Description:
Some devices have internal clocks. This parameter sets the
resulting sampling frequency. In many devices this
- parameter has an effect on input filters etc rather than
+ parameter has an effect on input filters etc. rather than
simply controlling when the input is sampled. As this
- effects datardy triggers, hardware buffers and the sysfs
+ effects data ready triggers, hardware buffers and the sysfs
direct access interfaces, it may be found in any of the
relevant directories. If it effects all of the above
then it is to be found in the base device directory.
KernelVersion: 2.6.35
Contact: linux-iio@vger.kernel.org
Description:
- Raw (unscaled no bias removal etc) voltage measurement from
+ Raw (unscaled no bias removal etc.) voltage measurement from
channel Y. In special cases where the channel does not
correspond to externally available input one of the named
versions may be used. The number must always be specified and
KernelVersion: 2.6.35
Contact: linux-iio@vger.kernel.org
Description:
- Raw (unscaled no bias removal etc) temperature measurement.
+ Raw (unscaled no bias removal etc.) temperature measurement.
If an axis is specified it generally means that the temperature
sensor is associated with one part of a compound device (e.g.
a gyroscope axis). Units after application of scale and offset
- are milli degrees Celsuis.
+ are milli degrees Celsius.
What: /sys/bus/iio/devices/iio:deviceX/in_tempX_input
KernelVersion: 2.6.38
Contact: linux-iio@vger.kernel.org
Description:
Angular velocity about axis x, y or z (may be arbitrarily
- assigned) Data converted by application of offset then scale to
- radians per second. Has all the equivalent parameters as
- per voltageY. Units after application of scale and offset are
- radians per second.
+ assigned). Has all the equivalent parameters as per voltageY.
+ Units after application of scale and offset are radians per
+ second.
What: /sys/bus/iio/devices/iio:deviceX/in_incli_x_raw
What: /sys/bus/iio/devices/iio:deviceX/in_incli_y_raw
Description:
Inclination raw reading about axis x, y or z (may be
arbitrarily assigned). Data converted by application of offset
- and scale to Degrees.
+ and scale to degrees.
What: /sys/bus/iio/devices/iio:deviceX/in_magn_x_raw
What: /sys/bus/iio/devices/iio:deviceX/in_magn_y_raw
Description:
If known for a device, offset to be added to <type>[Y]_raw prior
to scaling by <type>[Y]_scale in order to obtain value in the
- <type> units as specified in <type>[y]_raw documentation.
+ <type> units as specified in <type>[Y]_raw documentation.
Not present if the offset is always 0 or unknown. If Y or
axis <x|y|z> is not present, then the offset applies to all
in channels of <type>.
KernelVersion: 2.6.35
Contact: linux-iio@vger.kernel.org
Description:
- Hardware applied calibration offset. (assumed to fix production
+ Hardware applied calibration offset (assumed to fix production
inaccuracies).
What /sys/bus/iio/devices/iio:deviceX/in_voltageY_calibscale
KernelVersion: 2.6.35
Contact: linux-iio@vger.kernel.org
Description:
- Hardware applied calibration scale factor. (assumed to fix
+ Hardware applied calibration scale factor (assumed to fix
production inaccuracies). If shared across all channels,
<type>_calibscale is used.
KernelVersion: 2.635
Contact: linux-iio@vger.kernel.org
Description:
- If a discrete set of scale values are available, they
+ If a discrete set of scale values is available, they
are listed in this attribute.
What /sys/bus/iio/devices/iio:deviceX/out_voltageY_hardwaregain
Description:
Specifies the output powerdown mode.
DAC output stage is disconnected from the amplifier and
- 1kohm_to_gnd: connected to ground via an 1kOhm resistor
- 100kohm_to_gnd: connected to ground via an 100kOhm resistor
- three_state: left floating
+ 1kohm_to_gnd: connected to ground via an 1kOhm resistor,
+ 6kohm_to_gnd: connected to ground via a 6kOhm resistor,
+ 20kohm_to_gnd: connected to ground via a 20kOhm resistor,
+ 100kohm_to_gnd: connected to ground via an 100kOhm resistor,
+ three_state: left floating.
For a list of available output power down options read
outX_powerdown_mode_available. If Y is not present the
mode is shared across all outputs.
Contact: linux-iio@vger.kernel.org
Description:
Writing 1 causes output Y to enter the power down mode specified
- by the corresponding outY_powerdown_mode. Clearing returns to
- normal operation. Y may be suppressed if all outputs are
- controlled together.
+ by the corresponding outY_powerdown_mode. DAC output stage is
+ disconnected from the amplifier. Clearing returns to normal
+ operation. Y may be suppressed if all outputs are controlled
+ together.
What: /sys/bus/iio/devices/iio:deviceX/out_altvoltageY_frequency
KernelVersion: 3.4.0
different values, but the device can only enable both thresholds
or neither.
Note the driver will assume the last p events requested are
- to be enabled where p is however many it supports (which may
- vary depending on the exact set requested. So if you want to be
+ to be enabled where p is how many it supports (which may vary
+ depending on the exact set requested. So if you want to be
sure you have set what you think you have, check the contents of
these attributes after everything is configured. Drivers may
have to buffer any parameters so that they are consistent when
- a given event type is enabled a future point (and not those for
+ a given event type is enabled at a future point (and not those for
whatever event was previously enabled).
What: /sys/.../iio:deviceX/events/in_accel_x_roc_rising_en
What: /sys/.../buffer/scan_elements/in_magn_type
What: /sys/.../buffer/scan_elements/in_incli_type
What: /sys/.../buffer/scan_elements/in_voltageY_type
-What: /sys/.../buffer/scan_elements/in_voltage-in_type
+What: /sys/.../buffer/scan_elements/in_voltage_type
What: /sys/.../buffer/scan_elements/in_voltageY_supply_type
What: /sys/.../buffer/scan_elements/in_timestamp_type
KernelVersion: 2.6.37
the buffer output value appropriately. The storagebits value
also specifies the data alignment. So s48/64>>2 will be a
signed 48 bit integer stored in a 64 bit location aligned to
- a a64 bit boundary. To obtain the clean value, shift right 2
+ a 64 bit boundary. To obtain the clean value, shift right 2
and apply a mask to zero the top 16 bits of the result.
For other storage combinations this attribute will be extended
appropriately.
--- /dev/null
+What: /sys/bus/iio/devices/iio:deviceX/pll2_feedback_clk_present
+What: /sys/bus/iio/devices/iio:deviceX/pll2_reference_clk_present
+What: /sys/bus/iio/devices/iio:deviceX/pll1_reference_clk_a_present
+What: /sys/bus/iio/devices/iio:deviceX/pll1_reference_clk_b_present
+What: /sys/bus/iio/devices/iio:deviceX/pll1_reference_clk_test_present
+What: /sys/bus/iio/devices/iio:deviceX/vcxo_clk_present
+KernelVersion: 3.4.0
+Contact: linux-iio@vger.kernel.org
+Description:
+ Reading returns either '1' or '0'.
+ '1' means that the clock in question is present.
+ '0' means that the clock is missing.
+
+What: /sys/bus/iio/devices/iio:deviceX/pllY_locked
+KernelVersion: 3.4.0
+Contact: linux-iio@vger.kernel.org
+Description:
+ Reading returns either '1' or '0'. '1' means that the
+ pllY is locked.
+
+What: /sys/bus/iio/devices/iio:deviceX/store_eeprom
+KernelVersion: 3.4.0
+Contact: linux-iio@vger.kernel.org
+Description:
+ Writing '1' stores the current device configuration into
+ on-chip EEPROM. After power-up or chip reset the device will
+ automatically load the saved configuration.
+
+What: /sys/bus/iio/devices/iio:deviceX/sync_dividers
+KernelVersion: 3.4.0
+Contact: linux-iio@vger.kernel.org
+Description:
+ Writing '1' triggers the clock distribution synchronization
+ functionality. All dividers are reset and the channels start
+ with their predefined phase offsets (out_altvoltageY_phase).
+ Writing this file has the effect as driving the external
+ /SYNC pin low.
--- /dev/null
+What: /sys/bus/iio/devices/iio:deviceX/out_altvoltageY_frequency_resolution
+KernelVersion: 3.4.0
+Contact: linux-iio@vger.kernel.org
+Description:
+ Stores channel Y frequency resolution/channel spacing in Hz.
+ The value given directly influences the MODULUS used by
+ the fractional-N PLL. It is assumed that the algorithm
+ that is used to compute the various dividers, is able to
+ generate proper values for multiples of channel spacing.
+
+What: /sys/bus/iio/devices/iio:deviceX/out_altvoltageY_refin_frequency
+KernelVersion: 3.4.0
+Contact: linux-iio@vger.kernel.org
+Description:
+ Sets channel Y REFin frequency in Hz. In some clock chained
+ applications, the reference frequency used by the PLL may
+ change during runtime. This attribute allows the user to
+ adjust the reference frequency accordingly.
+ The value written has no effect until out_altvoltageY_frequency
+ is updated. Consider to use out_altvoltageY_powerdown to power
+ down the PLL and it's RFOut buffers during REFin changes.
--- /dev/null
+What: /sys/.../events/in_illuminance0_thresh_either_en
+Date: April 2012
+KernelVersion: 3.5
+Contact: Johan Hovold <jhovold@gmail.com>
+Description:
+ Event generated when channel passes one of the four thresholds
+ in each direction (rising|falling) and a zone change occurs.
+ The corresponding light zone can be read from
+ in_illuminance0_zone.
+
+What: /sys/.../events/in_illuminance0_threshY_hysteresis
+Date: May 2012
+KernelVersion: 3.5
+Contact: Johan Hovold <jhovold@gmail.com>
+Description:
+ Get the hysteresis for thresholds Y, that is,
+ threshY_hysteresis = threshY_raising - threshY_falling
+
+What: /sys/.../events/illuminance_threshY_falling_value
+What: /sys/.../events/illuminance_threshY_raising_value
+Date: April 2012
+KernelVersion: 3.5
+Contact: Johan Hovold <jhovold@gmail.com>
+Description:
+ Specifies the value of threshold that the device is comparing
+ against for the events enabled by
+ in_illuminance0_thresh_either_en (0..255), where Y in 0..3.
+
+ Note that threshY_falling must be less than or equal to
+ threshY_raising.
+
+ These thresholds correspond to the eight zone-boundary
+ registers (boundaryY_{low,high}) and define the five light
+ zones.
+
+What: /sys/bus/iio/devices/iio:deviceX/in_illuminance0_zone
+Date: April 2012
+KernelVersion: 3.5
+Contact: Johan Hovold <jhovold@gmail.com>
+Description:
+ Get the current light zone (0..4) as defined by the
+ in_illuminance0_threshY_{falling,rising} thresholds.
+
+What: /sys/bus/iio/devices/iio:deviceX/out_currentY_raw
+Date: May 2012
+KernelVersion: 3.5
+Contact: Johan Hovold <jhovold@gmail.com>
+Description:
+ Get output current for channel Y (0..255), that is,
+ out_currentY_currentZ_raw, where Z is the current zone.
+
+What: /sys/bus/iio/devices/iio:deviceX/out_currentY_currentZ_raw
+Date: May 2012
+KernelVersion: 3.5
+Contact: Johan Hovold <jhovold@gmail.com>
+Description:
+ Set the output current for channel out_currentY when in zone
+ Z (0..255), where Y in 0..2 and Z in 0..4.
+
+ These values correspond to the ALS-mapper target registers for
+ ALS-mapper Y + 1.
Setting the ramoops parameters can be done in 2 different manners:
1. Use the module parameters (which have the names of the variables described
as before).
+ For quick debugging, you can also reserve parts of memory during boot
+ and then use the reserved memory for ramoops. For example, assuming a machine
+ with > 128 MB of memory, the following kernel command line will tell the
+ kernel to use only the first 128 MB of memory, and place ECC-protected ramoops
+ region at 128 MB boundary:
+ "mem=128M ramoops.mem_address=0x8000000 ramoops.ecc=1"
2. Use a platform device and set the platform data. The parameters can then
be set through that platform data. An example of doing that is:
return ret;
}
+You can specify either RAM memory or peripheral devices' memory. However, when
+specifying RAM, be sure to reserve the memory by issuing memblock_reserve()
+very early in the architecture code, e.g.:
+
+#include <linux/memblock.h>
+
+memblock_reserve(ramoops_data.mem_address, ramoops_data.mem_size);
+
3. Dump format
The data dump begins with a header, currently defined as "====" followed by a
no buffer events so it is up to userspace to work out how
often to read from the buffer.
+config IIO_TRIGGERED_BUFFER
+ tristate
+ select IIO_TRIGGER
+ select IIO_KFIFO_BUF
+ help
+ Provides helper functions for setting up triggered buffers.
+
endif # IIO_BUFFER
config IIO_TRIGGER
source "drivers/iio/adc/Kconfig"
source "drivers/iio/amplifiers/Kconfig"
+source "drivers/iio/light/Kconfig"
+source "drivers/iio/frequency/Kconfig"
+source "drivers/iio/dac/Kconfig"
endif # IIO
industrialio-$(CONFIG_IIO_BUFFER) += industrialio-buffer.o
industrialio-$(CONFIG_IIO_TRIGGER) += industrialio-trigger.o
+obj-$(CONFIG_IIO_TRIGGERED_BUFFER) += industrialio-triggered-buffer.o
obj-$(CONFIG_IIO_KFIFO_BUF) += kfifo_buf.o
obj-y += adc/
obj-y += amplifiers/
+obj-y += light/
+obj-y += frequency/
+obj-y += dac/
tristate "Atmel AT91 ADC"
depends on ARCH_AT91
select IIO_BUFFER
- select IIO_KFIFO_BUF
- select IIO_TRIGGER
+ select IIO_TRIGGERED_BUFFER
select SYSFS
help
Say yes here to build support for Atmel AT91 ADC.
#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
-#include <linux/iio/kfifo_buf.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
#include <mach/at91_adc.h>
}
}
-static const struct iio_buffer_setup_ops at91_adc_buffer_ops = {
- .preenable = &iio_sw_buffer_preenable,
- .postenable = &iio_triggered_buffer_postenable,
- .predisable = &iio_triggered_buffer_predisable,
-};
-
static int at91_adc_buffer_init(struct iio_dev *idev)
{
- int ret;
-
- idev->buffer = iio_kfifo_allocate(idev);
- if (!idev->buffer) {
- ret = -ENOMEM;
- goto error_ret;
- }
-
- idev->pollfunc = iio_alloc_pollfunc(&iio_pollfunc_store_time,
- &at91_adc_trigger_handler,
- IRQF_ONESHOT,
- idev,
- "%s-consumer%d",
- idev->name,
- idev->id);
- if (idev->pollfunc == NULL) {
- ret = -ENOMEM;
- goto error_pollfunc;
- }
-
- idev->setup_ops = &at91_adc_buffer_ops;
- idev->modes |= INDIO_BUFFER_TRIGGERED;
-
- ret = iio_buffer_register(idev,
- idev->channels,
- idev->num_channels);
- if (ret)
- goto error_register;
-
- return 0;
-
-error_register:
- iio_dealloc_pollfunc(idev->pollfunc);
-error_pollfunc:
- iio_kfifo_free(idev->buffer);
-error_ret:
- return ret;
+ return iio_triggered_buffer_setup(idev, &iio_pollfunc_store_time,
+ &at91_adc_trigger_handler, NULL);
}
static void at91_adc_buffer_remove(struct iio_dev *idev)
{
- iio_buffer_unregister(idev);
- iio_dealloc_pollfunc(idev->pollfunc);
- iio_kfifo_free(idev->buffer);
+ iio_triggered_buffer_cleanup(idev);
}
static int at91_adc_read_raw(struct iio_dev *idev,
st->done,
msecs_to_jiffies(1000));
if (ret == 0)
- return -ETIMEDOUT;
- else if (ret < 0)
+ ret = -ETIMEDOUT;
+ if (ret < 0) {
+ mutex_unlock(&st->lock);
return ret;
+ }
*val = st->last_value;
--- /dev/null
+#
+# DAC drivers
+#
+menu "Digital to analog converters"
+
+config AD5064
+ tristate "Analog Devices AD5064/64-1/65/44/45/24/25, AD5628/48/66/68 DAC driver"
+ depends on SPI
+ help
+ Say yes here to build support for Analog Devices AD5024, AD5025, AD5044,
+ AD5045, AD5064, AD5064-1, AD5065, AD5628, AD5648, AD5666, AD5668 Digital
+ to Analog Converter.
+
+ To compile this driver as a module, choose M here: the
+ module will be called ad5064.
+
+config AD5360
+ tristate "Analog Devices Analog Devices AD5360/61/62/63/70/71/73 DAC driver"
+ depends on SPI
+ help
+ Say yes here to build support for Analog Devices AD5360, AD5361,
+ AD5362, AD5363, AD5370, AD5371, AD5373 multi-channel
+ Digital to Analog Converters (DAC).
+
+ To compile this driver as module choose M here: the module will be called
+ ad5360.
+
+config AD5380
+ tristate "Analog Devices AD5380/81/82/83/84/90/91/92 DAC driver"
+ depends on (SPI_MASTER || I2C)
+ select REGMAP_I2C if I2C
+ select REGMAP_SPI if SPI_MASTER
+ help
+ Say yes here to build support for Analog Devices AD5380, AD5381,
+ AD5382, AD5383, AD5384, AD5390, AD5391, AD5392 multi-channel
+ Digital to Analog Converters (DAC).
+
+ To compile this driver as module choose M here: the module will be called
+ ad5380.
+
+config AD5421
+ tristate "Analog Devices AD5421 DAC driver"
+ depends on SPI
+ help
+ Say yes here to build support for Analog Devices AD5421 loop-powered
+ digital-to-analog convertors (DAC).
+
+ To compile this driver as module choose M here: the module will be called
+ ad5421.
+
+config AD5624R_SPI
+ tristate "Analog Devices AD5624/44/64R DAC spi driver"
+ depends on SPI
+ help
+ Say yes here to build support for Analog Devices AD5624R, AD5644R and
+ AD5664R converters (DAC). This driver uses the common SPI interface.
+
+config AD5446
+ tristate "Analog Devices AD5446 and similar single channel DACs driver"
+ depends on SPI
+ help
+ Say yes here to build support for Analog Devices AD5444, AD5446, AD5450,
+ AD5451, AD5452, AD5453, AD5512A, AD5541A, AD5542A, AD5543, AD5553, AD5601,
+ AD5611, AD5620, AD5621, AD5640, AD5660, AD5662 DACs.
+
+ To compile this driver as a module, choose M here: the
+ module will be called ad5446.
+
+config AD5504
+ tristate "Analog Devices AD5504/AD5501 DAC SPI driver"
+ depends on SPI
+ help
+ Say yes here to build support for Analog Devices AD5504, AD5501,
+ High Voltage Digital to Analog Converter.
+
+ To compile this driver as a module, choose M here: the
+ module will be called ad5504.
+
+config AD5764
+ tristate "Analog Devices AD5764/64R/44/44R DAC driver"
+ depends on SPI_MASTER
+ help
+ Say yes here to build support for Analog Devices AD5764, AD5764R, AD5744,
+ AD5744R Digital to Analog Converter.
+
+ To compile this driver as a module, choose M here: the
+ module will be called ad5764.
+
+config AD5791
+ tristate "Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC SPI driver"
+ depends on SPI
+ help
+ Say yes here to build support for Analog Devices AD5760, AD5780,
+ AD5781, AD5790, AD5791 High Resolution Voltage Output Digital to
+ Analog Converter.
+
+ To compile this driver as a module, choose M here: the
+ module will be called ad5791.
+
+config AD5686
+ tristate "Analog Devices AD5686R/AD5685R/AD5684R DAC SPI driver"
+ depends on SPI
+ help
+ Say yes here to build support for Analog Devices AD5686R, AD5685R,
+ AD5684R, AD5791 Voltage Output Digital to
+ Analog Converter.
+
+ To compile this driver as a module, choose M here: the
+ module will be called ad5686.
+
+config MAX517
+ tristate "Maxim MAX517/518/519 DAC driver"
+ depends on I2C && EXPERIMENTAL
+ help
+ If you say yes here you get support for the Maxim chips MAX517,
+ MAX518 and MAX519 (I2C 8-Bit DACs with rail-to-rail outputs).
+
+ This driver can also be built as a module. If so, the module
+ will be called max517.
+
+config MCP4725
+ tristate "MCP4725 DAC driver"
+ depends on I2C
+ ---help---
+ Say Y here if you want to build a driver for the Microchip
+ MCP 4725 12-bit digital-to-analog converter (DAC) with I2C
+ interface.
+
+ To compile this driver as a module, choose M here: the module
+ will be called mcp4725.
+
+endmenu
--- /dev/null
+#
+# Makefile for industrial I/O DAC drivers
+#
+
+obj-$(CONFIG_AD5360) += ad5360.o
+obj-$(CONFIG_AD5380) += ad5380.o
+obj-$(CONFIG_AD5421) += ad5421.o
+obj-$(CONFIG_AD5624R_SPI) += ad5624r_spi.o
+obj-$(CONFIG_AD5064) += ad5064.o
+obj-$(CONFIG_AD5504) += ad5504.o
+obj-$(CONFIG_AD5446) += ad5446.o
+obj-$(CONFIG_AD5764) += ad5764.o
+obj-$(CONFIG_AD5791) += ad5791.o
+obj-$(CONFIG_AD5686) += ad5686.o
+obj-$(CONFIG_MAX517) += max517.o
+obj-$(CONFIG_MCP4725) += mcp4725.o
--- /dev/null
+/*
+ * AD5024, AD5025, AD5044, AD5045, AD5064, AD5064-1, AD5065, AD5628, AD5648,
+ * AD5666, AD5668 Digital to analog converters driver
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/regulator/consumer.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define AD5064_MAX_DAC_CHANNELS 8
+#define AD5064_MAX_VREFS 4
+
+#define AD5064_ADDR(x) ((x) << 20)
+#define AD5064_CMD(x) ((x) << 24)
+
+#define AD5064_ADDR_DAC(chan) (chan)
+#define AD5064_ADDR_ALL_DAC 0xF
+
+#define AD5064_CMD_WRITE_INPUT_N 0x0
+#define AD5064_CMD_UPDATE_DAC_N 0x1
+#define AD5064_CMD_WRITE_INPUT_N_UPDATE_ALL 0x2
+#define AD5064_CMD_WRITE_INPUT_N_UPDATE_N 0x3
+#define AD5064_CMD_POWERDOWN_DAC 0x4
+#define AD5064_CMD_CLEAR 0x5
+#define AD5064_CMD_LDAC_MASK 0x6
+#define AD5064_CMD_RESET 0x7
+#define AD5064_CMD_CONFIG 0x8
+
+#define AD5064_CONFIG_DAISY_CHAIN_ENABLE BIT(1)
+#define AD5064_CONFIG_INT_VREF_ENABLE BIT(0)
+
+#define AD5064_LDAC_PWRDN_NONE 0x0
+#define AD5064_LDAC_PWRDN_1K 0x1
+#define AD5064_LDAC_PWRDN_100K 0x2
+#define AD5064_LDAC_PWRDN_3STATE 0x3
+
+/**
+ * struct ad5064_chip_info - chip specific information
+ * @shared_vref: whether the vref supply is shared between channels
+ * @internal_vref: internal reference voltage. 0 if the chip has no internal
+ * vref.
+ * @channel: channel specification
+ * @num_channels: number of channels
+ */
+
+struct ad5064_chip_info {
+ bool shared_vref;
+ unsigned long internal_vref;
+ const struct iio_chan_spec *channels;
+ unsigned int num_channels;
+};
+
+/**
+ * struct ad5064_state - driver instance specific data
+ * @spi: spi_device
+ * @chip_info: chip model specific constants, available modes etc
+ * @vref_reg: vref supply regulators
+ * @pwr_down: whether channel is powered down
+ * @pwr_down_mode: channel's current power down mode
+ * @dac_cache: current DAC raw value (chip does not support readback)
+ * @use_internal_vref: set to true if the internal reference voltage should be
+ * used.
+ * @data: spi transfer buffers
+ */
+
+struct ad5064_state {
+ struct spi_device *spi;
+ const struct ad5064_chip_info *chip_info;
+ struct regulator_bulk_data vref_reg[AD5064_MAX_VREFS];
+ bool pwr_down[AD5064_MAX_DAC_CHANNELS];
+ u8 pwr_down_mode[AD5064_MAX_DAC_CHANNELS];
+ unsigned int dac_cache[AD5064_MAX_DAC_CHANNELS];
+ bool use_internal_vref;
+
+ /*
+ * DMA (thus cache coherency maintenance) requires the
+ * transfer buffers to live in their own cache lines.
+ */
+ __be32 data ____cacheline_aligned;
+};
+
+enum ad5064_type {
+ ID_AD5024,
+ ID_AD5025,
+ ID_AD5044,
+ ID_AD5045,
+ ID_AD5064,
+ ID_AD5064_1,
+ ID_AD5065,
+ ID_AD5628_1,
+ ID_AD5628_2,
+ ID_AD5648_1,
+ ID_AD5648_2,
+ ID_AD5666_1,
+ ID_AD5666_2,
+ ID_AD5668_1,
+ ID_AD5668_2,
+};
+
+static int ad5064_spi_write(struct ad5064_state *st, unsigned int cmd,
+ unsigned int addr, unsigned int val, unsigned int shift)
+{
+ val <<= shift;
+
+ st->data = cpu_to_be32(AD5064_CMD(cmd) | AD5064_ADDR(addr) | val);
+
+ return spi_write(st->spi, &st->data, sizeof(st->data));
+}
+
+static int ad5064_sync_powerdown_mode(struct ad5064_state *st,
+ unsigned int channel)
+{
+ unsigned int val;
+ int ret;
+
+ val = (0x1 << channel);
+
+ if (st->pwr_down[channel])
+ val |= st->pwr_down_mode[channel] << 8;
+
+ ret = ad5064_spi_write(st, AD5064_CMD_POWERDOWN_DAC, 0, val, 0);
+
+ return ret;
+}
+
+static const char * const ad5064_powerdown_modes[] = {
+ "1kohm_to_gnd",
+ "100kohm_to_gnd",
+ "three_state",
+};
+
+static int ad5064_get_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan)
+{
+ struct ad5064_state *st = iio_priv(indio_dev);
+
+ return st->pwr_down_mode[chan->channel] - 1;
+}
+
+static int ad5064_set_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan, unsigned int mode)
+{
+ struct ad5064_state *st = iio_priv(indio_dev);
+ int ret;
+
+ mutex_lock(&indio_dev->mlock);
+ st->pwr_down_mode[chan->channel] = mode + 1;
+
+ ret = ad5064_sync_powerdown_mode(st, chan->channel);
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static const struct iio_enum ad5064_powerdown_mode_enum = {
+ .items = ad5064_powerdown_modes,
+ .num_items = ARRAY_SIZE(ad5064_powerdown_modes),
+ .get = ad5064_get_powerdown_mode,
+ .set = ad5064_set_powerdown_mode,
+};
+
+static ssize_t ad5064_read_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, char *buf)
+{
+ struct ad5064_state *st = iio_priv(indio_dev);
+
+ return sprintf(buf, "%d\n", st->pwr_down[chan->channel]);
+}
+
+static ssize_t ad5064_write_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
+ size_t len)
+{
+ struct ad5064_state *st = iio_priv(indio_dev);
+ bool pwr_down;
+ int ret;
+
+ ret = strtobool(buf, &pwr_down);
+ if (ret)
+ return ret;
+
+ mutex_lock(&indio_dev->mlock);
+ st->pwr_down[chan->channel] = pwr_down;
+
+ ret = ad5064_sync_powerdown_mode(st, chan->channel);
+ mutex_unlock(&indio_dev->mlock);
+ return ret ? ret : len;
+}
+
+static int ad5064_get_vref(struct ad5064_state *st,
+ struct iio_chan_spec const *chan)
+{
+ unsigned int i;
+
+ if (st->use_internal_vref)
+ return st->chip_info->internal_vref;
+
+ i = st->chip_info->shared_vref ? 0 : chan->channel;
+ return regulator_get_voltage(st->vref_reg[i].consumer);
+}
+
+static int ad5064_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val,
+ int *val2,
+ long m)
+{
+ struct ad5064_state *st = iio_priv(indio_dev);
+ int scale_uv;
+
+ switch (m) {
+ case IIO_CHAN_INFO_RAW:
+ *val = st->dac_cache[chan->channel];
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_SCALE:
+ scale_uv = ad5064_get_vref(st, chan);
+ if (scale_uv < 0)
+ return scale_uv;
+
+ scale_uv = (scale_uv * 100) >> chan->scan_type.realbits;
+ *val = scale_uv / 100000;
+ *val2 = (scale_uv % 100000) * 10;
+ return IIO_VAL_INT_PLUS_MICRO;
+ default:
+ break;
+ }
+ return -EINVAL;
+}
+
+static int ad5064_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan, int val, int val2, long mask)
+{
+ struct ad5064_state *st = iio_priv(indio_dev);
+ int ret;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ if (val > (1 << chan->scan_type.realbits) || val < 0)
+ return -EINVAL;
+
+ mutex_lock(&indio_dev->mlock);
+ ret = ad5064_spi_write(st, AD5064_CMD_WRITE_INPUT_N_UPDATE_N,
+ chan->address, val, chan->scan_type.shift);
+ if (ret == 0)
+ st->dac_cache[chan->channel] = val;
+ mutex_unlock(&indio_dev->mlock);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+
+ return ret;
+}
+
+static const struct iio_info ad5064_info = {
+ .read_raw = ad5064_read_raw,
+ .write_raw = ad5064_write_raw,
+ .driver_module = THIS_MODULE,
+};
+
+static const struct iio_chan_spec_ext_info ad5064_ext_info[] = {
+ {
+ .name = "powerdown",
+ .read = ad5064_read_dac_powerdown,
+ .write = ad5064_write_dac_powerdown,
+ },
+ IIO_ENUM("powerdown_mode", false, &ad5064_powerdown_mode_enum),
+ IIO_ENUM_AVAILABLE("powerdown_mode", &ad5064_powerdown_mode_enum),
+ { },
+};
+
+#define AD5064_CHANNEL(chan, bits) { \
+ .type = IIO_VOLTAGE, \
+ .indexed = 1, \
+ .output = 1, \
+ .channel = (chan), \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+ IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \
+ .address = AD5064_ADDR_DAC(chan), \
+ .scan_type = IIO_ST('u', (bits), 16, 20 - (bits)), \
+ .ext_info = ad5064_ext_info, \
+}
+
+#define DECLARE_AD5064_CHANNELS(name, bits) \
+const struct iio_chan_spec name[] = { \
+ AD5064_CHANNEL(0, bits), \
+ AD5064_CHANNEL(1, bits), \
+ AD5064_CHANNEL(2, bits), \
+ AD5064_CHANNEL(3, bits), \
+ AD5064_CHANNEL(4, bits), \
+ AD5064_CHANNEL(5, bits), \
+ AD5064_CHANNEL(6, bits), \
+ AD5064_CHANNEL(7, bits), \
+}
+
+static DECLARE_AD5064_CHANNELS(ad5024_channels, 12);
+static DECLARE_AD5064_CHANNELS(ad5044_channels, 14);
+static DECLARE_AD5064_CHANNELS(ad5064_channels, 16);
+
+static const struct ad5064_chip_info ad5064_chip_info_tbl[] = {
+ [ID_AD5024] = {
+ .shared_vref = false,
+ .channels = ad5024_channels,
+ .num_channels = 4,
+ },
+ [ID_AD5025] = {
+ .shared_vref = false,
+ .channels = ad5024_channels,
+ .num_channels = 2,
+ },
+ [ID_AD5044] = {
+ .shared_vref = false,
+ .channels = ad5044_channels,
+ .num_channels = 4,
+ },
+ [ID_AD5045] = {
+ .shared_vref = false,
+ .channels = ad5044_channels,
+ .num_channels = 2,
+ },
+ [ID_AD5064] = {
+ .shared_vref = false,
+ .channels = ad5064_channels,
+ .num_channels = 4,
+ },
+ [ID_AD5064_1] = {
+ .shared_vref = true,
+ .channels = ad5064_channels,
+ .num_channels = 4,
+ },
+ [ID_AD5065] = {
+ .shared_vref = false,
+ .channels = ad5064_channels,
+ .num_channels = 2,
+ },
+ [ID_AD5628_1] = {
+ .shared_vref = true,
+ .internal_vref = 2500000,
+ .channels = ad5024_channels,
+ .num_channels = 8,
+ },
+ [ID_AD5628_2] = {
+ .shared_vref = true,
+ .internal_vref = 5000000,
+ .channels = ad5024_channels,
+ .num_channels = 8,
+ },
+ [ID_AD5648_1] = {
+ .shared_vref = true,
+ .internal_vref = 2500000,
+ .channels = ad5044_channels,
+ .num_channels = 8,
+ },
+ [ID_AD5648_2] = {
+ .shared_vref = true,
+ .internal_vref = 5000000,
+ .channels = ad5044_channels,
+ .num_channels = 8,
+ },
+ [ID_AD5666_1] = {
+ .shared_vref = true,
+ .internal_vref = 2500000,
+ .channels = ad5064_channels,
+ .num_channels = 4,
+ },
+ [ID_AD5666_2] = {
+ .shared_vref = true,
+ .internal_vref = 5000000,
+ .channels = ad5064_channels,
+ .num_channels = 4,
+ },
+ [ID_AD5668_1] = {
+ .shared_vref = true,
+ .internal_vref = 2500000,
+ .channels = ad5064_channels,
+ .num_channels = 8,
+ },
+ [ID_AD5668_2] = {
+ .shared_vref = true,
+ .internal_vref = 5000000,
+ .channels = ad5064_channels,
+ .num_channels = 8,
+ },
+};
+
+static inline unsigned int ad5064_num_vref(struct ad5064_state *st)
+{
+ return st->chip_info->shared_vref ? 1 : st->chip_info->num_channels;
+}
+
+static const char * const ad5064_vref_names[] = {
+ "vrefA",
+ "vrefB",
+ "vrefC",
+ "vrefD",
+};
+
+static const char * const ad5064_vref_name(struct ad5064_state *st,
+ unsigned int vref)
+{
+ return st->chip_info->shared_vref ? "vref" : ad5064_vref_names[vref];
+}
+
+static int __devinit ad5064_probe(struct spi_device *spi)
+{
+ enum ad5064_type type = spi_get_device_id(spi)->driver_data;
+ struct iio_dev *indio_dev;
+ struct ad5064_state *st;
+ unsigned int i;
+ int ret;
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL)
+ return -ENOMEM;
+
+ st = iio_priv(indio_dev);
+ spi_set_drvdata(spi, indio_dev);
+
+ st->chip_info = &ad5064_chip_info_tbl[type];
+ st->spi = spi;
+
+ for (i = 0; i < ad5064_num_vref(st); ++i)
+ st->vref_reg[i].supply = ad5064_vref_name(st, i);
+
+ ret = regulator_bulk_get(&st->spi->dev, ad5064_num_vref(st),
+ st->vref_reg);
+ if (ret) {
+ if (!st->chip_info->internal_vref)
+ goto error_free;
+ st->use_internal_vref = true;
+ ret = ad5064_spi_write(st, AD5064_CMD_CONFIG, 0,
+ AD5064_CONFIG_INT_VREF_ENABLE, 0);
+ if (ret) {
+ dev_err(&spi->dev, "Failed to enable internal vref: %d\n",
+ ret);
+ goto error_free;
+ }
+ } else {
+ ret = regulator_bulk_enable(ad5064_num_vref(st), st->vref_reg);
+ if (ret)
+ goto error_free_reg;
+ }
+
+ for (i = 0; i < st->chip_info->num_channels; ++i) {
+ st->pwr_down_mode[i] = AD5064_LDAC_PWRDN_1K;
+ st->dac_cache[i] = 0x8000;
+ }
+
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->name = spi_get_device_id(spi)->name;
+ indio_dev->info = &ad5064_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->channels = st->chip_info->channels;
+ indio_dev->num_channels = st->chip_info->num_channels;
+
+ ret = iio_device_register(indio_dev);
+ if (ret)
+ goto error_disable_reg;
+
+ return 0;
+
+error_disable_reg:
+ if (!st->use_internal_vref)
+ regulator_bulk_disable(ad5064_num_vref(st), st->vref_reg);
+error_free_reg:
+ if (!st->use_internal_vref)
+ regulator_bulk_free(ad5064_num_vref(st), st->vref_reg);
+error_free:
+ iio_device_free(indio_dev);
+
+ return ret;
+}
+
+
+static int __devexit ad5064_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+ struct ad5064_state *st = iio_priv(indio_dev);
+
+ iio_device_unregister(indio_dev);
+
+ if (!st->use_internal_vref) {
+ regulator_bulk_disable(ad5064_num_vref(st), st->vref_reg);
+ regulator_bulk_free(ad5064_num_vref(st), st->vref_reg);
+ }
+
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct spi_device_id ad5064_id[] = {
+ {"ad5024", ID_AD5024},
+ {"ad5025", ID_AD5025},
+ {"ad5044", ID_AD5044},
+ {"ad5045", ID_AD5045},
+ {"ad5064", ID_AD5064},
+ {"ad5064-1", ID_AD5064_1},
+ {"ad5065", ID_AD5065},
+ {"ad5628-1", ID_AD5628_1},
+ {"ad5628-2", ID_AD5628_2},
+ {"ad5648-1", ID_AD5648_1},
+ {"ad5648-2", ID_AD5648_2},
+ {"ad5666-1", ID_AD5666_1},
+ {"ad5666-2", ID_AD5666_2},
+ {"ad5668-1", ID_AD5668_1},
+ {"ad5668-2", ID_AD5668_2},
+ {"ad5668-3", ID_AD5668_2}, /* similar enough to ad5668-2 */
+ {}
+};
+MODULE_DEVICE_TABLE(spi, ad5064_id);
+
+static struct spi_driver ad5064_driver = {
+ .driver = {
+ .name = "ad5064",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5064_probe,
+ .remove = __devexit_p(ad5064_remove),
+ .id_table = ad5064_id,
+};
+module_spi_driver(ad5064_driver);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("Analog Devices AD5024/25/44/45/64/64-1/65, AD5628/48/66/68 DAC");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/*
+ * Analog devices AD5360, AD5361, AD5362, AD5363, AD5370, AD5371, AD5373
+ * multi-channel Digital to Analog Converters driver
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/regulator/consumer.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define AD5360_CMD(x) ((x) << 22)
+#define AD5360_ADDR(x) ((x) << 16)
+
+#define AD5360_READBACK_TYPE(x) ((x) << 13)
+#define AD5360_READBACK_ADDR(x) ((x) << 7)
+
+#define AD5360_CHAN_ADDR(chan) ((chan) + 0x8)
+
+#define AD5360_CMD_WRITE_DATA 0x3
+#define AD5360_CMD_WRITE_OFFSET 0x2
+#define AD5360_CMD_WRITE_GAIN 0x1
+#define AD5360_CMD_SPECIAL_FUNCTION 0x0
+
+/* Special function register addresses */
+#define AD5360_REG_SF_NOP 0x0
+#define AD5360_REG_SF_CTRL 0x1
+#define AD5360_REG_SF_OFS(x) (0x2 + (x))
+#define AD5360_REG_SF_READBACK 0x5
+
+#define AD5360_SF_CTRL_PWR_DOWN BIT(0)
+
+#define AD5360_READBACK_X1A 0x0
+#define AD5360_READBACK_X1B 0x1
+#define AD5360_READBACK_OFFSET 0x2
+#define AD5360_READBACK_GAIN 0x3
+#define AD5360_READBACK_SF 0x4
+
+
+/**
+ * struct ad5360_chip_info - chip specific information
+ * @channel_template: channel specification template
+ * @num_channels: number of channels
+ * @channels_per_group: number of channels per group
+ * @num_vrefs: number of vref supplies for the chip
+*/
+
+struct ad5360_chip_info {
+ struct iio_chan_spec channel_template;
+ unsigned int num_channels;
+ unsigned int channels_per_group;
+ unsigned int num_vrefs;
+};
+
+/**
+ * struct ad5360_state - driver instance specific data
+ * @spi: spi_device
+ * @chip_info: chip model specific constants, available modes etc
+ * @vref_reg: vref supply regulators
+ * @ctrl: control register cache
+ * @data: spi transfer buffers
+ */
+
+struct ad5360_state {
+ struct spi_device *spi;
+ const struct ad5360_chip_info *chip_info;
+ struct regulator_bulk_data vref_reg[3];
+ unsigned int ctrl;
+
+ /*
+ * DMA (thus cache coherency maintenance) requires the
+ * transfer buffers to live in their own cache lines.
+ */
+ union {
+ __be32 d32;
+ u8 d8[4];
+ } data[2] ____cacheline_aligned;
+};
+
+enum ad5360_type {
+ ID_AD5360,
+ ID_AD5361,
+ ID_AD5362,
+ ID_AD5363,
+ ID_AD5370,
+ ID_AD5371,
+ ID_AD5372,
+ ID_AD5373,
+};
+
+#define AD5360_CHANNEL(bits) { \
+ .type = IIO_VOLTAGE, \
+ .indexed = 1, \
+ .output = 1, \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+ IIO_CHAN_INFO_SCALE_SEPARATE_BIT | \
+ IIO_CHAN_INFO_OFFSET_SEPARATE_BIT | \
+ IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT | \
+ IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, \
+ .scan_type = IIO_ST('u', (bits), 16, 16 - (bits)) \
+}
+
+static const struct ad5360_chip_info ad5360_chip_info_tbl[] = {
+ [ID_AD5360] = {
+ .channel_template = AD5360_CHANNEL(16),
+ .num_channels = 16,
+ .channels_per_group = 8,
+ .num_vrefs = 2,
+ },
+ [ID_AD5361] = {
+ .channel_template = AD5360_CHANNEL(14),
+ .num_channels = 16,
+ .channels_per_group = 8,
+ .num_vrefs = 2,
+ },
+ [ID_AD5362] = {
+ .channel_template = AD5360_CHANNEL(16),
+ .num_channels = 8,
+ .channels_per_group = 4,
+ .num_vrefs = 2,
+ },
+ [ID_AD5363] = {
+ .channel_template = AD5360_CHANNEL(14),
+ .num_channels = 8,
+ .channels_per_group = 4,
+ .num_vrefs = 2,
+ },
+ [ID_AD5370] = {
+ .channel_template = AD5360_CHANNEL(16),
+ .num_channels = 40,
+ .channels_per_group = 8,
+ .num_vrefs = 2,
+ },
+ [ID_AD5371] = {
+ .channel_template = AD5360_CHANNEL(14),
+ .num_channels = 40,
+ .channels_per_group = 8,
+ .num_vrefs = 3,
+ },
+ [ID_AD5372] = {
+ .channel_template = AD5360_CHANNEL(16),
+ .num_channels = 32,
+ .channels_per_group = 8,
+ .num_vrefs = 2,
+ },
+ [ID_AD5373] = {
+ .channel_template = AD5360_CHANNEL(14),
+ .num_channels = 32,
+ .channels_per_group = 8,
+ .num_vrefs = 2,
+ },
+};
+
+static unsigned int ad5360_get_channel_vref_index(struct ad5360_state *st,
+ unsigned int channel)
+{
+ unsigned int i;
+
+ /* The first groups have their own vref, while the remaining groups
+ * share the last vref */
+ i = channel / st->chip_info->channels_per_group;
+ if (i >= st->chip_info->num_vrefs)
+ i = st->chip_info->num_vrefs - 1;
+
+ return i;
+}
+
+static int ad5360_get_channel_vref(struct ad5360_state *st,
+ unsigned int channel)
+{
+ unsigned int i = ad5360_get_channel_vref_index(st, channel);
+
+ return regulator_get_voltage(st->vref_reg[i].consumer);
+}
+
+
+static int ad5360_write_unlocked(struct iio_dev *indio_dev,
+ unsigned int cmd, unsigned int addr, unsigned int val,
+ unsigned int shift)
+{
+ struct ad5360_state *st = iio_priv(indio_dev);
+
+ val <<= shift;
+ val |= AD5360_CMD(cmd) | AD5360_ADDR(addr);
+ st->data[0].d32 = cpu_to_be32(val);
+
+ return spi_write(st->spi, &st->data[0].d8[1], 3);
+}
+
+static int ad5360_write(struct iio_dev *indio_dev, unsigned int cmd,
+ unsigned int addr, unsigned int val, unsigned int shift)
+{
+ int ret;
+
+ mutex_lock(&indio_dev->mlock);
+ ret = ad5360_write_unlocked(indio_dev, cmd, addr, val, shift);
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static int ad5360_read(struct iio_dev *indio_dev, unsigned int type,
+ unsigned int addr)
+{
+ struct ad5360_state *st = iio_priv(indio_dev);
+ struct spi_message m;
+ int ret;
+ struct spi_transfer t[] = {
+ {
+ .tx_buf = &st->data[0].d8[1],
+ .len = 3,
+ .cs_change = 1,
+ }, {
+ .rx_buf = &st->data[1].d8[1],
+ .len = 3,
+ },
+ };
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t[0], &m);
+ spi_message_add_tail(&t[1], &m);
+
+ mutex_lock(&indio_dev->mlock);
+
+ st->data[0].d32 = cpu_to_be32(AD5360_CMD(AD5360_CMD_SPECIAL_FUNCTION) |
+ AD5360_ADDR(AD5360_REG_SF_READBACK) |
+ AD5360_READBACK_TYPE(type) |
+ AD5360_READBACK_ADDR(addr));
+
+ ret = spi_sync(st->spi, &m);
+ if (ret >= 0)
+ ret = be32_to_cpu(st->data[1].d32) & 0xffff;
+
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static ssize_t ad5360_read_dac_powerdown(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+ struct ad5360_state *st = iio_priv(indio_dev);
+
+ return sprintf(buf, "%d\n", (bool)(st->ctrl & AD5360_SF_CTRL_PWR_DOWN));
+}
+
+static int ad5360_update_ctrl(struct iio_dev *indio_dev, unsigned int set,
+ unsigned int clr)
+{
+ struct ad5360_state *st = iio_priv(indio_dev);
+ unsigned int ret;
+
+ mutex_lock(&indio_dev->mlock);
+
+ st->ctrl |= set;
+ st->ctrl &= ~clr;
+
+ ret = ad5360_write_unlocked(indio_dev, AD5360_CMD_SPECIAL_FUNCTION,
+ AD5360_REG_SF_CTRL, st->ctrl, 0);
+
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static ssize_t ad5360_write_dac_powerdown(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t len)
+{
+ struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+ bool pwr_down;
+ int ret;
+
+ ret = strtobool(buf, &pwr_down);
+ if (ret)
+ return ret;
+
+ if (pwr_down)
+ ret = ad5360_update_ctrl(indio_dev, AD5360_SF_CTRL_PWR_DOWN, 0);
+ else
+ ret = ad5360_update_ctrl(indio_dev, 0, AD5360_SF_CTRL_PWR_DOWN);
+
+ return ret ? ret : len;
+}
+
+static IIO_DEVICE_ATTR(out_voltage_powerdown,
+ S_IRUGO | S_IWUSR,
+ ad5360_read_dac_powerdown,
+ ad5360_write_dac_powerdown, 0);
+
+static struct attribute *ad5360_attributes[] = {
+ &iio_dev_attr_out_voltage_powerdown.dev_attr.attr,
+ NULL,
+};
+
+static const struct attribute_group ad5360_attribute_group = {
+ .attrs = ad5360_attributes,
+};
+
+static int ad5360_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val,
+ int val2,
+ long mask)
+{
+ struct ad5360_state *st = iio_priv(indio_dev);
+ int max_val = (1 << chan->scan_type.realbits);
+ unsigned int ofs_index;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ if (val >= max_val || val < 0)
+ return -EINVAL;
+
+ return ad5360_write(indio_dev, AD5360_CMD_WRITE_DATA,
+ chan->address, val, chan->scan_type.shift);
+
+ case IIO_CHAN_INFO_CALIBBIAS:
+ if (val >= max_val || val < 0)
+ return -EINVAL;
+
+ return ad5360_write(indio_dev, AD5360_CMD_WRITE_OFFSET,
+ chan->address, val, chan->scan_type.shift);
+
+ case IIO_CHAN_INFO_CALIBSCALE:
+ if (val >= max_val || val < 0)
+ return -EINVAL;
+
+ return ad5360_write(indio_dev, AD5360_CMD_WRITE_GAIN,
+ chan->address, val, chan->scan_type.shift);
+
+ case IIO_CHAN_INFO_OFFSET:
+ if (val <= -max_val || val > 0)
+ return -EINVAL;
+
+ val = -val;
+
+ /* offset is supposed to have the same scale as raw, but it
+ * is always 14bits wide, so on a chip where the raw value has
+ * more bits, we need to shift offset. */
+ val >>= (chan->scan_type.realbits - 14);
+
+ /* There is one DAC offset register per vref. Changing one
+ * channels offset will also change the offset for all other
+ * channels which share the same vref supply. */
+ ofs_index = ad5360_get_channel_vref_index(st, chan->channel);
+ return ad5360_write(indio_dev, AD5360_CMD_SPECIAL_FUNCTION,
+ AD5360_REG_SF_OFS(ofs_index), val, 0);
+ default:
+ break;
+ }
+
+ return -EINVAL;
+}
+
+static int ad5360_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val,
+ int *val2,
+ long m)
+{
+ struct ad5360_state *st = iio_priv(indio_dev);
+ unsigned int ofs_index;
+ int scale_uv;
+ int ret;
+
+ switch (m) {
+ case IIO_CHAN_INFO_RAW:
+ ret = ad5360_read(indio_dev, AD5360_READBACK_X1A,
+ chan->address);
+ if (ret < 0)
+ return ret;
+ *val = ret >> chan->scan_type.shift;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_SCALE:
+ /* vout = 4 * vref * dac_code */
+ scale_uv = ad5360_get_channel_vref(st, chan->channel) * 4 * 100;
+ if (scale_uv < 0)
+ return scale_uv;
+
+ scale_uv >>= (chan->scan_type.realbits);
+ *val = scale_uv / 100000;
+ *val2 = (scale_uv % 100000) * 10;
+ return IIO_VAL_INT_PLUS_MICRO;
+ case IIO_CHAN_INFO_CALIBBIAS:
+ ret = ad5360_read(indio_dev, AD5360_READBACK_OFFSET,
+ chan->address);
+ if (ret < 0)
+ return ret;
+ *val = ret;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_CALIBSCALE:
+ ret = ad5360_read(indio_dev, AD5360_READBACK_GAIN,
+ chan->address);
+ if (ret < 0)
+ return ret;
+ *val = ret;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_OFFSET:
+ ofs_index = ad5360_get_channel_vref_index(st, chan->channel);
+ ret = ad5360_read(indio_dev, AD5360_READBACK_SF,
+ AD5360_REG_SF_OFS(ofs_index));
+ if (ret < 0)
+ return ret;
+
+ ret <<= (chan->scan_type.realbits - 14);
+ *val = -ret;
+ return IIO_VAL_INT;
+ }
+
+ return -EINVAL;
+}
+
+static const struct iio_info ad5360_info = {
+ .read_raw = ad5360_read_raw,
+ .write_raw = ad5360_write_raw,
+ .attrs = &ad5360_attribute_group,
+ .driver_module = THIS_MODULE,
+};
+
+static const char * const ad5360_vref_name[] = {
+ "vref0", "vref1", "vref2"
+};
+
+static int __devinit ad5360_alloc_channels(struct iio_dev *indio_dev)
+{
+ struct ad5360_state *st = iio_priv(indio_dev);
+ struct iio_chan_spec *channels;
+ unsigned int i;
+
+ channels = kcalloc(st->chip_info->num_channels,
+ sizeof(struct iio_chan_spec), GFP_KERNEL);
+
+ if (!channels)
+ return -ENOMEM;
+
+ for (i = 0; i < st->chip_info->num_channels; ++i) {
+ channels[i] = st->chip_info->channel_template;
+ channels[i].channel = i;
+ channels[i].address = AD5360_CHAN_ADDR(i);
+ }
+
+ indio_dev->channels = channels;
+
+ return 0;
+}
+
+static int __devinit ad5360_probe(struct spi_device *spi)
+{
+ enum ad5360_type type = spi_get_device_id(spi)->driver_data;
+ struct iio_dev *indio_dev;
+ struct ad5360_state *st;
+ unsigned int i;
+ int ret;
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL) {
+ dev_err(&spi->dev, "Failed to allocate iio device\n");
+ return -ENOMEM;
+ }
+
+ st = iio_priv(indio_dev);
+ spi_set_drvdata(spi, indio_dev);
+
+ st->chip_info = &ad5360_chip_info_tbl[type];
+ st->spi = spi;
+
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->name = spi_get_device_id(spi)->name;
+ indio_dev->info = &ad5360_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->num_channels = st->chip_info->num_channels;
+
+ ret = ad5360_alloc_channels(indio_dev);
+ if (ret) {
+ dev_err(&spi->dev, "Failed to allocate channel spec: %d\n", ret);
+ goto error_free;
+ }
+
+ for (i = 0; i < st->chip_info->num_vrefs; ++i)
+ st->vref_reg[i].supply = ad5360_vref_name[i];
+
+ ret = regulator_bulk_get(&st->spi->dev, st->chip_info->num_vrefs,
+ st->vref_reg);
+ if (ret) {
+ dev_err(&spi->dev, "Failed to request vref regulators: %d\n", ret);
+ goto error_free_channels;
+ }
+
+ ret = regulator_bulk_enable(st->chip_info->num_vrefs, st->vref_reg);
+ if (ret) {
+ dev_err(&spi->dev, "Failed to enable vref regulators: %d\n", ret);
+ goto error_free_reg;
+ }
+
+ ret = iio_device_register(indio_dev);
+ if (ret) {
+ dev_err(&spi->dev, "Failed to register iio device: %d\n", ret);
+ goto error_disable_reg;
+ }
+
+ return 0;
+
+error_disable_reg:
+ regulator_bulk_disable(st->chip_info->num_vrefs, st->vref_reg);
+error_free_reg:
+ regulator_bulk_free(st->chip_info->num_vrefs, st->vref_reg);
+error_free_channels:
+ kfree(indio_dev->channels);
+error_free:
+ iio_device_free(indio_dev);
+
+ return ret;
+}
+
+static int __devexit ad5360_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+ struct ad5360_state *st = iio_priv(indio_dev);
+
+ iio_device_unregister(indio_dev);
+
+ kfree(indio_dev->channels);
+
+ regulator_bulk_disable(st->chip_info->num_vrefs, st->vref_reg);
+ regulator_bulk_free(st->chip_info->num_vrefs, st->vref_reg);
+
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct spi_device_id ad5360_ids[] = {
+ { "ad5360", ID_AD5360 },
+ { "ad5361", ID_AD5361 },
+ { "ad5362", ID_AD5362 },
+ { "ad5363", ID_AD5363 },
+ { "ad5370", ID_AD5370 },
+ { "ad5371", ID_AD5371 },
+ { "ad5372", ID_AD5372 },
+ { "ad5373", ID_AD5373 },
+ {}
+};
+MODULE_DEVICE_TABLE(spi, ad5360_ids);
+
+static struct spi_driver ad5360_driver = {
+ .driver = {
+ .name = "ad5360",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5360_probe,
+ .remove = __devexit_p(ad5360_remove),
+ .id_table = ad5360_ids,
+};
+module_spi_driver(ad5360_driver);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("Analog Devices AD5360/61/62/63/70/71/72/73 DAC");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/*
+ * Analog devices AD5380, AD5381, AD5382, AD5383, AD5390, AD5391, AD5392
+ * multi-channel Digital to Analog Converters driver
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/regmap.h>
+#include <linux/regulator/consumer.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define AD5380_REG_DATA(x) (((x) << 2) | 3)
+#define AD5380_REG_OFFSET(x) (((x) << 2) | 2)
+#define AD5380_REG_GAIN(x) (((x) << 2) | 1)
+#define AD5380_REG_SF_PWR_DOWN (8 << 2)
+#define AD5380_REG_SF_PWR_UP (9 << 2)
+#define AD5380_REG_SF_CTRL (12 << 2)
+
+#define AD5380_CTRL_PWR_DOWN_MODE_OFFSET 13
+#define AD5380_CTRL_INT_VREF_2V5 BIT(12)
+#define AD5380_CTRL_INT_VREF_EN BIT(10)
+
+/**
+ * struct ad5380_chip_info - chip specific information
+ * @channel_template: channel specification template
+ * @num_channels: number of channels
+ * @int_vref: internal vref in uV
+*/
+
+struct ad5380_chip_info {
+ struct iio_chan_spec channel_template;
+ unsigned int num_channels;
+ unsigned int int_vref;
+};
+
+/**
+ * struct ad5380_state - driver instance specific data
+ * @regmap: regmap instance used by the device
+ * @chip_info: chip model specific constants, available modes etc
+ * @vref_reg: vref supply regulator
+ * @vref: actual reference voltage used in uA
+ * @pwr_down: whether the chip is currently in power down mode
+ */
+
+struct ad5380_state {
+ struct regmap *regmap;
+ const struct ad5380_chip_info *chip_info;
+ struct regulator *vref_reg;
+ int vref;
+ bool pwr_down;
+};
+
+enum ad5380_type {
+ ID_AD5380_3,
+ ID_AD5380_5,
+ ID_AD5381_3,
+ ID_AD5381_5,
+ ID_AD5382_3,
+ ID_AD5382_5,
+ ID_AD5383_3,
+ ID_AD5383_5,
+ ID_AD5390_3,
+ ID_AD5390_5,
+ ID_AD5391_3,
+ ID_AD5391_5,
+ ID_AD5392_3,
+ ID_AD5392_5,
+};
+
+static ssize_t ad5380_read_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, char *buf)
+{
+ struct ad5380_state *st = iio_priv(indio_dev);
+
+ return sprintf(buf, "%d\n", st->pwr_down);
+}
+
+static ssize_t ad5380_write_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
+ size_t len)
+{
+ struct ad5380_state *st = iio_priv(indio_dev);
+ bool pwr_down;
+ int ret;
+
+ ret = strtobool(buf, &pwr_down);
+ if (ret)
+ return ret;
+
+ mutex_lock(&indio_dev->mlock);
+
+ if (pwr_down)
+ ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_DOWN, 0);
+ else
+ ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_UP, 0);
+
+ st->pwr_down = pwr_down;
+
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret ? ret : len;
+}
+
+static const char * const ad5380_powerdown_modes[] = {
+ "100kohm_to_gnd",
+ "three_state",
+};
+
+static int ad5380_get_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan)
+{
+ struct ad5380_state *st = iio_priv(indio_dev);
+ unsigned int mode;
+ int ret;
+
+ ret = regmap_read(st->regmap, AD5380_REG_SF_CTRL, &mode);
+ if (ret)
+ return ret;
+
+ mode = (mode >> AD5380_CTRL_PWR_DOWN_MODE_OFFSET) & 1;
+
+ return mode;
+}
+
+static int ad5380_set_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan, unsigned int mode)
+{
+ struct ad5380_state *st = iio_priv(indio_dev);
+ int ret;
+
+ ret = regmap_update_bits(st->regmap, AD5380_REG_SF_CTRL,
+ 1 << AD5380_CTRL_PWR_DOWN_MODE_OFFSET,
+ mode << AD5380_CTRL_PWR_DOWN_MODE_OFFSET);
+
+ return ret;
+}
+
+static const struct iio_enum ad5380_powerdown_mode_enum = {
+ .items = ad5380_powerdown_modes,
+ .num_items = ARRAY_SIZE(ad5380_powerdown_modes),
+ .get = ad5380_get_powerdown_mode,
+ .set = ad5380_set_powerdown_mode,
+};
+
+static unsigned int ad5380_info_to_reg(struct iio_chan_spec const *chan,
+ long info)
+{
+ switch (info) {
+ case 0:
+ return AD5380_REG_DATA(chan->address);
+ case IIO_CHAN_INFO_CALIBBIAS:
+ return AD5380_REG_OFFSET(chan->address);
+ case IIO_CHAN_INFO_CALIBSCALE:
+ return AD5380_REG_GAIN(chan->address);
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+static int ad5380_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan, int val, int val2, long info)
+{
+ const unsigned int max_val = (1 << chan->scan_type.realbits);
+ struct ad5380_state *st = iio_priv(indio_dev);
+
+ switch (info) {
+ case IIO_CHAN_INFO_RAW:
+ case IIO_CHAN_INFO_CALIBSCALE:
+ if (val >= max_val || val < 0)
+ return -EINVAL;
+
+ return regmap_write(st->regmap,
+ ad5380_info_to_reg(chan, info),
+ val << chan->scan_type.shift);
+ case IIO_CHAN_INFO_CALIBBIAS:
+ val += (1 << chan->scan_type.realbits) / 2;
+ if (val >= max_val || val < 0)
+ return -EINVAL;
+
+ return regmap_write(st->regmap,
+ AD5380_REG_OFFSET(chan->address),
+ val << chan->scan_type.shift);
+ default:
+ break;
+ }
+ return -EINVAL;
+}
+
+static int ad5380_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan, int *val, int *val2, long info)
+{
+ struct ad5380_state *st = iio_priv(indio_dev);
+ unsigned long scale_uv;
+ int ret;
+
+ switch (info) {
+ case IIO_CHAN_INFO_RAW:
+ case IIO_CHAN_INFO_CALIBSCALE:
+ ret = regmap_read(st->regmap, ad5380_info_to_reg(chan, info),
+ val);
+ if (ret)
+ return ret;
+ *val >>= chan->scan_type.shift;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_CALIBBIAS:
+ ret = regmap_read(st->regmap, AD5380_REG_OFFSET(chan->address),
+ val);
+ if (ret)
+ return ret;
+ *val >>= chan->scan_type.shift;
+ val -= (1 << chan->scan_type.realbits) / 2;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_SCALE:
+ scale_uv = ((2 * st->vref) >> chan->scan_type.realbits) * 100;
+ *val = scale_uv / 100000;
+ *val2 = (scale_uv % 100000) * 10;
+ return IIO_VAL_INT_PLUS_MICRO;
+ default:
+ break;
+ }
+
+ return -EINVAL;
+}
+
+static const struct iio_info ad5380_info = {
+ .read_raw = ad5380_read_raw,
+ .write_raw = ad5380_write_raw,
+ .driver_module = THIS_MODULE,
+};
+
+static struct iio_chan_spec_ext_info ad5380_ext_info[] = {
+ {
+ .name = "powerdown",
+ .read = ad5380_read_dac_powerdown,
+ .write = ad5380_write_dac_powerdown,
+ },
+ IIO_ENUM("powerdown_mode", true, &ad5380_powerdown_mode_enum),
+ IIO_ENUM_AVAILABLE("powerdown_mode", &ad5380_powerdown_mode_enum),
+ { },
+};
+
+#define AD5380_CHANNEL(_bits) { \
+ .type = IIO_VOLTAGE, \
+ .indexed = 1, \
+ .output = 1, \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+ IIO_CHAN_INFO_SCALE_SHARED_BIT | \
+ IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT | \
+ IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, \
+ .scan_type = IIO_ST('u', (_bits), 16, 14 - (_bits)), \
+ .ext_info = ad5380_ext_info, \
+}
+
+static const struct ad5380_chip_info ad5380_chip_info_tbl[] = {
+ [ID_AD5380_3] = {
+ .channel_template = AD5380_CHANNEL(14),
+ .num_channels = 40,
+ .int_vref = 1250000,
+ },
+ [ID_AD5380_5] = {
+ .channel_template = AD5380_CHANNEL(14),
+ .num_channels = 40,
+ .int_vref = 2500000,
+ },
+ [ID_AD5381_3] = {
+ .channel_template = AD5380_CHANNEL(12),
+ .num_channels = 16,
+ .int_vref = 1250000,
+ },
+ [ID_AD5381_5] = {
+ .channel_template = AD5380_CHANNEL(12),
+ .num_channels = 16,
+ .int_vref = 2500000,
+ },
+ [ID_AD5382_3] = {
+ .channel_template = AD5380_CHANNEL(14),
+ .num_channels = 32,
+ .int_vref = 1250000,
+ },
+ [ID_AD5382_5] = {
+ .channel_template = AD5380_CHANNEL(14),
+ .num_channels = 32,
+ .int_vref = 2500000,
+ },
+ [ID_AD5383_3] = {
+ .channel_template = AD5380_CHANNEL(12),
+ .num_channels = 32,
+ .int_vref = 1250000,
+ },
+ [ID_AD5383_5] = {
+ .channel_template = AD5380_CHANNEL(12),
+ .num_channels = 32,
+ .int_vref = 2500000,
+ },
+ [ID_AD5390_3] = {
+ .channel_template = AD5380_CHANNEL(14),
+ .num_channels = 16,
+ .int_vref = 1250000,
+ },
+ [ID_AD5390_5] = {
+ .channel_template = AD5380_CHANNEL(14),
+ .num_channels = 16,
+ .int_vref = 2500000,
+ },
+ [ID_AD5391_3] = {
+ .channel_template = AD5380_CHANNEL(12),
+ .num_channels = 16,
+ .int_vref = 1250000,
+ },
+ [ID_AD5391_5] = {
+ .channel_template = AD5380_CHANNEL(12),
+ .num_channels = 16,
+ .int_vref = 2500000,
+ },
+ [ID_AD5392_3] = {
+ .channel_template = AD5380_CHANNEL(14),
+ .num_channels = 8,
+ .int_vref = 1250000,
+ },
+ [ID_AD5392_5] = {
+ .channel_template = AD5380_CHANNEL(14),
+ .num_channels = 8,
+ .int_vref = 2500000,
+ },
+};
+
+static int __devinit ad5380_alloc_channels(struct iio_dev *indio_dev)
+{
+ struct ad5380_state *st = iio_priv(indio_dev);
+ struct iio_chan_spec *channels;
+ unsigned int i;
+
+ channels = kcalloc(st->chip_info->num_channels,
+ sizeof(struct iio_chan_spec), GFP_KERNEL);
+
+ if (!channels)
+ return -ENOMEM;
+
+ for (i = 0; i < st->chip_info->num_channels; ++i) {
+ channels[i] = st->chip_info->channel_template;
+ channels[i].channel = i;
+ channels[i].address = i;
+ }
+
+ indio_dev->channels = channels;
+
+ return 0;
+}
+
+static int __devinit ad5380_probe(struct device *dev, struct regmap *regmap,
+ enum ad5380_type type, const char *name)
+{
+ struct iio_dev *indio_dev;
+ struct ad5380_state *st;
+ unsigned int ctrl = 0;
+ int ret;
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL) {
+ dev_err(dev, "Failed to allocate iio device\n");
+ ret = -ENOMEM;
+ goto error_out;
+ }
+
+ st = iio_priv(indio_dev);
+ dev_set_drvdata(dev, indio_dev);
+
+ st->chip_info = &ad5380_chip_info_tbl[type];
+ st->regmap = regmap;
+
+ indio_dev->dev.parent = dev;
+ indio_dev->name = name;
+ indio_dev->info = &ad5380_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->num_channels = st->chip_info->num_channels;
+
+ ret = ad5380_alloc_channels(indio_dev);
+ if (ret) {
+ dev_err(dev, "Failed to allocate channel spec: %d\n", ret);
+ goto error_free;
+ }
+
+ if (st->chip_info->int_vref == 2500000)
+ ctrl |= AD5380_CTRL_INT_VREF_2V5;
+
+ st->vref_reg = regulator_get(dev, "vref");
+ if (!IS_ERR(st->vref_reg)) {
+ ret = regulator_enable(st->vref_reg);
+ if (ret) {
+ dev_err(dev, "Failed to enable vref regulators: %d\n",
+ ret);
+ goto error_free_reg;
+ }
+
+ st->vref = regulator_get_voltage(st->vref_reg);
+ } else {
+ st->vref = st->chip_info->int_vref;
+ ctrl |= AD5380_CTRL_INT_VREF_EN;
+ }
+
+ ret = regmap_write(st->regmap, AD5380_REG_SF_CTRL, ctrl);
+ if (ret) {
+ dev_err(dev, "Failed to write to device: %d\n", ret);
+ goto error_disable_reg;
+ }
+
+ ret = iio_device_register(indio_dev);
+ if (ret) {
+ dev_err(dev, "Failed to register iio device: %d\n", ret);
+ goto error_disable_reg;
+ }
+
+ return 0;
+
+error_disable_reg:
+ if (!IS_ERR(st->vref_reg))
+ regulator_disable(st->vref_reg);
+error_free_reg:
+ if (!IS_ERR(st->vref_reg))
+ regulator_put(st->vref_reg);
+
+ kfree(indio_dev->channels);
+error_free:
+ iio_device_free(indio_dev);
+error_out:
+
+ return ret;
+}
+
+static int __devexit ad5380_remove(struct device *dev)
+{
+ struct iio_dev *indio_dev = dev_get_drvdata(dev);
+ struct ad5380_state *st = iio_priv(indio_dev);
+
+ iio_device_unregister(indio_dev);
+
+ kfree(indio_dev->channels);
+
+ if (!IS_ERR(st->vref_reg)) {
+ regulator_disable(st->vref_reg);
+ regulator_put(st->vref_reg);
+ }
+
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static bool ad5380_reg_false(struct device *dev, unsigned int reg)
+{
+ return false;
+}
+
+static const struct regmap_config ad5380_regmap_config = {
+ .reg_bits = 10,
+ .val_bits = 14,
+
+ .max_register = AD5380_REG_DATA(40),
+ .cache_type = REGCACHE_RBTREE,
+
+ .volatile_reg = ad5380_reg_false,
+ .readable_reg = ad5380_reg_false,
+};
+
+#if IS_ENABLED(CONFIG_SPI_MASTER)
+
+static int __devinit ad5380_spi_probe(struct spi_device *spi)
+{
+ const struct spi_device_id *id = spi_get_device_id(spi);
+ struct regmap *regmap;
+
+ regmap = devm_regmap_init_spi(spi, &ad5380_regmap_config);
+
+ if (IS_ERR(regmap))
+ return PTR_ERR(regmap);
+
+ return ad5380_probe(&spi->dev, regmap, id->driver_data, id->name);
+}
+
+static int __devexit ad5380_spi_remove(struct spi_device *spi)
+{
+ return ad5380_remove(&spi->dev);
+}
+
+static const struct spi_device_id ad5380_spi_ids[] = {
+ { "ad5380-3", ID_AD5380_3 },
+ { "ad5380-5", ID_AD5380_5 },
+ { "ad5381-3", ID_AD5381_3 },
+ { "ad5381-5", ID_AD5381_5 },
+ { "ad5382-3", ID_AD5382_3 },
+ { "ad5382-5", ID_AD5382_5 },
+ { "ad5383-3", ID_AD5383_3 },
+ { "ad5383-5", ID_AD5383_5 },
+ { "ad5384-3", ID_AD5380_3 },
+ { "ad5384-5", ID_AD5380_5 },
+ { "ad5390-3", ID_AD5390_3 },
+ { "ad5390-5", ID_AD5390_5 },
+ { "ad5391-3", ID_AD5391_3 },
+ { "ad5391-5", ID_AD5391_5 },
+ { "ad5392-3", ID_AD5392_3 },
+ { "ad5392-5", ID_AD5392_5 },
+ { }
+};
+MODULE_DEVICE_TABLE(spi, ad5380_spi_ids);
+
+static struct spi_driver ad5380_spi_driver = {
+ .driver = {
+ .name = "ad5380",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5380_spi_probe,
+ .remove = __devexit_p(ad5380_spi_remove),
+ .id_table = ad5380_spi_ids,
+};
+
+static inline int ad5380_spi_register_driver(void)
+{
+ return spi_register_driver(&ad5380_spi_driver);
+}
+
+static inline void ad5380_spi_unregister_driver(void)
+{
+ spi_unregister_driver(&ad5380_spi_driver);
+}
+
+#else
+
+static inline int ad5380_spi_register_driver(void)
+{
+ return 0;
+}
+
+static inline void ad5380_spi_unregister_driver(void)
+{
+}
+
+#endif
+
+#if IS_ENABLED(CONFIG_I2C)
+
+static int __devinit ad5380_i2c_probe(struct i2c_client *i2c,
+ const struct i2c_device_id *id)
+{
+ struct regmap *regmap;
+
+ regmap = devm_regmap_init_i2c(i2c, &ad5380_regmap_config);
+
+ if (IS_ERR(regmap))
+ return PTR_ERR(regmap);
+
+ return ad5380_probe(&i2c->dev, regmap, id->driver_data, id->name);
+}
+
+static int __devexit ad5380_i2c_remove(struct i2c_client *i2c)
+{
+ return ad5380_remove(&i2c->dev);
+}
+
+static const struct i2c_device_id ad5380_i2c_ids[] = {
+ { "ad5380-3", ID_AD5380_3 },
+ { "ad5380-5", ID_AD5380_5 },
+ { "ad5381-3", ID_AD5381_3 },
+ { "ad5381-5", ID_AD5381_5 },
+ { "ad5382-3", ID_AD5382_3 },
+ { "ad5382-5", ID_AD5382_5 },
+ { "ad5383-3", ID_AD5383_3 },
+ { "ad5383-5", ID_AD5383_5 },
+ { "ad5384-3", ID_AD5380_3 },
+ { "ad5384-5", ID_AD5380_5 },
+ { "ad5390-3", ID_AD5390_3 },
+ { "ad5390-5", ID_AD5390_5 },
+ { "ad5391-3", ID_AD5391_3 },
+ { "ad5391-5", ID_AD5391_5 },
+ { "ad5392-3", ID_AD5392_3 },
+ { "ad5392-5", ID_AD5392_5 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, ad5380_i2c_ids);
+
+static struct i2c_driver ad5380_i2c_driver = {
+ .driver = {
+ .name = "ad5380",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5380_i2c_probe,
+ .remove = __devexit_p(ad5380_i2c_remove),
+ .id_table = ad5380_i2c_ids,
+};
+
+static inline int ad5380_i2c_register_driver(void)
+{
+ return i2c_add_driver(&ad5380_i2c_driver);
+}
+
+static inline void ad5380_i2c_unregister_driver(void)
+{
+ i2c_del_driver(&ad5380_i2c_driver);
+}
+
+#else
+
+static inline int ad5380_i2c_register_driver(void)
+{
+ return 0;
+}
+
+static inline void ad5380_i2c_unregister_driver(void)
+{
+}
+
+#endif
+
+static int __init ad5380_spi_init(void)
+{
+ int ret;
+
+ ret = ad5380_spi_register_driver();
+ if (ret)
+ return ret;
+
+ ret = ad5380_i2c_register_driver();
+ if (ret) {
+ ad5380_spi_unregister_driver();
+ return ret;
+ }
+
+ return 0;
+}
+module_init(ad5380_spi_init);
+
+static void __exit ad5380_spi_exit(void)
+{
+ ad5380_i2c_unregister_driver();
+ ad5380_spi_unregister_driver();
+
+}
+module_exit(ad5380_spi_exit);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("Analog Devices AD5380/81/82/83/84/90/91/92 DAC");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/*
+ * AD5421 Digital to analog converters driver
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/device.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/iio/events.h>
+#include <linux/iio/dac/ad5421.h>
+
+
+#define AD5421_REG_DAC_DATA 0x1
+#define AD5421_REG_CTRL 0x2
+#define AD5421_REG_OFFSET 0x3
+#define AD5421_REG_GAIN 0x4
+/* load dac and fault shared the same register number. Writing to it will cause
+ * a dac load command, reading from it will return the fault status register */
+#define AD5421_REG_LOAD_DAC 0x5
+#define AD5421_REG_FAULT 0x5
+#define AD5421_REG_FORCE_ALARM_CURRENT 0x6
+#define AD5421_REG_RESET 0x7
+#define AD5421_REG_START_CONVERSION 0x8
+#define AD5421_REG_NOOP 0x9
+
+#define AD5421_CTRL_WATCHDOG_DISABLE BIT(12)
+#define AD5421_CTRL_AUTO_FAULT_READBACK BIT(11)
+#define AD5421_CTRL_MIN_CURRENT BIT(9)
+#define AD5421_CTRL_ADC_SOURCE_TEMP BIT(8)
+#define AD5421_CTRL_ADC_ENABLE BIT(7)
+#define AD5421_CTRL_PWR_DOWN_INT_VREF BIT(6)
+
+#define AD5421_FAULT_SPI BIT(15)
+#define AD5421_FAULT_PEC BIT(14)
+#define AD5421_FAULT_OVER_CURRENT BIT(13)
+#define AD5421_FAULT_UNDER_CURRENT BIT(12)
+#define AD5421_FAULT_TEMP_OVER_140 BIT(11)
+#define AD5421_FAULT_TEMP_OVER_100 BIT(10)
+#define AD5421_FAULT_UNDER_VOLTAGE_6V BIT(9)
+#define AD5421_FAULT_UNDER_VOLTAGE_12V BIT(8)
+
+/* These bits will cause the fault pin to go high */
+#define AD5421_FAULT_TRIGGER_IRQ \
+ (AD5421_FAULT_SPI | AD5421_FAULT_PEC | AD5421_FAULT_OVER_CURRENT | \
+ AD5421_FAULT_UNDER_CURRENT | AD5421_FAULT_TEMP_OVER_140)
+
+/**
+ * struct ad5421_state - driver instance specific data
+ * @spi: spi_device
+ * @ctrl: control register cache
+ * @current_range: current range which the device is configured for
+ * @data: spi transfer buffers
+ * @fault_mask: software masking of events
+ */
+struct ad5421_state {
+ struct spi_device *spi;
+ unsigned int ctrl;
+ enum ad5421_current_range current_range;
+ unsigned int fault_mask;
+
+ /*
+ * DMA (thus cache coherency maintenance) requires the
+ * transfer buffers to live in their own cache lines.
+ */
+ union {
+ u32 d32;
+ u8 d8[4];
+ } data[2] ____cacheline_aligned;
+};
+
+static const struct iio_chan_spec ad5421_channels[] = {
+ {
+ .type = IIO_CURRENT,
+ .indexed = 1,
+ .output = 1,
+ .channel = 0,
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
+ IIO_CHAN_INFO_SCALE_SHARED_BIT |
+ IIO_CHAN_INFO_OFFSET_SHARED_BIT |
+ IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT |
+ IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT,
+ .scan_type = IIO_ST('u', 16, 16, 0),
+ .event_mask = IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) |
+ IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING),
+ },
+ {
+ .type = IIO_TEMP,
+ .channel = -1,
+ .event_mask = IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
+ },
+};
+
+static int ad5421_write_unlocked(struct iio_dev *indio_dev,
+ unsigned int reg, unsigned int val)
+{
+ struct ad5421_state *st = iio_priv(indio_dev);
+
+ st->data[0].d32 = cpu_to_be32((reg << 16) | val);
+
+ return spi_write(st->spi, &st->data[0].d8[1], 3);
+}
+
+static int ad5421_write(struct iio_dev *indio_dev, unsigned int reg,
+ unsigned int val)
+{
+ int ret;
+
+ mutex_lock(&indio_dev->mlock);
+ ret = ad5421_write_unlocked(indio_dev, reg, val);
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static int ad5421_read(struct iio_dev *indio_dev, unsigned int reg)
+{
+ struct ad5421_state *st = iio_priv(indio_dev);
+ struct spi_message m;
+ int ret;
+ struct spi_transfer t[] = {
+ {
+ .tx_buf = &st->data[0].d8[1],
+ .len = 3,
+ .cs_change = 1,
+ }, {
+ .rx_buf = &st->data[1].d8[1],
+ .len = 3,
+ },
+ };
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t[0], &m);
+ spi_message_add_tail(&t[1], &m);
+
+ mutex_lock(&indio_dev->mlock);
+
+ st->data[0].d32 = cpu_to_be32((1 << 23) | (reg << 16));
+
+ ret = spi_sync(st->spi, &m);
+ if (ret >= 0)
+ ret = be32_to_cpu(st->data[1].d32) & 0xffff;
+
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static int ad5421_update_ctrl(struct iio_dev *indio_dev, unsigned int set,
+ unsigned int clr)
+{
+ struct ad5421_state *st = iio_priv(indio_dev);
+ unsigned int ret;
+
+ mutex_lock(&indio_dev->mlock);
+
+ st->ctrl &= ~clr;
+ st->ctrl |= set;
+
+ ret = ad5421_write_unlocked(indio_dev, AD5421_REG_CTRL, st->ctrl);
+
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static irqreturn_t ad5421_fault_handler(int irq, void *data)
+{
+ struct iio_dev *indio_dev = data;
+ struct ad5421_state *st = iio_priv(indio_dev);
+ unsigned int fault;
+ unsigned int old_fault = 0;
+ unsigned int events;
+
+ fault = ad5421_read(indio_dev, AD5421_REG_FAULT);
+ if (!fault)
+ return IRQ_NONE;
+
+ /* If we had a fault, this might mean that the DAC has lost its state
+ * and has been reset. Make sure that the control register actually
+ * contains what we expect it to contain. Otherwise the watchdog might
+ * be enabled and we get watchdog timeout faults, which will render the
+ * DAC unusable. */
+ ad5421_update_ctrl(indio_dev, 0, 0);
+
+
+ /* The fault pin stays high as long as a fault condition is present and
+ * it is not possible to mask fault conditions. For certain fault
+ * conditions for example like over-temperature it takes some time
+ * until the fault condition disappears. If we would exit the interrupt
+ * handler immediately after handling the event it would be entered
+ * again instantly. Thus we fall back to polling in case we detect that
+ * a interrupt condition is still present.
+ */
+ do {
+ /* 0xffff is a invalid value for the register and will only be
+ * read if there has been a communication error */
+ if (fault == 0xffff)
+ fault = 0;
+
+ /* we are only interested in new events */
+ events = (old_fault ^ fault) & fault;
+ events &= st->fault_mask;
+
+ if (events & AD5421_FAULT_OVER_CURRENT) {
+ iio_push_event(indio_dev,
+ IIO_UNMOD_EVENT_CODE(IIO_CURRENT,
+ 0,
+ IIO_EV_TYPE_THRESH,
+ IIO_EV_DIR_RISING),
+ iio_get_time_ns());
+ }
+
+ if (events & AD5421_FAULT_UNDER_CURRENT) {
+ iio_push_event(indio_dev,
+ IIO_UNMOD_EVENT_CODE(IIO_CURRENT,
+ 0,
+ IIO_EV_TYPE_THRESH,
+ IIO_EV_DIR_FALLING),
+ iio_get_time_ns());
+ }
+
+ if (events & AD5421_FAULT_TEMP_OVER_140) {
+ iio_push_event(indio_dev,
+ IIO_UNMOD_EVENT_CODE(IIO_TEMP,
+ 0,
+ IIO_EV_TYPE_MAG,
+ IIO_EV_DIR_RISING),
+ iio_get_time_ns());
+ }
+
+ old_fault = fault;
+ fault = ad5421_read(indio_dev, AD5421_REG_FAULT);
+
+ /* still active? go to sleep for some time */
+ if (fault & AD5421_FAULT_TRIGGER_IRQ)
+ msleep(1000);
+
+ } while (fault & AD5421_FAULT_TRIGGER_IRQ);
+
+
+ return IRQ_HANDLED;
+}
+
+static void ad5421_get_current_min_max(struct ad5421_state *st,
+ unsigned int *min, unsigned int *max)
+{
+ /* The current range is configured using external pins, which are
+ * usually hard-wired and not run-time switchable. */
+ switch (st->current_range) {
+ case AD5421_CURRENT_RANGE_4mA_20mA:
+ *min = 4000;
+ *max = 20000;
+ break;
+ case AD5421_CURRENT_RANGE_3mA8_21mA:
+ *min = 3800;
+ *max = 21000;
+ break;
+ case AD5421_CURRENT_RANGE_3mA2_24mA:
+ *min = 3200;
+ *max = 24000;
+ break;
+ default:
+ *min = 0;
+ *max = 1;
+ break;
+ }
+}
+
+static inline unsigned int ad5421_get_offset(struct ad5421_state *st)
+{
+ unsigned int min, max;
+
+ ad5421_get_current_min_max(st, &min, &max);
+ return (min * (1 << 16)) / (max - min);
+}
+
+static inline unsigned int ad5421_get_scale(struct ad5421_state *st)
+{
+ unsigned int min, max;
+
+ ad5421_get_current_min_max(st, &min, &max);
+ return ((max - min) * 1000) / (1 << 16);
+}
+
+static int ad5421_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan, int *val, int *val2, long m)
+{
+ struct ad5421_state *st = iio_priv(indio_dev);
+ int ret;
+
+ if (chan->type != IIO_CURRENT)
+ return -EINVAL;
+
+ switch (m) {
+ case IIO_CHAN_INFO_RAW:
+ ret = ad5421_read(indio_dev, AD5421_REG_DAC_DATA);
+ if (ret < 0)
+ return ret;
+ *val = ret;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_SCALE:
+ *val = 0;
+ *val2 = ad5421_get_scale(st);
+ return IIO_VAL_INT_PLUS_MICRO;
+ case IIO_CHAN_INFO_OFFSET:
+ *val = ad5421_get_offset(st);
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_CALIBBIAS:
+ ret = ad5421_read(indio_dev, AD5421_REG_OFFSET);
+ if (ret < 0)
+ return ret;
+ *val = ret - 32768;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_CALIBSCALE:
+ ret = ad5421_read(indio_dev, AD5421_REG_GAIN);
+ if (ret < 0)
+ return ret;
+ *val = ret;
+ return IIO_VAL_INT;
+ }
+
+ return -EINVAL;
+}
+
+static int ad5421_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan, int val, int val2, long mask)
+{
+ const unsigned int max_val = 1 << 16;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ if (val >= max_val || val < 0)
+ return -EINVAL;
+
+ return ad5421_write(indio_dev, AD5421_REG_DAC_DATA, val);
+ case IIO_CHAN_INFO_CALIBBIAS:
+ val += 32768;
+ if (val >= max_val || val < 0)
+ return -EINVAL;
+
+ return ad5421_write(indio_dev, AD5421_REG_OFFSET, val);
+ case IIO_CHAN_INFO_CALIBSCALE:
+ if (val >= max_val || val < 0)
+ return -EINVAL;
+
+ return ad5421_write(indio_dev, AD5421_REG_GAIN, val);
+ default:
+ break;
+ }
+
+ return -EINVAL;
+}
+
+static int ad5421_write_event_config(struct iio_dev *indio_dev,
+ u64 event_code, int state)
+{
+ struct ad5421_state *st = iio_priv(indio_dev);
+ unsigned int mask;
+
+ switch (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code)) {
+ case IIO_CURRENT:
+ if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
+ IIO_EV_DIR_RISING)
+ mask = AD5421_FAULT_OVER_CURRENT;
+ else
+ mask = AD5421_FAULT_UNDER_CURRENT;
+ break;
+ case IIO_TEMP:
+ mask = AD5421_FAULT_TEMP_OVER_140;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ mutex_lock(&indio_dev->mlock);
+ if (state)
+ st->fault_mask |= mask;
+ else
+ st->fault_mask &= ~mask;
+ mutex_unlock(&indio_dev->mlock);
+
+ return 0;
+}
+
+static int ad5421_read_event_config(struct iio_dev *indio_dev,
+ u64 event_code)
+{
+ struct ad5421_state *st = iio_priv(indio_dev);
+ unsigned int mask;
+
+ switch (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code)) {
+ case IIO_CURRENT:
+ if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
+ IIO_EV_DIR_RISING)
+ mask = AD5421_FAULT_OVER_CURRENT;
+ else
+ mask = AD5421_FAULT_UNDER_CURRENT;
+ break;
+ case IIO_TEMP:
+ mask = AD5421_FAULT_TEMP_OVER_140;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return (bool)(st->fault_mask & mask);
+}
+
+static int ad5421_read_event_value(struct iio_dev *indio_dev, u64 event_code,
+ int *val)
+{
+ int ret;
+
+ switch (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code)) {
+ case IIO_CURRENT:
+ ret = ad5421_read(indio_dev, AD5421_REG_DAC_DATA);
+ if (ret < 0)
+ return ret;
+ *val = ret;
+ break;
+ case IIO_TEMP:
+ *val = 140000;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static const struct iio_info ad5421_info = {
+ .read_raw = ad5421_read_raw,
+ .write_raw = ad5421_write_raw,
+ .read_event_config = ad5421_read_event_config,
+ .write_event_config = ad5421_write_event_config,
+ .read_event_value = ad5421_read_event_value,
+ .driver_module = THIS_MODULE,
+};
+
+static int __devinit ad5421_probe(struct spi_device *spi)
+{
+ struct ad5421_platform_data *pdata = dev_get_platdata(&spi->dev);
+ struct iio_dev *indio_dev;
+ struct ad5421_state *st;
+ int ret;
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL) {
+ dev_err(&spi->dev, "Failed to allocate iio device\n");
+ return -ENOMEM;
+ }
+
+ st = iio_priv(indio_dev);
+ spi_set_drvdata(spi, indio_dev);
+
+ st->spi = spi;
+
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->name = "ad5421";
+ indio_dev->info = &ad5421_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->channels = ad5421_channels;
+ indio_dev->num_channels = ARRAY_SIZE(ad5421_channels);
+
+ st->ctrl = AD5421_CTRL_WATCHDOG_DISABLE |
+ AD5421_CTRL_AUTO_FAULT_READBACK;
+
+ if (pdata) {
+ st->current_range = pdata->current_range;
+ if (pdata->external_vref)
+ st->ctrl |= AD5421_CTRL_PWR_DOWN_INT_VREF;
+ } else {
+ st->current_range = AD5421_CURRENT_RANGE_4mA_20mA;
+ }
+
+ /* write initial ctrl register value */
+ ad5421_update_ctrl(indio_dev, 0, 0);
+
+ if (spi->irq) {
+ ret = request_threaded_irq(spi->irq,
+ NULL,
+ ad5421_fault_handler,
+ IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
+ "ad5421 fault",
+ indio_dev);
+ if (ret)
+ goto error_free;
+ }
+
+ ret = iio_device_register(indio_dev);
+ if (ret) {
+ dev_err(&spi->dev, "Failed to register iio device: %d\n", ret);
+ goto error_free_irq;
+ }
+
+ return 0;
+
+error_free_irq:
+ if (spi->irq)
+ free_irq(spi->irq, indio_dev);
+error_free:
+ iio_device_free(indio_dev);
+
+ return ret;
+}
+
+static int __devexit ad5421_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+
+ iio_device_unregister(indio_dev);
+ if (spi->irq)
+ free_irq(spi->irq, indio_dev);
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static struct spi_driver ad5421_driver = {
+ .driver = {
+ .name = "ad5421",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5421_probe,
+ .remove = __devexit_p(ad5421_remove),
+};
+module_spi_driver(ad5421_driver);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("Analog Devices AD5421 DAC");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("spi:ad5421");
--- /dev/null
+/*
+ * AD5446 SPI DAC driver
+ *
+ * Copyright 2010 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/workqueue.h>
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/list.h>
+#include <linux/spi/spi.h>
+#include <linux/regulator/consumer.h>
+#include <linux/err.h>
+#include <linux/module.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#include "ad5446.h"
+
+static int ad5446_write(struct ad5446_state *st, unsigned val)
+{
+ __be16 data = cpu_to_be16(val);
+ return spi_write(st->spi, &data, sizeof(data));
+}
+
+static int ad5660_write(struct ad5446_state *st, unsigned val)
+{
+ uint8_t data[3];
+
+ data[0] = (val >> 16) & 0xFF;
+ data[1] = (val >> 8) & 0xFF;
+ data[2] = val & 0xFF;
+
+ return spi_write(st->spi, data, sizeof(data));
+}
+
+static const char * const ad5446_powerdown_modes[] = {
+ "1kohm_to_gnd", "100kohm_to_gnd", "three_state"
+};
+
+static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan, unsigned int mode)
+{
+ struct ad5446_state *st = iio_priv(indio_dev);
+
+ st->pwr_down_mode = mode + 1;
+
+ return 0;
+}
+
+static int ad5446_get_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan)
+{
+ struct ad5446_state *st = iio_priv(indio_dev);
+
+ return st->pwr_down_mode - 1;
+}
+
+static const struct iio_enum ad5446_powerdown_mode_enum = {
+ .items = ad5446_powerdown_modes,
+ .num_items = ARRAY_SIZE(ad5446_powerdown_modes),
+ .get = ad5446_get_powerdown_mode,
+ .set = ad5446_set_powerdown_mode,
+};
+
+static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private,
+ const struct iio_chan_spec *chan,
+ char *buf)
+{
+ struct ad5446_state *st = iio_priv(indio_dev);
+
+ return sprintf(buf, "%d\n", st->pwr_down);
+}
+
+static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private,
+ const struct iio_chan_spec *chan,
+ const char *buf, size_t len)
+{
+ struct ad5446_state *st = iio_priv(indio_dev);
+ unsigned int shift;
+ unsigned int val;
+ bool powerdown;
+ int ret;
+
+ ret = strtobool(buf, &powerdown);
+ if (ret)
+ return ret;
+
+ mutex_lock(&indio_dev->mlock);
+ st->pwr_down = powerdown;
+
+ if (st->pwr_down) {
+ shift = chan->scan_type.realbits + chan->scan_type.shift;
+ val = st->pwr_down_mode << shift;
+ } else {
+ val = st->cached_val;
+ }
+
+ ret = st->chip_info->write(st, val);
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret ? ret : len;
+}
+
+static const struct iio_chan_spec_ext_info ad5064_ext_info_powerdown[] = {
+ {
+ .name = "powerdown",
+ .read = ad5446_read_dac_powerdown,
+ .write = ad5446_write_dac_powerdown,
+ },
+ IIO_ENUM("powerdown_mode", false, &ad5446_powerdown_mode_enum),
+ IIO_ENUM_AVAILABLE("powerdown_mode", &ad5446_powerdown_mode_enum),
+ { },
+};
+
+#define _AD5446_CHANNEL(bits, storage, shift, ext) { \
+ .type = IIO_VOLTAGE, \
+ .indexed = 1, \
+ .output = 1, \
+ .channel = 0, \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+ IIO_CHAN_INFO_SCALE_SHARED_BIT, \
+ .scan_type = IIO_ST('u', (bits), (storage), (shift)), \
+ .ext_info = (ext), \
+}
+
+#define AD5446_CHANNEL(bits, storage, shift) \
+ _AD5446_CHANNEL(bits, storage, shift, NULL)
+
+#define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
+ _AD5446_CHANNEL(bits, storage, shift, ad5064_ext_info_powerdown)
+
+static const struct ad5446_chip_info ad5446_chip_info_tbl[] = {
+ [ID_AD5444] = {
+ .channel = AD5446_CHANNEL(12, 16, 2),
+ .write = ad5446_write,
+ },
+ [ID_AD5446] = {
+ .channel = AD5446_CHANNEL(14, 16, 0),
+ .write = ad5446_write,
+ },
+ [ID_AD5450] = {
+ .channel = AD5446_CHANNEL(8, 16, 6),
+ .write = ad5446_write,
+ },
+ [ID_AD5451] = {
+ .channel = AD5446_CHANNEL(10, 16, 4),
+ .write = ad5446_write,
+ },
+ [ID_AD5541A] = {
+ .channel = AD5446_CHANNEL(16, 16, 0),
+ .write = ad5446_write,
+ },
+ [ID_AD5512A] = {
+ .channel = AD5446_CHANNEL(12, 16, 4),
+ .write = ad5446_write,
+ },
+ [ID_AD5553] = {
+ .channel = AD5446_CHANNEL(14, 16, 0),
+ .write = ad5446_write,
+ },
+ [ID_AD5601] = {
+ .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
+ .write = ad5446_write,
+ },
+ [ID_AD5611] = {
+ .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
+ .write = ad5446_write,
+ },
+ [ID_AD5621] = {
+ .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
+ .write = ad5446_write,
+ },
+ [ID_AD5620_2500] = {
+ .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
+ .int_vref_mv = 2500,
+ .write = ad5446_write,
+ },
+ [ID_AD5620_1250] = {
+ .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
+ .int_vref_mv = 1250,
+ .write = ad5446_write,
+ },
+ [ID_AD5640_2500] = {
+ .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
+ .int_vref_mv = 2500,
+ .write = ad5446_write,
+ },
+ [ID_AD5640_1250] = {
+ .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
+ .int_vref_mv = 1250,
+ .write = ad5446_write,
+ },
+ [ID_AD5660_2500] = {
+ .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
+ .int_vref_mv = 2500,
+ .write = ad5660_write,
+ },
+ [ID_AD5660_1250] = {
+ .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
+ .int_vref_mv = 1250,
+ .write = ad5660_write,
+ },
+ [ID_AD5662] = {
+ .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
+ .write = ad5660_write,
+ },
+};
+
+static int ad5446_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val,
+ int *val2,
+ long m)
+{
+ struct ad5446_state *st = iio_priv(indio_dev);
+ unsigned long scale_uv;
+
+ switch (m) {
+ case IIO_CHAN_INFO_RAW:
+ *val = st->cached_val;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_SCALE:
+ scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
+ *val = scale_uv / 1000;
+ *val2 = (scale_uv % 1000) * 1000;
+ return IIO_VAL_INT_PLUS_MICRO;
+
+ }
+ return -EINVAL;
+}
+
+static int ad5446_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val,
+ int val2,
+ long mask)
+{
+ struct ad5446_state *st = iio_priv(indio_dev);
+ int ret = 0;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ if (val >= (1 << chan->scan_type.realbits) || val < 0)
+ return -EINVAL;
+
+ val <<= chan->scan_type.shift;
+ mutex_lock(&indio_dev->mlock);
+ st->cached_val = val;
+ if (!st->pwr_down)
+ ret = st->chip_info->write(st, val);
+ mutex_unlock(&indio_dev->mlock);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+
+ return ret;
+}
+
+static const struct iio_info ad5446_info = {
+ .read_raw = ad5446_read_raw,
+ .write_raw = ad5446_write_raw,
+ .driver_module = THIS_MODULE,
+};
+
+static int __devinit ad5446_probe(struct spi_device *spi)
+{
+ struct ad5446_state *st;
+ struct iio_dev *indio_dev;
+ struct regulator *reg;
+ int ret, voltage_uv = 0;
+
+ reg = regulator_get(&spi->dev, "vcc");
+ if (!IS_ERR(reg)) {
+ ret = regulator_enable(reg);
+ if (ret)
+ goto error_put_reg;
+
+ voltage_uv = regulator_get_voltage(reg);
+ }
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL) {
+ ret = -ENOMEM;
+ goto error_disable_reg;
+ }
+ st = iio_priv(indio_dev);
+ st->chip_info =
+ &ad5446_chip_info_tbl[spi_get_device_id(spi)->driver_data];
+
+ spi_set_drvdata(spi, indio_dev);
+ st->reg = reg;
+ st->spi = spi;
+
+ /* Establish that the iio_dev is a child of the spi device */
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->name = spi_get_device_id(spi)->name;
+ indio_dev->info = &ad5446_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->channels = &st->chip_info->channel;
+ indio_dev->num_channels = 1;
+
+ st->pwr_down_mode = MODE_PWRDWN_1k;
+
+ if (st->chip_info->int_vref_mv)
+ st->vref_mv = st->chip_info->int_vref_mv;
+ else if (voltage_uv)
+ st->vref_mv = voltage_uv / 1000;
+ else
+ dev_warn(&spi->dev, "reference voltage unspecified\n");
+
+ ret = iio_device_register(indio_dev);
+ if (ret)
+ goto error_free_device;
+
+ return 0;
+
+error_free_device:
+ iio_device_free(indio_dev);
+error_disable_reg:
+ if (!IS_ERR(reg))
+ regulator_disable(reg);
+error_put_reg:
+ if (!IS_ERR(reg))
+ regulator_put(reg);
+
+ return ret;
+}
+
+static int ad5446_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+ struct ad5446_state *st = iio_priv(indio_dev);
+
+ iio_device_unregister(indio_dev);
+ if (!IS_ERR(st->reg)) {
+ regulator_disable(st->reg);
+ regulator_put(st->reg);
+ }
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct spi_device_id ad5446_id[] = {
+ {"ad5444", ID_AD5444},
+ {"ad5446", ID_AD5446},
+ {"ad5450", ID_AD5450},
+ {"ad5451", ID_AD5451},
+ {"ad5452", ID_AD5444}, /* ad5452 is compatible to the ad5444 */
+ {"ad5453", ID_AD5446}, /* ad5453 is compatible to the ad5446 */
+ {"ad5512a", ID_AD5512A},
+ {"ad5541a", ID_AD5541A},
+ {"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */
+ {"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */
+ {"ad5553", ID_AD5553},
+ {"ad5601", ID_AD5601},
+ {"ad5611", ID_AD5611},
+ {"ad5621", ID_AD5621},
+ {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
+ {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
+ {"ad5640-2500", ID_AD5640_2500},
+ {"ad5640-1250", ID_AD5640_1250},
+ {"ad5660-2500", ID_AD5660_2500},
+ {"ad5660-1250", ID_AD5660_1250},
+ {"ad5662", ID_AD5662},
+ {}
+};
+MODULE_DEVICE_TABLE(spi, ad5446_id);
+
+static struct spi_driver ad5446_driver = {
+ .driver = {
+ .name = "ad5446",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5446_probe,
+ .remove = __devexit_p(ad5446_remove),
+ .id_table = ad5446_id,
+};
+module_spi_driver(ad5446_driver);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/*
+ * AD5446 SPI DAC driver
+ *
+ * Copyright 2010 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+#ifndef IIO_DAC_AD5446_H_
+#define IIO_DAC_AD5446_H_
+
+/* DAC Control Bits */
+
+#define AD5446_LOAD (0x0 << 14) /* Load and update */
+#define AD5446_SDO_DIS (0x1 << 14) /* Disable SDO */
+#define AD5446_NOP (0x2 << 14) /* No operation */
+#define AD5446_CLK_RISING (0x3 << 14) /* Clock data on rising edge */
+
+#define AD5620_LOAD (0x0 << 14) /* Load and update Norm Operation*/
+#define AD5620_PWRDWN_1k (0x1 << 14) /* Power-down: 1kOhm to GND */
+#define AD5620_PWRDWN_100k (0x2 << 14) /* Power-down: 100kOhm to GND */
+#define AD5620_PWRDWN_TRISTATE (0x3 << 14) /* Power-down: Three-state */
+
+#define AD5660_LOAD (0x0 << 16) /* Load and update Norm Operation*/
+#define AD5660_PWRDWN_1k (0x1 << 16) /* Power-down: 1kOhm to GND */
+#define AD5660_PWRDWN_100k (0x2 << 16) /* Power-down: 100kOhm to GND */
+#define AD5660_PWRDWN_TRISTATE (0x3 << 16) /* Power-down: Three-state */
+
+#define MODE_PWRDWN_1k 0x1
+#define MODE_PWRDWN_100k 0x2
+#define MODE_PWRDWN_TRISTATE 0x3
+
+/**
+ * struct ad5446_state - driver instance specific data
+ * @spi: spi_device
+ * @chip_info: chip model specific constants, available modes etc
+ * @reg: supply regulator
+ * @vref_mv: actual reference voltage used
+ */
+
+struct ad5446_state {
+ struct spi_device *spi;
+ const struct ad5446_chip_info *chip_info;
+ struct regulator *reg;
+ unsigned short vref_mv;
+ unsigned cached_val;
+ unsigned pwr_down_mode;
+ unsigned pwr_down;
+};
+
+/**
+ * struct ad5446_chip_info - chip specific information
+ * @channel: channel spec for the DAC
+ * @int_vref_mv: AD5620/40/60: the internal reference voltage
+ * @write: chip specific helper function to write to the register
+ */
+
+struct ad5446_chip_info {
+ struct iio_chan_spec channel;
+ u16 int_vref_mv;
+ int (*write)(struct ad5446_state *st, unsigned val);
+};
+
+/**
+ * ad5446_supported_device_ids:
+ * The AD5620/40/60 parts are available in different fixed internal reference
+ * voltage options. The actual part numbers may look differently
+ * (and a bit cryptic), however this style is used to make clear which
+ * parts are supported here.
+ */
+
+enum ad5446_supported_device_ids {
+ ID_AD5444,
+ ID_AD5446,
+ ID_AD5450,
+ ID_AD5451,
+ ID_AD5541A,
+ ID_AD5512A,
+ ID_AD5553,
+ ID_AD5601,
+ ID_AD5611,
+ ID_AD5621,
+ ID_AD5620_2500,
+ ID_AD5620_1250,
+ ID_AD5640_2500,
+ ID_AD5640_1250,
+ ID_AD5660_2500,
+ ID_AD5660_1250,
+ ID_AD5662,
+};
+
+#endif /* IIO_DAC_AD5446_H_ */
--- /dev/null
+/*
+ * AD5504, AD5501 High Voltage Digital to Analog Converter
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/regulator/consumer.h>
+#include <linux/module.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/iio/events.h>
+#include <linux/iio/dac/ad5504.h>
+
+#define AD5505_BITS 12
+#define AD5504_RES_MASK ((1 << (AD5505_BITS)) - 1)
+
+#define AD5504_CMD_READ (1 << 15)
+#define AD5504_CMD_WRITE (0 << 15)
+#define AD5504_ADDR(addr) ((addr) << 12)
+
+/* Registers */
+#define AD5504_ADDR_NOOP 0
+#define AD5504_ADDR_DAC(x) ((x) + 1)
+#define AD5504_ADDR_ALL_DAC 5
+#define AD5504_ADDR_CTRL 7
+
+/* Control Register */
+#define AD5504_DAC_PWR(ch) ((ch) << 2)
+#define AD5504_DAC_PWRDWN_MODE(mode) ((mode) << 6)
+#define AD5504_DAC_PWRDN_20K 0
+#define AD5504_DAC_PWRDN_3STATE 1
+
+/**
+ * struct ad5446_state - driver instance specific data
+ * @us: spi_device
+ * @reg: supply regulator
+ * @vref_mv: actual reference voltage used
+ * @pwr_down_mask power down mask
+ * @pwr_down_mode current power down mode
+ */
+
+struct ad5504_state {
+ struct spi_device *spi;
+ struct regulator *reg;
+ unsigned short vref_mv;
+ unsigned pwr_down_mask;
+ unsigned pwr_down_mode;
+};
+
+/**
+ * ad5504_supported_device_ids:
+ */
+
+enum ad5504_supported_device_ids {
+ ID_AD5504,
+ ID_AD5501,
+};
+
+static int ad5504_spi_write(struct spi_device *spi, u8 addr, u16 val)
+{
+ u16 tmp = cpu_to_be16(AD5504_CMD_WRITE |
+ AD5504_ADDR(addr) |
+ (val & AD5504_RES_MASK));
+
+ return spi_write(spi, (u8 *)&tmp, 2);
+}
+
+static int ad5504_spi_read(struct spi_device *spi, u8 addr)
+{
+ u16 tmp = cpu_to_be16(AD5504_CMD_READ | AD5504_ADDR(addr));
+ u16 val;
+ int ret;
+ struct spi_transfer t = {
+ .tx_buf = &tmp,
+ .rx_buf = &val,
+ .len = 2,
+ };
+ struct spi_message m;
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t, &m);
+ ret = spi_sync(spi, &m);
+
+ if (ret < 0)
+ return ret;
+
+ return be16_to_cpu(val) & AD5504_RES_MASK;
+}
+
+static int ad5504_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val,
+ int *val2,
+ long m)
+{
+ struct ad5504_state *st = iio_priv(indio_dev);
+ unsigned long scale_uv;
+ int ret;
+
+ switch (m) {
+ case IIO_CHAN_INFO_RAW:
+ ret = ad5504_spi_read(st->spi, chan->address);
+ if (ret < 0)
+ return ret;
+
+ *val = ret;
+
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_SCALE:
+ scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
+ *val = scale_uv / 1000;
+ *val2 = (scale_uv % 1000) * 1000;
+ return IIO_VAL_INT_PLUS_MICRO;
+
+ }
+ return -EINVAL;
+}
+
+static int ad5504_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val,
+ int val2,
+ long mask)
+{
+ struct ad5504_state *st = iio_priv(indio_dev);
+ int ret;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ if (val >= (1 << chan->scan_type.realbits) || val < 0)
+ return -EINVAL;
+
+ return ad5504_spi_write(st->spi, chan->address, val);
+ default:
+ ret = -EINVAL;
+ }
+
+ return -EINVAL;
+}
+
+static const char * const ad5504_powerdown_modes[] = {
+ "20kohm_to_gnd",
+ "three_state",
+};
+
+static int ad5504_get_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan)
+{
+ struct ad5504_state *st = iio_priv(indio_dev);
+
+ return st->pwr_down_mode;
+}
+
+static int ad5504_set_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan, unsigned int mode)
+{
+ struct ad5504_state *st = iio_priv(indio_dev);
+
+ st->pwr_down_mode = mode;
+
+ return 0;
+}
+
+static const struct iio_enum ad5504_powerdown_mode_enum = {
+ .items = ad5504_powerdown_modes,
+ .num_items = ARRAY_SIZE(ad5504_powerdown_modes),
+ .get = ad5504_get_powerdown_mode,
+ .set = ad5504_set_powerdown_mode,
+};
+
+static ssize_t ad5504_read_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, char *buf)
+{
+ struct ad5504_state *st = iio_priv(indio_dev);
+
+ return sprintf(buf, "%d\n",
+ !(st->pwr_down_mask & (1 << chan->channel)));
+}
+
+static ssize_t ad5504_write_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
+ size_t len)
+{
+ bool pwr_down;
+ int ret;
+ struct ad5504_state *st = iio_priv(indio_dev);
+
+ ret = strtobool(buf, &pwr_down);
+ if (ret)
+ return ret;
+
+ if (pwr_down)
+ st->pwr_down_mask |= (1 << chan->channel);
+ else
+ st->pwr_down_mask &= ~(1 << chan->channel);
+
+ ret = ad5504_spi_write(st->spi, AD5504_ADDR_CTRL,
+ AD5504_DAC_PWRDWN_MODE(st->pwr_down_mode) |
+ AD5504_DAC_PWR(st->pwr_down_mask));
+
+ /* writes to the CTRL register must be followed by a NOOP */
+ ad5504_spi_write(st->spi, AD5504_ADDR_NOOP, 0);
+
+ return ret ? ret : len;
+}
+
+static IIO_CONST_ATTR(temp0_thresh_rising_value, "110000");
+static IIO_CONST_ATTR(temp0_thresh_rising_en, "1");
+
+static struct attribute *ad5504_ev_attributes[] = {
+ &iio_const_attr_temp0_thresh_rising_value.dev_attr.attr,
+ &iio_const_attr_temp0_thresh_rising_en.dev_attr.attr,
+ NULL,
+};
+
+static struct attribute_group ad5504_ev_attribute_group = {
+ .attrs = ad5504_ev_attributes,
+ .name = "events",
+};
+
+static irqreturn_t ad5504_event_handler(int irq, void *private)
+{
+ iio_push_event(private,
+ IIO_UNMOD_EVENT_CODE(IIO_TEMP,
+ 0,
+ IIO_EV_TYPE_THRESH,
+ IIO_EV_DIR_RISING),
+ iio_get_time_ns());
+
+ return IRQ_HANDLED;
+}
+
+static const struct iio_info ad5504_info = {
+ .write_raw = ad5504_write_raw,
+ .read_raw = ad5504_read_raw,
+ .event_attrs = &ad5504_ev_attribute_group,
+ .driver_module = THIS_MODULE,
+};
+
+static const struct iio_chan_spec_ext_info ad5504_ext_info[] = {
+ {
+ .name = "powerdown",
+ .read = ad5504_read_dac_powerdown,
+ .write = ad5504_write_dac_powerdown,
+ },
+ IIO_ENUM("powerdown_mode", true, &ad5504_powerdown_mode_enum),
+ IIO_ENUM_AVAILABLE("powerdown_mode", &ad5504_powerdown_mode_enum),
+ { },
+};
+
+#define AD5504_CHANNEL(_chan) { \
+ .type = IIO_VOLTAGE, \
+ .indexed = 1, \
+ .output = 1, \
+ .channel = (_chan), \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+ IIO_CHAN_INFO_SCALE_SHARED_BIT, \
+ .address = AD5504_ADDR_DAC(_chan), \
+ .scan_type = IIO_ST('u', 12, 16, 0), \
+ .ext_info = ad5504_ext_info, \
+}
+
+static const struct iio_chan_spec ad5504_channels[] = {
+ AD5504_CHANNEL(0),
+ AD5504_CHANNEL(1),
+ AD5504_CHANNEL(2),
+ AD5504_CHANNEL(3),
+};
+
+static int __devinit ad5504_probe(struct spi_device *spi)
+{
+ struct ad5504_platform_data *pdata = spi->dev.platform_data;
+ struct iio_dev *indio_dev;
+ struct ad5504_state *st;
+ struct regulator *reg;
+ int ret, voltage_uv = 0;
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL) {
+ ret = -ENOMEM;
+ goto error_ret;
+ }
+ reg = regulator_get(&spi->dev, "vcc");
+ if (!IS_ERR(reg)) {
+ ret = regulator_enable(reg);
+ if (ret)
+ goto error_put_reg;
+
+ voltage_uv = regulator_get_voltage(reg);
+ }
+
+ spi_set_drvdata(spi, indio_dev);
+ st = iio_priv(indio_dev);
+ if (voltage_uv)
+ st->vref_mv = voltage_uv / 1000;
+ else if (pdata)
+ st->vref_mv = pdata->vref_mv;
+ else
+ dev_warn(&spi->dev, "reference voltage unspecified\n");
+
+ st->reg = reg;
+ st->spi = spi;
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->name = spi_get_device_id(st->spi)->name;
+ indio_dev->info = &ad5504_info;
+ if (spi_get_device_id(st->spi)->driver_data == ID_AD5501)
+ indio_dev->num_channels = 1;
+ else
+ indio_dev->num_channels = 4;
+ indio_dev->channels = ad5504_channels;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+
+ if (spi->irq) {
+ ret = request_threaded_irq(spi->irq,
+ NULL,
+ &ad5504_event_handler,
+ IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+ spi_get_device_id(st->spi)->name,
+ indio_dev);
+ if (ret)
+ goto error_disable_reg;
+ }
+
+ ret = iio_device_register(indio_dev);
+ if (ret)
+ goto error_free_irq;
+
+ return 0;
+
+error_free_irq:
+ if (spi->irq)
+ free_irq(spi->irq, indio_dev);
+error_disable_reg:
+ if (!IS_ERR(reg))
+ regulator_disable(reg);
+error_put_reg:
+ if (!IS_ERR(reg))
+ regulator_put(reg);
+
+ iio_device_free(indio_dev);
+error_ret:
+ return ret;
+}
+
+static int __devexit ad5504_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+ struct ad5504_state *st = iio_priv(indio_dev);
+
+ iio_device_unregister(indio_dev);
+ if (spi->irq)
+ free_irq(spi->irq, indio_dev);
+
+ if (!IS_ERR(st->reg)) {
+ regulator_disable(st->reg);
+ regulator_put(st->reg);
+ }
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct spi_device_id ad5504_id[] = {
+ {"ad5504", ID_AD5504},
+ {"ad5501", ID_AD5501},
+ {}
+};
+MODULE_DEVICE_TABLE(spi, ad5504_id);
+
+static struct spi_driver ad5504_driver = {
+ .driver = {
+ .name = "ad5504",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5504_probe,
+ .remove = __devexit_p(ad5504_remove),
+ .id_table = ad5504_id,
+};
+module_spi_driver(ad5504_driver);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("Analog Devices AD5501/AD5501 DAC");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/*
+ * AD5624R SPI DAC driver
+ *
+ * Copyright 2010-2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+#ifndef SPI_AD5624R_H_
+#define SPI_AD5624R_H_
+
+#define AD5624R_DAC_CHANNELS 4
+
+#define AD5624R_ADDR_DAC0 0x0
+#define AD5624R_ADDR_DAC1 0x1
+#define AD5624R_ADDR_DAC2 0x2
+#define AD5624R_ADDR_DAC3 0x3
+#define AD5624R_ADDR_ALL_DAC 0x7
+
+#define AD5624R_CMD_WRITE_INPUT_N 0x0
+#define AD5624R_CMD_UPDATE_DAC_N 0x1
+#define AD5624R_CMD_WRITE_INPUT_N_UPDATE_ALL 0x2
+#define AD5624R_CMD_WRITE_INPUT_N_UPDATE_N 0x3
+#define AD5624R_CMD_POWERDOWN_DAC 0x4
+#define AD5624R_CMD_RESET 0x5
+#define AD5624R_CMD_LDAC_SETUP 0x6
+#define AD5624R_CMD_INTERNAL_REFER_SETUP 0x7
+
+#define AD5624R_LDAC_PWRDN_NONE 0x0
+#define AD5624R_LDAC_PWRDN_1K 0x1
+#define AD5624R_LDAC_PWRDN_100K 0x2
+#define AD5624R_LDAC_PWRDN_3STATE 0x3
+
+/**
+ * struct ad5624r_chip_info - chip specific information
+ * @channels: channel spec for the DAC
+ * @int_vref_mv: AD5620/40/60: the internal reference voltage
+ */
+
+struct ad5624r_chip_info {
+ const struct iio_chan_spec *channels;
+ u16 int_vref_mv;
+};
+
+/**
+ * struct ad5446_state - driver instance specific data
+ * @indio_dev: the industrial I/O device
+ * @us: spi_device
+ * @chip_info: chip model specific constants, available modes etc
+ * @reg: supply regulator
+ * @vref_mv: actual reference voltage used
+ * @pwr_down_mask power down mask
+ * @pwr_down_mode current power down mode
+ */
+
+struct ad5624r_state {
+ struct spi_device *us;
+ const struct ad5624r_chip_info *chip_info;
+ struct regulator *reg;
+ unsigned short vref_mv;
+ unsigned pwr_down_mask;
+ unsigned pwr_down_mode;
+};
+
+/**
+ * ad5624r_supported_device_ids:
+ * The AD5624/44/64 parts are available in different
+ * fixed internal reference voltage options.
+ */
+
+enum ad5624r_supported_device_ids {
+ ID_AD5624R3,
+ ID_AD5644R3,
+ ID_AD5664R3,
+ ID_AD5624R5,
+ ID_AD5644R5,
+ ID_AD5664R5,
+};
+
+#endif /* SPI_AD5624R_H_ */
--- /dev/null
+/*
+ * AD5624R, AD5644R, AD5664R Digital to analog convertors spi driver
+ *
+ * Copyright 2010-2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/regulator/consumer.h>
+#include <linux/module.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#include "ad5624r.h"
+
+static int ad5624r_spi_write(struct spi_device *spi,
+ u8 cmd, u8 addr, u16 val, u8 len)
+{
+ u32 data;
+ u8 msg[3];
+
+ /*
+ * The input shift register is 24 bits wide. The first two bits are
+ * don't care bits. The next three are the command bits, C2 to C0,
+ * followed by the 3-bit DAC address, A2 to A0, and then the
+ * 16-, 14-, 12-bit data-word. The data-word comprises the 16-,
+ * 14-, 12-bit input code followed by 0, 2, or 4 don't care bits,
+ * for the AD5664R, AD5644R, and AD5624R, respectively.
+ */
+ data = (0 << 22) | (cmd << 19) | (addr << 16) | (val << (16 - len));
+ msg[0] = data >> 16;
+ msg[1] = data >> 8;
+ msg[2] = data;
+
+ return spi_write(spi, msg, 3);
+}
+
+static int ad5624r_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val,
+ int *val2,
+ long m)
+{
+ struct ad5624r_state *st = iio_priv(indio_dev);
+ unsigned long scale_uv;
+
+ switch (m) {
+ case IIO_CHAN_INFO_SCALE:
+ scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
+ *val = scale_uv / 1000;
+ *val2 = (scale_uv % 1000) * 1000;
+ return IIO_VAL_INT_PLUS_MICRO;
+
+ }
+ return -EINVAL;
+}
+
+static int ad5624r_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val,
+ int val2,
+ long mask)
+{
+ struct ad5624r_state *st = iio_priv(indio_dev);
+ int ret;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ if (val >= (1 << chan->scan_type.realbits) || val < 0)
+ return -EINVAL;
+
+ return ad5624r_spi_write(st->us,
+ AD5624R_CMD_WRITE_INPUT_N_UPDATE_N,
+ chan->address, val,
+ chan->scan_type.shift);
+ default:
+ ret = -EINVAL;
+ }
+
+ return -EINVAL;
+}
+
+static const char * const ad5624r_powerdown_modes[] = {
+ "1kohm_to_gnd",
+ "100kohm_to_gnd",
+ "three_state"
+};
+
+static int ad5624r_get_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan)
+{
+ struct ad5624r_state *st = iio_priv(indio_dev);
+
+ return st->pwr_down_mode;
+}
+
+static int ad5624r_set_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan, unsigned int mode)
+{
+ struct ad5624r_state *st = iio_priv(indio_dev);
+
+ st->pwr_down_mode = mode;
+
+ return 0;
+}
+
+static const struct iio_enum ad5624r_powerdown_mode_enum = {
+ .items = ad5624r_powerdown_modes,
+ .num_items = ARRAY_SIZE(ad5624r_powerdown_modes),
+ .get = ad5624r_get_powerdown_mode,
+ .set = ad5624r_set_powerdown_mode,
+};
+
+static ssize_t ad5624r_read_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, char *buf)
+{
+ struct ad5624r_state *st = iio_priv(indio_dev);
+
+ return sprintf(buf, "%d\n",
+ !!(st->pwr_down_mask & (1 << chan->channel)));
+}
+
+static ssize_t ad5624r_write_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
+ size_t len)
+{
+ bool pwr_down;
+ int ret;
+ struct ad5624r_state *st = iio_priv(indio_dev);
+
+ ret = strtobool(buf, &pwr_down);
+ if (ret)
+ return ret;
+
+ if (pwr_down)
+ st->pwr_down_mask |= (1 << chan->channel);
+ else
+ st->pwr_down_mask &= ~(1 << chan->channel);
+
+ ret = ad5624r_spi_write(st->us, AD5624R_CMD_POWERDOWN_DAC, 0,
+ (st->pwr_down_mode << 4) |
+ st->pwr_down_mask, 16);
+
+ return ret ? ret : len;
+}
+
+static const struct iio_info ad5624r_info = {
+ .write_raw = ad5624r_write_raw,
+ .read_raw = ad5624r_read_raw,
+ .driver_module = THIS_MODULE,
+};
+
+static const struct iio_chan_spec_ext_info ad5624r_ext_info[] = {
+ {
+ .name = "powerdown",
+ .read = ad5624r_read_dac_powerdown,
+ .write = ad5624r_write_dac_powerdown,
+ },
+ IIO_ENUM("powerdown_mode", true, &ad5624r_powerdown_mode_enum),
+ IIO_ENUM_AVAILABLE("powerdown_mode", &ad5624r_powerdown_mode_enum),
+ { },
+};
+
+#define AD5624R_CHANNEL(_chan, _bits) { \
+ .type = IIO_VOLTAGE, \
+ .indexed = 1, \
+ .output = 1, \
+ .channel = (_chan), \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+ IIO_CHAN_INFO_SCALE_SHARED_BIT, \
+ .address = (_chan), \
+ .scan_type = IIO_ST('u', (_bits), 16, 16 - (_bits)), \
+ .ext_info = ad5624r_ext_info, \
+}
+
+#define DECLARE_AD5624R_CHANNELS(_name, _bits) \
+ const struct iio_chan_spec _name##_channels[] = { \
+ AD5624R_CHANNEL(0, _bits), \
+ AD5624R_CHANNEL(1, _bits), \
+ AD5624R_CHANNEL(2, _bits), \
+ AD5624R_CHANNEL(3, _bits), \
+}
+
+static DECLARE_AD5624R_CHANNELS(ad5624r, 12);
+static DECLARE_AD5624R_CHANNELS(ad5644r, 14);
+static DECLARE_AD5624R_CHANNELS(ad5664r, 16);
+
+static const struct ad5624r_chip_info ad5624r_chip_info_tbl[] = {
+ [ID_AD5624R3] = {
+ .channels = ad5624r_channels,
+ .int_vref_mv = 1250,
+ },
+ [ID_AD5624R5] = {
+ .channels = ad5624r_channels,
+ .int_vref_mv = 2500,
+ },
+ [ID_AD5644R3] = {
+ .channels = ad5644r_channels,
+ .int_vref_mv = 1250,
+ },
+ [ID_AD5644R5] = {
+ .channels = ad5644r_channels,
+ .int_vref_mv = 2500,
+ },
+ [ID_AD5664R3] = {
+ .channels = ad5664r_channels,
+ .int_vref_mv = 1250,
+ },
+ [ID_AD5664R5] = {
+ .channels = ad5664r_channels,
+ .int_vref_mv = 2500,
+ },
+};
+
+static int __devinit ad5624r_probe(struct spi_device *spi)
+{
+ struct ad5624r_state *st;
+ struct iio_dev *indio_dev;
+ int ret, voltage_uv = 0;
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL) {
+ ret = -ENOMEM;
+ goto error_ret;
+ }
+ st = iio_priv(indio_dev);
+ st->reg = regulator_get(&spi->dev, "vcc");
+ if (!IS_ERR(st->reg)) {
+ ret = regulator_enable(st->reg);
+ if (ret)
+ goto error_put_reg;
+
+ voltage_uv = regulator_get_voltage(st->reg);
+ }
+
+ spi_set_drvdata(spi, indio_dev);
+ st->chip_info =
+ &ad5624r_chip_info_tbl[spi_get_device_id(spi)->driver_data];
+
+ if (voltage_uv)
+ st->vref_mv = voltage_uv / 1000;
+ else
+ st->vref_mv = st->chip_info->int_vref_mv;
+
+ st->us = spi;
+
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->name = spi_get_device_id(spi)->name;
+ indio_dev->info = &ad5624r_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->channels = st->chip_info->channels;
+ indio_dev->num_channels = AD5624R_DAC_CHANNELS;
+
+ ret = ad5624r_spi_write(spi, AD5624R_CMD_INTERNAL_REFER_SETUP, 0,
+ !!voltage_uv, 16);
+ if (ret)
+ goto error_disable_reg;
+
+ ret = iio_device_register(indio_dev);
+ if (ret)
+ goto error_disable_reg;
+
+ return 0;
+
+error_disable_reg:
+ if (!IS_ERR(st->reg))
+ regulator_disable(st->reg);
+error_put_reg:
+ if (!IS_ERR(st->reg))
+ regulator_put(st->reg);
+ iio_device_free(indio_dev);
+error_ret:
+
+ return ret;
+}
+
+static int __devexit ad5624r_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+ struct ad5624r_state *st = iio_priv(indio_dev);
+
+ iio_device_unregister(indio_dev);
+ if (!IS_ERR(st->reg)) {
+ regulator_disable(st->reg);
+ regulator_put(st->reg);
+ }
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct spi_device_id ad5624r_id[] = {
+ {"ad5624r3", ID_AD5624R3},
+ {"ad5644r3", ID_AD5644R3},
+ {"ad5664r3", ID_AD5664R3},
+ {"ad5624r5", ID_AD5624R5},
+ {"ad5644r5", ID_AD5644R5},
+ {"ad5664r5", ID_AD5664R5},
+ {}
+};
+MODULE_DEVICE_TABLE(spi, ad5624r_id);
+
+static struct spi_driver ad5624r_driver = {
+ .driver = {
+ .name = "ad5624r",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5624r_probe,
+ .remove = __devexit_p(ad5624r_remove),
+ .id_table = ad5624r_id,
+};
+module_spi_driver(ad5624r_driver);
+
+MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
+MODULE_DESCRIPTION("Analog Devices AD5624/44/64R DAC spi driver");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/*
+ * AD5686R, AD5685R, AD5684R Digital to analog converters driver
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/regulator/consumer.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define AD5686_DAC_CHANNELS 4
+
+#define AD5686_ADDR(x) ((x) << 16)
+#define AD5686_CMD(x) ((x) << 20)
+
+#define AD5686_ADDR_DAC(chan) (0x1 << (chan))
+#define AD5686_ADDR_ALL_DAC 0xF
+
+#define AD5686_CMD_NOOP 0x0
+#define AD5686_CMD_WRITE_INPUT_N 0x1
+#define AD5686_CMD_UPDATE_DAC_N 0x2
+#define AD5686_CMD_WRITE_INPUT_N_UPDATE_N 0x3
+#define AD5686_CMD_POWERDOWN_DAC 0x4
+#define AD5686_CMD_LDAC_MASK 0x5
+#define AD5686_CMD_RESET 0x6
+#define AD5686_CMD_INTERNAL_REFER_SETUP 0x7
+#define AD5686_CMD_DAISY_CHAIN_ENABLE 0x8
+#define AD5686_CMD_READBACK_ENABLE 0x9
+
+#define AD5686_LDAC_PWRDN_NONE 0x0
+#define AD5686_LDAC_PWRDN_1K 0x1
+#define AD5686_LDAC_PWRDN_100K 0x2
+#define AD5686_LDAC_PWRDN_3STATE 0x3
+
+/**
+ * struct ad5686_chip_info - chip specific information
+ * @int_vref_mv: AD5620/40/60: the internal reference voltage
+ * @channel: channel specification
+*/
+
+struct ad5686_chip_info {
+ u16 int_vref_mv;
+ struct iio_chan_spec channel[AD5686_DAC_CHANNELS];
+};
+
+/**
+ * struct ad5446_state - driver instance specific data
+ * @spi: spi_device
+ * @chip_info: chip model specific constants, available modes etc
+ * @reg: supply regulator
+ * @vref_mv: actual reference voltage used
+ * @pwr_down_mask: power down mask
+ * @pwr_down_mode: current power down mode
+ * @data: spi transfer buffers
+ */
+
+struct ad5686_state {
+ struct spi_device *spi;
+ const struct ad5686_chip_info *chip_info;
+ struct regulator *reg;
+ unsigned short vref_mv;
+ unsigned pwr_down_mask;
+ unsigned pwr_down_mode;
+ /*
+ * DMA (thus cache coherency maintenance) requires the
+ * transfer buffers to live in their own cache lines.
+ */
+
+ union {
+ u32 d32;
+ u8 d8[4];
+ } data[3] ____cacheline_aligned;
+};
+
+/**
+ * ad5686_supported_device_ids:
+ */
+
+enum ad5686_supported_device_ids {
+ ID_AD5684,
+ ID_AD5685,
+ ID_AD5686,
+};
+static int ad5686_spi_write(struct ad5686_state *st,
+ u8 cmd, u8 addr, u16 val, u8 shift)
+{
+ val <<= shift;
+
+ st->data[0].d32 = cpu_to_be32(AD5686_CMD(cmd) |
+ AD5686_ADDR(addr) |
+ val);
+
+ return spi_write(st->spi, &st->data[0].d8[1], 3);
+}
+
+static int ad5686_spi_read(struct ad5686_state *st, u8 addr)
+{
+ struct spi_transfer t[] = {
+ {
+ .tx_buf = &st->data[0].d8[1],
+ .len = 3,
+ .cs_change = 1,
+ }, {
+ .tx_buf = &st->data[1].d8[1],
+ .rx_buf = &st->data[2].d8[1],
+ .len = 3,
+ },
+ };
+ struct spi_message m;
+ int ret;
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t[0], &m);
+ spi_message_add_tail(&t[1], &m);
+
+ st->data[0].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_READBACK_ENABLE) |
+ AD5686_ADDR(addr));
+ st->data[1].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_NOOP));
+
+ ret = spi_sync(st->spi, &m);
+ if (ret < 0)
+ return ret;
+
+ return be32_to_cpu(st->data[2].d32);
+}
+
+static const char * const ad5686_powerdown_modes[] = {
+ "1kohm_to_gnd",
+ "100kohm_to_gnd",
+ "three_state"
+};
+
+static int ad5686_get_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan)
+{
+ struct ad5686_state *st = iio_priv(indio_dev);
+
+ return ((st->pwr_down_mode >> (chan->channel * 2)) & 0x3) - 1;
+}
+
+static int ad5686_set_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan, unsigned int mode)
+{
+ struct ad5686_state *st = iio_priv(indio_dev);
+
+ st->pwr_down_mode &= ~(0x3 << (chan->channel * 2));
+ st->pwr_down_mode |= ((mode + 1) << (chan->channel * 2));
+
+ return 0;
+}
+
+static const struct iio_enum ad5686_powerdown_mode_enum = {
+ .items = ad5686_powerdown_modes,
+ .num_items = ARRAY_SIZE(ad5686_powerdown_modes),
+ .get = ad5686_get_powerdown_mode,
+ .set = ad5686_set_powerdown_mode,
+};
+
+static ssize_t ad5686_read_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, char *buf)
+{
+ struct ad5686_state *st = iio_priv(indio_dev);
+
+ return sprintf(buf, "%d\n", !!(st->pwr_down_mask &
+ (0x3 << (chan->channel * 2))));
+}
+
+static ssize_t ad5686_write_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
+ size_t len)
+{
+ bool readin;
+ int ret;
+ struct ad5686_state *st = iio_priv(indio_dev);
+
+ ret = strtobool(buf, &readin);
+ if (ret)
+ return ret;
+
+ if (readin == true)
+ st->pwr_down_mask |= (0x3 << (chan->channel * 2));
+ else
+ st->pwr_down_mask &= ~(0x3 << (chan->channel * 2));
+
+ ret = ad5686_spi_write(st, AD5686_CMD_POWERDOWN_DAC, 0,
+ st->pwr_down_mask & st->pwr_down_mode, 0);
+
+ return ret ? ret : len;
+}
+
+static int ad5686_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val,
+ int *val2,
+ long m)
+{
+ struct ad5686_state *st = iio_priv(indio_dev);
+ unsigned long scale_uv;
+ int ret;
+
+ switch (m) {
+ case IIO_CHAN_INFO_RAW:
+ mutex_lock(&indio_dev->mlock);
+ ret = ad5686_spi_read(st, chan->address);
+ mutex_unlock(&indio_dev->mlock);
+ if (ret < 0)
+ return ret;
+ *val = ret;
+ return IIO_VAL_INT;
+ break;
+ case IIO_CHAN_INFO_SCALE:
+ scale_uv = (st->vref_mv * 100000)
+ >> (chan->scan_type.realbits);
+ *val = scale_uv / 100000;
+ *val2 = (scale_uv % 100000) * 10;
+ return IIO_VAL_INT_PLUS_MICRO;
+
+ }
+ return -EINVAL;
+}
+
+static int ad5686_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val,
+ int val2,
+ long mask)
+{
+ struct ad5686_state *st = iio_priv(indio_dev);
+ int ret;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ if (val > (1 << chan->scan_type.realbits) || val < 0)
+ return -EINVAL;
+
+ mutex_lock(&indio_dev->mlock);
+ ret = ad5686_spi_write(st,
+ AD5686_CMD_WRITE_INPUT_N_UPDATE_N,
+ chan->address,
+ val,
+ chan->scan_type.shift);
+ mutex_unlock(&indio_dev->mlock);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+
+ return ret;
+}
+
+static const struct iio_info ad5686_info = {
+ .read_raw = ad5686_read_raw,
+ .write_raw = ad5686_write_raw,
+ .driver_module = THIS_MODULE,
+};
+
+static const struct iio_chan_spec_ext_info ad5686_ext_info[] = {
+ {
+ .name = "powerdown",
+ .read = ad5686_read_dac_powerdown,
+ .write = ad5686_write_dac_powerdown,
+ },
+ IIO_ENUM("powerdown_mode", false, &ad5686_powerdown_mode_enum),
+ IIO_ENUM_AVAILABLE("powerdown_mode", &ad5686_powerdown_mode_enum),
+ { },
+};
+
+#define AD5868_CHANNEL(chan, bits, shift) { \
+ .type = IIO_VOLTAGE, \
+ .indexed = 1, \
+ .output = 1, \
+ .channel = chan, \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+ IIO_CHAN_INFO_SCALE_SHARED_BIT, \
+ .address = AD5686_ADDR_DAC(chan), \
+ .scan_type = IIO_ST('u', bits, 16, shift), \
+ .ext_info = ad5686_ext_info, \
+}
+
+static const struct ad5686_chip_info ad5686_chip_info_tbl[] = {
+ [ID_AD5684] = {
+ .channel[0] = AD5868_CHANNEL(0, 12, 4),
+ .channel[1] = AD5868_CHANNEL(1, 12, 4),
+ .channel[2] = AD5868_CHANNEL(2, 12, 4),
+ .channel[3] = AD5868_CHANNEL(3, 12, 4),
+ .int_vref_mv = 2500,
+ },
+ [ID_AD5685] = {
+ .channel[0] = AD5868_CHANNEL(0, 14, 2),
+ .channel[1] = AD5868_CHANNEL(1, 14, 2),
+ .channel[2] = AD5868_CHANNEL(2, 14, 2),
+ .channel[3] = AD5868_CHANNEL(3, 14, 2),
+ .int_vref_mv = 2500,
+ },
+ [ID_AD5686] = {
+ .channel[0] = AD5868_CHANNEL(0, 16, 0),
+ .channel[1] = AD5868_CHANNEL(1, 16, 0),
+ .channel[2] = AD5868_CHANNEL(2, 16, 0),
+ .channel[3] = AD5868_CHANNEL(3, 16, 0),
+ .int_vref_mv = 2500,
+ },
+};
+
+
+static int __devinit ad5686_probe(struct spi_device *spi)
+{
+ struct ad5686_state *st;
+ struct iio_dev *indio_dev;
+ int ret, regdone = 0, voltage_uv = 0;
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL)
+ return -ENOMEM;
+
+ st = iio_priv(indio_dev);
+ spi_set_drvdata(spi, indio_dev);
+
+ st->reg = regulator_get(&spi->dev, "vcc");
+ if (!IS_ERR(st->reg)) {
+ ret = regulator_enable(st->reg);
+ if (ret)
+ goto error_put_reg;
+
+ voltage_uv = regulator_get_voltage(st->reg);
+ }
+
+ st->chip_info =
+ &ad5686_chip_info_tbl[spi_get_device_id(spi)->driver_data];
+
+ if (voltage_uv)
+ st->vref_mv = voltage_uv / 1000;
+ else
+ st->vref_mv = st->chip_info->int_vref_mv;
+
+ st->spi = spi;
+
+ /* Set all the power down mode for all channels to 1K pulldown */
+ st->pwr_down_mode = 0x55;
+
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->name = spi_get_device_id(spi)->name;
+ indio_dev->info = &ad5686_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->channels = st->chip_info->channel;
+ indio_dev->num_channels = AD5686_DAC_CHANNELS;
+
+ regdone = 1;
+ ret = ad5686_spi_write(st, AD5686_CMD_INTERNAL_REFER_SETUP, 0,
+ !!voltage_uv, 0);
+ if (ret)
+ goto error_disable_reg;
+
+ ret = iio_device_register(indio_dev);
+ if (ret)
+ goto error_disable_reg;
+
+ return 0;
+
+error_disable_reg:
+ if (!IS_ERR(st->reg))
+ regulator_disable(st->reg);
+error_put_reg:
+ if (!IS_ERR(st->reg))
+ regulator_put(st->reg);
+
+ iio_device_free(indio_dev);
+
+ return ret;
+}
+
+static int __devexit ad5686_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+ struct ad5686_state *st = iio_priv(indio_dev);
+
+ iio_device_unregister(indio_dev);
+ if (!IS_ERR(st->reg)) {
+ regulator_disable(st->reg);
+ regulator_put(st->reg);
+ }
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct spi_device_id ad5686_id[] = {
+ {"ad5684", ID_AD5684},
+ {"ad5685", ID_AD5685},
+ {"ad5686", ID_AD5686},
+ {}
+};
+MODULE_DEVICE_TABLE(spi, ad5686_id);
+
+static struct spi_driver ad5686_driver = {
+ .driver = {
+ .name = "ad5686",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5686_probe,
+ .remove = __devexit_p(ad5686_remove),
+ .id_table = ad5686_id,
+};
+module_spi_driver(ad5686_driver);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("Analog Devices AD5686/85/84 DAC");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/*
+ * Analog devices AD5764, AD5764R, AD5744, AD5744R quad-channel
+ * Digital to Analog Converters driver
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/regulator/consumer.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define AD5764_REG_SF_NOP 0x0
+#define AD5764_REG_SF_CONFIG 0x1
+#define AD5764_REG_SF_CLEAR 0x4
+#define AD5764_REG_SF_LOAD 0x5
+#define AD5764_REG_DATA(x) ((2 << 3) | (x))
+#define AD5764_REG_COARSE_GAIN(x) ((3 << 3) | (x))
+#define AD5764_REG_FINE_GAIN(x) ((4 << 3) | (x))
+#define AD5764_REG_OFFSET(x) ((5 << 3) | (x))
+
+#define AD5764_NUM_CHANNELS 4
+
+/**
+ * struct ad5764_chip_info - chip specific information
+ * @int_vref: Value of the internal reference voltage in uV - 0 if external
+ * reference voltage is used
+ * @channel channel specification
+*/
+
+struct ad5764_chip_info {
+ unsigned long int_vref;
+ const struct iio_chan_spec *channels;
+};
+
+/**
+ * struct ad5764_state - driver instance specific data
+ * @spi: spi_device
+ * @chip_info: chip info
+ * @vref_reg: vref supply regulators
+ * @data: spi transfer buffers
+ */
+
+struct ad5764_state {
+ struct spi_device *spi;
+ const struct ad5764_chip_info *chip_info;
+ struct regulator_bulk_data vref_reg[2];
+
+ /*
+ * DMA (thus cache coherency maintenance) requires the
+ * transfer buffers to live in their own cache lines.
+ */
+ union {
+ __be32 d32;
+ u8 d8[4];
+ } data[2] ____cacheline_aligned;
+};
+
+enum ad5764_type {
+ ID_AD5744,
+ ID_AD5744R,
+ ID_AD5764,
+ ID_AD5764R,
+};
+
+#define AD5764_CHANNEL(_chan, _bits) { \
+ .type = IIO_VOLTAGE, \
+ .indexed = 1, \
+ .output = 1, \
+ .channel = (_chan), \
+ .address = (_chan), \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+ IIO_CHAN_INFO_OFFSET_SHARED_BIT | \
+ IIO_CHAN_INFO_SCALE_SEPARATE_BIT | \
+ IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT | \
+ IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, \
+ .scan_type = IIO_ST('u', (_bits), 16, 16 - (_bits)) \
+}
+
+#define DECLARE_AD5764_CHANNELS(_name, _bits) \
+const struct iio_chan_spec _name##_channels[] = { \
+ AD5764_CHANNEL(0, (_bits)), \
+ AD5764_CHANNEL(1, (_bits)), \
+ AD5764_CHANNEL(2, (_bits)), \
+ AD5764_CHANNEL(3, (_bits)), \
+};
+
+static DECLARE_AD5764_CHANNELS(ad5764, 16);
+static DECLARE_AD5764_CHANNELS(ad5744, 14);
+
+static const struct ad5764_chip_info ad5764_chip_infos[] = {
+ [ID_AD5744] = {
+ .int_vref = 0,
+ .channels = ad5744_channels,
+ },
+ [ID_AD5744R] = {
+ .int_vref = 5000000,
+ .channels = ad5744_channels,
+ },
+ [ID_AD5764] = {
+ .int_vref = 0,
+ .channels = ad5764_channels,
+ },
+ [ID_AD5764R] = {
+ .int_vref = 5000000,
+ .channels = ad5764_channels,
+ },
+};
+
+static int ad5764_write(struct iio_dev *indio_dev, unsigned int reg,
+ unsigned int val)
+{
+ struct ad5764_state *st = iio_priv(indio_dev);
+ int ret;
+
+ mutex_lock(&indio_dev->mlock);
+ st->data[0].d32 = cpu_to_be32((reg << 16) | val);
+
+ ret = spi_write(st->spi, &st->data[0].d8[1], 3);
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static int ad5764_read(struct iio_dev *indio_dev, unsigned int reg,
+ unsigned int *val)
+{
+ struct ad5764_state *st = iio_priv(indio_dev);
+ struct spi_message m;
+ int ret;
+ struct spi_transfer t[] = {
+ {
+ .tx_buf = &st->data[0].d8[1],
+ .len = 3,
+ .cs_change = 1,
+ }, {
+ .rx_buf = &st->data[1].d8[1],
+ .len = 3,
+ },
+ };
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t[0], &m);
+ spi_message_add_tail(&t[1], &m);
+
+ mutex_lock(&indio_dev->mlock);
+
+ st->data[0].d32 = cpu_to_be32((1 << 23) | (reg << 16));
+
+ ret = spi_sync(st->spi, &m);
+ if (ret >= 0)
+ *val = be32_to_cpu(st->data[1].d32) & 0xffff;
+
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static int ad5764_chan_info_to_reg(struct iio_chan_spec const *chan, long info)
+{
+ switch (info) {
+ case 0:
+ return AD5764_REG_DATA(chan->address);
+ case IIO_CHAN_INFO_CALIBBIAS:
+ return AD5764_REG_OFFSET(chan->address);
+ case IIO_CHAN_INFO_CALIBSCALE:
+ return AD5764_REG_FINE_GAIN(chan->address);
+ default:
+ break;
+ }
+
+ return 0;
+}
+
+static int ad5764_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan, int val, int val2, long info)
+{
+ const int max_val = (1 << chan->scan_type.realbits);
+ unsigned int reg;
+
+ switch (info) {
+ case IIO_CHAN_INFO_RAW:
+ if (val >= max_val || val < 0)
+ return -EINVAL;
+ val <<= chan->scan_type.shift;
+ break;
+ case IIO_CHAN_INFO_CALIBBIAS:
+ if (val >= 128 || val < -128)
+ return -EINVAL;
+ break;
+ case IIO_CHAN_INFO_CALIBSCALE:
+ if (val >= 32 || val < -32)
+ return -EINVAL;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ reg = ad5764_chan_info_to_reg(chan, info);
+ return ad5764_write(indio_dev, reg, (u16)val);
+}
+
+static int ad5764_get_channel_vref(struct ad5764_state *st,
+ unsigned int channel)
+{
+ if (st->chip_info->int_vref)
+ return st->chip_info->int_vref;
+ else
+ return regulator_get_voltage(st->vref_reg[channel / 2].consumer);
+}
+
+static int ad5764_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan, int *val, int *val2, long info)
+{
+ struct ad5764_state *st = iio_priv(indio_dev);
+ unsigned long scale_uv;
+ unsigned int reg;
+ int vref;
+ int ret;
+
+ switch (info) {
+ case IIO_CHAN_INFO_RAW:
+ reg = AD5764_REG_DATA(chan->address);
+ ret = ad5764_read(indio_dev, reg, val);
+ if (ret < 0)
+ return ret;
+ *val >>= chan->scan_type.shift;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_CALIBBIAS:
+ reg = AD5764_REG_OFFSET(chan->address);
+ ret = ad5764_read(indio_dev, reg, val);
+ if (ret < 0)
+ return ret;
+ *val = sign_extend32(*val, 7);
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_CALIBSCALE:
+ reg = AD5764_REG_FINE_GAIN(chan->address);
+ ret = ad5764_read(indio_dev, reg, val);
+ if (ret < 0)
+ return ret;
+ *val = sign_extend32(*val, 5);
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_SCALE:
+ /* vout = 4 * vref + ((dac_code / 65535) - 0.5) */
+ vref = ad5764_get_channel_vref(st, chan->channel);
+ if (vref < 0)
+ return vref;
+
+ scale_uv = (vref * 4 * 100) >> chan->scan_type.realbits;
+ *val = scale_uv / 100000;
+ *val2 = (scale_uv % 100000) * 10;
+ return IIO_VAL_INT_PLUS_MICRO;
+ case IIO_CHAN_INFO_OFFSET:
+ *val = -(1 << chan->scan_type.realbits) / 2;
+ return IIO_VAL_INT;
+ }
+
+ return -EINVAL;
+}
+
+static const struct iio_info ad5764_info = {
+ .read_raw = ad5764_read_raw,
+ .write_raw = ad5764_write_raw,
+ .driver_module = THIS_MODULE,
+};
+
+static int __devinit ad5764_probe(struct spi_device *spi)
+{
+ enum ad5764_type type = spi_get_device_id(spi)->driver_data;
+ struct iio_dev *indio_dev;
+ struct ad5764_state *st;
+ int ret;
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL) {
+ dev_err(&spi->dev, "Failed to allocate iio device\n");
+ return -ENOMEM;
+ }
+
+ st = iio_priv(indio_dev);
+ spi_set_drvdata(spi, indio_dev);
+
+ st->spi = spi;
+ st->chip_info = &ad5764_chip_infos[type];
+
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->name = spi_get_device_id(spi)->name;
+ indio_dev->info = &ad5764_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->num_channels = AD5764_NUM_CHANNELS;
+ indio_dev->channels = st->chip_info->channels;
+
+ if (st->chip_info->int_vref == 0) {
+ st->vref_reg[0].supply = "vrefAB";
+ st->vref_reg[1].supply = "vrefCD";
+
+ ret = regulator_bulk_get(&st->spi->dev,
+ ARRAY_SIZE(st->vref_reg), st->vref_reg);
+ if (ret) {
+ dev_err(&spi->dev, "Failed to request vref regulators: %d\n",
+ ret);
+ goto error_free;
+ }
+
+ ret = regulator_bulk_enable(ARRAY_SIZE(st->vref_reg),
+ st->vref_reg);
+ if (ret) {
+ dev_err(&spi->dev, "Failed to enable vref regulators: %d\n",
+ ret);
+ goto error_free_reg;
+ }
+ }
+
+ ret = iio_device_register(indio_dev);
+ if (ret) {
+ dev_err(&spi->dev, "Failed to register iio device: %d\n", ret);
+ goto error_disable_reg;
+ }
+
+ return 0;
+
+error_disable_reg:
+ if (st->chip_info->int_vref == 0)
+ regulator_bulk_disable(ARRAY_SIZE(st->vref_reg), st->vref_reg);
+error_free_reg:
+ if (st->chip_info->int_vref == 0)
+ regulator_bulk_free(ARRAY_SIZE(st->vref_reg), st->vref_reg);
+error_free:
+ iio_device_free(indio_dev);
+
+ return ret;
+}
+
+static int __devexit ad5764_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+ struct ad5764_state *st = iio_priv(indio_dev);
+
+ iio_device_unregister(indio_dev);
+
+ if (st->chip_info->int_vref == 0) {
+ regulator_bulk_disable(ARRAY_SIZE(st->vref_reg), st->vref_reg);
+ regulator_bulk_free(ARRAY_SIZE(st->vref_reg), st->vref_reg);
+ }
+
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct spi_device_id ad5764_ids[] = {
+ { "ad5744", ID_AD5744 },
+ { "ad5744r", ID_AD5744R },
+ { "ad5764", ID_AD5764 },
+ { "ad5764r", ID_AD5764R },
+ { }
+};
+MODULE_DEVICE_TABLE(spi, ad5764_ids);
+
+static struct spi_driver ad5764_driver = {
+ .driver = {
+ .name = "ad5764",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5764_probe,
+ .remove = __devexit_p(ad5764_remove),
+ .id_table = ad5764_ids,
+};
+module_spi_driver(ad5764_driver);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("Analog Devices AD5744/AD5744R/AD5764/AD5764R DAC");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/*
+ * AD5760, AD5780, AD5781, AD5790, AD5791 Voltage Output Digital to Analog
+ * Converter
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/fs.h>
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/regulator/consumer.h>
+#include <linux/module.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/iio/dac/ad5791.h>
+
+#define AD5791_RES_MASK(x) ((1 << (x)) - 1)
+#define AD5791_DAC_MASK AD5791_RES_MASK(20)
+#define AD5791_DAC_MSB (1 << 19)
+
+#define AD5791_CMD_READ (1 << 23)
+#define AD5791_CMD_WRITE (0 << 23)
+#define AD5791_ADDR(addr) ((addr) << 20)
+
+/* Registers */
+#define AD5791_ADDR_NOOP 0
+#define AD5791_ADDR_DAC0 1
+#define AD5791_ADDR_CTRL 2
+#define AD5791_ADDR_CLRCODE 3
+#define AD5791_ADDR_SW_CTRL 4
+
+/* Control Register */
+#define AD5791_CTRL_RBUF (1 << 1)
+#define AD5791_CTRL_OPGND (1 << 2)
+#define AD5791_CTRL_DACTRI (1 << 3)
+#define AD5791_CTRL_BIN2SC (1 << 4)
+#define AD5791_CTRL_SDODIS (1 << 5)
+#define AD5761_CTRL_LINCOMP(x) ((x) << 6)
+
+#define AD5791_LINCOMP_0_10 0
+#define AD5791_LINCOMP_10_12 1
+#define AD5791_LINCOMP_12_16 2
+#define AD5791_LINCOMP_16_19 3
+#define AD5791_LINCOMP_19_20 12
+
+#define AD5780_LINCOMP_0_10 0
+#define AD5780_LINCOMP_10_20 12
+
+/* Software Control Register */
+#define AD5791_SWCTRL_LDAC (1 << 0)
+#define AD5791_SWCTRL_CLR (1 << 1)
+#define AD5791_SWCTRL_RESET (1 << 2)
+
+#define AD5791_DAC_PWRDN_6K 0
+#define AD5791_DAC_PWRDN_3STATE 1
+
+/**
+ * struct ad5791_chip_info - chip specific information
+ * @get_lin_comp: function pointer to the device specific function
+ */
+
+struct ad5791_chip_info {
+ int (*get_lin_comp) (unsigned int span);
+};
+
+/**
+ * struct ad5791_state - driver instance specific data
+ * @us: spi_device
+ * @reg_vdd: positive supply regulator
+ * @reg_vss: negative supply regulator
+ * @chip_info: chip model specific constants
+ * @vref_mv: actual reference voltage used
+ * @vref_neg_mv: voltage of the negative supply
+ * @pwr_down_mode current power down mode
+ */
+
+struct ad5791_state {
+ struct spi_device *spi;
+ struct regulator *reg_vdd;
+ struct regulator *reg_vss;
+ const struct ad5791_chip_info *chip_info;
+ unsigned short vref_mv;
+ unsigned int vref_neg_mv;
+ unsigned ctrl;
+ unsigned pwr_down_mode;
+ bool pwr_down;
+};
+
+/**
+ * ad5791_supported_device_ids:
+ */
+
+enum ad5791_supported_device_ids {
+ ID_AD5760,
+ ID_AD5780,
+ ID_AD5781,
+ ID_AD5791,
+};
+
+static int ad5791_spi_write(struct spi_device *spi, u8 addr, u32 val)
+{
+ union {
+ u32 d32;
+ u8 d8[4];
+ } data;
+
+ data.d32 = cpu_to_be32(AD5791_CMD_WRITE |
+ AD5791_ADDR(addr) |
+ (val & AD5791_DAC_MASK));
+
+ return spi_write(spi, &data.d8[1], 3);
+}
+
+static int ad5791_spi_read(struct spi_device *spi, u8 addr, u32 *val)
+{
+ union {
+ u32 d32;
+ u8 d8[4];
+ } data[3];
+ int ret;
+ struct spi_message msg;
+ struct spi_transfer xfers[] = {
+ {
+ .tx_buf = &data[0].d8[1],
+ .bits_per_word = 8,
+ .len = 3,
+ .cs_change = 1,
+ }, {
+ .tx_buf = &data[1].d8[1],
+ .rx_buf = &data[2].d8[1],
+ .bits_per_word = 8,
+ .len = 3,
+ },
+ };
+
+ data[0].d32 = cpu_to_be32(AD5791_CMD_READ |
+ AD5791_ADDR(addr));
+ data[1].d32 = cpu_to_be32(AD5791_ADDR(AD5791_ADDR_NOOP));
+
+ spi_message_init(&msg);
+ spi_message_add_tail(&xfers[0], &msg);
+ spi_message_add_tail(&xfers[1], &msg);
+ ret = spi_sync(spi, &msg);
+
+ *val = be32_to_cpu(data[2].d32);
+
+ return ret;
+}
+
+static const char * const ad5791_powerdown_modes[] = {
+ "6kohm_to_gnd",
+ "three_state",
+};
+
+static int ad5791_get_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan)
+{
+ struct ad5791_state *st = iio_priv(indio_dev);
+
+ return st->pwr_down_mode;
+}
+
+static int ad5791_set_powerdown_mode(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan, unsigned int mode)
+{
+ struct ad5791_state *st = iio_priv(indio_dev);
+
+ st->pwr_down_mode = mode;
+
+ return 0;
+}
+
+static const struct iio_enum ad5791_powerdown_mode_enum = {
+ .items = ad5791_powerdown_modes,
+ .num_items = ARRAY_SIZE(ad5791_powerdown_modes),
+ .get = ad5791_get_powerdown_mode,
+ .set = ad5791_set_powerdown_mode,
+};
+
+static ssize_t ad5791_read_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, char *buf)
+{
+ struct ad5791_state *st = iio_priv(indio_dev);
+
+ return sprintf(buf, "%d\n", st->pwr_down);
+}
+
+static ssize_t ad5791_write_dac_powerdown(struct iio_dev *indio_dev,
+ uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
+ size_t len)
+{
+ bool pwr_down;
+ int ret;
+ struct ad5791_state *st = iio_priv(indio_dev);
+
+ ret = strtobool(buf, &pwr_down);
+ if (ret)
+ return ret;
+
+ if (!pwr_down) {
+ st->ctrl &= ~(AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
+ } else {
+ if (st->pwr_down_mode == AD5791_DAC_PWRDN_6K)
+ st->ctrl |= AD5791_CTRL_OPGND;
+ else if (st->pwr_down_mode == AD5791_DAC_PWRDN_3STATE)
+ st->ctrl |= AD5791_CTRL_DACTRI;
+ }
+ st->pwr_down = pwr_down;
+
+ ret = ad5791_spi_write(st->spi, AD5791_ADDR_CTRL, st->ctrl);
+
+ return ret ? ret : len;
+}
+
+static int ad5791_get_lin_comp(unsigned int span)
+{
+ if (span <= 10000)
+ return AD5791_LINCOMP_0_10;
+ else if (span <= 12000)
+ return AD5791_LINCOMP_10_12;
+ else if (span <= 16000)
+ return AD5791_LINCOMP_12_16;
+ else if (span <= 19000)
+ return AD5791_LINCOMP_16_19;
+ else
+ return AD5791_LINCOMP_19_20;
+}
+
+static int ad5780_get_lin_comp(unsigned int span)
+{
+ if (span <= 10000)
+ return AD5780_LINCOMP_0_10;
+ else
+ return AD5780_LINCOMP_10_20;
+}
+static const struct ad5791_chip_info ad5791_chip_info_tbl[] = {
+ [ID_AD5760] = {
+ .get_lin_comp = ad5780_get_lin_comp,
+ },
+ [ID_AD5780] = {
+ .get_lin_comp = ad5780_get_lin_comp,
+ },
+ [ID_AD5781] = {
+ .get_lin_comp = ad5791_get_lin_comp,
+ },
+ [ID_AD5791] = {
+ .get_lin_comp = ad5791_get_lin_comp,
+ },
+};
+
+static int ad5791_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val,
+ int *val2,
+ long m)
+{
+ struct ad5791_state *st = iio_priv(indio_dev);
+ u64 val64;
+ int ret;
+
+ switch (m) {
+ case IIO_CHAN_INFO_RAW:
+ ret = ad5791_spi_read(st->spi, chan->address, val);
+ if (ret)
+ return ret;
+ *val &= AD5791_DAC_MASK;
+ *val >>= chan->scan_type.shift;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_SCALE:
+ *val = 0;
+ *val2 = (((u64)st->vref_mv) * 1000000ULL) >> chan->scan_type.realbits;
+ return IIO_VAL_INT_PLUS_MICRO;
+ case IIO_CHAN_INFO_OFFSET:
+ val64 = (((u64)st->vref_neg_mv) << chan->scan_type.realbits);
+ do_div(val64, st->vref_mv);
+ *val = -val64;
+ return IIO_VAL_INT;
+ default:
+ return -EINVAL;
+ }
+
+};
+
+static const struct iio_chan_spec_ext_info ad5791_ext_info[] = {
+ {
+ .name = "powerdown",
+ .shared = true,
+ .read = ad5791_read_dac_powerdown,
+ .write = ad5791_write_dac_powerdown,
+ },
+ IIO_ENUM("powerdown_mode", true, &ad5791_powerdown_mode_enum),
+ IIO_ENUM_AVAILABLE("powerdown_mode", &ad5791_powerdown_mode_enum),
+ { },
+};
+
+#define AD5791_CHAN(bits, shift) { \
+ .type = IIO_VOLTAGE, \
+ .output = 1, \
+ .indexed = 1, \
+ .address = AD5791_ADDR_DAC0, \
+ .channel = 0, \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+ IIO_CHAN_INFO_SCALE_SHARED_BIT | \
+ IIO_CHAN_INFO_OFFSET_SHARED_BIT, \
+ .scan_type = IIO_ST('u', bits, 24, shift), \
+ .ext_info = ad5791_ext_info, \
+}
+
+static const struct iio_chan_spec ad5791_channels[] = {
+ [ID_AD5760] = AD5791_CHAN(16, 4),
+ [ID_AD5780] = AD5791_CHAN(18, 2),
+ [ID_AD5781] = AD5791_CHAN(18, 2),
+ [ID_AD5791] = AD5791_CHAN(20, 0)
+};
+
+static int ad5791_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val,
+ int val2,
+ long mask)
+{
+ struct ad5791_state *st = iio_priv(indio_dev);
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ val &= AD5791_RES_MASK(chan->scan_type.realbits);
+ val <<= chan->scan_type.shift;
+
+ return ad5791_spi_write(st->spi, chan->address, val);
+
+ default:
+ return -EINVAL;
+ }
+}
+
+static const struct iio_info ad5791_info = {
+ .read_raw = &ad5791_read_raw,
+ .write_raw = &ad5791_write_raw,
+ .driver_module = THIS_MODULE,
+};
+
+static int __devinit ad5791_probe(struct spi_device *spi)
+{
+ struct ad5791_platform_data *pdata = spi->dev.platform_data;
+ struct iio_dev *indio_dev;
+ struct ad5791_state *st;
+ int ret, pos_voltage_uv = 0, neg_voltage_uv = 0;
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL) {
+ ret = -ENOMEM;
+ goto error_ret;
+ }
+ st = iio_priv(indio_dev);
+ st->reg_vdd = regulator_get(&spi->dev, "vdd");
+ if (!IS_ERR(st->reg_vdd)) {
+ ret = regulator_enable(st->reg_vdd);
+ if (ret)
+ goto error_put_reg_pos;
+
+ pos_voltage_uv = regulator_get_voltage(st->reg_vdd);
+ }
+
+ st->reg_vss = regulator_get(&spi->dev, "vss");
+ if (!IS_ERR(st->reg_vss)) {
+ ret = regulator_enable(st->reg_vss);
+ if (ret)
+ goto error_put_reg_neg;
+
+ neg_voltage_uv = regulator_get_voltage(st->reg_vss);
+ }
+
+ st->pwr_down = true;
+ st->spi = spi;
+
+ if (!IS_ERR(st->reg_vss) && !IS_ERR(st->reg_vdd)) {
+ st->vref_mv = (pos_voltage_uv + neg_voltage_uv) / 1000;
+ st->vref_neg_mv = neg_voltage_uv / 1000;
+ } else if (pdata) {
+ st->vref_mv = pdata->vref_pos_mv + pdata->vref_neg_mv;
+ st->vref_neg_mv = pdata->vref_neg_mv;
+ } else {
+ dev_warn(&spi->dev, "reference voltage unspecified\n");
+ }
+
+ ret = ad5791_spi_write(spi, AD5791_ADDR_SW_CTRL, AD5791_SWCTRL_RESET);
+ if (ret)
+ goto error_disable_reg_neg;
+
+ st->chip_info = &ad5791_chip_info_tbl[spi_get_device_id(spi)
+ ->driver_data];
+
+
+ st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info->get_lin_comp(st->vref_mv))
+ | ((pdata && pdata->use_rbuf_gain2) ? 0 : AD5791_CTRL_RBUF) |
+ AD5791_CTRL_BIN2SC;
+
+ ret = ad5791_spi_write(spi, AD5791_ADDR_CTRL, st->ctrl |
+ AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
+ if (ret)
+ goto error_disable_reg_neg;
+
+ spi_set_drvdata(spi, indio_dev);
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->info = &ad5791_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->channels
+ = &ad5791_channels[spi_get_device_id(spi)->driver_data];
+ indio_dev->num_channels = 1;
+ indio_dev->name = spi_get_device_id(st->spi)->name;
+ ret = iio_device_register(indio_dev);
+ if (ret)
+ goto error_disable_reg_neg;
+
+ return 0;
+
+error_disable_reg_neg:
+ if (!IS_ERR(st->reg_vss))
+ regulator_disable(st->reg_vss);
+error_put_reg_neg:
+ if (!IS_ERR(st->reg_vss))
+ regulator_put(st->reg_vss);
+
+ if (!IS_ERR(st->reg_vdd))
+ regulator_disable(st->reg_vdd);
+error_put_reg_pos:
+ if (!IS_ERR(st->reg_vdd))
+ regulator_put(st->reg_vdd);
+ iio_device_free(indio_dev);
+error_ret:
+
+ return ret;
+}
+
+static int __devexit ad5791_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+ struct ad5791_state *st = iio_priv(indio_dev);
+
+ iio_device_unregister(indio_dev);
+ if (!IS_ERR(st->reg_vdd)) {
+ regulator_disable(st->reg_vdd);
+ regulator_put(st->reg_vdd);
+ }
+
+ if (!IS_ERR(st->reg_vss)) {
+ regulator_disable(st->reg_vss);
+ regulator_put(st->reg_vss);
+ }
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct spi_device_id ad5791_id[] = {
+ {"ad5760", ID_AD5760},
+ {"ad5780", ID_AD5780},
+ {"ad5781", ID_AD5781},
+ {"ad5790", ID_AD5791},
+ {"ad5791", ID_AD5791},
+ {}
+};
+MODULE_DEVICE_TABLE(spi, ad5791_id);
+
+static struct spi_driver ad5791_driver = {
+ .driver = {
+ .name = "ad5791",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad5791_probe,
+ .remove = __devexit_p(ad5791_remove),
+ .id_table = ad5791_id,
+};
+module_spi_driver(ad5791_driver);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/*
+ * max517.c - Support for Maxim MAX517, MAX518 and MAX519
+ *
+ * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/iio/dac/max517.h>
+
+#define MAX517_DRV_NAME "max517"
+
+/* Commands */
+#define COMMAND_CHANNEL0 0x00
+#define COMMAND_CHANNEL1 0x01 /* for MAX518 and MAX519 */
+#define COMMAND_PD 0x08 /* Power Down */
+
+enum max517_device_ids {
+ ID_MAX517,
+ ID_MAX518,
+ ID_MAX519,
+};
+
+struct max517_data {
+ struct i2c_client *client;
+ unsigned short vref_mv[2];
+};
+
+/*
+ * channel: bit 0: channel 1
+ * bit 1: channel 2
+ * (this way, it's possible to set both channels at once)
+ */
+static int max517_set_value(struct iio_dev *indio_dev,
+ long val, int channel)
+{
+ struct max517_data *data = iio_priv(indio_dev);
+ struct i2c_client *client = data->client;
+ u8 outbuf[2];
+ int res;
+
+ if (val < 0 || val > 255)
+ return -EINVAL;
+
+ outbuf[0] = channel;
+ outbuf[1] = val;
+
+ res = i2c_master_send(client, outbuf, 2);
+ if (res < 0)
+ return res;
+ else if (res != 2)
+ return -EIO;
+ else
+ return 0;
+}
+
+static int max517_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val,
+ int *val2,
+ long m)
+{
+ struct max517_data *data = iio_priv(indio_dev);
+ unsigned int scale_uv;
+
+ switch (m) {
+ case IIO_CHAN_INFO_SCALE:
+ /* Corresponds to Vref / 2^(bits) */
+ scale_uv = (data->vref_mv[chan->channel] * 1000) >> 8;
+ *val = scale_uv / 1000000;
+ *val2 = scale_uv % 1000000;
+ return IIO_VAL_INT_PLUS_MICRO;
+ default:
+ break;
+ }
+ return -EINVAL;
+}
+
+static int max517_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan, int val, int val2, long mask)
+{
+ int ret;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ ret = max517_set_value(indio_dev, val, chan->channel);
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int max517_suspend(struct device *dev)
+{
+ u8 outbuf = COMMAND_PD;
+
+ return i2c_master_send(to_i2c_client(dev), &outbuf, 1);
+}
+
+static int max517_resume(struct device *dev)
+{
+ u8 outbuf = 0;
+
+ return i2c_master_send(to_i2c_client(dev), &outbuf, 1);
+}
+
+static SIMPLE_DEV_PM_OPS(max517_pm_ops, max517_suspend, max517_resume);
+#define MAX517_PM_OPS (&max517_pm_ops)
+#else
+#define MAX517_PM_OPS NULL
+#endif
+
+static const struct iio_info max517_info = {
+ .read_raw = max517_read_raw,
+ .write_raw = max517_write_raw,
+ .driver_module = THIS_MODULE,
+};
+
+#define MAX517_CHANNEL(chan) { \
+ .type = IIO_VOLTAGE, \
+ .indexed = 1, \
+ .output = 1, \
+ .channel = (chan), \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+ IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \
+ .scan_type = IIO_ST('u', 8, 8, 0), \
+}
+
+static const struct iio_chan_spec max517_channels[] = {
+ MAX517_CHANNEL(0),
+ MAX517_CHANNEL(1)
+};
+
+static int __devinit max517_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct max517_data *data;
+ struct iio_dev *indio_dev;
+ struct max517_platform_data *platform_data = client->dev.platform_data;
+ int err;
+
+ indio_dev = iio_device_alloc(sizeof(*data));
+ if (indio_dev == NULL) {
+ err = -ENOMEM;
+ goto exit;
+ }
+ data = iio_priv(indio_dev);
+ i2c_set_clientdata(client, indio_dev);
+ data->client = client;
+
+ /* establish that the iio_dev is a child of the i2c device */
+ indio_dev->dev.parent = &client->dev;
+
+ /* reduced channel set for MAX517 */
+ if (id->driver_data == ID_MAX517)
+ indio_dev->num_channels = 1;
+ else
+ indio_dev->num_channels = 2;
+ indio_dev->channels = max517_channels;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->info = &max517_info;
+
+ /*
+ * Reference voltage on MAX518 and default is 5V, else take vref_mv
+ * from platform_data
+ */
+ if (id->driver_data == ID_MAX518 || !platform_data) {
+ data->vref_mv[0] = data->vref_mv[1] = 5000; /* mV */
+ } else {
+ data->vref_mv[0] = platform_data->vref_mv[0];
+ data->vref_mv[1] = platform_data->vref_mv[1];
+ }
+
+ err = iio_device_register(indio_dev);
+ if (err)
+ goto exit_free_device;
+
+ dev_info(&client->dev, "DAC registered\n");
+
+ return 0;
+
+exit_free_device:
+ iio_device_free(indio_dev);
+exit:
+ return err;
+}
+
+static int __devexit max517_remove(struct i2c_client *client)
+{
+ iio_device_unregister(i2c_get_clientdata(client));
+ iio_device_free(i2c_get_clientdata(client));
+
+ return 0;
+}
+
+static const struct i2c_device_id max517_id[] = {
+ { "max517", ID_MAX517 },
+ { "max518", ID_MAX518 },
+ { "max519", ID_MAX519 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, max517_id);
+
+static struct i2c_driver max517_driver = {
+ .driver = {
+ .name = MAX517_DRV_NAME,
+ .pm = MAX517_PM_OPS,
+ },
+ .probe = max517_probe,
+ .remove = __devexit_p(max517_remove),
+ .id_table = max517_id,
+};
+module_i2c_driver(max517_driver);
+
+MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
+MODULE_DESCRIPTION("MAX517/MAX518/MAX519 8-bit DAC");
+MODULE_LICENSE("GPL");
--- /dev/null
+/*
+ * mcp4725.c - Support for Microchip MCP4725
+ *
+ * Copyright (C) 2012 Peter Meerwald <pmeerw@pmeerw.net>
+ *
+ * Based on max517 by Roland Stigge <stigge@antcom.de>
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License. See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * driver for the Microchip I2C 12-bit digital-to-analog converter (DAC)
+ * (7-bit I2C slave address 0x60, the three LSBs can be configured in
+ * hardware)
+ *
+ * writing the DAC value to EEPROM is not supported
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#include <linux/iio/dac/mcp4725.h>
+
+#define MCP4725_DRV_NAME "mcp4725"
+
+struct mcp4725_data {
+ struct i2c_client *client;
+ u16 vref_mv;
+ u16 dac_value;
+};
+
+#ifdef CONFIG_PM_SLEEP
+static int mcp4725_suspend(struct device *dev)
+{
+ u8 outbuf[2];
+
+ outbuf[0] = 0x3 << 4; /* power-down bits, 500 kOhm resistor */
+ outbuf[1] = 0;
+
+ return i2c_master_send(to_i2c_client(dev), outbuf, 2);
+}
+
+static int mcp4725_resume(struct device *dev)
+{
+ struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+ struct mcp4725_data *data = iio_priv(indio_dev);
+ u8 outbuf[2];
+
+ /* restore previous DAC value */
+ outbuf[0] = (data->dac_value >> 8) & 0xf;
+ outbuf[1] = data->dac_value & 0xff;
+
+ return i2c_master_send(to_i2c_client(dev), outbuf, 2);
+}
+
+static SIMPLE_DEV_PM_OPS(mcp4725_pm_ops, mcp4725_suspend, mcp4725_resume);
+#define MCP4725_PM_OPS (&mcp4725_pm_ops)
+#else
+#define MCP4725_PM_OPS NULL
+#endif
+
+static const struct iio_chan_spec mcp4725_channel = {
+ .type = IIO_VOLTAGE,
+ .indexed = 1,
+ .output = 1,
+ .channel = 0,
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
+ IIO_CHAN_INFO_SCALE_SHARED_BIT,
+ .scan_type = IIO_ST('u', 12, 16, 0),
+};
+
+static int mcp4725_set_value(struct iio_dev *indio_dev, int val)
+{
+ struct mcp4725_data *data = iio_priv(indio_dev);
+ u8 outbuf[2];
+ int ret;
+
+ if (val >= (1 << 12) || val < 0)
+ return -EINVAL;
+
+ outbuf[0] = (val >> 8) & 0xf;
+ outbuf[1] = val & 0xff;
+
+ ret = i2c_master_send(data->client, outbuf, 2);
+ if (ret < 0)
+ return ret;
+ else if (ret != 2)
+ return -EIO;
+ else
+ return 0;
+}
+
+static int mcp4725_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val, int *val2, long mask)
+{
+ struct mcp4725_data *data = iio_priv(indio_dev);
+ unsigned long scale_uv;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ *val = data->dac_value;
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_SCALE:
+ scale_uv = (data->vref_mv * 1000) >> 12;
+ *val = scale_uv / 1000000;
+ *val2 = scale_uv % 1000000;
+ return IIO_VAL_INT_PLUS_MICRO;
+ }
+ return -EINVAL;
+}
+
+static int mcp4725_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val, int val2, long mask)
+{
+ struct mcp4725_data *data = iio_priv(indio_dev);
+ int ret;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ ret = mcp4725_set_value(indio_dev, val);
+ data->dac_value = val;
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ return ret;
+}
+
+static const struct iio_info mcp4725_info = {
+ .read_raw = mcp4725_read_raw,
+ .write_raw = mcp4725_write_raw,
+ .driver_module = THIS_MODULE,
+};
+
+static int __devinit mcp4725_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct mcp4725_data *data;
+ struct iio_dev *indio_dev;
+ struct mcp4725_platform_data *platform_data = client->dev.platform_data;
+ u8 inbuf[3];
+ int err;
+
+ if (!platform_data || !platform_data->vref_mv) {
+ dev_err(&client->dev, "invalid platform data");
+ err = -EINVAL;
+ goto exit;
+ }
+
+ indio_dev = iio_device_alloc(sizeof(*data));
+ if (indio_dev == NULL) {
+ err = -ENOMEM;
+ goto exit;
+ }
+ data = iio_priv(indio_dev);
+ i2c_set_clientdata(client, indio_dev);
+ data->client = client;
+
+ indio_dev->dev.parent = &client->dev;
+ indio_dev->info = &mcp4725_info;
+ indio_dev->channels = &mcp4725_channel;
+ indio_dev->num_channels = 1;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+
+ data->vref_mv = platform_data->vref_mv;
+
+ /* read current DAC value */
+ err = i2c_master_recv(client, inbuf, 3);
+ if (err < 0) {
+ dev_err(&client->dev, "failed to read DAC value");
+ goto exit_free_device;
+ }
+ data->dac_value = (inbuf[1] << 4) | (inbuf[2] >> 4);
+
+ err = iio_device_register(indio_dev);
+ if (err)
+ goto exit_free_device;
+
+ dev_info(&client->dev, "MCP4725 DAC registered\n");
+
+ return 0;
+
+exit_free_device:
+ iio_device_free(indio_dev);
+exit:
+ return err;
+}
+
+static int __devexit mcp4725_remove(struct i2c_client *client)
+{
+ struct iio_dev *indio_dev = i2c_get_clientdata(client);
+
+ iio_device_unregister(indio_dev);
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct i2c_device_id mcp4725_id[] = {
+ { "mcp4725", 0 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, mcp4725_id);
+
+static struct i2c_driver mcp4725_driver = {
+ .driver = {
+ .name = MCP4725_DRV_NAME,
+ .pm = MCP4725_PM_OPS,
+ },
+ .probe = mcp4725_probe,
+ .remove = __devexit_p(mcp4725_remove),
+ .id_table = mcp4725_id,
+};
+module_i2c_driver(mcp4725_driver);
+
+MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
+MODULE_DESCRIPTION("MCP4725 12-bit DAC");
+MODULE_LICENSE("GPL");
--- /dev/null
+#
+# Frequency
+# Direct Digital Synthesis drivers (DDS)
+# Clock Distribution device drivers
+# Phase-Locked Loop (PLL) frequency synthesizers
+#
+
+menu "Frequency Synthesizers DDS/PLL"
+
+menu "Clock Generator/Distribution"
+
+config AD9523
+ tristate "Analog Devices AD9523 Low Jitter Clock Generator"
+ depends on SPI
+ help
+ Say yes here to build support for Analog Devices AD9523 Low Jitter
+ Clock Generator. The driver provides direct access via sysfs.
+
+ To compile this driver as a module, choose M here: the
+ module will be called ad9523.
+
+endmenu
+
+#
+# Phase-Locked Loop (PLL) frequency synthesizers
+#
+
+menu "Phase-Locked Loop (PLL) frequency synthesizers"
+
+config ADF4350
+ tristate "Analog Devices ADF4350/ADF4351 Wideband Synthesizers"
+ depends on SPI
+ help
+ Say yes here to build support for Analog Devices ADF4350/ADF4351
+ Wideband Synthesizers. The driver provides direct access via sysfs.
+
+ To compile this driver as a module, choose M here: the
+ module will be called adf4350.
+
+endmenu
+endmenu
--- /dev/null
+#
+# Makefile iio/frequency
+#
+
+obj-$(CONFIG_AD9523) += ad9523.o
+obj-$(CONFIG_ADF4350) += adf4350.o
--- /dev/null
+/*
+ * AD9523 SPI Low Jitter Clock Generator
+ *
+ * Copyright 2012 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/spi/spi.h>
+#include <linux/regulator/consumer.h>
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/iio/frequency/ad9523.h>
+
+#define AD9523_READ (1 << 15)
+#define AD9523_WRITE (0 << 15)
+#define AD9523_CNT(x) (((x) - 1) << 13)
+#define AD9523_ADDR(x) ((x) & 0xFFF)
+
+#define AD9523_R1B (1 << 16)
+#define AD9523_R2B (2 << 16)
+#define AD9523_R3B (3 << 16)
+#define AD9523_TRANSF_LEN(x) ((x) >> 16)
+
+#define AD9523_SERIAL_PORT_CONFIG (AD9523_R1B | 0x0)
+#define AD9523_VERSION_REGISTER (AD9523_R1B | 0x2)
+#define AD9523_PART_REGISTER (AD9523_R1B | 0x3)
+#define AD9523_READBACK_CTRL (AD9523_R1B | 0x4)
+
+#define AD9523_EEPROM_CUSTOMER_VERSION_ID (AD9523_R2B | 0x6)
+
+#define AD9523_PLL1_REF_A_DIVIDER (AD9523_R2B | 0x11)
+#define AD9523_PLL1_REF_B_DIVIDER (AD9523_R2B | 0x13)
+#define AD9523_PLL1_REF_TEST_DIVIDER (AD9523_R1B | 0x14)
+#define AD9523_PLL1_FEEDBACK_DIVIDER (AD9523_R2B | 0x17)
+#define AD9523_PLL1_CHARGE_PUMP_CTRL (AD9523_R2B | 0x19)
+#define AD9523_PLL1_INPUT_RECEIVERS_CTRL (AD9523_R1B | 0x1A)
+#define AD9523_PLL1_REF_CTRL (AD9523_R1B | 0x1B)
+#define AD9523_PLL1_MISC_CTRL (AD9523_R1B | 0x1C)
+#define AD9523_PLL1_LOOP_FILTER_CTRL (AD9523_R1B | 0x1D)
+
+#define AD9523_PLL2_CHARGE_PUMP (AD9523_R1B | 0xF0)
+#define AD9523_PLL2_FEEDBACK_DIVIDER_AB (AD9523_R1B | 0xF1)
+#define AD9523_PLL2_CTRL (AD9523_R1B | 0xF2)
+#define AD9523_PLL2_VCO_CTRL (AD9523_R1B | 0xF3)
+#define AD9523_PLL2_VCO_DIVIDER (AD9523_R1B | 0xF4)
+#define AD9523_PLL2_LOOP_FILTER_CTRL (AD9523_R2B | 0xF6)
+#define AD9523_PLL2_R2_DIVIDER (AD9523_R1B | 0xF7)
+
+#define AD9523_CHANNEL_CLOCK_DIST(ch) (AD9523_R3B | (0x192 + 3 * ch))
+
+#define AD9523_PLL1_OUTPUT_CTRL (AD9523_R1B | 0x1BA)
+#define AD9523_PLL1_OUTPUT_CHANNEL_CTRL (AD9523_R1B | 0x1BB)
+
+#define AD9523_READBACK_0 (AD9523_R1B | 0x22C)
+#define AD9523_READBACK_1 (AD9523_R1B | 0x22D)
+
+#define AD9523_STATUS_SIGNALS (AD9523_R3B | 0x232)
+#define AD9523_POWER_DOWN_CTRL (AD9523_R1B | 0x233)
+#define AD9523_IO_UPDATE (AD9523_R1B | 0x234)
+
+#define AD9523_EEPROM_DATA_XFER_STATUS (AD9523_R1B | 0xB00)
+#define AD9523_EEPROM_ERROR_READBACK (AD9523_R1B | 0xB01)
+#define AD9523_EEPROM_CTRL1 (AD9523_R1B | 0xB02)
+#define AD9523_EEPROM_CTRL2 (AD9523_R1B | 0xB03)
+
+/* AD9523_SERIAL_PORT_CONFIG */
+
+#define AD9523_SER_CONF_SDO_ACTIVE (1 << 7)
+#define AD9523_SER_CONF_SOFT_RESET (1 << 5)
+
+/* AD9523_READBACK_CTRL */
+#define AD9523_READBACK_CTRL_READ_BUFFERED (1 << 0)
+
+/* AD9523_PLL1_CHARGE_PUMP_CTRL */
+#define AD9523_PLL1_CHARGE_PUMP_CURRENT_nA(x) (((x) / 500) & 0x7F)
+#define AD9523_PLL1_CHARGE_PUMP_TRISTATE (1 << 7)
+#define AD9523_PLL1_CHARGE_PUMP_MODE_NORMAL (3 << 8)
+#define AD9523_PLL1_CHARGE_PUMP_MODE_PUMP_DOWN (2 << 8)
+#define AD9523_PLL1_CHARGE_PUMP_MODE_PUMP_UP (1 << 8)
+#define AD9523_PLL1_CHARGE_PUMP_MODE_TRISTATE (0 << 8)
+#define AD9523_PLL1_BACKLASH_PW_MIN (0 << 10)
+#define AD9523_PLL1_BACKLASH_PW_LOW (1 << 10)
+#define AD9523_PLL1_BACKLASH_PW_HIGH (2 << 10)
+#define AD9523_PLL1_BACKLASH_PW_MAX (3 << 10)
+
+/* AD9523_PLL1_INPUT_RECEIVERS_CTRL */
+#define AD9523_PLL1_REF_TEST_RCV_EN (1 << 7)
+#define AD9523_PLL1_REFB_DIFF_RCV_EN (1 << 6)
+#define AD9523_PLL1_REFA_DIFF_RCV_EN (1 << 5)
+#define AD9523_PLL1_REFB_RCV_EN (1 << 4)
+#define AD9523_PLL1_REFA_RCV_EN (1 << 3)
+#define AD9523_PLL1_REFA_REFB_PWR_CTRL_EN (1 << 2)
+#define AD9523_PLL1_OSC_IN_CMOS_NEG_INP_EN (1 << 1)
+#define AD9523_PLL1_OSC_IN_DIFF_EN (1 << 0)
+
+/* AD9523_PLL1_REF_CTRL */
+#define AD9523_PLL1_BYPASS_REF_TEST_DIV_EN (1 << 7)
+#define AD9523_PLL1_BYPASS_FEEDBACK_DIV_EN (1 << 6)
+#define AD9523_PLL1_ZERO_DELAY_MODE_INT (1 << 5)
+#define AD9523_PLL1_ZERO_DELAY_MODE_EXT (0 << 5)
+#define AD9523_PLL1_OSC_IN_PLL_FEEDBACK_EN (1 << 4)
+#define AD9523_PLL1_ZD_IN_CMOS_NEG_INP_EN (1 << 3)
+#define AD9523_PLL1_ZD_IN_DIFF_EN (1 << 2)
+#define AD9523_PLL1_REFB_CMOS_NEG_INP_EN (1 << 1)
+#define AD9523_PLL1_REFA_CMOS_NEG_INP_EN (1 << 0)
+
+/* AD9523_PLL1_MISC_CTRL */
+#define AD9523_PLL1_REFB_INDEP_DIV_CTRL_EN (1 << 7)
+#define AD9523_PLL1_OSC_CTRL_FAIL_VCC_BY2_EN (1 << 6)
+#define AD9523_PLL1_REF_MODE(x) ((x) << 2)
+#define AD9523_PLL1_BYPASS_REFB_DIV (1 << 1)
+#define AD9523_PLL1_BYPASS_REFA_DIV (1 << 0)
+
+/* AD9523_PLL1_LOOP_FILTER_CTRL */
+#define AD9523_PLL1_LOOP_FILTER_RZERO(x) ((x) & 0xF)
+
+/* AD9523_PLL2_CHARGE_PUMP */
+#define AD9523_PLL2_CHARGE_PUMP_CURRENT_nA(x) ((x) / 3500)
+
+/* AD9523_PLL2_FEEDBACK_DIVIDER_AB */
+#define AD9523_PLL2_FB_NDIV_A_CNT(x) (((x) & 0x3) << 6)
+#define AD9523_PLL2_FB_NDIV_B_CNT(x) (((x) & 0x3F) << 0)
+#define AD9523_PLL2_FB_NDIV(a, b) (4 * (b) + (a))
+
+/* AD9523_PLL2_CTRL */
+#define AD9523_PLL2_CHARGE_PUMP_MODE_NORMAL (3 << 0)
+#define AD9523_PLL2_CHARGE_PUMP_MODE_PUMP_DOWN (2 << 0)
+#define AD9523_PLL2_CHARGE_PUMP_MODE_PUMP_UP (1 << 0)
+#define AD9523_PLL2_CHARGE_PUMP_MODE_TRISTATE (0 << 0)
+#define AD9523_PLL2_BACKLASH_PW_MIN (0 << 2)
+#define AD9523_PLL2_BACKLASH_PW_LOW (1 << 2)
+#define AD9523_PLL2_BACKLASH_PW_HIGH (2 << 2)
+#define AD9523_PLL2_BACKLASH_PW_MAX (3 << 1)
+#define AD9523_PLL2_BACKLASH_CTRL_EN (1 << 4)
+#define AD9523_PLL2_FREQ_DOUBLER_EN (1 << 5)
+#define AD9523_PLL2_LOCK_DETECT_PWR_DOWN_EN (1 << 7)
+
+/* AD9523_PLL2_VCO_CTRL */
+#define AD9523_PLL2_VCO_CALIBRATE (1 << 1)
+#define AD9523_PLL2_FORCE_VCO_MIDSCALE (1 << 2)
+#define AD9523_PLL2_FORCE_REFERENCE_VALID (1 << 3)
+#define AD9523_PLL2_FORCE_RELEASE_SYNC (1 << 4)
+
+/* AD9523_PLL2_VCO_DIVIDER */
+#define AD9523_PLL2_VCO_DIV_M1(x) ((((x) - 3) & 0x3) << 0)
+#define AD9523_PLL2_VCO_DIV_M2(x) ((((x) - 3) & 0x3) << 4)
+#define AD9523_PLL2_VCO_DIV_M1_PWR_DOWN_EN (1 << 2)
+#define AD9523_PLL2_VCO_DIV_M2_PWR_DOWN_EN (1 << 6)
+
+/* AD9523_PLL2_LOOP_FILTER_CTRL */
+#define AD9523_PLL2_LOOP_FILTER_CPOLE1(x) (((x) & 0x7) << 0)
+#define AD9523_PLL2_LOOP_FILTER_RZERO(x) (((x) & 0x7) << 3)
+#define AD9523_PLL2_LOOP_FILTER_RPOLE2(x) (((x) & 0x7) << 6)
+#define AD9523_PLL2_LOOP_FILTER_RZERO_BYPASS_EN (1 << 8)
+
+/* AD9523_PLL2_R2_DIVIDER */
+#define AD9523_PLL2_R2_DIVIDER_VAL(x) (((x) & 0x1F) << 0)
+
+/* AD9523_CHANNEL_CLOCK_DIST */
+#define AD9523_CLK_DIST_DIV_PHASE(x) (((x) & 0x3F) << 18)
+#define AD9523_CLK_DIST_DIV_PHASE_REV(x) ((ret >> 18) & 0x3F)
+#define AD9523_CLK_DIST_DIV(x) ((((x) - 1) & 0x3FF) << 8)
+#define AD9523_CLK_DIST_DIV_REV(x) (((ret >> 8) & 0x3FF) + 1)
+#define AD9523_CLK_DIST_INV_DIV_OUTPUT_EN (1 << 7)
+#define AD9523_CLK_DIST_IGNORE_SYNC_EN (1 << 6)
+#define AD9523_CLK_DIST_PWR_DOWN_EN (1 << 5)
+#define AD9523_CLK_DIST_LOW_PWR_MODE_EN (1 << 4)
+#define AD9523_CLK_DIST_DRIVER_MODE(x) (((x) & 0xF) << 0)
+
+/* AD9523_PLL1_OUTPUT_CTRL */
+#define AD9523_PLL1_OUTP_CTRL_VCO_DIV_SEL_CH6_M2 (1 << 7)
+#define AD9523_PLL1_OUTP_CTRL_VCO_DIV_SEL_CH5_M2 (1 << 6)
+#define AD9523_PLL1_OUTP_CTRL_VCO_DIV_SEL_CH4_M2 (1 << 5)
+#define AD9523_PLL1_OUTP_CTRL_CMOS_DRV_WEAK (1 << 4)
+#define AD9523_PLL1_OUTP_CTRL_OUTPUT_DIV_1 (0 << 0)
+#define AD9523_PLL1_OUTP_CTRL_OUTPUT_DIV_2 (1 << 0)
+#define AD9523_PLL1_OUTP_CTRL_OUTPUT_DIV_4 (2 << 0)
+#define AD9523_PLL1_OUTP_CTRL_OUTPUT_DIV_8 (4 << 0)
+#define AD9523_PLL1_OUTP_CTRL_OUTPUT_DIV_16 (8 << 0)
+
+/* AD9523_PLL1_OUTPUT_CHANNEL_CTRL */
+#define AD9523_PLL1_OUTP_CH_CTRL_OUTPUT_PWR_DOWN_EN (1 << 7)
+#define AD9523_PLL1_OUTP_CH_CTRL_VCO_DIV_SEL_CH9_M2 (1 << 6)
+#define AD9523_PLL1_OUTP_CH_CTRL_VCO_DIV_SEL_CH8_M2 (1 << 5)
+#define AD9523_PLL1_OUTP_CH_CTRL_VCO_DIV_SEL_CH7_M2 (1 << 4)
+#define AD9523_PLL1_OUTP_CH_CTRL_VCXO_SRC_SEL_CH3 (1 << 3)
+#define AD9523_PLL1_OUTP_CH_CTRL_VCXO_SRC_SEL_CH2 (1 << 2)
+#define AD9523_PLL1_OUTP_CH_CTRL_VCXO_SRC_SEL_CH1 (1 << 1)
+#define AD9523_PLL1_OUTP_CH_CTRL_VCXO_SRC_SEL_CH0 (1 << 0)
+
+/* AD9523_READBACK_0 */
+#define AD9523_READBACK_0_STAT_PLL2_REF_CLK (1 << 7)
+#define AD9523_READBACK_0_STAT_PLL2_FB_CLK (1 << 6)
+#define AD9523_READBACK_0_STAT_VCXO (1 << 5)
+#define AD9523_READBACK_0_STAT_REF_TEST (1 << 4)
+#define AD9523_READBACK_0_STAT_REFB (1 << 3)
+#define AD9523_READBACK_0_STAT_REFA (1 << 2)
+#define AD9523_READBACK_0_STAT_PLL2_LD (1 << 1)
+#define AD9523_READBACK_0_STAT_PLL1_LD (1 << 0)
+
+/* AD9523_READBACK_1 */
+#define AD9523_READBACK_1_HOLDOVER_ACTIVE (1 << 3)
+#define AD9523_READBACK_1_AUTOMODE_SEL_REFB (1 << 2)
+#define AD9523_READBACK_1_VCO_CALIB_IN_PROGRESS (1 << 0)
+
+/* AD9523_STATUS_SIGNALS */
+#define AD9523_STATUS_SIGNALS_SYNC_MAN_CTRL (1 << 16)
+#define AD9523_STATUS_MONITOR_01_PLL12_LOCKED (0x302)
+/* AD9523_POWER_DOWN_CTRL */
+#define AD9523_POWER_DOWN_CTRL_PLL1_PWR_DOWN (1 << 2)
+#define AD9523_POWER_DOWN_CTRL_PLL2_PWR_DOWN (1 << 1)
+#define AD9523_POWER_DOWN_CTRL_DIST_PWR_DOWN (1 << 0)
+
+/* AD9523_IO_UPDATE */
+#define AD9523_IO_UPDATE_EN (1 << 0)
+
+/* AD9523_EEPROM_DATA_XFER_STATUS */
+#define AD9523_EEPROM_DATA_XFER_IN_PROGRESS (1 << 0)
+
+/* AD9523_EEPROM_ERROR_READBACK */
+#define AD9523_EEPROM_ERROR_READBACK_FAIL (1 << 0)
+
+/* AD9523_EEPROM_CTRL1 */
+#define AD9523_EEPROM_CTRL1_SOFT_EEPROM (1 << 1)
+#define AD9523_EEPROM_CTRL1_EEPROM_WRITE_PROT_DIS (1 << 0)
+
+/* AD9523_EEPROM_CTRL2 */
+#define AD9523_EEPROM_CTRL2_REG2EEPROM (1 << 0)
+
+#define AD9523_NUM_CHAN 14
+#define AD9523_NUM_CHAN_ALT_CLK_SRC 10
+
+/* Helpers to avoid excess line breaks */
+#define AD_IFE(_pde, _a, _b) ((pdata->_pde) ? _a : _b)
+#define AD_IF(_pde, _a) AD_IFE(_pde, _a, 0)
+
+enum {
+ AD9523_STAT_PLL1_LD,
+ AD9523_STAT_PLL2_LD,
+ AD9523_STAT_REFA,
+ AD9523_STAT_REFB,
+ AD9523_STAT_REF_TEST,
+ AD9523_STAT_VCXO,
+ AD9523_STAT_PLL2_FB_CLK,
+ AD9523_STAT_PLL2_REF_CLK,
+ AD9523_SYNC,
+ AD9523_EEPROM,
+};
+
+enum {
+ AD9523_VCO1,
+ AD9523_VCO2,
+ AD9523_VCXO,
+ AD9523_NUM_CLK_SRC,
+};
+
+struct ad9523_state {
+ struct spi_device *spi;
+ struct regulator *reg;
+ struct ad9523_platform_data *pdata;
+ struct iio_chan_spec ad9523_channels[AD9523_NUM_CHAN];
+
+ unsigned long vcxo_freq;
+ unsigned long vco_freq;
+ unsigned long vco_out_freq[AD9523_NUM_CLK_SRC];
+ unsigned char vco_out_map[AD9523_NUM_CHAN_ALT_CLK_SRC];
+
+ /*
+ * DMA (thus cache coherency maintenance) requires the
+ * transfer buffers to live in their own cache lines.
+ */
+ union {
+ __be32 d32;
+ u8 d8[4];
+ } data[2] ____cacheline_aligned;
+};
+
+static int ad9523_read(struct iio_dev *indio_dev, unsigned addr)
+{
+ struct ad9523_state *st = iio_priv(indio_dev);
+ struct spi_message m;
+ int ret;
+
+ /* We encode the register size 1..3 bytes into the register address.
+ * On transfer we get the size from the register datum, and make sure
+ * the result is properly aligned.
+ */
+
+ struct spi_transfer t[] = {
+ {
+ .tx_buf = &st->data[0].d8[2],
+ .len = 2,
+ }, {
+ .rx_buf = &st->data[1].d8[4 - AD9523_TRANSF_LEN(addr)],
+ .len = AD9523_TRANSF_LEN(addr),
+ },
+ };
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t[0], &m);
+ spi_message_add_tail(&t[1], &m);
+
+ st->data[0].d32 = cpu_to_be32(AD9523_READ |
+ AD9523_CNT(AD9523_TRANSF_LEN(addr)) |
+ AD9523_ADDR(addr));
+
+ ret = spi_sync(st->spi, &m);
+ if (ret < 0)
+ dev_err(&indio_dev->dev, "read failed (%d)", ret);
+ else
+ ret = be32_to_cpu(st->data[1].d32) & (0xFFFFFF >>
+ (8 * (3 - AD9523_TRANSF_LEN(addr))));
+
+ return ret;
+};
+
+static int ad9523_write(struct iio_dev *indio_dev, unsigned addr, unsigned val)
+{
+ struct ad9523_state *st = iio_priv(indio_dev);
+ struct spi_message m;
+ int ret;
+ struct spi_transfer t[] = {
+ {
+ .tx_buf = &st->data[0].d8[2],
+ .len = 2,
+ }, {
+ .tx_buf = &st->data[1].d8[4 - AD9523_TRANSF_LEN(addr)],
+ .len = AD9523_TRANSF_LEN(addr),
+ },
+ };
+
+ spi_message_init(&m);
+ spi_message_add_tail(&t[0], &m);
+ spi_message_add_tail(&t[1], &m);
+
+ st->data[0].d32 = cpu_to_be32(AD9523_WRITE |
+ AD9523_CNT(AD9523_TRANSF_LEN(addr)) |
+ AD9523_ADDR(addr));
+ st->data[1].d32 = cpu_to_be32(val);
+
+ ret = spi_sync(st->spi, &m);
+
+ if (ret < 0)
+ dev_err(&indio_dev->dev, "write failed (%d)", ret);
+
+ return ret;
+}
+
+static int ad9523_io_update(struct iio_dev *indio_dev)
+{
+ return ad9523_write(indio_dev, AD9523_IO_UPDATE, AD9523_IO_UPDATE_EN);
+}
+
+static int ad9523_vco_out_map(struct iio_dev *indio_dev,
+ unsigned ch, unsigned out)
+{
+ struct ad9523_state *st = iio_priv(indio_dev);
+ int ret;
+ unsigned mask;
+
+ switch (ch) {
+ case 0 ... 3:
+ ret = ad9523_read(indio_dev, AD9523_PLL1_OUTPUT_CHANNEL_CTRL);
+ if (ret < 0)
+ break;
+ mask = AD9523_PLL1_OUTP_CH_CTRL_VCXO_SRC_SEL_CH0 << ch;
+ if (out) {
+ ret |= mask;
+ out = 2;
+ } else {
+ ret &= ~mask;
+ }
+ ret = ad9523_write(indio_dev,
+ AD9523_PLL1_OUTPUT_CHANNEL_CTRL, ret);
+ break;
+ case 4 ... 6:
+ ret = ad9523_read(indio_dev, AD9523_PLL1_OUTPUT_CTRL);
+ if (ret < 0)
+ break;
+ mask = AD9523_PLL1_OUTP_CTRL_VCO_DIV_SEL_CH4_M2 << (ch - 4);
+ if (out)
+ ret |= mask;
+ else
+ ret &= ~mask;
+ ret = ad9523_write(indio_dev, AD9523_PLL1_OUTPUT_CTRL, ret);
+ break;
+ case 7 ... 9:
+ ret = ad9523_read(indio_dev, AD9523_PLL1_OUTPUT_CHANNEL_CTRL);
+ if (ret < 0)
+ break;
+ mask = AD9523_PLL1_OUTP_CH_CTRL_VCO_DIV_SEL_CH7_M2 << (ch - 7);
+ if (out)
+ ret |= mask;
+ else
+ ret &= ~mask;
+ ret = ad9523_write(indio_dev,
+ AD9523_PLL1_OUTPUT_CHANNEL_CTRL, ret);
+ break;
+ default:
+ return 0;
+ }
+
+ st->vco_out_map[ch] = out;
+
+ return ret;
+}
+
+static int ad9523_set_clock_provider(struct iio_dev *indio_dev,
+ unsigned ch, unsigned long freq)
+{
+ struct ad9523_state *st = iio_priv(indio_dev);
+ long tmp1, tmp2;
+ bool use_alt_clk_src;
+
+ switch (ch) {
+ case 0 ... 3:
+ use_alt_clk_src = (freq == st->vco_out_freq[AD9523_VCXO]);
+ break;
+ case 4 ... 9:
+ tmp1 = st->vco_out_freq[AD9523_VCO1] / freq;
+ tmp2 = st->vco_out_freq[AD9523_VCO2] / freq;
+ tmp1 *= freq;
+ tmp2 *= freq;
+ use_alt_clk_src = (abs(tmp1 - freq) > abs(tmp2 - freq));
+ break;
+ default:
+ /* Ch 10..14: No action required, return success */
+ return 0;
+ }
+
+ return ad9523_vco_out_map(indio_dev, ch, use_alt_clk_src);
+}
+
+static int ad9523_store_eeprom(struct iio_dev *indio_dev)
+{
+ int ret, tmp;
+
+ ret = ad9523_write(indio_dev, AD9523_EEPROM_CTRL1,
+ AD9523_EEPROM_CTRL1_EEPROM_WRITE_PROT_DIS);
+ if (ret < 0)
+ return ret;
+ ret = ad9523_write(indio_dev, AD9523_EEPROM_CTRL2,
+ AD9523_EEPROM_CTRL2_REG2EEPROM);
+ if (ret < 0)
+ return ret;
+
+ tmp = 4;
+ do {
+ msleep(16);
+ ret = ad9523_read(indio_dev,
+ AD9523_EEPROM_DATA_XFER_STATUS);
+ if (ret < 0)
+ return ret;
+ } while ((ret & AD9523_EEPROM_DATA_XFER_IN_PROGRESS) && tmp--);
+
+ ret = ad9523_write(indio_dev, AD9523_EEPROM_CTRL1, 0);
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_read(indio_dev, AD9523_EEPROM_ERROR_READBACK);
+ if (ret < 0)
+ return ret;
+
+ if (ret & AD9523_EEPROM_ERROR_READBACK_FAIL) {
+ dev_err(&indio_dev->dev, "Verify EEPROM failed");
+ ret = -EIO;
+ }
+
+ return ret;
+}
+
+static int ad9523_sync(struct iio_dev *indio_dev)
+{
+ int ret, tmp;
+
+ ret = ad9523_read(indio_dev, AD9523_STATUS_SIGNALS);
+ if (ret < 0)
+ return ret;
+
+ tmp = ret;
+ tmp |= AD9523_STATUS_SIGNALS_SYNC_MAN_CTRL;
+
+ ret = ad9523_write(indio_dev, AD9523_STATUS_SIGNALS, tmp);
+ if (ret < 0)
+ return ret;
+
+ ad9523_io_update(indio_dev);
+ tmp &= ~AD9523_STATUS_SIGNALS_SYNC_MAN_CTRL;
+
+ ret = ad9523_write(indio_dev, AD9523_STATUS_SIGNALS, tmp);
+ if (ret < 0)
+ return ret;
+
+ return ad9523_io_update(indio_dev);
+}
+
+static ssize_t ad9523_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+ struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
+ bool state;
+ int ret;
+
+ ret = strtobool(buf, &state);
+ if (ret < 0)
+ return ret;
+
+ if (!state)
+ return 0;
+
+ mutex_lock(&indio_dev->mlock);
+ switch ((u32)this_attr->address) {
+ case AD9523_SYNC:
+ ret = ad9523_sync(indio_dev);
+ break;
+ case AD9523_EEPROM:
+ ret = ad9523_store_eeprom(indio_dev);
+ break;
+ default:
+ ret = -ENODEV;
+ }
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret ? ret : len;
+}
+
+static ssize_t ad9523_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+ struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
+ int ret;
+
+ mutex_lock(&indio_dev->mlock);
+ ret = ad9523_read(indio_dev, AD9523_READBACK_0);
+ if (ret >= 0) {
+ ret = sprintf(buf, "%d\n", !!(ret & (1 <<
+ (u32)this_attr->address)));
+ }
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static IIO_DEVICE_ATTR(pll1_locked, S_IRUGO,
+ ad9523_show,
+ NULL,
+ AD9523_STAT_PLL1_LD);
+
+static IIO_DEVICE_ATTR(pll2_locked, S_IRUGO,
+ ad9523_show,
+ NULL,
+ AD9523_STAT_PLL2_LD);
+
+static IIO_DEVICE_ATTR(pll1_reference_clk_a_present, S_IRUGO,
+ ad9523_show,
+ NULL,
+ AD9523_STAT_REFA);
+
+static IIO_DEVICE_ATTR(pll1_reference_clk_b_present, S_IRUGO,
+ ad9523_show,
+ NULL,
+ AD9523_STAT_REFB);
+
+static IIO_DEVICE_ATTR(pll1_reference_clk_test_present, S_IRUGO,
+ ad9523_show,
+ NULL,
+ AD9523_STAT_REF_TEST);
+
+static IIO_DEVICE_ATTR(vcxo_clk_present, S_IRUGO,
+ ad9523_show,
+ NULL,
+ AD9523_STAT_VCXO);
+
+static IIO_DEVICE_ATTR(pll2_feedback_clk_present, S_IRUGO,
+ ad9523_show,
+ NULL,
+ AD9523_STAT_PLL2_FB_CLK);
+
+static IIO_DEVICE_ATTR(pll2_reference_clk_present, S_IRUGO,
+ ad9523_show,
+ NULL,
+ AD9523_STAT_PLL2_REF_CLK);
+
+static IIO_DEVICE_ATTR(sync_dividers, S_IWUSR,
+ NULL,
+ ad9523_store,
+ AD9523_SYNC);
+
+static IIO_DEVICE_ATTR(store_eeprom, S_IWUSR,
+ NULL,
+ ad9523_store,
+ AD9523_EEPROM);
+
+static struct attribute *ad9523_attributes[] = {
+ &iio_dev_attr_sync_dividers.dev_attr.attr,
+ &iio_dev_attr_store_eeprom.dev_attr.attr,
+ &iio_dev_attr_pll2_feedback_clk_present.dev_attr.attr,
+ &iio_dev_attr_pll2_reference_clk_present.dev_attr.attr,
+ &iio_dev_attr_pll1_reference_clk_a_present.dev_attr.attr,
+ &iio_dev_attr_pll1_reference_clk_b_present.dev_attr.attr,
+ &iio_dev_attr_pll1_reference_clk_test_present.dev_attr.attr,
+ &iio_dev_attr_vcxo_clk_present.dev_attr.attr,
+ &iio_dev_attr_pll1_locked.dev_attr.attr,
+ &iio_dev_attr_pll2_locked.dev_attr.attr,
+ NULL,
+};
+
+static const struct attribute_group ad9523_attribute_group = {
+ .attrs = ad9523_attributes,
+};
+
+static int ad9523_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val,
+ int *val2,
+ long m)
+{
+ struct ad9523_state *st = iio_priv(indio_dev);
+ unsigned code;
+ int ret;
+
+ mutex_lock(&indio_dev->mlock);
+ ret = ad9523_read(indio_dev, AD9523_CHANNEL_CLOCK_DIST(chan->channel));
+ mutex_unlock(&indio_dev->mlock);
+
+ if (ret < 0)
+ return ret;
+
+ switch (m) {
+ case IIO_CHAN_INFO_RAW:
+ *val = !(ret & AD9523_CLK_DIST_PWR_DOWN_EN);
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_FREQUENCY:
+ *val = st->vco_out_freq[st->vco_out_map[chan->channel]] /
+ AD9523_CLK_DIST_DIV_REV(ret);
+ return IIO_VAL_INT;
+ case IIO_CHAN_INFO_PHASE:
+ code = (AD9523_CLK_DIST_DIV_PHASE_REV(ret) * 3141592) /
+ AD9523_CLK_DIST_DIV_REV(ret);
+ *val = code / 1000000;
+ *val2 = (code % 1000000) * 10;
+ return IIO_VAL_INT_PLUS_MICRO;
+ default:
+ return -EINVAL;
+ }
+};
+
+static int ad9523_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val,
+ int val2,
+ long mask)
+{
+ struct ad9523_state *st = iio_priv(indio_dev);
+ unsigned reg;
+ int ret, tmp, code;
+
+ mutex_lock(&indio_dev->mlock);
+ ret = ad9523_read(indio_dev, AD9523_CHANNEL_CLOCK_DIST(chan->channel));
+ if (ret < 0)
+ goto out;
+
+ reg = ret;
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ if (val)
+ reg &= ~AD9523_CLK_DIST_PWR_DOWN_EN;
+ else
+ reg |= AD9523_CLK_DIST_PWR_DOWN_EN;
+ break;
+ case IIO_CHAN_INFO_FREQUENCY:
+ if (val <= 0) {
+ ret = -EINVAL;
+ goto out;
+ }
+ ret = ad9523_set_clock_provider(indio_dev, chan->channel, val);
+ if (ret < 0)
+ goto out;
+ tmp = st->vco_out_freq[st->vco_out_map[chan->channel]] / val;
+ tmp = clamp(tmp, 1, 1024);
+ reg &= ~(0x3FF << 8);
+ reg |= AD9523_CLK_DIST_DIV(tmp);
+ break;
+ case IIO_CHAN_INFO_PHASE:
+ code = val * 1000000 + val2 % 1000000;
+ tmp = (code * AD9523_CLK_DIST_DIV_REV(ret)) / 3141592;
+ tmp = clamp(tmp, 0, 63);
+ reg &= ~AD9523_CLK_DIST_DIV_PHASE(~0);
+ reg |= AD9523_CLK_DIST_DIV_PHASE(tmp);
+ break;
+ default:
+ ret = -EINVAL;
+ goto out;
+ }
+
+ ret = ad9523_write(indio_dev, AD9523_CHANNEL_CLOCK_DIST(chan->channel),
+ reg);
+ if (ret < 0)
+ goto out;
+
+ ad9523_io_update(indio_dev);
+out:
+ mutex_unlock(&indio_dev->mlock);
+ return ret;
+}
+
+static int ad9523_reg_access(struct iio_dev *indio_dev,
+ unsigned reg, unsigned writeval,
+ unsigned *readval)
+{
+ int ret;
+
+ mutex_lock(&indio_dev->mlock);
+ if (readval == NULL) {
+ ret = ad9523_write(indio_dev, reg | AD9523_R1B, writeval);
+ ad9523_io_update(indio_dev);
+ } else {
+ ret = ad9523_read(indio_dev, reg | AD9523_R1B);
+ if (ret < 0)
+ goto out_unlock;
+ *readval = ret;
+ ret = 0;
+ }
+
+out_unlock:
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static const struct iio_info ad9523_info = {
+ .read_raw = &ad9523_read_raw,
+ .write_raw = &ad9523_write_raw,
+ .debugfs_reg_access = &ad9523_reg_access,
+ .attrs = &ad9523_attribute_group,
+ .driver_module = THIS_MODULE,
+};
+
+static int ad9523_setup(struct iio_dev *indio_dev)
+{
+ struct ad9523_state *st = iio_priv(indio_dev);
+ struct ad9523_platform_data *pdata = st->pdata;
+ struct ad9523_channel_spec *chan;
+ unsigned long active_mask = 0;
+ int ret, i;
+
+ ret = ad9523_write(indio_dev, AD9523_SERIAL_PORT_CONFIG,
+ AD9523_SER_CONF_SOFT_RESET |
+ (st->spi->mode & SPI_3WIRE ? 0 :
+ AD9523_SER_CONF_SDO_ACTIVE));
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_READBACK_CTRL,
+ AD9523_READBACK_CTRL_READ_BUFFERED);
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_io_update(indio_dev);
+ if (ret < 0)
+ return ret;
+
+ /*
+ * PLL1 Setup
+ */
+ ret = ad9523_write(indio_dev, AD9523_PLL1_REF_A_DIVIDER,
+ pdata->refa_r_div);
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL1_REF_B_DIVIDER,
+ pdata->refb_r_div);
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL1_FEEDBACK_DIVIDER,
+ pdata->pll1_feedback_div);
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL1_CHARGE_PUMP_CTRL,
+ AD9523_PLL1_CHARGE_PUMP_CURRENT_nA(pdata->
+ pll1_charge_pump_current_nA) |
+ AD9523_PLL1_CHARGE_PUMP_MODE_NORMAL |
+ AD9523_PLL1_BACKLASH_PW_MIN);
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL1_INPUT_RECEIVERS_CTRL,
+ AD_IF(refa_diff_rcv_en, AD9523_PLL1_REFA_RCV_EN) |
+ AD_IF(refb_diff_rcv_en, AD9523_PLL1_REFB_RCV_EN) |
+ AD_IF(osc_in_diff_en, AD9523_PLL1_OSC_IN_DIFF_EN) |
+ AD_IF(osc_in_cmos_neg_inp_en,
+ AD9523_PLL1_OSC_IN_CMOS_NEG_INP_EN) |
+ AD_IF(refa_diff_rcv_en, AD9523_PLL1_REFA_DIFF_RCV_EN) |
+ AD_IF(refb_diff_rcv_en, AD9523_PLL1_REFB_DIFF_RCV_EN));
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL1_REF_CTRL,
+ AD_IF(zd_in_diff_en, AD9523_PLL1_ZD_IN_DIFF_EN) |
+ AD_IF(zd_in_cmos_neg_inp_en,
+ AD9523_PLL1_ZD_IN_CMOS_NEG_INP_EN) |
+ AD_IF(zero_delay_mode_internal_en,
+ AD9523_PLL1_ZERO_DELAY_MODE_INT) |
+ AD_IF(osc_in_feedback_en, AD9523_PLL1_OSC_IN_PLL_FEEDBACK_EN) |
+ AD_IF(refa_cmos_neg_inp_en, AD9523_PLL1_REFA_CMOS_NEG_INP_EN) |
+ AD_IF(refb_cmos_neg_inp_en, AD9523_PLL1_REFB_CMOS_NEG_INP_EN));
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL1_MISC_CTRL,
+ AD9523_PLL1_REFB_INDEP_DIV_CTRL_EN |
+ AD9523_PLL1_REF_MODE(pdata->ref_mode));
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL1_LOOP_FILTER_CTRL,
+ AD9523_PLL1_LOOP_FILTER_RZERO(pdata->pll1_loop_filter_rzero));
+ if (ret < 0)
+ return ret;
+ /*
+ * PLL2 Setup
+ */
+
+ ret = ad9523_write(indio_dev, AD9523_PLL2_CHARGE_PUMP,
+ AD9523_PLL2_CHARGE_PUMP_CURRENT_nA(pdata->
+ pll2_charge_pump_current_nA));
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL2_FEEDBACK_DIVIDER_AB,
+ AD9523_PLL2_FB_NDIV_A_CNT(pdata->pll2_ndiv_a_cnt) |
+ AD9523_PLL2_FB_NDIV_B_CNT(pdata->pll2_ndiv_b_cnt));
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL2_CTRL,
+ AD9523_PLL2_CHARGE_PUMP_MODE_NORMAL |
+ AD9523_PLL2_BACKLASH_CTRL_EN |
+ AD_IF(pll2_freq_doubler_en, AD9523_PLL2_FREQ_DOUBLER_EN));
+ if (ret < 0)
+ return ret;
+
+ st->vco_freq = (pdata->vcxo_freq * (pdata->pll2_freq_doubler_en ? 2 : 1)
+ / pdata->pll2_r2_div) * AD9523_PLL2_FB_NDIV(pdata->
+ pll2_ndiv_a_cnt, pdata->pll2_ndiv_b_cnt);
+
+ ret = ad9523_write(indio_dev, AD9523_PLL2_VCO_CTRL,
+ AD9523_PLL2_VCO_CALIBRATE);
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL2_VCO_DIVIDER,
+ AD9523_PLL2_VCO_DIV_M1(pdata->pll2_vco_diff_m1) |
+ AD9523_PLL2_VCO_DIV_M2(pdata->pll2_vco_diff_m2) |
+ AD_IFE(pll2_vco_diff_m1, 0,
+ AD9523_PLL2_VCO_DIV_M1_PWR_DOWN_EN) |
+ AD_IFE(pll2_vco_diff_m2, 0,
+ AD9523_PLL2_VCO_DIV_M2_PWR_DOWN_EN));
+ if (ret < 0)
+ return ret;
+
+ if (pdata->pll2_vco_diff_m1)
+ st->vco_out_freq[AD9523_VCO1] =
+ st->vco_freq / pdata->pll2_vco_diff_m1;
+
+ if (pdata->pll2_vco_diff_m2)
+ st->vco_out_freq[AD9523_VCO2] =
+ st->vco_freq / pdata->pll2_vco_diff_m2;
+
+ st->vco_out_freq[AD9523_VCXO] = pdata->vcxo_freq;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL2_R2_DIVIDER,
+ AD9523_PLL2_R2_DIVIDER_VAL(pdata->pll2_r2_div));
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_PLL2_LOOP_FILTER_CTRL,
+ AD9523_PLL2_LOOP_FILTER_CPOLE1(pdata->cpole1) |
+ AD9523_PLL2_LOOP_FILTER_RZERO(pdata->rzero) |
+ AD9523_PLL2_LOOP_FILTER_RPOLE2(pdata->rpole2) |
+ AD_IF(rzero_bypass_en,
+ AD9523_PLL2_LOOP_FILTER_RZERO_BYPASS_EN));
+ if (ret < 0)
+ return ret;
+
+ for (i = 0; i < pdata->num_channels; i++) {
+ chan = &pdata->channels[i];
+ if (chan->channel_num < AD9523_NUM_CHAN) {
+ __set_bit(chan->channel_num, &active_mask);
+ ret = ad9523_write(indio_dev,
+ AD9523_CHANNEL_CLOCK_DIST(chan->channel_num),
+ AD9523_CLK_DIST_DRIVER_MODE(chan->driver_mode) |
+ AD9523_CLK_DIST_DIV(chan->channel_divider) |
+ AD9523_CLK_DIST_DIV_PHASE(chan->divider_phase) |
+ (chan->sync_ignore_en ?
+ AD9523_CLK_DIST_IGNORE_SYNC_EN : 0) |
+ (chan->divider_output_invert_en ?
+ AD9523_CLK_DIST_INV_DIV_OUTPUT_EN : 0) |
+ (chan->low_power_mode_en ?
+ AD9523_CLK_DIST_LOW_PWR_MODE_EN : 0) |
+ (chan->output_dis ?
+ AD9523_CLK_DIST_PWR_DOWN_EN : 0));
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_vco_out_map(indio_dev, chan->channel_num,
+ chan->use_alt_clock_src);
+ if (ret < 0)
+ return ret;
+
+ st->ad9523_channels[i].type = IIO_ALTVOLTAGE;
+ st->ad9523_channels[i].output = 1;
+ st->ad9523_channels[i].indexed = 1;
+ st->ad9523_channels[i].channel = chan->channel_num;
+ st->ad9523_channels[i].extend_name =
+ chan->extended_name;
+ st->ad9523_channels[i].info_mask =
+ IIO_CHAN_INFO_RAW_SEPARATE_BIT |
+ IIO_CHAN_INFO_PHASE_SEPARATE_BIT |
+ IIO_CHAN_INFO_FREQUENCY_SEPARATE_BIT;
+ }
+ }
+
+ for_each_clear_bit(i, &active_mask, AD9523_NUM_CHAN)
+ ad9523_write(indio_dev,
+ AD9523_CHANNEL_CLOCK_DIST(i),
+ AD9523_CLK_DIST_DRIVER_MODE(TRISTATE) |
+ AD9523_CLK_DIST_PWR_DOWN_EN);
+
+ ret = ad9523_write(indio_dev, AD9523_POWER_DOWN_CTRL, 0);
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_write(indio_dev, AD9523_STATUS_SIGNALS,
+ AD9523_STATUS_MONITOR_01_PLL12_LOCKED);
+ if (ret < 0)
+ return ret;
+
+ ret = ad9523_io_update(indio_dev);
+ if (ret < 0)
+ return ret;
+
+ return 0;
+}
+
+static int __devinit ad9523_probe(struct spi_device *spi)
+{
+ struct ad9523_platform_data *pdata = spi->dev.platform_data;
+ struct iio_dev *indio_dev;
+ struct ad9523_state *st;
+ int ret;
+
+ if (!pdata) {
+ dev_err(&spi->dev, "no platform data?\n");
+ return -EINVAL;
+ }
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL)
+ return -ENOMEM;
+
+ st = iio_priv(indio_dev);
+
+ st->reg = regulator_get(&spi->dev, "vcc");
+ if (!IS_ERR(st->reg)) {
+ ret = regulator_enable(st->reg);
+ if (ret)
+ goto error_put_reg;
+ }
+
+ spi_set_drvdata(spi, indio_dev);
+ st->spi = spi;
+ st->pdata = pdata;
+
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->name = (pdata->name[0] != 0) ? pdata->name :
+ spi_get_device_id(spi)->name;
+ indio_dev->info = &ad9523_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->channels = st->ad9523_channels;
+ indio_dev->num_channels = pdata->num_channels;
+
+ ret = ad9523_setup(indio_dev);
+ if (ret < 0)
+ goto error_disable_reg;
+
+ ret = iio_device_register(indio_dev);
+ if (ret)
+ goto error_disable_reg;
+
+ dev_info(&spi->dev, "probed %s\n", indio_dev->name);
+
+ return 0;
+
+error_disable_reg:
+ if (!IS_ERR(st->reg))
+ regulator_disable(st->reg);
+error_put_reg:
+ if (!IS_ERR(st->reg))
+ regulator_put(st->reg);
+
+ iio_device_free(indio_dev);
+
+ return ret;
+}
+
+static int __devexit ad9523_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+ struct ad9523_state *st = iio_priv(indio_dev);
+
+ iio_device_unregister(indio_dev);
+
+ if (!IS_ERR(st->reg)) {
+ regulator_disable(st->reg);
+ regulator_put(st->reg);
+ }
+
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct spi_device_id ad9523_id[] = {
+ {"ad9523-1", 9523},
+ {}
+};
+MODULE_DEVICE_TABLE(spi, ad9523_id);
+
+static struct spi_driver ad9523_driver = {
+ .driver = {
+ .name = "ad9523",
+ .owner = THIS_MODULE,
+ },
+ .probe = ad9523_probe,
+ .remove = __devexit_p(ad9523_remove),
+ .id_table = ad9523_id,
+};
+module_spi_driver(ad9523_driver);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("Analog Devices AD9523 CLOCKDIST/PLL");
+MODULE_LICENSE("GPL v2");
--- /dev/null
+/*
+ * ADF4350/ADF4351 SPI Wideband Synthesizer driver
+ *
+ * Copyright 2012 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/spi/spi.h>
+#include <linux/regulator/consumer.h>
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/gcd.h>
+#include <linux/gpio.h>
+#include <asm/div64.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/iio/frequency/adf4350.h>
+
+enum {
+ ADF4350_FREQ,
+ ADF4350_FREQ_REFIN,
+ ADF4350_FREQ_RESOLUTION,
+ ADF4350_PWRDOWN,
+};
+
+struct adf4350_state {
+ struct spi_device *spi;
+ struct regulator *reg;
+ struct adf4350_platform_data *pdata;
+ unsigned long clkin;
+ unsigned long chspc; /* Channel Spacing */
+ unsigned long fpfd; /* Phase Frequency Detector */
+ unsigned long min_out_freq;
+ unsigned r0_fract;
+ unsigned r0_int;
+ unsigned r1_mod;
+ unsigned r4_rf_div_sel;
+ unsigned long regs[6];
+ unsigned long regs_hw[6];
+
+ /*
+ * DMA (thus cache coherency maintenance) requires the
+ * transfer buffers to live in their own cache lines.
+ */
+ __be32 val ____cacheline_aligned;
+};
+
+static struct adf4350_platform_data default_pdata = {
+ .clkin = 122880000,
+ .channel_spacing = 10000,
+ .r2_user_settings = ADF4350_REG2_PD_POLARITY_POS |
+ ADF4350_REG2_CHARGE_PUMP_CURR_uA(2500),
+ .r3_user_settings = ADF4350_REG3_12BIT_CLKDIV_MODE(0),
+ .r4_user_settings = ADF4350_REG4_OUTPUT_PWR(3) |
+ ADF4350_REG4_MUTE_TILL_LOCK_EN,
+ .gpio_lock_detect = -1,
+};
+
+static int adf4350_sync_config(struct adf4350_state *st)
+{
+ int ret, i, doublebuf = 0;
+
+ for (i = ADF4350_REG5; i >= ADF4350_REG0; i--) {
+ if ((st->regs_hw[i] != st->regs[i]) ||
+ ((i == ADF4350_REG0) && doublebuf)) {
+
+ switch (i) {
+ case ADF4350_REG1:
+ case ADF4350_REG4:
+ doublebuf = 1;
+ break;
+ }
+
+ st->val = cpu_to_be32(st->regs[i] | i);
+ ret = spi_write(st->spi, &st->val, 4);
+ if (ret < 0)
+ return ret;
+ st->regs_hw[i] = st->regs[i];
+ dev_dbg(&st->spi->dev, "[%d] 0x%X\n",
+ i, (u32)st->regs[i] | i);
+ }
+ }
+ return 0;
+}
+
+static int adf4350_reg_access(struct iio_dev *indio_dev,
+ unsigned reg, unsigned writeval,
+ unsigned *readval)
+{
+ struct adf4350_state *st = iio_priv(indio_dev);
+ int ret;
+
+ if (reg > ADF4350_REG5)
+ return -EINVAL;
+
+ mutex_lock(&indio_dev->mlock);
+ if (readval == NULL) {
+ st->regs[reg] = writeval & ~(BIT(0) | BIT(1) | BIT(2));
+ ret = adf4350_sync_config(st);
+ } else {
+ *readval = st->regs_hw[reg];
+ ret = 0;
+ }
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret;
+}
+
+static int adf4350_tune_r_cnt(struct adf4350_state *st, unsigned short r_cnt)
+{
+ struct adf4350_platform_data *pdata = st->pdata;
+
+ do {
+ r_cnt++;
+ st->fpfd = (st->clkin * (pdata->ref_doubler_en ? 2 : 1)) /
+ (r_cnt * (pdata->ref_div2_en ? 2 : 1));
+ } while (st->fpfd > ADF4350_MAX_FREQ_PFD);
+
+ return r_cnt;
+}
+
+static int adf4350_set_freq(struct adf4350_state *st, unsigned long long freq)
+{
+ struct adf4350_platform_data *pdata = st->pdata;
+ u64 tmp;
+ u32 div_gcd, prescaler;
+ u16 mdiv, r_cnt = 0;
+ u8 band_sel_div;
+
+ if (freq > ADF4350_MAX_OUT_FREQ || freq < st->min_out_freq)
+ return -EINVAL;
+
+ if (freq > ADF4350_MAX_FREQ_45_PRESC) {
+ prescaler = ADF4350_REG1_PRESCALER;
+ mdiv = 75;
+ } else {
+ prescaler = 0;
+ mdiv = 23;
+ }
+
+ st->r4_rf_div_sel = 0;
+
+ while (freq < ADF4350_MIN_VCO_FREQ) {
+ freq <<= 1;
+ st->r4_rf_div_sel++;
+ }
+
+ /*
+ * Allow a predefined reference division factor
+ * if not set, compute our own
+ */
+ if (pdata->ref_div_factor)
+ r_cnt = pdata->ref_div_factor - 1;
+
+ do {
+ r_cnt = adf4350_tune_r_cnt(st, r_cnt);
+
+ st->r1_mod = st->fpfd / st->chspc;
+ while (st->r1_mod > ADF4350_MAX_MODULUS) {
+ r_cnt = adf4350_tune_r_cnt(st, r_cnt);
+ st->r1_mod = st->fpfd / st->chspc;
+ }
+
+ tmp = freq * (u64)st->r1_mod + (st->fpfd > 1);
+ do_div(tmp, st->fpfd); /* Div round closest (n + d/2)/d */
+ st->r0_fract = do_div(tmp, st->r1_mod);
+ st->r0_int = tmp;
+ } while (mdiv > st->r0_int);
+
+ band_sel_div = DIV_ROUND_UP(st->fpfd, ADF4350_MAX_BANDSEL_CLK);
+
+ if (st->r0_fract && st->r1_mod) {
+ div_gcd = gcd(st->r1_mod, st->r0_fract);
+ st->r1_mod /= div_gcd;
+ st->r0_fract /= div_gcd;
+ } else {
+ st->r0_fract = 0;
+ st->r1_mod = 1;
+ }
+
+ dev_dbg(&st->spi->dev, "VCO: %llu Hz, PFD %lu Hz\n"
+ "REF_DIV %d, R0_INT %d, R0_FRACT %d\n"
+ "R1_MOD %d, RF_DIV %d\nPRESCALER %s, BAND_SEL_DIV %d\n",
+ freq, st->fpfd, r_cnt, st->r0_int, st->r0_fract, st->r1_mod,
+ 1 << st->r4_rf_div_sel, prescaler ? "8/9" : "4/5",
+ band_sel_div);
+
+ st->regs[ADF4350_REG0] = ADF4350_REG0_INT(st->r0_int) |
+ ADF4350_REG0_FRACT(st->r0_fract);
+
+ st->regs[ADF4350_REG1] = ADF4350_REG1_PHASE(0) |
+ ADF4350_REG1_MOD(st->r1_mod) |
+ prescaler;
+
+ st->regs[ADF4350_REG2] =
+ ADF4350_REG2_10BIT_R_CNT(r_cnt) |
+ ADF4350_REG2_DOUBLE_BUFF_EN |
+ (pdata->ref_doubler_en ? ADF4350_REG2_RMULT2_EN : 0) |
+ (pdata->ref_div2_en ? ADF4350_REG2_RDIV2_EN : 0) |
+ (pdata->r2_user_settings & (ADF4350_REG2_PD_POLARITY_POS |
+ ADF4350_REG2_LDP_6ns | ADF4350_REG2_LDF_INT_N |
+ ADF4350_REG2_CHARGE_PUMP_CURR_uA(5000) |
+ ADF4350_REG2_MUXOUT(0x7) | ADF4350_REG2_NOISE_MODE(0x9)));
+
+ st->regs[ADF4350_REG3] = pdata->r3_user_settings &
+ (ADF4350_REG3_12BIT_CLKDIV(0xFFF) |
+ ADF4350_REG3_12BIT_CLKDIV_MODE(0x3) |
+ ADF4350_REG3_12BIT_CSR_EN |
+ ADF4351_REG3_CHARGE_CANCELLATION_EN |
+ ADF4351_REG3_ANTI_BACKLASH_3ns_EN |
+ ADF4351_REG3_BAND_SEL_CLOCK_MODE_HIGH);
+
+ st->regs[ADF4350_REG4] =
+ ADF4350_REG4_FEEDBACK_FUND |
+ ADF4350_REG4_RF_DIV_SEL(st->r4_rf_div_sel) |
+ ADF4350_REG4_8BIT_BAND_SEL_CLKDIV(band_sel_div) |
+ ADF4350_REG4_RF_OUT_EN |
+ (pdata->r4_user_settings &
+ (ADF4350_REG4_OUTPUT_PWR(0x3) |
+ ADF4350_REG4_AUX_OUTPUT_PWR(0x3) |
+ ADF4350_REG4_AUX_OUTPUT_EN |
+ ADF4350_REG4_AUX_OUTPUT_FUND |
+ ADF4350_REG4_MUTE_TILL_LOCK_EN));
+
+ st->regs[ADF4350_REG5] = ADF4350_REG5_LD_PIN_MODE_DIGITAL;
+
+ return adf4350_sync_config(st);
+}
+
+static ssize_t adf4350_write(struct iio_dev *indio_dev,
+ uintptr_t private,
+ const struct iio_chan_spec *chan,
+ const char *buf, size_t len)
+{
+ struct adf4350_state *st = iio_priv(indio_dev);
+ unsigned long long readin;
+ int ret;
+
+ ret = kstrtoull(buf, 10, &readin);
+ if (ret)
+ return ret;
+
+ mutex_lock(&indio_dev->mlock);
+ switch ((u32)private) {
+ case ADF4350_FREQ:
+ ret = adf4350_set_freq(st, readin);
+ break;
+ case ADF4350_FREQ_REFIN:
+ if (readin > ADF4350_MAX_FREQ_REFIN)
+ ret = -EINVAL;
+ else
+ st->clkin = readin;
+ break;
+ case ADF4350_FREQ_RESOLUTION:
+ if (readin == 0)
+ ret = -EINVAL;
+ else
+ st->chspc = readin;
+ break;
+ case ADF4350_PWRDOWN:
+ if (readin)
+ st->regs[ADF4350_REG2] |= ADF4350_REG2_POWER_DOWN_EN;
+ else
+ st->regs[ADF4350_REG2] &= ~ADF4350_REG2_POWER_DOWN_EN;
+
+ adf4350_sync_config(st);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret ? ret : len;
+}
+
+static ssize_t adf4350_read(struct iio_dev *indio_dev,
+ uintptr_t private,
+ const struct iio_chan_spec *chan,
+ char *buf)
+{
+ struct adf4350_state *st = iio_priv(indio_dev);
+ unsigned long long val;
+ int ret = 0;
+
+ mutex_lock(&indio_dev->mlock);
+ switch ((u32)private) {
+ case ADF4350_FREQ:
+ val = (u64)((st->r0_int * st->r1_mod) + st->r0_fract) *
+ (u64)st->fpfd;
+ do_div(val, st->r1_mod * (1 << st->r4_rf_div_sel));
+ /* PLL unlocked? return error */
+ if (gpio_is_valid(st->pdata->gpio_lock_detect))
+ if (!gpio_get_value(st->pdata->gpio_lock_detect)) {
+ dev_dbg(&st->spi->dev, "PLL un-locked\n");
+ ret = -EBUSY;
+ }
+ break;
+ case ADF4350_FREQ_REFIN:
+ val = st->clkin;
+ break;
+ case ADF4350_FREQ_RESOLUTION:
+ val = st->chspc;
+ break;
+ case ADF4350_PWRDOWN:
+ val = !!(st->regs[ADF4350_REG2] & ADF4350_REG2_POWER_DOWN_EN);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+ mutex_unlock(&indio_dev->mlock);
+
+ return ret < 0 ? ret : sprintf(buf, "%llu\n", val);
+}
+
+#define _ADF4350_EXT_INFO(_name, _ident) { \
+ .name = _name, \
+ .read = adf4350_read, \
+ .write = adf4350_write, \
+ .private = _ident, \
+}
+
+static const struct iio_chan_spec_ext_info adf4350_ext_info[] = {
+ /* Ideally we use IIO_CHAN_INFO_FREQUENCY, but there are
+ * values > 2^32 in order to support the entire frequency range
+ * in Hz. Using scale is a bit ugly.
+ */
+ _ADF4350_EXT_INFO("frequency", ADF4350_FREQ),
+ _ADF4350_EXT_INFO("frequency_resolution", ADF4350_FREQ_RESOLUTION),
+ _ADF4350_EXT_INFO("refin_frequency", ADF4350_FREQ_REFIN),
+ _ADF4350_EXT_INFO("powerdown", ADF4350_PWRDOWN),
+ { },
+};
+
+static const struct iio_chan_spec adf4350_chan = {
+ .type = IIO_ALTVOLTAGE,
+ .indexed = 1,
+ .output = 1,
+ .ext_info = adf4350_ext_info,
+};
+
+static const struct iio_info adf4350_info = {
+ .debugfs_reg_access = &adf4350_reg_access,
+ .driver_module = THIS_MODULE,
+};
+
+static int __devinit adf4350_probe(struct spi_device *spi)
+{
+ struct adf4350_platform_data *pdata = spi->dev.platform_data;
+ struct iio_dev *indio_dev;
+ struct adf4350_state *st;
+ int ret;
+
+ if (!pdata) {
+ dev_warn(&spi->dev, "no platform data? using default\n");
+
+ pdata = &default_pdata;
+ }
+
+ indio_dev = iio_device_alloc(sizeof(*st));
+ if (indio_dev == NULL)
+ return -ENOMEM;
+
+ st = iio_priv(indio_dev);
+
+ st->reg = regulator_get(&spi->dev, "vcc");
+ if (!IS_ERR(st->reg)) {
+ ret = regulator_enable(st->reg);
+ if (ret)
+ goto error_put_reg;
+ }
+
+ spi_set_drvdata(spi, indio_dev);
+ st->spi = spi;
+ st->pdata = pdata;
+
+ indio_dev->dev.parent = &spi->dev;
+ indio_dev->name = (pdata->name[0] != 0) ? pdata->name :
+ spi_get_device_id(spi)->name;
+
+ indio_dev->info = &adf4350_info;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+ indio_dev->channels = &adf4350_chan;
+ indio_dev->num_channels = 1;
+
+ st->chspc = pdata->channel_spacing;
+ st->clkin = pdata->clkin;
+
+ st->min_out_freq = spi_get_device_id(spi)->driver_data == 4351 ?
+ ADF4351_MIN_OUT_FREQ : ADF4350_MIN_OUT_FREQ;
+
+ memset(st->regs_hw, 0xFF, sizeof(st->regs_hw));
+
+ if (gpio_is_valid(pdata->gpio_lock_detect)) {
+ ret = gpio_request(pdata->gpio_lock_detect, indio_dev->name);
+ if (ret) {
+ dev_err(&spi->dev, "fail to request lock detect GPIO-%d",
+ pdata->gpio_lock_detect);
+ goto error_disable_reg;
+ }
+ gpio_direction_input(pdata->gpio_lock_detect);
+ }
+
+ if (pdata->power_up_frequency) {
+ ret = adf4350_set_freq(st, pdata->power_up_frequency);
+ if (ret)
+ goto error_free_gpio;
+ }
+
+ ret = iio_device_register(indio_dev);
+ if (ret)
+ goto error_free_gpio;
+
+ return 0;
+
+error_free_gpio:
+ if (gpio_is_valid(pdata->gpio_lock_detect))
+ gpio_free(pdata->gpio_lock_detect);
+
+error_disable_reg:
+ if (!IS_ERR(st->reg))
+ regulator_disable(st->reg);
+error_put_reg:
+ if (!IS_ERR(st->reg))
+ regulator_put(st->reg);
+
+ iio_device_free(indio_dev);
+
+ return ret;
+}
+
+static int __devexit adf4350_remove(struct spi_device *spi)
+{
+ struct iio_dev *indio_dev = spi_get_drvdata(spi);
+ struct adf4350_state *st = iio_priv(indio_dev);
+ struct regulator *reg = st->reg;
+
+ st->regs[ADF4350_REG2] |= ADF4350_REG2_POWER_DOWN_EN;
+ adf4350_sync_config(st);
+
+ iio_device_unregister(indio_dev);
+
+ if (!IS_ERR(reg)) {
+ regulator_disable(reg);
+ regulator_put(reg);
+ }
+
+ if (gpio_is_valid(st->pdata->gpio_lock_detect))
+ gpio_free(st->pdata->gpio_lock_detect);
+
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static const struct spi_device_id adf4350_id[] = {
+ {"adf4350", 4350},
+ {"adf4351", 4351},
+ {}
+};
+
+static struct spi_driver adf4350_driver = {
+ .driver = {
+ .name = "adf4350",
+ .owner = THIS_MODULE,
+ },
+ .probe = adf4350_probe,
+ .remove = __devexit_p(adf4350_remove),
+ .id_table = adf4350_id,
+};
+module_spi_driver(adf4350_driver);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("Analog Devices ADF4350/ADF4351 PLL");
+MODULE_LICENSE("GPL v2");
if (channels) {
/* new magic */
for (i = 0; i < num_channels; i++) {
+ if (channels[i].scan_index < 0)
+ continue;
+
/* Establish necessary mask length */
if (channels[i].scan_index >
(int)indio_dev->masklength - 1)
buffer->scan_mask);
else
indio_dev->active_scan_mask = buffer->scan_mask;
+
+ if (indio_dev->active_scan_mask == NULL)
+ return -EINVAL;
+
iio_update_demux(indio_dev);
if (indio_dev->info->update_scan_mode)
this_attr->c, buf, len);
}
+ssize_t iio_enum_available_read(struct iio_dev *indio_dev,
+ uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
+{
+ const struct iio_enum *e = (const struct iio_enum *)priv;
+ unsigned int i;
+ size_t len = 0;
+
+ if (!e->num_items)
+ return 0;
+
+ for (i = 0; i < e->num_items; ++i)
+ len += scnprintf(buf + len, PAGE_SIZE - len, "%s ", e->items[i]);
+
+ /* replace last space with a newline */
+ buf[len - 1] = '\n';
+
+ return len;
+}
+EXPORT_SYMBOL_GPL(iio_enum_available_read);
+
+ssize_t iio_enum_read(struct iio_dev *indio_dev,
+ uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
+{
+ const struct iio_enum *e = (const struct iio_enum *)priv;
+ int i;
+
+ if (!e->get)
+ return -EINVAL;
+
+ i = e->get(indio_dev, chan);
+ if (i < 0)
+ return i;
+ else if (i >= e->num_items)
+ return -EINVAL;
+
+ return sprintf(buf, "%s\n", e->items[i]);
+}
+EXPORT_SYMBOL_GPL(iio_enum_read);
+
+ssize_t iio_enum_write(struct iio_dev *indio_dev,
+ uintptr_t priv, const struct iio_chan_spec *chan, const char *buf,
+ size_t len)
+{
+ const struct iio_enum *e = (const struct iio_enum *)priv;
+ unsigned int i;
+ int ret;
+
+ if (!e->set)
+ return -EINVAL;
+
+ for (i = 0; i < e->num_items; i++) {
+ if (sysfs_streq(buf, e->items[i]))
+ break;
+ }
+
+ if (i == e->num_items)
+ return -EINVAL;
+
+ ret = e->set(indio_dev, chan, i);
+ return ret ? ret : len;
+}
+EXPORT_SYMBOL_GPL(iio_enum_write);
+
static ssize_t iio_read_channel_info(struct device *dev,
struct device_attribute *attr,
char *buf)
struct device_attribute *attr,
char *buf)
{
- struct iio_trigger *trig = dev_get_drvdata(dev);
+ struct iio_trigger *trig = to_iio_trigger(dev);
return sprintf(buf, "%s\n", trig->name);
}
trig->dev.type = &iio_trig_type;
trig->dev.bus = &iio_bus_type;
device_initialize(&trig->dev);
- dev_set_drvdata(&trig->dev, (void *)trig);
mutex_init(&trig->pool_lock);
trig->subirq_base
--- /dev/null
+ /*
+ * Copyright (c) 2012 Analog Devices, Inc.
+ * Author: Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * 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/kernel.h>
+#include <linux/export.h>
+#include <linux/module.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/kfifo_buf.h>
+#include <linux/iio/triggered_buffer.h>
+#include <linux/iio/trigger_consumer.h>
+
+static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
+ .preenable = &iio_sw_buffer_preenable,
+ .postenable = &iio_triggered_buffer_postenable,
+ .predisable = &iio_triggered_buffer_predisable,
+};
+
+/**
+ * iio_triggered_buffer_setup() - Setup triggered buffer and pollfunc
+ * @indio_dev: IIO device structure
+ * @pollfunc_bh: Function which will be used as pollfunc bottom half
+ * @pollfunc_th: Function which will be used as pollfunc top half
+ * @setup_ops: Buffer setup functions to use for this device.
+ * If NULL the default setup functions for triggered
+ * buffers will be used.
+ *
+ * This function combines some common tasks which will normally be performed
+ * when setting up a triggered buffer. It will allocate the buffer and the
+ * pollfunc, as well as register the buffer with the IIO core.
+ *
+ * Before calling this function the indio_dev structure should already be
+ * completely initialized, but not yet registered. In practice this means that
+ * this function should be called right before iio_device_register().
+ *
+ * To free the resources allocated by this function call
+ * iio_triggered_buffer_cleanup().
+ */
+int iio_triggered_buffer_setup(struct iio_dev *indio_dev,
+ irqreturn_t (*pollfunc_bh)(int irq, void *p),
+ irqreturn_t (*pollfunc_th)(int irq, void *p),
+ const struct iio_buffer_setup_ops *setup_ops)
+{
+ int ret;
+
+ indio_dev->buffer = iio_kfifo_allocate(indio_dev);
+ if (!indio_dev->buffer) {
+ ret = -ENOMEM;
+ goto error_ret;
+ }
+
+ indio_dev->pollfunc = iio_alloc_pollfunc(pollfunc_bh,
+ pollfunc_th,
+ IRQF_ONESHOT,
+ indio_dev,
+ "%s_consumer%d",
+ indio_dev->name,
+ indio_dev->id);
+ if (indio_dev->pollfunc == NULL) {
+ ret = -ENOMEM;
+ goto error_kfifo_free;
+ }
+
+ /* Ring buffer functions - here trigger setup related */
+ if (setup_ops)
+ indio_dev->setup_ops = setup_ops;
+ else
+ indio_dev->setup_ops = &iio_triggered_buffer_setup_ops;
+
+ /* Flag that polled ring buffering is possible */
+ indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
+
+ ret = iio_buffer_register(indio_dev,
+ indio_dev->channels,
+ indio_dev->num_channels);
+ if (ret)
+ goto error_dealloc_pollfunc;
+
+ return 0;
+
+error_dealloc_pollfunc:
+ iio_dealloc_pollfunc(indio_dev->pollfunc);
+error_kfifo_free:
+ iio_kfifo_free(indio_dev->buffer);
+error_ret:
+ return ret;
+}
+EXPORT_SYMBOL(iio_triggered_buffer_setup);
+
+/**
+ * iio_triggered_buffer_cleanup() - Free resources allocated by iio_triggered_buffer_setup()
+ * @indio_dev: IIO device structure
+ */
+void iio_triggered_buffer_cleanup(struct iio_dev *indio_dev)
+{
+ iio_buffer_unregister(indio_dev);
+ iio_dealloc_pollfunc(indio_dev->pollfunc);
+ iio_kfifo_free(indio_dev->buffer);
+}
+EXPORT_SYMBOL(iio_triggered_buffer_cleanup);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("IIO helper functions for setting up triggered buffers");
+MODULE_LICENSE("GPL");
strcmp(channel_name, c_i->map->consumer_channel) != 0))
continue;
c = c_i;
- get_device(&c->indio_dev->dev);
+ iio_device_get(c->indio_dev);
break;
}
mutex_unlock(&iio_map_list_lock);
void iio_st_channel_release(struct iio_channel *channel)
{
- put_device(&channel->indio_dev->dev);
+ iio_device_put(channel->indio_dev);
kfree(channel);
}
EXPORT_SYMBOL_GPL(iio_st_channel_release);
c->map->adc_channel_label);
if (chans[mapind].channel == NULL) {
ret = -EINVAL;
- put_device(&chans[mapind].indio_dev->dev);
+ iio_device_put(chans[mapind].indio_dev);
goto error_free_chans;
}
- get_device(&chans[mapind].indio_dev->dev);
+ iio_device_get(chans[mapind].indio_dev);
mapind++;
}
mutex_unlock(&iio_map_list_lock);
error_free_chans:
for (i = 0; i < nummaps; i++)
- if (chans[i].indio_dev)
- put_device(&chans[i].indio_dev->dev);
+ iio_device_put(chans[i].indio_dev);
kfree(chans);
error_ret:
mutex_unlock(&iio_map_list_lock);
struct iio_channel *chan = &channels[0];
while (chan->indio_dev) {
- put_device(&chan->indio_dev->dev);
+ iio_device_put(chan->indio_dev);
chan++;
}
kfree(channels);
--- /dev/null
+#
+# Light sensors
+#
+menu "Light sensors"
+
+config SENSORS_LM3533
+ tristate "LM3533 ambient light sensor"
+ depends on MFD_LM3533
+ help
+ If you say yes here you get support for the ambient light sensor
+ interface on National Semiconductor / TI LM3533 Lighting Power
+ chips.
+
+ The sensor interface can be used to control the LEDs and backlights
+ of the chip through defining five light zones and three sets of
+ corresponding output-current values.
+
+ The driver provides raw and mean adc readings along with the current
+ light zone through sysfs. A threshold event can be generated on zone
+ changes. The ALS-control output values can be set per zone for the
+ three current output channels.
+
+config VCNL4000
+ tristate "VCNL4000 combined ALS and proximity sensor"
+ depends on I2C
+ help
+ Say Y here if you want to build a driver for the Vishay VCNL4000
+ combined ambient light and proximity sensor.
+
+ To compile this driver as a module, choose M here: the
+ module will be called vcnl4000.
+
+endmenu
--- /dev/null
+#
+# Makefile for IIO Light sensors
+#
+
+obj-$(CONFIG_SENSORS_LM3533) += lm3533-als.o
+obj-$(CONFIG_VCNL4000) += vcnl4000.o
--- /dev/null
+/*
+ * lm3533-als.c -- LM3533 Ambient Light Sensor driver
+ *
+ * Copyright (C) 2011-2012 Texas Instruments
+ *
+ * Author: Johan Hovold <jhovold@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/atomic.h>
+#include <linux/fs.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/iio/events.h>
+#include <linux/iio/iio.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/mfd/core.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+
+#include <linux/mfd/lm3533.h>
+
+
+#define LM3533_ALS_RESISTOR_MIN 1
+#define LM3533_ALS_RESISTOR_MAX 127
+#define LM3533_ALS_CHANNEL_CURRENT_MAX 2
+#define LM3533_ALS_THRESH_MAX 3
+#define LM3533_ALS_ZONE_MAX 4
+
+#define LM3533_REG_ALS_RESISTOR_SELECT 0x30
+#define LM3533_REG_ALS_CONF 0x31
+#define LM3533_REG_ALS_ZONE_INFO 0x34
+#define LM3533_REG_ALS_READ_ADC_RAW 0x37
+#define LM3533_REG_ALS_READ_ADC_AVERAGE 0x38
+#define LM3533_REG_ALS_BOUNDARY_BASE 0x50
+#define LM3533_REG_ALS_TARGET_BASE 0x60
+
+#define LM3533_ALS_ENABLE_MASK 0x01
+#define LM3533_ALS_INPUT_MODE_MASK 0x02
+#define LM3533_ALS_INT_ENABLE_MASK 0x01
+
+#define LM3533_ALS_ZONE_SHIFT 2
+#define LM3533_ALS_ZONE_MASK 0x1c
+
+#define LM3533_ALS_FLAG_INT_ENABLED 1
+
+
+struct lm3533_als {
+ struct lm3533 *lm3533;
+ struct platform_device *pdev;
+
+ unsigned long flags;
+ int irq;
+
+ atomic_t zone;
+ struct mutex thresh_mutex;
+};
+
+
+static int lm3533_als_get_adc(struct iio_dev *indio_dev, bool average,
+ int *adc)
+{
+ struct lm3533_als *als = iio_priv(indio_dev);
+ u8 reg;
+ u8 val;
+ int ret;
+
+ if (average)
+ reg = LM3533_REG_ALS_READ_ADC_AVERAGE;
+ else
+ reg = LM3533_REG_ALS_READ_ADC_RAW;
+
+ ret = lm3533_read(als->lm3533, reg, &val);
+ if (ret) {
+ dev_err(&indio_dev->dev, "failed to read adc\n");
+ return ret;
+ }
+
+ *adc = val;
+
+ return 0;
+}
+
+static int _lm3533_als_get_zone(struct iio_dev *indio_dev, u8 *zone)
+{
+ struct lm3533_als *als = iio_priv(indio_dev);
+ u8 val;
+ int ret;
+
+ ret = lm3533_read(als->lm3533, LM3533_REG_ALS_ZONE_INFO, &val);
+ if (ret) {
+ dev_err(&indio_dev->dev, "failed to read zone\n");
+ return ret;
+ }
+
+ val = (val & LM3533_ALS_ZONE_MASK) >> LM3533_ALS_ZONE_SHIFT;
+ *zone = min_t(u8, val, LM3533_ALS_ZONE_MAX);
+
+ return 0;
+}
+
+static int lm3533_als_get_zone(struct iio_dev *indio_dev, u8 *zone)
+{
+ struct lm3533_als *als = iio_priv(indio_dev);
+ int ret;
+
+ if (test_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags)) {
+ *zone = atomic_read(&als->zone);
+ } else {
+ ret = _lm3533_als_get_zone(indio_dev, zone);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
+
+/*
+ * channel output channel 0..2
+ * zone zone 0..4
+ */
+static inline u8 lm3533_als_get_target_reg(unsigned channel, unsigned zone)
+{
+ return LM3533_REG_ALS_TARGET_BASE + 5 * channel + zone;
+}
+
+static int lm3533_als_get_target(struct iio_dev *indio_dev, unsigned channel,
+ unsigned zone, u8 *val)
+{
+ struct lm3533_als *als = iio_priv(indio_dev);
+ u8 reg;
+ int ret;
+
+ if (channel > LM3533_ALS_CHANNEL_CURRENT_MAX)
+ return -EINVAL;
+
+ if (zone > LM3533_ALS_ZONE_MAX)
+ return -EINVAL;
+
+ reg = lm3533_als_get_target_reg(channel, zone);
+ ret = lm3533_read(als->lm3533, reg, val);
+ if (ret)
+ dev_err(&indio_dev->dev, "failed to get target current\n");
+
+ return ret;
+}
+
+static int lm3533_als_set_target(struct iio_dev *indio_dev, unsigned channel,
+ unsigned zone, u8 val)
+{
+ struct lm3533_als *als = iio_priv(indio_dev);
+ u8 reg;
+ int ret;
+
+ if (channel > LM3533_ALS_CHANNEL_CURRENT_MAX)
+ return -EINVAL;
+
+ if (zone > LM3533_ALS_ZONE_MAX)
+ return -EINVAL;
+
+ reg = lm3533_als_get_target_reg(channel, zone);
+ ret = lm3533_write(als->lm3533, reg, val);
+ if (ret)
+ dev_err(&indio_dev->dev, "failed to set target current\n");
+
+ return ret;
+}
+
+static int lm3533_als_get_current(struct iio_dev *indio_dev, unsigned channel,
+ int *val)
+{
+ u8 zone;
+ u8 target;
+ int ret;
+
+ ret = lm3533_als_get_zone(indio_dev, &zone);
+ if (ret)
+ return ret;
+
+ ret = lm3533_als_get_target(indio_dev, channel, zone, &target);
+ if (ret)
+ return ret;
+
+ *val = target;
+
+ return 0;
+}
+
+static int lm3533_als_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val, int *val2, long mask)
+{
+ int ret;
+
+ switch (mask) {
+ case 0:
+ switch (chan->type) {
+ case IIO_LIGHT:
+ ret = lm3533_als_get_adc(indio_dev, false, val);
+ break;
+ case IIO_CURRENT:
+ ret = lm3533_als_get_current(indio_dev, chan->channel,
+ val);
+ break;
+ default:
+ return -EINVAL;
+ }
+ break;
+ case IIO_CHAN_INFO_AVERAGE_RAW:
+ ret = lm3533_als_get_adc(indio_dev, true, val);
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ if (ret)
+ return ret;
+
+ return IIO_VAL_INT;
+}
+
+#define CHANNEL_CURRENT(_channel) \
+ { \
+ .type = IIO_CURRENT, \
+ .channel = _channel, \
+ .indexed = true, \
+ .output = true, \
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT, \
+ }
+
+static const struct iio_chan_spec lm3533_als_channels[] = {
+ {
+ .type = IIO_LIGHT,
+ .channel = 0,
+ .indexed = true,
+ .info_mask = (IIO_CHAN_INFO_AVERAGE_RAW_SEPARATE_BIT |
+ IIO_CHAN_INFO_RAW_SEPARATE_BIT),
+ },
+ CHANNEL_CURRENT(0),
+ CHANNEL_CURRENT(1),
+ CHANNEL_CURRENT(2),
+};
+
+static irqreturn_t lm3533_als_isr(int irq, void *dev_id)
+{
+
+ struct iio_dev *indio_dev = dev_id;
+ struct lm3533_als *als = iio_priv(indio_dev);
+ u8 zone;
+ int ret;
+
+ /* Clear interrupt by reading the ALS zone register. */
+ ret = _lm3533_als_get_zone(indio_dev, &zone);
+ if (ret)
+ goto out;
+
+ atomic_set(&als->zone, zone);
+
+ iio_push_event(indio_dev,
+ IIO_UNMOD_EVENT_CODE(IIO_LIGHT,
+ 0,
+ IIO_EV_TYPE_THRESH,
+ IIO_EV_DIR_EITHER),
+ iio_get_time_ns());
+out:
+ return IRQ_HANDLED;
+}
+
+static int lm3533_als_set_int_mode(struct iio_dev *indio_dev, int enable)
+{
+ struct lm3533_als *als = iio_priv(indio_dev);
+ u8 mask = LM3533_ALS_INT_ENABLE_MASK;
+ u8 val;
+ int ret;
+
+ if (enable)
+ val = mask;
+ else
+ val = 0;
+
+ ret = lm3533_update(als->lm3533, LM3533_REG_ALS_ZONE_INFO, val, mask);
+ if (ret) {
+ dev_err(&indio_dev->dev, "failed to set int mode %d\n",
+ enable);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int lm3533_als_get_int_mode(struct iio_dev *indio_dev, int *enable)
+{
+ struct lm3533_als *als = iio_priv(indio_dev);
+ u8 mask = LM3533_ALS_INT_ENABLE_MASK;
+ u8 val;
+ int ret;
+
+ ret = lm3533_read(als->lm3533, LM3533_REG_ALS_ZONE_INFO, &val);
+ if (ret) {
+ dev_err(&indio_dev->dev, "failed to get int mode\n");
+ return ret;
+ }
+
+ *enable = !!(val & mask);
+
+ return 0;
+}
+
+static inline u8 lm3533_als_get_threshold_reg(unsigned nr, bool raising)
+{
+ u8 offset = !raising;
+
+ return LM3533_REG_ALS_BOUNDARY_BASE + 2 * nr + offset;
+}
+
+static int lm3533_als_get_threshold(struct iio_dev *indio_dev, unsigned nr,
+ bool raising, u8 *val)
+{
+ struct lm3533_als *als = iio_priv(indio_dev);
+ u8 reg;
+ int ret;
+
+ if (nr > LM3533_ALS_THRESH_MAX)
+ return -EINVAL;
+
+ reg = lm3533_als_get_threshold_reg(nr, raising);
+ ret = lm3533_read(als->lm3533, reg, val);
+ if (ret)
+ dev_err(&indio_dev->dev, "failed to get threshold\n");
+
+ return ret;
+}
+
+static int lm3533_als_set_threshold(struct iio_dev *indio_dev, unsigned nr,
+ bool raising, u8 val)
+{
+ struct lm3533_als *als = iio_priv(indio_dev);
+ u8 val2;
+ u8 reg, reg2;
+ int ret;
+
+ if (nr > LM3533_ALS_THRESH_MAX)
+ return -EINVAL;
+
+ reg = lm3533_als_get_threshold_reg(nr, raising);
+ reg2 = lm3533_als_get_threshold_reg(nr, !raising);
+
+ mutex_lock(&als->thresh_mutex);
+ ret = lm3533_read(als->lm3533, reg2, &val2);
+ if (ret) {
+ dev_err(&indio_dev->dev, "failed to get threshold\n");
+ goto out;
+ }
+ /*
+ * This device does not allow negative hysteresis (in fact, it uses
+ * whichever value is smaller as the lower bound) so we need to make
+ * sure that thresh_falling <= thresh_raising.
+ */
+ if ((raising && (val < val2)) || (!raising && (val > val2))) {
+ ret = -EINVAL;
+ goto out;
+ }
+
+ ret = lm3533_write(als->lm3533, reg, val);
+ if (ret) {
+ dev_err(&indio_dev->dev, "failed to set threshold\n");
+ goto out;
+ }
+out:
+ mutex_unlock(&als->thresh_mutex);
+
+ return ret;
+}
+
+static int lm3533_als_get_hysteresis(struct iio_dev *indio_dev, unsigned nr,
+ u8 *val)
+{
+ struct lm3533_als *als = iio_priv(indio_dev);
+ u8 falling;
+ u8 raising;
+ int ret;
+
+ if (nr > LM3533_ALS_THRESH_MAX)
+ return -EINVAL;
+
+ mutex_lock(&als->thresh_mutex);
+ ret = lm3533_als_get_threshold(indio_dev, nr, false, &falling);
+ if (ret)
+ goto out;
+ ret = lm3533_als_get_threshold(indio_dev, nr, true, &raising);
+ if (ret)
+ goto out;
+
+ *val = raising - falling;
+out:
+ mutex_unlock(&als->thresh_mutex);
+
+ return ret;
+}
+
+static int show_thresh_either_en(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+ struct lm3533_als *als = iio_priv(indio_dev);
+ int enable;
+ int ret;
+
+ if (als->irq) {
+ ret = lm3533_als_get_int_mode(indio_dev, &enable);
+ if (ret)
+ return ret;
+ } else {
+ enable = 0;
+ }
+
+ return scnprintf(buf, PAGE_SIZE, "%u\n", enable);
+}
+
+static int store_thresh_either_en(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+ struct lm3533_als *als = iio_priv(indio_dev);
+ unsigned long enable;
+ bool int_enabled;
+ u8 zone;
+ int ret;
+
+ if (!als->irq)
+ return -EBUSY;
+
+ if (kstrtoul(buf, 0, &enable))
+ return -EINVAL;
+
+ int_enabled = test_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
+
+ if (enable && !int_enabled) {
+ ret = lm3533_als_get_zone(indio_dev, &zone);
+ if (ret)
+ return ret;
+
+ atomic_set(&als->zone, zone);
+
+ set_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
+ }
+
+ ret = lm3533_als_set_int_mode(indio_dev, enable);
+ if (ret) {
+ if (!int_enabled)
+ clear_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
+
+ return ret;
+ }
+
+ if (!enable)
+ clear_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
+
+ return len;
+}
+
+static ssize_t show_zone(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+ u8 zone;
+ int ret;
+
+ ret = lm3533_als_get_zone(indio_dev, &zone);
+ if (ret)
+ return ret;
+
+ return scnprintf(buf, PAGE_SIZE, "%u\n", zone);
+}
+
+enum lm3533_als_attribute_type {
+ LM3533_ATTR_TYPE_HYSTERESIS,
+ LM3533_ATTR_TYPE_TARGET,
+ LM3533_ATTR_TYPE_THRESH_FALLING,
+ LM3533_ATTR_TYPE_THRESH_RAISING,
+};
+
+struct lm3533_als_attribute {
+ struct device_attribute dev_attr;
+ enum lm3533_als_attribute_type type;
+ u8 val1;
+ u8 val2;
+};
+
+static inline struct lm3533_als_attribute *
+to_lm3533_als_attr(struct device_attribute *attr)
+{
+ return container_of(attr, struct lm3533_als_attribute, dev_attr);
+}
+
+static ssize_t show_als_attr(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+ struct lm3533_als_attribute *als_attr = to_lm3533_als_attr(attr);
+ u8 val;
+ int ret;
+
+ switch (als_attr->type) {
+ case LM3533_ATTR_TYPE_HYSTERESIS:
+ ret = lm3533_als_get_hysteresis(indio_dev, als_attr->val1,
+ &val);
+ break;
+ case LM3533_ATTR_TYPE_TARGET:
+ ret = lm3533_als_get_target(indio_dev, als_attr->val1,
+ als_attr->val2, &val);
+ break;
+ case LM3533_ATTR_TYPE_THRESH_FALLING:
+ ret = lm3533_als_get_threshold(indio_dev, als_attr->val1,
+ false, &val);
+ break;
+ case LM3533_ATTR_TYPE_THRESH_RAISING:
+ ret = lm3533_als_get_threshold(indio_dev, als_attr->val1,
+ true, &val);
+ break;
+ default:
+ ret = -ENXIO;
+ }
+
+ if (ret)
+ return ret;
+
+ return scnprintf(buf, PAGE_SIZE, "%u\n", val);
+}
+
+static ssize_t store_als_attr(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+ struct lm3533_als_attribute *als_attr = to_lm3533_als_attr(attr);
+ u8 val;
+ int ret;
+
+ if (kstrtou8(buf, 0, &val))
+ return -EINVAL;
+
+ switch (als_attr->type) {
+ case LM3533_ATTR_TYPE_TARGET:
+ ret = lm3533_als_set_target(indio_dev, als_attr->val1,
+ als_attr->val2, val);
+ break;
+ case LM3533_ATTR_TYPE_THRESH_FALLING:
+ ret = lm3533_als_set_threshold(indio_dev, als_attr->val1,
+ false, val);
+ break;
+ case LM3533_ATTR_TYPE_THRESH_RAISING:
+ ret = lm3533_als_set_threshold(indio_dev, als_attr->val1,
+ true, val);
+ break;
+ default:
+ ret = -ENXIO;
+ }
+
+ if (ret)
+ return ret;
+
+ return len;
+}
+
+#define ALS_ATTR(_name, _mode, _show, _store, _type, _val1, _val2) \
+ { .dev_attr = __ATTR(_name, _mode, _show, _store), \
+ .type = _type, \
+ .val1 = _val1, \
+ .val2 = _val2 }
+
+#define LM3533_ALS_ATTR(_name, _mode, _show, _store, _type, _val1, _val2) \
+ struct lm3533_als_attribute lm3533_als_attr_##_name = \
+ ALS_ATTR(_name, _mode, _show, _store, _type, _val1, _val2)
+
+#define ALS_TARGET_ATTR_RW(_channel, _zone) \
+ LM3533_ALS_ATTR(out_current##_channel##_current##_zone##_raw, \
+ S_IRUGO | S_IWUSR, \
+ show_als_attr, store_als_attr, \
+ LM3533_ATTR_TYPE_TARGET, _channel, _zone)
+/*
+ * ALS output current values (ALS mapper targets)
+ *
+ * out_current[0-2]_current[0-4]_raw 0-255
+ */
+static ALS_TARGET_ATTR_RW(0, 0);
+static ALS_TARGET_ATTR_RW(0, 1);
+static ALS_TARGET_ATTR_RW(0, 2);
+static ALS_TARGET_ATTR_RW(0, 3);
+static ALS_TARGET_ATTR_RW(0, 4);
+
+static ALS_TARGET_ATTR_RW(1, 0);
+static ALS_TARGET_ATTR_RW(1, 1);
+static ALS_TARGET_ATTR_RW(1, 2);
+static ALS_TARGET_ATTR_RW(1, 3);
+static ALS_TARGET_ATTR_RW(1, 4);
+
+static ALS_TARGET_ATTR_RW(2, 0);
+static ALS_TARGET_ATTR_RW(2, 1);
+static ALS_TARGET_ATTR_RW(2, 2);
+static ALS_TARGET_ATTR_RW(2, 3);
+static ALS_TARGET_ATTR_RW(2, 4);
+
+#define ALS_THRESH_FALLING_ATTR_RW(_nr) \
+ LM3533_ALS_ATTR(in_illuminance0_thresh##_nr##_falling_value, \
+ S_IRUGO | S_IWUSR, \
+ show_als_attr, store_als_attr, \
+ LM3533_ATTR_TYPE_THRESH_FALLING, _nr, 0)
+
+#define ALS_THRESH_RAISING_ATTR_RW(_nr) \
+ LM3533_ALS_ATTR(in_illuminance0_thresh##_nr##_raising_value, \
+ S_IRUGO | S_IWUSR, \
+ show_als_attr, store_als_attr, \
+ LM3533_ATTR_TYPE_THRESH_RAISING, _nr, 0)
+/*
+ * ALS Zone thresholds (boundaries)
+ *
+ * in_illuminance0_thresh[0-3]_falling_value 0-255
+ * in_illuminance0_thresh[0-3]_raising_value 0-255
+ */
+static ALS_THRESH_FALLING_ATTR_RW(0);
+static ALS_THRESH_FALLING_ATTR_RW(1);
+static ALS_THRESH_FALLING_ATTR_RW(2);
+static ALS_THRESH_FALLING_ATTR_RW(3);
+
+static ALS_THRESH_RAISING_ATTR_RW(0);
+static ALS_THRESH_RAISING_ATTR_RW(1);
+static ALS_THRESH_RAISING_ATTR_RW(2);
+static ALS_THRESH_RAISING_ATTR_RW(3);
+
+#define ALS_HYSTERESIS_ATTR_RO(_nr) \
+ LM3533_ALS_ATTR(in_illuminance0_thresh##_nr##_hysteresis, \
+ S_IRUGO, show_als_attr, NULL, \
+ LM3533_ATTR_TYPE_HYSTERESIS, _nr, 0)
+/*
+ * ALS Zone threshold hysteresis
+ *
+ * threshY_hysteresis = threshY_raising - threshY_falling
+ *
+ * in_illuminance0_thresh[0-3]_hysteresis 0-255
+ * in_illuminance0_thresh[0-3]_hysteresis 0-255
+ */
+static ALS_HYSTERESIS_ATTR_RO(0);
+static ALS_HYSTERESIS_ATTR_RO(1);
+static ALS_HYSTERESIS_ATTR_RO(2);
+static ALS_HYSTERESIS_ATTR_RO(3);
+
+#define ILLUMINANCE_ATTR_RO(_name) \
+ DEVICE_ATTR(in_illuminance0_##_name, S_IRUGO, show_##_name, NULL)
+#define ILLUMINANCE_ATTR_RW(_name) \
+ DEVICE_ATTR(in_illuminance0_##_name, S_IRUGO | S_IWUSR , \
+ show_##_name, store_##_name)
+/*
+ * ALS Zone threshold-event enable
+ *
+ * in_illuminance0_thresh_either_en 0,1
+ */
+static ILLUMINANCE_ATTR_RW(thresh_either_en);
+
+/*
+ * ALS Current Zone
+ *
+ * in_illuminance0_zone 0-4
+ */
+static ILLUMINANCE_ATTR_RO(zone);
+
+static struct attribute *lm3533_als_event_attributes[] = {
+ &dev_attr_in_illuminance0_thresh_either_en.attr,
+ &lm3533_als_attr_in_illuminance0_thresh0_falling_value.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh0_hysteresis.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh0_raising_value.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh1_falling_value.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh1_hysteresis.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh1_raising_value.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh2_falling_value.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh2_hysteresis.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh2_raising_value.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh3_falling_value.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh3_hysteresis.dev_attr.attr,
+ &lm3533_als_attr_in_illuminance0_thresh3_raising_value.dev_attr.attr,
+ NULL
+};
+
+static struct attribute_group lm3533_als_event_attribute_group = {
+ .attrs = lm3533_als_event_attributes
+};
+
+static struct attribute *lm3533_als_attributes[] = {
+ &dev_attr_in_illuminance0_zone.attr,
+ &lm3533_als_attr_out_current0_current0_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current0_current1_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current0_current2_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current0_current3_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current0_current4_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current1_current0_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current1_current1_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current1_current2_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current1_current3_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current1_current4_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current2_current0_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current2_current1_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current2_current2_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current2_current3_raw.dev_attr.attr,
+ &lm3533_als_attr_out_current2_current4_raw.dev_attr.attr,
+ NULL
+};
+
+static struct attribute_group lm3533_als_attribute_group = {
+ .attrs = lm3533_als_attributes
+};
+
+static int __devinit lm3533_als_set_input_mode(struct lm3533_als *als,
+ bool pwm_mode)
+{
+ u8 mask = LM3533_ALS_INPUT_MODE_MASK;
+ u8 val;
+ int ret;
+
+ if (pwm_mode)
+ val = mask; /* pwm input */
+ else
+ val = 0; /* analog input */
+
+ ret = lm3533_update(als->lm3533, LM3533_REG_ALS_CONF, val, mask);
+ if (ret) {
+ dev_err(&als->pdev->dev, "failed to set input mode %d\n",
+ pwm_mode);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int __devinit lm3533_als_set_resistor(struct lm3533_als *als, u8 val)
+{
+ int ret;
+
+ if (val < LM3533_ALS_RESISTOR_MIN || val > LM3533_ALS_RESISTOR_MAX)
+ return -EINVAL;
+
+ ret = lm3533_write(als->lm3533, LM3533_REG_ALS_RESISTOR_SELECT, val);
+ if (ret) {
+ dev_err(&als->pdev->dev, "failed to set resistor\n");
+ return ret;
+ }
+
+ return 0;
+}
+
+static int __devinit lm3533_als_setup(struct lm3533_als *als,
+ struct lm3533_als_platform_data *pdata)
+{
+ int ret;
+
+ ret = lm3533_als_set_input_mode(als, pdata->pwm_mode);
+ if (ret)
+ return ret;
+
+ /* ALS input is always high impedance in PWM-mode. */
+ if (!pdata->pwm_mode) {
+ ret = lm3533_als_set_resistor(als, pdata->r_select);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
+
+static int __devinit lm3533_als_setup_irq(struct lm3533_als *als, void *dev)
+{
+ u8 mask = LM3533_ALS_INT_ENABLE_MASK;
+ int ret;
+
+ /* Make sure interrupts are disabled. */
+ ret = lm3533_update(als->lm3533, LM3533_REG_ALS_ZONE_INFO, 0, mask);
+ if (ret) {
+ dev_err(&als->pdev->dev, "failed to disable interrupts\n");
+ return ret;
+ }
+
+ ret = request_threaded_irq(als->irq, NULL, lm3533_als_isr,
+ IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+ dev_name(&als->pdev->dev), dev);
+ if (ret) {
+ dev_err(&als->pdev->dev, "failed to request irq %d\n",
+ als->irq);
+ return ret;
+ }
+
+ return 0;
+}
+
+static int __devinit lm3533_als_enable(struct lm3533_als *als)
+{
+ u8 mask = LM3533_ALS_ENABLE_MASK;
+ int ret;
+
+ ret = lm3533_update(als->lm3533, LM3533_REG_ALS_CONF, mask, mask);
+ if (ret)
+ dev_err(&als->pdev->dev, "failed to enable ALS\n");
+
+ return ret;
+}
+
+static int lm3533_als_disable(struct lm3533_als *als)
+{
+ u8 mask = LM3533_ALS_ENABLE_MASK;
+ int ret;
+
+ ret = lm3533_update(als->lm3533, LM3533_REG_ALS_CONF, 0, mask);
+ if (ret)
+ dev_err(&als->pdev->dev, "failed to disable ALS\n");
+
+ return ret;
+}
+
+static const struct iio_info lm3533_als_info = {
+ .attrs = &lm3533_als_attribute_group,
+ .event_attrs = &lm3533_als_event_attribute_group,
+ .driver_module = THIS_MODULE,
+ .read_raw = &lm3533_als_read_raw,
+};
+
+static int __devinit lm3533_als_probe(struct platform_device *pdev)
+{
+ struct lm3533 *lm3533;
+ struct lm3533_als_platform_data *pdata;
+ struct lm3533_als *als;
+ struct iio_dev *indio_dev;
+ int ret;
+
+ lm3533 = dev_get_drvdata(pdev->dev.parent);
+ if (!lm3533)
+ return -EINVAL;
+
+ pdata = pdev->dev.platform_data;
+ if (!pdata) {
+ dev_err(&pdev->dev, "no platform data\n");
+ return -EINVAL;
+ }
+
+ indio_dev = iio_device_alloc(sizeof(*als));
+ if (!indio_dev)
+ return -ENOMEM;
+
+ indio_dev->info = &lm3533_als_info;
+ indio_dev->channels = lm3533_als_channels;
+ indio_dev->num_channels = ARRAY_SIZE(lm3533_als_channels);
+ indio_dev->name = dev_name(&pdev->dev);
+ indio_dev->dev.parent = pdev->dev.parent;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+
+ als = iio_priv(indio_dev);
+ als->lm3533 = lm3533;
+ als->pdev = pdev;
+ als->irq = lm3533->irq;
+ atomic_set(&als->zone, 0);
+ mutex_init(&als->thresh_mutex);
+
+ platform_set_drvdata(pdev, indio_dev);
+
+ if (als->irq) {
+ ret = lm3533_als_setup_irq(als, indio_dev);
+ if (ret)
+ goto err_free_dev;
+ }
+
+ ret = lm3533_als_setup(als, pdata);
+ if (ret)
+ goto err_free_irq;
+
+ ret = lm3533_als_enable(als);
+ if (ret)
+ goto err_free_irq;
+
+ ret = iio_device_register(indio_dev);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to register ALS\n");
+ goto err_disable;
+ }
+
+ return 0;
+
+err_disable:
+ lm3533_als_disable(als);
+err_free_irq:
+ if (als->irq)
+ free_irq(als->irq, indio_dev);
+err_free_dev:
+ iio_device_free(indio_dev);
+
+ return ret;
+}
+
+static int __devexit lm3533_als_remove(struct platform_device *pdev)
+{
+ struct iio_dev *indio_dev = platform_get_drvdata(pdev);
+ struct lm3533_als *als = iio_priv(indio_dev);
+
+ lm3533_als_set_int_mode(indio_dev, false);
+ iio_device_unregister(indio_dev);
+ lm3533_als_disable(als);
+ if (als->irq)
+ free_irq(als->irq, indio_dev);
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static struct platform_driver lm3533_als_driver = {
+ .driver = {
+ .name = "lm3533-als",
+ .owner = THIS_MODULE,
+ },
+ .probe = lm3533_als_probe,
+ .remove = __devexit_p(lm3533_als_remove),
+};
+module_platform_driver(lm3533_als_driver);
+
+MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>");
+MODULE_DESCRIPTION("LM3533 Ambient Light Sensor driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:lm3533-als");
--- /dev/null
+/*
+ * vcnl4000.c - Support for Vishay VCNL4000 combined ambient light and
+ * proximity sensor
+ *
+ * Copyright 2012 Peter Meerwald <pmeerw@pmeerw.net>
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License. See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * IIO driver for VCNL4000 (7-bit I2C slave address 0x13)
+ *
+ * TODO:
+ * allow to adjust IR current
+ * proximity threshold and event handling
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define VCNL4000_DRV_NAME "vcnl4000"
+
+#define VCNL4000_COMMAND 0x80 /* Command register */
+#define VCNL4000_PROD_REV 0x81 /* Product ID and Revision ID */
+#define VCNL4000_LED_CURRENT 0x83 /* IR LED current for proximity mode */
+#define VCNL4000_AL_PARAM 0x84 /* Ambient light parameter register */
+#define VCNL4000_AL_RESULT_HI 0x85 /* Ambient light result register, MSB */
+#define VCNL4000_AL_RESULT_LO 0x86 /* Ambient light result register, LSB */
+#define VCNL4000_PS_RESULT_HI 0x87 /* Proximity result register, MSB */
+#define VCNL4000_PS_RESULT_LO 0x88 /* Proximity result register, LSB */
+#define VCNL4000_PS_MEAS_FREQ 0x89 /* Proximity test signal frequency */
+#define VCNL4000_PS_MOD_ADJ 0x8a /* Proximity modulator timing adjustment */
+
+/* Bit masks for COMMAND register */
+#define VCNL4000_AL_RDY 0x40 /* ALS data ready? */
+#define VCNL4000_PS_RDY 0x20 /* proximity data ready? */
+#define VCNL4000_AL_OD 0x10 /* start on-demand ALS measurement */
+#define VCNL4000_PS_OD 0x08 /* start on-demand proximity measurement */
+
+struct vcnl4000_data {
+ struct i2c_client *client;
+};
+
+static const struct i2c_device_id vcnl4000_id[] = {
+ { "vcnl4000", 0 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, vcnl4000_id);
+
+static int vcnl4000_measure(struct vcnl4000_data *data, u8 req_mask,
+ u8 rdy_mask, u8 data_reg, int *val)
+{
+ int tries = 20;
+ u16 buf;
+ int ret;
+
+ ret = i2c_smbus_write_byte_data(data->client, VCNL4000_COMMAND,
+ req_mask);
+ if (ret < 0)
+ return ret;
+
+ /* wait for data to become ready */
+ while (tries--) {
+ ret = i2c_smbus_read_byte_data(data->client, VCNL4000_COMMAND);
+ if (ret < 0)
+ return ret;
+ if (ret & rdy_mask)
+ break;
+ msleep(20); /* measurement takes up to 100 ms */
+ }
+
+ if (tries < 0) {
+ dev_err(&data->client->dev,
+ "vcnl4000_measure() failed, data not ready\n");
+ return -EIO;
+ }
+
+ ret = i2c_smbus_read_i2c_block_data(data->client,
+ data_reg, sizeof(buf), (u8 *) &buf);
+ if (ret < 0)
+ return ret;
+
+ *val = be16_to_cpu(buf);
+
+ return 0;
+}
+
+static const struct iio_chan_spec vcnl4000_channels[] = {
+ {
+ .type = IIO_LIGHT,
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
+ IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
+ }, {
+ .type = IIO_PROXIMITY,
+ .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT,
+ }
+};
+
+static int vcnl4000_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int *val, int *val2, long mask)
+{
+ int ret = -EINVAL;
+ struct vcnl4000_data *data = iio_priv(indio_dev);
+
+ switch (mask) {
+ case IIO_CHAN_INFO_RAW:
+ switch (chan->type) {
+ case IIO_LIGHT:
+ ret = vcnl4000_measure(data,
+ VCNL4000_AL_OD, VCNL4000_AL_RDY,
+ VCNL4000_AL_RESULT_HI, val);
+ if (ret < 0)
+ return ret;
+ ret = IIO_VAL_INT;
+ break;
+ case IIO_PROXIMITY:
+ ret = vcnl4000_measure(data,
+ VCNL4000_PS_OD, VCNL4000_PS_RDY,
+ VCNL4000_PS_RESULT_HI, val);
+ if (ret < 0)
+ return ret;
+ ret = IIO_VAL_INT;
+ break;
+ default:
+ break;
+ }
+ break;
+ case IIO_CHAN_INFO_SCALE:
+ if (chan->type == IIO_LIGHT) {
+ *val = 0;
+ *val2 = 250000;
+ ret = IIO_VAL_INT_PLUS_MICRO;
+ }
+ break;
+ default:
+ break;
+ }
+
+ return ret;
+}
+
+static const struct iio_info vcnl4000_info = {
+ .read_raw = vcnl4000_read_raw,
+ .driver_module = THIS_MODULE,
+};
+
+static int __devinit vcnl4000_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct vcnl4000_data *data;
+ struct iio_dev *indio_dev;
+ int ret;
+
+ indio_dev = iio_device_alloc(sizeof(*data));
+ if (!indio_dev)
+ return -ENOMEM;
+
+ data = iio_priv(indio_dev);
+ i2c_set_clientdata(client, indio_dev);
+ data->client = client;
+
+ ret = i2c_smbus_read_byte_data(data->client, VCNL4000_PROD_REV);
+ if (ret < 0)
+ goto error_free_dev;
+
+ dev_info(&client->dev, "VCNL4000 Ambient light/proximity sensor, Prod %02x, Rev: %02x\n",
+ ret >> 4, ret & 0xf);
+
+ indio_dev->dev.parent = &client->dev;
+ indio_dev->info = &vcnl4000_info;
+ indio_dev->channels = vcnl4000_channels;
+ indio_dev->num_channels = ARRAY_SIZE(vcnl4000_channels);
+ indio_dev->name = VCNL4000_DRV_NAME;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+
+ ret = iio_device_register(indio_dev);
+ if (ret < 0)
+ goto error_free_dev;
+
+ return 0;
+
+error_free_dev:
+ iio_device_free(indio_dev);
+ return ret;
+}
+
+static int __devexit vcnl4000_remove(struct i2c_client *client)
+{
+ struct iio_dev *indio_dev = i2c_get_clientdata(client);
+
+ iio_device_unregister(indio_dev);
+ iio_device_free(indio_dev);
+
+ return 0;
+}
+
+static struct i2c_driver vcnl4000_driver = {
+ .driver = {
+ .name = VCNL4000_DRV_NAME,
+ .owner = THIS_MODULE,
+ },
+ .probe = vcnl4000_probe,
+ .remove = __devexit_p(vcnl4000_remove),
+ .id_table = vcnl4000_id,
+};
+
+module_i2c_driver(vcnl4000_driver);
+
+MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
+MODULE_DESCRIPTION("Vishay VCNL4000 proximity/ambient light sensor driver");
+MODULE_LICENSE("GPL");
source "drivers/staging/wlags49_h25/Kconfig"
-source "drivers/staging/sm7xx/Kconfig"
+source "drivers/staging/sm7xxfb/Kconfig"
source "drivers/staging/crystalhd/Kconfig"
source "drivers/staging/gdm72xx/Kconfig"
+source "drivers/staging/csr/Kconfig"
+
endif # STAGING
obj-$(CONFIG_ZSMALLOC) += zsmalloc/
obj-$(CONFIG_WLAGS49_H2) += wlags49_h2/
obj-$(CONFIG_WLAGS49_H25) += wlags49_h25/
-obj-$(CONFIG_FB_SM7XX) += sm7xx/
+obj-$(CONFIG_FB_SM7XX) += sm7xxfb/
obj-$(CONFIG_CRYSTALHD) += crystalhd/
obj-$(CONFIG_CXT1E1) += cxt1e1/
obj-$(CONFIG_FB_XGI) += xgifb/
obj-$(CONFIG_USB_WPAN_HCD) += ozwpan/
obj-$(CONFIG_USB_G_CCG) += ccg/
obj-$(CONFIG_WIMAX_GDM72XX) += gdm72xx/
+obj-$(CONFIG_CSR_WIFI) += csr/
tristate "Android log driver"
default n
-config ANDROID_RAM_CONSOLE
- bool "Android RAM buffer console"
- depends on !S390 && !UML && HAVE_MEMBLOCK && PSTORE_RAM=y
- default n
-
config ANDROID_TIMED_OUTPUT
bool "Timed output class driver"
default y
obj-$(CONFIG_ANDROID_BINDER_IPC) += binder.o
obj-$(CONFIG_ASHMEM) += ashmem.o
obj-$(CONFIG_ANDROID_LOGGER) += logger.o
-obj-$(CONFIG_ANDROID_RAM_CONSOLE) += ram_console.o
obj-$(CONFIG_ANDROID_TIMED_OUTPUT) += timed_output.o
obj-$(CONFIG_ANDROID_TIMED_GPIO) += timed_gpio.o
obj-$(CONFIG_ANDROID_LOW_MEMORY_KILLER) += lowmemorykiller.o
#define ANDROID_ALARM_PRINT_IO (1U << 1)
#define ANDROID_ALARM_PRINT_INT (1U << 2)
-
static int debug_mask = ANDROID_ALARM_PRINT_INFO;
module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);
-#define pr_alarm(debug_level_mask, args...) \
- do { \
- if (debug_mask & ANDROID_ALARM_PRINT_##debug_level_mask) { \
- pr_info(args); \
- } \
- } while (0)
+#define alarm_dbg(debug_level_mask, fmt, ...) \
+do { \
+ if (debug_mask & ANDROID_ALARM_PRINT_##debug_level_mask) \
+ pr_info(fmt, ##__VA_ARGS__); \
+} while (0)
#define ANDROID_ALARM_WAKEUP_MASK ( \
ANDROID_ALARM_RTC_WAKEUP_MASK | \
switch (ANDROID_ALARM_BASE_CMD(cmd)) {
case ANDROID_ALARM_CLEAR(0):
spin_lock_irqsave(&alarm_slock, flags);
- pr_alarm(IO, "alarm %d clear\n", alarm_type);
+ alarm_dbg(IO, "alarm %d clear\n", alarm_type);
devalarm_try_to_cancel(&alarms[alarm_type]);
if (alarm_pending) {
alarm_pending &= ~alarm_type_mask;
}
from_old_alarm_set:
spin_lock_irqsave(&alarm_slock, flags);
- pr_alarm(IO, "alarm %d set %ld.%09ld\n", alarm_type,
- new_alarm_time.tv_sec, new_alarm_time.tv_nsec);
+ alarm_dbg(IO, "alarm %d set %ld.%09ld\n",
+ alarm_type,
+ new_alarm_time.tv_sec, new_alarm_time.tv_nsec);
alarm_enabled |= alarm_type_mask;
devalarm_start(&alarms[alarm_type],
timespec_to_ktime(new_alarm_time));
/* fall though */
case ANDROID_ALARM_WAIT:
spin_lock_irqsave(&alarm_slock, flags);
- pr_alarm(IO, "alarm wait\n");
+ alarm_dbg(IO, "alarm wait\n");
if (!alarm_pending && wait_pending) {
__pm_relax(&alarm_wake_lock);
wait_pending = 0;
default:
rv = -EINVAL;
- goto err1;
}
err1:
return rv;
unsigned long flags;
spin_lock_irqsave(&alarm_slock, flags);
- if (file->private_data != 0) {
+ if (file->private_data) {
for (i = 0; i < ANDROID_ALARM_TYPE_COUNT; i++) {
uint32_t alarm_type_mask = 1U << i;
if (alarm_enabled & alarm_type_mask) {
- pr_alarm(INFO, "alarm_release: clear alarm, "
- "pending %d\n",
- !!(alarm_pending & alarm_type_mask));
+ alarm_dbg(INFO,
+ "%s: clear alarm, pending %d\n",
+ __func__,
+ !!(alarm_pending & alarm_type_mask));
alarm_enabled &= ~alarm_type_mask;
}
spin_unlock_irqrestore(&alarm_slock, flags);
}
if (alarm_pending | wait_pending) {
if (alarm_pending)
- pr_alarm(INFO, "alarm_release: clear "
- "pending alarms %x\n", alarm_pending);
+ alarm_dbg(INFO, "%s: clear pending alarms %x\n",
+ __func__, alarm_pending);
__pm_relax(&alarm_wake_lock);
wait_pending = 0;
alarm_pending = 0;
unsigned long flags;
uint32_t alarm_type_mask = 1U << alarm->type;
- pr_alarm(INT, "devalarm_triggered type %d\n", alarm->type);
+ alarm_dbg(INT, "%s: type %d\n", __func__, alarm->type);
spin_lock_irqsave(&alarm_slock, flags);
if (alarm_enabled & alarm_type_mask) {
__pm_wakeup_event(&alarm_wake_lock, 5000); /* 5secs */
** GNU General Public License for more details.
*/
+#define pr_fmt(fmt) "ashmem: " fmt
+
#include <linux/module.h>
#include <linux/file.h>
#include <linux/fs.h>
sizeof(struct ashmem_area),
0, 0, NULL);
if (unlikely(!ashmem_area_cachep)) {
- printk(KERN_ERR "ashmem: failed to create slab cache\n");
+ pr_err("failed to create slab cache\n");
return -ENOMEM;
}
sizeof(struct ashmem_range),
0, 0, NULL);
if (unlikely(!ashmem_range_cachep)) {
- printk(KERN_ERR "ashmem: failed to create slab cache\n");
+ pr_err("failed to create slab cache\n");
return -ENOMEM;
}
ret = misc_register(&ashmem_misc);
if (unlikely(ret)) {
- printk(KERN_ERR "ashmem: failed to register misc device!\n");
+ pr_err("failed to register misc device!\n");
return ret;
}
register_shrinker(&ashmem_shrinker);
- printk(KERN_INFO "ashmem: initialized\n");
+ pr_info("initialized\n");
return 0;
}
ret = misc_deregister(&ashmem_misc);
if (unlikely(ret))
- printk(KERN_ERR "ashmem: failed to unregister misc device!\n");
+ pr_err("failed to unregister misc device!\n");
kmem_cache_destroy(ashmem_range_cachep);
kmem_cache_destroy(ashmem_area_cachep);
- printk(KERN_INFO "ashmem: unloaded\n");
+ pr_info("unloaded\n");
}
module_init(ashmem_init);
#define binder_debug(mask, x...) \
do { \
if (binder_debug_mask & mask) \
- printk(KERN_INFO x); \
+ pr_info(x); \
} while (0)
#define binder_user_error(x...) \
do { \
if (binder_debug_mask & BINDER_DEBUG_USER_ERROR) \
- printk(KERN_INFO x); \
+ pr_info(x); \
if (binder_stop_on_user_error) \
binder_stop_on_user_error = 2; \
} while (0)
#if 1
/* Sanity check */
if (fdt->fd[fd] != NULL) {
- printk(KERN_WARNING "get_unused_fd: slot %d not NULL!\n", fd);
+ pr_warn("get_unused_fd: slot %d not NULL!\n", fd);
fdt->fd[fd] = NULL;
}
#endif
goto free_range;
if (vma == NULL) {
- printk(KERN_ERR "binder: %d: binder_alloc_buf failed to "
+ pr_err("binder: %d: binder_alloc_buf failed to "
"map pages in userspace, no vma\n", proc->pid);
goto err_no_vma;
}
BUG_ON(*page);
*page = alloc_page(GFP_KERNEL | __GFP_ZERO);
if (*page == NULL) {
- printk(KERN_ERR "binder: %d: binder_alloc_buf failed "
+ pr_err("binder: %d: binder_alloc_buf failed "
"for page at %p\n", proc->pid, page_addr);
goto err_alloc_page_failed;
}
page_array_ptr = page;
ret = map_vm_area(&tmp_area, PAGE_KERNEL, &page_array_ptr);
if (ret) {
- printk(KERN_ERR "binder: %d: binder_alloc_buf failed "
+ pr_err("binder: %d: binder_alloc_buf failed "
"to map page at %p in kernel\n",
proc->pid, page_addr);
goto err_map_kernel_failed;
(uintptr_t)page_addr + proc->user_buffer_offset;
ret = vm_insert_page(vma, user_page_addr, page[0]);
if (ret) {
- printk(KERN_ERR "binder: %d: binder_alloc_buf failed "
+ pr_err("binder: %d: binder_alloc_buf failed "
"to map page at %lx in userspace\n",
proc->pid, user_page_addr);
goto err_vm_insert_page_failed;
size_t size;
if (proc->vma == NULL) {
- printk(KERN_ERR "binder: %d: binder_alloc_buf, no vma\n",
+ pr_err("binder: %d: binder_alloc_buf, no vma\n",
proc->pid);
return NULL;
}
}
}
if (best_fit == NULL) {
- printk(KERN_ERR "binder: %d: binder_alloc_buf size %zd failed, "
+ pr_err("binder: %d: binder_alloc_buf size %zd failed, "
"no address space\n", proc->pid, size);
return NULL;
}
node->internal_strong_refs == 0 &&
!(node == binder_context_mgr_node &&
node->has_strong_ref)) {
- printk(KERN_ERR "binder: invalid inc strong "
+ pr_err("binder: invalid inc strong "
"node for %d\n", node->debug_id);
return -EINVAL;
}
node->local_weak_refs++;
if (!node->has_weak_ref && list_empty(&node->work.entry)) {
if (target_list == NULL) {
- printk(KERN_ERR "binder: invalid inc weak node "
+ pr_err("binder: invalid inc weak node "
"for %d\n", node->debug_id);
return -EINVAL;
}
target_thread->return_error = error_code;
wake_up_interruptible(&target_thread->wait);
} else {
- printk(KERN_ERR "binder: reply failed, target "
+ pr_err("binder: reply failed, target "
"thread, %d:%d, has error code %d "
"already\n", target_thread->proc->pid,
target_thread->pid,
if (*offp > buffer->data_size - sizeof(*fp) ||
buffer->data_size < sizeof(*fp) ||
!IS_ALIGNED(*offp, sizeof(void *))) {
- printk(KERN_ERR "binder: transaction release %d bad"
+ pr_err("binder: transaction release %d bad"
"offset %zd, size %zd\n", debug_id,
*offp, buffer->data_size);
continue;
case BINDER_TYPE_WEAK_BINDER: {
struct binder_node *node = binder_get_node(proc, fp->binder);
if (node == NULL) {
- printk(KERN_ERR "binder: transaction release %d"
+ pr_err("binder: transaction release %d"
" bad node %p\n", debug_id, fp->binder);
break;
}
case BINDER_TYPE_WEAK_HANDLE: {
struct binder_ref *ref = binder_get_ref(proc, fp->handle);
if (ref == NULL) {
- printk(KERN_ERR "binder: transaction release %d"
+ pr_err("binder: transaction release %d"
" bad handle %ld\n", debug_id,
fp->handle);
break;
break;
default:
- printk(KERN_ERR "binder: transaction release %d bad "
+ pr_err("binder: transaction release %d bad "
"object type %lx\n", debug_id, fp->type);
break;
}
break;
}
case BC_ATTEMPT_ACQUIRE:
- printk(KERN_ERR "binder: BC_ATTEMPT_ACQUIRE not supported\n");
+ pr_err("binder: BC_ATTEMPT_ACQUIRE not supported\n");
return -EINVAL;
case BC_ACQUIRE_RESULT:
- printk(KERN_ERR "binder: BC_ACQUIRE_RESULT not supported\n");
+ pr_err("binder: BC_ACQUIRE_RESULT not supported\n");
return -EINVAL;
case BC_FREE_BUFFER: {
} break;
default:
- printk(KERN_ERR "binder: %d:%d unknown command %d\n",
+ pr_err("binder: %d:%d unknown command %d\n",
proc->pid, thread->pid, cmd);
return -EINVAL;
}
unsigned int size = _IOC_SIZE(cmd);
void __user *ubuf = (void __user *)arg;
- /*printk(KERN_INFO "binder_ioctl: %d:%d %x %lx\n", proc->pid, current->pid, cmd, arg);*/
+ /*pr_info("binder_ioctl: %d:%d %x %lx\n", proc->pid, current->pid, cmd, arg);*/
ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);
if (ret)
break;
case BINDER_SET_CONTEXT_MGR:
if (binder_context_mgr_node != NULL) {
- printk(KERN_ERR "binder: BINDER_SET_CONTEXT_MGR already set\n");
+ pr_err("binder: BINDER_SET_CONTEXT_MGR already set\n");
ret = -EBUSY;
goto err;
}
if (binder_context_mgr_uid != -1) {
if (binder_context_mgr_uid != current->cred->euid) {
- printk(KERN_ERR "binder: BINDER_SET_"
+ pr_err("binder: BINDER_SET_"
"CONTEXT_MGR bad uid %d != %d\n",
current->cred->euid,
binder_context_mgr_uid);
mutex_unlock(&binder_lock);
wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);
if (ret && ret != -ERESTARTSYS)
- printk(KERN_INFO "binder: %d:%d ioctl %x %lx returned %d\n", proc->pid, current->pid, cmd, arg, ret);
+ pr_info("binder: %d:%d ioctl %x %lx returned %d\n", proc->pid, current->pid, cmd, arg, ret);
return ret;
}
#ifdef CONFIG_CPU_CACHE_VIPT
if (cache_is_vipt_aliasing()) {
while (CACHE_COLOUR((vma->vm_start ^ (uint32_t)proc->buffer))) {
- printk(KERN_INFO "binder_mmap: %d %lx-%lx maps %p bad alignment\n", proc->pid, vma->vm_start, vma->vm_end, proc->buffer);
+ pr_info("binder_mmap: %d %lx-%lx maps %p bad alignment\n", proc->pid, vma->vm_start, vma->vm_end, proc->buffer);
vma->vm_start += PAGE_SIZE;
}
}
proc->vma = vma;
proc->vma_vm_mm = vma->vm_mm;
- /*printk(KERN_INFO "binder_mmap: %d %lx-%lx maps %p\n",
+ /*pr_info("binder_mmap: %d %lx-%lx maps %p\n",
proc->pid, vma->vm_start, vma->vm_end, proc->buffer);*/
return 0;
err_already_mapped:
mutex_unlock(&binder_mmap_lock);
err_bad_arg:
- printk(KERN_ERR "binder_mmap: %d %lx-%lx %s failed %d\n",
+ pr_err("binder_mmap: %d %lx-%lx %s failed %d\n",
proc->pid, vma->vm_start, vma->vm_end, failure_string, ret);
return ret;
}
if (t) {
t->buffer = NULL;
buffer->transaction = NULL;
- printk(KERN_ERR "binder: release proc %d, "
+ pr_err("binder: release proc %d, "
"transaction %d, not freed\n",
proc->pid, t->debug_id);
/*BUG();*/
* GNU General Public License for more details.
*/
+#define pr_fmt(fmt) "logger: " fmt
+
#include <linux/sched.h>
#include <linux/module.h>
#include <linux/fs.h>
/* finally, initialize the misc device for this log */
ret = misc_register(&log->misc);
if (unlikely(ret)) {
- printk(KERN_ERR "logger: failed to register misc "
- "device for log '%s'!\n", log->misc.name);
+ pr_err("failed to register misc device for log '%s'!\n",
+ log->misc.name);
goto out_free_log;
}
- printk(KERN_INFO "logger: created %luK log '%s'\n",
- (unsigned long) log->size >> 10, log->misc.name);
+ pr_info("created %luK log '%s'\n",
+ (unsigned long) log->size >> 10, log->misc.name);
return 0;
+++ /dev/null
-/* drivers/android/ram_console.c
- *
- * Copyright (C) 2007-2008 Google, Inc.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- */
-
-#include <linux/console.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/proc_fs.h>
-#include <linux/string.h>
-#include <linux/uaccess.h>
-#include <linux/io.h>
-#include <linux/pstore_ram.h>
-#include "ram_console.h"
-
-static struct persistent_ram_zone *ram_console_zone;
-static const char *bootinfo;
-static size_t bootinfo_size;
-
-static void
-ram_console_write(struct console *console, const char *s, unsigned int count)
-{
- struct persistent_ram_zone *prz = console->data;
- persistent_ram_write(prz, s, count);
-}
-
-static struct console ram_console = {
- .name = "ram",
- .write = ram_console_write,
- .flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME,
- .index = -1,
-};
-
-void ram_console_enable_console(int enabled)
-{
- if (enabled)
- ram_console.flags |= CON_ENABLED;
- else
- ram_console.flags &= ~CON_ENABLED;
-}
-
-static int __init ram_console_probe(struct platform_device *pdev)
-{
- struct ram_console_platform_data *pdata = pdev->dev.platform_data;
- struct persistent_ram_zone *prz;
-
- prz = persistent_ram_init_ringbuffer(&pdev->dev, true);
- if (IS_ERR(prz))
- return PTR_ERR(prz);
-
-
- if (pdata) {
- bootinfo = kstrdup(pdata->bootinfo, GFP_KERNEL);
- if (bootinfo)
- bootinfo_size = strlen(bootinfo);
- }
-
- ram_console_zone = prz;
- ram_console.data = prz;
-
- register_console(&ram_console);
-
- return 0;
-}
-
-static struct platform_driver ram_console_driver = {
- .driver = {
- .name = "ram_console",
- },
-};
-
-static int __init ram_console_module_init(void)
-{
- return platform_driver_probe(&ram_console_driver, ram_console_probe);
-}
-
-#ifndef CONFIG_PRINTK
-#define dmesg_restrict 0
-#endif
-
-static ssize_t ram_console_read_old(struct file *file, char __user *buf,
- size_t len, loff_t *offset)
-{
- loff_t pos = *offset;
- ssize_t count;
- struct persistent_ram_zone *prz = ram_console_zone;
- size_t old_log_size = persistent_ram_old_size(prz);
- const char *old_log = persistent_ram_old(prz);
- char *str;
- int ret;
-
- if (dmesg_restrict && !capable(CAP_SYSLOG))
- return -EPERM;
-
- /* Main last_kmsg log */
- if (pos < old_log_size) {
- count = min(len, (size_t)(old_log_size - pos));
- if (copy_to_user(buf, old_log + pos, count))
- return -EFAULT;
- goto out;
- }
-
- /* ECC correction notice */
- pos -= old_log_size;
- count = persistent_ram_ecc_string(prz, NULL, 0);
- if (pos < count) {
- str = kmalloc(count, GFP_KERNEL);
- if (!str)
- return -ENOMEM;
- persistent_ram_ecc_string(prz, str, count + 1);
- count = min(len, (size_t)(count - pos));
- ret = copy_to_user(buf, str + pos, count);
- kfree(str);
- if (ret)
- return -EFAULT;
- goto out;
- }
-
- /* Boot info passed through pdata */
- pos -= count;
- if (pos < bootinfo_size) {
- count = min(len, (size_t)(bootinfo_size - pos));
- if (copy_to_user(buf, bootinfo + pos, count))
- return -EFAULT;
- goto out;
- }
-
- /* EOF */
- return 0;
-
-out:
- *offset += count;
- return count;
-}
-
-static const struct file_operations ram_console_file_ops = {
- .owner = THIS_MODULE,
- .read = ram_console_read_old,
-};
-
-static int __init ram_console_late_init(void)
-{
- struct proc_dir_entry *entry;
- struct persistent_ram_zone *prz = ram_console_zone;
-
- if (!prz)
- return 0;
-
- if (persistent_ram_old_size(prz) == 0)
- return 0;
-
- entry = create_proc_entry("last_kmsg", S_IFREG | S_IRUGO, NULL);
- if (!entry) {
- printk(KERN_ERR "ram_console: failed to create proc entry\n");
- persistent_ram_free_old(prz);
- return 0;
- }
-
- entry->proc_fops = &ram_console_file_ops;
- entry->size = persistent_ram_old_size(prz) +
- persistent_ram_ecc_string(prz, NULL, 0) +
- bootinfo_size;
-
- return 0;
-}
-
-late_initcall(ram_console_late_init);
-postcore_initcall(ram_console_module_init);
*
*/
+#define pr_fmt(fmt) "timed_output: " fmt
+
#include <linux/module.h>
#include <linux/types.h>
#include <linux/device.h>
err_create_file:
device_destroy(timed_output_class, MKDEV(0, tdev->index));
- printk(KERN_ERR "timed_output: Failed to register driver %s\n",
+ pr_err("failed to register driver %s\n",
tdev->name);
return ret;
#define MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES 256
#include "Debug.h"
-struct _LEADER {
+struct bcm_leader {
USHORT Vcid;
USHORT PLength;
UCHAR Status;
UCHAR Unused[3];
} __packed;
-typedef struct _LEADER LEADER, *PLEADER;
-struct _PACKETTOSEND {
- LEADER Leader;
+struct bcm_packettosend {
+ struct bcm_leader Leader;
UCHAR ucPayload;
} __packed;
-typedef struct _PACKETTOSEND PACKETTOSEND, *PPACKETTOSEND;
-struct _CONTROL_PACKET {
+struct bcm_control_packet {
PVOID ControlBuff;
UINT ControlBuffLen;
- struct _CONTROL_PACKET *next;
+ struct bcm_control_packet *next;
} __packed;
-typedef struct _CONTROL_PACKET CONTROL_PACKET, *PCONTROL_PACKET;
-struct link_request {
- LEADER Leader;
+struct bcm_link_request {
+ struct bcm_leader Leader;
UCHAR szData[4];
} __packed;
-typedef struct link_request LINK_REQUEST, *PLINK_REQUEST;
-
-/* classification extension is added */
-typedef struct _ADD_CONNECTION {
- ULONG SrcIpAddressCount;
- ULONG SrcIpAddress[MAX_CONNECTIONS];
- ULONG SrcIpMask[MAX_CONNECTIONS];
-
- ULONG DestIpAddressCount;
- ULONG DestIpAddress[MAX_CONNECTIONS];
- ULONG DestIpMask[MAX_CONNECTIONS];
-
- USHORT SrcPortBegin;
- USHORT SrcPortEnd;
-
- USHORT DestPortBegin;
- USHORT DestPortEnd;
-
- UCHAR SrcTOS;
- UCHAR SrcProtocol;
-} ADD_CONNECTION, *PADD_CONNECTION;
-
-typedef struct _CLASSIFICATION_RULE {
- UCHAR ucIPSrcAddrLen;
- UCHAR ucIPSrcAddr[32];
- UCHAR ucIPDestAddrLen;
- UCHAR ucIPDestAddr[32];
- UCHAR ucSrcPortRangeLen;
- UCHAR ucSrcPortRange[4];
- UCHAR ucDestPortRangeLen;
- UCHAR ucDestPortRange[4];
- USHORT usVcid;
-} CLASSIFICATION_RULE, *PCLASSIFICATION_RULE;
-
-typedef struct _CLASSIFICATION_ONLY {
- USHORT usVcid;
- ULONG DestIpAddress;
- ULONG DestIpMask;
- USHORT usPortLo;
- USHORT usPortHi;
- BOOLEAN bIpVersion;
- UCHAR ucDestinationAddress[16];
-} CLASSIFICATION_ONLY, *PCLASSIFICATION_ONLY;
#define MAX_IP_RANGE_LENGTH 4
#define MAX_PORT_RANGE 4
UCHAR ucIpv6Mask[MAX_IP_RANGE_LENGTH * IPV6_ADDRESS_SIZEINBYTES];
};
} U_IP_ADDRESS;
-struct _packet_info;
-typedef struct _S_HDR_SUPRESSION_CONTEXTINFO {
- UCHAR ucaHdrSupressionInBuf[MAX_PHS_LENGTHS]; /* Intermediate buffer to accumulate pkt Header for PHS */
- UCHAR ucaHdrSupressionOutBuf[MAX_PHS_LENGTHS + PHSI_LEN]; /* Intermediate buffer containing pkt Header after PHS */
-} S_HDR_SUPRESSION_CONTEXTINFO;
+struct bcm_hdr_suppression_contextinfo {
+ UCHAR ucaHdrSuppressionInBuf[MAX_PHS_LENGTHS]; /* Intermediate buffer to accumulate pkt Header for PHS */
+ UCHAR ucaHdrSuppressionOutBuf[MAX_PHS_LENGTHS + PHSI_LEN]; /* Intermediate buffer containing pkt Header after PHS */
+};
-typedef struct _S_CLASSIFIER_RULE {
+struct bcm_classifier_rule {
ULONG ulSFID;
UCHAR ucReserved[2];
B_UINT16 uiClassifierRuleIndex;
UCHAR usUserPriority[2];
USHORT usVLANID;
USHORT usValidityBitMap;
-} S_CLASSIFIER_RULE;
-/* typedef struct _S_CLASSIFIER_RULE S_CLASSIFIER_RULE; */
+};
-typedef struct _S_FRAGMENTED_PACKET_INFO {
+struct bcm_fragmented_packet_info {
BOOLEAN bUsed;
ULONG ulSrcIpAddress;
USHORT usIpIdentification;
- S_CLASSIFIER_RULE *pstMatchedClassifierEntry;
+ struct bcm_classifier_rule *pstMatchedClassifierEntry;
BOOLEAN bOutOfOrderFragment;
-} S_FRAGMENTED_PACKET_INFO, *PS_FRAGMENTED_PACKET_INFO;
+};
-struct _packet_info {
+struct bcm_packet_info {
/* classification extension Rule */
ULONG ulSFID;
USHORT usVCID_Value;
UCHAR bIPCSSupport;
UCHAR bEthCSSupport;
};
-typedef struct _packet_info PacketInfo;
-typedef struct _PER_TARANG_DATA {
- struct _PER_TARANG_DATA *next;
- struct _MINI_ADAPTER *Adapter;
+struct bcm_tarang_data {
+ struct bcm_tarang_data *next;
+ struct bcm_mini_adapter *Adapter;
struct sk_buff *RxAppControlHead;
struct sk_buff *RxAppControlTail;
int AppCtrlQueueLen;
BOOLEAN bApplicationToExit;
S_MIBS_DROPPED_APP_CNTRL_MESSAGES stDroppedAppCntrlMsgs;
ULONG RxCntrlMsgBitMask;
-} PER_TARANG_DATA, *PPER_TARANG_DATA;
-
-#ifdef REL_4_1
-typedef struct _TARGET_PARAMS {
- B_UINT32 m_u32CfgVersion;
-
- /* Scanning Related Params */
- B_UINT32 m_u32CenterFrequency;
- B_UINT32 m_u32BandAScan;
- B_UINT32 m_u32BandBScan;
- B_UINT32 m_u32BandCScan;
-
- /* QoS Params */
- B_UINT32 m_u32minGrantsize; /* size of minimum grant is 0 or 6 */
- B_UINT32 m_u32PHSEnable;
-
- /* HO Params */
- B_UINT32 m_u32HoEnable;
- B_UINT32 m_u32HoReserved1;
- B_UINT32 m_u32HoReserved2;
-
- /* Power Control Params */
- B_UINT32 m_u32MimoEnable;
- B_UINT32 m_u32SecurityEnable;
- /*
- * bit 1: 1 Idlemode enable;
- * bit 2: 1 Sleepmode Enable
- */
- B_UINT32 m_u32PowerSavingModesEnable;
- /* PowerSaving Mode Options:
- * bit 0 = 1: CPE mode - to keep pcmcia if alive;
- * bit 1 = 1: CINR reporing in Idlemode Msg
- * bit 2 = 1: Default PSC Enable in sleepmode
- */
- B_UINT32 m_u32PowerSavingModeOptions;
-
- B_UINT32 m_u32ArqEnable;
-
- /* From Version #3, the HARQ section renamed as general */
- B_UINT32 m_u32HarqEnable;
- /* EEPROM Param Location */
- B_UINT32 m_u32EEPROMFlag;
- /* BINARY TYPE - 4th MSByte:
- * Interface Type - 3rd MSByte:
- * Vendor Type - 2nd MSByte
- */
- /* Unused - LSByte */
- B_UINT32 m_u32Customize;
- B_UINT32 m_u32ConfigBW; /* In Hz */
- B_UINT32 m_u32ShutDownTimer;
- B_UINT32 m_u32RadioParameter;
- B_UINT32 m_u32PhyParameter1;
- B_UINT32 m_u32PhyParameter2;
- B_UINT32 m_u32PhyParameter3;
-
- /* in eval mode only;
- * lower 16bits = basic cid for testing;
- * then bit 16 is test cqich,
- * bit 17 test init rang;
- * bit 18 test periodic rang
- * bit 19 is test harq ack/nack
- */
- B_UINT32 m_u32TestOptions;
- B_UINT32 m_u32MaxMACDataperDLFrame;
- B_UINT32 m_u32MaxMACDataperULFrame;
- B_UINT32 m_u32Corr2MacFlags;
-
- /* adding driver params. */
- B_UINT32 HostDrvrConfig1;
- B_UINT32 HostDrvrConfig2;
- B_UINT32 HostDrvrConfig3;
- B_UINT32 HostDrvrConfig4;
- B_UINT32 HostDrvrConfig5;
- B_UINT32 HostDrvrConfig6;
- B_UINT32 m_u32SegmentedPUSCenable;
-
- /* BAMC enable - but 4.x does not support this feature
- * This is added just to sync 4.x and 5.x CFGs
- */
- B_UINT32 m_u32BandAMCEnable;
-} STARGETPARAMS, *PSTARGETPARAMS;
-#endif
+};
-typedef struct _STTARGETDSXBUFFER {
+struct bcm_targetdsx_buffer {
ULONG ulTargetDsxBuffer;
B_UINT16 tid;
BOOLEAN valid;
-} STTARGETDSXBUFFER, *PSTTARGETDSXBUFFER;
+};
-typedef int (*FP_FLASH_WRITE)(struct _MINI_ADAPTER *, UINT, PVOID);
+typedef int (*FP_FLASH_WRITE)(struct bcm_mini_adapter *, UINT, PVOID);
-typedef int (*FP_FLASH_WRITE_STATUS)(struct _MINI_ADAPTER *, UINT, PVOID);
+typedef int (*FP_FLASH_WRITE_STATUS)(struct bcm_mini_adapter *, UINT, PVOID);
/*
* Driver adapter data structure
*/
-struct _MINI_ADAPTER {
- struct _MINI_ADAPTER *next;
+struct bcm_mini_adapter {
+ struct bcm_mini_adapter *next;
struct net_device *dev;
u32 msg_enable;
CHAR *caDsxReqResp;
struct sk_buff *RxControlTail;
struct semaphore RxAppControlQueuelock;
struct semaphore fw_download_sema;
- PPER_TARANG_DATA pTarangs;
+ struct bcm_tarang_data *pTarangs;
spinlock_t control_queue_lock;
wait_queue_head_t process_read_wait_queue;
USHORT PrevNumRecvDescs;
USHORT CurrNumRecvDescs;
UINT u32TotalDSD;
- PacketInfo PackInfo[NO_OF_QUEUES];
- S_CLASSIFIER_RULE astClassifierTable[MAX_CLASSIFIERS];
+ struct bcm_packet_info PackInfo[NO_OF_QUEUES];
+ struct bcm_classifier_rule astClassifierTable[MAX_CLASSIFIERS];
BOOLEAN TransferMode;
/*************** qos ******************/
UINT index_datpkt;
struct semaphore rdmwrmsync;
- STTARGETDSXBUFFER astTargetDsxBuffer[MAX_TARGET_DSX_BUFFERS];
+ struct bcm_targetdsx_buffer astTargetDsxBuffer[MAX_TARGET_DSX_BUFFERS];
ULONG ulFreeTargetBufferCnt;
ULONG ulCurrentTargetBuffer;
ULONG ulTotalTargetBuffersAvailable;
BOOLEAN bLinkDownRequested;
int downloadDDR;
PHS_DEVICE_EXTENSION stBCMPhsContext;
- S_HDR_SUPRESSION_CONTEXTINFO stPhsTxContextInfo;
+ struct bcm_hdr_suppression_contextinfo stPhsTxContextInfo;
uint8_t ucaPHSPktRestoreBuf[2048];
uint8_t bPHSEnabled;
BOOLEAN AutoFirmDld;
BOOLEAN bDPLLConfig;
UINT32 aTxPktSizeHist[MIBS_MAX_HIST_ENTRIES];
UINT32 aRxPktSizeHist[MIBS_MAX_HIST_ENTRIES];
- S_FRAGMENTED_PACKET_INFO astFragmentedPktClassifierTable[MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES];
+ struct bcm_fragmented_packet_info astFragmentedPktClassifierTable[MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES];
atomic_t uiMBupdate;
UINT32 PmuMode;
NVM_TYPE eNVMType;
UINT gpioBitMap;
S_BCM_DEBUG_STATE stDebugState;
};
-typedef struct _MINI_ADAPTER MINI_ADAPTER, *PMINI_ADAPTER;
#define GET_BCM_ADAPTER(net_dev) netdev_priv(net_dev)
-struct _ETH_HEADER_STRUC {
+struct bcm_eth_header {
UCHAR au8DestinationAddress[6];
UCHAR au8SourceAddress[6];
USHORT u16Etype;
} __packed;
-typedef struct _ETH_HEADER_STRUC ETH_HEADER_STRUC, *PETH_HEADER_STRUC;
-typedef struct FirmwareInfo {
+struct bcm_firmware_info {
void __user *pvMappedFirmwareAddress;
ULONG u32FirmwareLength;
ULONG u32StartingAddress;
-} __packed FIRMWARE_INFO, *PFIRMWARE_INFO;
+} __packed;
/* holds the value of net_device structure.. */
extern struct net_device *gblpnetdev;
-typedef struct _cntl_pkt {
- PMINI_ADAPTER Adapter;
- PLEADER PLeader;
-} cntl_pkt;
-typedef LINK_REQUEST CONTROL_MESSAGE;
-typedef struct _DDR_SETTING {
+struct bcm_ddr_setting {
UINT ulRegAddress;
UINT ulRegValue;
-} DDR_SETTING, *PDDR_SETTING;
-typedef DDR_SETTING DDR_SET_NODE, *PDDR_SET_NODE;
-int InitAdapter(PMINI_ADAPTER psAdapter);
+};
+int InitAdapter(struct bcm_mini_adapter *psAdapter);
/* =====================================================================
* Beceem vendor request codes for EP0
#define EP5 4
#define EP6 5
-typedef enum eInterface_setting {
+enum bcm_einterface_setting {
DEFAULT_SETTING_0 = 0,
ALTERNATE_SETTING_1 = 1,
-} INTERFACE_SETTING;
+};
#endif /* __ADAPTER_H__ */
static int bcm_char_open(struct inode *inode, struct file * filp)
{
- PMINI_ADAPTER Adapter = NULL;
- PPER_TARANG_DATA pTarang = NULL;
+ struct bcm_mini_adapter *Adapter = NULL;
+ struct bcm_tarang_data *pTarang = NULL;
Adapter = GET_BCM_ADAPTER(gblpnetdev);
- pTarang = kzalloc(sizeof(PER_TARANG_DATA), GFP_KERNEL);
+ pTarang = kzalloc(sizeof(struct bcm_tarang_data), GFP_KERNEL);
if (!pTarang)
return -ENOMEM;
static int bcm_char_release(struct inode *inode, struct file *filp)
{
- PPER_TARANG_DATA pTarang, tmp, ptmp;
- PMINI_ADAPTER Adapter = NULL;
+ struct bcm_tarang_data *pTarang, *tmp, *ptmp;
+ struct bcm_mini_adapter *Adapter = NULL;
struct sk_buff *pkt, *npkt;
- pTarang = (PPER_TARANG_DATA)filp->private_data;
+ pTarang = (struct bcm_tarang_data *)filp->private_data;
if (pTarang == NULL) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
static ssize_t bcm_char_read(struct file *filp, char __user *buf, size_t size,
loff_t *f_pos)
{
- PPER_TARANG_DATA pTarang = filp->private_data;
- PMINI_ADAPTER Adapter = pTarang->Adapter;
+ struct bcm_tarang_data *pTarang = filp->private_data;
+ struct bcm_mini_adapter *Adapter = pTarang->Adapter;
struct sk_buff *Packet = NULL;
ssize_t PktLen = 0;
int wait_ret_val = 0;
static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
{
- PPER_TARANG_DATA pTarang = filp->private_data;
+ struct bcm_tarang_data *pTarang = filp->private_data;
void __user *argp = (void __user *)arg;
- PMINI_ADAPTER Adapter = pTarang->Adapter;
+ struct bcm_mini_adapter *Adapter = pTarang->Adapter;
INT Status = STATUS_FAILURE;
int timeout = 0;
IOCTL_BUFFER IoBuffer;
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT;
- if (IoBuffer.InputLength < sizeof(struct link_request))
+ if (IoBuffer.InputLength < sizeof(struct bcm_link_request))
return -EINVAL;
if (IoBuffer.InputLength > MAX_CNTL_PKT_SIZE)
}
case IOCTL_BCM_BUFFER_DOWNLOAD: {
- FIRMWARE_INFO *psFwInfo = NULL;
+ struct bcm_firmware_info *psFwInfo = NULL;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
if (!down_trylock(&Adapter->fw_download_sema)) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
"Length for FW DLD is : %lx\n", IoBuffer.InputLength);
- if (IoBuffer.InputLength > sizeof(FIRMWARE_INFO)) {
+ if (IoBuffer.InputLength > sizeof(struct bcm_firmware_info)) {
up(&Adapter->fw_download_sema);
return -EINVAL;
}
break;
case IOCTL_GET_PACK_INFO:
- if (copy_to_user(argp, &Adapter->PackInfo, sizeof(PacketInfo)*NO_OF_QUEUES))
+ if (copy_to_user(argp, &Adapter->PackInfo, sizeof(struct bcm_packet_info)*NO_OF_QUEUES))
return -EFAULT;
Status = STATUS_SUCCESS;
break;
.llseek = no_llseek,
};
-int register_control_device_interface(PMINI_ADAPTER Adapter)
+int register_control_device_interface(struct bcm_mini_adapter *Adapter)
{
if (Adapter->major > 0)
return 0;
}
-void unregister_control_device_interface(PMINI_ADAPTER Adapter)
+void unregister_control_device_interface(struct bcm_mini_adapter *Adapter)
{
if (Adapter->major > 0) {
device_destroy(bcm_class, MKDEV(Adapter->major, 0));
static INT bcm_open(struct net_device *dev)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(dev);
if (Adapter->fw_download_done == FALSE) {
pr_notice(PFX "%s: link up failed (download in progress)\n",
static INT bcm_close(struct net_device *dev)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(dev);
if (netif_msg_ifdown(Adapter))
pr_info(PFX "%s: disabling interface\n", dev->name);
static netdev_tx_t bcm_transmit(struct sk_buff *skb, struct net_device *dev)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(dev);
u16 qindex = skb_get_queue_mapping(skb);
static void bcm_get_drvinfo(struct net_device *dev,
struct ethtool_drvinfo *info)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(dev);
PS_INTERFACE_ADAPTER psIntfAdapter = Adapter->pvInterfaceAdapter;
struct usb_device *udev = interface_to_usbdev(psIntfAdapter->interface);
static u32 bcm_get_link(struct net_device *dev)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(dev);
return Adapter->LinkUpStatus;
}
static u32 bcm_get_msglevel(struct net_device *dev)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(dev);
return Adapter->msg_enable;
}
static void bcm_set_msglevel(struct net_device *dev, u32 level)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(dev);
Adapter->msg_enable = level;
}
.set_msglevel = bcm_set_msglevel,
};
-int register_networkdev(PMINI_ADAPTER Adapter)
+int register_networkdev(struct bcm_mini_adapter *Adapter)
{
struct net_device *net = Adapter->dev;
PS_INTERFACE_ADAPTER IntfAdapter = Adapter->pvInterfaceAdapter;
return 0;
}
-void unregister_networkdev(PMINI_ADAPTER Adapter)
+void unregister_networkdev(struct bcm_mini_adapter *Adapter)
{
struct net_device *net = Adapter->dev;
PS_INTERFACE_ADAPTER IntfAdapter = Adapter->pvInterfaceAdapter;
eDeleteClassifier
};
-static ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter, B_UINT16 tid);
+static ULONG GetNextTargetBufferLocation(struct bcm_mini_adapter *Adapter, B_UINT16 tid);
/************************************************************
* Function - SearchSfid
* Returns - Queue index for this SFID(If matched)
* Else Invalid Queue Index(If Not matched)
************************************************************/
-int SearchSfid(PMINI_ADAPTER Adapter, UINT uiSfid)
+int SearchSfid(struct bcm_mini_adapter *Adapter, UINT uiSfid)
{
int i;
* Returns - Queue index for the free SFID
* Else returns Invalid Index.
****************************************************************/
-static int SearchFreeSfid(PMINI_ADAPTER Adapter)
+static int SearchFreeSfid(struct bcm_mini_adapter *Adapter)
{
int i;
/*
* Function: SearchClsid
* Description: This routinue would search Classifier having specified ClassifierID as input parameter
- * Input parameters: PMINI_ADAPTER Adapter - Adapter Context
+ * Input parameters: struct bcm_mini_adapter *Adapter - Adapter Context
* unsigned int uiSfid - The SF in which the classifier is to searched
* B_UINT16 uiClassifierID - The classifier ID to be searched
* Return: int :Classifier table index of matching entry
*/
-static int SearchClsid(PMINI_ADAPTER Adapter, ULONG ulSFID, B_UINT16 uiClassifierID)
+static int SearchClsid(struct bcm_mini_adapter *Adapter, ULONG ulSFID, B_UINT16 uiClassifierID)
{
int i;
* This routinue would search Free available Classifier entry in classifier table.
* @return free Classifier Entry index in classifier table for specified SF
*/
-static int SearchFreeClsid(PMINI_ADAPTER Adapter /**Adapter Context*/)
+static int SearchFreeClsid(struct bcm_mini_adapter *Adapter /**Adapter Context*/)
{
int i;
return MAX_CLASSIFIERS+1;
}
-static VOID deleteSFBySfid(PMINI_ADAPTER Adapter, UINT uiSearchRuleIndex)
+static VOID deleteSFBySfid(struct bcm_mini_adapter *Adapter, UINT uiSearchRuleIndex)
{
/* deleting all the packet held in the SF */
flush_queue(Adapter, uiSearchRuleIndex);
}
static inline VOID
-CopyIpAddrToClassifier(S_CLASSIFIER_RULE *pstClassifierEntry,
+CopyIpAddrToClassifier(struct bcm_classifier_rule *pstClassifierEntry,
B_UINT8 u8IpAddressLen, B_UINT8 *pu8IpAddressMaskSrc,
BOOLEAN bIpVersion6, E_IPADDR_CONTEXT eIpAddrContext)
{
UINT nSizeOfIPAddressInBytes = IP_LENGTH_OF_ADDRESS;
UCHAR *ptrClassifierIpAddress = NULL;
UCHAR *ptrClassifierIpMask = NULL;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if (bIpVersion6)
nSizeOfIPAddressInBytes = IPV6_ADDRESS_SIZEINBYTES;
}
}
-void ClearTargetDSXBuffer(PMINI_ADAPTER Adapter, B_UINT16 TID, BOOLEAN bFreeAll)
+void ClearTargetDSXBuffer(struct bcm_mini_adapter *Adapter, B_UINT16 TID, BOOLEAN bFreeAll)
{
int i;
* @ingroup ctrl_pkt_functions
* copy classifier rule into the specified SF index
*/
-static inline VOID CopyClassifierRuleToSF(PMINI_ADAPTER Adapter, stConvergenceSLTypes *psfCSType, UINT uiSearchRuleIndex, UINT nClassifierIndex)
+static inline VOID CopyClassifierRuleToSF(struct bcm_mini_adapter *Adapter, stConvergenceSLTypes *psfCSType, UINT uiSearchRuleIndex, UINT nClassifierIndex)
{
- S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
+ struct bcm_classifier_rule *pstClassifierEntry = NULL;
/* VOID *pvPhsContext = NULL; */
int i;
/* UCHAR ucProtocolLength=0; */
/*
* @ingroup ctrl_pkt_functions
*/
-static inline VOID DeleteClassifierRuleFromSF(PMINI_ADAPTER Adapter, UINT uiSearchRuleIndex, UINT nClassifierIndex)
+static inline VOID DeleteClassifierRuleFromSF(struct bcm_mini_adapter *Adapter, UINT uiSearchRuleIndex, UINT nClassifierIndex)
{
- S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
+ struct bcm_classifier_rule *pstClassifierEntry = NULL;
B_UINT16 u16PacketClassificationRuleIndex;
USHORT usVCID;
/* VOID *pvPhsContext = NULL; */
if (pstClassifierEntry) {
pstClassifierEntry->bUsed = FALSE;
pstClassifierEntry->uiClassifierRuleIndex = 0;
- memset(pstClassifierEntry, 0, sizeof(S_CLASSIFIER_RULE));
+ memset(pstClassifierEntry, 0, sizeof(struct bcm_classifier_rule));
/* Delete the PHS Rule for this classifier */
PhsDeleteClassifierRule(&Adapter->stBCMPhsContext, usVCID, u16PacketClassificationRuleIndex);
/*
* @ingroup ctrl_pkt_functions
*/
-VOID DeleteAllClassifiersForSF(PMINI_ADAPTER Adapter, UINT uiSearchRuleIndex)
+VOID DeleteAllClassifiersForSF(struct bcm_mini_adapter *Adapter, UINT uiSearchRuleIndex)
{
- S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
+ struct bcm_classifier_rule *pstClassifierEntry = NULL;
int i;
/* B_UINT16 u16PacketClassificationRuleIndex; */
USHORT ulVCID;
* related data into the Adapter structure.
* @ingroup ctrl_pkt_functions
*/
-static VOID CopyToAdapter(register
PMINI_ADAPTER Adapter, /* <Pointer to the Adapter structure */
+static VOID CopyToAdapter(register
struct bcm_mini_adapter *Adapter, /* <Pointer to the Adapter structure */
register pstServiceFlowParamSI psfLocalSet, /* <Pointer to the ServiceFlowParamSI structure */
register UINT uiSearchRuleIndex, /* <Index of Queue, to which this data belongs */
register UCHAR ucDsxType,
int nIndex;
stLocalSFAddIndicationAlt *pstAddIndication;
UINT nCurClassifierCnt;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
pstAddIndication = (stLocalSFAddIndicationAlt *)pvBuffer;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, "======>");
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_CONTROL, DBG_LVL_ALL, " bValid: 0x%X", pstAddIndication->sfActiveSet.bValid);
}
-static inline ULONG RestoreSFParam(PMINI_ADAPTER Adapter, ULONG ulAddrSFParamSet, PUCHAR pucDestBuffer)
+static inline ULONG RestoreSFParam(struct bcm_mini_adapter *Adapter, ULONG ulAddrSFParamSet, PUCHAR pucDestBuffer)
{
UINT nBytesToRead = sizeof(stServiceFlowParamSI);
return 1;
}
-static ULONG StoreSFParam(PMINI_ADAPTER Adapter, PUCHAR pucSrcBuffer, ULONG ulAddrSFParamSet)
+static ULONG StoreSFParam(struct bcm_mini_adapter *Adapter, PUCHAR pucSrcBuffer, ULONG ulAddrSFParamSet)
{
UINT nBytesToWrite = sizeof(stServiceFlowParamSI);
int ret = 0;
return 1;
}
-ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter, PVOID pvBuffer, UINT *puBufferLength)
+ULONG StoreCmControlResponseMessage(struct bcm_mini_adapter *Adapter, PVOID pvBuffer, UINT *puBufferLength)
{
stLocalSFAddIndicationAlt *pstAddIndicationAlt = NULL;
stLocalSFAddIndication *pstAddIndication = NULL;
}
static inline stLocalSFAddIndicationAlt
-*RestoreCmControlResponseMessage(register PMINI_ADAPTER Adapter, register PVOID pvBuffer)
+*RestoreCmControlResponseMessage(register struct bcm_mini_adapter *Adapter, register PVOID pvBuffer)
{
ULONG ulStatus = 0;
stLocalSFAddIndication *pstAddIndication = NULL;
return NULL;
}
-ULONG SetUpTargetDsxBuffers(PMINI_ADAPTER Adapter)
+ULONG SetUpTargetDsxBuffers(struct bcm_mini_adapter *Adapter)
{
ULONG ulTargetDsxBuffersBase = 0;
ULONG ulCntTargetBuffers;
return 1;
}
-static ULONG GetNextTargetBufferLocation(PMINI_ADAPTER Adapter, B_UINT16 tid)
+static ULONG GetNextTargetBufferLocation(struct bcm_mini_adapter *Adapter, B_UINT16 tid)
{
ULONG ulTargetDSXBufferAddress;
ULONG ulTargetDsxBufferIndexToUse, ulMaxTry;
return ulTargetDSXBufferAddress;
}
-int AllocAdapterDsxBuffer(PMINI_ADAPTER Adapter)
+int AllocAdapterDsxBuffer(struct bcm_mini_adapter *Adapter)
{
/*
* Need to Allocate memory to contain the SUPER Large structures
return 0;
}
-int FreeAdapterDsxBuffer(PMINI_ADAPTER Adapter)
+int FreeAdapterDsxBuffer(struct bcm_mini_adapter *Adapter)
{
kfree(Adapter->caDsxReqResp);
return 0;
* for the Connection Management.
* @return - Queue index for the free SFID else returns Invalid Index.
*/
-BOOLEAN CmControlResponseMessage(
PMINI_ADAPTER Adapter, /* <Pointer to the Adapter structure */
+BOOLEAN CmControlResponseMessage(
struct bcm_mini_adapter *Adapter, /* <Pointer to the Adapter structure */
PVOID pvBuffer /* Starting Address of the Buffer, that contains the AddIndication Data */)
{
stServiceFlowParamSI *psfLocalSet = NULL;
stLocalSFAddIndicationAlt *pstAddIndication = NULL;
stLocalSFChangeIndicationAlt *pstChangeIndication = NULL;
- PLEADER pLeader = NULL;
+ struct bcm_leader *pLeader = NULL;
/*
* Otherwise the message contains a target address from where we need to
DumpCmControlPacket(pstAddIndication);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "====>");
- pLeader = (PLEADER)Adapter->caDsxReqResp;
+ pLeader = (struct bcm_leader *)Adapter->caDsxReqResp;
pLeader->Status = CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ;
pLeader->Vcid = 0;
return TRUE;
}
-int get_dsx_sf_data_to_application(PMINI_ADAPTER Adapter, UINT uiSFId, void __user *user_buffer)
+int get_dsx_sf_data_to_application(struct bcm_mini_adapter *Adapter, UINT uiSFId, void __user *user_buffer)
{
int status = 0;
- struct _packet_info *psSfInfo = NULL;
+ struct bcm_packet_info *psSfInfo = NULL;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG, DBG_LVL_ALL, "status =%d", status);
status = SearchSfid(Adapter, uiSFId);
return STATUS_SUCCESS;
}
-VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter, PUINT puiBuffer)
+VOID OverrideServiceFlowParams(struct bcm_mini_adapter *Adapter, PUINT puiBuffer)
{
B_UINT32 u32NumofSFsinMsg = ntohl(*(puiBuffer + 1));
stIM_SFHostNotify *pHostInfo = NULL;
}stLocalSFChangeIndicationAlt;
-ULONG StoreCmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer,UINT *puBufferLength);
+ULONG StoreCmControlResponseMessage(struct bcm_mini_adapter *Adapter, PVOID pvBuffer,UINT *puBufferLength);
-INT AllocAdapterDsxBuffer(PMINI_ADAPTER Adapter);
+INT AllocAdapterDsxBuffer(struct bcm_mini_adapter *Adapter);
-INT FreeAdapterDsxBuffer(PMINI_ADAPTER Adapter);
-ULONG SetUpTargetDsxBuffers(PMINI_ADAPTER Adapter);
+INT FreeAdapterDsxBuffer(struct bcm_mini_adapter *Adapter);
+ULONG SetUpTargetDsxBuffers(struct bcm_mini_adapter *Adapter);
-BOOLEAN CmControlResponseMessage(PMINI_ADAPTER Adapter,PVOID pvBuffer);
+BOOLEAN CmControlResponseMessage(struct bcm_mini_adapter *Adapter, PVOID pvBuffer);
#pragma pack (pop)
//DDR INIT-133Mhz
#define T3_SKIP_CLOCK_PROGRAM_DUMP_133MHZ 12 //index for 0x0F007000
-static DDR_SET_NODE asT3_DDRSetting133MHz[]= {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3_DDRSetting133MHz[]= {// # DPLL Clock Setting
{0x0F000800,0x00007212},
{0x0f000820,0x07F13FFF},
{0x0f000810,0x00000F95},
};
//80Mhz
#define T3_SKIP_CLOCK_PROGRAM_DUMP_80MHZ 10 //index for 0x0F007000
-static DDR_SET_NODE asT3_DDRSetting80MHz[]= {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3_DDRSetting80MHz[]= {// # DPLL Clock Setting
{0x0f000810,0x00000F95},
{0x0f000820,0x07f1ffff},
{0x0f000860,0x00000000},
};
//100Mhz
#define T3_SKIP_CLOCK_PROGRAM_DUMP_100MHZ 13 //index for 0x0F007000
-static DDR_SET_NODE asT3_DDRSetting100MHz[]= {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3_DDRSetting100MHz[]= {// # DPLL Clock Setting
{0x0F000800,0x00007008},
{0x0f000810,0x00000F95},
{0x0f000820,0x07F13E3F},
//Net T3B DDR Settings
//DDR INIT-133Mhz
-static DDR_SET_NODE asDPLL_266MHZ[] = {
+static struct bcm_ddr_setting asDPLL_266MHZ[] = {
{0x0F000800,0x00007212},
{0x0f000820,0x07F13FFF},
{0x0f000810,0x00000F95},
};
#define T3B_SKIP_CLOCK_PROGRAM_DUMP_133MHZ 11 //index for 0x0F007000
-static DDR_SET_NODE asT3B_DDRSetting133MHz[] = {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3B_DDRSetting133MHz[] = {// # DPLL Clock Setting
{0x0f000810,0x00000F95},
{0x0f000810,0x00000F95},
{0x0f000810,0x00000F95},
};
#define T3B_SKIP_CLOCK_PROGRAM_DUMP_80MHZ 9 //index for 0x0F007000
-static DDR_SET_NODE asT3B_DDRSetting80MHz[] = {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3B_DDRSetting80MHz[] = {// # DPLL Clock Setting
{0x0f000810,0x00000F95},
{0x0f000820,0x07F13FFF},
{0x0f000840,0x0FFF1F00},
//100Mhz
#define T3B_SKIP_CLOCK_PROGRAM_DUMP_100MHZ 9 //index for 0x0F007000
-static DDR_SET_NODE asT3B_DDRSetting100MHz[] = {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3B_DDRSetting100MHz[] = {// # DPLL Clock Setting
{0x0f000810,0x00000F95},
{0x0f000820,0x07F1369B},
{0x0f000840,0x0FFF0800},
#define T3LP_SKIP_CLOCK_PROGRAM_DUMP_133MHZ 9 //index for 0x0F007000
-static DDR_SET_NODE asT3LP_DDRSetting133MHz[]= {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3LP_DDRSetting133MHz[]= {// # DPLL Clock Setting
{0x0f000820,0x03F1365B},
{0x0f000810,0x00002F95},
{0x0f000880,0x000003DD},
};
#define T3LP_SKIP_CLOCK_PROGRAM_DUMP_100MHZ 11 //index for 0x0F007000
-static DDR_SET_NODE asT3LP_DDRSetting100MHz[]= {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3LP_DDRSetting100MHz[]= {// # DPLL Clock Setting
{0x0f000810,0x00002F95},
{0x0f000820,0x03F1369B},
{0x0f000840,0x0fff0000},
};
#define T3LP_SKIP_CLOCK_PROGRAM_DUMP_80MHZ 9 //index for 0x0F007000
-static DDR_SET_NODE asT3LP_DDRSetting80MHz[]= {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3LP_DDRSetting80MHz[]= {// # DPLL Clock Setting
{0x0f000820,0x07F13FFF},
{0x0f000810,0x00002F95},
{0x0f000860,0x00000000},
///T3 LP-B (UMA-B)
#define T3LPB_SKIP_CLOCK_PROGRAM_DUMP_160MHZ 7 //index for 0x0F007000
-static DDR_SET_NODE asT3LPB_DDRSetting160MHz[]= {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3LPB_DDRSetting160MHz[]= {// # DPLL Clock Setting
{0x0f000820,0x03F137DB},
{0x0f000810,0x01842795},
#define T3LPB_SKIP_CLOCK_PROGRAM_DUMP_133MHZ 7 //index for 0x0F007000
-static DDR_SET_NODE asT3LPB_DDRSetting133MHz[]= {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3LPB_DDRSetting133MHz[]= {// # DPLL Clock Setting
{0x0f000820,0x03F1365B},
{0x0f000810,0x00002F95},
{0x0f000880,0x000003DD},
};
#define T3LPB_SKIP_CLOCK_PROGRAM_DUMP_100MHZ 8 //index for 0x0F007000
-static DDR_SET_NODE asT3LPB_DDRSetting100MHz[]= {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3LPB_DDRSetting100MHz[]= {// # DPLL Clock Setting
{0x0f000810,0x00002F95},
{0x0f000820,0x03F1369B},
{0x0f000840,0x0fff0000},
};
#define T3LPB_SKIP_CLOCK_PROGRAM_DUMP_80MHZ 7 //index for 0x0F007000
-static DDR_SET_NODE asT3LPB_DDRSetting80MHz[]= {// # DPLL Clock Setting
+static struct bcm_ddr_setting asT3LPB_DDRSetting80MHz[]= {// # DPLL Clock Setting
{0x0f000820,0x07F13FFF},
{0x0f000810,0x00002F95},
{0x0f000860,0x00000000},
};
-int ddr_init(MINI_ADAPTER *Adapter)
+int ddr_init(struct bcm_mini_adapter *Adapter)
{
- PDDR_SETTING psDDRSetting=NULL;
+ struct bcm_ddr_setting *psDDRSetting=NULL;
ULONG RegCount=0;
UINT value = 0;
UINT uiResetValue = 0;
case DDR_80_MHZ:
psDDRSetting=asT3LP_DDRSetting80MHz;
RegCount=(sizeof(asT3LP_DDRSetting80MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
break;
case DDR_100_MHZ:
psDDRSetting=asT3LP_DDRSetting100MHz;
RegCount=(sizeof(asT3LP_DDRSetting100MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
break;
case DDR_133_MHZ:
psDDRSetting=asT3LP_DDRSetting133MHz;
RegCount=(sizeof(asT3LP_DDRSetting133MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
if(Adapter->bMipsConfig == MIPS_200_MHZ)
{
uiClockSetting = 0x03F13652;
case DDR_80_MHZ:
psDDRSetting = asT3LPB_DDRSetting80MHz;
RegCount=(sizeof(asT3B_DDRSetting80MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
break;
case DDR_100_MHZ:
psDDRSetting=asT3LPB_DDRSetting100MHz;
RegCount=(sizeof(asT3B_DDRSetting100MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
break;
case DDR_133_MHZ:
psDDRSetting = asT3LPB_DDRSetting133MHz;
RegCount=(sizeof(asT3B_DDRSetting133MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
if(Adapter->bMipsConfig == MIPS_200_MHZ)
{
case DDR_160_MHZ:
psDDRSetting = asT3LPB_DDRSetting160MHz;
- RegCount = sizeof(asT3LPB_DDRSetting160MHz)/sizeof(DDR_SETTING);
+ RegCount = sizeof(asT3LPB_DDRSetting160MHz)/sizeof(struct bcm_ddr_setting);
if(Adapter->bMipsConfig == MIPS_200_MHZ)
{
case DDR_80_MHZ:
psDDRSetting = asT3_DDRSetting80MHz;
RegCount = (sizeof(asT3_DDRSetting80MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
break;
case DDR_100_MHZ:
psDDRSetting = asT3_DDRSetting100MHz;
RegCount = (sizeof(asT3_DDRSetting100MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
break;
case DDR_133_MHZ:
psDDRSetting = asT3_DDRSetting133MHz;
RegCount = (sizeof(asT3_DDRSetting133MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
break;
default:
return -EINVAL;
case DDR_80_MHZ:
psDDRSetting = asT3B_DDRSetting80MHz;
RegCount=(sizeof(asT3B_DDRSetting80MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
break;
case DDR_100_MHZ:
psDDRSetting=asT3B_DDRSetting100MHz;
RegCount=(sizeof(asT3B_DDRSetting100MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
break;
case DDR_133_MHZ:
sizeof(asDPLL_266MHZ));
psDDRSetting = asT3B_DDRSetting133MHz;
RegCount=(sizeof(asT3B_DDRSetting133MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
}
else
{
psDDRSetting = asT3B_DDRSetting133MHz;
RegCount=(sizeof(asT3B_DDRSetting133MHz)/
- sizeof(DDR_SETTING));
+ sizeof(struct bcm_ddr_setting));
if(Adapter->bMipsConfig == MIPS_200_MHZ)
{
uiClockSetting = 0x07F13652;
return retval;
}
-int download_ddr_settings(PMINI_ADAPTER Adapter)
+int download_ddr_settings(struct bcm_mini_adapter *Adapter)
{
- PDDR_SET_NODE psDDRSetting=NULL;
+ struct bcm_ddr_setting *psDDRSetting=NULL;
ULONG RegCount=0;
unsigned long ul_ddr_setting_load_addr = DDR_DUMP_INTERNAL_DEVICE_MEMORY;
UINT value = 0;
}
ul_ddr_setting_load_addr+=sizeof(ULONG);
- RegCount*=(sizeof(DDR_SETTING)/sizeof(ULONG));
+ RegCount*=(sizeof(struct bcm_ddr_setting)/sizeof(ULONG));
while(RegCount && !retval)
{
-int ddr_init(PMINI_ADAPTER psAdapter);
-int download_ddr_settings(PMINI_ADAPTER psAdapter);
+int ddr_init(struct bcm_mini_adapter *psAdapter);
+int download_ddr_settings(struct bcm_mini_adapter *psAdapter);
#endif
* Enqueue the control packet for Application.
* @return None
*/
-static VOID handle_rx_control_packet(PMINI_ADAPTER Adapter, struct sk_buff *skb)
+static VOID handle_rx_control_packet(struct bcm_mini_adapter *Adapter, struct sk_buff *skb)
{
- PPER_TARANG_DATA pTarang = NULL;
+ struct bcm_tarang_data *pTarang = NULL;
BOOLEAN HighPriorityMessage = FALSE;
struct sk_buff *newPacket = NULL;
CHAR cntrl_msg_mask_bit = 0;
* @ingroup ctrl_pkt_functions
* Thread to handle control pkt reception
*/
-int control_packet_handler(PMINI_ADAPTER Adapter /* pointer to adapter object*/)
+int control_packet_handler(struct bcm_mini_adapter *Adapter /* pointer to adapter object*/)
{
struct sk_buff *ctrl_packet = NULL;
unsigned long flags = 0;
INT flushAllAppQ(void)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
- PPER_TARANG_DATA pTarang = NULL;
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_tarang_data *pTarang = NULL;
struct sk_buff *PacketToDrop = NULL;
for (pTarang = Adapter->pTarangs; pTarang; pTarang = pTarang->next) {
while (pTarang->RxAppControlHead != NULL) {
#include "headers.h"
-static BOOLEAN MatchSrcIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule,
+static BOOLEAN MatchSrcIpv6Address(struct bcm_classifier_rule *pstClassifierRule,
IPV6Header *pstIpv6Header);
-static BOOLEAN MatchDestIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule,
+static BOOLEAN MatchDestIpv6Address(struct bcm_classifier_rule *pstClassifierRule,
IPV6Header *pstIpv6Header);
static VOID DumpIpv6Header(IPV6Header *pstIpv6Header);
UCHAR *pucRetHeaderPtr = NULL;
UCHAR *pucPayloadPtr = NULL;
USHORT usNextHeaderOffset = 0 ;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if ((ppucPayload == NULL) || (*pusPayloadLength == 0) ||
(*bParseDone)) {
BOOLEAN bDone = FALSE;
UCHAR ucHeaderType = 0;
UCHAR *pucNextHeader = NULL;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if (!pucPayload || (usPayloadLength == 0))
return 0;
/*
- * Arg 1 PMINI_ADAPTER Adapter is a pointer ot the driver contorl structure
+ * Arg 1 struct bcm_mini_adapter *Adapter is a pointer ot the driver contorl structure
* Arg 2 PVOID pcIpHeader is a pointer to the IP header of the packet
*/
-USHORT IpVersion6(PMINI_ADAPTER Adapter, PVOID pcIpHeader,
- S_CLASSIFIER_RULE *pstClassifierRule)
+USHORT IpVersion6(struct bcm_mini_adapter *Adapter, PVOID pcIpHeader,
+ struct bcm_classifier_rule *pstClassifierRule)
{
USHORT ushDestPort = 0;
USHORT ushSrcPort = 0;
}
-static BOOLEAN MatchSrcIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule,
+static BOOLEAN MatchSrcIpv6Address(struct bcm_classifier_rule *pstClassifierRule,
IPV6Header *pstIpv6Header)
{
UINT uiLoopIndex = 0;
UINT uiIpv6AddIndex = 0;
UINT uiIpv6AddrNoLongWords = 4;
ULONG aulSrcIP[4];
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
/*
* This is the no. of Src Addresses ie Range of IP Addresses contained
* in the classifier rule for which we need to match
return FALSE;
}
-static BOOLEAN MatchDestIpv6Address(S_CLASSIFIER_RULE *pstClassifierRule,
+static BOOLEAN MatchDestIpv6Address(struct bcm_classifier_rule *pstClassifierRule,
IPV6Header *pstIpv6Header)
{
UINT uiLoopIndex = 0;
UINT uiIpv6AddIndex = 0;
UINT uiIpv6AddrNoLongWords = 4;
ULONG aulDestIP[4];
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
/*
* This is the no. of Destination Addresses
* ie Range of IP Addresses contained in the classifier rule
{
UINT uiIpv6AddrNoLongWords = 4;
UINT uiIpv6AddIndex = 0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
for (uiIpv6AddIndex = 0; uiIpv6AddIndex < uiIpv6AddrNoLongWords; uiIpv6AddIndex++) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV6_DBG, DBG_LVL_ALL,
":%lx", puIpv6Address[uiIpv6AddIndex]);
{
UCHAR ucVersion;
UCHAR ucPrio;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV6_DBG, DBG_LVL_ALL,
"----Ipv6 Header---");
ucVersion = pstIpv6Header->ucVersionPrio & 0xf0;
//Function Prototypes
-USHORT IpVersion6(PMINI_ADAPTER Adapter, /**< Pointer to the driver control structure */
+USHORT IpVersion6(struct bcm_mini_adapter *Adapter, /**< Pointer to the driver control structure */
PVOID pcIpHeader, /**<Pointer to the IP Hdr of the packet*/
- S_CLASSIFIER_RULE *pstClassifierRule );
+ struct bcm_classifier_rule *pstClassifierRule );
VOID DumpIpv6Address(ULONG *puIpv6Address);
-extern BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort);
-extern BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort);
-extern BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucProtocol);
+extern BOOLEAN MatchSrcPort(struct bcm_classifier_rule *pstClassifierRule,USHORT ushSrcPort);
+extern BOOLEAN MatchDestPort(struct bcm_classifier_rule *pstClassifierRule,USHORT ushSrcPort);
+extern BOOLEAN MatchProtocol(struct bcm_classifier_rule *pstClassifierRule,UCHAR ucProtocol);
#endif
atomic_t uNumRcbUsed;
atomic_t uCurrRcb;
- PMINI_ADAPTER psAdapter;
+ struct bcm_mini_adapter *psAdapter;
BOOLEAN bFlashBoot;
BOOLEAN bHighSpeedDevice ;
int errno = 0, len = 0; /* ,is_config_file = 0 */
loff_t pos = 0;
PS_INTERFACE_ADAPTER psIntfAdapter = (PS_INTERFACE_ADAPTER)arg;
- /* PMINI_ADAPTER Adapter = psIntfAdapter->psAdapter; */
+ /* struct bcm_mini_adapter *Adapter = psIntfAdapter->psAdapter; */
char *buff = kmalloc(MAX_TRANSFER_CTRL_BYTE_USB, GFP_KERNEL);
if (!buff)
return Status;
}
-static int bcm_download_config_file(PMINI_ADAPTER Adapter, FIRMWARE_INFO *psFwInfo)
+static int bcm_download_config_file(struct bcm_mini_adapter *Adapter, struct bcm_firmware_info *psFwInfo)
{
int retval = STATUS_SUCCESS;
B_UINT32 value = 0;
static int bcm_compare_buff_contents(unsigned char *readbackbuff, unsigned char *buff, unsigned int len)
{
int retval = STATUS_SUCCESS;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if ((len-sizeof(unsigned int)) < 4) {
if (memcmp(readbackbuff , buff, len))
retval = -EINVAL;
return retval;
}
-int bcm_ioctl_fw_download(PMINI_ADAPTER Adapter, FIRMWARE_INFO *psFwInfo)
+int bcm_ioctl_fw_download(struct bcm_mini_adapter *Adapter, struct bcm_firmware_info *psFwInfo)
{
int retval = STATUS_SUCCESS;
PUCHAR buff = NULL;
return retval;
}
-static INT buffDnld(PMINI_ADAPTER Adapter, PUCHAR mappedbuffer, UINT u32FirmwareLength, ULONG u32StartingAddress)
+static INT buffDnld(struct bcm_mini_adapter *Adapter, PUCHAR mappedbuffer, UINT u32FirmwareLength, ULONG u32StartingAddress)
{
unsigned int len = 0;
int retval = STATUS_SUCCESS;
return retval;
}
-static INT buffRdbkVerify(PMINI_ADAPTER Adapter, PUCHAR mappedbuffer, UINT u32FirmwareLength, ULONG u32StartingAddress)
+static INT buffRdbkVerify(struct bcm_mini_adapter *Adapter, PUCHAR mappedbuffer, UINT u32FirmwareLength, ULONG u32StartingAddress)
{
UINT len = u32FirmwareLength;
INT retval = STATUS_SUCCESS;
return retval;
}
-INT buffDnldVerify(PMINI_ADAPTER Adapter, unsigned char *mappedbuffer, unsigned int u32FirmwareLength, unsigned long u32StartingAddress)
+INT buffDnldVerify(struct bcm_mini_adapter *Adapter, unsigned char *mappedbuffer, unsigned int u32FirmwareLength, unsigned long u32StartingAddress)
{
INT status = STATUS_SUCCESS;
A software abort pattern is written to the device to wake it and necessary power state
transitions from host are performed here.
-Input parameters: IN PMINI_ADAPTER Adapter - Miniport Adapter Context
+Input parameters: IN struct bcm_mini_adapter *Adapter - Miniport Adapter Context
Return: BCM_STATUS_SUCCESS - If Wakeup of the HW Interface was successful.
Necessary power state transitions from host for idle mode or other device specific
initializations are performed here.
-Input parameters: IN PMINI_ADAPTER Adapter - Miniport Adapter Context
+Input parameters: IN struct bcm_mini_adapter * Adapter - Miniport Adapter Context
Return: BCM_STATUS_SUCCESS - If Idle mode response related HW configuration was successful.
*/
-int InterfaceIdleModeRespond(PMINI_ADAPTER Adapter, unsigned int* puiBuffer)
+int InterfaceIdleModeRespond(struct bcm_mini_adapter *Adapter, unsigned int* puiBuffer)
{
int status = STATUS_SUCCESS;
unsigned int uiRegRead = 0;
return status;
}
-static int InterfaceAbortIdlemode(PMINI_ADAPTER Adapter, unsigned int Pattern)
+static int InterfaceAbortIdlemode(struct bcm_mini_adapter *Adapter, unsigned int Pattern)
{
int status = STATUS_SUCCESS;
unsigned int value;
}
return status;
}
-int InterfaceIdleModeWakeup(PMINI_ADAPTER Adapter)
+int InterfaceIdleModeWakeup(struct bcm_mini_adapter *Adapter)
{
ULONG Status = 0;
if(Adapter->bTriedToWakeUpFromlowPowerMode)
return Status;
}
-void InterfaceHandleShutdownModeWakeup(PMINI_ADAPTER Adapter)
+void InterfaceHandleShutdownModeWakeup(struct bcm_mini_adapter *Adapter)
{
unsigned int uiRegVal = 0;
INT Status = 0;
#ifndef _INTERFACE_IDLEMODE_H
#define _INTERFACE_IDLEMODE_H
-INT InterfaceIdleModeWakeup(PMINI_ADAPTER Adapter);
+INT InterfaceIdleModeWakeup(struct bcm_mini_adapter *Adapter);
-INT InterfaceIdleModeRespond(PMINI_ADAPTER Adapter, unsigned int *puiBuffer);
+INT InterfaceIdleModeRespond(struct bcm_mini_adapter *Adapter, unsigned int *puiBuffer);
-VOID InterfaceWriteIdleModeWakePattern(PMINI_ADAPTER Adapter);
+VOID InterfaceWriteIdleModeWakePattern(struct bcm_mini_adapter *Adapter);
-INT InterfaceWakeUp(PMINI_ADAPTER Adapter);
+INT InterfaceWakeUp(struct bcm_mini_adapter * Adapter);
-VOID InterfaceHandleShutdownModeWakeup(PMINI_ADAPTER Adapter);
+VOID InterfaceHandleShutdownModeWakeup(struct bcm_mini_adapter *Adapter);
#endif
AdapterFree(psIntfAdapter->psAdapter);
}
-static void ConfigureEndPointTypesThroughEEPROM(PMINI_ADAPTER Adapter)
+static void ConfigureEndPointTypesThroughEEPROM(struct bcm_mini_adapter *Adapter)
{
unsigned long ulReg = 0;
int bytes;
{
struct usb_device *udev = interface_to_usbdev(intf);
int retval;
- PMINI_ADAPTER psAdapter;
+ struct bcm_mini_adapter *psAdapter;
PS_INTERFACE_ADAPTER psIntfAdapter;
struct net_device *ndev;
/* Reserve one extra queue for the bit-bucket */
- ndev = alloc_etherdev_mq(sizeof(MINI_ADAPTER), NO_OF_QUEUES+1);
+ ndev = alloc_etherdev_mq(sizeof(struct bcm_mini_adapter), NO_OF_QUEUES+1);
if (ndev == NULL) {
dev_err(&udev->dev, DRV_NAME ": no memory for device\n");
return -ENOMEM;
static void usbbcm_disconnect(struct usb_interface *intf)
{
PS_INTERFACE_ADAPTER psIntfAdapter = usb_get_intfdata(intf);
- PMINI_ADAPTER psAdapter;
+ struct bcm_mini_adapter *psAdapter;
struct usb_device *udev = interface_to_usbdev(intf);
if (psIntfAdapter == NULL)
{
int status = urb->status;
PS_INTERFACE_ADAPTER psIntfAdapter = (PS_INTERFACE_ADAPTER)urb->context;
- PMINI_ADAPTER Adapter = psIntfAdapter->psAdapter ;
+ struct bcm_mini_adapter *Adapter = psIntfAdapter->psAdapter ;
if (netif_msg_intr(Adapter))
pr_info(PFX "%s: interrupt status %d\n",
INT StartInterruptUrb(PS_INTERFACE_ADAPTER psIntfAdapter);
-VOID InterfaceEnableInterrupt(PMINI_ADAPTER Adapter);
+VOID InterfaceEnableInterrupt(struct bcm_mini_adapter *Adapter);
-VOID InterfaceDisableInterrupt(PMINI_ADAPTER Adapter);
+VOID InterfaceDisableInterrupt(struct bcm_mini_adapter *Adapter);
#endif
return InterfaceWRM((PS_INTERFACE_ADAPTER)arg, addr, buff, len);
}
-INT Bcm_clear_halt_of_endpoints(PMINI_ADAPTER Adapter)
+INT Bcm_clear_halt_of_endpoints(struct bcm_mini_adapter *Adapter)
{
PS_INTERFACE_ADAPTER psIntfAdapter = (PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter);
INT status = STATUS_SUCCESS;
PVOID buff,
INT len);
-INT Bcm_clear_halt_of_endpoints(PMINI_ADAPTER Adapter);
+INT Bcm_clear_halt_of_endpoints(struct bcm_mini_adapter *Adapter);
VOID Bcm_kill_all_URBs(PS_INTERFACE_ADAPTER psIntfAdapter);
#include "headers.h"
-static int SearchVcid(PMINI_ADAPTER Adapter,unsigned short usVcid)
+static int SearchVcid(struct bcm_mini_adapter *Adapter,unsigned short usVcid)
{
int iIndex=0;
//int idleflag = 0 ;
PUSB_RCB pRcb = (PUSB_RCB)urb->context;
PS_INTERFACE_ADAPTER psIntfAdapter = pRcb->psIntfAdapter;
- PMINI_ADAPTER Adapter = psIntfAdapter->psAdapter;
- PLEADER pLeader = urb->transfer_buffer;
+ struct bcm_mini_adapter *Adapter = psIntfAdapter->psAdapter;
+ struct bcm_leader *pLeader = urb->transfer_buffer;
if (unlikely(netif_msg_rx_status(Adapter)))
pr_info(PFX "%s: rx urb status %d length %d\n",
BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_RX, RX_CTRL, DBG_LVL_ALL, "Received control pkt...");
*(PUSHORT)skb->data = pLeader->Status;
memcpy(skb->data+sizeof(USHORT), urb->transfer_buffer +
- (sizeof(LEADER)), pLeader->PLength);
+ (sizeof(struct bcm_leader)), pLeader->PLength);
skb->len = pLeader->PLength + sizeof(USHORT);
spin_lock(&Adapter->control_queue_lock);
*/
BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_RX, RX_DATA, DBG_LVL_ALL, "Received Data pkt...");
skb_reserve(skb, 2 + SKB_RESERVE_PHS_BYTES);
- memcpy(skb->data+ETH_HLEN, (PUCHAR)urb->transfer_buffer + sizeof(LEADER), pLeader->PLength);
+ memcpy(skb->data+ETH_HLEN, (PUCHAR)urb->transfer_buffer + sizeof(struct bcm_leader), pLeader->PLength);
skb->dev = Adapter->dev;
/* currently skb->len has extra ETH_HLEN bytes in the beginning */
Description: This is the hardware specific Function for Receiving
data packet/control packets from the device.
-Input parameters: IN PMINI_ADAPTER Adapter - Miniport Adapter Context
+Input parameters: IN struct bcm_mini_adapter *Adapter - Miniport Adapter Context
{
PUSB_TCB pTcb= (PUSB_TCB)urb->context;
PS_INTERFACE_ADAPTER psIntfAdapter = pTcb->psIntfAdapter;
- CONTROL_MESSAGE *pControlMsg = (CONTROL_MESSAGE *)urb->transfer_buffer;
- PMINI_ADAPTER psAdapter = psIntfAdapter->psAdapter ;
+ struct bcm_link_request *pControlMsg = (struct bcm_link_request *)urb->transfer_buffer;
+ struct bcm_mini_adapter *psAdapter = psIntfAdapter->psAdapter ;
BOOLEAN bpowerDownMsg = FALSE ;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if (unlikely(netif_msg_tx_done(Adapter)))
pr_info(PFX "%s: transmit status %d\n", Adapter->dev->name, urb->status);
* Returns - None
**********************************************************************/
-static VOID UpdateTokenCount(register PMINI_ADAPTER Adapter)
+static VOID UpdateTokenCount(register struct bcm_mini_adapter *Adapter)
{
ULONG liCurrentTime;
INT i = 0;
* Returns - The number of bytes allowed for transmission.
*
***********************************************************************/
-static ULONG GetSFTokenCount(PMINI_ADAPTER Adapter, PacketInfo *psSF)
+static ULONG GetSFTokenCount(struct bcm_mini_adapter *Adapter, struct bcm_packet_info *psSF)
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TOKEN_COUNTS, DBG_LVL_ALL, "IsPacketAllowedForFlow ===>");
/* Validate the parameters */
This function despatches packet from the specified queue.
@return Zero(success) or Negative value(failure)
*/
-static INT SendPacketFromQueue(PMINI_ADAPTER Adapter,/**<Logical Adapter*/
- PacketInfo *psSF, /**<Queue identifier*/
+static INT SendPacketFromQueue(struct bcm_mini_adapter *Adapter,/**<Logical Adapter*/
+ struct bcm_packet_info *psSF, /**<Queue identifier*/
struct sk_buff* Packet) /**<Pointer to the packet to be sent*/
{
INT Status=STATUS_FAILURE;
* Returns - None.
*
****************************************************************************/
-static VOID CheckAndSendPacketFromIndex(PMINI_ADAPTER Adapter, PacketInfo *psSF)
+static VOID CheckAndSendPacketFromIndex(struct bcm_mini_adapter *Adapter, struct bcm_packet_info *psSF)
{
struct sk_buff *QueuePacket=NULL;
char *pControlPacket = NULL;
{
spin_lock_bh(&psSF->SFQueueLock);
psSF->NumOfPacketsSent++;
- psSF->uiSentBytes+=((PLEADER)pControlPacket)->PLength;
+ psSF->uiSentBytes+=((struct bcm_leader *)pControlPacket)->PLength;
psSF->uiSentPackets++;
atomic_dec(&Adapter->TotalPacketCount);
- psSF->uiCurrentBytesOnHost -= ((PLEADER)pControlPacket)->PLength;
+ psSF->uiCurrentBytesOnHost -= ((struct bcm_leader *)pControlPacket)->PLength;
psSF->uiCurrentPacketsOnHost--;
atomic_inc(&Adapter->index_rd_txcntrlpkt);
spin_unlock_bh(&psSF->SFQueueLock);
*
* Returns - None.
********************************************************************/
-VOID transmit_packets(PMINI_ADAPTER Adapter)
+VOID transmit_packets(struct bcm_mini_adapter *Adapter)
{
UINT uiPrevTotalCount = 0;
int iIndex = 0;
/*Leader related terms */
#define LEADER_STATUS 0x00
#define LEADER_STATUS_TCP_ACK 0x1
-#define LEADER_SIZE sizeof(LEADER)
-#define MAC_ADDR_REQ_SIZE sizeof(PACKETTOSEND)
-#define SS_INFO_REQ_SIZE sizeof(PACKETTOSEND)
+#define LEADER_SIZE sizeof(struct bcm_leader)
+#define MAC_ADDR_REQ_SIZE sizeof(struct bcm_packettosend)
+#define SS_INFO_REQ_SIZE sizeof(struct bcm_packettosend)
#define CM_REQUEST_SIZE (LEADER_SIZE + sizeof(stLocalSFChangeRequest))
-#define IDLE_REQ_SIZE sizeof(PACKETTOSEND)
+#define IDLE_REQ_SIZE sizeof(struct bcm_packettosend)
#define MAX_TRANSFER_CTRL_BYTE_USB (2*1024)
#define IDLE_MODE_WAKEUP_NOTIFIER_ADDRESS 0x1FC02FA8
#define IDLE_MODE_MAX_RETRY_COUNT 1000
-#ifdef REL_4_1
-#define CONFIG_BEGIN_ADDR 0xBF60B004
-#else
#define CONFIG_BEGIN_ADDR 0xBF60B000
-#endif
#define FIRMWARE_BEGIN_ADDR 0xBFC00000
#include "headers.h"
-static int BcmFileDownload(PMINI_ADAPTER Adapter, const char *path, unsigned int loc);
-static VOID doPowerAutoCorrection(PMINI_ADAPTER psAdapter);
-static void HandleShutDownModeRequest(PMINI_ADAPTER Adapter, PUCHAR pucBuffer);
-static int bcm_parse_target_params(PMINI_ADAPTER Adapter);
-static void beceem_protocol_reset(PMINI_ADAPTER Adapter);
+static int BcmFileDownload(struct bcm_mini_adapter *Adapter, const char *path, unsigned int loc);
+static VOID doPowerAutoCorrection(struct bcm_mini_adapter *psAdapter);
+static void HandleShutDownModeRequest(struct bcm_mini_adapter *Adapter, PUCHAR pucBuffer);
+static int bcm_parse_target_params(struct bcm_mini_adapter *Adapter);
+static void beceem_protocol_reset(struct bcm_mini_adapter *Adapter);
-static VOID default_wimax_protocol_initialize(PMINI_ADAPTER Adapter)
+static VOID default_wimax_protocol_initialize(struct bcm_mini_adapter *Adapter)
{
UINT uiLoopIndex;
return;
}
-INT InitAdapter(PMINI_ADAPTER psAdapter)
+INT InitAdapter(struct bcm_mini_adapter *psAdapter)
{
int i = 0;
INT Status = STATUS_SUCCESS;
return STATUS_SUCCESS;
}
-VOID AdapterFree(PMINI_ADAPTER Adapter)
+VOID AdapterFree(struct bcm_mini_adapter *Adapter)
{
int count;
beceem_protocol_reset(Adapter);
free_netdev(Adapter->dev);
}
-static int create_worker_threads(PMINI_ADAPTER psAdapter)
+static int create_worker_threads(struct bcm_mini_adapter *psAdapter)
{
/* Rx Control Packets Processing */
psAdapter->control_packet_handler = kthread_run((int (*)(void *))
return 0;
}
-static struct file *open_firmware_file(PMINI_ADAPTER Adapter, const char *path)
+static struct file *open_firmware_file(struct bcm_mini_adapter *Adapter, const char *path)
{
struct file *flp = NULL;
mm_segment_t oldfs;
* Path to image file
* Download Address on the chip
*/
-static int BcmFileDownload(PMINI_ADAPTER Adapter, const char *path, unsigned int loc)
+static int BcmFileDownload(struct bcm_mini_adapter *Adapter, const char *path, unsigned int loc)
{
int errorno = 0;
struct file *flp = NULL;
* Logical Adapter
* Control Packet Buffer
*/
-INT CopyBufferToControlPacket(PMINI_ADAPTER Adapter, PVOID ioBuffer)
+INT CopyBufferToControlPacket(struct bcm_mini_adapter *Adapter, PVOID ioBuffer)
{
- PLEADER pLeader = NULL;
+ struct bcm_leader *pLeader = NULL;
INT Status = 0;
unsigned char *ctrl_buff = NULL;
UINT pktlen = 0;
- PLINK_REQUEST pLinkReq = NULL;
+ struct bcm_link_request *pLinkReq = NULL;
PUCHAR pucAddIndication = NULL;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "======>");
return -EINVAL;
}
- pLinkReq = (PLINK_REQUEST)ioBuffer;
- pLeader = (PLEADER)ioBuffer; /* ioBuffer Contains sw_Status and Payload */
+ pLinkReq = (struct bcm_link_request *)ioBuffer;
+ pLeader = (struct bcm_leader *)ioBuffer; /* ioBuffer Contains sw_Status and Payload */
if (Adapter->bShutStatus == TRUE &&
pLinkReq->szData[0] == LINK_DOWN_REQ_PAYLOAD &&
memset(ctrl_buff, 0, pktlen+LEADER_SIZE);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Copying the Control Packet Buffer with length=%d\n", pLeader->PLength);
- *(PLEADER)ctrl_buff = *pLeader;
+ *(struct bcm_leader *)ctrl_buff = *pLeader;
memcpy(ctrl_buff + LEADER_SIZE, ((PUCHAR)ioBuffer + LEADER_SIZE), pLeader->PLength);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Enqueuing the Control Packet");
*
* Returns - None.
*****************************************************************/
-static VOID SendStatisticsPointerRequest(PMINI_ADAPTER Adapter, PLINK_REQUEST pstStatisticsPtrRequest)
+static VOID SendStatisticsPointerRequest(struct bcm_mini_adapter *Adapter, struct bcm_link_request *pstStatisticsPtrRequest)
{
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "======>");
pstStatisticsPtrRequest->Leader.Status = STATS_POINTER_REQ_STATUS;
*
* Returns - None.
*******************************************************************/
-VOID LinkMessage(PMINI_ADAPTER Adapter)
+VOID LinkMessage(struct bcm_mini_adapter *Adapter)
{
- PLINK_REQUEST pstLinkRequest = NULL;
+ struct bcm_link_request *pstLinkRequest = NULL;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "=====>");
if (Adapter->LinkStatus == SYNC_UP_REQUEST && Adapter->AutoSyncup) {
- pstLinkRequest = kzalloc(sizeof(LINK_REQUEST), GFP_ATOMIC);
+ pstLinkRequest = kzalloc(sizeof(struct bcm_link_request), GFP_ATOMIC);
if (!pstLinkRequest) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Can not allocate memory for Link request!");
return;
Adapter->bSyncUpRequestSent = TRUE;
} else if (Adapter->LinkStatus == PHY_SYNC_ACHIVED && Adapter->AutoLinkUp) {
- pstLinkRequest = kzalloc(sizeof(LINK_REQUEST), GFP_ATOMIC);
+ pstLinkRequest = kzalloc(sizeof(struct bcm_link_request), GFP_ATOMIC);
if (!pstLinkRequest) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Can not allocate memory for Link request!");
return;
*
* Returns - None.
************************************************************************/
-VOID StatisticsResponse(PMINI_ADAPTER Adapter, PVOID pvBuffer)
+VOID StatisticsResponse(struct bcm_mini_adapter *Adapter, PVOID pvBuffer)
{
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "%s====>", __func__);
Adapter->StatisticsPointer = ntohl(*(__be32 *)pvBuffer);
*
* Returns - None.
***********************************************************************/
-VOID LinkControlResponseMessage(PMINI_ADAPTER Adapter, PUCHAR pucBuffer)
+VOID LinkControlResponseMessage(struct bcm_mini_adapter *Adapter, PUCHAR pucBuffer)
{
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "=====>");
return;
}
-void SendIdleModeResponse(PMINI_ADAPTER Adapter)
+void SendIdleModeResponse(struct bcm_mini_adapter *Adapter)
{
INT status = 0, NVMAccess = 0, lowPwrAbortMsg = 0;
struct timeval tv;
- CONTROL_MESSAGE stIdleResponse = {{0} };
+ struct bcm_link_request stIdleResponse = {{0} };
memset(&tv, 0, sizeof(tv));
stIdleResponse.Leader.Status = IDLE_MESSAGE;
stIdleResponse.Leader.PLength = IDLE_MODE_PAYLOAD_LENGTH;
*
* Returns - None.
*******************************************************************/
-VOID DumpPackInfo(PMINI_ADAPTER Adapter)
+VOID DumpPackInfo(struct bcm_mini_adapter *Adapter)
{
UINT uiLoopIndex = 0;
UINT uiIndex = 0;
UINT uiClsfrIndex = 0;
- S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
+ struct bcm_classifier_rule *pstClassifierEntry = NULL;
for (uiLoopIndex = 0; uiLoopIndex < NO_OF_QUEUES; uiLoopIndex++) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "*********** Showing Details Of Queue %d***** ******", uiLoopIndex);
return;
}
-int reset_card_proc(PMINI_ADAPTER ps_adapter)
+int reset_card_proc(struct bcm_mini_adapter *ps_adapter)
{
int retval = STATUS_SUCCESS;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
PS_INTERFACE_ADAPTER psIntfAdapter = NULL;
unsigned int value = 0, uiResetValue = 0;
int bytes;
return retval;
}
-int run_card_proc(PMINI_ADAPTER ps_adapter)
+int run_card_proc(struct bcm_mini_adapter *ps_adapter)
{
int status = STATUS_SUCCESS;
int bytes;
return status;
}
-int InitCardAndDownloadFirmware(PMINI_ADAPTER ps_adapter)
+int InitCardAndDownloadFirmware(struct bcm_mini_adapter *ps_adapter)
{
int status;
UINT value = 0;
return status;
}
-static int bcm_parse_target_params(PMINI_ADAPTER Adapter)
+static int bcm_parse_target_params(struct bcm_mini_adapter *Adapter)
{
struct file *flp = NULL;
mm_segment_t oldfs = {0};
return STATUS_SUCCESS;
}
-void beceem_parse_target_struct(PMINI_ADAPTER Adapter)
+void beceem_parse_target_struct(struct bcm_mini_adapter *Adapter)
{
UINT uiHostDrvrCfg6 = 0, uiEEPROMFlag = 0;
doPowerAutoCorrection(Adapter);
}
-static VOID doPowerAutoCorrection(PMINI_ADAPTER psAdapter)
+static VOID doPowerAutoCorrection(struct bcm_mini_adapter *psAdapter)
{
UINT reporting_mode;
}
#if 0
-static unsigned char *ReadMacAddrEEPROM(PMINI_ADAPTER Adapter, ulong dwAddress)
+static unsigned char *ReadMacAddrEEPROM(struct bcm_mini_adapter *Adapter, ulong dwAddress)
{
int status = 0, i = 0;
unsigned int temp = 0;
#define CACHE_ADDRESS_MASK 0x80000000
#define UNCACHE_ADDRESS_MASK 0xa0000000
-int rdm(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
+int rdm(struct bcm_mini_adapter *Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
{
return Adapter->interface_rdm(Adapter->pvInterfaceAdapter,
uiAddress, pucBuff, sSize);
}
-int wrm(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
+int wrm(struct bcm_mini_adapter *Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
{
int iRetVal;
return iRetVal;
}
-int wrmalt(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
+int wrmalt(struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
{
convertEndian(RWM_WRITE, pucBuff, size);
return wrm(Adapter, uiAddress, (PUCHAR)pucBuff, size);
}
-int rdmalt(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
+int rdmalt(struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
{
INT uiRetVal = 0;
return uiRetVal;
}
-int wrmWithLock(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
+int wrmWithLock(struct bcm_mini_adapter *Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
{
INT status = STATUS_SUCCESS;
down(&Adapter->rdmwrmsync);
return status;
}
-int wrmaltWithLock(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
+int wrmaltWithLock(struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
{
int iRetVal = STATUS_SUCCESS;
return iRetVal;
}
-int rdmaltWithLock(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
+int rdmaltWithLock(struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
{
INT uiRetVal = STATUS_SUCCESS;
return uiRetVal;
}
-static VOID HandleShutDownModeWakeup(PMINI_ADAPTER Adapter)
+static VOID HandleShutDownModeWakeup(struct bcm_mini_adapter *Adapter)
{
int clear_abort_pattern = 0, Status = 0;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "====>\n");
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "<====\n");
}
-static VOID SendShutModeResponse(PMINI_ADAPTER Adapter)
+static VOID SendShutModeResponse(struct bcm_mini_adapter *Adapter)
{
- CONTROL_MESSAGE stShutdownResponse;
+ struct bcm_link_request stShutdownResponse;
UINT NVMAccess = 0, lowPwrAbortMsg = 0;
UINT Status = 0;
- memset(&stShutdownResponse, 0, sizeof(CONTROL_MESSAGE));
+ memset(&stShutdownResponse, 0, sizeof(struct bcm_link_request));
stShutdownResponse.Leader.Status = LINK_UP_CONTROL_REQ;
stShutdownResponse.Leader.PLength = 8; /* 8 bytes; */
stShutdownResponse.szData[0] = LINK_UP_ACK;
}
}
-static void HandleShutDownModeRequest(PMINI_ADAPTER Adapter, PUCHAR pucBuffer)
+static void HandleShutDownModeRequest(struct bcm_mini_adapter *Adapter, PUCHAR pucBuffer)
{
B_UINT32 uiResetValue = 0;
return;
}
-VOID ResetCounters(PMINI_ADAPTER Adapter)
+VOID ResetCounters(struct bcm_mini_adapter *Adapter)
{
beceem_protocol_reset(Adapter);
Adapter->CurrNumRecvDescs = 0;
Adapter->bShutStatus = FALSE;
}
-S_CLASSIFIER_RULE *GetFragIPClsEntry(PMINI_ADAPTER Adapter, USHORT usIpIdentification, ULONG SrcIP)
+struct bcm_classifier_rule *GetFragIPClsEntry(struct bcm_mini_adapter *Adapter, USHORT usIpIdentification, ULONG SrcIP)
{
UINT uiIndex = 0;
for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
return NULL;
}
-void AddFragIPClsEntry(PMINI_ADAPTER Adapter, PS_FRAGMENTED_PACKET_INFO psFragPktInfo)
+void AddFragIPClsEntry(struct bcm_mini_adapter *Adapter, struct bcm_fragmented_packet_info *psFragPktInfo)
{
UINT uiIndex = 0;
for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
if (!Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) {
- memcpy(&Adapter->astFragmentedPktClassifierTable[uiIndex], psFragPktInfo, sizeof(S_FRAGMENTED_PACKET_INFO));
+ memcpy(&Adapter->astFragmentedPktClassifierTable[uiIndex], psFragPktInfo, sizeof(struct bcm_fragmented_packet_info));
break;
}
}
}
-void DelFragIPClsEntry(PMINI_ADAPTER Adapter, USHORT usIpIdentification, ULONG SrcIp)
+void DelFragIPClsEntry(struct bcm_mini_adapter *Adapter, USHORT usIpIdentification, ULONG SrcIp)
{
UINT uiIndex = 0;
for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
(Adapter->astFragmentedPktClassifierTable[uiIndex].usIpIdentification == usIpIdentification) &&
(Adapter->astFragmentedPktClassifierTable[uiIndex].ulSrcIpAddress == SrcIp))
- memset(&Adapter->astFragmentedPktClassifierTable[uiIndex], 0, sizeof(S_FRAGMENTED_PACKET_INFO));
+ memset(&Adapter->astFragmentedPktClassifierTable[uiIndex], 0, sizeof(struct bcm_fragmented_packet_info));
}
}
-void update_per_cid_rx(PMINI_ADAPTER Adapter)
+void update_per_cid_rx(struct bcm_mini_adapter *Adapter)
{
UINT qindex = 0;
Adapter->liDrainCalculated = jiffies;
}
-void update_per_sf_desc_cnts(PMINI_ADAPTER Adapter)
+void update_per_sf_desc_cnts(struct bcm_mini_adapter *Adapter)
{
INT iIndex = 0;
u32 uibuff[MAX_TARGET_DSX_BUFFERS];
atomic_set(&Adapter->uiMBupdate, FALSE);
}
-void flush_queue(PMINI_ADAPTER Adapter, UINT iQIndex)
+void flush_queue(struct bcm_mini_adapter *Adapter, UINT iQIndex)
{
struct sk_buff *PacketToDrop = NULL;
struct net_device_stats *netstats = &Adapter->dev->stats;
spin_unlock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
}
-static void beceem_protocol_reset(PMINI_ADAPTER Adapter)
+static void beceem_protocol_reset(struct bcm_mini_adapter *Adapter)
{
int i;
if (netif_msg_link(Adapter))
if (Adapter->TimerActive == TRUE)
Adapter->TimerActive = FALSE;
- memset(Adapter->astFragmentedPktClassifierTable, 0, sizeof(S_FRAGMENTED_PACKET_INFO) * MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES);
+ memset(Adapter->astFragmentedPktClassifierTable, 0, sizeof(struct bcm_fragmented_packet_info) * MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES);
for (i = 0; i < HiPriority; i++) {
/* resetting only the first size (S_MIBS_SERVICEFLOW_TABLE) for the SF. */
Description: This routine handle PHS(Payload Header Suppression for Tx path.
It extracts a fragment of the NDIS_PACKET containing the header
- to be suppressed.It then supresses the header by invoking PHS exported compress routine.
- The header data after supression is copied back to the NDIS_PACKET.
+ to be suppressed. It then suppresses the header by invoking PHS exported compress routine.
+ The header data after suppression is copied back to the NDIS_PACKET.
-Input parameters: IN PMINI_ADAPTER Adapter - Miniport Adapter Context
+Input parameters: IN struct bcm_mini_adapter *Adapter - Miniport Adapter Context
IN Packet - NDIS packet containing data to be transmitted
IN USHORT Vcid - vcid pertaining to connection on which the packet is being sent.Used to
identify PHS rule to be applied.
Other - If an error occured.
*/
-int PHSTransmit(PMINI_ADAPTER Adapter,
+int PHSTransmit(struct bcm_mini_adapter *Adapter,
struct sk_buff **pPacket,
USHORT Vcid,
B_UINT16 uiClassifierRuleID,
UINT unPHSNewPktHeaderLen = 0;
/* Pointer to PHS IN Hdr Buffer */
PUCHAR pucPHSPktHdrInBuf =
- Adapter->stPhsTxContextInfo.ucaHdrSupressionInBuf;
+ Adapter->stPhsTxContextInfo.ucaHdrSuppressionInBuf;
/* Pointer to PHS OUT Hdr Buffer */
PUCHAR pucPHSPktHdrOutBuf =
- Adapter->stPhsTxContextInfo.ucaHdrSupressionOutBuf;
+ Adapter->stPhsTxContextInfo.ucaHdrSuppressionOutBuf;
UINT usPacketType;
UINT BytesToRemove=0;
BOOLEAN bPHSI = 0;
if(!bEthCSSupport)
BytesToRemove=ETH_HLEN;
/*
- Accumulate the header upto the size we support supression
+ Accumulate the header upto the size we support suppression
from NDIS packet
*/
{
- // Step 2 Supress Header using PHS and fill into intermediate ucaPHSPktHdrOutBuf.
+ // Step 2 Suppress Header using PHS and fill into intermediate ucaPHSPktHdrOutBuf.
// Suppress only if IP Header and PHS Enabled For the Service Flow
if(((usPacketType == ETHERNET_FRAMETYPE_IPV4) ||
(usPacketType == ETHERNET_FRAMETYPE_IPV6)) &&
return STATUS_SUCCESS;
}
-int PHSReceive(PMINI_ADAPTER Adapter,
+int PHSReceive(struct bcm_mini_adapter *Adapter,
USHORT usVcid,
struct sk_buff *packet,
UINT *punPacketLen,
UINT bHeaderSuppressionEnabled)
{
u32 nStandardPktHdrLen = 0;
- u32 nTotalsupressedPktHdrBytes = 0;
+ u32 nTotalsuppressedPktHdrBytes = 0;
int ulPhsStatus = 0;
PUCHAR pucInBuff = NULL ;
UINT TotalBytesAdded = 0;
usVcid,
pucInBuff,
Adapter->ucaPHSPktRestoreBuf,
- &nTotalsupressedPktHdrBytes,
+ &nTotalsuppressedPktHdrBytes,
&nStandardPktHdrLen);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECEIVE,DBG_LVL_ALL,"\nSupressed PktHdrLen : 0x%x Restored PktHdrLen : 0x%x",
- nTotalsupressedPktHdrBytes,nStandardPktHdrLen);
+ BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECEIVE,DBG_LVL_ALL,"\nSuppressed PktHdrLen : 0x%x Restored PktHdrLen : 0x%x",
+ nTotalsuppressedPktHdrBytes,nStandardPktHdrLen);
if(ulPhsStatus != STATUS_PHS_COMPRESSED)
{
}
else
{
- TotalBytesAdded = nStandardPktHdrLen - nTotalsupressedPktHdrBytes - PHSI_LEN;
+ TotalBytesAdded = nStandardPktHdrLen - nTotalsuppressedPktHdrBytes - PHSI_LEN;
if(TotalBytesAdded)
{
if(skb_headroom(packet) >= (SKB_RESERVE_ETHERNET_HEADER + TotalBytesAdded))
void DumpFullPacket(UCHAR *pBuf,UINT nPktLen)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,"Dumping Data Packet");
BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL,pBuf,nPktLen);
}
// TRUE(1) -If allocation of memory was success full.
// FALSE -If allocation of memory fails.
//-----------------------------------------------------------------------------
-int phs_init(PPHS_DEVICE_EXTENSION pPhsdeviceExtension,PMINI_ADAPTER Adapter)
+int phs_init(PPHS_DEVICE_EXTENSION pPhsdeviceExtension, struct bcm_mini_adapter *Adapter)
{
int i;
S_SERVICEFLOW_TABLE *pstServiceFlowTable;
ULONG lStatus =0;
UINT nSFIndex =0 ;
S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
UINT nSFIndex =0, nClsidIndex =0 ;
S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
S_CLASSIFIER_TABLE *pstClassifierRulesTable = NULL;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
PPHS_DEVICE_EXTENSION pDeviceExtension= (PPHS_DEVICE_EXTENSION)pvContext;
UINT nSFIndex =0, nClsidIndex =0 ;
S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
S_CLASSIFIER_ENTRY *pstClassifierEntry = NULL;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
PPHS_DEVICE_EXTENSION pDeviceExtension= (PPHS_DEVICE_EXTENSION)pvContext;
if(pDeviceExtension)
UINT nSFIndex =0, nClsidIndex =0 ;
S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
S_CLASSIFIER_TABLE *pstClassifierRulesTable = NULL;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
PPHS_DEVICE_EXTENSION pDeviceExtension= (PPHS_DEVICE_EXTENSION)pvContext;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL,"====> \n");
S_CLASSIFIER_ENTRY *pstClassifierEntry = NULL;
S_PHS_RULE *pstPhsRule = NULL;
ULONG lStatus =0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
S_PHS_RULE *pstPhsRule = NULL;
UINT phsi;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
PPHS_DEVICE_EXTENSION pDeviceExtension=
(PPHS_DEVICE_EXTENSION)pvContext;
static void free_phs_serviceflow_rules(S_SERVICEFLOW_TABLE *psServiceFlowRulesTable)
{
int i,j;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "=======>\n");
if(psServiceFlowRulesTable)
UINT uiStatus =PHS_SUCCESS;
UINT nClassifierIndex = 0;
S_CLASSIFIER_TABLE *psaClassifiertable = NULL;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
psaClassifiertable = pstServiceFlowEntry->pstClassifierTable;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL, "==>");
BOOLEAN bFreeEntryFound = FALSE;
S_CLASSIFIER_ENTRY *psClassifierRules = NULL;
UINT nStatus = PHS_SUCCESS;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_DISPATCH, DBG_LVL_ALL,"Inside CreateClassifierPHSRule");
if(psaClassifiertable == NULL)
{
S_PHS_RULE *pstAddPhsRule = NULL;
UINT nPhsRuleIndex = 0;
BOOLEAN bPHSRuleOrphaned = FALSE;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
psPhsRule->u8RefCnt =0;
/* Step 1 Deref Any Exisiting PHS Rule in this classifier Entry*/
void DumpPhsRules(PPHS_DEVICE_EXTENSION pDeviceExtension)
{
int i,j,k,l;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\n Dumping PHS Rules : \n");
for(i=0;i<MAX_SERVICEFLOWS;i++)
{
int bit,i=0;
unsigned char *phsf,*phsm;
int in_buf_len = *header_size-1;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
in_buf++;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_RECEIVE,DBG_LVL_ALL,"====>\n");
*header_size = 0;
,unsigned char *out_buf,UINT *header_size,UINT *new_header_size)
{
unsigned char *old_addr = out_buf;
- int supress = 0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ int suppress = 0;
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if(phs_rule == NULL)
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nphs_compress(): phs_rule null!");
}
//To copy PHSI
out_buf++;
- supress = verify_suppress_phsf(in_buf,out_buf,phs_rule->u8PHSF,
+ suppress = verify_suppress_phsf(in_buf,out_buf,phs_rule->u8PHSF,
phs_rule->u8PHSM, phs_rule->u8PHSS, phs_rule->u8PHSV,new_header_size);
- if(supress == STATUS_PHS_COMPRESSED)
+ if(suppress == STATUS_PHS_COMPRESSED)
{
*old_addr = (unsigned char)phs_rule->u8PHSI;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nCOMP:In phs_compress phsi %d",phs_rule->u8PHSI);
*old_addr = ZERO_PHSI;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nCOMP:In phs_compress PHSV Verification failed");
}
- return supress;
+ return suppress;
}
{
unsigned int size=0;
int bit,i=0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, PHS_SEND, DBG_LVL_ALL,"\nCOMP:In verify_phsf PHSM - 0x%X",*phsm);
#ifndef BCM_MINIPORT_PHSMODULE_H
#define BCM_MINIPORT_PHSMODULE_H
-int PHSTransmit(PMINI_ADAPTER Adapter,
+int PHSTransmit(struct bcm_mini_adapter *Adapter,
struct sk_buff **pPacket,
USHORT Vcid,
B_UINT16 uiClassifierRuleID,
PUINT PacketLen,
UCHAR bEthCSSupport);
-int PHSReceive(PMINI_ADAPTER Adapter,
+int PHSReceive(struct bcm_mini_adapter *Adapter,
USHORT usVcid,
struct sk_buff *packet,
UINT *punPacketLen,
void DumpPhsRules(PPHS_DEVICE_EXTENSION pDeviceExtension);
-int phs_init(PPHS_DEVICE_EXTENSION pPhsdeviceExtension,PMINI_ADAPTER Adapter);
+int phs_init(PPHS_DEVICE_EXTENSION pPhsdeviceExtension,struct bcm_mini_adapter *Adapter);
int PhsCleanup(PPHS_DEVICE_EXTENSION pPHSDeviceExt);
typedef struct _ETH_CS_802_Q_FRAME
{
- ETH_HEADER_STRUC EThHdr;
+ struct bcm_eth_header EThHdr;
USHORT UserPriority:3;
USHORT CFI:1;
USHORT VLANID:12;
typedef struct _ETH_CS_802_LLC_FRAME
{
- ETH_HEADER_STRUC EThHdr;
+ struct bcm_eth_header EThHdr;
unsigned char DSAP;
unsigned char SSAP;
unsigned char Control;
typedef struct _ETH_CS_802_LLC_SNAP_FRAME
{
- ETH_HEADER_STRUC EThHdr;
+ struct bcm_eth_header EThHdr;
unsigned char DSAP;
unsigned char SSAP;
unsigned char Control;
typedef struct _ETH_CS_ETH2_FRAME
{
- ETH_HEADER_STRUC EThHdr;
+ struct bcm_eth_header EThHdr;
} __attribute__((packed)) ETH_CS_ETH2_FRAME;
#define ETHERNET_FRAMETYPE_IPV4 ntohs(0x0800)
#ifndef _PROTOTYPES_H_
#define _PROTOTYPES_H_
-VOID LinkControlResponseMessage(PMINI_ADAPTER Adapter, PUCHAR pucBuffer);
+VOID LinkControlResponseMessage(struct bcm_mini_adapter *Adapter, PUCHAR pucBuffer);
-VOID StatisticsResponse(PMINI_ADAPTER Adapter,PVOID pvBuffer);
+VOID StatisticsResponse(struct bcm_mini_adapter *Adapter,PVOID pvBuffer);
-VOID IdleModeResponse(PMINI_ADAPTER Adapter,PUINT puiBuffer);
+VOID IdleModeResponse(struct bcm_mini_adapter *Adapter,PUINT puiBuffer);
-int control_packet_handler (PMINI_ADAPTER Adapter);
+int control_packet_handler (struct bcm_mini_adapter *Adapter);
-VOID DeleteAllClassifiersForSF(PMINI_ADAPTER Adapter,UINT uiSearchRuleIndex);
+VOID DeleteAllClassifiersForSF(struct bcm_mini_adapter *Adapter,UINT uiSearchRuleIndex);
-VOID flush_all_queues(PMINI_ADAPTER Adapter);
+VOID flush_all_queues(struct bcm_mini_adapter *Adapter);
-int register_control_device_interface(PMINI_ADAPTER ps_adapter);
+int register_control_device_interface(struct bcm_mini_adapter *ps_adapter);
-void unregister_control_device_interface(PMINI_ADAPTER Adapter);
+void unregister_control_device_interface(struct bcm_mini_adapter *Adapter);
-INT CopyBufferToControlPacket(PMINI_ADAPTER Adapter,/**<Logical Adapter*/
+INT CopyBufferToControlPacket(struct bcm_mini_adapter *Adapter,/**<Logical Adapter*/
PVOID ioBuffer/**<Control Packet Buffer*/
);
-VOID SortPackInfo(PMINI_ADAPTER Adapter);
+VOID SortPackInfo(struct bcm_mini_adapter *Adapter);
-VOID SortClassifiers(PMINI_ADAPTER Adapter);
+VOID SortClassifiers(struct bcm_mini_adapter *Adapter);
-VOID flush_all_queues(PMINI_ADAPTER Adapter);
+VOID flush_all_queues(struct bcm_mini_adapter *Adapter);
-VOID PruneQueueAllSF(PMINI_ADAPTER Adapter);
+VOID PruneQueueAllSF(struct bcm_mini_adapter *Adapter);
-INT SearchSfid(PMINI_ADAPTER Adapter,UINT uiSfid);
+INT SearchSfid(struct bcm_mini_adapter *Adapter,UINT uiSfid);
-USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb);
+USHORT ClassifyPacket(struct bcm_mini_adapter *Adapter,struct sk_buff* skb);
-BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort);
-BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort);
-BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucProtocol);
+BOOLEAN MatchSrcPort(struct bcm_classifier_rule *pstClassifierRule,USHORT ushSrcPort);
+BOOLEAN MatchDestPort(struct bcm_classifier_rule *pstClassifierRule,USHORT ushSrcPort);
+BOOLEAN MatchProtocol(struct bcm_classifier_rule *pstClassifierRule,UCHAR ucProtocol);
-INT SetupNextSend(PMINI_ADAPTER Adapter, /**<Logical Adapter*/
+INT SetupNextSend(struct bcm_mini_adapter *Adapter, /**<Logical Adapter*/
struct sk_buff *Packet, /**<data buffer*/
USHORT Vcid) ;
-VOID LinkMessage(PMINI_ADAPTER Adapter);
+VOID LinkMessage(struct bcm_mini_adapter *Adapter);
-VOID transmit_packets(PMINI_ADAPTER Adapter);
+VOID transmit_packets(struct bcm_mini_adapter *Adapter);
-INT SendControlPacket(PMINI_ADAPTER Adapter, /**<Logical Adapter*/
+INT SendControlPacket(struct bcm_mini_adapter *Adapter, /**<Logical Adapter*/
char *pControlPacket/**<Control Packet*/
);
-int register_networkdev(PMINI_ADAPTER Adapter);
-void unregister_networkdev(PMINI_ADAPTER Adapter);
+int register_networkdev(struct bcm_mini_adapter *Adapter);
+void unregister_networkdev(struct bcm_mini_adapter *Adapter);
-INT AllocAdapterDsxBuffer(PMINI_ADAPTER Adapter);
+INT AllocAdapterDsxBuffer(struct bcm_mini_adapter *Adapter);
-VOID AdapterFree(PMINI_ADAPTER Adapter);
+VOID AdapterFree(struct bcm_mini_adapter *Adapter);
-INT FreeAdapterDsxBuffer(PMINI_ADAPTER Adapter);
+INT FreeAdapterDsxBuffer(struct bcm_mini_adapter *Adapter);
-int tx_pkt_handler(PMINI_ADAPTER Adapter);
+int tx_pkt_handler(struct bcm_mini_adapter *Adapter);
-int reset_card_proc(PMINI_ADAPTER Adapter );
+int reset_card_proc(struct bcm_mini_adapter *Adapter );
-int run_card_proc(PMINI_ADAPTER Adapter );
+int run_card_proc(struct bcm_mini_adapter *Adapter );
-int InitCardAndDownloadFirmware(PMINI_ADAPTER ps_adapter);
+int InitCardAndDownloadFirmware(struct bcm_mini_adapter *ps_adapter);
-INT ReadMacAddressFromNVM(PMINI_ADAPTER Adapter);
+INT ReadMacAddressFromNVM(struct bcm_mini_adapter *Adapter);
-int register_control_device_interface(PMINI_ADAPTER ps_adapter);
+int register_control_device_interface(struct bcm_mini_adapter *ps_adapter);
-void DumpPackInfo(PMINI_ADAPTER Adapter);
+void DumpPackInfo(struct bcm_mini_adapter *Adapter);
-int rdm(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t size);
+int rdm(struct bcm_mini_adapter *Adapter, UINT uiAddress, PCHAR pucBuff, size_t size);
-int wrm(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t size);
+int wrm(struct bcm_mini_adapter *Adapter, UINT uiAddress, PCHAR pucBuff, size_t size);
-int wrmalt (PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t sSize);
+int wrmalt (struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t sSize);
-int rdmalt (PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t sSize);
+int rdmalt (struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t sSize);
-int get_dsx_sf_data_to_application(PMINI_ADAPTER Adapter, UINT uiSFId, void __user * user_buffer);
+int get_dsx_sf_data_to_application(struct bcm_mini_adapter *Adapter, UINT uiSFId, void __user * user_buffer);
-void SendIdleModeResponse(PMINI_ADAPTER Adapter);
+void SendIdleModeResponse(struct bcm_mini_adapter *Adapter);
-int ProcessGetHostMibs(PMINI_ADAPTER Adapter, S_MIBS_HOST_STATS_MIBS *buf);
-void GetDroppedAppCntrlPktMibs(S_MIBS_HOST_STATS_MIBS *ioBuffer, PPER_TARANG_DATA pTarang);
-void beceem_parse_target_struct(PMINI_ADAPTER Adapter);
+int ProcessGetHostMibs(struct bcm_mini_adapter *Adapter, S_MIBS_HOST_STATS_MIBS *buf);
+void GetDroppedAppCntrlPktMibs(S_MIBS_HOST_STATS_MIBS *ioBuffer, struct bcm_tarang_data *pTarang);
+void beceem_parse_target_struct(struct bcm_mini_adapter *Adapter);
-int bcm_ioctl_fw_download(PMINI_ADAPTER Adapter, FIRMWARE_INFO *psFwInfo);
+int bcm_ioctl_fw_download(struct bcm_mini_adapter *Adapter, struct bcm_firmware_info *psFwInfo);
-void CopyMIBSExtendedSFParameters(PMINI_ADAPTER Adapter,
+void CopyMIBSExtendedSFParameters(struct bcm_mini_adapter *Adapter,
CServiceFlowParamSI *psfLocalSet, UINT uiSearchRuleIndex);
-VOID ResetCounters(PMINI_ADAPTER Adapter);
+VOID ResetCounters(struct bcm_mini_adapter *Adapter);
-int InitLedSettings(PMINI_ADAPTER Adapter);
+int InitLedSettings(struct bcm_mini_adapter *Adapter);
-S_CLASSIFIER_RULE *GetFragIPClsEntry(PMINI_ADAPTER Adapter,USHORT usIpIdentification,ULONG SrcIP);
+struct bcm_classifier_rule *GetFragIPClsEntry(struct bcm_mini_adapter *Adapter,USHORT usIpIdentification,ULONG SrcIP);
-void AddFragIPClsEntry(PMINI_ADAPTER Adapter,PS_FRAGMENTED_PACKET_INFO psFragPktInfo);
+void AddFragIPClsEntry(struct bcm_mini_adapter *Adapter, struct bcm_fragmented_packet_info *psFragPktInfo);
-void DelFragIPClsEntry(PMINI_ADAPTER Adapter,USHORT usIpIdentification,ULONG SrcIp);
+void DelFragIPClsEntry(struct bcm_mini_adapter *Adapter,USHORT usIpIdentification,ULONG SrcIp);
-void update_per_cid_rx (PMINI_ADAPTER Adapter);
+void update_per_cid_rx (struct bcm_mini_adapter *Adapter);
-void update_per_sf_desc_cnts( PMINI_ADAPTER Adapter);
+void update_per_sf_desc_cnts( struct bcm_mini_adapter *Adapter);
-void ClearTargetDSXBuffer(PMINI_ADAPTER Adapter,B_UINT16 TID,BOOLEAN bFreeAll);
+void ClearTargetDSXBuffer(struct bcm_mini_adapter *Adapter,B_UINT16 TID,BOOLEAN bFreeAll);
-void flush_queue(PMINI_ADAPTER Adapter, UINT iQIndex);
+void flush_queue(struct bcm_mini_adapter *Adapter, UINT iQIndex);
INT flushAllAppQ(VOID);
INT BeceemEEPROMBulkRead(
- PMINI_ADAPTER Adapter,
+ struct bcm_mini_adapter *Adapter,
PUINT pBuffer,
UINT uiOffset,
UINT uiNumBytes);
-INT WriteBeceemEEPROM(PMINI_ADAPTER Adapter,UINT uiEEPROMOffset, UINT uiData);
+INT WriteBeceemEEPROM(struct bcm_mini_adapter *Adapter,UINT uiEEPROMOffset, UINT uiData);
-INT PropagateCalParamsFromFlashToMemory(PMINI_ADAPTER Adapter);
+INT PropagateCalParamsFromFlashToMemory(struct bcm_mini_adapter *Adapter);
INT BeceemEEPROMBulkWrite(
- PMINI_ADAPTER Adapter,
+ struct bcm_mini_adapter *Adapter,
PUCHAR pBuffer,
UINT uiOffset,
UINT uiNumBytes,
BOOLEAN bVerify);
-INT ReadBeceemEEPROM(PMINI_ADAPTER Adapter,UINT dwAddress, UINT *pdwData);
+INT ReadBeceemEEPROM(struct bcm_mini_adapter *Adapter,UINT dwAddress, UINT *pdwData);
INT BeceemNVMRead(
- PMINI_ADAPTER Adapter,
+ struct bcm_mini_adapter *Adapter,
PUINT pBuffer,
UINT uiOffset,
UINT uiNumBytes);
INT BeceemNVMWrite(
- PMINI_ADAPTER Adapter,
+ struct bcm_mini_adapter *Adapter,
PUINT pBuffer,
UINT uiOffset,
UINT uiNumBytes,
BOOLEAN bVerify);
-INT BcmInitNVM(PMINI_ADAPTER Adapter);
+INT BcmInitNVM(struct bcm_mini_adapter *Adapter);
-INT BcmUpdateSectorSize(PMINI_ADAPTER Adapter,UINT uiSectorSize);
-BOOLEAN IsSectionExistInFlash(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL section);
+INT BcmUpdateSectorSize(struct bcm_mini_adapter *Adapter,UINT uiSectorSize);
+BOOLEAN IsSectionExistInFlash(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL section);
-INT BcmGetFlash2xSectionalBitMap(PMINI_ADAPTER Adapter, PFLASH2X_BITMAP psFlash2xBitMap);
+INT BcmGetFlash2xSectionalBitMap(struct bcm_mini_adapter *Adapter, PFLASH2X_BITMAP psFlash2xBitMap);
INT BcmFlash2xBulkWrite(
- PMINI_ADAPTER Adapter,
+ struct bcm_mini_adapter *Adapter,
PUINT pBuffer,
FLASH2X_SECTION_VAL eFlashSectionVal,
UINT uiOffset,
UINT bVerify);
INT BcmFlash2xBulkRead(
- PMINI_ADAPTER Adapter,
+ struct bcm_mini_adapter *Adapter,
PUINT pBuffer,
FLASH2X_SECTION_VAL eFlashSectionVal,
UINT uiOffsetWithinSectionVal,
UINT uiNumBytes);
-INT BcmGetSectionValStartOffset(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlashSectionVal);
+INT BcmGetSectionValStartOffset(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlashSectionVal);
-INT BcmSetActiveSection(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectVal);
-INT BcmAllocFlashCSStructure(PMINI_ADAPTER psAdapter);
-INT BcmDeAllocFlashCSStructure(PMINI_ADAPTER psAdapter);
+INT BcmSetActiveSection(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlash2xSectVal);
+INT BcmAllocFlashCSStructure(struct bcm_mini_adapter *psAdapter);
+INT BcmDeAllocFlashCSStructure(struct bcm_mini_adapter *psAdapter);
-INT BcmCopyISO(PMINI_ADAPTER Adapter, FLASH2X_COPY_SECTION sCopySectStrut);
-INT BcmFlash2xCorruptSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal);
-INT BcmFlash2xWriteSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlashSectionVal);
-INT validateFlash2xReadWrite(PMINI_ADAPTER Adapter, PFLASH2X_READWRITE psFlash2xReadWrite);
-INT IsFlash2x(PMINI_ADAPTER Adapter);
-INT BcmCopySection(PMINI_ADAPTER Adapter,
+INT BcmCopyISO(struct bcm_mini_adapter *Adapter, FLASH2X_COPY_SECTION sCopySectStrut);
+INT BcmFlash2xCorruptSig(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal);
+INT BcmFlash2xWriteSig(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlashSectionVal);
+INT validateFlash2xReadWrite(struct bcm_mini_adapter *Adapter, PFLASH2X_READWRITE psFlash2xReadWrite);
+INT IsFlash2x(struct bcm_mini_adapter *Adapter);
+INT BcmCopySection(struct bcm_mini_adapter *Adapter,
FLASH2X_SECTION_VAL SrcSection,
FLASH2X_SECTION_VAL DstSection,
UINT offset,
UINT numOfBytes);
-BOOLEAN IsNonCDLessDevice(PMINI_ADAPTER Adapter);
+BOOLEAN IsNonCDLessDevice(struct bcm_mini_adapter *Adapter);
-VOID OverrideServiceFlowParams(PMINI_ADAPTER Adapter,PUINT puiBuffer);
+VOID OverrideServiceFlowParams(struct bcm_mini_adapter *Adapter,PUINT puiBuffer);
-int wrmaltWithLock (PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t sSize);
-int rdmaltWithLock (PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t sSize);
+int wrmaltWithLock (struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t sSize);
+int rdmaltWithLock (struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t sSize);
-int wrmWithLock(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t size);
-INT buffDnldVerify(PMINI_ADAPTER Adapter, unsigned char *mappedbuffer, unsigned int u32FirmwareLength,
+int wrmWithLock(struct bcm_mini_adapter *Adapter, UINT uiAddress, PCHAR pucBuff, size_t size);
+INT buffDnldVerify(struct bcm_mini_adapter *Adapter, unsigned char *mappedbuffer, unsigned int u32FirmwareLength,
unsigned long u32StartingAddress);
VOID putUsbSuspend(struct work_struct *work);
-BOOLEAN IsReqGpioIsLedInNVM(PMINI_ADAPTER Adapter, UINT gpios);
+BOOLEAN IsReqGpioIsLedInNVM(struct bcm_mini_adapter *Adapter, UINT gpios);
#endif
*/
#include "headers.h"
-static void EThCSGetPktInfo(PMINI_ADAPTER Adapter,PVOID pvEthPayload,PS_ETHCS_PKT_INFO pstEthCsPktInfo);
-static BOOLEAN EThCSClassifyPkt(PMINI_ADAPTER Adapter,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo,S_CLASSIFIER_RULE *pstClassifierRule, B_UINT8 EthCSCupport);
+static void EThCSGetPktInfo(struct bcm_mini_adapter *Adapter,PVOID pvEthPayload,PS_ETHCS_PKT_INFO pstEthCsPktInfo);
+static BOOLEAN EThCSClassifyPkt(struct bcm_mini_adapter *Adapter,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo,struct bcm_classifier_rule *pstClassifierRule, B_UINT8 EthCSCupport);
-static USHORT IpVersion4(PMINI_ADAPTER Adapter, struct iphdr *iphd,
- S_CLASSIFIER_RULE *pstClassifierRule );
+static USHORT IpVersion4(struct bcm_mini_adapter *Adapter, struct iphdr *iphd,
+ struct bcm_classifier_rule *pstClassifierRule );
-static VOID PruneQueue(PMINI_ADAPTER Adapter, INT iIndex);
+static VOID PruneQueue(struct bcm_mini_adapter *Adapter, INT iIndex);
/*******************************************************************
*
* Returns - TRUE(If address matches) else FAIL .
*********************************************************************/
-BOOLEAN MatchSrcIpAddress(S_CLASSIFIER_RULE *pstClassifierRule,ULONG ulSrcIP)
+BOOLEAN MatchSrcIpAddress(struct bcm_classifier_rule *pstClassifierRule,ULONG ulSrcIP)
{
UCHAR ucLoopIndex=0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
ulSrcIP=ntohl(ulSrcIP);
if(0 == pstClassifierRule->ucIPSourceAddressLength)
*
* Returns - TRUE(If address matches) else FAIL .
*********************************************************************/
-BOOLEAN MatchDestIpAddress(S_CLASSIFIER_RULE *pstClassifierRule,ULONG ulDestIP)
+BOOLEAN MatchDestIpAddress(struct bcm_classifier_rule *pstClassifierRule,ULONG ulDestIP)
{
UCHAR ucLoopIndex=0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
ulDestIP=ntohl(ulDestIP);
if(0 == pstClassifierRule->ucIPDestinationAddressLength)
*
* Returns - TRUE(If address matches) else FAIL.
**************************************************************************/
-BOOLEAN MatchTos(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucTypeOfService)
+BOOLEAN MatchTos(struct bcm_classifier_rule *pstClassifierRule,UCHAR ucTypeOfService)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if( 3 != pstClassifierRule->ucIPTypeOfServiceLength )
return TRUE;
*
* Returns - TRUE(If address matches) else FAIL.
****************************************************************************/
-BOOLEAN MatchProtocol(S_CLASSIFIER_RULE *pstClassifierRule,UCHAR ucProtocol)
+BOOLEAN MatchProtocol(struct bcm_classifier_rule *pstClassifierRule,UCHAR ucProtocol)
{
UCHAR ucLoopIndex=0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if(0 == pstClassifierRule->ucProtocolLength)
return TRUE;
for(ucLoopIndex=0;ucLoopIndex<pstClassifierRule->ucProtocolLength;ucLoopIndex++)
*
* Returns - TRUE(If address matches) else FAIL.
***************************************************************************/
-BOOLEAN MatchSrcPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushSrcPort)
+BOOLEAN MatchSrcPort(struct bcm_classifier_rule *pstClassifierRule,USHORT ushSrcPort)
{
UCHAR ucLoopIndex=0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if(0 == pstClassifierRule->ucSrcPortRangeLength)
*
* Returns - TRUE(If address matches) else FAIL.
***************************************************************************/
-BOOLEAN MatchDestPort(S_CLASSIFIER_RULE *pstClassifierRule,USHORT ushDestPort)
+BOOLEAN MatchDestPort(struct bcm_classifier_rule *pstClassifierRule,USHORT ushDestPort)
{
UCHAR ucLoopIndex=0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if(0 == pstClassifierRule->ucDestPortRangeLength)
return TRUE;
Compares IPV4 Ip address and port number
@return Queue Index.
*/
-static USHORT IpVersion4(PMINI_ADAPTER Adapter,
+static USHORT IpVersion4(struct bcm_mini_adapter *Adapter,
struct iphdr *iphd,
- S_CLASSIFIER_RULE *pstClassifierRule )
+ struct bcm_classifier_rule *pstClassifierRule)
{
xporthdr *xprt_hdr=NULL;
BOOLEAN bClassificationSucceed=FALSE;
return bClassificationSucceed;
}
-VOID PruneQueueAllSF(PMINI_ADAPTER Adapter)
+VOID PruneQueueAllSF(struct bcm_mini_adapter *Adapter)
{
UINT iIndex = 0;
drops packets from the Head till the number of bytes is
less than or equal to max queue size for the queue.
*/
-static VOID PruneQueue(PMINI_ADAPTER Adapter, INT iIndex)
+static VOID PruneQueue(struct bcm_mini_adapter *Adapter, INT iIndex)
{
struct sk_buff* PacketToDrop=NULL;
struct net_device_stats *netstats;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, PRUNE_QUEUE, DBG_LVL_ALL, "<=====");
}
-VOID flush_all_queues(PMINI_ADAPTER Adapter)
+VOID flush_all_queues(struct bcm_mini_adapter *Adapter)
{
INT iQIndex;
UINT uiTotalPacketLength;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "<=====");
}
-USHORT ClassifyPacket(PMINI_ADAPTER Adapter,struct sk_buff* skb)
+USHORT ClassifyPacket(struct bcm_mini_adapter *Adapter,struct sk_buff* skb)
{
INT uiLoopIndex=0;
- S_CLASSIFIER_RULE *pstClassifierRule = NULL;
+ struct bcm_classifier_rule *pstClassifierRule = NULL;
S_ETHCS_PKT_INFO stEthCsPktInfo;
PVOID pvEThPayload = NULL;
struct iphdr *pIpHeader = NULL;
if(bFragmentedPkt && (usCurrFragment == 0))
{
//First Fragment of Fragmented Packet. Create Frag CLS Entry
- S_FRAGMENTED_PACKET_INFO stFragPktInfo;
+ struct bcm_fragmented_packet_info stFragPktInfo;
stFragPktInfo.bUsed = TRUE;
stFragPktInfo.ulSrcIpAddress = pIpHeader->saddr;
stFragPktInfo.usIpIdentification = pIpHeader->id;
return INVALID_QUEUE_INDEX;
}
-static BOOLEAN EthCSMatchSrcMACAddress(S_CLASSIFIER_RULE *pstClassifierRule,PUCHAR Mac)
+static BOOLEAN EthCSMatchSrcMACAddress(struct bcm_classifier_rule *pstClassifierRule,PUCHAR Mac)
{
UINT i=0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if(pstClassifierRule->ucEthCSSrcMACLen==0)
return TRUE;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s \n",__FUNCTION__);
return TRUE;
}
-static BOOLEAN EthCSMatchDestMACAddress(S_CLASSIFIER_RULE *pstClassifierRule,PUCHAR Mac)
+static BOOLEAN EthCSMatchDestMACAddress(struct bcm_classifier_rule *pstClassifierRule,PUCHAR Mac)
{
UINT i=0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if(pstClassifierRule->ucEthCSDestMACLen==0)
return TRUE;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s \n",__FUNCTION__);
return TRUE;
}
-static BOOLEAN EthCSMatchEThTypeSAP(S_CLASSIFIER_RULE *pstClassifierRule,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo)
+static BOOLEAN EthCSMatchEThTypeSAP(struct bcm_classifier_rule *pstClassifierRule,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
if((pstClassifierRule->ucEtherTypeLen==0)||
(pstClassifierRule->au8EthCSEtherType[0] == 0))
return TRUE;
}
-static BOOLEAN EthCSMatchVLANRules(S_CLASSIFIER_RULE *pstClassifierRule,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo)
+static BOOLEAN EthCSMatchVLANRules(struct bcm_classifier_rule *pstClassifierRule,struct sk_buff* skb,PS_ETHCS_PKT_INFO pstEthCsPktInfo)
{
BOOLEAN bClassificationSucceed = FALSE;
USHORT usVLANID;
B_UINT8 uPriority = 0;
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s CLS UserPrio:%x CLS VLANID:%x\n",__FUNCTION__,ntohs(*((USHORT *)pstClassifierRule->usUserPriority)),pstClassifierRule->usVLANID);
if(pstEthCsPktInfo->eNwpktEthFrameType!=eEth802QVLANFrame)
return FALSE;
- uPriority = (ntohs(*(USHORT *)(skb->data + sizeof(ETH_HEADER_STRUC))) & 0xF000) >> 13;
+ uPriority = (ntohs(*(USHORT *)(skb->data + sizeof(struct bcm_eth_header))) & 0xF000) >> 13;
if((uPriority >= pstClassifierRule->usUserPriority[0]) && (uPriority <= pstClassifierRule->usUserPriority[1]))
bClassificationSucceed = TRUE;
if(pstEthCsPktInfo->eNwpktEthFrameType!=eEth802QVLANFrame)
return FALSE;
- usVLANID = ntohs(*(USHORT *)(skb->data + sizeof(ETH_HEADER_STRUC))) & 0xFFF;
+ usVLANID = ntohs(*(USHORT *)(skb->data + sizeof(struct bcm_eth_header))) & 0xFFF;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "%s Pkt VLANID %x Priority: %d\n",__FUNCTION__,usVLANID, uPriority);
}
-static BOOLEAN EThCSClassifyPkt(PMINI_ADAPTER Adapter,struct sk_buff* skb,
+static BOOLEAN EThCSClassifyPkt(struct bcm_mini_adapter *Adapter,struct sk_buff* skb,
PS_ETHCS_PKT_INFO pstEthCsPktInfo,
- S_CLASSIFIER_RULE *pstClassifierRule,
+ struct bcm_classifier_rule *pstClassifierRule,
B_UINT8 EthCSCupport)
{
BOOLEAN bClassificationSucceed = FALSE;
- bClassificationSucceed = EthCSMatchSrcMACAddress(pstClassifierRule,((ETH_HEADER_STRUC *)(skb->data))->au8SourceAddress);
+ bClassificationSucceed = EthCSMatchSrcMACAddress(pstClassifierRule,((struct bcm_eth_header *)(skb->data))->au8SourceAddress);
if(!bClassificationSucceed)
return FALSE;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS SrcMAC Matched\n");
- bClassificationSucceed = EthCSMatchDestMACAddress(pstClassifierRule,((ETH_HEADER_STRUC*)(skb->data))->au8DestinationAddress);
+ bClassificationSucceed = EthCSMatchDestMACAddress(pstClassifierRule,((struct bcm_eth_header *)(skb->data))->au8DestinationAddress);
if(!bClassificationSucceed)
return FALSE;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "ETH CS DestMAC Matched\n");
return bClassificationSucceed;
}
-static void EThCSGetPktInfo(PMINI_ADAPTER Adapter,PVOID pvEthPayload,
+static void EThCSGetPktInfo(struct bcm_mini_adapter *Adapter,PVOID pvEthPayload,
PS_ETHCS_PKT_INFO pstEthCsPktInfo)
{
- USHORT u16Etype = ntohs(((ETH_HEADER_STRUC*)pvEthPayload)->u16Etype);
+ USHORT u16Etype = ntohs(((struct bcm_eth_header *)pvEthPayload)->u16Etype);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCSGetPktInfo : Eth Hdr Type : %X\n",u16Etype);
if(u16Etype > 0x5dc)
else
pstEthCsPktInfo->eNwpktIPFrameType = eNonIPPacket;
- pstEthCsPktInfo->usEtherType = ((ETH_HEADER_STRUC*)pvEthPayload)->u16Etype;
+ pstEthCsPktInfo->usEtherType = ((struct bcm_eth_header *)pvEthPayload)->u16Etype;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCsPktInfo->eNwpktIPFrameType : %x\n",pstEthCsPktInfo->eNwpktIPFrameType);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCsPktInfo->eNwpktEthFrameType : %x\n",pstEthCsPktInfo->eNwpktEthFrameType);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, IPV4_DBG, DBG_LVL_ALL, "EthCsPktInfo->usEtherType : %x\n",pstEthCsPktInfo->usEtherType);
This function dispatches control packet to the h/w interface
@return zero(success) or -ve value(failure)
*/
-INT SendControlPacket(PMINI_ADAPTER Adapter, char *pControlPacket)
+INT SendControlPacket(struct bcm_mini_adapter *Adapter, char *pControlPacket)
{
- PLEADER PLeader = (PLEADER)pControlPacket;
+ struct bcm_leader *PLeader = (struct bcm_leader *)pControlPacket;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Tx");
if(!pControlPacket || !Adapter)
to the target via the host h/w interface.
@return zero(success) or -ve value(failure)
*/
-INT SetupNextSend(PMINI_ADAPTER Adapter, struct sk_buff *Packet, USHORT Vcid)
+INT SetupNextSend(struct bcm_mini_adapter *Adapter, struct sk_buff *Packet, USHORT Vcid)
{
int status=0;
BOOLEAN bHeaderSupressionEnabled = FALSE;
B_UINT16 uiClassifierRuleID;
u16 QueueIndex = skb_get_queue_mapping(Packet);
- LEADER Leader={0};
+ struct bcm_leader Leader={0};
if(Packet->len > MAX_DEVICE_DESC_SIZE)
{
else
{
Leader.PLength = Packet->len - ETH_HLEN;
- memcpy((LEADER*)skb_pull(Packet, (ETH_HLEN - LEADER_SIZE)), &Leader, LEADER_SIZE);
+ memcpy((struct bcm_leader *)skb_pull(Packet, (ETH_HLEN - LEADER_SIZE)), &Leader, LEADER_SIZE);
}
status = Adapter->interface_transmit(Adapter->pvInterfaceAdapter,
return status;
}
-static int tx_pending(PMINI_ADAPTER Adapter)
+static int tx_pending(struct bcm_mini_adapter *Adapter)
{
return (atomic_read(&Adapter->TxPktAvail)
&& MINIMUM_PENDING_DESCRIPTORS < atomic_read(&Adapter->CurrNumFreeTxDesc))
@ingroup tx_functions
Transmit thread
*/
-int tx_pkt_handler(PMINI_ADAPTER Adapter /**< pointer to adapter object*/
+int tx_pkt_handler(struct bcm_mini_adapter *Adapter /**< pointer to adapter object*/
)
{
int status = 0;
B_UINT8 u8PHSM[MAX_PHS_LENGTHS];
/** 8bit Total number of bytes to be suppressed for the Service Flow*/
B_UINT8 u8PHSS;
- /** 8bit Indicates whether or not Packet Header contents need to be verified prior to supression */
+ /** 8bit Indicates whether or not Packet Header contents need to be verified prior to suppression */
B_UINT8 u8PHSV;
/** Vendor Specific PHS param Length Of The Service Flow*/
B_UINT8 u8VendorSpecificPHSParamsLength;
#include "headers.h"
-INT ProcessGetHostMibs(PMINI_ADAPTER Adapter, S_MIBS_HOST_STATS_MIBS *pstHostMibs)
+INT ProcessGetHostMibs(struct bcm_mini_adapter *Adapter, S_MIBS_HOST_STATS_MIBS *pstHostMibs)
{
S_SERVICEFLOW_ENTRY *pstServiceFlowEntry = NULL;
S_PHS_RULE *pstPhsRule = NULL;
return STATUS_SUCCESS;
}
-VOID GetDroppedAppCntrlPktMibs(S_MIBS_HOST_STATS_MIBS *pstHostMibs, const PPER_TARANG_DATA pTarang)
+VOID GetDroppedAppCntrlPktMibs(S_MIBS_HOST_STATS_MIBS *pstHostMibs, struct bcm_tarang_data *pTarang)
{
memcpy(&(pstHostMibs->stDroppedAppCntrlMsgs),
&(pTarang->stDroppedAppCntrlMsgs),
sizeof(S_MIBS_DROPPED_APP_CNTRL_MESSAGES));
}
-VOID CopyMIBSExtendedSFParameters(PMINI_ADAPTER Adapter, CServiceFlowParamSI *psfLocalSet, UINT uiSearchRuleIndex)
+VOID CopyMIBSExtendedSFParameters(struct bcm_mini_adapter *Adapter, CServiceFlowParamSI *psfLocalSet, UINT uiSearchRuleIndex)
{
S_MIBS_EXTSERVICEFLOW_PARAMETERS *t = &Adapter->PackInfo[uiSearchRuleIndex].stMibsExtServiceFlowTable;
return u16CheckSum;
}
-BOOLEAN IsReqGpioIsLedInNVM(PMINI_ADAPTER Adapter, UINT gpios)
+BOOLEAN IsReqGpioIsLedInNVM(struct bcm_mini_adapter *Adapter, UINT gpios)
{
INT Status;
Status = (Adapter->gpioBitMap & gpios) ^ gpios;
return TRUE;
}
-static INT LED_Blink(PMINI_ADAPTER Adapter, UINT GPIO_Num, UCHAR uiLedIndex,
+static INT LED_Blink(struct bcm_mini_adapter *Adapter, UINT GPIO_Num, UCHAR uiLedIndex,
ULONG timeout, INT num_of_time, LedEventInfo_t currdriverstate)
{
int Status = STATUS_SUCCESS;
-static INT LED_Proportional_Blink(PMINI_ADAPTER Adapter, UCHAR GPIO_Num_tx,
+static INT LED_Proportional_Blink(struct bcm_mini_adapter *Adapter, UCHAR GPIO_Num_tx,
UCHAR uiTxLedIndex, UCHAR GPIO_Num_rx, UCHAR uiRxLedIndex,
LedEventInfo_t currdriverstate)
{
* <OSAL_STATUS_CODE>
* -----------------------------------------------------------------------------
*/
-static INT ValidateDSDParamsChecksum(PMINI_ADAPTER Adapter, ULONG ulParamOffset,
+static INT ValidateDSDParamsChecksum(struct bcm_mini_adapter *Adapter, ULONG ulParamOffset,
USHORT usParamLen)
{
INT Status = STATUS_SUCCESS;
* <OSAL_STATUS_CODE>
* -----------------------------------------------------------------------------
*/
-static INT ValidateHWParmStructure(PMINI_ADAPTER Adapter, ULONG ulHwParamOffset)
+static INT ValidateHWParmStructure(struct bcm_mini_adapter *Adapter, ULONG ulHwParamOffset)
{
INT Status = STATUS_SUCCESS;
return Status;
} /* ValidateHWParmStructure() */
-static int ReadLEDInformationFromEEPROM(PMINI_ADAPTER Adapter,
+static int ReadLEDInformationFromEEPROM(struct bcm_mini_adapter *Adapter,
UCHAR GPIO_Array[])
{
int Status = STATUS_SUCCESS;
}
-static int ReadConfigFileStructure(PMINI_ADAPTER Adapter,
+static int ReadConfigFileStructure(struct bcm_mini_adapter *Adapter,
BOOLEAN *bEnableThread)
{
int Status = STATUS_SUCCESS;
*
* -----------------------------------------------------------------------------
*/
-static VOID LedGpioInit(PMINI_ADAPTER Adapter)
+static VOID LedGpioInit(struct bcm_mini_adapter *Adapter)
{
UINT uiResetValue = 0;
UINT uiIndex = 0;
Adapter->LEDInfo.bIdle_led_off = FALSE;
}
-static INT BcmGetGPIOPinInfo(PMINI_ADAPTER Adapter, UCHAR *GPIO_num_tx,
+static INT BcmGetGPIOPinInfo(struct bcm_mini_adapter *Adapter, UCHAR *GPIO_num_tx,
UCHAR *GPIO_num_rx, UCHAR *uiLedTxIndex, UCHAR *uiLedRxIndex,
LedEventInfo_t currdriverstate)
{
}
return STATUS_SUCCESS;
}
-static VOID LEDControlThread(PMINI_ADAPTER Adapter)
+static VOID LEDControlThread(struct bcm_mini_adapter *Adapter)
{
UINT uiIndex = 0;
UCHAR GPIO_num = 0;
Adapter->LEDInfo.led_thread_running = BCM_LED_THREAD_DISABLED;
}
-int InitLedSettings(PMINI_ADAPTER Adapter)
+int InitLedSettings(struct bcm_mini_adapter *Adapter)
{
int Status = STATUS_SUCCESS;
BOOLEAN bEnableThread = TRUE;
#define DWORD unsigned int
-static INT BcmDoChipSelect(PMINI_ADAPTER Adapter, UINT offset);
-static INT BcmGetActiveDSD(PMINI_ADAPTER Adapter);
-static INT BcmGetActiveISO(PMINI_ADAPTER Adapter);
-static UINT BcmGetEEPROMSize(PMINI_ADAPTER Adapter);
-static INT BcmGetFlashCSInfo(PMINI_ADAPTER Adapter);
-static UINT BcmGetFlashSectorSize(PMINI_ADAPTER Adapter, UINT FlashSectorSizeSig, UINT FlashSectorSize);
-
-static VOID BcmValidateNvmType(PMINI_ADAPTER Adapter);
-static INT BcmGetNvmSize(PMINI_ADAPTER Adapter);
-static UINT BcmGetFlashSize(PMINI_ADAPTER Adapter);
-static NVM_TYPE BcmGetNvmType(PMINI_ADAPTER Adapter);
-
-static INT BcmGetSectionValEndOffset(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal);
-
-static B_UINT8 IsOffsetWritable(PMINI_ADAPTER Adapter, UINT uiOffset);
-static INT IsSectionWritable(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL Section);
-static INT IsSectionExistInVendorInfo(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL section);
-
-static INT ReadDSDPriority(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL dsd);
-static INT ReadDSDSignature(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL dsd);
-static INT ReadISOPriority(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL iso);
-static INT ReadISOSignature(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL iso);
-
-static INT CorruptDSDSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal);
-static INT CorruptISOSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal);
-static INT SaveHeaderIfPresent(PMINI_ADAPTER Adapter, PUCHAR pBuff, UINT uiSectAlignAddr);
-static INT WriteToFlashWithoutSectorErase(PMINI_ADAPTER Adapter, PUINT pBuff,
- FLASH2X_SECTION_VAL eFlash2xSectionVal,
- UINT uiOffset, UINT uiNumBytes);
-static FLASH2X_SECTION_VAL getHighestPriDSD(PMINI_ADAPTER Adapter);
-static FLASH2X_SECTION_VAL getHighestPriISO(PMINI_ADAPTER Adapter);
-
-static INT BeceemFlashBulkRead(
- PMINI_ADAPTER Adapter,
+static int BcmDoChipSelect(struct bcm_mini_adapter *Adapter, unsigned int offset);
+static int BcmGetActiveDSD(struct bcm_mini_adapter *Adapter);
+static int BcmGetActiveISO(struct bcm_mini_adapter *Adapter);
+static unsigned int BcmGetEEPROMSize(struct bcm_mini_adapter *Adapter);
+static int BcmGetFlashCSInfo(struct bcm_mini_adapter *Adapter);
+static unsigned int BcmGetFlashSectorSize(struct bcm_mini_adapter *Adapter, unsigned int FlashSectorSizeSig, unsigned int FlashSectorSize);
+
+static VOID BcmValidateNvmType(struct bcm_mini_adapter *Adapter);
+static int BcmGetNvmSize(struct bcm_mini_adapter *Adapter);
+static unsigned int BcmGetFlashSize(struct bcm_mini_adapter *Adapter);
+static NVM_TYPE BcmGetNvmType(struct bcm_mini_adapter *Adapter);
+
+static int BcmGetSectionValEndOffset(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal);
+
+static B_UINT8 IsOffsetWritable(struct bcm_mini_adapter *Adapter, unsigned int uiOffset);
+static int IsSectionWritable(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL Section);
+static int IsSectionExistInVendorInfo(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL section);
+
+static int ReadDSDPriority(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL dsd);
+static int ReadDSDSignature(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL dsd);
+static int ReadISOPriority(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL iso);
+static int ReadISOSignature(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL iso);
+
+static int CorruptDSDSig(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal);
+static int CorruptISOSig(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal);
+static int SaveHeaderIfPresent(struct bcm_mini_adapter *Adapter, PUCHAR pBuff, unsigned int uiSectAlignAddr);
+static int WriteToFlashWithoutSectorErase(struct bcm_mini_adapter *Adapter, PUINT pBuff,
+ FLASH2X_SECTION_VAL eFlash2xSectionVal,
+ unsigned int uiOffset, unsigned int uiNumBytes);
+static FLASH2X_SECTION_VAL getHighestPriDSD(struct bcm_mini_adapter *Adapter);
+static FLASH2X_SECTION_VAL getHighestPriISO(struct bcm_mini_adapter *Adapter);
+
+static int BeceemFlashBulkRead(
+ struct bcm_mini_adapter *Adapter,
PUINT pBuffer,
- UINT uiOffset,
- UINT uiNumBytes);
+ unsigned int uiOffset,
+ unsigned int uiNumBytes);
-static INT BeceemFlashBulkWrite(
- PMINI_ADAPTER Adapter,
+static int BeceemFlashBulkWrite(
+ struct bcm_mini_adapter *Adapter,
PUINT pBuffer,
- UINT uiOffset,
- UINT uiNumBytes,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes,
BOOLEAN bVerify);
-static INT GetFlashBaseAddr(PMINI_ADAPTER Adapter);
+static int GetFlashBaseAddr(struct bcm_mini_adapter *Adapter);
-static INT ReadBeceemEEPROMBulk(PMINI_ADAPTER Adapter,UINT dwAddress, UINT *pdwData, UINT dwNumData);
+static int ReadBeceemEEPROMBulk(struct bcm_mini_adapter *Adapter, unsigned int dwAddress, unsigned int *pdwData, unsigned int dwNumData);
-// Procedure: ReadEEPROMStatusRegister
-//
-// Description: Reads the standard EEPROM Status Register.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-static UCHAR ReadEEPROMStatusRegister( PMINI_ADAPTER Adapter )
+/* Procedure: ReadEEPROMStatusRegister
+ *
+ * Description: Reads the standard EEPROM Status Register.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * Returns:
+ * OSAL_STATUS_CODE
+ */
+static UCHAR ReadEEPROMStatusRegister(struct bcm_mini_adapter *Adapter)
{
UCHAR uiData = 0;
- DWORD dwRetries = MAX_EEPROM_RETRIES*RETRIES_PER_DELAY;
- UINT uiStatus = 0;
- UINT value = 0;
- UINT value1 = 0;
+ DWORD dwRetries = MAX_EEPROM_RETRIES * RETRIES_PER_DELAY;
+ unsigned int uiStatus = 0;
+ unsigned int value = 0;
+ unsigned int value1 = 0;
/* Read the EEPROM status register */
- value = EEPROM_READ_STATUS_REGISTER ;
- wrmalt( Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
+ value = EEPROM_READ_STATUS_REGISTER;
+ wrmalt(Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
- while ( dwRetries != 0 )
- {
- value=0;
- uiStatus = 0 ;
+ while (dwRetries != 0) {
+ value = 0;
+ uiStatus = 0;
rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &uiStatus, sizeof(uiStatus));
- if(Adapter->device_removed == TRUE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Modem has got removed hence exiting....");
+ if (Adapter->device_removed == TRUE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Modem has got removed hence exiting....");
break;
}
/* Wait for Avail bit to be set. */
- if ( ( uiStatus & EEPROM_READ_DATA_AVAIL) != 0 )
- {
+ if ((uiStatus & EEPROM_READ_DATA_AVAIL) != 0) {
/* Clear the Avail/Full bits - which ever is set. */
value = uiStatus & (EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL);
- wrmalt( Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
+ wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
- value =0;
+ value = 0;
rdmalt(Adapter, EEPROM_READ_DATAQ_REG, &value, sizeof(value));
uiData = (UCHAR)value;
break;
}
- dwRetries-- ;
- if ( dwRetries == 0 )
- {
- rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
- rdmalt(Adapter, EEPROM_SPI_Q_STATUS_REG, &value1, sizeof(value1));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"0x3004 = %x 0x3008 = %x, retries = %d failed.\n",value,value1, MAX_EEPROM_RETRIES*RETRIES_PER_DELAY);
+ dwRetries--;
+ if (dwRetries == 0) {
+ rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
+ rdmalt(Adapter, EEPROM_SPI_Q_STATUS_REG, &value1, sizeof(value1));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "0x3004 = %x 0x3008 = %x, retries = %d failed.\n", value, value1, MAX_EEPROM_RETRIES * RETRIES_PER_DELAY);
return uiData;
}
- if( !(dwRetries%RETRIES_PER_DELAY) )
- msleep(1);
+ if (!(dwRetries%RETRIES_PER_DELAY))
+ udelay(1000);
uiStatus = 0 ;
}
return uiData;
} /* ReadEEPROMStatusRegister */
-//-----------------------------------------------------------------------------
-// Procedure: ReadBeceemEEPROMBulk
-//
-// Description: This routine reads 16Byte data from EEPROM
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// dwAddress - EEPROM Offset to read the data from.
-// pdwData - Pointer to double word where data needs to be stored in. // dwNumWords - Number of words. Valid values are 4 ONLY.
-//
-// Returns:
-// OSAL_STATUS_CODE:
-//-----------------------------------------------------------------------------
-
-INT ReadBeceemEEPROMBulk( PMINI_ADAPTER Adapter,
- DWORD dwAddress,
- DWORD *pdwData,
- DWORD dwNumWords
- )
+/*
+ * Procedure: ReadBeceemEEPROMBulk
+ *
+ * Description: This routine reads 16Byte data from EEPROM
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * dwAddress - EEPROM Offset to read the data from.
+ * pdwData - Pointer to double word where data needs to be stored in. // dwNumWords - Number of words. Valid values are 4 ONLY.
+ *
+ * Returns:
+ * OSAL_STATUS_CODE:
+ */
+
+int ReadBeceemEEPROMBulk(struct bcm_mini_adapter *Adapter,
+ DWORD dwAddress,
+ DWORD *pdwData,
+ DWORD dwNumWords)
{
DWORD dwIndex = 0;
- DWORD dwRetries = MAX_EEPROM_RETRIES*RETRIES_PER_DELAY;
- UINT uiStatus = 0;
- UINT value= 0;
- UINT value1 = 0;
+ DWORD dwRetries = MAX_EEPROM_RETRIES * RETRIES_PER_DELAY;
+ unsigned int uiStatus = 0;
+ unsigned int value = 0;
+ unsigned int value1 = 0;
UCHAR *pvalue;
/* Flush the read and cmd queue. */
- value=( EEPROM_READ_QUEUE_FLUSH | EEPROM_CMD_QUEUE_FLUSH );
- wrmalt( Adapter, SPI_FLUSH_REG, &value, sizeof(value) );
- value=0;
- wrmalt( Adapter, SPI_FLUSH_REG, &value, sizeof(value));
+ value = (EEPROM_READ_QUEUE_FLUSH | EEPROM_CMD_QUEUE_FLUSH);
+ wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
+ value = 0;
+ wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
/* Clear the Avail/Full bits. */
- value=( EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL );
- wrmalt( Adapter, EEPROM_SPI_Q_STATUS1_REG,&value, sizeof(value));
-
- value= dwAddress | ( (dwNumWords == 4) ? EEPROM_16_BYTE_PAGE_READ : EEPROM_4_BYTE_PAGE_READ );
- wrmalt( Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
+ value = (EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL);
+ wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
- while ( dwRetries != 0 )
- {
+ value = dwAddress | ((dwNumWords == 4) ? EEPROM_16_BYTE_PAGE_READ : EEPROM_4_BYTE_PAGE_READ);
+ wrmalt(Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
+ while (dwRetries != 0) {
uiStatus = 0;
rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &uiStatus, sizeof(uiStatus));
- if(Adapter->device_removed == TRUE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Modem has got Removed.hence exiting from loop...");
+ if (Adapter->device_removed == TRUE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Modem has got Removed.hence exiting from loop...");
return -ENODEV;
}
/* If we are reading 16 bytes we want to be sure that the queue
* is full before we read. In the other cases we are ok if the
- * queue has data available */
- if ( dwNumWords == 4 )
- {
- if ( ( uiStatus & EEPROM_READ_DATA_FULL ) != 0 )
- {
+ * queue has data available
+ */
+ if (dwNumWords == 4) {
+ if ((uiStatus & EEPROM_READ_DATA_FULL) != 0) {
/* Clear the Avail/Full bits - which ever is set. */
- value = ( uiStatus & (EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL) ) ;
- wrmalt( Adapter, EEPROM_SPI_Q_STATUS1_REG,&value, sizeof(value));
+ value = (uiStatus & (EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL));
+ wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
break;
}
- }
- else if ( dwNumWords == 1 )
- {
-
- if ( ( uiStatus & EEPROM_READ_DATA_AVAIL ) != 0 )
- {
+ } else if (dwNumWords == 1) {
+ if ((uiStatus & EEPROM_READ_DATA_AVAIL) != 0) {
/* We just got Avail and we have to read 32bits so we
- * need this sleep for Cardbus kind of devices. */
- if (Adapter->chip_id == 0xBECE0210 )
- udelay(800);
+ * need this sleep for Cardbus kind of devices.
+ */
+ if (Adapter->chip_id == 0xBECE0210)
+ udelay(800);
/* Clear the Avail/Full bits - which ever is set. */
- value=( uiStatus & (EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL) );
- wrmalt( Adapter, EEPROM_SPI_Q_STATUS1_REG,&value, sizeof(value));
+ value = (uiStatus & (EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL));
+ wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
break;
}
}
uiStatus = 0;
dwRetries--;
- if(dwRetries == 0)
- {
- value=0;
- value1=0;
+ if (dwRetries == 0) {
+ value = 0;
+ value1 = 0;
rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
rdmalt(Adapter, EEPROM_SPI_Q_STATUS_REG, &value1, sizeof(value1));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "dwNumWords %d 0x3004 = %x 0x3008 = %x retries = %d failed.\n", dwNumWords, value, value1, MAX_EEPROM_RETRIES*RETRIES_PER_DELAY);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "dwNumWords %d 0x3004 = %x 0x3008 = %x retries = %d failed.\n",
+ dwNumWords, value, value1, MAX_EEPROM_RETRIES * RETRIES_PER_DELAY);
return STATUS_FAILURE;
}
- if( !(dwRetries%RETRIES_PER_DELAY) )
- msleep(1);
+
+ if (!(dwRetries%RETRIES_PER_DELAY))
+ udelay(1000);
}
- for ( dwIndex = 0; dwIndex < dwNumWords ; dwIndex++ )
- {
+ for (dwIndex = 0; dwIndex < dwNumWords; dwIndex++) {
/* We get only a byte at a time - from LSB to MSB. We shift it into an integer. */
pvalue = (PUCHAR)(pdwData + dwIndex);
- value =0;
+ value = 0;
rdmalt(Adapter, EEPROM_READ_DATAQ_REG, &value, sizeof(value));
pvalue[0] = value;
pvalue[1] = value;
- value =0;
+ value = 0;
rdmalt(Adapter, EEPROM_READ_DATAQ_REG, &value, sizeof(value));
pvalue[2] = value;
return STATUS_SUCCESS;
} /* ReadBeceemEEPROMBulk() */
-//-----------------------------------------------------------------------------
-// Procedure: ReadBeceemEEPROM
-//
-// Description: This routine reads 4 data from EEPROM. It uses 1 or 2 page
-// reads to do this operation.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// uiOffset - EEPROM Offset to read the data from.
-// pBuffer - Pointer to word where data needs to be stored in.
-//
-// Returns:
-// OSAL_STATUS_CODE:
-//-----------------------------------------------------------------------------
-
-INT ReadBeceemEEPROM( PMINI_ADAPTER Adapter,
- DWORD uiOffset,
- DWORD *pBuffer
- )
+/*
+ * Procedure: ReadBeceemEEPROM
+ *
+ * Description: This routine reads 4 data from EEPROM. It uses 1 or 2 page
+ * reads to do this operation.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * uiOffset - EEPROM Offset to read the data from.
+ * pBuffer - Pointer to word where data needs to be stored in.
+ *
+ * Returns:
+ * OSAL_STATUS_CODE:
+ */
+
+int ReadBeceemEEPROM(struct bcm_mini_adapter *Adapter,
+ DWORD uiOffset,
+ DWORD *pBuffer)
{
- UINT uiData[8] = {0};
- UINT uiByteOffset = 0;
- UINT uiTempOffset = 0;
+ unsigned int uiData[8] = {0};
+ unsigned int uiByteOffset = 0;
+ unsigned int uiTempOffset = 0;
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL," ====> ");
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " ====> ");
uiTempOffset = uiOffset - (uiOffset % MAX_RW_SIZE);
uiByteOffset = uiOffset - uiTempOffset;
ReadBeceemEEPROMBulk(Adapter, uiTempOffset, (PUINT)&uiData[0], 4);
/* A word can overlap at most over 2 pages. In that case we read the
- * next page too. */
- if ( uiByteOffset > 12 )
- {
+ * next page too.
+ */
+ if (uiByteOffset > 12)
ReadBeceemEEPROMBulk(Adapter, uiTempOffset + MAX_RW_SIZE, (PUINT)&uiData[4], 4);
- }
- memcpy( (PUCHAR) pBuffer, ( ((PUCHAR)&uiData[0]) + uiByteOffset ), 4);
+ memcpy((PUCHAR)pBuffer, (((PUCHAR)&uiData[0]) + uiByteOffset), 4);
return STATUS_SUCCESS;
} /* ReadBeceemEEPROM() */
-
-
-INT ReadMacAddressFromNVM(PMINI_ADAPTER Adapter)
+int ReadMacAddressFromNVM(struct bcm_mini_adapter *Adapter)
{
- INT Status;
+ int Status;
unsigned char puMacAddr[6];
Status = BeceemNVMRead(Adapter,
INIT_PARAMS_1_MACADDRESS_ADDRESS,
MAC_ADDRESS_SIZE);
- if(Status == STATUS_SUCCESS)
+ if (Status == STATUS_SUCCESS)
memcpy(Adapter->dev->dev_addr, puMacAddr, MAC_ADDRESS_SIZE);
return Status;
}
-//-----------------------------------------------------------------------------
-// Procedure: BeceemEEPROMBulkRead
-//
-// Description: Reads the EEPROM and returns the Data.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// pBuffer - Buffer to store the data read from EEPROM
-// uiOffset - Offset of EEPROM from where data should be read
-// uiNumBytes - Number of bytes to be read from the EEPROM.
-//
-// Returns:
-// OSAL_STATUS_SUCCESS - if EEPROM read is successful.
-// <FAILURE> - if failed.
-//-----------------------------------------------------------------------------
-
-INT BeceemEEPROMBulkRead(
- PMINI_ADAPTER Adapter,
- PUINT pBuffer,
- UINT uiOffset,
- UINT uiNumBytes)
+/*
+ * Procedure: BeceemEEPROMBulkRead
+ *
+ * Description: Reads the EEPROM and returns the Data.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * pBuffer - Buffer to store the data read from EEPROM
+ * uiOffset - Offset of EEPROM from where data should be read
+ * uiNumBytes - Number of bytes to be read from the EEPROM.
+ *
+ * Returns:
+ * OSAL_STATUS_SUCCESS - if EEPROM read is successful.
+ * <FAILURE> - if failed.
+ */
+
+int BeceemEEPROMBulkRead(struct bcm_mini_adapter *Adapter,
+ PUINT pBuffer,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes)
{
- UINT uiData[4] = {0};
- //UINT uiAddress = 0;
- UINT uiBytesRemaining = uiNumBytes;
- UINT uiIndex = 0;
- UINT uiTempOffset = 0;
- UINT uiExtraBytes = 0;
- UINT uiFailureRetries = 0;
+ unsigned int uiData[4] = {0};
+ /* unsigned int uiAddress = 0; */
+ unsigned int uiBytesRemaining = uiNumBytes;
+ unsigned int uiIndex = 0;
+ unsigned int uiTempOffset = 0;
+ unsigned int uiExtraBytes = 0;
+ unsigned int uiFailureRetries = 0;
PUCHAR pcBuff = (PUCHAR)pBuffer;
-
- if(uiOffset%MAX_RW_SIZE&& uiBytesRemaining)
- {
- uiTempOffset = uiOffset - (uiOffset%MAX_RW_SIZE);
- uiExtraBytes = uiOffset-uiTempOffset;
- ReadBeceemEEPROMBulk(Adapter,uiTempOffset,(PUINT)&uiData[0],4);
- if(uiBytesRemaining >= (MAX_RW_SIZE - uiExtraBytes))
- {
- memcpy(pBuffer,(((PUCHAR)&uiData[0])+uiExtraBytes),MAX_RW_SIZE - uiExtraBytes);
-
+ if (uiOffset % MAX_RW_SIZE && uiBytesRemaining) {
+ uiTempOffset = uiOffset - (uiOffset % MAX_RW_SIZE);
+ uiExtraBytes = uiOffset - uiTempOffset;
+ ReadBeceemEEPROMBulk(Adapter, uiTempOffset, (PUINT)&uiData[0], 4);
+ if (uiBytesRemaining >= (MAX_RW_SIZE - uiExtraBytes)) {
+ memcpy(pBuffer, (((PUCHAR)&uiData[0]) + uiExtraBytes), MAX_RW_SIZE - uiExtraBytes);
uiBytesRemaining -= (MAX_RW_SIZE - uiExtraBytes);
uiIndex += (MAX_RW_SIZE - uiExtraBytes);
uiOffset += (MAX_RW_SIZE - uiExtraBytes);
- }
- else
- {
- memcpy(pBuffer,(((PUCHAR)&uiData[0])+uiExtraBytes),uiBytesRemaining);
+ } else {
+ memcpy(pBuffer, (((PUCHAR)&uiData[0]) + uiExtraBytes), uiBytesRemaining);
uiIndex += uiBytesRemaining;
uiOffset += uiBytesRemaining;
uiBytesRemaining = 0;
}
-
-
}
-
- while(uiBytesRemaining && uiFailureRetries != 128)
- {
- if(Adapter->device_removed )
- {
+ while (uiBytesRemaining && uiFailureRetries != 128) {
+ if (Adapter->device_removed)
return -1;
- }
- if(uiBytesRemaining >= MAX_RW_SIZE)
- {
+ if (uiBytesRemaining >= MAX_RW_SIZE) {
/* For the requests more than or equal to 16 bytes, use bulk
* read function to make the access faster.
- * We read 4 Dwords of data */
- if(0 == ReadBeceemEEPROMBulk(Adapter,uiOffset,&uiData[0],4))
- {
- memcpy(pcBuff+uiIndex,&uiData[0],MAX_RW_SIZE);
+ * We read 4 Dwords of data
+ */
+ if (ReadBeceemEEPROMBulk(Adapter, uiOffset, &uiData[0], 4) == 0) {
+ memcpy(pcBuff + uiIndex, &uiData[0], MAX_RW_SIZE);
uiOffset += MAX_RW_SIZE;
uiBytesRemaining -= MAX_RW_SIZE;
uiIndex += MAX_RW_SIZE;
- }
- else
- {
+ } else {
uiFailureRetries++;
- mdelay(3);//sleep for a while before retry...
+ mdelay(3); /* sleep for a while before retry... */
}
- }
- else if(uiBytesRemaining >= 4)
- {
- if(0 == ReadBeceemEEPROM(Adapter,uiOffset,&uiData[0]))
- {
- memcpy(pcBuff+uiIndex,&uiData[0],4);
+ } else if (uiBytesRemaining >= 4) {
+ if (ReadBeceemEEPROM(Adapter, uiOffset, &uiData[0]) == 0) {
+ memcpy(pcBuff + uiIndex, &uiData[0], 4);
uiOffset += 4;
uiBytesRemaining -= 4;
- uiIndex +=4;
- }
- else
- {
+ uiIndex += 4;
+ } else {
uiFailureRetries++;
- mdelay(3);//sleep for a while before retry...
+ mdelay(3); /* sleep for a while before retry... */
}
- }
- else
- { // Handle the reads less than 4 bytes...
+ } else {
+ /* Handle the reads less than 4 bytes... */
PUCHAR pCharBuff = (PUCHAR)pBuffer;
pCharBuff += uiIndex;
- if(0 == ReadBeceemEEPROM(Adapter,uiOffset,&uiData[0]))
- {
- memcpy(pCharBuff,&uiData[0],uiBytesRemaining);//copy only bytes requested.
+ if (ReadBeceemEEPROM(Adapter, uiOffset, &uiData[0]) == 0) {
+ memcpy(pCharBuff, &uiData[0], uiBytesRemaining); /* copy only bytes requested. */
uiBytesRemaining = 0;
- }
- else
- {
+ } else {
uiFailureRetries++;
- mdelay(3);//sleep for a while before retry...
+ mdelay(3); /* sleep for a while before retry... */
}
}
-
}
return 0;
}
-//-----------------------------------------------------------------------------
-// Procedure: BeceemFlashBulkRead
-//
-// Description: Reads the FLASH and returns the Data.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// pBuffer - Buffer to store the data read from FLASH
-// uiOffset - Offset of FLASH from where data should be read
-// uiNumBytes - Number of bytes to be read from the FLASH.
-//
-// Returns:
-// OSAL_STATUS_SUCCESS - if FLASH read is successful.
-// <FAILURE> - if failed.
-//-----------------------------------------------------------------------------
-
-static INT BeceemFlashBulkRead(
- PMINI_ADAPTER Adapter,
- PUINT pBuffer,
- UINT uiOffset,
- UINT uiNumBytes)
+/*
+ * Procedure: BeceemFlashBulkRead
+ *
+ * Description: Reads the FLASH and returns the Data.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * pBuffer - Buffer to store the data read from FLASH
+ * uiOffset - Offset of FLASH from where data should be read
+ * uiNumBytes - Number of bytes to be read from the FLASH.
+ *
+ * Returns:
+ * OSAL_STATUS_SUCCESS - if FLASH read is successful.
+ * <FAILURE> - if failed.
+ */
+
+static int BeceemFlashBulkRead(struct bcm_mini_adapter *Adapter,
+ PUINT pBuffer,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes)
{
- UINT uiIndex = 0;
- UINT uiBytesToRead = uiNumBytes;
- INT Status = 0;
- UINT uiPartOffset = 0;
+ unsigned int uiIndex = 0;
+ unsigned int uiBytesToRead = uiNumBytes;
+ int Status = 0;
+ unsigned int uiPartOffset = 0;
int bytes;
- if(Adapter->device_removed )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device Got Removed ");
+ if (Adapter->device_removed) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device Got Removed");
return -ENODEV;
}
- //Adding flash Base address
-// uiOffset = uiOffset + GetFlashBaseAddr(Adapter);
-#if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
- Status = bcmflash_raw_read((uiOffset/FLASH_PART_SIZE),(uiOffset % FLASH_PART_SIZE),( unsigned char *)pBuffer,uiNumBytes);
- return Status;
-#endif
+ /* Adding flash Base address
+ * uiOffset = uiOffset + GetFlashBaseAddr(Adapter);
+ */
+ #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
+ Status = bcmflash_raw_read((uiOffset/FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
+ return Status;
+ #endif
Adapter->SelectedChip = RESET_CHIP_SELECT;
- if(uiOffset % MAX_RW_SIZE)
- {
- BcmDoChipSelect(Adapter,uiOffset);
+ if (uiOffset % MAX_RW_SIZE) {
+ BcmDoChipSelect(Adapter, uiOffset);
uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
- uiBytesToRead = MAX_RW_SIZE - (uiOffset%MAX_RW_SIZE);
- uiBytesToRead = MIN(uiNumBytes,uiBytesToRead);
+ uiBytesToRead = MAX_RW_SIZE - (uiOffset % MAX_RW_SIZE);
+ uiBytesToRead = MIN(uiNumBytes, uiBytesToRead);
- bytes = rdm(Adapter, uiPartOffset, (PCHAR)pBuffer+uiIndex, uiBytesToRead);
+ bytes = rdm(Adapter, uiPartOffset, (PCHAR)pBuffer + uiIndex, uiBytesToRead);
if (bytes < 0) {
Status = bytes;
Adapter->SelectedChip = RESET_CHIP_SELECT;
uiNumBytes -= uiBytesToRead;
}
- while(uiNumBytes)
- {
- BcmDoChipSelect(Adapter,uiOffset);
+ while (uiNumBytes) {
+ BcmDoChipSelect(Adapter, uiOffset);
uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
- uiBytesToRead = MIN(uiNumBytes,MAX_RW_SIZE);
+ uiBytesToRead = MIN(uiNumBytes, MAX_RW_SIZE);
- bytes = rdm(Adapter, uiPartOffset, (PCHAR)pBuffer+uiIndex, uiBytesToRead);
+ bytes = rdm(Adapter, uiPartOffset, (PCHAR)pBuffer + uiIndex, uiBytesToRead);
if (bytes < 0) {
Status = bytes;
break;
}
-
uiIndex += uiBytesToRead;
uiOffset += uiBytesToRead;
uiNumBytes -= uiBytesToRead;
-
}
Adapter->SelectedChip = RESET_CHIP_SELECT;
return Status;
}
-//-----------------------------------------------------------------------------
-// Procedure: BcmGetFlashSize
-//
-// Description: Finds the size of FLASH.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-//
-// Returns:
-// UINT - size of the FLASH Storage.
-//
-//-----------------------------------------------------------------------------
-
-static UINT BcmGetFlashSize(PMINI_ADAPTER Adapter)
+/*
+ * Procedure: BcmGetFlashSize
+ *
+ * Description: Finds the size of FLASH.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ *
+ * Returns:
+ * unsigned int - size of the FLASH Storage.
+ *
+ */
+
+static unsigned int BcmGetFlashSize(struct bcm_mini_adapter *Adapter)
{
- if(IsFlash2x(Adapter))
- return (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(DSD_HEADER));
+ if (IsFlash2x(Adapter))
+ return Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(DSD_HEADER);
else
- return 32*1024;
-
-
+ return 32 * 1024;
}
-//-----------------------------------------------------------------------------
-// Procedure: BcmGetEEPROMSize
-//
-// Description: Finds the size of EEPROM.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-//
-// Returns:
-// UINT - size of the EEPROM Storage.
-//
-//-----------------------------------------------------------------------------
-
-static UINT BcmGetEEPROMSize(PMINI_ADAPTER Adapter)
+/*
+ * Procedure: BcmGetEEPROMSize
+ *
+ * Description: Finds the size of EEPROM.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ *
+ * Returns:
+ * unsigned int - size of the EEPROM Storage.
+ *
+ */
+
+static unsigned int BcmGetEEPROMSize(struct bcm_mini_adapter *Adapter)
{
- UINT uiData = 0;
- UINT uiIndex = 0;
-
-//
-// if EEPROM is present and already Calibrated,it will have
-// 'BECM' string at 0th offset.
-// To find the EEPROM size read the possible boundaries of the
-// EEPROM like 4K,8K etc..accessing the EEPROM beyond its size will
-// result in wrap around. So when we get the End of the EEPROM we will
-// get 'BECM' string which is indeed at offset 0.
-//
- BeceemEEPROMBulkRead(Adapter,&uiData,0x0,4);
- if(uiData == BECM)
- {
- for(uiIndex = 2;uiIndex <=256; uiIndex*=2)
- {
- BeceemEEPROMBulkRead(Adapter,&uiData,uiIndex*1024,4);
- if(uiData == BECM)
- {
- return uiIndex*1024;
- }
- }
- }
- else
- {
-//
-// EEPROM may not be present or not programmed
-//
+ unsigned int uiData = 0;
+ unsigned int uiIndex = 0;
- uiData = 0xBABEFACE;
- if(0 == BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&uiData,0,4,TRUE))
- {
+ /*
+ * if EEPROM is present and already Calibrated,it will have
+ * 'BECM' string at 0th offset.
+ * To find the EEPROM size read the possible boundaries of the
+ * EEPROM like 4K,8K etc..accessing the EEPROM beyond its size will
+ * result in wrap around. So when we get the End of the EEPROM we will
+ * get 'BECM' string which is indeed at offset 0.
+ */
+ BeceemEEPROMBulkRead(Adapter, &uiData, 0x0, 4);
+ if (uiData == BECM) {
+ for (uiIndex = 2; uiIndex <= 256; uiIndex *= 2) {
+ BeceemEEPROMBulkRead(Adapter, &uiData, uiIndex * 1024, 4);
+ if (uiData == BECM)
+ return uiIndex * 1024;
+ }
+ } else {
+ /*
+ * EEPROM may not be present or not programmed
+ */
+ uiData = 0xBABEFACE;
+ if (BeceemEEPROMBulkWrite(Adapter, (PUCHAR)&uiData, 0, 4, TRUE) == 0) {
uiData = 0;
- for(uiIndex = 2;uiIndex <=256; uiIndex*=2)
- {
- BeceemEEPROMBulkRead(Adapter,&uiData,uiIndex*1024,4);
- if(uiData == 0xBABEFACE)
- {
- return uiIndex*1024;
- }
+ for (uiIndex = 2; uiIndex <= 256; uiIndex *= 2) {
+ BeceemEEPROMBulkRead(Adapter, &uiData, uiIndex * 1024, 4);
+ if (uiData == 0xBABEFACE)
+ return uiIndex * 1024;
}
}
-
}
return 0;
}
-
-//-----------------------------------------------------------------------------
-// Procedure: FlashSectorErase
-//
-// Description: Finds the sector size of the FLASH.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// addr - sector start address
-// numOfSectors - number of sectors to be erased.
-//
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-
-static INT FlashSectorErase(PMINI_ADAPTER Adapter,
- UINT addr,
- UINT numOfSectors)
+/*
+ * Procedure: FlashSectorErase
+ *
+ * Description: Finds the sector size of the FLASH.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * addr - sector start address
+ * numOfSectors - number of sectors to be erased.
+ *
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+static int FlashSectorErase(struct bcm_mini_adapter *Adapter,
+ unsigned int addr,
+ unsigned int numOfSectors)
{
- UINT iIndex = 0, iRetries = 0;
- UINT uiStatus = 0;
- UINT value;
+ unsigned int iIndex = 0, iRetries = 0;
+ unsigned int uiStatus = 0;
+ unsigned int value;
int bytes;
- for(iIndex=0;iIndex<numOfSectors;iIndex++)
- {
+ for (iIndex = 0; iIndex < numOfSectors; iIndex++) {
value = 0x06000000;
wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
iRetries = 0;
- do
- {
+ do {
value = (FLASH_CMD_STATUS_REG_READ << 24);
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Programing of FLASH_SPI_CMDQ_REG fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programing of FLASH_SPI_CMDQ_REG fails");
return STATUS_FAILURE;
}
return uiStatus;
}
iRetries++;
- //After every try lets make the CPU free for 10 ms. generally time taken by the
- //the sector erase cycle is 500 ms to 40000 msec. hence sleeping 10 ms
- //won't hamper performance in any case.
- msleep(10);
- }while((uiStatus & 0x1) && (iRetries < 400));
-
- if(uiStatus & 0x1)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"iRetries crossing the limit of 80000\n");
+ /* After every try lets make the CPU free for 10 ms. generally time taken by the
+ * the sector erase cycle is 500 ms to 40000 msec. hence sleeping 10 ms
+ * won't hamper performance in any case.
+ */
+ udelay(10000);
+ } while ((uiStatus & 0x1) && (iRetries < 400));
+
+ if (uiStatus & 0x1) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "iRetries crossing the limit of 80000\n");
return STATUS_FAILURE;
}
}
return 0;
}
-//-----------------------------------------------------------------------------
-// Procedure: flashByteWrite
-//
-// Description: Performs Byte by Byte write to flash
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// uiOffset - Offset of the flash where data needs to be written to.
-// pData - Address of Data to be written.
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-static INT flashByteWrite(
- PMINI_ADAPTER Adapter,
- UINT uiOffset,
- PVOID pData)
+/*
+ * Procedure: flashByteWrite
+ *
+ * Description: Performs Byte by Byte write to flash
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * uiOffset - Offset of the flash where data needs to be written to.
+ * pData - Address of Data to be written.
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+static int flashByteWrite(struct bcm_mini_adapter *Adapter,
+ unsigned int uiOffset,
+ PVOID pData)
{
-
- UINT uiStatus = 0;
- INT iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; //3
-
- UINT value;
+ unsigned int uiStatus = 0;
+ int iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; /* 3 */
+ unsigned int value;
ULONG ulData = *(PUCHAR)pData;
int bytes;
+ /*
+ * need not write 0xFF because write requires an erase and erase will
+ * make whole sector 0xFF.
+ */
-//
-// need not write 0xFF because write requires an erase and erase will
-// make whole sector 0xFF.
-//
-
- if(0xFF == ulData)
- {
+ if (0xFF == ulData)
return STATUS_SUCCESS;
- }
-// DumpDebug(NVM_RW,("flashWrite ====>\n"));
+ /* DumpDebug(NVM_RW,("flashWrite ====>\n")); */
value = (FLASH_CMD_WRITE_ENABLE << 24);
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG,&value, sizeof(value)) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Write enable in FLASH_SPI_CMDQ_REG register fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write enable in FLASH_SPI_CMDQ_REG register fails");
return STATUS_FAILURE;
}
- if(wrm(Adapter,FLASH_SPI_WRITEQ_REG, (PCHAR)&ulData, 4) < 0 )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"DATA Write on FLASH_SPI_WRITEQ_REG fails");
+
+ if (wrm(Adapter, FLASH_SPI_WRITEQ_REG, (PCHAR)&ulData, 4) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "DATA Write on FLASH_SPI_WRITEQ_REG fails");
return STATUS_FAILURE;
}
value = (0x02000000 | (uiOffset & 0xFFFFFF));
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG,&value, sizeof(value)) < 0 )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Programming of FLASH_SPI_CMDQ_REG fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programming of FLASH_SPI_CMDQ_REG fails");
return STATUS_FAILURE;
}
- //__udelay(950);
+ /* __udelay(950); */
- do
- {
+ do {
value = (FLASH_CMD_STATUS_REG_READ << 24);
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Programing of FLASH_SPI_CMDQ_REG fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programing of FLASH_SPI_CMDQ_REG fails");
return STATUS_FAILURE;
- }
- //__udelay(1);
+ }
+ /* __udelay(1); */
bytes = rdmalt(Adapter, FLASH_SPI_READQ_REG, &uiStatus, sizeof(uiStatus));
if (bytes < 0) {
uiStatus = bytes;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reading status of FLASH_SPI_READQ_REG fails");
return uiStatus;
}
- iRetries--;
- if( iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
- msleep(1);
+ iRetries--;
+ if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
+ udelay(1000);
- }while((uiStatus & 0x1) && (iRetries >0) );
+ } while ((uiStatus & 0x1) && (iRetries > 0));
- if(uiStatus & 0x1)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Write fails even after checking status for 200 times.");
- return STATUS_FAILURE ;
+ if (uiStatus & 0x1) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write fails even after checking status for 200 times.");
+ return STATUS_FAILURE;
}
return STATUS_SUCCESS;
}
-
-
-//-----------------------------------------------------------------------------
-// Procedure: flashWrite
-//
-// Description: Performs write to flash
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// uiOffset - Offset of the flash where data needs to be written to.
-// pData - Address of Data to be written.
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-static INT flashWrite(
- PMINI_ADAPTER Adapter,
- UINT uiOffset,
- PVOID pData)
-
+/*
+ * Procedure: flashWrite
+ *
+ * Description: Performs write to flash
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * uiOffset - Offset of the flash where data needs to be written to.
+ * pData - Address of Data to be written.
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+static int flashWrite(struct bcm_mini_adapter *Adapter,
+ unsigned int uiOffset,
+ PVOID pData)
{
- //UINT uiStatus = 0;
- //INT iRetries = 0;
- //UINT uiReadBack = 0;
-
- UINT uiStatus = 0;
- INT iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; //3
-
- UINT value;
- UINT uiErasePattern[4] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF};
+ /* unsigned int uiStatus = 0;
+ * int iRetries = 0;
+ * unsigned int uiReadBack = 0;
+ */
+ unsigned int uiStatus = 0;
+ int iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; /* 3 */
+ unsigned int value;
+ unsigned int uiErasePattern[4] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
int bytes;
-//
-// need not write 0xFFFFFFFF because write requires an erase and erase will
-// make whole sector 0xFFFFFFFF.
-//
+ /*
+ * need not write 0xFFFFFFFF because write requires an erase and erase will
+ * make whole sector 0xFFFFFFFF.
+ */
if (!memcmp(pData, uiErasePattern, MAX_RW_SIZE))
- {
return 0;
- }
value = (FLASH_CMD_WRITE_ENABLE << 24);
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG,&value, sizeof(value)) < 0 )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Write Enable of FLASH_SPI_CMDQ_REG fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write Enable of FLASH_SPI_CMDQ_REG fails");
return STATUS_FAILURE;
}
- if(wrm(Adapter, uiOffset, (PCHAR)pData, MAX_RW_SIZE) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Data write fails...");
+
+ if (wrm(Adapter, uiOffset, (PCHAR)pData, MAX_RW_SIZE) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Data write fails...");
return STATUS_FAILURE;
}
- //__udelay(950);
- do
- {
+ /* __udelay(950); */
+ do {
value = (FLASH_CMD_STATUS_REG_READ << 24);
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Programing of FLASH_SPI_CMDQ_REG fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programing of FLASH_SPI_CMDQ_REG fails");
return STATUS_FAILURE;
- }
- //__udelay(1);
+ }
+ /* __udelay(1); */
bytes = rdmalt(Adapter, FLASH_SPI_READQ_REG, &uiStatus, sizeof(uiStatus));
if (bytes < 0) {
uiStatus = bytes;
}
iRetries--;
- //this will ensure that in there will be no changes in the current path.
- //currently one rdm/wrm takes 125 us.
- //Hence 125 *2 * FLASH_PER_RETRIES_DELAY > 3 ms(worst case delay)
- //Hence current implementation cycle will intoduce no delay in current path
- if(iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
- msleep(1);
- }while((uiStatus & 0x1) && (iRetries > 0));
-
- if(uiStatus & 0x1)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Write fails even after checking status for 200 times.");
- return STATUS_FAILURE ;
+ /* this will ensure that in there will be no changes in the current path.
+ * currently one rdm/wrm takes 125 us.
+ * Hence 125 *2 * FLASH_PER_RETRIES_DELAY > 3 ms(worst case delay)
+ * Hence current implementation cycle will intoduce no delay in current path
+ */
+ if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
+ udelay(1000);
+ } while ((uiStatus & 0x1) && (iRetries > 0));
+
+ if (uiStatus & 0x1) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write fails even after checking status for 200 times.");
+ return STATUS_FAILURE;
}
return STATUS_SUCCESS;
}
-//-----------------------------------------------------------------------------
-// Procedure: flashByteWriteStatus
-//
-// Description: Performs byte by byte write to flash with write done status check
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// uiOffset - Offset of the flash where data needs to be written to.
-// pData - Address of the Data to be written.
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-static INT flashByteWriteStatus(
- PMINI_ADAPTER Adapter,
- UINT uiOffset,
- PVOID pData)
+/*-----------------------------------------------------------------------------
+ * Procedure: flashByteWriteStatus
+ *
+ * Description: Performs byte by byte write to flash with write done status check
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * uiOffset - Offset of the flash where data needs to be written to.
+ * pData - Address of the Data to be written.
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+static int flashByteWriteStatus(struct bcm_mini_adapter *Adapter,
+ unsigned int uiOffset,
+ PVOID pData)
{
- UINT uiStatus = 0;
- INT iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; //3
+ unsigned int uiStatus = 0;
+ int iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; /* 3 */
ULONG ulData = *(PUCHAR)pData;
- UINT value;
+ unsigned int value;
int bytes;
-//
-// need not write 0xFFFFFFFF because write requires an erase and erase will
-// make whole sector 0xFFFFFFFF.
-//
+ /*
+ * need not write 0xFFFFFFFF because write requires an erase and erase will
+ * make whole sector 0xFFFFFFFF.
+ */
- if(0xFF == ulData)
- {
+ if (0xFF == ulData)
return STATUS_SUCCESS;
- }
- // DumpDebug(NVM_RW,("flashWrite ====>\n"));
+ /* DumpDebug(NVM_RW,("flashWrite ====>\n")); */
value = (FLASH_CMD_WRITE_ENABLE << 24);
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG,&value, sizeof(value)) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Write enable in FLASH_SPI_CMDQ_REG register fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write enable in FLASH_SPI_CMDQ_REG register fails");
return STATUS_SUCCESS;
}
- if(wrm(Adapter,FLASH_SPI_WRITEQ_REG, (PCHAR)&ulData, 4) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"DATA Write on FLASH_SPI_WRITEQ_REG fails");
+ if (wrm(Adapter, FLASH_SPI_WRITEQ_REG, (PCHAR)&ulData, 4) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "DATA Write on FLASH_SPI_WRITEQ_REG fails");
return STATUS_FAILURE;
}
value = (0x02000000 | (uiOffset & 0xFFFFFF));
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG,&value, sizeof(value)) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Programming of FLASH_SPI_CMDQ_REG fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programming of FLASH_SPI_CMDQ_REG fails");
return STATUS_FAILURE;
}
- //msleep(1);
+ /* msleep(1); */
- do
- {
+ do {
value = (FLASH_CMD_STATUS_REG_READ << 24);
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Programing of FLASH_SPI_CMDQ_REG fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programing of FLASH_SPI_CMDQ_REG fails");
return STATUS_FAILURE;
}
- //__udelay(1);
+ /* __udelay(1); */
bytes = rdmalt(Adapter, FLASH_SPI_READQ_REG, &uiStatus, sizeof(uiStatus));
if (bytes < 0) {
uiStatus = bytes;
}
iRetries--;
- if( iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
- msleep(1);
- }while((uiStatus & 0x1) && (iRetries > 0));
+ if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
+ udelay(1000);
- if(uiStatus & 0x1)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Write fails even after checking status for 200 times.");
- return STATUS_FAILURE ;
+ } while ((uiStatus & 0x1) && (iRetries > 0));
+
+ if (uiStatus & 0x1) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write fails even after checking status for 200 times.");
+ return STATUS_FAILURE;
}
return STATUS_SUCCESS;
-
}
-//-----------------------------------------------------------------------------
-// Procedure: flashWriteStatus
-//
-// Description: Performs write to flash with write done status check
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// uiOffset - Offset of the flash where data needs to be written to.
-// pData - Address of the Data to be written.
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-static INT flashWriteStatus(
- PMINI_ADAPTER Adapter,
- UINT uiOffset,
- PVOID pData)
+/*
+ * Procedure: flashWriteStatus
+ *
+ * Description: Performs write to flash with write done status check
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * uiOffset - Offset of the flash where data needs to be written to.
+ * pData - Address of the Data to be written.
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+static int flashWriteStatus(struct bcm_mini_adapter *Adapter,
+ unsigned int uiOffset,
+ PVOID pData)
{
- UINT uiStatus = 0;
- INT iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; //3
- //UINT uiReadBack = 0;
- UINT value;
- UINT uiErasePattern[4] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF};
+ unsigned int uiStatus = 0;
+ int iRetries = MAX_FLASH_RETRIES * FLASH_PER_RETRIES_DELAY; /* 3 */
+ /* unsigned int uiReadBack = 0; */
+ unsigned int value;
+ unsigned int uiErasePattern[4] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
int bytes;
-//
-// need not write 0xFFFFFFFF because write requires an erase and erase will
-// make whole sector 0xFFFFFFFF.
-//
- if (!memcmp(pData,uiErasePattern,MAX_RW_SIZE))
- {
+ /*
+ * need not write 0xFFFFFFFF because write requires an erase and erase will
+ * make whole sector 0xFFFFFFFF.
+ */
+ if (!memcmp(pData, uiErasePattern, MAX_RW_SIZE))
return 0;
- }
value = (FLASH_CMD_WRITE_ENABLE << 24);
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG,&value, sizeof(value)) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Write Enable of FLASH_SPI_CMDQ_REG fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write Enable of FLASH_SPI_CMDQ_REG fails");
return STATUS_FAILURE;
}
- if(wrm(Adapter, uiOffset, (PCHAR)pData, MAX_RW_SIZE) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Data write fails...");
+
+ if (wrm(Adapter, uiOffset, (PCHAR)pData, MAX_RW_SIZE) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Data write fails...");
return STATUS_FAILURE;
}
- // __udelay(1);
+ /* __udelay(1); */
- do
- {
+ do {
value = (FLASH_CMD_STATUS_REG_READ << 24);
- if(wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Programing of FLASH_SPI_CMDQ_REG fails");
+ if (wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value)) < 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Programing of FLASH_SPI_CMDQ_REG fails");
return STATUS_FAILURE;
- }
- //__udelay(1);
+ }
+ /* __udelay(1); */
bytes = rdmalt(Adapter, FLASH_SPI_READQ_REG, &uiStatus, sizeof(uiStatus));
if (bytes < 0) {
uiStatus = bytes;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reading status of FLASH_SPI_READQ_REG fails");
return uiStatus;
}
- iRetries--;
- //this will ensure that in there will be no changes in the current path.
- //currently one rdm/wrm takes 125 us.
- //Hence 125 *2 * FLASH_PER_RETRIES_DELAY >3 ms(worst case delay)
- //Hence current implementation cycle will intoduce no delay in current path
- if(iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
- msleep(1);
- }while((uiStatus & 0x1) && (iRetries >0));
-
- if(uiStatus & 0x1)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Write fails even after checking status for 200 times.");
- return STATUS_FAILURE ;
+ iRetries--;
+ /* this will ensure that in there will be no changes in the current path.
+ * currently one rdm/wrm takes 125 us.
+ * Hence 125 *2 * FLASH_PER_RETRIES_DELAY >3 ms(worst case delay)
+ * Hence current implementation cycle will intoduce no delay in current path
+ */
+ if (iRetries && ((iRetries % FLASH_PER_RETRIES_DELAY) == 0))
+ udelay(1000);
+
+ } while ((uiStatus & 0x1) && (iRetries > 0));
+
+ if (uiStatus & 0x1) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write fails even after checking status for 200 times.");
+ return STATUS_FAILURE;
}
return STATUS_SUCCESS;
}
-//-----------------------------------------------------------------------------
-// Procedure: BcmRestoreBlockProtectStatus
-//
-// Description: Restores the original block protection status.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// ulWriteStatus -Original status
-// Returns:
-// <VOID>
-//
-//-----------------------------------------------------------------------------
-
-static VOID BcmRestoreBlockProtectStatus(PMINI_ADAPTER Adapter,ULONG ulWriteStatus)
+/*
+ * Procedure: BcmRestoreBlockProtectStatus
+ *
+ * Description: Restores the original block protection status.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * ulWriteStatus -Original status
+ * Returns:
+ * <VOID>
+ *
+ */
+
+static VOID BcmRestoreBlockProtectStatus(struct bcm_mini_adapter *Adapter, ULONG ulWriteStatus)
{
- UINT value;
- value = (FLASH_CMD_WRITE_ENABLE<< 24);
+ unsigned int value;
+ value = (FLASH_CMD_WRITE_ENABLE << 24);
wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
udelay(20);
- value = (FLASH_CMD_STATUS_REG_WRITE<<24)|(ulWriteStatus << 16);
+ value = (FLASH_CMD_STATUS_REG_WRITE << 24) | (ulWriteStatus << 16);
wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
udelay(20);
}
-//-----------------------------------------------------------------------------
-// Procedure: BcmFlashUnProtectBlock
-//
-// Description: UnProtects appropriate blocks for writing.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// uiOffset - Offset of the flash where data needs to be written to. This should be Sector aligned.
-// Returns:
-// ULONG - Status value before UnProtect.
-//
-//-----------------------------------------------------------------------------
-static ULONG BcmFlashUnProtectBlock(PMINI_ADAPTER Adapter,UINT uiOffset, UINT uiLength)
+
+/*
+ * Procedure: BcmFlashUnProtectBlock
+ *
+ * Description: UnProtects appropriate blocks for writing.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * uiOffset - Offset of the flash where data needs to be written to. This should be Sector aligned.
+ * Returns:
+ * ULONG - Status value before UnProtect.
+ *
+ */
+
+static ULONG BcmFlashUnProtectBlock(struct bcm_mini_adapter *Adapter, unsigned int uiOffset, unsigned int uiLength)
{
- ULONG ulStatus = 0;
- ULONG ulWriteStatus = 0;
- UINT value;
- uiOffset = uiOffset&0x000FFFFF;
+ ULONG ulStatus = 0;
+ ULONG ulWriteStatus = 0;
+ unsigned int value;
-//
-// Implemented only for 1MB Flash parts.
-//
- if(FLASH_PART_SST25VF080B == Adapter->ulFlashID)
- {
- //
- // Get Current BP status.
- //
+ uiOffset = uiOffset&0x000FFFFF;
+ /*
+ * Implemented only for 1MB Flash parts.
+ */
+ if (FLASH_PART_SST25VF080B == Adapter->ulFlashID) {
+ /*
+ * Get Current BP status.
+ */
value = (FLASH_CMD_STATUS_REG_READ << 24);
wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
udelay(10);
- //
- // Read status will be WWXXYYZZ. We have to take only WW.
- //
+ /*
+ * Read status will be WWXXYYZZ. We have to take only WW.
+ */
rdmalt(Adapter, FLASH_SPI_READQ_REG, (PUINT)&ulStatus, sizeof(ulStatus));
ulStatus >>= 24;
ulWriteStatus = ulStatus;
-
- //
- // Bits [5-2] give current block level protection status.
- // Bit5: BP3 - DONT CARE
- // BP2-BP0: 0 - NO PROTECTION, 1 - UPPER 1/16, 2 - UPPER 1/8, 3 - UPPER 1/4
- // 4 - UPPER 1/2. 5 to 7 - ALL BLOCKS
- //
-
- if(ulStatus)
- {
- if((uiOffset+uiLength) <= 0x80000)
- {
- //
- // Offset comes in lower half of 1MB. Protect the upper half.
- // Clear BP1 and BP0 and set BP2.
- //
+ /*
+ * Bits [5-2] give current block level protection status.
+ * Bit5: BP3 - DONT CARE
+ * BP2-BP0: 0 - NO PROTECTION, 1 - UPPER 1/16, 2 - UPPER 1/8, 3 - UPPER 1/4
+ * 4 - UPPER 1/2. 5 to 7 - ALL BLOCKS
+ */
+
+ if (ulStatus) {
+ if ((uiOffset+uiLength) <= 0x80000) {
+ /*
+ * Offset comes in lower half of 1MB. Protect the upper half.
+ * Clear BP1 and BP0 and set BP2.
+ */
ulWriteStatus |= (0x4<<2);
ulWriteStatus &= ~(0x3<<2);
- }
- else if((uiOffset+uiLength) <= 0xC0000)
- {
- //
- // Offset comes below Upper 1/4. Upper 1/4 can be protected.
- // Clear BP2 and set BP1 and BP0.
- //
+ } else if ((uiOffset + uiLength) <= 0xC0000) {
+ /*
+ * Offset comes below Upper 1/4. Upper 1/4 can be protected.
+ * Clear BP2 and set BP1 and BP0.
+ */
ulWriteStatus |= (0x3<<2);
ulWriteStatus &= ~(0x1<<4);
+ } else if ((uiOffset + uiLength) <= 0xE0000) {
+ /*
+ * Offset comes below Upper 1/8. Upper 1/8 can be protected.
+ * Clear BP2 and BP0 and set BP1
+ */
+ ulWriteStatus |= (0x1<<3);
+ ulWriteStatus &= ~(0x5<<2);
+ } else if ((uiOffset + uiLength) <= 0xF0000) {
+ /*
+ * Offset comes below Upper 1/16. Only upper 1/16 can be protected.
+ * Set BP0 and Clear BP2,BP1.
+ */
+ ulWriteStatus |= (0x1<<2);
+ ulWriteStatus &= ~(0x3<<3);
+ } else {
+ /*
+ * Unblock all.
+ * Clear BP2,BP1 and BP0.
+ */
+ ulWriteStatus &= ~(0x7<<2);
}
- else if((uiOffset+uiLength) <= 0xE0000)
- {
- //
- // Offset comes below Upper 1/8. Upper 1/8 can be protected.
- // Clear BP2 and BP0 and set BP1
- //
- ulWriteStatus |= (0x1<<3);
- ulWriteStatus &= ~(0x5<<2);
-
- }
- else if((uiOffset+uiLength) <= 0xF0000)
- {
- //
- // Offset comes below Upper 1/16. Only upper 1/16 can be protected.
- // Set BP0 and Clear BP2,BP1.
- //
- ulWriteStatus |= (0x1<<2);
- ulWriteStatus &= ~(0x3<<3);
- }
- else
- {
- //
- // Unblock all.
- // Clear BP2,BP1 and BP0.
- //
- ulWriteStatus &= ~(0x7<<2);
- }
-
- value = (FLASH_CMD_WRITE_ENABLE<< 24);
+
+ value = (FLASH_CMD_WRITE_ENABLE << 24);
wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
udelay(20);
- value = (FLASH_CMD_STATUS_REG_WRITE<<24)|(ulWriteStatus << 16);
+ value = (FLASH_CMD_STATUS_REG_WRITE << 24) | (ulWriteStatus << 16);
wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
udelay(20);
-
}
-
}
return ulStatus;
}
-//-----------------------------------------------------------------------------
-// Procedure: BeceemFlashBulkWrite
-//
-// Description: Performs write to the flash
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// pBuffer - Data to be written.
-// uiOffset - Offset of the flash where data needs to be written to.
-// uiNumBytes - Number of bytes to be written.
-// bVerify - read verify flag.
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-static INT BeceemFlashBulkWrite(
- PMINI_ADAPTER Adapter,
- PUINT pBuffer,
- UINT uiOffset,
- UINT uiNumBytes,
- BOOLEAN bVerify)
+
+/*
+ * Procedure: BeceemFlashBulkWrite
+ *
+ * Description: Performs write to the flash
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * pBuffer - Data to be written.
+ * uiOffset - Offset of the flash where data needs to be written to.
+ * uiNumBytes - Number of bytes to be written.
+ * bVerify - read verify flag.
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+static int BeceemFlashBulkWrite(struct bcm_mini_adapter *Adapter,
+ PUINT pBuffer,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes,
+ BOOLEAN bVerify)
{
- PCHAR pTempBuff = NULL;
- PUCHAR pcBuffer = (PUCHAR)pBuffer;
- UINT uiIndex = 0;
- UINT uiOffsetFromSectStart = 0;
- UINT uiSectAlignAddr = 0;
- UINT uiCurrSectOffsetAddr = 0;
- UINT uiSectBoundary = 0;
- UINT uiNumSectTobeRead = 0;
- UCHAR ucReadBk[16] = {0};
- ULONG ulStatus = 0;
- INT Status = STATUS_SUCCESS;
- UINT uiTemp = 0;
- UINT index = 0;
- UINT uiPartOffset = 0;
-
-#if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
- Status = bcmflash_raw_write((uiOffset/FLASH_PART_SIZE),(uiOffset % FLASH_PART_SIZE),( unsigned char *)pBuffer,uiNumBytes);
- return Status;
-#endif
-
- uiOffsetFromSectStart = uiOffset & ~(Adapter->uiSectorSize - 1);
-
- //Adding flash Base address
-// uiOffset = uiOffset + GetFlashBaseAddr(Adapter);
-
- uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
- uiCurrSectOffsetAddr = uiOffset & (Adapter->uiSectorSize - 1);
- uiSectBoundary = uiSectAlignAddr + Adapter->uiSectorSize;
+ PCHAR pTempBuff = NULL;
+ PUCHAR pcBuffer = (PUCHAR)pBuffer;
+ unsigned int uiIndex = 0;
+ unsigned int uiOffsetFromSectStart = 0;
+ unsigned int uiSectAlignAddr = 0;
+ unsigned int uiCurrSectOffsetAddr = 0;
+ unsigned int uiSectBoundary = 0;
+ unsigned int uiNumSectTobeRead = 0;
+ UCHAR ucReadBk[16] = {0};
+ ULONG ulStatus = 0;
+ int Status = STATUS_SUCCESS;
+ unsigned int uiTemp = 0;
+ unsigned int index = 0;
+ unsigned int uiPartOffset = 0;
+
+ #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
+ Status = bcmflash_raw_write((uiOffset / FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
+ return Status;
+ #endif
+
+ uiOffsetFromSectStart = uiOffset & ~(Adapter->uiSectorSize - 1);
+
+ /* Adding flash Base address
+ * uiOffset = uiOffset + GetFlashBaseAddr(Adapter);
+ */
+
+ uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
+ uiCurrSectOffsetAddr = uiOffset & (Adapter->uiSectorSize - 1);
+ uiSectBoundary = uiSectAlignAddr + Adapter->uiSectorSize;
pTempBuff = kmalloc(Adapter->uiSectorSize, GFP_KERNEL);
- if(NULL == pTempBuff)
+ if (!pTempBuff)
goto BeceemFlashBulkWrite_EXIT;
-//
-// check if the data to be written is overlapped across sectors
-//
- if(uiOffset+uiNumBytes < uiSectBoundary)
- {
+ /*
+ * check if the data to be written is overlapped across sectors
+ */
+ if (uiOffset+uiNumBytes < uiSectBoundary) {
uiNumSectTobeRead = 1;
- }
- else
- {
- // Number of sectors = Last sector start address/First sector start address
- uiNumSectTobeRead = (uiCurrSectOffsetAddr+uiNumBytes)/Adapter->uiSectorSize;
- if((uiCurrSectOffsetAddr+uiNumBytes)%Adapter->uiSectorSize)
- {
+ } else {
+ /* Number of sectors = Last sector start address/First sector start address */
+ uiNumSectTobeRead = (uiCurrSectOffsetAddr + uiNumBytes) / Adapter->uiSectorSize;
+ if ((uiCurrSectOffsetAddr + uiNumBytes)%Adapter->uiSectorSize)
uiNumSectTobeRead++;
- }
}
- //Check whether Requested sector is writable or not in case of flash2x write. But if write call is
- // for DSD calibration, allow it without checking of sector permission
+ /* Check whether Requested sector is writable or not in case of flash2x write. But if write call is
+ * for DSD calibration, allow it without checking of sector permission
+ */
- if(IsFlash2x(Adapter) && (Adapter->bAllDSDWriteAllow == FALSE))
- {
+ if (IsFlash2x(Adapter) && (Adapter->bAllDSDWriteAllow == FALSE)) {
index = 0;
- uiTemp = uiNumSectTobeRead ;
- while(uiTemp)
- {
- if(IsOffsetWritable(Adapter, uiOffsetFromSectStart + index * Adapter->uiSectorSize ) == FALSE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Sector Starting at offset <0X%X> is not writable",
- (uiOffsetFromSectStart + index * Adapter->uiSectorSize));
+ uiTemp = uiNumSectTobeRead;
+ while (uiTemp) {
+ if (IsOffsetWritable(Adapter, uiOffsetFromSectStart + index * Adapter->uiSectorSize) == FALSE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Sector Starting at offset <0X%X> is not writable",
+ (uiOffsetFromSectStart + index * Adapter->uiSectorSize));
Status = SECTOR_IS_NOT_WRITABLE;
goto BeceemFlashBulkWrite_EXIT;
- }
- uiTemp = uiTemp - 1;
- index = index + 1 ;
+ }
+ uiTemp = uiTemp - 1;
+ index = index + 1 ;
}
}
Adapter->SelectedChip = RESET_CHIP_SELECT;
- while(uiNumSectTobeRead)
- {
- //do_gettimeofday(&tv1);
- //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "\nTime In start of write :%ld ms\n",(tv1.tv_sec *1000 + tv1.tv_usec /1000));
+ while (uiNumSectTobeRead) {
+ /* do_gettimeofday(&tv1);
+ * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "\nTime In start of write :%ld ms\n",(tv1.tv_sec *1000 + tv1.tv_usec /1000));
+ */
uiPartOffset = (uiSectAlignAddr & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
- BcmDoChipSelect(Adapter,uiSectAlignAddr);
+ BcmDoChipSelect(Adapter, uiSectAlignAddr);
- if(0 != BeceemFlashBulkRead(Adapter,
+ if (0 != BeceemFlashBulkRead(Adapter,
(PUINT)pTempBuff,
uiOffsetFromSectStart,
- Adapter->uiSectorSize))
- {
+ Adapter->uiSectorSize)) {
Status = -1;
goto BeceemFlashBulkWrite_EXIT;
}
- //do_gettimeofday(&tr);
- //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken by Read :%ld ms\n", (tr.tv_sec *1000 + tr.tv_usec/1000) - (tv1.tv_sec *1000 + tv1.tv_usec/1000));
-
- ulStatus = BcmFlashUnProtectBlock(Adapter,uiSectAlignAddr,Adapter->uiSectorSize);
-
-
- if(uiNumSectTobeRead > 1)
- {
-
- memcpy(&pTempBuff[uiCurrSectOffsetAddr],pcBuffer,uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr));
- pcBuffer += ((uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr)));
- uiNumBytes -= (uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr));
- }
- else
- {
- memcpy(&pTempBuff[uiCurrSectOffsetAddr],pcBuffer,uiNumBytes);
- }
-
- if(IsFlash2x(Adapter))
- {
- SaveHeaderIfPresent(Adapter,(PUCHAR)pTempBuff,uiOffsetFromSectStart);
+ /* do_gettimeofday(&tr);
+ * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken by Read :%ld ms\n", (tr.tv_sec *1000 + tr.tv_usec/1000) - (tv1.tv_sec *1000 + tv1.tv_usec/1000));
+ */
+ ulStatus = BcmFlashUnProtectBlock(Adapter, uiSectAlignAddr, Adapter->uiSectorSize);
+
+ if (uiNumSectTobeRead > 1) {
+ memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
+ pcBuffer += ((uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr)));
+ uiNumBytes -= (uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
+ } else {
+ memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiNumBytes);
}
- FlashSectorErase(Adapter,uiPartOffset,1);
- //do_gettimeofday(&te);
- //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken by Erase :%ld ms\n", (te.tv_sec *1000 + te.tv_usec/1000) - (tr.tv_sec *1000 + tr.tv_usec/1000));
+ if (IsFlash2x(Adapter))
+ SaveHeaderIfPresent(Adapter, (PUCHAR)pTempBuff, uiOffsetFromSectStart);
- for(uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex +=Adapter->ulFlashWriteSize)
- {
- if(Adapter->device_removed)
- {
+ FlashSectorErase(Adapter, uiPartOffset, 1);
+ /* do_gettimeofday(&te);
+ * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken by Erase :%ld ms\n", (te.tv_sec *1000 + te.tv_usec/1000) - (tr.tv_sec *1000 + tr.tv_usec/1000));
+ */
+ for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex += Adapter->ulFlashWriteSize) {
+ if (Adapter->device_removed) {
Status = -1;
goto BeceemFlashBulkWrite_EXIT;
}
- if(STATUS_SUCCESS != (*Adapter->fpFlashWrite)(Adapter,uiPartOffset+uiIndex,(&pTempBuff[uiIndex])))
- {
+
+ if (STATUS_SUCCESS != (*Adapter->fpFlashWrite)(Adapter, uiPartOffset + uiIndex, (&pTempBuff[uiIndex]))) {
Status = -1;
goto BeceemFlashBulkWrite_EXIT;
}
}
- //do_gettimeofday(&tw);
- //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken in Write to Flash :%ld ms\n", (tw.tv_sec *1000 + tw.tv_usec/1000) - (te.tv_sec *1000 + te.tv_usec/1000));
- for(uiIndex = 0;uiIndex < Adapter->uiSectorSize;uiIndex += MAX_RW_SIZE)
- {
- if(STATUS_SUCCESS == BeceemFlashBulkRead(Adapter,(PUINT)ucReadBk,uiOffsetFromSectStart+uiIndex,MAX_RW_SIZE))
- {
- if(Adapter->ulFlashWriteSize == 1)
- {
- UINT uiReadIndex = 0;
- for(uiReadIndex = 0; uiReadIndex < 16; uiReadIndex++)
- {
- if(ucReadBk[uiReadIndex] != pTempBuff[uiIndex+uiReadIndex])
- {
- if(STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter,uiPartOffset+uiIndex+uiReadIndex,&pTempBuff[uiIndex+uiReadIndex]))
- {
+ /* do_gettimeofday(&tw);
+ * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken in Write to Flash :%ld ms\n", (tw.tv_sec *1000 + tw.tv_usec/1000) - (te.tv_sec *1000 + te.tv_usec/1000));
+ */
+ for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex += MAX_RW_SIZE) {
+ if (STATUS_SUCCESS == BeceemFlashBulkRead(Adapter, (PUINT)ucReadBk, uiOffsetFromSectStart + uiIndex, MAX_RW_SIZE)) {
+ if (Adapter->ulFlashWriteSize == 1) {
+ unsigned int uiReadIndex = 0;
+ for (uiReadIndex = 0; uiReadIndex < 16; uiReadIndex++) {
+ if (ucReadBk[uiReadIndex] != pTempBuff[uiIndex + uiReadIndex]) {
+ if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter, uiPartOffset + uiIndex + uiReadIndex, &pTempBuff[uiIndex+uiReadIndex])) {
Status = STATUS_FAILURE;
goto BeceemFlashBulkWrite_EXIT;
}
}
}
- }
- else
- {
- if(memcmp(ucReadBk,&pTempBuff[uiIndex],MAX_RW_SIZE))
- {
- if(STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter,uiPartOffset+uiIndex,&pTempBuff[uiIndex]))
- {
+ } else {
+ if (memcmp(ucReadBk, &pTempBuff[uiIndex], MAX_RW_SIZE)) {
+ if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter, uiPartOffset + uiIndex, &pTempBuff[uiIndex])) {
Status = STATUS_FAILURE;
goto BeceemFlashBulkWrite_EXIT;
}
}
}
}
- //do_gettimeofday(&twv);
- //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken in Write to Flash verification :%ld ms\n", (twv.tv_sec *1000 + twv.tv_usec/1000) - (tw.tv_sec *1000 + tw.tv_usec/1000));
-
-
- if(ulStatus)
- {
- BcmRestoreBlockProtectStatus(Adapter,ulStatus);
+ /* do_gettimeofday(&twv);
+ * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken in Write to Flash verification :%ld ms\n", (twv.tv_sec *1000 + twv.tv_usec/1000) - (tw.tv_sec *1000 + tw.tv_usec/1000));
+ */
+ if (ulStatus) {
+ BcmRestoreBlockProtectStatus(Adapter, ulStatus);
ulStatus = 0;
}
uiOffsetFromSectStart += Adapter->uiSectorSize;
uiNumSectTobeRead--;
}
- //do_gettimeofday(&tv2);
- //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Time after Write :%ld ms\n",(tv2.tv_sec *1000 + tv2.tv_usec/1000));
- //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken by in Write is :%ld ms\n", (tv2.tv_sec *1000 + tv2.tv_usec/1000) - (tv1.tv_sec *1000 + tv1.tv_usec/1000));
-//
-// Cleanup.
-//
+ /* do_gettimeofday(&tv2);
+ * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Time after Write :%ld ms\n",(tv2.tv_sec *1000 + tv2.tv_usec/1000));
+ * BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Total time taken by in Write is :%ld ms\n", (tv2.tv_sec *1000 + tv2.tv_usec/1000) - (tv1.tv_sec *1000 + tv1.tv_usec/1000));
+ *
+ * Cleanup.
+ */
BeceemFlashBulkWrite_EXIT:
- if(ulStatus)
- {
- BcmRestoreBlockProtectStatus(Adapter,ulStatus);
- }
-
+ if (ulStatus)
+ BcmRestoreBlockProtectStatus(Adapter, ulStatus);
+
kfree(pTempBuff);
Adapter->SelectedChip = RESET_CHIP_SELECT;
return Status;
}
-
-//-----------------------------------------------------------------------------
-// Procedure: BeceemFlashBulkWriteStatus
-//
-// Description: Writes to Flash. Checks the SPI status after each write.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// pBuffer - Data to be written.
-// uiOffset - Offset of the flash where data needs to be written to.
-// uiNumBytes - Number of bytes to be written.
-// bVerify - read verify flag.
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-static INT BeceemFlashBulkWriteStatus(
- PMINI_ADAPTER Adapter,
- PUINT pBuffer,
- UINT uiOffset,
- UINT uiNumBytes,
- BOOLEAN bVerify)
+/*
+ * Procedure: BeceemFlashBulkWriteStatus
+ *
+ * Description: Writes to Flash. Checks the SPI status after each write.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * pBuffer - Data to be written.
+ * uiOffset - Offset of the flash where data needs to be written to.
+ * uiNumBytes - Number of bytes to be written.
+ * bVerify - read verify flag.
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+static int BeceemFlashBulkWriteStatus(struct bcm_mini_adapter *Adapter,
+ PUINT pBuffer,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes,
+ BOOLEAN bVerify)
{
- PCHAR pTempBuff = NULL;
- PUCHAR pcBuffer = (PUCHAR)pBuffer;
- UINT uiIndex = 0;
- UINT uiOffsetFromSectStart = 0;
- UINT uiSectAlignAddr = 0;
- UINT uiCurrSectOffsetAddr = 0;
- UINT uiSectBoundary = 0;
- UINT uiNumSectTobeRead = 0;
- UCHAR ucReadBk[16] = {0};
- ULONG ulStatus = 0;
- UINT Status = STATUS_SUCCESS;
- UINT uiTemp = 0;
- UINT index = 0;
- UINT uiPartOffset = 0;
-
- uiOffsetFromSectStart = uiOffset & ~(Adapter->uiSectorSize - 1);
-
- //uiOffset += Adapter->ulFlashCalStart;
- //Adding flash Base address
-// uiOffset = uiOffset + GetFlashBaseAddr(Adapter);
-
- uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
- uiCurrSectOffsetAddr = uiOffset & (Adapter->uiSectorSize - 1);
- uiSectBoundary = uiSectAlignAddr + Adapter->uiSectorSize;
+ PCHAR pTempBuff = NULL;
+ PUCHAR pcBuffer = (PUCHAR)pBuffer;
+ unsigned int uiIndex = 0;
+ unsigned int uiOffsetFromSectStart = 0;
+ unsigned int uiSectAlignAddr = 0;
+ unsigned int uiCurrSectOffsetAddr = 0;
+ unsigned int uiSectBoundary = 0;
+ unsigned int uiNumSectTobeRead = 0;
+ UCHAR ucReadBk[16] = {0};
+ ULONG ulStatus = 0;
+ unsigned int Status = STATUS_SUCCESS;
+ unsigned int uiTemp = 0;
+ unsigned int index = 0;
+ unsigned int uiPartOffset = 0;
+
+ uiOffsetFromSectStart = uiOffset & ~(Adapter->uiSectorSize - 1);
+
+ /* uiOffset += Adapter->ulFlashCalStart;
+ * Adding flash Base address
+ * uiOffset = uiOffset + GetFlashBaseAddr(Adapter);
+ */
+ uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
+ uiCurrSectOffsetAddr = uiOffset & (Adapter->uiSectorSize - 1);
+ uiSectBoundary = uiSectAlignAddr + Adapter->uiSectorSize;
pTempBuff = kmalloc(Adapter->uiSectorSize, GFP_KERNEL);
- if(NULL == pTempBuff)
+ if (!pTempBuff)
goto BeceemFlashBulkWriteStatus_EXIT;
-//
-// check if the data to be written is overlapped across sectors
-//
- if(uiOffset+uiNumBytes < uiSectBoundary)
- {
+ /*
+ * check if the data to be written is overlapped across sectors
+ */
+ if (uiOffset+uiNumBytes < uiSectBoundary) {
uiNumSectTobeRead = 1;
- }
- else
- {
-// Number of sectors = Last sector start address/First sector start address
- uiNumSectTobeRead = (uiCurrSectOffsetAddr+uiNumBytes)/Adapter->uiSectorSize;
- if((uiCurrSectOffsetAddr+uiNumBytes)%Adapter->uiSectorSize)
- {
+ } else {
+ /* Number of sectors = Last sector start address/First sector start address */
+ uiNumSectTobeRead = (uiCurrSectOffsetAddr + uiNumBytes) / Adapter->uiSectorSize;
+ if ((uiCurrSectOffsetAddr + uiNumBytes)%Adapter->uiSectorSize)
uiNumSectTobeRead++;
- }
}
- if(IsFlash2x(Adapter) && (Adapter->bAllDSDWriteAllow == FALSE))
- {
+ if (IsFlash2x(Adapter) && (Adapter->bAllDSDWriteAllow == FALSE)) {
index = 0;
- uiTemp = uiNumSectTobeRead ;
- while(uiTemp)
- {
- if(IsOffsetWritable(Adapter,uiOffsetFromSectStart + index * Adapter->uiSectorSize ) == FALSE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Sector Starting at offset <0X%x> is not writable",
- (uiOffsetFromSectStart + index * Adapter->uiSectorSize));
+ uiTemp = uiNumSectTobeRead;
+ while (uiTemp) {
+ if (IsOffsetWritable(Adapter, uiOffsetFromSectStart + index * Adapter->uiSectorSize) == FALSE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Sector Starting at offset <0X%x> is not writable",
+ (uiOffsetFromSectStart + index * Adapter->uiSectorSize));
Status = SECTOR_IS_NOT_WRITABLE;
goto BeceemFlashBulkWriteStatus_EXIT;
- }
- uiTemp = uiTemp - 1;
- index = index + 1 ;
+ }
+ uiTemp = uiTemp - 1;
+ index = index + 1 ;
}
}
Adapter->SelectedChip = RESET_CHIP_SELECT;
- while(uiNumSectTobeRead)
- {
+ while (uiNumSectTobeRead) {
uiPartOffset = (uiSectAlignAddr & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
- BcmDoChipSelect(Adapter,uiSectAlignAddr);
- if(0 != BeceemFlashBulkRead(Adapter,
+ BcmDoChipSelect(Adapter, uiSectAlignAddr);
+ if (0 != BeceemFlashBulkRead(Adapter,
(PUINT)pTempBuff,
uiOffsetFromSectStart,
- Adapter->uiSectorSize))
- {
+ Adapter->uiSectorSize)) {
Status = -1;
goto BeceemFlashBulkWriteStatus_EXIT;
}
- ulStatus = BcmFlashUnProtectBlock(Adapter,uiOffsetFromSectStart,Adapter->uiSectorSize);
-
- if(uiNumSectTobeRead > 1)
- {
-
- memcpy(&pTempBuff[uiCurrSectOffsetAddr],pcBuffer,uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr));
- pcBuffer += ((uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr)));
- uiNumBytes -= (uiSectBoundary-(uiSectAlignAddr+uiCurrSectOffsetAddr));
- }
- else
- {
- memcpy(&pTempBuff[uiCurrSectOffsetAddr],pcBuffer,uiNumBytes);
- }
+ ulStatus = BcmFlashUnProtectBlock(Adapter, uiOffsetFromSectStart, Adapter->uiSectorSize);
- if(IsFlash2x(Adapter))
- {
- SaveHeaderIfPresent(Adapter,(PUCHAR)pTempBuff,uiOffsetFromSectStart);
+ if (uiNumSectTobeRead > 1) {
+ memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
+ pcBuffer += ((uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr)));
+ uiNumBytes -= (uiSectBoundary - (uiSectAlignAddr + uiCurrSectOffsetAddr));
+ } else {
+ memcpy(&pTempBuff[uiCurrSectOffsetAddr], pcBuffer, uiNumBytes);
}
- FlashSectorErase(Adapter,uiPartOffset,1);
+ if (IsFlash2x(Adapter))
+ SaveHeaderIfPresent(Adapter, (PUCHAR)pTempBuff, uiOffsetFromSectStart);
- for(uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex +=Adapter->ulFlashWriteSize)
+ FlashSectorErase(Adapter, uiPartOffset, 1);
- {
- if(Adapter->device_removed)
- {
+ for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex += Adapter->ulFlashWriteSize) {
+ if (Adapter->device_removed) {
Status = -1;
goto BeceemFlashBulkWriteStatus_EXIT;
}
- if(STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter,uiPartOffset+uiIndex,&pTempBuff[uiIndex]))
- {
+ if (STATUS_SUCCESS != (*Adapter->fpFlashWriteWithStatusCheck)(Adapter, uiPartOffset+uiIndex, &pTempBuff[uiIndex])) {
Status = -1;
goto BeceemFlashBulkWriteStatus_EXIT;
}
}
- if(bVerify)
- {
- for(uiIndex = 0;uiIndex < Adapter->uiSectorSize;uiIndex += MAX_RW_SIZE)
- {
-
- if(STATUS_SUCCESS == BeceemFlashBulkRead(Adapter,(PUINT)ucReadBk,uiOffsetFromSectStart+uiIndex,MAX_RW_SIZE))
- {
- if(memcmp(ucReadBk,&pTempBuff[uiIndex],MAX_RW_SIZE))
- {
+ if (bVerify) {
+ for (uiIndex = 0; uiIndex < Adapter->uiSectorSize; uiIndex += MAX_RW_SIZE) {
+ if (STATUS_SUCCESS == BeceemFlashBulkRead(Adapter, (PUINT)ucReadBk, uiOffsetFromSectStart + uiIndex, MAX_RW_SIZE)) {
+ if (memcmp(ucReadBk, &pTempBuff[uiIndex], MAX_RW_SIZE)) {
Status = STATUS_FAILURE;
goto BeceemFlashBulkWriteStatus_EXIT;
}
-
}
-
}
}
- if(ulStatus)
- {
- BcmRestoreBlockProtectStatus(Adapter,ulStatus);
+ if (ulStatus) {
+ BcmRestoreBlockProtectStatus(Adapter, ulStatus);
ulStatus = 0;
}
uiOffsetFromSectStart += Adapter->uiSectorSize;
uiNumSectTobeRead--;
}
-//
-// Cleanup.
-//
+/*
+ * Cleanup.
+ */
BeceemFlashBulkWriteStatus_EXIT:
- if(ulStatus)
- {
- BcmRestoreBlockProtectStatus(Adapter,ulStatus);
- }
+ if (ulStatus)
+ BcmRestoreBlockProtectStatus(Adapter, ulStatus);
kfree(pTempBuff);
Adapter->SelectedChip = RESET_CHIP_SELECT;
return Status;
-
}
-//-----------------------------------------------------------------------------
-// Procedure: PropagateCalParamsFromEEPROMToMemory
-//
-// Description: Dumps the calibration section of EEPROM to DDR.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-
-INT PropagateCalParamsFromEEPROMToMemory(PMINI_ADAPTER Adapter)
+/*
+ * Procedure: PropagateCalParamsFromEEPROMToMemory
+ *
+ * Description: Dumps the calibration section of EEPROM to DDR.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+int PropagateCalParamsFromEEPROMToMemory(struct bcm_mini_adapter *Adapter)
{
PCHAR pBuff = kmalloc(BUFFER_4K, GFP_KERNEL);
- UINT uiEepromSize = 0;
- UINT uiIndex = 0;
- UINT uiBytesToCopy = 0;
- UINT uiCalStartAddr = EEPROM_CALPARAM_START;
- UINT uiMemoryLoc = EEPROM_CAL_DATA_INTERNAL_LOC;
- UINT value;
- INT Status = 0;
- if(pBuff == NULL)
- {
- return -1;
- }
-
- if(0 != BeceemEEPROMBulkRead(Adapter,&uiEepromSize,EEPROM_SIZE_OFFSET,4))
- {
+ unsigned int uiEepromSize = 0;
+ unsigned int uiIndex = 0;
+ unsigned int uiBytesToCopy = 0;
+ unsigned int uiCalStartAddr = EEPROM_CALPARAM_START;
+ unsigned int uiMemoryLoc = EEPROM_CAL_DATA_INTERNAL_LOC;
+ unsigned int value;
+ int Status = 0;
+
+ if (!pBuff)
+ return -ENOMEM;
+ if (0 != BeceemEEPROMBulkRead(Adapter, &uiEepromSize, EEPROM_SIZE_OFFSET, 4)) {
kfree(pBuff);
return -1;
}
uiEepromSize >>= 16;
- if(uiEepromSize > 1024*1024)
- {
+ if (uiEepromSize > 1024 * 1024) {
kfree(pBuff);
return -1;
}
+ uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
- uiBytesToCopy = MIN(BUFFER_4K,uiEepromSize);
-
- while(uiBytesToCopy)
- {
- if(0 != BeceemEEPROMBulkRead(Adapter,(PUINT)pBuff,uiCalStartAddr,uiBytesToCopy))
- {
+ while (uiBytesToCopy) {
+ if (0 != BeceemEEPROMBulkRead(Adapter, (PUINT)pBuff, uiCalStartAddr, uiBytesToCopy)) {
Status = -1;
break;
}
- wrm(Adapter,uiMemoryLoc,(PCHAR)(((PULONG)pBuff)+uiIndex),uiBytesToCopy);
+ wrm(Adapter, uiMemoryLoc, (PCHAR)(((PULONG)pBuff) + uiIndex), uiBytesToCopy);
uiMemoryLoc += uiBytesToCopy;
uiEepromSize -= uiBytesToCopy;
uiCalStartAddr += uiBytesToCopy;
- uiIndex += uiBytesToCopy/4;
- uiBytesToCopy = MIN(BUFFER_4K,uiEepromSize);
+ uiIndex += uiBytesToCopy / 4;
+ uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
}
value = 0xbeadbead;
- wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC-4,&value, sizeof(value));
+ wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4, &value, sizeof(value));
value = 0xbeadbead;
- wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC-8,&value, sizeof(value));
+ wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));
kfree(pBuff);
return Status;
-
}
-//-----------------------------------------------------------------------------
-// Procedure: PropagateCalParamsFromFlashToMemory
-//
-// Description: Dumps the calibration section of EEPROM to DDR.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-INT PropagateCalParamsFromFlashToMemory(PMINI_ADAPTER Adapter)
+/*
+ * Procedure: PropagateCalParamsFromFlashToMemory
+ *
+ * Description: Dumps the calibration section of EEPROM to DDR.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+int PropagateCalParamsFromFlashToMemory(struct bcm_mini_adapter *Adapter)
{
PCHAR pBuff, pPtr;
- UINT uiEepromSize = 0;
- UINT uiBytesToCopy = 0;
- //UINT uiIndex = 0;
- UINT uiCalStartAddr = EEPROM_CALPARAM_START;
- UINT uiMemoryLoc = EEPROM_CAL_DATA_INTERNAL_LOC;
- UINT value;
- INT Status = 0;
-//
-// Write the signature first. This will ensure firmware does not access EEPROM.
-//
+ unsigned int uiEepromSize = 0;
+ unsigned int uiBytesToCopy = 0;
+ /* unsigned int uiIndex = 0; */
+ unsigned int uiCalStartAddr = EEPROM_CALPARAM_START;
+ unsigned int uiMemoryLoc = EEPROM_CAL_DATA_INTERNAL_LOC;
+ unsigned int value;
+ int Status = 0;
+
+ /*
+ * Write the signature first. This will ensure firmware does not access EEPROM.
+ */
value = 0xbeadbead;
wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4, &value, sizeof(value));
value = 0xbeadbead;
wrmalt(Adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));
- if(0 != BeceemNVMRead(Adapter,&uiEepromSize,EEPROM_SIZE_OFFSET, 4))
- {
+ if (0 != BeceemNVMRead(Adapter, &uiEepromSize, EEPROM_SIZE_OFFSET, 4))
return -1;
- }
+
uiEepromSize = ntohl(uiEepromSize);
uiEepromSize >>= 16;
-//
-// subtract the auto init section size
-//
+ /*
+ * subtract the auto init section size
+ */
uiEepromSize -= EEPROM_CALPARAM_START;
- if(uiEepromSize > 1024*1024)
- {
+ if (uiEepromSize > 1024 * 1024)
return -1;
- }
pBuff = kmalloc(uiEepromSize, GFP_KERNEL);
- if ( pBuff == NULL )
- return -1;
+ if (pBuff == NULL)
+ return -ENOMEM;
- if(0 != BeceemNVMRead(Adapter,(PUINT)pBuff,uiCalStartAddr, uiEepromSize))
- {
+ if (0 != BeceemNVMRead(Adapter, (PUINT)pBuff, uiCalStartAddr, uiEepromSize)) {
kfree(pBuff);
return -1;
}
pPtr = pBuff;
- uiBytesToCopy = MIN(BUFFER_4K,uiEepromSize);
+ uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
- while(uiBytesToCopy)
- {
- Status = wrm(Adapter,uiMemoryLoc,(PCHAR)pPtr,uiBytesToCopy);
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"wrm failed with status :%d",Status);
+ while (uiBytesToCopy) {
+ Status = wrm(Adapter, uiMemoryLoc, (PCHAR)pPtr, uiBytesToCopy);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "wrm failed with status :%d", Status);
break;
}
pPtr += uiBytesToCopy;
uiEepromSize -= uiBytesToCopy;
uiMemoryLoc += uiBytesToCopy;
- uiBytesToCopy = MIN(BUFFER_4K,uiEepromSize);
+ uiBytesToCopy = MIN(BUFFER_4K, uiEepromSize);
}
kfree(pBuff);
return Status;
-
}
-//-----------------------------------------------------------------------------
-// Procedure: BeceemEEPROMReadBackandVerify
-//
-// Description: Read back the data written and verifies.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// pBuffer - Data to be written.
-// uiOffset - Offset of the flash where data needs to be written to.
-// uiNumBytes - Number of bytes to be written.
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-static INT BeceemEEPROMReadBackandVerify(
- PMINI_ADAPTER Adapter,
- PUINT pBuffer,
- UINT uiOffset,
- UINT uiNumBytes)
+/*
+ * Procedure: BeceemEEPROMReadBackandVerify
+ *
+ * Description: Read back the data written and verifies.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * pBuffer - Data to be written.
+ * uiOffset - Offset of the flash where data needs to be written to.
+ * uiNumBytes - Number of bytes to be written.
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+static int BeceemEEPROMReadBackandVerify(struct bcm_mini_adapter *Adapter,
+ PUINT pBuffer,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes)
{
- UINT uiRdbk = 0;
- UINT uiIndex = 0;
- UINT uiData = 0;
- UINT auiData[4] = {0};
+ unsigned int uiRdbk = 0;
+ unsigned int uiIndex = 0;
+ unsigned int uiData = 0;
+ unsigned int auiData[4] = {0};
- while(uiNumBytes)
- {
- if(Adapter->device_removed )
- {
+ while (uiNumBytes) {
+ if (Adapter->device_removed)
return -1;
- }
- if(uiNumBytes >= MAX_RW_SIZE)
- {// for the requests more than or equal to MAX_RW_SIZE bytes, use bulk read function to make the access faster.
- BeceemEEPROMBulkRead(Adapter,&auiData[0],uiOffset,MAX_RW_SIZE);
+ if (uiNumBytes >= MAX_RW_SIZE) {
+ /* for the requests more than or equal to MAX_RW_SIZE bytes, use bulk read function to make the access faster. */
+ BeceemEEPROMBulkRead(Adapter, &auiData[0], uiOffset, MAX_RW_SIZE);
- if(memcmp(&pBuffer[uiIndex],&auiData[0],MAX_RW_SIZE))
- {
- // re-write
- BeceemEEPROMBulkWrite(Adapter,(PUCHAR)(pBuffer+uiIndex),uiOffset,MAX_RW_SIZE,FALSE);
+ if (memcmp(&pBuffer[uiIndex], &auiData[0], MAX_RW_SIZE)) {
+ /* re-write */
+ BeceemEEPROMBulkWrite(Adapter, (PUCHAR)(pBuffer + uiIndex), uiOffset, MAX_RW_SIZE, FALSE);
mdelay(3);
- BeceemEEPROMBulkRead(Adapter,&auiData[0],uiOffset,MAX_RW_SIZE);
+ BeceemEEPROMBulkRead(Adapter, &auiData[0], uiOffset, MAX_RW_SIZE);
- if(memcmp(&pBuffer[uiIndex],&auiData[0],MAX_RW_SIZE))
- {
+ if (memcmp(&pBuffer[uiIndex], &auiData[0], MAX_RW_SIZE))
return -1;
- }
}
uiOffset += MAX_RW_SIZE;
uiNumBytes -= MAX_RW_SIZE;
uiIndex += 4;
-
- }
- else if(uiNumBytes >= 4)
- {
- BeceemEEPROMBulkRead(Adapter,&uiData,uiOffset,4);
- if(uiData != pBuffer[uiIndex])
- {
- //re-write
- BeceemEEPROMBulkWrite(Adapter,(PUCHAR)(pBuffer+uiIndex),uiOffset,4,FALSE);
+ } else if (uiNumBytes >= 4) {
+ BeceemEEPROMBulkRead(Adapter, &uiData, uiOffset, 4);
+ if (uiData != pBuffer[uiIndex]) {
+ /* re-write */
+ BeceemEEPROMBulkWrite(Adapter, (PUCHAR)(pBuffer + uiIndex), uiOffset, 4, FALSE);
mdelay(3);
- BeceemEEPROMBulkRead(Adapter,&uiData,uiOffset,4);
- if(uiData != pBuffer[uiIndex])
- {
+ BeceemEEPROMBulkRead(Adapter, &uiData, uiOffset, 4);
+ if (uiData != pBuffer[uiIndex])
return -1;
- }
}
uiOffset += 4;
uiNumBytes -= 4;
uiIndex++;
-
- }
- else
- { // Handle the reads less than 4 bytes...
+ } else {
+ /* Handle the reads less than 4 bytes... */
uiData = 0;
- memcpy(&uiData,((PUCHAR)pBuffer)+(uiIndex*sizeof(UINT)),uiNumBytes);
- BeceemEEPROMBulkRead(Adapter,&uiRdbk,uiOffset,4);
+ memcpy(&uiData, ((PUCHAR)pBuffer) + (uiIndex * sizeof(unsigned int)), uiNumBytes);
+ BeceemEEPROMBulkRead(Adapter, &uiRdbk, uiOffset, 4);
- if(memcmp(&uiData, &uiRdbk, uiNumBytes))
+ if (memcmp(&uiData, &uiRdbk, uiNumBytes))
return -1;
uiNumBytes = 0;
}
-
}
return 0;
}
-static VOID BcmSwapWord(UINT *ptr1) {
-
- UINT tempval = (UINT)*ptr1;
+static VOID BcmSwapWord(unsigned int *ptr1)
+{
+ unsigned int tempval = (unsigned int)*ptr1;
char *ptr2 = (char *)&tempval;
char *ptr = (char *)ptr1;
ptr[3] = ptr2[0];
}
-//-----------------------------------------------------------------------------
-// Procedure: BeceemEEPROMWritePage
-//
-// Description: Performs page write (16bytes) to the EEPROM
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// uiData - Data to be written.
-// uiOffset - Offset of the EEPROM where data needs to be written to.
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-static INT BeceemEEPROMWritePage( PMINI_ADAPTER Adapter, UINT uiData[], UINT uiOffset )
+/*
+ * Procedure: BeceemEEPROMWritePage
+ *
+ * Description: Performs page write (16bytes) to the EEPROM
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * uiData - Data to be written.
+ * uiOffset - Offset of the EEPROM where data needs to be written to.
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+static int BeceemEEPROMWritePage(struct bcm_mini_adapter *Adapter, unsigned int uiData[], unsigned int uiOffset)
{
- UINT uiRetries = MAX_EEPROM_RETRIES*RETRIES_PER_DELAY;
- UINT uiStatus = 0;
+ unsigned int uiRetries = MAX_EEPROM_RETRIES * RETRIES_PER_DELAY;
+ unsigned int uiStatus = 0;
UCHAR uiEpromStatus = 0;
- UINT value =0 ;
+ unsigned int value = 0;
/* Flush the Write/Read/Cmd queues. */
- value = ( EEPROM_WRITE_QUEUE_FLUSH | EEPROM_CMD_QUEUE_FLUSH | EEPROM_READ_QUEUE_FLUSH );
- wrmalt( Adapter, SPI_FLUSH_REG, &value, sizeof(value));
- value = 0 ;
- wrmalt( Adapter, SPI_FLUSH_REG, &value, sizeof(value) );
+ value = (EEPROM_WRITE_QUEUE_FLUSH | EEPROM_CMD_QUEUE_FLUSH | EEPROM_READ_QUEUE_FLUSH);
+ wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
+ value = 0;
+ wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
/* Clear the Empty/Avail/Full bits. After this it has been confirmed
* that the bit was cleared by reading back the register. See NOTE below.
* We also clear the Read queues as we do a EEPROM status register read
- * later. */
- value = ( EEPROM_WRITE_QUEUE_EMPTY | EEPROM_WRITE_QUEUE_AVAIL | EEPROM_WRITE_QUEUE_FULL | EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL ) ;
- wrmalt( Adapter, EEPROM_SPI_Q_STATUS1_REG,&value, sizeof(value));
+ * later.
+ */
+ value = (EEPROM_WRITE_QUEUE_EMPTY | EEPROM_WRITE_QUEUE_AVAIL | EEPROM_WRITE_QUEUE_FULL | EEPROM_READ_DATA_AVAIL | EEPROM_READ_DATA_FULL);
+ wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
/* Enable write */
- value = EEPROM_WRITE_ENABLE ;
- wrmalt( Adapter, EEPROM_CMDQ_SPI_REG,&value, sizeof(value) );
+ value = EEPROM_WRITE_ENABLE;
+ wrmalt(Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
/* We can write back to back 8bits * 16 into the queue and as we have
- * checked for the queue to be empty we can write in a burst. */
+ * checked for the queue to be empty we can write in a burst.
+ */
value = uiData[0];
BcmSwapWord(&value);
- wrm( Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
+ wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
value = uiData[1];
BcmSwapWord(&value);
- wrm( Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
+ wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
value = uiData[2];
BcmSwapWord(&value);
- wrm( Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
+ wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
value = uiData[3];
BcmSwapWord(&value);
- wrm( Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
+ wrm(Adapter, EEPROM_WRITE_DATAQ_REG, (PUCHAR)&value, 4);
/* NOTE : After this write, on readback of EEPROM_SPI_Q_STATUS1_REG
* shows that we see 7 for the EEPROM data write. Which means that
* queue got full, also space is available as well as the queue is empty.
- * This may happen in sequence. */
- value = EEPROM_16_BYTE_PAGE_WRITE | uiOffset ;
- wrmalt( Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value) );
+ * This may happen in sequence.
+ */
+ value = EEPROM_16_BYTE_PAGE_WRITE | uiOffset;
+ wrmalt(Adapter, EEPROM_CMDQ_SPI_REG, &value, sizeof(value));
/* Ideally we should loop here without tries and eventually succeed.
* What we are checking if the previous write has completed, and this
- * may take time. We should wait till the Empty bit is set. */
+ * may take time. We should wait till the Empty bit is set.
+ */
uiStatus = 0;
rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &uiStatus, sizeof(uiStatus));
- while ( ( uiStatus & EEPROM_WRITE_QUEUE_EMPTY ) == 0 )
- {
+ while ((uiStatus & EEPROM_WRITE_QUEUE_EMPTY) == 0) {
uiRetries--;
- if ( uiRetries == 0 )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "0x0f003004 = %x, %d retries failed.\n", uiStatus, MAX_EEPROM_RETRIES *RETRIES_PER_DELAY);
- return STATUS_FAILURE ;
+ if (uiRetries == 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "0x0f003004 = %x, %d retries failed.\n", uiStatus, MAX_EEPROM_RETRIES * RETRIES_PER_DELAY);
+ return STATUS_FAILURE;
}
- if( !(uiRetries%RETRIES_PER_DELAY) )
- msleep(1);
+ if (!(uiRetries%RETRIES_PER_DELAY))
+ udelay(1000);
uiStatus = 0;
rdmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &uiStatus, sizeof(uiStatus));
- if(Adapter->device_removed == TRUE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Modem got removed hence exiting from loop....");
+ if (Adapter->device_removed == TRUE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Modem got removed hence exiting from loop....");
return -ENODEV;
}
-
}
- if ( uiRetries != 0 )
- {
+ if (uiRetries != 0) {
/* Clear the ones that are set - either, Empty/Full/Avail bits */
- value = ( uiStatus & ( EEPROM_WRITE_QUEUE_EMPTY | EEPROM_WRITE_QUEUE_AVAIL | EEPROM_WRITE_QUEUE_FULL ) );
- wrmalt( Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
+ value = (uiStatus & (EEPROM_WRITE_QUEUE_EMPTY | EEPROM_WRITE_QUEUE_AVAIL | EEPROM_WRITE_QUEUE_FULL));
+ wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
}
/* Here we should check if the EEPROM status register is correct before
* proceeding. Bit 0 in the EEPROM Status register should be 0 before
* we proceed further. A 1 at Bit 0 indicates that the EEPROM is busy
* with the previous write. Note also that issuing this read finally
- * means the previous write to the EEPROM has completed. */
- uiRetries = MAX_EEPROM_RETRIES*RETRIES_PER_DELAY;
+ * means the previous write to the EEPROM has completed.
+ */
+ uiRetries = MAX_EEPROM_RETRIES * RETRIES_PER_DELAY;
uiEpromStatus = 0;
- while ( uiRetries != 0 )
- {
- uiEpromStatus = ReadEEPROMStatusRegister( Adapter) ;
- if(Adapter->device_removed == TRUE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Modem has got removed hence exiting from loop...");
+ while (uiRetries != 0) {
+ uiEpromStatus = ReadEEPROMStatusRegister(Adapter);
+ if (Adapter->device_removed == TRUE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Modem has got removed hence exiting from loop...");
return -ENODEV;
}
- if ( ( EEPROM_STATUS_REG_WRITE_BUSY & uiEpromStatus ) == 0 )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM status register = %x tries = %d\n", uiEpromStatus, (MAX_EEPROM_RETRIES * RETRIES_PER_DELAY- uiRetries) );
- return STATUS_SUCCESS ;
+ if ((EEPROM_STATUS_REG_WRITE_BUSY & uiEpromStatus) == 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "EEPROM status register = %x tries = %d\n", uiEpromStatus, (MAX_EEPROM_RETRIES * RETRIES_PER_DELAY - uiRetries));
+ return STATUS_SUCCESS;
}
uiRetries--;
- if ( uiRetries == 0 )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "0x0f003004 = %x, for EEPROM status read %d retries failed.\n", uiEpromStatus, MAX_EEPROM_RETRIES *RETRIES_PER_DELAY);
- return STATUS_FAILURE ;
+ if (uiRetries == 0) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "0x0f003004 = %x, for EEPROM status read %d retries failed.\n", uiEpromStatus, MAX_EEPROM_RETRIES * RETRIES_PER_DELAY);
+ return STATUS_FAILURE;
}
uiEpromStatus = 0;
- if( !(uiRetries%RETRIES_PER_DELAY) )
- msleep(1);
+ if (!(uiRetries%RETRIES_PER_DELAY))
+ udelay(1000);
}
- return STATUS_SUCCESS ;
+ return STATUS_SUCCESS;
} /* BeceemEEPROMWritePage */
-
-//-----------------------------------------------------------------------------
-// Procedure: BeceemEEPROMBulkWrite
-//
-// Description: Performs write to the EEPROM
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// pBuffer - Data to be written.
-// uiOffset - Offset of the EEPROM where data needs to be written to.
-// uiNumBytes - Number of bytes to be written.
-// bVerify - read verify flag.
-// Returns:
-// OSAL_STATUS_CODE
-//
-//-----------------------------------------------------------------------------
-
-INT BeceemEEPROMBulkWrite(
- PMINI_ADAPTER Adapter,
- PUCHAR pBuffer,
- UINT uiOffset,
- UINT uiNumBytes,
- BOOLEAN bVerify)
+/*
+ * Procedure: BeceemEEPROMBulkWrite
+ *
+ * Description: Performs write to the EEPROM
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * pBuffer - Data to be written.
+ * uiOffset - Offset of the EEPROM where data needs to be written to.
+ * uiNumBytes - Number of bytes to be written.
+ * bVerify - read verify flag.
+ * Returns:
+ * OSAL_STATUS_CODE
+ *
+ */
+
+int BeceemEEPROMBulkWrite(struct bcm_mini_adapter *Adapter,
+ PUCHAR pBuffer,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes,
+ BOOLEAN bVerify)
{
- UINT uiBytesToCopy = uiNumBytes;
- //UINT uiRdbk = 0;
- UINT uiData[4] = {0};
- UINT uiIndex = 0;
- UINT uiTempOffset = 0;
- UINT uiExtraBytes = 0;
- //PUINT puiBuffer = (PUINT)pBuffer;
- //INT value;
-
- if(uiOffset%MAX_RW_SIZE && uiBytesToCopy)
- {
- uiTempOffset = uiOffset - (uiOffset%MAX_RW_SIZE);
- uiExtraBytes = uiOffset-uiTempOffset;
-
-
- BeceemEEPROMBulkRead(Adapter,&uiData[0],uiTempOffset,MAX_RW_SIZE);
-
- if(uiBytesToCopy >= (16 -uiExtraBytes))
- {
- memcpy((((PUCHAR)&uiData[0])+uiExtraBytes),pBuffer,MAX_RW_SIZE- uiExtraBytes);
-
- if ( STATUS_FAILURE == BeceemEEPROMWritePage( Adapter, uiData, uiTempOffset ) )
- return STATUS_FAILURE;
+ unsigned int uiBytesToCopy = uiNumBytes;
+ /* unsigned int uiRdbk = 0; */
+ unsigned int uiData[4] = {0};
+ unsigned int uiIndex = 0;
+ unsigned int uiTempOffset = 0;
+ unsigned int uiExtraBytes = 0;
+ /* PUINT puiBuffer = (PUINT)pBuffer;
+ * int value;
+ */
+
+ if (uiOffset % MAX_RW_SIZE && uiBytesToCopy) {
+ uiTempOffset = uiOffset - (uiOffset % MAX_RW_SIZE);
+ uiExtraBytes = uiOffset - uiTempOffset;
+
+ BeceemEEPROMBulkRead(Adapter, &uiData[0], uiTempOffset, MAX_RW_SIZE);
+
+ if (uiBytesToCopy >= (16 - uiExtraBytes)) {
+ memcpy((((PUCHAR)&uiData[0]) + uiExtraBytes), pBuffer, MAX_RW_SIZE - uiExtraBytes);
+
+ if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiTempOffset))
+ return STATUS_FAILURE;
uiBytesToCopy -= (MAX_RW_SIZE - uiExtraBytes);
uiIndex += (MAX_RW_SIZE - uiExtraBytes);
uiOffset += (MAX_RW_SIZE - uiExtraBytes);
- }
- else
- {
- memcpy((((PUCHAR)&uiData[0])+uiExtraBytes),pBuffer,uiBytesToCopy);
+ } else {
+ memcpy((((PUCHAR)&uiData[0]) + uiExtraBytes), pBuffer, uiBytesToCopy);
- if ( STATUS_FAILURE == BeceemEEPROMWritePage( Adapter, uiData, uiTempOffset ) )
- return STATUS_FAILURE;
+ if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiTempOffset))
+ return STATUS_FAILURE;
uiIndex += uiBytesToCopy;
uiOffset += uiBytesToCopy;
uiBytesToCopy = 0;
}
-
-
}
- while(uiBytesToCopy)
- {
- if(Adapter->device_removed)
- {
+ while (uiBytesToCopy) {
+ if (Adapter->device_removed)
return -1;
- }
- if(uiBytesToCopy >= MAX_RW_SIZE)
- {
-
- if (STATUS_FAILURE == BeceemEEPROMWritePage( Adapter, (PUINT) &pBuffer[uiIndex], uiOffset ) )
- return STATUS_FAILURE;
+ if (uiBytesToCopy >= MAX_RW_SIZE) {
+ if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, (PUINT) &pBuffer[uiIndex], uiOffset))
+ return STATUS_FAILURE;
uiIndex += MAX_RW_SIZE;
uiOffset += MAX_RW_SIZE;
- uiBytesToCopy -= MAX_RW_SIZE;
- }
- else
- {
- //
- // To program non 16byte aligned data, read 16byte and then update.
- //
- BeceemEEPROMBulkRead(Adapter,&uiData[0],uiOffset,16);
- memcpy(&uiData[0],pBuffer+uiIndex,uiBytesToCopy);
-
+ uiBytesToCopy -= MAX_RW_SIZE;
+ } else {
+ /*
+ * To program non 16byte aligned data, read 16byte and then update.
+ */
+ BeceemEEPROMBulkRead(Adapter, &uiData[0], uiOffset, 16);
+ memcpy(&uiData[0], pBuffer + uiIndex, uiBytesToCopy);
+
+ if (STATUS_FAILURE == BeceemEEPROMWritePage(Adapter, uiData, uiOffset))
+ return STATUS_FAILURE;
- if ( STATUS_FAILURE == BeceemEEPROMWritePage( Adapter, uiData, uiOffset ) )
- return STATUS_FAILURE;
uiBytesToCopy = 0;
}
-
}
return 0;
}
-//-----------------------------------------------------------------------------
-// Procedure: BeceemNVMRead
-//
-// Description: Reads n number of bytes from NVM.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// pBuffer - Buffer to store the data read from NVM
-// uiOffset - Offset of NVM from where data should be read
-// uiNumBytes - Number of bytes to be read from the NVM.
-//
-// Returns:
-// OSAL_STATUS_SUCCESS - if NVM read is successful.
-// <FAILURE> - if failed.
-//-----------------------------------------------------------------------------
-
-INT BeceemNVMRead(
- PMINI_ADAPTER Adapter,
- PUINT pBuffer,
- UINT uiOffset,
- UINT uiNumBytes)
+/*
+ * Procedure: BeceemNVMRead
+ *
+ * Description: Reads n number of bytes from NVM.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * pBuffer - Buffer to store the data read from NVM
+ * uiOffset - Offset of NVM from where data should be read
+ * uiNumBytes - Number of bytes to be read from the NVM.
+ *
+ * Returns:
+ * OSAL_STATUS_SUCCESS - if NVM read is successful.
+ * <FAILURE> - if failed.
+ */
+
+int BeceemNVMRead(struct bcm_mini_adapter *Adapter,
+ PUINT pBuffer,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes)
{
- INT Status = 0;
-#if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
- UINT uiTemp = 0, value;
-#endif
+ int Status = 0;
- if(Adapter->eNVMType == NVM_FLASH)
- {
- if(Adapter->bFlashRawRead == FALSE)
- {
- if (IsSectionExistInVendorInfo(Adapter,Adapter->eActiveDSD))
- return vendorextnReadSection(Adapter,(PUCHAR)pBuffer,Adapter->eActiveDSD,uiOffset,uiNumBytes);
- uiOffset = uiOffset+ Adapter->ulFlashCalStart ;
+ #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
+ unsigned int uiTemp = 0, value;
+ #endif
+
+ if (Adapter->eNVMType == NVM_FLASH) {
+ if (Adapter->bFlashRawRead == FALSE) {
+ if (IsSectionExistInVendorInfo(Adapter, Adapter->eActiveDSD))
+ return vendorextnReadSection(Adapter, (PUCHAR)pBuffer, Adapter->eActiveDSD, uiOffset, uiNumBytes);
+
+ uiOffset = uiOffset + Adapter->ulFlashCalStart;
}
-#if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
- Status = bcmflash_raw_read((uiOffset/FLASH_PART_SIZE),(uiOffset % FLASH_PART_SIZE),( unsigned char *)pBuffer,uiNumBytes);
-#else
- rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
- value = 0;
- wrmalt(Adapter, 0x0f000C80,&value, sizeof(value));
- Status = BeceemFlashBulkRead(Adapter,
+ #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
+ Status = bcmflash_raw_read((uiOffset / FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
+ #else
+ rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
+ value = 0;
+ wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
+ Status = BeceemFlashBulkRead(Adapter,
pBuffer,
uiOffset,
uiNumBytes);
- wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
-#endif
- }
- else if(Adapter->eNVMType == NVM_EEPROM)
- {
+ wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
+ #endif
+ } else if (Adapter->eNVMType == NVM_EEPROM) {
Status = BeceemEEPROMBulkRead(Adapter,
pBuffer,
uiOffset,
uiNumBytes);
- }
- else
- {
+ } else {
Status = -1;
}
+
return Status;
}
-//-----------------------------------------------------------------------------
-// Procedure: BeceemNVMWrite
-//
-// Description: Writes n number of bytes to NVM.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// pBuffer - Buffer contains the data to be written.
-// uiOffset - Offset of NVM where data to be written to.
-// uiNumBytes - Number of bytes to be written..
-//
-// Returns:
-// OSAL_STATUS_SUCCESS - if NVM write is successful.
-// <FAILURE> - if failed.
-//-----------------------------------------------------------------------------
-
-INT BeceemNVMWrite(
- PMINI_ADAPTER Adapter,
- PUINT pBuffer,
- UINT uiOffset,
- UINT uiNumBytes,
- BOOLEAN bVerify)
+/*
+ * Procedure: BeceemNVMWrite
+ *
+ * Description: Writes n number of bytes to NVM.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * pBuffer - Buffer contains the data to be written.
+ * uiOffset - Offset of NVM where data to be written to.
+ * uiNumBytes - Number of bytes to be written..
+ *
+ * Returns:
+ * OSAL_STATUS_SUCCESS - if NVM write is successful.
+ * <FAILURE> - if failed.
+ */
+
+int BeceemNVMWrite(struct bcm_mini_adapter *Adapter,
+ PUINT pBuffer,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes,
+ BOOLEAN bVerify)
{
- INT Status = 0;
- UINT uiTemp = 0;
- UINT uiMemoryLoc = EEPROM_CAL_DATA_INTERNAL_LOC;
- UINT uiIndex = 0;
-#if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
- UINT value;
-#endif
- UINT uiFlashOffset = 0;
-
- if(Adapter->eNVMType == NVM_FLASH)
- {
- if (IsSectionExistInVendorInfo(Adapter,Adapter->eActiveDSD))
- Status = vendorextnWriteSection(Adapter,(PUCHAR)pBuffer,Adapter->eActiveDSD,uiOffset,uiNumBytes,bVerify);
- else
- {
- uiFlashOffset = uiOffset + Adapter->ulFlashCalStart;
+ int Status = 0;
+ unsigned int uiTemp = 0;
+ unsigned int uiMemoryLoc = EEPROM_CAL_DATA_INTERNAL_LOC;
+ unsigned int uiIndex = 0;
-#if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
- Status = bcmflash_raw_write((uiFlashOffset/FLASH_PART_SIZE), (uiFlashOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer,uiNumBytes);
-#else
- rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
- value = 0;
- wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
+ #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
+ unsigned int value;
+ #endif
- if(Adapter->bStatusWrite == TRUE)
- {
- Status = BeceemFlashBulkWriteStatus(Adapter,
- pBuffer,
- uiFlashOffset,
- uiNumBytes ,
- bVerify);
- }
- else
- {
+ unsigned int uiFlashOffset = 0;
- Status = BeceemFlashBulkWrite(Adapter,
- pBuffer,
- uiFlashOffset,
- uiNumBytes,
- bVerify);
- }
-#endif
- }
+ if (Adapter->eNVMType == NVM_FLASH) {
+ if (IsSectionExistInVendorInfo(Adapter, Adapter->eActiveDSD))
+ Status = vendorextnWriteSection(Adapter, (PUCHAR)pBuffer, Adapter->eActiveDSD, uiOffset, uiNumBytes, bVerify);
+ else {
+ uiFlashOffset = uiOffset + Adapter->ulFlashCalStart;
+
+ #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
+ Status = bcmflash_raw_write((uiFlashOffset / FLASH_PART_SIZE), (uiFlashOffset % FLASH_PART_SIZE), (unsigned char *)pBuffer, uiNumBytes);
+ #else
+ rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
+ value = 0;
+ wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
+
+ if (Adapter->bStatusWrite == TRUE)
+ Status = BeceemFlashBulkWriteStatus(Adapter,
+ pBuffer,
+ uiFlashOffset,
+ uiNumBytes ,
+ bVerify);
+ else
+ Status = BeceemFlashBulkWrite(Adapter,
+ pBuffer,
+ uiFlashOffset,
+ uiNumBytes,
+ bVerify);
+ #endif
+ }
- if(uiOffset >= EEPROM_CALPARAM_START)
- {
+ if (uiOffset >= EEPROM_CALPARAM_START) {
uiMemoryLoc += (uiOffset - EEPROM_CALPARAM_START);
- while(uiNumBytes)
- {
- if(uiNumBytes > BUFFER_4K)
- {
- wrm(Adapter,(uiMemoryLoc+uiIndex),(PCHAR)(pBuffer+(uiIndex/4)),BUFFER_4K);
+ while (uiNumBytes) {
+ if (uiNumBytes > BUFFER_4K) {
+ wrm(Adapter, (uiMemoryLoc+uiIndex), (PCHAR)(pBuffer + (uiIndex / 4)), BUFFER_4K);
uiNumBytes -= BUFFER_4K;
uiIndex += BUFFER_4K;
- }
- else
- {
- wrm(Adapter,uiMemoryLoc+uiIndex,(PCHAR)(pBuffer+(uiIndex/4)),uiNumBytes);
+ } else {
+ wrm(Adapter, uiMemoryLoc+uiIndex, (PCHAR)(pBuffer + (uiIndex / 4)), uiNumBytes);
uiNumBytes = 0;
break;
}
}
- }
- else
- {
- if((uiOffset+uiNumBytes) > EEPROM_CALPARAM_START)
- {
+ } else {
+ if ((uiOffset + uiNumBytes) > EEPROM_CALPARAM_START) {
ULONG ulBytesTobeSkipped = 0;
- PUCHAR pcBuffer = (PUCHAR)pBuffer;// char pointer to take care of odd byte cases.
+ PUCHAR pcBuffer = (PUCHAR)pBuffer; /* char pointer to take care of odd byte cases. */
uiNumBytes -= (EEPROM_CALPARAM_START - uiOffset);
ulBytesTobeSkipped += (EEPROM_CALPARAM_START - uiOffset);
uiOffset += (EEPROM_CALPARAM_START - uiOffset);
- while(uiNumBytes)
- {
- if(uiNumBytes > BUFFER_4K)
- {
- wrm(Adapter,uiMemoryLoc+uiIndex,(PCHAR )&pcBuffer[ulBytesTobeSkipped+uiIndex],BUFFER_4K);
+ while (uiNumBytes) {
+ if (uiNumBytes > BUFFER_4K) {
+ wrm(Adapter, uiMemoryLoc + uiIndex, (PCHAR)&pcBuffer[ulBytesTobeSkipped + uiIndex], BUFFER_4K);
uiNumBytes -= BUFFER_4K;
uiIndex += BUFFER_4K;
- }
- else
- {
- wrm(Adapter,uiMemoryLoc+uiIndex,(PCHAR)&pcBuffer[ulBytesTobeSkipped+uiIndex],uiNumBytes);
+ } else {
+ wrm(Adapter, uiMemoryLoc + uiIndex, (PCHAR)&pcBuffer[ulBytesTobeSkipped + uiIndex], uiNumBytes);
uiNumBytes = 0;
break;
}
}
-
}
}
-
- // restore the values.
- wrmalt(Adapter,0x0f000C80,&uiTemp, sizeof(uiTemp));
- }
- else if(Adapter->eNVMType == NVM_EEPROM)
- {
+ /* restore the values. */
+ wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
+ } else if (Adapter->eNVMType == NVM_EEPROM) {
Status = BeceemEEPROMBulkWrite(Adapter,
(PUCHAR)pBuffer,
uiOffset,
uiNumBytes,
bVerify);
- if(bVerify)
- {
- Status = BeceemEEPROMReadBackandVerify(Adapter,(PUINT)pBuffer,uiOffset,uiNumBytes);
- }
- }
- else
- {
+ if (bVerify)
+ Status = BeceemEEPROMReadBackandVerify(Adapter, (PUINT)pBuffer, uiOffset, uiNumBytes);
+ } else {
Status = -1;
}
return Status;
}
-//-----------------------------------------------------------------------------
-// Procedure: BcmUpdateSectorSize
-//
-// Description: Updates the sector size to FLASH.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-// uiSectorSize - sector size
-//
-// Returns:
-// OSAL_STATUS_SUCCESS - if NVM write is successful.
-// <FAILURE> - if failed.
-//-----------------------------------------------------------------------------
-
-INT BcmUpdateSectorSize(PMINI_ADAPTER Adapter,UINT uiSectorSize)
+/*
+ * Procedure: BcmUpdateSectorSize
+ *
+ * Description: Updates the sector size to FLASH.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ * uiSectorSize - sector size
+ *
+ * Returns:
+ * OSAL_STATUS_SUCCESS - if NVM write is successful.
+ * <FAILURE> - if failed.
+ */
+
+int BcmUpdateSectorSize(struct bcm_mini_adapter *Adapter, unsigned int uiSectorSize)
{
- INT Status = -1;
+ int Status = -1;
FLASH_CS_INFO sFlashCsInfo = {0};
- UINT uiTemp = 0;
-
- UINT uiSectorSig = 0;
- UINT uiCurrentSectorSize = 0;
-
- UINT value;
-
-
+ unsigned int uiTemp = 0;
+ unsigned int uiSectorSig = 0;
+ unsigned int uiCurrentSectorSize = 0;
+ unsigned int value;
rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
value = 0;
- wrmalt(Adapter, 0x0f000C80,&value, sizeof(value));
+ wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
-//
-// Before updating the sector size in the reserved area, check if already present.
-//
- BeceemFlashBulkRead(Adapter,(PUINT)&sFlashCsInfo,Adapter->ulFlashControlSectionStart,sizeof(sFlashCsInfo));
+ /*
+ * Before updating the sector size in the reserved area, check if already present.
+ */
+ BeceemFlashBulkRead(Adapter, (PUINT)&sFlashCsInfo, Adapter->ulFlashControlSectionStart, sizeof(sFlashCsInfo));
uiSectorSig = ntohl(sFlashCsInfo.FlashSectorSizeSig);
uiCurrentSectorSize = ntohl(sFlashCsInfo.FlashSectorSize);
- if(uiSectorSig == FLASH_SECTOR_SIZE_SIG)
- {
-
- if((uiCurrentSectorSize <= MAX_SECTOR_SIZE) && (uiCurrentSectorSize >= MIN_SECTOR_SIZE))
- {
- if(uiSectorSize == uiCurrentSectorSize)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Provided sector size is same as programmed in Flash");
+ if (uiSectorSig == FLASH_SECTOR_SIZE_SIG) {
+ if ((uiCurrentSectorSize <= MAX_SECTOR_SIZE) && (uiCurrentSectorSize >= MIN_SECTOR_SIZE)) {
+ if (uiSectorSize == uiCurrentSectorSize) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Provided sector size is same as programmed in Flash");
Status = STATUS_SUCCESS;
- goto Restore ;
+ goto Restore;
}
}
}
- if((uiSectorSize <= MAX_SECTOR_SIZE) && (uiSectorSize >= MIN_SECTOR_SIZE))
- {
-
+ if ((uiSectorSize <= MAX_SECTOR_SIZE) && (uiSectorSize >= MIN_SECTOR_SIZE)) {
sFlashCsInfo.FlashSectorSize = htonl(uiSectorSize);
sFlashCsInfo.FlashSectorSizeSig = htonl(FLASH_SECTOR_SIZE_SIG);
Adapter->ulFlashControlSectionStart,
sizeof(sFlashCsInfo),
TRUE);
-
-
}
- Restore :
- // restore the values.
- wrmalt(Adapter, 0x0f000C80,&uiTemp, sizeof(uiTemp));
-
+Restore:
+ /* restore the values. */
+ wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
return Status;
-
}
-//-----------------------------------------------------------------------------
-// Procedure: BcmGetFlashSectorSize
-//
-// Description: Finds the sector size of the FLASH.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-//
-// Returns:
-// UINT - sector size.
-//
-//-----------------------------------------------------------------------------
-
-static UINT BcmGetFlashSectorSize(PMINI_ADAPTER Adapter, UINT FlashSectorSizeSig, UINT FlashSectorSize)
+/*
+ * Procedure: BcmGetFlashSectorSize
+ *
+ * Description: Finds the sector size of the FLASH.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ *
+ * Returns:
+ * unsigned int - sector size.
+ *
+ */
+
+static unsigned int BcmGetFlashSectorSize(struct bcm_mini_adapter *Adapter, unsigned int FlashSectorSizeSig, unsigned int FlashSectorSize)
{
- UINT uiSectorSize = 0;
- UINT uiSectorSig = 0;
+ unsigned int uiSectorSize = 0;
+ unsigned int uiSectorSig = 0;
- if(Adapter->bSectorSizeOverride &&
+ if (Adapter->bSectorSizeOverride &&
(Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
- Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE))
- {
+ Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE)) {
Adapter->uiSectorSize = Adapter->uiSectorSizeInCFG;
- }
- else
- {
-
+ } else {
uiSectorSig = FlashSectorSizeSig;
- if(uiSectorSig == FLASH_SECTOR_SIZE_SIG)
- {
+ if (uiSectorSig == FLASH_SECTOR_SIZE_SIG) {
uiSectorSize = FlashSectorSize;
- //
- // If the sector size stored in the FLASH makes sense then use it.
- //
- if(uiSectorSize <= MAX_SECTOR_SIZE && uiSectorSize >= MIN_SECTOR_SIZE)
- {
+ /*
+ * If the sector size stored in the FLASH makes sense then use it.
+ */
+ if (uiSectorSize <= MAX_SECTOR_SIZE && uiSectorSize >= MIN_SECTOR_SIZE) {
Adapter->uiSectorSize = uiSectorSize;
- }
- //No valid size in FLASH, check if Config file has it.
- else if(Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
- Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE)
- {
+ } else if (Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
+ Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE) {
+ /* No valid size in FLASH, check if Config file has it. */
Adapter->uiSectorSize = Adapter->uiSectorSizeInCFG;
- }
- // Init to Default, if none of the above works.
- else
- {
+ } else {
+ /* Init to Default, if none of the above works. */
Adapter->uiSectorSize = DEFAULT_SECTOR_SIZE;
}
-
- }
- else
- {
- if(Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
- Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE)
- {
+ } else {
+ if (Adapter->uiSectorSizeInCFG <= MAX_SECTOR_SIZE &&
+ Adapter->uiSectorSizeInCFG >= MIN_SECTOR_SIZE)
Adapter->uiSectorSize = Adapter->uiSectorSizeInCFG;
- }
else
- {
Adapter->uiSectorSize = DEFAULT_SECTOR_SIZE;
- }
}
}
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Sector size :%x \n", Adapter->uiSectorSize);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Sector size :%x\n", Adapter->uiSectorSize);
+
return Adapter->uiSectorSize;
}
-//-----------------------------------------------------------------------------
-// Procedure: BcmInitEEPROMQueues
-//
-// Description: Initialization of EEPROM queues.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-//
-// Returns:
-// <OSAL_STATUS_CODE>
-//-----------------------------------------------------------------------------
-
-static INT BcmInitEEPROMQueues(PMINI_ADAPTER Adapter)
+/*
+ * Procedure: BcmInitEEPROMQueues
+ *
+ * Description: Initialization of EEPROM queues.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ *
+ * Returns:
+ * <OSAL_STATUS_CODE>
+ */
+
+static int BcmInitEEPROMQueues(struct bcm_mini_adapter *Adapter)
{
- UINT value = 0;
+ unsigned int value = 0;
/* CHIP Bug : Clear the Avail bits on the Read queue. The default
* value on this register is supposed to be 0x00001102.
- * But we get 0x00001122. */
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Fixing reset value on 0x0f003004 register\n" );
+ * But we get 0x00001122.
+ */
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Fixing reset value on 0x0f003004 register\n");
value = EEPROM_READ_DATA_AVAIL;
- wrmalt( Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
+ wrmalt(Adapter, EEPROM_SPI_Q_STATUS1_REG, &value, sizeof(value));
/* Flush the all the EEPROM queues. */
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " Flushing the queues\n");
- value =EEPROM_ALL_QUEUE_FLUSH ;
- wrmalt( Adapter, SPI_FLUSH_REG, &value, sizeof(value));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " Flushing the queues\n");
+ value = EEPROM_ALL_QUEUE_FLUSH;
+ wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
value = 0;
- wrmalt( Adapter, SPI_FLUSH_REG, &value, sizeof(value) );
+ wrmalt(Adapter, SPI_FLUSH_REG, &value, sizeof(value));
/* Read the EEPROM Status Register. Just to see, no real purpose. */
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "EEPROM Status register value = %x\n", ReadEEPROMStatusRegister(Adapter) );
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "EEPROM Status register value = %x\n", ReadEEPROMStatusRegister(Adapter));
return STATUS_SUCCESS;
} /* BcmInitEEPROMQueues() */
-//-----------------------------------------------------------------------------
-// Procedure: BcmInitNVM
-//
-// Description: Initialization of NVM, EEPROM size,FLASH size, sector size etc.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-//
-// Returns:
-// <OSAL_STATUS_CODE>
-//-----------------------------------------------------------------------------
-
-INT BcmInitNVM(PMINI_ADAPTER ps_adapter)
+/*
+ * Procedure: BcmInitNVM
+ *
+ * Description: Initialization of NVM, EEPROM size,FLASH size, sector size etc.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ *
+ * Returns:
+ * <OSAL_STATUS_CODE>
+ */
+
+int BcmInitNVM(struct bcm_mini_adapter *ps_adapter)
{
BcmValidateNvmType(ps_adapter);
BcmInitEEPROMQueues(ps_adapter);
- if(ps_adapter->eNVMType == NVM_AUTODETECT)
- {
+ if (ps_adapter->eNVMType == NVM_AUTODETECT) {
ps_adapter->eNVMType = BcmGetNvmType(ps_adapter);
- if(ps_adapter->eNVMType == NVM_UNKNOWN)
- {
- BCM_DEBUG_PRINT(ps_adapter,DBG_TYPE_PRINTK, 0, 0, "NVM Type is unknown!!\n");
- }
- }
- else if(ps_adapter->eNVMType == NVM_FLASH)
- {
+ if (ps_adapter->eNVMType == NVM_UNKNOWN)
+ BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_PRINTK, 0, 0, "NVM Type is unknown!!\n");
+ } else if (ps_adapter->eNVMType == NVM_FLASH) {
BcmGetFlashCSInfo(ps_adapter);
}
return STATUS_SUCCESS;
}
-/***************************************************************************/
-/*BcmGetNvmSize : set the EEPROM or flash size in Adapter.
-*
-*Input Parameter:
-* Adapter data structure
-*Return Value :
-* 0. means success;
-*/
-/***************************************************************************/
-
-static INT BcmGetNvmSize(PMINI_ADAPTER Adapter)
+
+/* BcmGetNvmSize : set the EEPROM or flash size in Adapter.
+ *
+ * Input Parameter:
+ * Adapter data structure
+ * Return Value :
+ * 0. means success;
+ */
+
+static int BcmGetNvmSize(struct bcm_mini_adapter *Adapter)
{
- if(Adapter->eNVMType == NVM_EEPROM)
- {
+ if (Adapter->eNVMType == NVM_EEPROM)
Adapter->uiNVMDSDSize = BcmGetEEPROMSize(Adapter);
- }
- else if(Adapter->eNVMType == NVM_FLASH)
- {
+ else if (Adapter->eNVMType == NVM_FLASH)
Adapter->uiNVMDSDSize = BcmGetFlashSize(Adapter);
- }
+
return 0;
}
-//-----------------------------------------------------------------------------
-// Procedure: BcmValidateNvm
-//
-// Description: Validates the NVM Type option selected against the device
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-//
-// Returns:
-// <VOID>
-//-----------------------------------------------------------------------------
-static VOID BcmValidateNvmType(PMINI_ADAPTER Adapter)
+/*
+ * Procedure: BcmValidateNvm
+ *
+ * Description: Validates the NVM Type option selected against the device
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ *
+ * Returns:
+ * <VOID>
+ */
+
+static VOID BcmValidateNvmType(struct bcm_mini_adapter *Adapter)
{
+ /*
+ * if forcing the FLASH through CFG file, we should ensure device really has a FLASH.
+ * Accessing the FLASH address without the FLASH being present can cause hang/freeze etc.
+ * So if NVM_FLASH is selected for older chipsets, change it to AUTODETECT where EEPROM is 1st choice.
+ */
- //
- // if forcing the FLASH through CFG file, we should ensure device really has a FLASH.
- // Accessing the FLASH address without the FLASH being present can cause hang/freeze etc.
- // So if NVM_FLASH is selected for older chipsets, change it to AUTODETECT where EEPROM is 1st choice.
- //
-
- if(Adapter->eNVMType == NVM_FLASH &&
+ if (Adapter->eNVMType == NVM_FLASH &&
Adapter->chip_id < 0xBECE3300)
- {
Adapter->eNVMType = NVM_AUTODETECT;
- }
}
-//-----------------------------------------------------------------------------
-// Procedure: BcmReadFlashRDID
-//
-// Description: Reads ID from Serial Flash
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-//
-// Returns:
-// Flash ID
-//-----------------------------------------------------------------------------
-static ULONG BcmReadFlashRDID(PMINI_ADAPTER Adapter)
+
+/*
+ * Procedure: BcmReadFlashRDID
+ *
+ * Description: Reads ID from Serial Flash
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ *
+ * Returns:
+ * Flash ID
+ */
+
+static ULONG BcmReadFlashRDID(struct bcm_mini_adapter *Adapter)
{
ULONG ulRDID = 0;
- UINT value;
-//
-// Read ID Instruction.
-//
- value = (FLASH_CMD_READ_ID<<24);
- wrmalt(Adapter, FLASH_SPI_CMDQ_REG,&value, sizeof(value));
-
-//Delay
- udelay(10);
-//
-// Read SPI READQ REG. The output will be WWXXYYZZ.
-// The ID is 3Bytes long and is WWXXYY. ZZ needs to be Ignored.
-//
- rdmalt(Adapter, FLASH_SPI_READQ_REG, (PUINT)&ulRDID, sizeof(ulRDID));
+ unsigned int value;
- return (ulRDID >>8);
+ /*
+ * Read ID Instruction.
+ */
+ value = (FLASH_CMD_READ_ID << 24);
+ wrmalt(Adapter, FLASH_SPI_CMDQ_REG, &value, sizeof(value));
+
+ /* Delay */
+ udelay(10);
+ /*
+ * Read SPI READQ REG. The output will be WWXXYYZZ.
+ * The ID is 3Bytes long and is WWXXYY. ZZ needs to be Ignored.
+ */
+ rdmalt(Adapter, FLASH_SPI_READQ_REG, (PUINT)&ulRDID, sizeof(ulRDID));
+ return ulRDID >> 8;
}
-INT BcmAllocFlashCSStructure(PMINI_ADAPTER psAdapter)
+int BcmAllocFlashCSStructure(struct bcm_mini_adapter *psAdapter)
{
- if(psAdapter == NULL)
- {
- BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_PRINTK, 0, 0, "Adapter structure point is NULL");
+ if (!psAdapter) {
+ BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure point is NULL");
return -EINVAL;
}
psAdapter->psFlashCSInfo = (PFLASH_CS_INFO)kzalloc(sizeof(FLASH_CS_INFO), GFP_KERNEL);
- if(psAdapter->psFlashCSInfo == NULL)
- {
- BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_PRINTK, 0, 0,"Can't Allocate memory for Flash 1.x");
+ if (psAdapter->psFlashCSInfo == NULL) {
+ BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Can't Allocate memory for Flash 1.x");
return -ENOMEM;
}
psAdapter->psFlash2xCSInfo = (PFLASH2X_CS_INFO)kzalloc(sizeof(FLASH2X_CS_INFO), GFP_KERNEL);
- if(psAdapter->psFlash2xCSInfo == NULL)
- {
- BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_PRINTK, 0, 0,"Can't Allocate memory for Flash 2.x");
+ if (!psAdapter->psFlash2xCSInfo) {
+ BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Can't Allocate memory for Flash 2.x");
kfree(psAdapter->psFlashCSInfo);
return -ENOMEM;
}
psAdapter->psFlash2xVendorInfo = (PFLASH2X_VENDORSPECIFIC_INFO)kzalloc(sizeof(FLASH2X_VENDORSPECIFIC_INFO), GFP_KERNEL);
- if(psAdapter->psFlash2xVendorInfo == NULL)
- {
- BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_PRINTK, 0, 0,"Can't Allocate Vendor Info Memory for Flash 2.x");
+ if (!psAdapter->psFlash2xVendorInfo) {
+ BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Can't Allocate Vendor Info Memory for Flash 2.x");
kfree(psAdapter->psFlashCSInfo);
kfree(psAdapter->psFlash2xCSInfo);
return -ENOMEM;
return STATUS_SUCCESS;
}
-INT BcmDeAllocFlashCSStructure(PMINI_ADAPTER psAdapter)
+int BcmDeAllocFlashCSStructure(struct bcm_mini_adapter *psAdapter)
{
- if(psAdapter == NULL)
- {
- BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_PRINTK, 0, 0," Adapter structure point is NULL");
+ if (!psAdapter) {
+ BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure point is NULL");
return -EINVAL;
}
kfree(psAdapter->psFlashCSInfo);
kfree(psAdapter->psFlash2xCSInfo);
kfree(psAdapter->psFlash2xVendorInfo);
- return STATUS_SUCCESS ;
+ return STATUS_SUCCESS;
}
-static INT BcmDumpFlash2XCSStructure(PFLASH2X_CS_INFO psFlash2xCSInfo,PMINI_ADAPTER Adapter)
+static int BcmDumpFlash2XCSStructure(PFLASH2X_CS_INFO psFlash2xCSInfo, struct bcm_mini_adapter *Adapter)
{
- UINT Index = 0;
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "**********************FLASH2X CS Structure *******************");
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is :%x", (psFlash2xCSInfo->MagicNumber));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Major Version :%d", MAJOR_VERSION(psFlash2xCSInfo->FlashLayoutVersion));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Minor Version :%d", MINOR_VERSION(psFlash2xCSInfo->FlashLayoutVersion));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " ISOImageMajorVersion:0x%x", (psFlash2xCSInfo->ISOImageVersion));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SCSIFirmwareMajorVersion :0x%x", (psFlash2xCSInfo->SCSIFirmwareVersion));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForPart1ISOImage :0x%x", (psFlash2xCSInfo->OffsetFromZeroForPart1ISOImage));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForScsiFirmware :0x%x", (psFlash2xCSInfo->OffsetFromZeroForScsiFirmware));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SizeOfScsiFirmware :0x%x", (psFlash2xCSInfo->SizeOfScsiFirmware ));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForPart2ISOImage :0x%x", (psFlash2xCSInfo->OffsetFromZeroForPart2ISOImage));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSDStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSDStart));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSDEnd :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSDEnd));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSAStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSAStart));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSAEnd :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSAEnd));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForControlSectionStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForControlSectionStart));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForControlSectionData :0x%x", (psFlash2xCSInfo->OffsetFromZeroForControlSectionData));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "CDLessInactivityTimeout :0x%x", (psFlash2xCSInfo->CDLessInactivityTimeout));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "NewImageSignature :0x%x", (psFlash2xCSInfo->NewImageSignature));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashSectorSizeSig :0x%x", (psFlash2xCSInfo->FlashSectorSizeSig));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashSectorSize :0x%x", (psFlash2xCSInfo->FlashSectorSize));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashWriteSupportSize :0x%x", (psFlash2xCSInfo->FlashWriteSupportSize));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "TotalFlashSize :0x%X", (psFlash2xCSInfo->TotalFlashSize));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashBaseAddr :0x%x", (psFlash2xCSInfo->FlashBaseAddr));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashPartMaxSize :0x%x", (psFlash2xCSInfo->FlashPartMaxSize));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "IsCDLessDeviceBootSig :0x%x", (psFlash2xCSInfo->IsCDLessDeviceBootSig));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "MassStorageTimeout :0x%x", (psFlash2xCSInfo->MassStorageTimeout));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part1Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part1Start));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part1End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part1End));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part2Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part2Start));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part2End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part2End));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part3Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part3Start));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part3End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part3End));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part1Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part1Start));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part1End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part1End));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part2Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part2Start));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part2End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part2End));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part3Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part3Start));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part3End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part3End));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromDSDStartForDSDHeader :0x%x", (psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD1Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD1Start));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD1End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD1End));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD2Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD2Start));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD2End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD2End));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA1Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA1Start));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA1End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA1End));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA2Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA2Start));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA2End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA2End));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Sector Access Bit Map is Defined as :");
- for(Index =0; Index <(FLASH2X_TOTAL_SIZE/(DEFAULT_SECTOR_SIZE *16)); Index++)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SectorAccessBitMap[%d] :0x%x", Index,
+ unsigned int Index = 0;
+
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "**********************FLASH2X CS Structure *******************");
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is :%x", (psFlash2xCSInfo->MagicNumber));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Major Version :%d", MAJOR_VERSION(psFlash2xCSInfo->FlashLayoutVersion));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Minor Version :%d", MINOR_VERSION(psFlash2xCSInfo->FlashLayoutVersion));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " ISOImageMajorVersion:0x%x", (psFlash2xCSInfo->ISOImageVersion));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SCSIFirmwareMajorVersion :0x%x", (psFlash2xCSInfo->SCSIFirmwareVersion));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForPart1ISOImage :0x%x", (psFlash2xCSInfo->OffsetFromZeroForPart1ISOImage));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForScsiFirmware :0x%x", (psFlash2xCSInfo->OffsetFromZeroForScsiFirmware));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SizeOfScsiFirmware :0x%x", (psFlash2xCSInfo->SizeOfScsiFirmware));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForPart2ISOImage :0x%x", (psFlash2xCSInfo->OffsetFromZeroForPart2ISOImage));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSDStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSDStart));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSDEnd :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSDEnd));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSAStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSAStart));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSAEnd :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSAEnd));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForControlSectionStart :0x%x", (psFlash2xCSInfo->OffsetFromZeroForControlSectionStart));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForControlSectionData :0x%x", (psFlash2xCSInfo->OffsetFromZeroForControlSectionData));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "CDLessInactivityTimeout :0x%x", (psFlash2xCSInfo->CDLessInactivityTimeout));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "NewImageSignature :0x%x", (psFlash2xCSInfo->NewImageSignature));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashSectorSizeSig :0x%x", (psFlash2xCSInfo->FlashSectorSizeSig));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashSectorSize :0x%x", (psFlash2xCSInfo->FlashSectorSize));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashWriteSupportSize :0x%x", (psFlash2xCSInfo->FlashWriteSupportSize));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "TotalFlashSize :0x%X", (psFlash2xCSInfo->TotalFlashSize));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashBaseAddr :0x%x", (psFlash2xCSInfo->FlashBaseAddr));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FlashPartMaxSize :0x%x", (psFlash2xCSInfo->FlashPartMaxSize));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "IsCDLessDeviceBootSig :0x%x", (psFlash2xCSInfo->IsCDLessDeviceBootSig));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "MassStorageTimeout :0x%x", (psFlash2xCSInfo->MassStorageTimeout));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part1Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part1Start));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part1End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part1End));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part2Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part2Start));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part2End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part2End));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part3Start :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part3Start));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage1Part3End :0x%x", (psFlash2xCSInfo->OffsetISOImage1Part3End));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part1Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part1Start));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part1End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part1End));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part2Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part2Start));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part2End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part2End));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part3Start :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part3Start));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetISOImage2Part3End :0x%x", (psFlash2xCSInfo->OffsetISOImage2Part3End));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromDSDStartForDSDHeader :0x%x", (psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD1Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD1Start));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD1End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD1End));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD2Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD2Start));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForDSD2End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForDSD2End));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA1Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA1Start));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA1End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA1End));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA2Start :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA2Start));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "OffsetFromZeroForVSA2End :0x%x", (psFlash2xCSInfo->OffsetFromZeroForVSA2End));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Sector Access Bit Map is Defined as :");
+
+ for (Index = 0; Index < (FLASH2X_TOTAL_SIZE / (DEFAULT_SECTOR_SIZE * 16)); Index++)
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SectorAccessBitMap[%d] :0x%x", Index,
(psFlash2xCSInfo->SectorAccessBitMap[Index]));
- }
return STATUS_SUCCESS;
}
-
-static INT ConvertEndianOf2XCSStructure(PFLASH2X_CS_INFO psFlash2xCSInfo)
+static int ConvertEndianOf2XCSStructure(PFLASH2X_CS_INFO psFlash2xCSInfo)
{
- UINT Index = 0;
+ unsigned int Index = 0;
+
psFlash2xCSInfo->MagicNumber = ntohl(psFlash2xCSInfo->MagicNumber);
- psFlash2xCSInfo->FlashLayoutVersion= ntohl(psFlash2xCSInfo->FlashLayoutVersion);
- //psFlash2xCSInfo->FlashLayoutMinorVersion = ntohs(psFlash2xCSInfo->FlashLayoutMinorVersion);
+ psFlash2xCSInfo->FlashLayoutVersion = ntohl(psFlash2xCSInfo->FlashLayoutVersion);
+ /* psFlash2xCSInfo->FlashLayoutMinorVersion = ntohs(psFlash2xCSInfo->FlashLayoutMinorVersion); */
psFlash2xCSInfo->ISOImageVersion = ntohl(psFlash2xCSInfo->ISOImageVersion);
- psFlash2xCSInfo->SCSIFirmwareVersion =ntohl(psFlash2xCSInfo->SCSIFirmwareVersion);
+ psFlash2xCSInfo->SCSIFirmwareVersion = ntohl(psFlash2xCSInfo->SCSIFirmwareVersion);
psFlash2xCSInfo->OffsetFromZeroForPart1ISOImage = ntohl(psFlash2xCSInfo->OffsetFromZeroForPart1ISOImage);
psFlash2xCSInfo->OffsetFromZeroForScsiFirmware = ntohl(psFlash2xCSInfo->OffsetFromZeroForScsiFirmware);
- psFlash2xCSInfo->SizeOfScsiFirmware = ntohl(psFlash2xCSInfo->SizeOfScsiFirmware );
+ psFlash2xCSInfo->SizeOfScsiFirmware = ntohl(psFlash2xCSInfo->SizeOfScsiFirmware);
psFlash2xCSInfo->OffsetFromZeroForPart2ISOImage = ntohl(psFlash2xCSInfo->OffsetFromZeroForPart2ISOImage);
psFlash2xCSInfo->OffsetFromZeroForDSDStart = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSDStart);
psFlash2xCSInfo->OffsetFromZeroForDSDEnd = ntohl(psFlash2xCSInfo->OffsetFromZeroForDSDEnd);
psFlash2xCSInfo->OffsetFromZeroForVSA1End = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA1End);
psFlash2xCSInfo->OffsetFromZeroForVSA2Start = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA2Start);
psFlash2xCSInfo->OffsetFromZeroForVSA2End = ntohl(psFlash2xCSInfo->OffsetFromZeroForVSA2End);
- for(Index =0; Index <(FLASH2X_TOTAL_SIZE/(DEFAULT_SECTOR_SIZE *16)); Index++)
- {
- psFlash2xCSInfo->SectorAccessBitMap[Index] = ntohl(psFlash2xCSInfo->SectorAccessBitMap[Index]);
- }
+
+ for (Index = 0; Index < (FLASH2X_TOTAL_SIZE / (DEFAULT_SECTOR_SIZE * 16)); Index++)
+ psFlash2xCSInfo->SectorAccessBitMap[Index] = ntohl(psFlash2xCSInfo->SectorAccessBitMap[Index]);
+
return STATUS_SUCCESS;
}
-static INT ConvertEndianOfCSStructure(PFLASH_CS_INFO psFlashCSInfo)
+static int ConvertEndianOfCSStructure(PFLASH_CS_INFO psFlashCSInfo)
{
- //UINT Index = 0;
- psFlashCSInfo->MagicNumber =ntohl(psFlashCSInfo->MagicNumber);
- psFlashCSInfo->FlashLayoutVersion =ntohl(psFlashCSInfo->FlashLayoutVersion);
- psFlashCSInfo->ISOImageVersion = ntohl(psFlashCSInfo->ISOImageVersion);
- //won't convert according to old assumption
- psFlashCSInfo->SCSIFirmwareVersion =(psFlashCSInfo->SCSIFirmwareVersion);
-
- psFlashCSInfo->OffsetFromZeroForPart1ISOImage = ntohl(psFlashCSInfo->OffsetFromZeroForPart1ISOImage);
- psFlashCSInfo->OffsetFromZeroForScsiFirmware = ntohl(psFlashCSInfo->OffsetFromZeroForScsiFirmware);
- psFlashCSInfo->SizeOfScsiFirmware = ntohl(psFlashCSInfo->SizeOfScsiFirmware );
- psFlashCSInfo->OffsetFromZeroForPart2ISOImage = ntohl(psFlashCSInfo->OffsetFromZeroForPart2ISOImage);
- psFlashCSInfo->OffsetFromZeroForCalibrationStart = ntohl(psFlashCSInfo->OffsetFromZeroForCalibrationStart);
- psFlashCSInfo->OffsetFromZeroForCalibrationEnd = ntohl(psFlashCSInfo->OffsetFromZeroForCalibrationEnd);
- psFlashCSInfo->OffsetFromZeroForVSAStart = ntohl(psFlashCSInfo->OffsetFromZeroForVSAStart);
- psFlashCSInfo->OffsetFromZeroForVSAEnd = ntohl(psFlashCSInfo->OffsetFromZeroForVSAEnd);
- psFlashCSInfo->OffsetFromZeroForControlSectionStart = ntohl(psFlashCSInfo->OffsetFromZeroForControlSectionStart);
- psFlashCSInfo->OffsetFromZeroForControlSectionData = ntohl(psFlashCSInfo->OffsetFromZeroForControlSectionData);
- psFlashCSInfo->CDLessInactivityTimeout = ntohl(psFlashCSInfo->CDLessInactivityTimeout);
- psFlashCSInfo->NewImageSignature = ntohl(psFlashCSInfo->NewImageSignature);
- psFlashCSInfo->FlashSectorSizeSig = ntohl(psFlashCSInfo->FlashSectorSizeSig);
- psFlashCSInfo->FlashSectorSize = ntohl(psFlashCSInfo->FlashSectorSize);
- psFlashCSInfo->FlashWriteSupportSize = ntohl(psFlashCSInfo->FlashWriteSupportSize);
- psFlashCSInfo->TotalFlashSize = ntohl(psFlashCSInfo->TotalFlashSize);
- psFlashCSInfo->FlashBaseAddr = ntohl(psFlashCSInfo->FlashBaseAddr);
- psFlashCSInfo->FlashPartMaxSize = ntohl(psFlashCSInfo->FlashPartMaxSize);
- psFlashCSInfo->IsCDLessDeviceBootSig = ntohl(psFlashCSInfo->IsCDLessDeviceBootSig);
- psFlashCSInfo->MassStorageTimeout = ntohl(psFlashCSInfo->MassStorageTimeout);
+ /* unsigned int Index = 0; */
+ psFlashCSInfo->MagicNumber = ntohl(psFlashCSInfo->MagicNumber);
+ psFlashCSInfo->FlashLayoutVersion = ntohl(psFlashCSInfo->FlashLayoutVersion);
+ psFlashCSInfo->ISOImageVersion = ntohl(psFlashCSInfo->ISOImageVersion);
+ /* won't convert according to old assumption */
+ psFlashCSInfo->SCSIFirmwareVersion = (psFlashCSInfo->SCSIFirmwareVersion);
+ psFlashCSInfo->OffsetFromZeroForPart1ISOImage = ntohl(psFlashCSInfo->OffsetFromZeroForPart1ISOImage);
+ psFlashCSInfo->OffsetFromZeroForScsiFirmware = ntohl(psFlashCSInfo->OffsetFromZeroForScsiFirmware);
+ psFlashCSInfo->SizeOfScsiFirmware = ntohl(psFlashCSInfo->SizeOfScsiFirmware);
+ psFlashCSInfo->OffsetFromZeroForPart2ISOImage = ntohl(psFlashCSInfo->OffsetFromZeroForPart2ISOImage);
+ psFlashCSInfo->OffsetFromZeroForCalibrationStart = ntohl(psFlashCSInfo->OffsetFromZeroForCalibrationStart);
+ psFlashCSInfo->OffsetFromZeroForCalibrationEnd = ntohl(psFlashCSInfo->OffsetFromZeroForCalibrationEnd);
+ psFlashCSInfo->OffsetFromZeroForVSAStart = ntohl(psFlashCSInfo->OffsetFromZeroForVSAStart);
+ psFlashCSInfo->OffsetFromZeroForVSAEnd = ntohl(psFlashCSInfo->OffsetFromZeroForVSAEnd);
+ psFlashCSInfo->OffsetFromZeroForControlSectionStart = ntohl(psFlashCSInfo->OffsetFromZeroForControlSectionStart);
+ psFlashCSInfo->OffsetFromZeroForControlSectionData = ntohl(psFlashCSInfo->OffsetFromZeroForControlSectionData);
+ psFlashCSInfo->CDLessInactivityTimeout = ntohl(psFlashCSInfo->CDLessInactivityTimeout);
+ psFlashCSInfo->NewImageSignature = ntohl(psFlashCSInfo->NewImageSignature);
+ psFlashCSInfo->FlashSectorSizeSig = ntohl(psFlashCSInfo->FlashSectorSizeSig);
+ psFlashCSInfo->FlashSectorSize = ntohl(psFlashCSInfo->FlashSectorSize);
+ psFlashCSInfo->FlashWriteSupportSize = ntohl(psFlashCSInfo->FlashWriteSupportSize);
+ psFlashCSInfo->TotalFlashSize = ntohl(psFlashCSInfo->TotalFlashSize);
+ psFlashCSInfo->FlashBaseAddr = ntohl(psFlashCSInfo->FlashBaseAddr);
+ psFlashCSInfo->FlashPartMaxSize = ntohl(psFlashCSInfo->FlashPartMaxSize);
+ psFlashCSInfo->IsCDLessDeviceBootSig = ntohl(psFlashCSInfo->IsCDLessDeviceBootSig);
+ psFlashCSInfo->MassStorageTimeout = ntohl(psFlashCSInfo->MassStorageTimeout);
return STATUS_SUCCESS;
}
-static INT IsSectionExistInVendorInfo(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL section)
+static int IsSectionExistInVendorInfo(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL section)
{
- return ( Adapter->uiVendorExtnFlag &&
- (Adapter->psFlash2xVendorInfo->VendorSection[section].AccessFlags & FLASH2X_SECTION_PRESENT) &&
- (Adapter->psFlash2xVendorInfo->VendorSection[section].OffsetFromZeroForSectionStart != UNINIT_PTR_IN_CS) );
+ return (Adapter->uiVendorExtnFlag &&
+ (Adapter->psFlash2xVendorInfo->VendorSection[section].AccessFlags & FLASH2X_SECTION_PRESENT) &&
+ (Adapter->psFlash2xVendorInfo->VendorSection[section].OffsetFromZeroForSectionStart != UNINIT_PTR_IN_CS));
}
-static VOID UpdateVendorInfo(PMINI_ADAPTER Adapter)
+static VOID UpdateVendorInfo(struct bcm_mini_adapter *Adapter)
{
B_UINT32 i = 0;
- UINT uiSizeSection = 0;
+ unsigned int uiSizeSection = 0;
Adapter->uiVendorExtnFlag = FALSE;
- for(i = 0;i < TOTAL_SECTIONS;i++)
+ for (i = 0; i < TOTAL_SECTIONS; i++)
Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart = UNINIT_PTR_IN_CS;
- if(STATUS_SUCCESS != vendorextnGetSectionInfo(Adapter, Adapter->psFlash2xVendorInfo))
+ if (STATUS_SUCCESS != vendorextnGetSectionInfo(Adapter, Adapter->psFlash2xVendorInfo))
return;
i = 0;
- while(i < TOTAL_SECTIONS)
- {
- if(!(Adapter->psFlash2xVendorInfo->VendorSection[i].AccessFlags & FLASH2X_SECTION_PRESENT))
- {
+ while (i < TOTAL_SECTIONS) {
+ if (!(Adapter->psFlash2xVendorInfo->VendorSection[i].AccessFlags & FLASH2X_SECTION_PRESENT)) {
i++;
continue;
}
Adapter->uiVendorExtnFlag = TRUE;
uiSizeSection = (Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionEnd -
- Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart);
+ Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart);
- switch(i)
- {
+ switch (i) {
case DSD0:
- if(( uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(DSD_HEADER))) &&
- (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
+ if ((uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(DSD_HEADER))) &&
+ (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd = VENDOR_PTR_IN_CS;
else
Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd = UNINIT_PTR_IN_CS;
break;
case DSD1:
- if(( uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(DSD_HEADER))) &&
- (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
+ if ((uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(DSD_HEADER))) &&
+ (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End = VENDOR_PTR_IN_CS;
else
Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End = UNINIT_PTR_IN_CS;
break;
case DSD2:
- if(( uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(DSD_HEADER))) &&
- (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
+ if ((uiSizeSection >= (Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(DSD_HEADER))) &&
+ (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart))
Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End = VENDOR_PTR_IN_CS;
else
Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End = UNINIT_PTR_IN_CS;
break;
case VSA0:
- if(UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
+ if (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd = VENDOR_PTR_IN_CS;
else
Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd = UNINIT_PTR_IN_CS;
break;
case VSA1:
- if(UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
+ if (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End = VENDOR_PTR_IN_CS;
else
Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End = UNINIT_PTR_IN_CS;
break;
case VSA2:
- if(UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
+ if (UNINIT_PTR_IN_CS != Adapter->psFlash2xVendorInfo->VendorSection[i].OffsetFromZeroForSectionStart)
Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End = VENDOR_PTR_IN_CS;
else
Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start = Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End = UNINIT_PTR_IN_CS;
}
i++;
}
-
}
-//-----------------------------------------------------------------------------
-// Procedure: BcmGetFlashCSInfo
-//
-// Description: Reads control structure and gets Cal section addresses.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-//
-// Returns:
-// <VOID>
-//-----------------------------------------------------------------------------
-
-static INT BcmGetFlashCSInfo(PMINI_ADAPTER Adapter)
+/*
+ * Procedure: BcmGetFlashCSInfo
+ *
+ * Description: Reads control structure and gets Cal section addresses.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ *
+ * Returns:
+ * <VOID>
+ */
+
+static int BcmGetFlashCSInfo(struct bcm_mini_adapter *Adapter)
{
- //FLASH_CS_INFO sFlashCsInfo = {0};
+ /* FLASH_CS_INFO sFlashCsInfo = {0}; */
+
+ #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
+ unsigned int value;
+ #endif
-#if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
- UINT value;
-#endif
- UINT uiFlashLayoutMajorVersion;
+ unsigned int uiFlashLayoutMajorVersion;
Adapter->uiFlashLayoutMinorVersion = 0;
Adapter->uiFlashLayoutMajorVersion = 0;
Adapter->ulFlashControlSectionStart = FLASH_CS_INFO_START_ADDR;
-
Adapter->uiFlashBaseAdd = 0;
Adapter->ulFlashCalStart = 0;
- memset(Adapter->psFlashCSInfo, 0 ,sizeof(FLASH_CS_INFO));
- memset(Adapter->psFlash2xCSInfo, 0 ,sizeof(FLASH2X_CS_INFO));
+ memset(Adapter->psFlashCSInfo, 0 , sizeof(FLASH_CS_INFO));
+ memset(Adapter->psFlash2xCSInfo, 0 , sizeof(FLASH2X_CS_INFO));
- if(!Adapter->bDDRInitDone)
- {
- {
- value = FLASH_CONTIGIOUS_START_ADDR_BEFORE_INIT;
- wrmalt(Adapter, 0xAF00A080, &value, sizeof(value));
- }
+ if (!Adapter->bDDRInitDone) {
+ value = FLASH_CONTIGIOUS_START_ADDR_BEFORE_INIT;
+ wrmalt(Adapter, 0xAF00A080, &value, sizeof(value));
}
-
- // Reading first 8 Bytes to get the Flash Layout
- // MagicNumber(4 bytes) +FlashLayoutMinorVersion(2 Bytes) +FlashLayoutMajorVersion(2 Bytes)
- BeceemFlashBulkRead(Adapter,(PUINT)Adapter->psFlashCSInfo,Adapter->ulFlashControlSectionStart,8);
+ /* Reading first 8 Bytes to get the Flash Layout
+ * MagicNumber(4 bytes) +FlashLayoutMinorVersion(2 Bytes) +FlashLayoutMajorVersion(2 Bytes)
+ */
+ BeceemFlashBulkRead(Adapter, (PUINT)Adapter->psFlashCSInfo, Adapter->ulFlashControlSectionStart, 8);
Adapter->psFlashCSInfo->FlashLayoutVersion = ntohl(Adapter->psFlashCSInfo->FlashLayoutVersion);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Layout Version :%X", (Adapter->psFlashCSInfo->FlashLayoutVersion));
- //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Layout Minor Version :%d\n", ntohs(sFlashCsInfo.FlashLayoutMinorVersion));
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is :%x\n", ntohl(Adapter->psFlashCSInfo->MagicNumber));
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Layout Version :%X", (Adapter->psFlashCSInfo->FlashLayoutVersion));
+ /* BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Flash Layout Minor Version :%d\n", ntohs(sFlashCsInfo.FlashLayoutMinorVersion)); */
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is :%x\n", ntohl(Adapter->psFlashCSInfo->MagicNumber));
- if(FLASH_CONTROL_STRUCT_SIGNATURE == ntohl(Adapter->psFlashCSInfo->MagicNumber))
- {
+ if (FLASH_CONTROL_STRUCT_SIGNATURE == ntohl(Adapter->psFlashCSInfo->MagicNumber)) {
uiFlashLayoutMajorVersion = MAJOR_VERSION((Adapter->psFlashCSInfo->FlashLayoutVersion));
Adapter->uiFlashLayoutMinorVersion = MINOR_VERSION((Adapter->psFlashCSInfo->FlashLayoutVersion));
- }
- else
- {
+ } else {
Adapter->uiFlashLayoutMinorVersion = 0;
uiFlashLayoutMajorVersion = 0;
}
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"FLASH LAYOUT MAJOR VERSION :%X", uiFlashLayoutMajorVersion);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "FLASH LAYOUT MAJOR VERSION :%X", uiFlashLayoutMajorVersion);
- if(uiFlashLayoutMajorVersion < FLASH_2X_MAJOR_NUMBER)
- {
- BeceemFlashBulkRead(Adapter,(PUINT)Adapter->psFlashCSInfo,Adapter->ulFlashControlSectionStart,sizeof(FLASH_CS_INFO));
+ if (uiFlashLayoutMajorVersion < FLASH_2X_MAJOR_NUMBER) {
+ BeceemFlashBulkRead(Adapter, (PUINT)Adapter->psFlashCSInfo, Adapter->ulFlashControlSectionStart, sizeof(FLASH_CS_INFO));
ConvertEndianOfCSStructure(Adapter->psFlashCSInfo);
Adapter->ulFlashCalStart = (Adapter->psFlashCSInfo->OffsetFromZeroForCalibrationStart);
- if(!((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1)))
- {
+ if (!((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1)))
Adapter->ulFlashControlSectionStart = Adapter->psFlashCSInfo->OffsetFromZeroForControlSectionStart;
- }
- if((FLASH_CONTROL_STRUCT_SIGNATURE == (Adapter->psFlashCSInfo->MagicNumber)) &&
- (SCSI_FIRMWARE_MINOR_VERSION <= MINOR_VERSION(Adapter->psFlashCSInfo->SCSIFirmwareVersion)) &&
- (FLASH_SECTOR_SIZE_SIG == (Adapter->psFlashCSInfo->FlashSectorSizeSig)) &&
- (BYTE_WRITE_SUPPORT == (Adapter->psFlashCSInfo->FlashWriteSupportSize)))
- {
+ if ((FLASH_CONTROL_STRUCT_SIGNATURE == (Adapter->psFlashCSInfo->MagicNumber)) &&
+ (SCSI_FIRMWARE_MINOR_VERSION <= MINOR_VERSION(Adapter->psFlashCSInfo->SCSIFirmwareVersion)) &&
+ (FLASH_SECTOR_SIZE_SIG == (Adapter->psFlashCSInfo->FlashSectorSizeSig)) &&
+ (BYTE_WRITE_SUPPORT == (Adapter->psFlashCSInfo->FlashWriteSupportSize))) {
Adapter->ulFlashWriteSize = (Adapter->psFlashCSInfo->FlashWriteSupportSize);
- Adapter->fpFlashWrite = flashByteWrite;
- Adapter->fpFlashWriteWithStatusCheck = flashByteWriteStatus;
- }
- else
- {
+ Adapter->fpFlashWrite = flashByteWrite;
+ Adapter->fpFlashWriteWithStatusCheck = flashByteWriteStatus;
+ } else {
Adapter->ulFlashWriteSize = MAX_RW_SIZE;
Adapter->fpFlashWrite = flashWrite;
- Adapter->fpFlashWriteWithStatusCheck = flashWriteStatus;
+ Adapter->fpFlashWriteWithStatusCheck = flashWriteStatus;
}
BcmGetFlashSectorSize(Adapter, (Adapter->psFlashCSInfo->FlashSectorSizeSig),
- (Adapter->psFlashCSInfo->FlashSectorSize));
-
-
+ (Adapter->psFlashCSInfo->FlashSectorSize));
Adapter->uiFlashBaseAdd = Adapter->psFlashCSInfo->FlashBaseAddr & 0xFCFFFFFF;
-
-
- }
- else
- {
- if(BcmFlash2xBulkRead(Adapter,(PUINT)Adapter->psFlash2xCSInfo,NO_SECTION_VAL,
- Adapter->ulFlashControlSectionStart,sizeof(FLASH2X_CS_INFO)))
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Unable to read CS structure \n");
+ } else {
+ if (BcmFlash2xBulkRead(Adapter, (PUINT)Adapter->psFlash2xCSInfo, NO_SECTION_VAL,
+ Adapter->ulFlashControlSectionStart, sizeof(FLASH2X_CS_INFO))) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Unable to read CS structure\n");
return STATUS_FAILURE;
}
+
ConvertEndianOf2XCSStructure(Adapter->psFlash2xCSInfo);
- BcmDumpFlash2XCSStructure(Adapter->psFlash2xCSInfo,Adapter);
- if((FLASH_CONTROL_STRUCT_SIGNATURE == Adapter->psFlash2xCSInfo->MagicNumber) &&
- (SCSI_FIRMWARE_MINOR_VERSION <= MINOR_VERSION(Adapter->psFlash2xCSInfo->SCSIFirmwareVersion)) &&
- (FLASH_SECTOR_SIZE_SIG == Adapter->psFlash2xCSInfo->FlashSectorSizeSig) &&
- (BYTE_WRITE_SUPPORT == Adapter->psFlash2xCSInfo->FlashWriteSupportSize))
- {
+ BcmDumpFlash2XCSStructure(Adapter->psFlash2xCSInfo, Adapter);
+ if ((FLASH_CONTROL_STRUCT_SIGNATURE == Adapter->psFlash2xCSInfo->MagicNumber) &&
+ (SCSI_FIRMWARE_MINOR_VERSION <= MINOR_VERSION(Adapter->psFlash2xCSInfo->SCSIFirmwareVersion)) &&
+ (FLASH_SECTOR_SIZE_SIG == Adapter->psFlash2xCSInfo->FlashSectorSizeSig) &&
+ (BYTE_WRITE_SUPPORT == Adapter->psFlash2xCSInfo->FlashWriteSupportSize)) {
Adapter->ulFlashWriteSize = Adapter->psFlash2xCSInfo->FlashWriteSupportSize;
- Adapter->fpFlashWrite = flashByteWrite;
- Adapter->fpFlashWriteWithStatusCheck = flashByteWriteStatus;
- }
- else
- {
+ Adapter->fpFlashWrite = flashByteWrite;
+ Adapter->fpFlashWriteWithStatusCheck = flashByteWriteStatus;
+ } else {
Adapter->ulFlashWriteSize = MAX_RW_SIZE;
Adapter->fpFlashWrite = flashWrite;
- Adapter->fpFlashWriteWithStatusCheck = flashWriteStatus;
+ Adapter->fpFlashWriteWithStatusCheck = flashWriteStatus;
}
BcmGetFlashSectorSize(Adapter, Adapter->psFlash2xCSInfo->FlashSectorSizeSig,
- Adapter->psFlash2xCSInfo->FlashSectorSize);
+ Adapter->psFlash2xCSInfo->FlashSectorSize);
UpdateVendorInfo(Adapter);
BcmGetActiveISO(Adapter);
Adapter->uiFlashBaseAdd = Adapter->psFlash2xCSInfo->FlashBaseAddr & 0xFCFFFFFF;
Adapter->ulFlashControlSectionStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart;
-
}
/*
- Concerns: what if CS sector size does not match with this sector size ???
- what is the indication of AccessBitMap in CS in flash 2.x ????
- */
+ * Concerns: what if CS sector size does not match with this sector size ???
+ * what is the indication of AccessBitMap in CS in flash 2.x ????
+ */
Adapter->ulFlashID = BcmReadFlashRDID(Adapter);
-
Adapter->uiFlashLayoutMajorVersion = uiFlashLayoutMajorVersion;
-
- return STATUS_SUCCESS ;
+ return STATUS_SUCCESS;
}
-
-//-----------------------------------------------------------------------------
-// Procedure: BcmGetNvmType
-//
-// Description: Finds the type of NVM used.
-//
-// Arguments:
-// Adapter - ptr to Adapter object instance
-//
-// Returns:
-// NVM_TYPE
-//
-//-----------------------------------------------------------------------------
-
-static NVM_TYPE BcmGetNvmType(PMINI_ADAPTER Adapter)
+/*
+ * Procedure: BcmGetNvmType
+ *
+ * Description: Finds the type of NVM used.
+ *
+ * Arguments:
+ * Adapter - ptr to Adapter object instance
+ *
+ * Returns:
+ * NVM_TYPE
+ *
+ */
+
+static NVM_TYPE BcmGetNvmType(struct bcm_mini_adapter *Adapter)
{
- UINT uiData = 0;
+ unsigned int uiData = 0;
- BeceemEEPROMBulkRead(Adapter,&uiData,0x0,4);
- if(uiData == BECM)
- {
+ BeceemEEPROMBulkRead(Adapter, &uiData, 0x0, 4);
+ if (uiData == BECM)
return NVM_EEPROM;
- }
- //
- // Read control struct and get cal addresses before accessing the flash
- //
+
+ /*
+ * Read control struct and get cal addresses before accessing the flash
+ */
BcmGetFlashCSInfo(Adapter);
- BeceemFlashBulkRead(Adapter,&uiData,0x0 + Adapter->ulFlashCalStart,4);
- if(uiData == BECM)
- {
+ BeceemFlashBulkRead(Adapter, &uiData, 0x0 + Adapter->ulFlashCalStart, 4);
+ if (uiData == BECM)
return NVM_FLASH;
- }
-//
-// even if there is no valid signature on EEPROM/FLASH find out if they really exist.
-// if exist select it.
-//
- if(BcmGetEEPROMSize(Adapter))
- {
- return NVM_EEPROM;
- }
-
-//TBD for Flash.
+ /*
+ * even if there is no valid signature on EEPROM/FLASH find out if they really exist.
+ * if exist select it.
+ */
+ if (BcmGetEEPROMSize(Adapter))
+ return NVM_EEPROM;
+ /* TBD for Flash. */
return NVM_UNKNOWN;
}
-/**
-* BcmGetSectionValStartOffset - this will calculate the section's starting offset if section val is given
-* @Adapter : Drivers Private Data structure
-* @eFlashSectionVal : Flash secion value defined in enum FLASH2X_SECTION_VAL
-*
-* Return value:-
-* On success it return the start offset of the provided section val
-* On Failure -returns STATUS_FAILURE
-**/
-
-INT BcmGetSectionValStartOffset(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlashSectionVal)
+/*
+ * BcmGetSectionValStartOffset - this will calculate the section's starting offset if section val is given
+ * @Adapter : Drivers Private Data structure
+ * @eFlashSectionVal : Flash secion value defined in enum FLASH2X_SECTION_VAL
+ *
+ * Return value:-
+ * On success it return the start offset of the provided section val
+ * On Failure -returns STATUS_FAILURE
+ */
+
+int BcmGetSectionValStartOffset(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlashSectionVal)
{
/*
- * Considering all the section for which end offset can be calculated or directly given
- * in CS Structure. if matching case does not exist, return STATUS_FAILURE indicating section
- * endoffset can't be calculated or given in CS Structure.
- */
+ * Considering all the section for which end offset can be calculated or directly given
+ * in CS Structure. if matching case does not exist, return STATUS_FAILURE indicating section
+ * endoffset can't be calculated or given in CS Structure.
+ */
- INT SectStartOffset = 0 ;
+ int SectStartOffset = 0;
- SectStartOffset = INVALID_OFFSET ;
+ SectStartOffset = INVALID_OFFSET;
- if(IsSectionExistInVendorInfo(Adapter,eFlashSectionVal))
- {
+ if (IsSectionExistInVendorInfo(Adapter, eFlashSectionVal))
return Adapter->psFlash2xVendorInfo->VendorSection[eFlashSectionVal].OffsetFromZeroForSectionStart;
- }
- switch(eFlashSectionVal)
- {
- case ISO_IMAGE1 :
- if((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start != UNINIT_PTR_IN_CS) &&
- (IsNonCDLessDevice(Adapter) == FALSE))
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start);
- break;
- case ISO_IMAGE2 :
- if((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start != UNINIT_PTR_IN_CS) &&
- (IsNonCDLessDevice(Adapter) == FALSE))
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start);
- break;
- case DSD0 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart);
- break;
- case DSD1 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start);
- break;
- case DSD2 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start);
- break;
- case VSA0 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart);
- break;
- case VSA1 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start);
- break;
- case VSA2 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start);
- break;
- case SCSI :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware);
- break;
- case CONTROL_SECTION :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart);
- break;
- case ISO_IMAGE1_PART2 :
- if(Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start);
- break;
- case ISO_IMAGE1_PART3 :
- if(Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
- break;
- case ISO_IMAGE2_PART2 :
- if(Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start);
- break;
- case ISO_IMAGE2_PART3 :
- if(Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start != UNINIT_PTR_IN_CS)
- SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
- break;
- default :
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Section Does not exist in Flash 2.x");
- SectStartOffset = INVALID_OFFSET;
+ switch (eFlashSectionVal) {
+ case ISO_IMAGE1:
+ if ((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start != UNINIT_PTR_IN_CS) &&
+ (IsNonCDLessDevice(Adapter) == FALSE))
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start);
+ break;
+ case ISO_IMAGE2:
+ if ((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start != UNINIT_PTR_IN_CS) &&
+ (IsNonCDLessDevice(Adapter) == FALSE))
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start);
+ break;
+ case DSD0:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart);
+ break;
+ case DSD1:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start);
+ break;
+ case DSD2:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start);
+ break;
+ case VSA0:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart);
+ break;
+ case VSA1:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start);
+ break;
+ case VSA2:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start);
+ break;
+ case SCSI:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware);
+ break;
+ case CONTROL_SECTION:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart);
+ break;
+ case ISO_IMAGE1_PART2:
+ if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start);
+ break;
+ case ISO_IMAGE1_PART3:
+ if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
+ break;
+ case ISO_IMAGE2_PART2:
+ if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start);
+ break;
+ case ISO_IMAGE2_PART3:
+ if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start != UNINIT_PTR_IN_CS)
+ SectStartOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
+ break;
+ default:
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section Does not exist in Flash 2.x");
+ SectStartOffset = INVALID_OFFSET;
}
+
return SectStartOffset;
}
-/**
-* BcmGetSectionValEndOffset - this will calculate the section's Ending offset if section val is given
-* @Adapter : Drivers Private Data structure
-* @eFlashSectionVal : Flash secion value defined in enum FLASH2X_SECTION_VAL
-*
-* Return value:-
-* On success it return the end offset of the provided section val
-* On Failure -returns STATUS_FAILURE
-**/
-
-INT BcmGetSectionValEndOffset(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal)
+/*
+ * BcmGetSectionValEndOffset - this will calculate the section's Ending offset if section val is given
+ * @Adapter : Drivers Private Data structure
+ * @eFlashSectionVal : Flash secion value defined in enum FLASH2X_SECTION_VAL
+ *
+ * Return value:-
+ * On success it return the end offset of the provided section val
+ * On Failure -returns STATUS_FAILURE
+ */
+
+int BcmGetSectionValEndOffset(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal)
{
- INT SectEndOffset = 0 ;
- SectEndOffset = INVALID_OFFSET;
+ int SectEndOffset = 0;
- if(IsSectionExistInVendorInfo(Adapter,eFlash2xSectionVal))
- {
+ SectEndOffset = INVALID_OFFSET;
+ if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
return Adapter->psFlash2xVendorInfo->VendorSection[eFlash2xSectionVal].OffsetFromZeroForSectionEnd;
- }
- switch(eFlash2xSectionVal)
- {
- case ISO_IMAGE1 :
- if((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End!= UNINIT_PTR_IN_CS) &&
- (IsNonCDLessDevice(Adapter) == FALSE))
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End);
- break;
- case ISO_IMAGE2 :
- if((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End!= UNINIT_PTR_IN_CS) &&
- (IsNonCDLessDevice(Adapter) == FALSE))
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End);
- break;
- case DSD0 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd != UNINIT_PTR_IN_CS)
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd);
- break;
- case DSD1 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End != UNINIT_PTR_IN_CS)
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End);
- break;
- case DSD2 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End != UNINIT_PTR_IN_CS)
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End);
- break;
- case VSA0 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd != UNINIT_PTR_IN_CS)
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd);
- break;
- case VSA1 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End != UNINIT_PTR_IN_CS)
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End);
- break;
- case VSA2 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End != UNINIT_PTR_IN_CS)
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End);
- break;
- case SCSI :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
- SectEndOffset = ((Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware) +
+ switch (eFlash2xSectionVal) {
+ case ISO_IMAGE1:
+ if ((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End != UNINIT_PTR_IN_CS) &&
+ (IsNonCDLessDevice(Adapter) == FALSE))
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End);
+ break;
+ case ISO_IMAGE2:
+ if ((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End != UNINIT_PTR_IN_CS) &&
+ (IsNonCDLessDevice(Adapter) == FALSE))
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End);
+ break;
+ case DSD0:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd != UNINIT_PTR_IN_CS)
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDEnd);
+ break;
+ case DSD1:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End != UNINIT_PTR_IN_CS)
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1End);
+ break;
+ case DSD2:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End != UNINIT_PTR_IN_CS)
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2End);
+ break;
+ case VSA0:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd != UNINIT_PTR_IN_CS)
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAEnd);
+ break;
+ case VSA1:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End != UNINIT_PTR_IN_CS)
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1End);
+ break;
+ case VSA2:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End != UNINIT_PTR_IN_CS)
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2End);
+ break;
+ case SCSI:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
+ SectEndOffset = ((Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware) +
(Adapter->psFlash2xCSInfo->SizeOfScsiFirmware));
- break;
- case CONTROL_SECTION :
- //Not Clear So Putting failure. confirm and fix it.
- SectEndOffset = STATUS_FAILURE;
- case ISO_IMAGE1_PART2 :
- if(Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End!= UNINIT_PTR_IN_CS)
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End);
- break;
- case ISO_IMAGE1_PART3 :
- if(Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End!= UNINIT_PTR_IN_CS)
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End);
- break;
- case ISO_IMAGE2_PART2 :
- if(Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End != UNINIT_PTR_IN_CS)
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End);
- break;
- case ISO_IMAGE2_PART3 :
- if(Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End!= UNINIT_PTR_IN_CS)
- SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End);
- break;
-
- default :
- SectEndOffset = INVALID_OFFSET;
+ break;
+ case CONTROL_SECTION:
+ /* Not Clear So Putting failure. confirm and fix it. */
+ SectEndOffset = STATUS_FAILURE;
+ case ISO_IMAGE1_PART2:
+ if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End != UNINIT_PTR_IN_CS)
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End);
+ break;
+ case ISO_IMAGE1_PART3:
+ if (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End != UNINIT_PTR_IN_CS)
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End);
+ break;
+ case ISO_IMAGE2_PART2:
+ if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End != UNINIT_PTR_IN_CS)
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End);
+ break;
+ case ISO_IMAGE2_PART3:
+ if (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End != UNINIT_PTR_IN_CS)
+ SectEndOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End);
+ break;
+ default:
+ SectEndOffset = INVALID_OFFSET;
}
+
return SectEndOffset ;
}
/*
-* BcmFlash2xBulkRead:- Read API for Flash Map 2.x .
-* @Adapter :Driver Private Data Structure
-* @pBuffer : Buffer where data has to be put after reading
-* @eFlashSectionVal :Flash Section Val defined in FLASH2X_SECTION_VAL
-* @uiOffsetWithinSectionVal :- Offset with in provided section
-* @uiNumBytes : Number of Bytes for Read
-*
-* Return value:-
-* return true on success and STATUS_FAILURE on fail.
-*/
-
-INT BcmFlash2xBulkRead(
- PMINI_ADAPTER Adapter,
- PUINT pBuffer,
- FLASH2X_SECTION_VAL eFlash2xSectionVal,
- UINT uiOffsetWithinSectionVal,
- UINT uiNumBytes)
+ * BcmFlash2xBulkRead:- Read API for Flash Map 2.x .
+ * @Adapter :Driver Private Data Structure
+ * @pBuffer : Buffer where data has to be put after reading
+ * @eFlashSectionVal :Flash Section Val defined in FLASH2X_SECTION_VAL
+ * @uiOffsetWithinSectionVal :- Offset with in provided section
+ * @uiNumBytes : Number of Bytes for Read
+ *
+ * Return value:-
+ * return true on success and STATUS_FAILURE on fail.
+ */
+
+int BcmFlash2xBulkRead(struct bcm_mini_adapter *Adapter,
+ PUINT pBuffer,
+ FLASH2X_SECTION_VAL eFlash2xSectionVal,
+ unsigned int uiOffsetWithinSectionVal,
+ unsigned int uiNumBytes)
{
+ int Status = STATUS_SUCCESS;
+ int SectionStartOffset = 0;
+ unsigned int uiAbsoluteOffset = 0;
+ unsigned int uiTemp = 0, value = 0;
- INT Status = STATUS_SUCCESS;
- INT SectionStartOffset = 0;
- UINT uiAbsoluteOffset = 0 ;
- UINT uiTemp =0, value =0 ;
- if(Adapter == NULL)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Adapter structure is NULL");
+ if (!Adapter) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure is NULL");
return -EINVAL;
}
- if(Adapter->device_removed )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device has been removed");
+ if (Adapter->device_removed) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device has been removed");
return -ENODEV;
}
- //NO_SECTION_VAL means absolute offset is given.
- if(eFlash2xSectionVal == NO_SECTION_VAL)
+ /* NO_SECTION_VAL means absolute offset is given. */
+ if (eFlash2xSectionVal == NO_SECTION_VAL)
SectionStartOffset = 0;
else
- SectionStartOffset = BcmGetSectionValStartOffset(Adapter,eFlash2xSectionVal);
+ SectionStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectionVal);
- if(SectionStartOffset == STATUS_FAILURE )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"This Section<%d> does not exixt in Flash 2.x Map ",eFlash2xSectionVal);
+ if (SectionStartOffset == STATUS_FAILURE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "This Section<%d> does not exixt in Flash 2.x Map ", eFlash2xSectionVal);
return -EINVAL;
}
- if(IsSectionExistInVendorInfo(Adapter,eFlash2xSectionVal))
- return vendorextnReadSection(Adapter,(PUCHAR)pBuffer, eFlash2xSectionVal, uiOffsetWithinSectionVal, uiNumBytes);
+ if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
+ return vendorextnReadSection(Adapter, (PUCHAR)pBuffer, eFlash2xSectionVal, uiOffsetWithinSectionVal, uiNumBytes);
- //calculating the absolute offset from FLASH;
+ /* calculating the absolute offset from FLASH; */
uiAbsoluteOffset = uiOffsetWithinSectionVal + SectionStartOffset;
rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
value = 0;
- wrmalt(Adapter, 0x0f000C80,&value, sizeof(value));
-
- Status= BeceemFlashBulkRead(Adapter, pBuffer,uiAbsoluteOffset,uiNumBytes) ;
-
+ wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
+ Status = BeceemFlashBulkRead(Adapter, pBuffer, uiAbsoluteOffset, uiNumBytes);
wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Flash Read Failed with Status :%d", Status);
- return Status ;
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Read Failed with Status :%d", Status);
+ return Status;
}
return Status;
}
/*
-* BcmFlash2xBulkWrite :-API for Writing on the Flash Map 2.x.
-* @Adapter :Driver Private Data Structure
-* @pBuffer : Buffer From where data has to taken for writing
-* @eFlashSectionVal :Flash Section Val defined in FLASH2X_SECTION_VAL
-* @uiOffsetWithinSectionVal :- Offset with in provided section
-* @uiNumBytes : Number of Bytes for Write
-*
-* Return value:-
-* return true on success and STATUS_FAILURE on fail.
-*
-*/
-
-INT BcmFlash2xBulkWrite(
- PMINI_ADAPTER Adapter,
- PUINT pBuffer,
- FLASH2X_SECTION_VAL eFlash2xSectVal,
- UINT uiOffset,
- UINT uiNumBytes,
- UINT bVerify)
+ * BcmFlash2xBulkWrite :-API for Writing on the Flash Map 2.x.
+ * @Adapter :Driver Private Data Structure
+ * @pBuffer : Buffer From where data has to taken for writing
+ * @eFlashSectionVal :Flash Section Val defined in FLASH2X_SECTION_VAL
+ * @uiOffsetWithinSectionVal :- Offset with in provided section
+ * @uiNumBytes : Number of Bytes for Write
+ *
+ * Return value:-
+ * return true on success and STATUS_FAILURE on fail.
+ *
+ */
+
+int BcmFlash2xBulkWrite(struct bcm_mini_adapter *Adapter,
+ PUINT pBuffer,
+ FLASH2X_SECTION_VAL eFlash2xSectVal,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes,
+ unsigned int bVerify)
{
+ int Status = STATUS_SUCCESS;
+ unsigned int FlashSectValStartOffset = 0;
+ unsigned int uiTemp = 0, value = 0;
- INT Status = STATUS_SUCCESS;
- UINT FlashSectValStartOffset = 0;
- UINT uiTemp = 0, value = 0;
- if(Adapter == NULL)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Adapter structure is NULL");
+ if (!Adapter) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Adapter structure is NULL");
return -EINVAL;
}
- if(Adapter->device_removed )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device has been removed");
+
+ if (Adapter->device_removed) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device has been removed");
return -ENODEV;
}
- //NO_SECTION_VAL means absolute offset is given.
- if(eFlash2xSectVal == NO_SECTION_VAL)
+ /* NO_SECTION_VAL means absolute offset is given. */
+ if (eFlash2xSectVal == NO_SECTION_VAL)
FlashSectValStartOffset = 0;
else
- FlashSectValStartOffset = BcmGetSectionValStartOffset(Adapter,eFlash2xSectVal);
+ FlashSectValStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectVal);
- if(FlashSectValStartOffset == STATUS_FAILURE )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"This Section<%d> does not exixt in Flash Map 2.x",eFlash2xSectVal);
+ if (FlashSectValStartOffset == STATUS_FAILURE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "This Section<%d> does not exixt in Flash Map 2.x", eFlash2xSectVal);
return -EINVAL;
}
- if(IsSectionExistInVendorInfo(Adapter,eFlash2xSectVal))
+ if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectVal))
return vendorextnWriteSection(Adapter, (PUCHAR)pBuffer, eFlash2xSectVal, uiOffset, uiNumBytes, bVerify);
- //calculating the absolute offset from FLASH;
+ /* calculating the absolute offset from FLASH; */
uiOffset = uiOffset + FlashSectValStartOffset;
rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
value = 0;
- wrmalt(Adapter, 0x0f000C80,&value, sizeof(value));
+ wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
- Status = BeceemFlashBulkWrite(Adapter, pBuffer,uiOffset,uiNumBytes,bVerify);
+ Status = BeceemFlashBulkWrite(Adapter, pBuffer, uiOffset, uiNumBytes, bVerify);
wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Flash Write failed with Status :%d", Status);
- return Status ;
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Write failed with Status :%d", Status);
+ return Status;
}
return Status;
-
}
-/**
-* BcmGetActiveDSD : Set the Active DSD in Adapter Structure which has to be dumped in DDR
-* @Adapter :-Drivers private Data Structure
-*
-* Return Value:-
-* Return STATUS_SUCESS if get success in setting the right DSD else negaive error code
-*
-**/
-static INT BcmGetActiveDSD(PMINI_ADAPTER Adapter)
+/*
+ * BcmGetActiveDSD : Set the Active DSD in Adapter Structure which has to be dumped in DDR
+ * @Adapter :-Drivers private Data Structure
+ *
+ * Return Value:-
+ * Return STATUS_SUCESS if get success in setting the right DSD else negaive error code
+ *
+ */
+
+static int BcmGetActiveDSD(struct bcm_mini_adapter *Adapter)
{
- FLASH2X_SECTION_VAL uiHighestPriDSD = 0 ;
+ FLASH2X_SECTION_VAL uiHighestPriDSD = 0;
uiHighestPriDSD = getHighestPriDSD(Adapter);
Adapter->eActiveDSD = uiHighestPriDSD;
- if(DSD0 == uiHighestPriDSD)
+ if (DSD0 == uiHighestPriDSD)
Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart;
- if(DSD1 == uiHighestPriDSD)
+ if (DSD1 == uiHighestPriDSD)
Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start;
- if(DSD2 == uiHighestPriDSD)
+ if (DSD2 == uiHighestPriDSD)
Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start;
- if(Adapter->eActiveDSD)
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Active DSD :%d", Adapter->eActiveDSD);
- if(Adapter->eActiveDSD == 0)
- {
- //if No DSD gets Active, Make Active the DSD with WR permission
- if(IsSectionWritable(Adapter,DSD2))
- {
+ if (Adapter->eActiveDSD)
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Active DSD :%d", Adapter->eActiveDSD);
+ if (Adapter->eActiveDSD == 0) {
+ /* if No DSD gets Active, Make Active the DSD with WR permission */
+ if (IsSectionWritable(Adapter, DSD2)) {
Adapter->eActiveDSD = DSD2;
Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start;
- }
- else if(IsSectionWritable(Adapter,DSD1))
- {
+ } else if (IsSectionWritable(Adapter, DSD1)) {
Adapter->eActiveDSD = DSD1;
Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start;
- }
- else if(IsSectionWritable(Adapter,DSD0))
- {
+ } else if (IsSectionWritable(Adapter, DSD0)) {
Adapter->eActiveDSD = DSD0;
Adapter->ulFlashCalStart = Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart;
}
return STATUS_SUCCESS;
}
-
-/**
-* BcmGetActiveISO :- Set the Active ISO in Adapter Data Structue
-* @Adapter : Driver private Data Structure
-*
-* Return Value:-
-* Sucsess:- STATUS_SUCESS
-* Failure- : negative erro code
-*
-**/
-
-static INT BcmGetActiveISO(PMINI_ADAPTER Adapter)
+/*
+ * BcmGetActiveISO :- Set the Active ISO in Adapter Data Structue
+ * @Adapter : Driver private Data Structure
+ *
+ * Return Value:-
+ * Sucsess:- STATUS_SUCESS
+ * Failure- : negative erro code
+ *
+ */
+
+static int BcmGetActiveISO(struct bcm_mini_adapter *Adapter)
{
+ int HighestPriISO = 0;
- INT HighestPriISO = 0 ;
HighestPriISO = getHighestPriISO(Adapter);
- Adapter->eActiveISO = HighestPriISO ;
- if(Adapter->eActiveISO == ISO_IMAGE2)
+ Adapter->eActiveISO = HighestPriISO;
+ if (Adapter->eActiveISO == ISO_IMAGE2)
Adapter->uiActiveISOOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start);
- else if(Adapter->eActiveISO == ISO_IMAGE1)
+ else if (Adapter->eActiveISO == ISO_IMAGE1)
Adapter->uiActiveISOOffset = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start);
- if(Adapter->eActiveISO)
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Active ISO :%x", Adapter->eActiveISO);
+ if (Adapter->eActiveISO)
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Active ISO :%x", Adapter->eActiveISO);
return STATUS_SUCCESS;
}
-/**
-* IsOffsetWritable :- it will tell the access permission of the sector having passed offset
-* @Adapter : Drivers Private Data Structure
-* @uiOffset : Offset provided in the Flash
-*
-* Return Value:-
-* Success:-TRUE , offset is writable
-* Failure:-FALSE, offset is RO
-*
-**/
-B_UINT8 IsOffsetWritable(PMINI_ADAPTER Adapter, UINT uiOffset)
+/*
+ * IsOffsetWritable :- it will tell the access permission of the sector having passed offset
+ * @Adapter : Drivers Private Data Structure
+ * @uiOffset : Offset provided in the Flash
+ *
+ * Return Value:-
+ * Success:-TRUE , offset is writable
+ * Failure:-FALSE, offset is RO
+ *
+ */
+
+B_UINT8 IsOffsetWritable(struct bcm_mini_adapter *Adapter, unsigned int uiOffset)
{
- UINT uiSectorNum = 0;
- UINT uiWordOfSectorPermission =0;
- UINT uiBitofSectorePermission = 0;
+ unsigned int uiSectorNum = 0;
+ unsigned int uiWordOfSectorPermission = 0;
+ unsigned int uiBitofSectorePermission = 0;
B_UINT32 permissionBits = 0;
+
uiSectorNum = uiOffset/Adapter->uiSectorSize;
- //calculating the word having this Sector Access permission from SectorAccessBitMap Array
- uiWordOfSectorPermission = Adapter->psFlash2xCSInfo->SectorAccessBitMap[uiSectorNum /16];
+ /* calculating the word having this Sector Access permission from SectorAccessBitMap Array */
+ uiWordOfSectorPermission = Adapter->psFlash2xCSInfo->SectorAccessBitMap[uiSectorNum / 16];
- //calculating the bit index inside the word for this sector
- uiBitofSectorePermission = 2*(15 - uiSectorNum %16);
+ /* calculating the bit index inside the word for this sector */
+ uiBitofSectorePermission = 2 * (15 - uiSectorNum % 16);
- //Setting Access permission
- permissionBits = uiWordOfSectorPermission & (0x3 << uiBitofSectorePermission) ;
+ /* Setting Access permission */
+ permissionBits = uiWordOfSectorPermission & (0x3 << uiBitofSectorePermission);
permissionBits = (permissionBits >> uiBitofSectorePermission) & 0x3;
- if(permissionBits == SECTOR_READWRITE_PERMISSION)
- return TRUE;
+ if (permissionBits == SECTOR_READWRITE_PERMISSION)
+ return TRUE;
else
return FALSE;
}
-static INT BcmDumpFlash2xSectionBitMap(PFLASH2X_BITMAP psFlash2xBitMap)
+static int BcmDumpFlash2xSectionBitMap(PFLASH2X_BITMAP psFlash2xBitMap)
{
- PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "***************Flash 2.x Section Bitmap***************");
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"ISO_IMAGE1 :0X%x", psFlash2xBitMap->ISO_IMAGE1);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"ISO_IMAGE2 :0X%x", psFlash2xBitMap->ISO_IMAGE2);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"DSD0 :0X%x", psFlash2xBitMap->DSD0);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"DSD1 :0X%x", psFlash2xBitMap->DSD1);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"DSD2 :0X%x", psFlash2xBitMap->DSD2);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"VSA0 :0X%x", psFlash2xBitMap->VSA0);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"VSA1 :0X%x", psFlash2xBitMap->VSA1);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"VSA2 :0X%x", psFlash2xBitMap->VSA2);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"SCSI :0X%x", psFlash2xBitMap->SCSI);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"CONTROL_SECTION :0X%x", psFlash2xBitMap->CONTROL_SECTION);
+ struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
+
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "***************Flash 2.x Section Bitmap***************");
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO_IMAGE1 :0X%x", psFlash2xBitMap->ISO_IMAGE1);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO_IMAGE2 :0X%x", psFlash2xBitMap->ISO_IMAGE2);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD0 :0X%x", psFlash2xBitMap->DSD0);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD1 :0X%x", psFlash2xBitMap->DSD1);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD2 :0X%x", psFlash2xBitMap->DSD2);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "VSA0 :0X%x", psFlash2xBitMap->VSA0);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "VSA1 :0X%x", psFlash2xBitMap->VSA1);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "VSA2 :0X%x", psFlash2xBitMap->VSA2);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SCSI :0X%x", psFlash2xBitMap->SCSI);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "CONTROL_SECTION :0X%x", psFlash2xBitMap->CONTROL_SECTION);
return STATUS_SUCCESS;
}
-/**
-* BcmGetFlash2xSectionalBitMap :- It will provide the bit map of all the section present in Flash
-* 8bit has been assigned to every section.
- bit[0] :Section present or not
- bit[1] :section is valid or not
- bit[2] : Secton is read only or has write permission too.
- bit[3] : Active Section -
- bit[7...4] = Reserved .
-
- @Adapter:-Driver private Data Structure
-*
-* Return value:-
-* Success:- STATUS_SUCESS
-* Failure:- negative error code
-**/
-
-INT BcmGetFlash2xSectionalBitMap(PMINI_ADAPTER Adapter, PFLASH2X_BITMAP psFlash2xBitMap)
+/*
+ * BcmGetFlash2xSectionalBitMap :- It will provide the bit map of all the section present in Flash
+ * 8bit has been assigned to every section.
+ * bit[0] :Section present or not
+ * bit[1] :section is valid or not
+ * bit[2] : Secton is read only or has write permission too.
+ * bit[3] : Active Section -
+ * bit[7...4] = Reserved .
+ *
+ * @Adapter:-Driver private Data Structure
+ *
+ * Return value:-
+ * Success:- STATUS_SUCESS
+ * Failure:- negative error code
+ */
+
+int BcmGetFlash2xSectionalBitMap(struct bcm_mini_adapter *Adapter, PFLASH2X_BITMAP psFlash2xBitMap)
{
-
-
PFLASH2X_CS_INFO psFlash2xCSInfo = Adapter->psFlash2xCSInfo;
- FLASH2X_SECTION_VAL uiHighestPriDSD = 0 ;
- FLASH2X_SECTION_VAL uiHighestPriISO= 0 ;
- BOOLEAN SetActiveDSDDone = FALSE ;
- BOOLEAN SetActiveISODone = FALSE ;
-
- //For 1.x map all the section except DSD0 will be shown as not present
- //This part will be used by calibration tool to detect the number of DSD present in Flash.
- if(IsFlash2x(Adapter) == FALSE)
- {
+ FLASH2X_SECTION_VAL uiHighestPriDSD = 0;
+ FLASH2X_SECTION_VAL uiHighestPriISO = 0;
+ BOOLEAN SetActiveDSDDone = FALSE;
+ BOOLEAN SetActiveISODone = FALSE;
+
+ /* For 1.x map all the section except DSD0 will be shown as not present
+ * This part will be used by calibration tool to detect the number of DSD present in Flash.
+ */
+ if (IsFlash2x(Adapter) == FALSE) {
psFlash2xBitMap->ISO_IMAGE2 = 0;
psFlash2xBitMap->ISO_IMAGE1 = 0;
- psFlash2xBitMap->DSD0 = FLASH2X_SECTION_VALID | FLASH2X_SECTION_ACT | FLASH2X_SECTION_PRESENT; //0xF; //0000(Reseved)1(Active)0(RW)1(valid)1(present)
- psFlash2xBitMap->DSD1 = 0 ;
- psFlash2xBitMap->DSD2 = 0 ;
- psFlash2xBitMap->VSA0 = 0 ;
- psFlash2xBitMap->VSA1 = 0 ;
- psFlash2xBitMap->VSA2 = 0 ;
- psFlash2xBitMap->CONTROL_SECTION = 0 ;
- psFlash2xBitMap->SCSI= 0 ;
- psFlash2xBitMap->Reserved0 = 0 ;
- psFlash2xBitMap->Reserved1 = 0 ;
- psFlash2xBitMap->Reserved2 = 0 ;
- return STATUS_SUCCESS ;
+ psFlash2xBitMap->DSD0 = FLASH2X_SECTION_VALID | FLASH2X_SECTION_ACT | FLASH2X_SECTION_PRESENT; /* 0xF; 0000(Reseved)1(Active)0(RW)1(valid)1(present) */
+ psFlash2xBitMap->DSD1 = 0;
+ psFlash2xBitMap->DSD2 = 0;
+ psFlash2xBitMap->VSA0 = 0;
+ psFlash2xBitMap->VSA1 = 0;
+ psFlash2xBitMap->VSA2 = 0;
+ psFlash2xBitMap->CONTROL_SECTION = 0;
+ psFlash2xBitMap->SCSI = 0;
+ psFlash2xBitMap->Reserved0 = 0;
+ psFlash2xBitMap->Reserved1 = 0;
+ psFlash2xBitMap->Reserved2 = 0;
+ return STATUS_SUCCESS;
}
uiHighestPriDSD = getHighestPriDSD(Adapter);
uiHighestPriISO = getHighestPriISO(Adapter);
- ///
- // IS0 IMAGE 2
- ///
- if((psFlash2xCSInfo->OffsetISOImage2Part1Start) != UNINIT_PTR_IN_CS)
- {
- //Setting the 0th Bit representing the Section is present or not.
- psFlash2xBitMap->ISO_IMAGE2= psFlash2xBitMap->ISO_IMAGE2 | FLASH2X_SECTION_PRESENT;
-
+ /*
+ * IS0 IMAGE 2
+ */
+ if ((psFlash2xCSInfo->OffsetISOImage2Part1Start) != UNINIT_PTR_IN_CS) {
+ /* Setting the 0th Bit representing the Section is present or not. */
+ psFlash2xBitMap->ISO_IMAGE2 = psFlash2xBitMap->ISO_IMAGE2 | FLASH2X_SECTION_PRESENT;
- if(ReadISOSignature(Adapter,ISO_IMAGE2)== ISO_IMAGE_MAGIC_NUMBER)
+ if (ReadISOSignature(Adapter, ISO_IMAGE2) == ISO_IMAGE_MAGIC_NUMBER)
psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_VALID;
-
- //Calculation for extrating the Access permission
- if(IsSectionWritable(Adapter, ISO_IMAGE2) == FALSE)
+ /* Calculation for extrating the Access permission */
+ if (IsSectionWritable(Adapter, ISO_IMAGE2) == FALSE)
psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_RO;
- if(SetActiveISODone == FALSE && uiHighestPriISO == ISO_IMAGE2)
- {
- psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_ACT ;
+ if (SetActiveISODone == FALSE && uiHighestPriISO == ISO_IMAGE2) {
+ psFlash2xBitMap->ISO_IMAGE2 |= FLASH2X_SECTION_ACT;
SetActiveISODone = TRUE;
}
-
}
- ///
- // IS0 IMAGE 1
- ///
- if((psFlash2xCSInfo->OffsetISOImage1Part1Start) != UNINIT_PTR_IN_CS)
- {
- //Setting the 0th Bit representing the Section is present or not.
+ /*
+ * IS0 IMAGE 1
+ */
+ if ((psFlash2xCSInfo->OffsetISOImage1Part1Start) != UNINIT_PTR_IN_CS) {
+ /* Setting the 0th Bit representing the Section is present or not. */
psFlash2xBitMap->ISO_IMAGE1 = psFlash2xBitMap->ISO_IMAGE1 | FLASH2X_SECTION_PRESENT;
- if(ReadISOSignature(Adapter,ISO_IMAGE1) == ISO_IMAGE_MAGIC_NUMBER)
+ if (ReadISOSignature(Adapter, ISO_IMAGE1) == ISO_IMAGE_MAGIC_NUMBER)
psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_VALID;
- // Calculation for extrating the Access permission
- if(IsSectionWritable(Adapter, ISO_IMAGE1) == FALSE)
+ /* Calculation for extrating the Access permission */
+ if (IsSectionWritable(Adapter, ISO_IMAGE1) == FALSE)
psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_RO;
- if(SetActiveISODone == FALSE && uiHighestPriISO == ISO_IMAGE1)
- {
- psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_ACT ;
+ if (SetActiveISODone == FALSE && uiHighestPriISO == ISO_IMAGE1) {
+ psFlash2xBitMap->ISO_IMAGE1 |= FLASH2X_SECTION_ACT;
SetActiveISODone = TRUE;
}
}
+ /*
+ * DSD2
+ */
+ if ((psFlash2xCSInfo->OffsetFromZeroForDSD2Start) != UNINIT_PTR_IN_CS) {
+ /* Setting the 0th Bit representing the Section is present or not. */
+ psFlash2xBitMap->DSD2 = psFlash2xBitMap->DSD2 | FLASH2X_SECTION_PRESENT;
-
- ///
- // DSD2
- ///
- if((psFlash2xCSInfo->OffsetFromZeroForDSD2Start) != UNINIT_PTR_IN_CS)
- {
- //Setting the 0th Bit representing the Section is present or not.
- psFlash2xBitMap->DSD2= psFlash2xBitMap->DSD2 | FLASH2X_SECTION_PRESENT;
-
- if(ReadDSDSignature(Adapter,DSD2)== DSD_IMAGE_MAGIC_NUMBER)
+ if (ReadDSDSignature(Adapter, DSD2) == DSD_IMAGE_MAGIC_NUMBER)
psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_VALID;
- //Calculation for extrating the Access permission
- if(IsSectionWritable(Adapter, DSD2) == FALSE)
- {
+ /* Calculation for extrating the Access permission */
+ if (IsSectionWritable(Adapter, DSD2) == FALSE) {
psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_RO;
-
- }
- else
- {
- //Means section is writable
- if((SetActiveDSDDone == FALSE) && (uiHighestPriDSD == DSD2))
- {
- psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_ACT ;
- SetActiveDSDDone =TRUE ;
+ } else {
+ /* Means section is writable */
+ if ((SetActiveDSDDone == FALSE) && (uiHighestPriDSD == DSD2)) {
+ psFlash2xBitMap->DSD2 |= FLASH2X_SECTION_ACT;
+ SetActiveDSDDone = TRUE;
}
}
}
- ///
- // DSD 1
- ///
- if((psFlash2xCSInfo->OffsetFromZeroForDSD1Start) != UNINIT_PTR_IN_CS)
- {
- //Setting the 0th Bit representing the Section is present or not.
- psFlash2xBitMap->DSD1= psFlash2xBitMap->DSD1 | FLASH2X_SECTION_PRESENT;
-
+ /*
+ * DSD 1
+ */
+ if ((psFlash2xCSInfo->OffsetFromZeroForDSD1Start) != UNINIT_PTR_IN_CS) {
+ /* Setting the 0th Bit representing the Section is present or not. */
+ psFlash2xBitMap->DSD1 = psFlash2xBitMap->DSD1 | FLASH2X_SECTION_PRESENT;
- if(ReadDSDSignature(Adapter,DSD1)== DSD_IMAGE_MAGIC_NUMBER)
+ if (ReadDSDSignature(Adapter, DSD1) == DSD_IMAGE_MAGIC_NUMBER)
psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_VALID;
- //Calculation for extrating the Access permission
- if(IsSectionWritable(Adapter, DSD1) == FALSE)
- {
+ /* Calculation for extrating the Access permission */
+ if (IsSectionWritable(Adapter, DSD1) == FALSE) {
psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_RO;
- }
- else
- {
- //Means section is writable
- if((SetActiveDSDDone == FALSE) && (uiHighestPriDSD == DSD1))
- {
- psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_ACT ;
- SetActiveDSDDone =TRUE ;
+ } else {
+ /* Means section is writable */
+ if ((SetActiveDSDDone == FALSE) && (uiHighestPriDSD == DSD1)) {
+ psFlash2xBitMap->DSD1 |= FLASH2X_SECTION_ACT;
+ SetActiveDSDDone = TRUE;
}
}
-
}
- ///
- //For DSD 0
- //
- if((psFlash2xCSInfo->OffsetFromZeroForDSDStart) != UNINIT_PTR_IN_CS)
- {
- //Setting the 0th Bit representing the Section is present or not.
+ /*
+ * For DSD 0
+ */
+ if ((psFlash2xCSInfo->OffsetFromZeroForDSDStart) != UNINIT_PTR_IN_CS) {
+ /* Setting the 0th Bit representing the Section is present or not. */
psFlash2xBitMap->DSD0 = psFlash2xBitMap->DSD0 | FLASH2X_SECTION_PRESENT;
- if(ReadDSDSignature(Adapter,DSD0) == DSD_IMAGE_MAGIC_NUMBER)
+ if (ReadDSDSignature(Adapter, DSD0) == DSD_IMAGE_MAGIC_NUMBER)
psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_VALID;
- //Setting Access permission
- if(IsSectionWritable(Adapter, DSD0) == FALSE)
- {
+ /* Setting Access permission */
+ if (IsSectionWritable(Adapter, DSD0) == FALSE) {
psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_RO;
- }
- else
- {
- //Means section is writable
- if((SetActiveDSDDone == FALSE) &&(uiHighestPriDSD == DSD0))
- {
- psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_ACT ;
- SetActiveDSDDone =TRUE ;
+ } else {
+ /* Means section is writable */
+ if ((SetActiveDSDDone == FALSE) && (uiHighestPriDSD == DSD0)) {
+ psFlash2xBitMap->DSD0 |= FLASH2X_SECTION_ACT;
+ SetActiveDSDDone = TRUE;
}
}
}
- ///
- // VSA 0
- ///
- if((psFlash2xCSInfo->OffsetFromZeroForVSAStart) != UNINIT_PTR_IN_CS)
- {
- //Setting the 0th Bit representing the Section is present or not.
- psFlash2xBitMap->VSA0= psFlash2xBitMap->VSA0 | FLASH2X_SECTION_PRESENT;
+ /*
+ * VSA 0
+ */
+ if ((psFlash2xCSInfo->OffsetFromZeroForVSAStart) != UNINIT_PTR_IN_CS) {
+ /* Setting the 0th Bit representing the Section is present or not. */
+ psFlash2xBitMap->VSA0 = psFlash2xBitMap->VSA0 | FLASH2X_SECTION_PRESENT;
- //Setting the Access Bit. Map is not defined hece setting it always valid
+ /* Setting the Access Bit. Map is not defined hece setting it always valid */
psFlash2xBitMap->VSA0 |= FLASH2X_SECTION_VALID;
- //Calculation for extrating the Access permission
- if(IsSectionWritable(Adapter, VSA0) == FALSE)
+ /* Calculation for extrating the Access permission */
+ if (IsSectionWritable(Adapter, VSA0) == FALSE)
psFlash2xBitMap->VSA0 |= FLASH2X_SECTION_RO;
- //By Default section is Active
- psFlash2xBitMap->VSA0 |= FLASH2X_SECTION_ACT ;
-
+ /* By Default section is Active */
+ psFlash2xBitMap->VSA0 |= FLASH2X_SECTION_ACT;
}
+ /*
+ * VSA 1
+ */
+ if ((psFlash2xCSInfo->OffsetFromZeroForVSA1Start) != UNINIT_PTR_IN_CS) {
+ /* Setting the 0th Bit representing the Section is present or not. */
+ psFlash2xBitMap->VSA1 = psFlash2xBitMap->VSA1 | FLASH2X_SECTION_PRESENT;
- ///
- // VSA 1
- ///
-
- if((psFlash2xCSInfo->OffsetFromZeroForVSA1Start) != UNINIT_PTR_IN_CS)
- {
- //Setting the 0th Bit representing the Section is present or not.
- psFlash2xBitMap->VSA1= psFlash2xBitMap->VSA1 | FLASH2X_SECTION_PRESENT;
-
- //Setting the Access Bit. Map is not defined hece setting it always valid
- psFlash2xBitMap->VSA1|= FLASH2X_SECTION_VALID;
+ /* Setting the Access Bit. Map is not defined hece setting it always valid */
+ psFlash2xBitMap->VSA1 |= FLASH2X_SECTION_VALID;
- //Checking For Access permission
- if(IsSectionWritable(Adapter, VSA1) == FALSE)
+ /* Checking For Access permission */
+ if (IsSectionWritable(Adapter, VSA1) == FALSE)
psFlash2xBitMap->VSA1 |= FLASH2X_SECTION_RO;
- //By Default section is Active
- psFlash2xBitMap->VSA1 |= FLASH2X_SECTION_ACT ;
-
+ /* By Default section is Active */
+ psFlash2xBitMap->VSA1 |= FLASH2X_SECTION_ACT;
}
+ /*
+ * VSA 2
+ */
+ if ((psFlash2xCSInfo->OffsetFromZeroForVSA2Start) != UNINIT_PTR_IN_CS) {
+ /* Setting the 0th Bit representing the Section is present or not. */
+ psFlash2xBitMap->VSA2 = psFlash2xBitMap->VSA2 | FLASH2X_SECTION_PRESENT;
- ///
- // VSA 2
- ///
-
- if((psFlash2xCSInfo->OffsetFromZeroForVSA2Start) != UNINIT_PTR_IN_CS)
- {
- //Setting the 0th Bit representing the Section is present or not.
- psFlash2xBitMap->VSA2= psFlash2xBitMap->VSA2 | FLASH2X_SECTION_PRESENT;
-
-
- //Setting the Access Bit. Map is not defined hece setting it always valid
+ /* Setting the Access Bit. Map is not defined hece setting it always valid */
psFlash2xBitMap->VSA2 |= FLASH2X_SECTION_VALID;
- //Checking For Access permission
- if(IsSectionWritable(Adapter, VSA2) == FALSE)
+ /* Checking For Access permission */
+ if (IsSectionWritable(Adapter, VSA2) == FALSE)
psFlash2xBitMap->VSA2 |= FLASH2X_SECTION_RO;
- //By Default section is Active
- psFlash2xBitMap->VSA2 |= FLASH2X_SECTION_ACT ;
+ /* By Default section is Active */
+ psFlash2xBitMap->VSA2 |= FLASH2X_SECTION_ACT;
}
- ///
- // SCSI Section
- ///
- if((psFlash2xCSInfo->OffsetFromZeroForScsiFirmware) != UNINIT_PTR_IN_CS)
- {
- //Setting the 0th Bit representing the Section is present or not.
- psFlash2xBitMap->SCSI= psFlash2xBitMap->SCSI | FLASH2X_SECTION_PRESENT;
-
+ /*
+ * SCSI Section
+ */
+ if ((psFlash2xCSInfo->OffsetFromZeroForScsiFirmware) != UNINIT_PTR_IN_CS) {
+ /* Setting the 0th Bit representing the Section is present or not. */
+ psFlash2xBitMap->SCSI = psFlash2xBitMap->SCSI | FLASH2X_SECTION_PRESENT;
- //Setting the Access Bit. Map is not defined hece setting it always valid
- psFlash2xBitMap->SCSI|= FLASH2X_SECTION_VALID;
+ /* Setting the Access Bit. Map is not defined hece setting it always valid */
+ psFlash2xBitMap->SCSI |= FLASH2X_SECTION_VALID;
- //Checking For Access permission
- if(IsSectionWritable(Adapter, SCSI) == FALSE)
+ /* Checking For Access permission */
+ if (IsSectionWritable(Adapter, SCSI) == FALSE)
psFlash2xBitMap->SCSI |= FLASH2X_SECTION_RO;
- //By Default section is Active
- psFlash2xBitMap->SCSI |= FLASH2X_SECTION_ACT ;
-
+ /* By Default section is Active */
+ psFlash2xBitMap->SCSI |= FLASH2X_SECTION_ACT;
}
-
- ///
- // Control Section
- ///
- if((psFlash2xCSInfo->OffsetFromZeroForControlSectionStart) != UNINIT_PTR_IN_CS)
- {
- //Setting the 0th Bit representing the Section is present or not.
+ /*
+ * Control Section
+ */
+ if ((psFlash2xCSInfo->OffsetFromZeroForControlSectionStart) != UNINIT_PTR_IN_CS) {
+ /* Setting the 0th Bit representing the Section is present or not. */
psFlash2xBitMap->CONTROL_SECTION = psFlash2xBitMap->CONTROL_SECTION | (FLASH2X_SECTION_PRESENT);
-
- //Setting the Access Bit. Map is not defined hece setting it always valid
+ /* Setting the Access Bit. Map is not defined hece setting it always valid */
psFlash2xBitMap->CONTROL_SECTION |= FLASH2X_SECTION_VALID;
- //Checking For Access permission
- if(IsSectionWritable(Adapter, CONTROL_SECTION) == FALSE)
+ /* Checking For Access permission */
+ if (IsSectionWritable(Adapter, CONTROL_SECTION) == FALSE)
psFlash2xBitMap->CONTROL_SECTION |= FLASH2X_SECTION_RO;
- //By Default section is Active
- psFlash2xBitMap->CONTROL_SECTION |= FLASH2X_SECTION_ACT ;
-
+ /* By Default section is Active */
+ psFlash2xBitMap->CONTROL_SECTION |= FLASH2X_SECTION_ACT;
}
- ///
- // For Reserved Sections
- ///
+ /*
+ * For Reserved Sections
+ */
psFlash2xBitMap->Reserved0 = 0;
psFlash2xBitMap->Reserved0 = 0;
psFlash2xBitMap->Reserved0 = 0;
-
BcmDumpFlash2xSectionBitMap(psFlash2xBitMap);
- return STATUS_SUCCESS ;
-
+ return STATUS_SUCCESS;
}
-/**
-BcmSetActiveSection :- Set Active section is used to make priority field highest over other
- section of same type.
-
-@Adapater :- Bcm Driver Private Data Structure
-@eFlash2xSectionVal :- Flash section val whose priority has to be made highest.
-
-Return Value:- Make the priorit highest else return erorr code
-**/
-INT BcmSetActiveSection(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectVal)
+/*
+ * BcmSetActiveSection :- Set Active section is used to make priority field highest over other
+ * section of same type.
+ *
+ * @Adapater :- Bcm Driver Private Data Structure
+ * @eFlash2xSectionVal :- Flash section val whose priority has to be made highest.
+ *
+ * Return Value:- Make the priorit highest else return erorr code
+ *
+ */
+
+int BcmSetActiveSection(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlash2xSectVal)
{
unsigned int SectImagePriority = 0;
- INT Status =STATUS_SUCCESS;
-
- //DSD_HEADER sDSD = {0};
- //ISO_HEADER sISO = {0};
- INT HighestPriDSD = 0 ;
- INT HighestPriISO = 0;
-
+ int Status = STATUS_SUCCESS;
+ /* DSD_HEADER sDSD = {0};
+ * ISO_HEADER sISO = {0};
+ */
+ int HighestPriDSD = 0 ;
+ int HighestPriISO = 0;
- Status = IsSectionWritable(Adapter,eFlash2xSectVal) ;
- if(Status != TRUE )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Provided Section <%d> is not writable",eFlash2xSectVal);
+ Status = IsSectionWritable(Adapter, eFlash2xSectVal);
+ if (Status != TRUE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Provided Section <%d> is not writable", eFlash2xSectVal);
return STATUS_FAILURE;
}
- Adapter->bHeaderChangeAllowed = TRUE ;
- switch(eFlash2xSectVal)
- {
- case ISO_IMAGE1 :
- case ISO_IMAGE2 :
- if(ReadISOSignature(Adapter,eFlash2xSectVal)== ISO_IMAGE_MAGIC_NUMBER )
- {
- HighestPriISO = getHighestPriISO(Adapter);
+ Adapter->bHeaderChangeAllowed = TRUE;
+ switch (eFlash2xSectVal) {
+ case ISO_IMAGE1:
+ case ISO_IMAGE2:
+ if (ReadISOSignature(Adapter, eFlash2xSectVal) == ISO_IMAGE_MAGIC_NUMBER) {
+ HighestPriISO = getHighestPriISO(Adapter);
+
+ if (HighestPriISO == eFlash2xSectVal) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given ISO<%x> already has highest priority", eFlash2xSectVal);
+ Status = STATUS_SUCCESS;
+ break;
+ }
+
+ SectImagePriority = ReadISOPriority(Adapter, HighestPriISO) + 1;
- if(HighestPriISO == eFlash2xSectVal )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Given ISO<%x> already has highest priority",eFlash2xSectVal );
- Status = STATUS_SUCCESS ;
+ if ((SectImagePriority <= 0) && IsSectionWritable(Adapter, HighestPriISO)) {
+ /* This is a SPECIAL Case which will only happen if the current highest priority ISO has priority value = 0x7FFFFFFF.
+ * We will write 1 to the current Highest priority ISO And then shall increase the priority of the requested ISO
+ * by user
+ */
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SectImagePriority wraparound happened, eFlash2xSectVal: 0x%x\n", eFlash2xSectVal);
+ SectImagePriority = htonl(0x1);
+ Status = BcmFlash2xBulkWrite(Adapter,
+ &SectImagePriority,
+ HighestPriISO,
+ 0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImagePriority),
+ SIGNATURE_SIZE,
+ TRUE);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
+ Status = STATUS_FAILURE;
break;
}
- SectImagePriority = ReadISOPriority(Adapter, HighestPriISO) + 1;
-
- if((SectImagePriority <= 0) && IsSectionWritable(Adapter,HighestPriISO))
- {
- // This is a SPECIAL Case which will only happen if the current highest priority ISO has priority value = 0x7FFFFFFF.
- // We will write 1 to the current Highest priority ISO And then shall increase the priority of the requested ISO
- // by user
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "SectImagePriority wraparound happened, eFlash2xSectVal: 0x%x\n",eFlash2xSectVal);
- SectImagePriority = htonl(0x1);
- Status = BcmFlash2xBulkWrite(Adapter,
- &SectImagePriority,
- HighestPriISO,
- 0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImagePriority),
- SIGNATURE_SIZE,
- TRUE);
-
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Priority has not been written properly");
- Status = STATUS_FAILURE;
- break ;
- }
-
- HighestPriISO = getHighestPriISO(Adapter);
-
- if(HighestPriISO == eFlash2xSectVal )
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Given ISO<%x> already has highest priority",eFlash2xSectVal );
- Status = STATUS_SUCCESS ;
- break;
- }
+ HighestPriISO = getHighestPriISO(Adapter);
- SectImagePriority = 2;
- }
+ if (HighestPriISO == eFlash2xSectVal) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given ISO<%x> already has highest priority", eFlash2xSectVal);
+ Status = STATUS_SUCCESS;
+ break;
+ }
+ SectImagePriority = 2;
+ }
- SectImagePriority = htonl(SectImagePriority);
+ SectImagePriority = htonl(SectImagePriority);
- Status = BcmFlash2xBulkWrite(Adapter,
- &SectImagePriority,
- eFlash2xSectVal,
- 0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImagePriority),
- SIGNATURE_SIZE,
- TRUE);
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Priority has not been written properly");
- break ;
- }
- }
- else
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Signature is currupted. Hence can't increase the priority");
- Status = STATUS_FAILURE ;
+ Status = BcmFlash2xBulkWrite(Adapter,
+ &SectImagePriority,
+ eFlash2xSectVal,
+ 0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImagePriority),
+ SIGNATURE_SIZE,
+ TRUE);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
break;
}
+ } else {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Signature is currupted. Hence can't increase the priority");
+ Status = STATUS_FAILURE;
break;
- case DSD0 :
- case DSD1 :
- case DSD2 :
- if(ReadDSDSignature(Adapter,eFlash2xSectVal)== DSD_IMAGE_MAGIC_NUMBER)
- {
- HighestPriDSD = getHighestPriDSD(Adapter);
+ }
+ break;
+ case DSD0:
+ case DSD1:
+ case DSD2:
+ if (ReadDSDSignature(Adapter, eFlash2xSectVal) == DSD_IMAGE_MAGIC_NUMBER) {
+ HighestPriDSD = getHighestPriDSD(Adapter);
+ if ((HighestPriDSD == eFlash2xSectVal)) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given DSD<%x> already has highest priority", eFlash2xSectVal);
+ Status = STATUS_SUCCESS;
+ break;
+ }
+
+ SectImagePriority = ReadDSDPriority(Adapter, HighestPriDSD) + 1;
+ if (SectImagePriority <= 0) {
+ /* This is a SPECIAL Case which will only happen if the current highest priority DSD has priority value = 0x7FFFFFFF.
+ * We will write 1 to the current Highest priority DSD And then shall increase the priority of the requested DSD
+ * by user
+ */
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, NVM_RW, DBG_LVL_ALL, "SectImagePriority wraparound happened, eFlash2xSectVal: 0x%x\n", eFlash2xSectVal);
+ SectImagePriority = htonl(0x1);
- if((HighestPriDSD == eFlash2xSectVal))
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Given DSD<%x> already has highest priority", eFlash2xSectVal);
- Status = STATUS_SUCCESS ;
+ Status = BcmFlash2xBulkWrite(Adapter,
+ &SectImagePriority,
+ HighestPriDSD,
+ Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImagePriority),
+ SIGNATURE_SIZE,
+ TRUE);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
break;
}
- SectImagePriority = ReadDSDPriority(Adapter, HighestPriDSD) + 1 ;
- if(SectImagePriority <= 0)
- {
- // This is a SPECIAL Case which will only happen if the current highest priority DSD has priority value = 0x7FFFFFFF.
- // We will write 1 to the current Highest priority DSD And then shall increase the priority of the requested DSD
- // by user
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, NVM_RW, DBG_LVL_ALL, "SectImagePriority wraparound happened, eFlash2xSectVal: 0x%x\n",eFlash2xSectVal);
- SectImagePriority = htonl(0x1);
-
- Status = BcmFlash2xBulkWrite(Adapter,
- &SectImagePriority,
- HighestPriDSD,
- Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImagePriority),
- SIGNATURE_SIZE,
- TRUE);
-
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
- break ;
- }
-
- HighestPriDSD = getHighestPriDSD(Adapter);
-
- if((HighestPriDSD == eFlash2xSectVal))
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Made the DSD: %x highest by reducing priority of other\n", eFlash2xSectVal);
- Status = STATUS_SUCCESS ;
- break;
- }
-
- SectImagePriority = htonl(0x2);
- Status = BcmFlash2xBulkWrite(Adapter,
- &SectImagePriority,
- HighestPriDSD,
- Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImagePriority),
- SIGNATURE_SIZE,
- TRUE);
-
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
- break ;
- }
-
- HighestPriDSD = getHighestPriDSD(Adapter);
-
- if((HighestPriDSD == eFlash2xSectVal))
- {
- Status = STATUS_SUCCESS ;
- break;
- }
- SectImagePriority = 3 ;
+ HighestPriDSD = getHighestPriDSD(Adapter);
+ if ((HighestPriDSD == eFlash2xSectVal)) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Made the DSD: %x highest by reducing priority of other\n", eFlash2xSectVal);
+ Status = STATUS_SUCCESS;
+ break;
}
- SectImagePriority = htonl(SectImagePriority);
+
+ SectImagePriority = htonl(0x2);
Status = BcmFlash2xBulkWrite(Adapter,
- &SectImagePriority,
- eFlash2xSectVal,
- Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImagePriority),
- SIGNATURE_SIZE ,
- TRUE);
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Priority has not been written properly");
- Status = STATUS_FAILURE ;
- break ;
+ &SectImagePriority,
+ HighestPriDSD,
+ Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImagePriority),
+ SIGNATURE_SIZE,
+ TRUE);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
+ break;
}
+
+ HighestPriDSD = getHighestPriDSD(Adapter);
+ if ((HighestPriDSD == eFlash2xSectVal)) {
+ Status = STATUS_SUCCESS;
+ break;
+ }
+
+ SectImagePriority = 3;
}
- else
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Signature is currupted. Hence can't increase the priority");
- Status = STATUS_FAILURE ;
+ SectImagePriority = htonl(SectImagePriority);
+ Status = BcmFlash2xBulkWrite(Adapter,
+ &SectImagePriority,
+ eFlash2xSectVal,
+ Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImagePriority),
+ SIGNATURE_SIZE,
+ TRUE);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Priority has not been written properly");
+ Status = STATUS_FAILURE;
break;
}
+ } else {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Signature is currupted. Hence can't increase the priority");
+ Status = STATUS_FAILURE;
break;
- case VSA0 :
- case VSA1 :
- case VSA2 :
- //Has to be decided
- break ;
- default :
- Status = STATUS_FAILURE ;
- break;
-
+ }
+ break;
+ case VSA0:
+ case VSA1:
+ case VSA2:
+ /* Has to be decided */
+ break;
+ default:
+ Status = STATUS_FAILURE;
+ break;
}
- Adapter->bHeaderChangeAllowed = FALSE ;
+ Adapter->bHeaderChangeAllowed = FALSE;
return Status;
-
}
-/**
-BcmCopyISO - Used only for copying the ISO section
-@Adapater :- Bcm Driver Private Data Structure
-@sCopySectStrut :- Section copy structure
-
-Return value:- SUCCESS if copies successfully else negative error code
-
-**/
-INT BcmCopyISO(PMINI_ADAPTER Adapter, FLASH2X_COPY_SECTION sCopySectStrut)
+/*
+ * BcmCopyISO - Used only for copying the ISO section
+ * @Adapater :- Bcm Driver Private Data Structure
+ * @sCopySectStrut :- Section copy structure
+ *
+ * Return value:- SUCCESS if copies successfully else negative error code
+ *
+ */
+
+int BcmCopyISO(struct bcm_mini_adapter *Adapter, FLASH2X_COPY_SECTION sCopySectStrut)
{
-
PCHAR Buff = NULL;
- FLASH2X_SECTION_VAL eISOReadPart = 0,eISOWritePart = 0;
- UINT uiReadOffsetWithinPart = 0, uiWriteOffsetWithinPart = 0;
- UINT uiTotalDataToCopy = 0;
- BOOLEAN IsThisHeaderSector = FALSE ;
- UINT sigOffset = 0;
- UINT ISOLength = 0;
- UINT Status = STATUS_SUCCESS;
- UINT SigBuff[MAX_RW_SIZE];
- UINT i = 0;
-
- if(ReadISOSignature(Adapter,sCopySectStrut.SrcSection) != ISO_IMAGE_MAGIC_NUMBER)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "error as Source ISO Section does not have valid signature");
+ FLASH2X_SECTION_VAL eISOReadPart = 0, eISOWritePart = 0;
+ unsigned int uiReadOffsetWithinPart = 0, uiWriteOffsetWithinPart = 0;
+ unsigned int uiTotalDataToCopy = 0;
+ BOOLEAN IsThisHeaderSector = FALSE;
+ unsigned int sigOffset = 0;
+ unsigned int ISOLength = 0;
+ unsigned int Status = STATUS_SUCCESS;
+ unsigned int SigBuff[MAX_RW_SIZE];
+ unsigned int i = 0;
+
+ if (ReadISOSignature(Adapter, sCopySectStrut.SrcSection) != ISO_IMAGE_MAGIC_NUMBER) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Source ISO Section does not have valid signature");
return STATUS_FAILURE;
}
Status = BcmFlash2xBulkRead(Adapter,
- &ISOLength,
- sCopySectStrut.SrcSection,
- 0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER,ISOImageSize),
- 4);
-
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO\n");
+ &ISOLength,
+ sCopySectStrut.SrcSection,
+ 0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImageSize),
+ 4);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO\n");
return Status;
}
ISOLength = htonl(ISOLength);
-
- if(ISOLength % Adapter->uiSectorSize)
- {
- ISOLength = Adapter->uiSectorSize*(1 + ISOLength/Adapter->uiSectorSize);
- }
+ if (ISOLength % Adapter->uiSectorSize)
+ ISOLength = Adapter->uiSectorSize * (1 + ISOLength/Adapter->uiSectorSize);
sigOffset = FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImageMagicNumber);
Buff = kzalloc(Adapter->uiSectorSize, GFP_KERNEL);
- if(Buff == NULL)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for section size");
- return -ENOMEM;
+ if (!Buff) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed for section size");
+ return -ENOMEM;
}
- if(sCopySectStrut.SrcSection ==ISO_IMAGE1 && sCopySectStrut.DstSection ==ISO_IMAGE2)
- {
- eISOReadPart = ISO_IMAGE1 ;
- eISOWritePart = ISO_IMAGE2 ;
+ if (sCopySectStrut.SrcSection == ISO_IMAGE1 && sCopySectStrut.DstSection == ISO_IMAGE2) {
+ eISOReadPart = ISO_IMAGE1;
+ eISOWritePart = ISO_IMAGE2;
uiReadOffsetWithinPart = 0;
- uiWriteOffsetWithinPart = 0 ;
-
- uiTotalDataToCopy =(Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start)+
- (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start)+
- (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
-
- if(uiTotalDataToCopy < ISOLength)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"error as Source ISO Section does not have valid signature");
+ uiWriteOffsetWithinPart = 0;
+
+ uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start) +
+ (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start) +
+ (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
+
+ if (uiTotalDataToCopy < ISOLength) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Source ISO Section does not have valid signature");
Status = STATUS_FAILURE;
goto out;
}
- uiTotalDataToCopy =(Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start)+
- (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start)+
- (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
+ uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start) +
+ (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start) +
+ (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
- if(uiTotalDataToCopy < ISOLength)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"error as Dest ISO Section does not have enough section size");
+ if (uiTotalDataToCopy < ISOLength) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Dest ISO Section does not have enough section size");
Status = STATUS_FAILURE;
goto out;
}
uiTotalDataToCopy = ISOLength;
- CorruptISOSig(Adapter,ISO_IMAGE2);
-
- while(uiTotalDataToCopy)
- {
- if(uiTotalDataToCopy == Adapter->uiSectorSize)
- {
- //Setting for write of first sector. First sector is assumed to be written in last
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Writing the signature sector");
- eISOReadPart = ISO_IMAGE1 ;
+ CorruptISOSig(Adapter, ISO_IMAGE2);
+ while (uiTotalDataToCopy) {
+ if (uiTotalDataToCopy == Adapter->uiSectorSize) {
+ /* Setting for write of first sector. First sector is assumed to be written in last */
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Writing the signature sector");
+ eISOReadPart = ISO_IMAGE1;
uiReadOffsetWithinPart = 0;
eISOWritePart = ISO_IMAGE2;
- uiWriteOffsetWithinPart = 0 ;
- IsThisHeaderSector = TRUE ;
-
- }
- else
- {
- uiReadOffsetWithinPart = uiReadOffsetWithinPart + Adapter->uiSectorSize ;
- uiWriteOffsetWithinPart = uiWriteOffsetWithinPart + Adapter->uiSectorSize ;
+ uiWriteOffsetWithinPart = 0;
+ IsThisHeaderSector = TRUE;
+ } else {
+ uiReadOffsetWithinPart = uiReadOffsetWithinPart + Adapter->uiSectorSize;
+ uiWriteOffsetWithinPart = uiWriteOffsetWithinPart + Adapter->uiSectorSize;
- if((eISOReadPart == ISO_IMAGE1) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start) ))
- {
- eISOReadPart = ISO_IMAGE1_PART2 ;
+ if ((eISOReadPart == ISO_IMAGE1) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start))) {
+ eISOReadPart = ISO_IMAGE1_PART2;
uiReadOffsetWithinPart = 0;
}
- if((eISOReadPart == ISO_IMAGE1_PART2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start)))
- {
- eISOReadPart = ISO_IMAGE1_PART3 ;
+
+ if ((eISOReadPart == ISO_IMAGE1_PART2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start))) {
+ eISOReadPart = ISO_IMAGE1_PART3;
uiReadOffsetWithinPart = 0;
}
- if((eISOWritePart == ISO_IMAGE2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start)))
- {
- eISOWritePart = ISO_IMAGE2_PART2 ;
+
+ if ((eISOWritePart == ISO_IMAGE2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start))) {
+ eISOWritePart = ISO_IMAGE2_PART2;
uiWriteOffsetWithinPart = 0;
}
- if((eISOWritePart == ISO_IMAGE2_PART2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start)))
- {
- eISOWritePart = ISO_IMAGE2_PART3 ;
+
+ if ((eISOWritePart == ISO_IMAGE2_PART2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start))) {
+ eISOWritePart = ISO_IMAGE2_PART3;
uiWriteOffsetWithinPart = 0;
}
}
Status = BcmFlash2xBulkRead(Adapter,
- (PUINT)Buff,
- eISOReadPart,
- uiReadOffsetWithinPart,
- Adapter->uiSectorSize
- );
-
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOReadPart, uiReadOffsetWithinPart);
+ (PUINT)Buff,
+ eISOReadPart,
+ uiReadOffsetWithinPart,
+ Adapter->uiSectorSize);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOReadPart, uiReadOffsetWithinPart);
break;
}
- if(IsThisHeaderSector == TRUE)
- {
- //If this is header sector write 0xFFFFFFFF at the sig time and in last write sig
+ if (IsThisHeaderSector == TRUE) {
+ /* If this is header sector write 0xFFFFFFFF at the sig time and in last write sig */
memcpy(SigBuff, Buff + sigOffset, MAX_RW_SIZE);
- for(i = 0; i < MAX_RW_SIZE;i++)
+ for (i = 0; i < MAX_RW_SIZE; i++)
*(Buff + sigOffset + i) = 0xFF;
}
- Adapter->bHeaderChangeAllowed = TRUE ;
-
+ Adapter->bHeaderChangeAllowed = TRUE;
Status = BcmFlash2xBulkWrite(Adapter,
- (PUINT)Buff,
- eISOWritePart,
- uiWriteOffsetWithinPart,
- Adapter->uiSectorSize,
- TRUE);
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Write failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOWritePart, uiWriteOffsetWithinPart);
+ (PUINT)Buff,
+ eISOWritePart,
+ uiWriteOffsetWithinPart,
+ Adapter->uiSectorSize,
+ TRUE);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOWritePart, uiWriteOffsetWithinPart);
break;
}
Adapter->bHeaderChangeAllowed = FALSE;
-
- if(IsThisHeaderSector == TRUE)
- {
+ if (IsThisHeaderSector == TRUE) {
WriteToFlashWithoutSectorErase(Adapter,
- SigBuff,
- eISOWritePart,
- sigOffset,
- MAX_RW_SIZE);
- IsThisHeaderSector = FALSE ;
+ SigBuff,
+ eISOWritePart,
+ sigOffset,
+ MAX_RW_SIZE);
+ IsThisHeaderSector = FALSE;
}
- //subtracting the written Data
- uiTotalDataToCopy = uiTotalDataToCopy - Adapter->uiSectorSize ;
+ /* subtracting the written Data */
+ uiTotalDataToCopy = uiTotalDataToCopy - Adapter->uiSectorSize;
}
+ }
+ if (sCopySectStrut.SrcSection == ISO_IMAGE2 && sCopySectStrut.DstSection == ISO_IMAGE1) {
+ eISOReadPart = ISO_IMAGE2;
+ eISOWritePart = ISO_IMAGE1;
+ uiReadOffsetWithinPart = 0;
+ uiWriteOffsetWithinPart = 0;
- }
+ uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start) +
+ (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start) +
+ (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
- if(sCopySectStrut.SrcSection ==ISO_IMAGE2 && sCopySectStrut.DstSection ==ISO_IMAGE1)
- {
- eISOReadPart = ISO_IMAGE2 ;
- eISOWritePart = ISO_IMAGE1 ;
- uiReadOffsetWithinPart = 0;
- uiWriteOffsetWithinPart = 0 ;
-
- uiTotalDataToCopy =(Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start)+
- (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start)+
- (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage2Part3Start);
-
- if(uiTotalDataToCopy < ISOLength)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"error as Source ISO Section does not have valid signature");
+ if (uiTotalDataToCopy < ISOLength) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Source ISO Section does not have valid signature");
Status = STATUS_FAILURE;
goto out;
}
- uiTotalDataToCopy =(Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start)+
- (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start)+
- (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End) -
- (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
+ uiTotalDataToCopy = (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start) +
+ (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start) +
+ (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3End) -
+ (Adapter->psFlash2xCSInfo->OffsetISOImage1Part3Start);
- if(uiTotalDataToCopy < ISOLength)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"error as Dest ISO Section does not have enough section size");
+ if (uiTotalDataToCopy < ISOLength) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "error as Dest ISO Section does not have enough section size");
Status = STATUS_FAILURE;
goto out;
}
uiTotalDataToCopy = ISOLength;
- CorruptISOSig(Adapter,ISO_IMAGE1);
+ CorruptISOSig(Adapter, ISO_IMAGE1);
- while(uiTotalDataToCopy)
- {
- if(uiTotalDataToCopy == Adapter->uiSectorSize)
- {
- //Setting for write of first sector. First sector is assumed to be written in last
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Writing the signature sector");
- eISOReadPart = ISO_IMAGE2 ;
+ while (uiTotalDataToCopy) {
+ if (uiTotalDataToCopy == Adapter->uiSectorSize) {
+ /* Setting for write of first sector. First sector is assumed to be written in last */
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Writing the signature sector");
+ eISOReadPart = ISO_IMAGE2;
uiReadOffsetWithinPart = 0;
eISOWritePart = ISO_IMAGE1;
- uiWriteOffsetWithinPart = 0 ;
+ uiWriteOffsetWithinPart = 0;
IsThisHeaderSector = TRUE;
+ } else {
+ uiReadOffsetWithinPart = uiReadOffsetWithinPart + Adapter->uiSectorSize;
+ uiWriteOffsetWithinPart = uiWriteOffsetWithinPart + Adapter->uiSectorSize;
- }
- else
- {
- uiReadOffsetWithinPart = uiReadOffsetWithinPart + Adapter->uiSectorSize ;
- uiWriteOffsetWithinPart = uiWriteOffsetWithinPart + Adapter->uiSectorSize ;
-
- if((eISOReadPart == ISO_IMAGE2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start) ))
- {
- eISOReadPart = ISO_IMAGE2_PART2 ;
+ if ((eISOReadPart == ISO_IMAGE2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start))) {
+ eISOReadPart = ISO_IMAGE2_PART2;
uiReadOffsetWithinPart = 0;
}
- if((eISOReadPart == ISO_IMAGE2_PART2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start)))
- {
- eISOReadPart = ISO_IMAGE2_PART3 ;
+
+ if ((eISOReadPart == ISO_IMAGE2_PART2) && (uiReadOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage2Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage2Part2Start))) {
+ eISOReadPart = ISO_IMAGE2_PART3;
uiReadOffsetWithinPart = 0;
}
- if((eISOWritePart == ISO_IMAGE1) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start)))
- {
- eISOWritePart = ISO_IMAGE1_PART2 ;
+
+ if ((eISOWritePart == ISO_IMAGE1) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part1End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start))) {
+ eISOWritePart = ISO_IMAGE1_PART2;
uiWriteOffsetWithinPart = 0;
}
- if((eISOWritePart == ISO_IMAGE1_PART2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start)))
- {
- eISOWritePart = ISO_IMAGE1_PART3 ;
+
+ if ((eISOWritePart == ISO_IMAGE1_PART2) && (uiWriteOffsetWithinPart == (Adapter->psFlash2xCSInfo->OffsetISOImage1Part2End - Adapter->psFlash2xCSInfo->OffsetISOImage1Part2Start))) {
+ eISOWritePart = ISO_IMAGE1_PART3;
uiWriteOffsetWithinPart = 0;
}
}
Status = BcmFlash2xBulkRead(Adapter,
- (PUINT)Buff,
- eISOReadPart,
- uiReadOffsetWithinPart,
- Adapter->uiSectorSize
- );
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOReadPart, uiReadOffsetWithinPart);
+ (PUINT)Buff,
+ eISOReadPart,
+ uiReadOffsetWithinPart,
+ Adapter->uiSectorSize);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOReadPart, uiReadOffsetWithinPart);
break;
}
- if(IsThisHeaderSector == TRUE)
- {
- //If this is header sector write 0xFFFFFFFF at the sig time and in last write sig
+ if (IsThisHeaderSector == TRUE) {
+ /* If this is header sector write 0xFFFFFFFF at the sig time and in last write sig */
memcpy(SigBuff, Buff + sigOffset, MAX_RW_SIZE);
- for(i = 0; i < MAX_RW_SIZE;i++)
+ for (i = 0; i < MAX_RW_SIZE; i++)
*(Buff + sigOffset + i) = 0xFF;
-
}
- Adapter->bHeaderChangeAllowed = TRUE ;
+ Adapter->bHeaderChangeAllowed = TRUE;
Status = BcmFlash2xBulkWrite(Adapter,
- (PUINT)Buff,
- eISOWritePart,
- uiWriteOffsetWithinPart,
- Adapter->uiSectorSize,
- TRUE);
-
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Write failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOWritePart, uiWriteOffsetWithinPart);
+ (PUINT)Buff,
+ eISOWritePart,
+ uiWriteOffsetWithinPart,
+ Adapter->uiSectorSize,
+ TRUE);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write failed while copying ISO: Part: %x, OffsetWithinPart: %x\n", eISOWritePart, uiWriteOffsetWithinPart);
break;
}
- Adapter->bHeaderChangeAllowed = FALSE ;
-
- if(IsThisHeaderSector == TRUE)
- {
+ Adapter->bHeaderChangeAllowed = FALSE;
+ if (IsThisHeaderSector == TRUE) {
WriteToFlashWithoutSectorErase(Adapter,
- SigBuff,
- eISOWritePart,
- sigOffset,
- MAX_RW_SIZE);
- IsThisHeaderSector = FALSE ;
+ SigBuff,
+ eISOWritePart,
+ sigOffset,
+ MAX_RW_SIZE);
+
+ IsThisHeaderSector = FALSE;
}
- //subtracting the written Data
- uiTotalDataToCopy = uiTotalDataToCopy - Adapter->uiSectorSize ;
+ /* subtracting the written Data */
+ uiTotalDataToCopy = uiTotalDataToCopy - Adapter->uiSectorSize;
}
-
-
}
-
out:
kfree(Buff);
return Status;
}
-/**
-BcmFlash2xCorruptSig : this API is used to corrupt the written sig in Bcm Header present in flash section.
- It will corrupt the sig, if Section is writable, by making first bytes as zero.
-@Adapater :- Bcm Driver Private Data Structure
-@eFlash2xSectionVal :- Flash section val which has header
-Return Value :-
- Success :- If Section is present and writable, corrupt the sig and return STATUS_SUCCESS
- Failure :-Return negative error code
-
-
-**/
-INT BcmFlash2xCorruptSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal)
+/*
+ * BcmFlash2xCorruptSig : this API is used to corrupt the written sig in Bcm Header present in flash section.
+ * It will corrupt the sig, if Section is writable, by making first bytes as zero.
+ * @Adapater :- Bcm Driver Private Data Structure
+ * @eFlash2xSectionVal :- Flash section val which has header
+ *
+ * Return Value :-
+ * Success :- If Section is present and writable, corrupt the sig and return STATUS_SUCCESS
+ * Failure :-Return negative error code
+ */
+
+int BcmFlash2xCorruptSig(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal)
{
+ int Status = STATUS_SUCCESS;
- INT Status = STATUS_SUCCESS ;
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Section Value :%x \n", eFlash2xSectionVal);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section Value :%x\n", eFlash2xSectionVal);
- if((eFlash2xSectionVal == DSD0) || (eFlash2xSectionVal == DSD1) || (eFlash2xSectionVal == DSD2))
- {
+ if ((eFlash2xSectionVal == DSD0) || (eFlash2xSectionVal == DSD1) || (eFlash2xSectionVal == DSD2)) {
Status = CorruptDSDSig(Adapter, eFlash2xSectionVal);
- }
- else if(eFlash2xSectionVal == ISO_IMAGE1 || eFlash2xSectionVal == ISO_IMAGE2)
- {
+ } else if (eFlash2xSectionVal == ISO_IMAGE1 || eFlash2xSectionVal == ISO_IMAGE2) {
Status = CorruptISOSig(Adapter, eFlash2xSectionVal);
- }
- else
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Given Section <%d>does not have Header",eFlash2xSectionVal);
+ } else {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Given Section <%d>does not have Header", eFlash2xSectionVal);
return STATUS_SUCCESS;
}
return Status;
}
-/**
-BcmFlash2xWriteSig :-this API is used to Write the sig if requested Section has
- header and Write Permission.
-@Adapater :- Bcm Driver Private Data Structure
-@eFlashSectionVal :- Flash section val which has header
-
-Return Value :-
- Success :- If Section is present and writable write the sig and return STATUS_SUCCESS
- Failure :-Return negative error code
-
-**/
-INT BcmFlash2xWriteSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlashSectionVal)
-{
- UINT uiSignature = 0 ;
- UINT uiOffset = 0;
- //DSD_HEADER dsdHeader = {0};
+/*
+ *BcmFlash2xWriteSig :-this API is used to Write the sig if requested Section has
+ * header and Write Permission.
+ * @Adapater :- Bcm Driver Private Data Structure
+ * @eFlashSectionVal :- Flash section val which has header
+ *
+ * Return Value :-
+ * Success :- If Section is present and writable write the sig and return STATUS_SUCCESS
+ * Failure :-Return negative error code
+ */
+
+int BcmFlash2xWriteSig(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlashSectionVal)
+{
+ unsigned int uiSignature = 0;
+ unsigned int uiOffset = 0;
- if(Adapter->bSigCorrupted == FALSE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Signature is not corrupted by driver, hence not restoring\n");
+ /* DSD_HEADER dsdHeader = {0}; */
+ if (Adapter->bSigCorrupted == FALSE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Signature is not corrupted by driver, hence not restoring\n");
return STATUS_SUCCESS;
}
- if(Adapter->bAllDSDWriteAllow == FALSE)
- {
- if(IsSectionWritable(Adapter,eFlashSectionVal) == FALSE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Section is not Writable...Hence can't Write signature");
+
+ if (Adapter->bAllDSDWriteAllow == FALSE) {
+ if (IsSectionWritable(Adapter, eFlashSectionVal) == FALSE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section is not Writable...Hence can't Write signature");
return SECTOR_IS_NOT_WRITABLE;
}
}
- if((eFlashSectionVal == DSD0) ||(eFlashSectionVal == DSD1) || (eFlashSectionVal == DSD2))
- {
- uiSignature = htonl(DSD_IMAGE_MAGIC_NUMBER) ;
- uiOffset = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader ;
- uiOffset += FIELD_OFFSET_IN_HEADER(PDSD_HEADER,DSDImageMagicNumber);
+ if ((eFlashSectionVal == DSD0) || (eFlashSectionVal == DSD1) || (eFlashSectionVal == DSD2)) {
+ uiSignature = htonl(DSD_IMAGE_MAGIC_NUMBER);
+ uiOffset = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader;
- if((ReadDSDSignature(Adapter,eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Corrupted Pattern is not there. Hence won't write sig");
+ uiOffset += FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImageMagicNumber);
+
+ if ((ReadDSDSignature(Adapter, eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Corrupted Pattern is not there. Hence won't write sig");
return STATUS_FAILURE;
}
-
- }
- else if((eFlashSectionVal == ISO_IMAGE1) || (eFlashSectionVal == ISO_IMAGE2))
- {
+ } else if ((eFlashSectionVal == ISO_IMAGE1) || (eFlashSectionVal == ISO_IMAGE2)) {
uiSignature = htonl(ISO_IMAGE_MAGIC_NUMBER);
- //uiOffset = 0;
- uiOffset = FIELD_OFFSET_IN_HEADER(PISO_HEADER,ISOImageMagicNumber);
- if((ReadISOSignature(Adapter,eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Currupted Pattern is not there. Hence won't write sig");
+ /* uiOffset = 0; */
+ uiOffset = FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImageMagicNumber);
+ if ((ReadISOSignature(Adapter, eFlashSectionVal) & 0xFF000000) != CORRUPTED_PATTERN) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Currupted Pattern is not there. Hence won't write sig");
return STATUS_FAILURE;
}
- }
- else
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"GIVEN SECTION< %d > IS NOT VALID FOR SIG WRITE...", eFlashSectionVal);
+ } else {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "GIVEN SECTION< %d > IS NOT VALID FOR SIG WRITE...", eFlashSectionVal);
return STATUS_FAILURE;
}
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Restoring the signature");
-
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Restoring the signature");
Adapter->bHeaderChangeAllowed = TRUE;
Adapter->bSigCorrupted = FALSE;
- BcmFlash2xBulkWrite(Adapter, &uiSignature,eFlashSectionVal,uiOffset,SIGNATURE_SIZE,TRUE);
+ BcmFlash2xBulkWrite(Adapter, &uiSignature, eFlashSectionVal, uiOffset, SIGNATURE_SIZE, TRUE);
Adapter->bHeaderChangeAllowed = FALSE;
-
-
return STATUS_SUCCESS;
}
-/**
-validateFlash2xReadWrite :- This API is used to validate the user request for Read/Write.
- if requested Bytes goes beyond the Requested section, it reports error.
-@Adapater :- Bcm Driver Private Data Structure
-@psFlash2xReadWrite :-Flash2x Read/write structure pointer
-Return values:-Return TRUE is request is valid else FALSE.
-
-
-**/
-INT validateFlash2xReadWrite(PMINI_ADAPTER Adapter, PFLASH2X_READWRITE psFlash2xReadWrite)
+/*
+ * validateFlash2xReadWrite :- This API is used to validate the user request for Read/Write.
+ * if requested Bytes goes beyond the Requested section, it reports error.
+ * @Adapater :- Bcm Driver Private Data Structure
+ * @psFlash2xReadWrite :-Flash2x Read/write structure pointer
+ *
+ * Return values:-Return TRUE is request is valid else FALSE.
+ */
+
+int validateFlash2xReadWrite(struct bcm_mini_adapter *Adapter, PFLASH2X_READWRITE psFlash2xReadWrite)
{
- UINT uiNumOfBytes = 0 ;
- UINT uiSectStartOffset = 0 ;
- UINT uiSectEndOffset = 0;
+ unsigned int uiNumOfBytes = 0;
+ unsigned int uiSectStartOffset = 0;
+ unsigned int uiSectEndOffset = 0;
+
uiNumOfBytes = psFlash2xReadWrite->numOfBytes;
- if(IsSectionExistInFlash(Adapter,psFlash2xReadWrite->Section) != TRUE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Section<%x> does not exixt in Flash",psFlash2xReadWrite->Section);
+ if (IsSectionExistInFlash(Adapter, psFlash2xReadWrite->Section) != TRUE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section<%x> does not exixt in Flash", psFlash2xReadWrite->Section);
return FALSE;
}
- uiSectStartOffset = BcmGetSectionValStartOffset(Adapter,psFlash2xReadWrite->Section);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Start offset :%x ,section :%d\n",uiSectStartOffset,psFlash2xReadWrite->Section);
- if((psFlash2xReadWrite->Section == ISO_IMAGE1) ||(psFlash2xReadWrite->Section == ISO_IMAGE2))
- {
- if(psFlash2xReadWrite->Section == ISO_IMAGE1)
- {
- uiSectEndOffset = BcmGetSectionValEndOffset(Adapter,ISO_IMAGE1) -
- BcmGetSectionValStartOffset(Adapter,ISO_IMAGE1)+
- BcmGetSectionValEndOffset(Adapter,ISO_IMAGE1_PART2) -
- BcmGetSectionValStartOffset(Adapter,ISO_IMAGE1_PART2)+
- BcmGetSectionValEndOffset(Adapter,ISO_IMAGE1_PART3) -
- BcmGetSectionValStartOffset(Adapter,ISO_IMAGE1_PART3);
+ uiSectStartOffset = BcmGetSectionValStartOffset(Adapter, psFlash2xReadWrite->Section);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Start offset :%x ,section :%d\n", uiSectStartOffset, psFlash2xReadWrite->Section);
+ if ((psFlash2xReadWrite->Section == ISO_IMAGE1) || (psFlash2xReadWrite->Section == ISO_IMAGE2)) {
+ if (psFlash2xReadWrite->Section == ISO_IMAGE1) {
+ uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1) -
+ BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1) +
+ BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1_PART2) -
+ BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1_PART2) +
+ BcmGetSectionValEndOffset(Adapter, ISO_IMAGE1_PART3) -
+ BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1_PART3);
+ } else if (psFlash2xReadWrite->Section == ISO_IMAGE2) {
+ uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2) -
+ BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2) +
+ BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2_PART2) -
+ BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2_PART2) +
+ BcmGetSectionValEndOffset(Adapter, ISO_IMAGE2_PART3) -
+ BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2_PART3);
}
- else if(psFlash2xReadWrite->Section == ISO_IMAGE2)
- {
- uiSectEndOffset = BcmGetSectionValEndOffset(Adapter,ISO_IMAGE2) -
- BcmGetSectionValStartOffset(Adapter,ISO_IMAGE2)+
- BcmGetSectionValEndOffset(Adapter,ISO_IMAGE2_PART2) -
- BcmGetSectionValStartOffset(Adapter,ISO_IMAGE2_PART2)+
- BcmGetSectionValEndOffset(Adapter,ISO_IMAGE2_PART3) -
- BcmGetSectionValStartOffset(Adapter,ISO_IMAGE2_PART3);
- }
+ /* since this uiSectEndoffset is the size of iso Image. hence for calculating the vitual endoffset
+ * it should be added in startoffset. so that check done in last of this function can be valued.
+ */
+ uiSectEndOffset = uiSectStartOffset + uiSectEndOffset;
- //since this uiSectEndoffset is the size of iso Image. hence for calculating the vitual endoffset
- //it should be added in startoffset. so that check done in last of this function can be valued.
- uiSectEndOffset = uiSectStartOffset + uiSectEndOffset ;
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Total size of the ISO Image :%x", uiSectEndOffset);
+ } else
+ uiSectEndOffset = BcmGetSectionValEndOffset(Adapter, psFlash2xReadWrite->Section);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Total size of the ISO Image :%x",uiSectEndOffset);
- }
- else
- uiSectEndOffset = BcmGetSectionValEndOffset(Adapter,psFlash2xReadWrite->Section);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "End offset :%x \n",uiSectEndOffset);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "End offset :%x\n", uiSectEndOffset);
- //Checking the boundary condition
- if((uiSectStartOffset + psFlash2xReadWrite->offset + uiNumOfBytes) <= uiSectEndOffset)
+ /* Checking the boundary condition */
+ if ((uiSectStartOffset + psFlash2xReadWrite->offset + uiNumOfBytes) <= uiSectEndOffset)
return TRUE;
- else
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Invalid Request....");
+ else {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Invalid Request....");
return FALSE;
}
-
}
-/**
-IsFlash2x :- check for Flash 2.x
-@Adapater :- Bcm Driver Private Data Structure
-
-Return value:-
- return TRUE if flah2.x of hgher version else return false.
-**/
-
-INT IsFlash2x(PMINI_ADAPTER Adapter)
+/*
+ * IsFlash2x :- check for Flash 2.x
+ * Adapater :- Bcm Driver Private Data Structure
+ *
+ * Return value:-
+ * return TRUE if flah2.x of hgher version else return false.
+ */
+
+int IsFlash2x(struct bcm_mini_adapter *Adapter)
{
- if(Adapter->uiFlashLayoutMajorVersion >= FLASH_2X_MAJOR_NUMBER)
- return TRUE ;
+ if (Adapter->uiFlashLayoutMajorVersion >= FLASH_2X_MAJOR_NUMBER)
+ return TRUE;
else
return FALSE;
}
-/**
-GetFlashBaseAddr :- Calculate the Flash Base address
-@Adapater :- Bcm Driver Private Data Structure
-
-Return Value:-
- Success :- Base Address of the Flash
-**/
-static INT GetFlashBaseAddr(PMINI_ADAPTER Adapter)
+/*
+ * GetFlashBaseAddr :- Calculate the Flash Base address
+ * @Adapater :- Bcm Driver Private Data Structure
+ *
+ * Return Value:-
+ * Success :- Base Address of the Flash
+ */
+
+static int GetFlashBaseAddr(struct bcm_mini_adapter *Adapter)
{
+ unsigned int uiBaseAddr = 0;
- UINT uiBaseAddr = 0;
-
- if(Adapter->bDDRInitDone)
- {
+ if (Adapter->bDDRInitDone) {
/*
- For All Valid Flash Versions... except 1.1, take the value from FlashBaseAddr
- In case of Raw Read... use the default value
- */
- if(Adapter->uiFlashLayoutMajorVersion && (Adapter->bFlashRawRead == FALSE) &&
- !((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1))
- )
- uiBaseAddr = Adapter->uiFlashBaseAdd ;
+ * For All Valid Flash Versions... except 1.1, take the value from FlashBaseAddr
+ * In case of Raw Read... use the default value
+ */
+ if (Adapter->uiFlashLayoutMajorVersion && (Adapter->bFlashRawRead == FALSE) &&
+ !((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1)))
+ uiBaseAddr = Adapter->uiFlashBaseAdd;
else
uiBaseAddr = FLASH_CONTIGIOUS_START_ADDR_AFTER_INIT;
- }
- else
- {
+ } else {
/*
- For All Valid Flash Versions... except 1.1, take the value from FlashBaseAddr
- In case of Raw Read... use the default value
- */
- if(Adapter->uiFlashLayoutMajorVersion && (Adapter->bFlashRawRead == FALSE) &&
- !((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1))
- )
+ * For All Valid Flash Versions... except 1.1, take the value from FlashBaseAddr
+ * In case of Raw Read... use the default value
+ */
+ if (Adapter->uiFlashLayoutMajorVersion && (Adapter->bFlashRawRead == FALSE) &&
+ !((Adapter->uiFlashLayoutMajorVersion == 1) && (Adapter->uiFlashLayoutMinorVersion == 1)))
uiBaseAddr = Adapter->uiFlashBaseAdd | FLASH_CONTIGIOUS_START_ADDR_BEFORE_INIT;
else
uiBaseAddr = FLASH_CONTIGIOUS_START_ADDR_BEFORE_INIT;
}
- return uiBaseAddr ;
+ return uiBaseAddr;
}
-/**
-BcmCopySection :- This API is used to copy the One section in another. Both section should
- be contiuous and of same size. Hence this Will not be applicabe to copy ISO.
-
-@Adapater :- Bcm Driver Private Data Structure
-@SrcSection :- Source section From where data has to be copied
-@DstSection :- Destination section to which data has to be copied
-@offset :- Offset from/to where data has to be copied from one section to another.
-@numOfBytes :- number of byes that has to be copyed from one section to another at given offset.
- in case of numofBytes equal zero complete section will be copied.
-
-Return Values-
- Success : Return STATUS_SUCCESS
- Faillure :- return negative error code
-
-**/
-
-INT BcmCopySection(PMINI_ADAPTER Adapter,
- FLASH2X_SECTION_VAL SrcSection,
- FLASH2X_SECTION_VAL DstSection,
- UINT offset,
- UINT numOfBytes)
+
+/*
+ * BcmCopySection :- This API is used to copy the One section in another. Both section should
+ * be contiuous and of same size. Hence this Will not be applicabe to copy ISO.
+ *
+ * @Adapater :- Bcm Driver Private Data Structure
+ * @SrcSection :- Source section From where data has to be copied
+ * @DstSection :- Destination section to which data has to be copied
+ * @offset :- Offset from/to where data has to be copied from one section to another.
+ * @numOfBytes :- number of byes that has to be copyed from one section to another at given offset.
+ * in case of numofBytes equal zero complete section will be copied.
+ * Return Values-
+ * Success : Return STATUS_SUCCESS
+ * Faillure :- return negative error code
+ */
+
+int BcmCopySection(struct bcm_mini_adapter *Adapter,
+ FLASH2X_SECTION_VAL SrcSection,
+ FLASH2X_SECTION_VAL DstSection,
+ unsigned int offset,
+ unsigned int numOfBytes)
{
- UINT BuffSize = 0 ;
- UINT BytesToBeCopied = 0;
- PUCHAR pBuff = NULL ;
- INT Status = STATUS_SUCCESS ;
- if(SrcSection == DstSection)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Source and Destination should be different ...try again");
+ unsigned int BuffSize = 0;
+ unsigned int BytesToBeCopied = 0;
+ PUCHAR pBuff = NULL;
+ int Status = STATUS_SUCCESS;
+
+ if (SrcSection == DstSection) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Source and Destination should be different ...try again");
return -EINVAL;
}
- if((SrcSection != DSD0) && (SrcSection != DSD1) && (SrcSection != DSD2))
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Source should be DSD subsection");
- return -EINVAL;
- }
- if((DstSection != DSD0) && (DstSection != DSD1) && (DstSection != DSD2))
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Destination should be DSD subsection");
- return -EINVAL;
+
+ if ((SrcSection != DSD0) && (SrcSection != DSD1) && (SrcSection != DSD2)) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Source should be DSD subsection");
+ return -EINVAL;
}
- //if offset zero means have to copy complete secton
+ if ((DstSection != DSD0) && (DstSection != DSD1) && (DstSection != DSD2)) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Destination should be DSD subsection");
+ return -EINVAL;
+ }
- if(numOfBytes == 0)
- {
- numOfBytes = BcmGetSectionValEndOffset(Adapter,SrcSection)
- - BcmGetSectionValStartOffset(Adapter,SrcSection);
+ /* if offset zero means have to copy complete secton */
+ if (numOfBytes == 0) {
+ numOfBytes = BcmGetSectionValEndOffset(Adapter, SrcSection)
+ - BcmGetSectionValStartOffset(Adapter, SrcSection);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL," Section Size :0x%x",numOfBytes);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Section Size :0x%x", numOfBytes);
}
- if((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter,SrcSection)
- - BcmGetSectionValStartOffset(Adapter,SrcSection))
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0," Input parameters going beyond the section offS: %x numB: %x of Source Section\n",
- offset, numOfBytes);
+ if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter, SrcSection)
+ - BcmGetSectionValStartOffset(Adapter, SrcSection)) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, " Input parameters going beyond the section offS: %x numB: %x of Source Section\n",
+ offset, numOfBytes);
return -EINVAL;
}
- if((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter,DstSection)
- - BcmGetSectionValStartOffset(Adapter,DstSection))
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0," Input parameters going beyond the section offS: %x numB: %x of Destination Section\n",
- offset, numOfBytes);
+ if ((offset + numOfBytes) > BcmGetSectionValEndOffset(Adapter, DstSection)
+ - BcmGetSectionValStartOffset(Adapter, DstSection)) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Input parameters going beyond the section offS: %x numB: %x of Destination Section\n",
+ offset, numOfBytes);
return -EINVAL;
}
-
- if(numOfBytes > Adapter->uiSectorSize )
+ if (numOfBytes > Adapter->uiSectorSize)
BuffSize = Adapter->uiSectorSize;
else
- BuffSize = numOfBytes ;
+ BuffSize = numOfBytes;
pBuff = (PCHAR)kzalloc(BuffSize, GFP_KERNEL);
- if(pBuff == NULL)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed.. ");
+ if (!pBuff) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed.. ");
return -ENOMEM;
}
-
- BytesToBeCopied = Adapter->uiSectorSize ;
- if(offset % Adapter->uiSectorSize)
+ BytesToBeCopied = Adapter->uiSectorSize;
+ if (offset % Adapter->uiSectorSize)
BytesToBeCopied = Adapter->uiSectorSize - (offset % Adapter->uiSectorSize);
- if(BytesToBeCopied > numOfBytes)
- BytesToBeCopied = numOfBytes ;
-
-
+ if (BytesToBeCopied > numOfBytes)
+ BytesToBeCopied = numOfBytes;
Adapter->bHeaderChangeAllowed = TRUE;
- do
- {
- Status = BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, SrcSection , offset,BytesToBeCopied);
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Read failed at offset :%d for NOB :%d", SrcSection,BytesToBeCopied);
+ do {
+ Status = BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, SrcSection , offset, BytesToBeCopied);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read failed at offset :%d for NOB :%d", SrcSection, BytesToBeCopied);
break;
}
- Status = BcmFlash2xBulkWrite(Adapter,(PUINT)pBuff,DstSection,offset,BytesToBeCopied,FALSE);
- if(Status)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Write failed at offset :%d for NOB :%d", DstSection,BytesToBeCopied);
+ Status = BcmFlash2xBulkWrite(Adapter, (PUINT)pBuff, DstSection, offset, BytesToBeCopied, FALSE);
+ if (Status) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Write failed at offset :%d for NOB :%d", DstSection, BytesToBeCopied);
break;
}
offset = offset + BytesToBeCopied;
- numOfBytes = numOfBytes - BytesToBeCopied ;
- if(numOfBytes)
- {
- if(numOfBytes > Adapter->uiSectorSize )
+ numOfBytes = numOfBytes - BytesToBeCopied;
+ if (numOfBytes) {
+ if (numOfBytes > Adapter->uiSectorSize)
BytesToBeCopied = Adapter->uiSectorSize;
else
BytesToBeCopied = numOfBytes;
}
- }while(numOfBytes > 0) ;
+ } while (numOfBytes > 0);
+
kfree(pBuff);
- Adapter->bHeaderChangeAllowed = FALSE ;
+ Adapter->bHeaderChangeAllowed = FALSE;
+
return Status;
}
-/**
-SaveHeaderIfPresent :- This API is use to Protect the Header in case of Header Sector write
-@Adapater :- Bcm Driver Private Data Structure
-@pBuff :- Data buffer that has to be written in sector having the header map.
-@uiOffset :- Flash offset that has to be written.
-
-Return value :-
- Success :- On success return STATUS_SUCCESS
- Faillure :- Return negative error code
-
-**/
-
-INT SaveHeaderIfPresent(PMINI_ADAPTER Adapter, PUCHAR pBuff, UINT uiOffset)
+/*
+ * SaveHeaderIfPresent :- This API is use to Protect the Header in case of Header Sector write
+ * @Adapater :- Bcm Driver Private Data Structure
+ * @pBuff :- Data buffer that has to be written in sector having the header map.
+ * @uiOffset :- Flash offset that has to be written.
+ *
+ * Return value :-
+ * Success :- On success return STATUS_SUCCESS
+ * Faillure :- Return negative error code
+ */
+
+int SaveHeaderIfPresent(struct bcm_mini_adapter *Adapter, PUCHAR pBuff, unsigned int uiOffset)
{
- UINT offsetToProtect = 0,HeaderSizeToProtect =0;
- BOOLEAN bHasHeader = FALSE ;
- PUCHAR pTempBuff =NULL;
- UINT uiSectAlignAddr = 0;
- UINT sig = 0;
+ unsigned int offsetToProtect = 0, HeaderSizeToProtect = 0;
+ BOOLEAN bHasHeader = FALSE;
+ PUCHAR pTempBuff = NULL;
+ unsigned int uiSectAlignAddr = 0;
+ unsigned int sig = 0;
- //making the offset sector aligned
+ /* making the offset sector aligned */
uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
-
- if((uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter,DSD2)- Adapter->uiSectorSize)||
- (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter,DSD1)- Adapter->uiSectorSize)||
- (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter,DSD0)- Adapter->uiSectorSize))
- {
-
- //offset from the sector boundary having the header map
+ if ((uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD2) - Adapter->uiSectorSize) ||
+ (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD1) - Adapter->uiSectorSize) ||
+ (uiSectAlignAddr == BcmGetSectionValEndOffset(Adapter, DSD0) - Adapter->uiSectorSize)) {
+ /* offset from the sector boundary having the header map */
offsetToProtect = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader % Adapter->uiSectorSize;
HeaderSizeToProtect = sizeof(DSD_HEADER);
- bHasHeader = TRUE ;
+ bHasHeader = TRUE;
}
- if(uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter,ISO_IMAGE1) ||
- uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter,ISO_IMAGE2))
- {
+ if (uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter, ISO_IMAGE1) ||
+ uiSectAlignAddr == BcmGetSectionValStartOffset(Adapter, ISO_IMAGE2)) {
offsetToProtect = 0;
HeaderSizeToProtect = sizeof(ISO_HEADER);
bHasHeader = TRUE;
}
- //If Header is present overwrite passed buffer with this
- if(bHasHeader && (Adapter->bHeaderChangeAllowed == FALSE))
- {
+ /* If Header is present overwrite passed buffer with this */
+ if (bHasHeader && (Adapter->bHeaderChangeAllowed == FALSE)) {
pTempBuff = (PUCHAR)kzalloc(HeaderSizeToProtect, GFP_KERNEL);
- if(pTempBuff == NULL)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed ");
+ if (!pTempBuff) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed");
return -ENOMEM;
}
- //Read header
- BeceemFlashBulkRead(Adapter,(PUINT)pTempBuff,(uiSectAlignAddr + offsetToProtect),HeaderSizeToProtect);
- BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,pTempBuff ,HeaderSizeToProtect);
- //Replace Buffer content with Header
- memcpy(pBuff +offsetToProtect,pTempBuff,HeaderSizeToProtect);
+ /* Read header */
+ BeceemFlashBulkRead(Adapter, (PUINT)pTempBuff, (uiSectAlignAddr + offsetToProtect), HeaderSizeToProtect);
+ BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pTempBuff, HeaderSizeToProtect);
+ /* Replace Buffer content with Header */
+ memcpy(pBuff + offsetToProtect, pTempBuff, HeaderSizeToProtect);
kfree(pTempBuff);
}
- if(bHasHeader && Adapter->bSigCorrupted)
- {
- sig = *((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(PDSD_HEADER,DSDImageMagicNumber)));
+ if (bHasHeader && Adapter->bSigCorrupted) {
+ sig = *((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImageMagicNumber)));
sig = ntohl(sig);
- if((sig & 0xFF000000) != CORRUPTED_PATTERN)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Desired pattern is not at sig offset. Hence won't restore");
+ if ((sig & 0xFF000000) != CORRUPTED_PATTERN) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Desired pattern is not at sig offset. Hence won't restore");
Adapter->bSigCorrupted = FALSE;
return STATUS_SUCCESS;
}
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL," Corrupted sig is :%X", sig);
- *((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(PDSD_HEADER,DSDImageMagicNumber)))= htonl(DSD_IMAGE_MAGIC_NUMBER);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Restoring the signature in Header Write only");
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, " Corrupted sig is :%X", sig);
+ *((PUINT)(pBuff + offsetToProtect + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImageMagicNumber))) = htonl(DSD_IMAGE_MAGIC_NUMBER);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Restoring the signature in Header Write only");
Adapter->bSigCorrupted = FALSE;
}
- return STATUS_SUCCESS ;
+ return STATUS_SUCCESS;
}
-/**
-BcmDoChipSelect : This will selcet the appropriate chip for writing.
-@Adapater :- Bcm Driver Private Data Structure
-
-OutPut:-
- Select the Appropriate chip and retrn status Success
-**/
-static INT BcmDoChipSelect(PMINI_ADAPTER Adapter, UINT offset)
+/*
+ * BcmDoChipSelect : This will selcet the appropriate chip for writing.
+ * @Adapater :- Bcm Driver Private Data Structure
+ *
+ * OutPut:-
+ * Select the Appropriate chip and retrn status Success
+ */
+static int BcmDoChipSelect(struct bcm_mini_adapter *Adapter, unsigned int offset)
{
- UINT FlashConfig = 0;
- INT ChipNum = 0;
- UINT GPIOConfig = 0;
- UINT PartNum = 0;
+ unsigned int FlashConfig = 0;
+ int ChipNum = 0;
+ unsigned int GPIOConfig = 0;
+ unsigned int PartNum = 0;
- ChipNum = offset / FLASH_PART_SIZE ;
+ ChipNum = offset / FLASH_PART_SIZE;
- //
- // Chip Select mapping to enable flash0.
- // To select flash 0, we have to OR with (0<<12).
- // ORing 0 will have no impact so not doing that part.
- // In future if Chip select value changes from 0 to non zero,
- // That needs be taken care with backward comaptibility. No worries for now.
- //
+ /*
+ * Chip Select mapping to enable flash0.
+ * To select flash 0, we have to OR with (0<<12).
+ * ORing 0 will have no impact so not doing that part.
+ * In future if Chip select value changes from 0 to non zero,
+ * That needs be taken care with backward comaptibility. No worries for now.
+ */
/*
- SelectedChip Variable is the selection that the host is 100% Sure the same as what the register will hold. This can be ONLY ensured
- if the Chip doesn't goes to low power mode while the flash operation is in progress (NVMRdmWrmLock is taken)
- Before every new Flash Write operation, we reset the variable. This is to ensure that after any wake-up from
- power down modes (Idle mode/shutdown mode), the values in the register will be different.
- */
+ * SelectedChip Variable is the selection that the host is 100% Sure the same as what the register will hold. This can be ONLY ensured
+ * if the Chip doesn't goes to low power mode while the flash operation is in progress (NVMRdmWrmLock is taken)
+ * Before every new Flash Write operation, we reset the variable. This is to ensure that after any wake-up from
+ * power down modes (Idle mode/shutdown mode), the values in the register will be different.
+ */
- if(Adapter->SelectedChip == ChipNum)
- return STATUS_SUCCESS;
+ if (Adapter->SelectedChip == ChipNum)
+ return STATUS_SUCCESS;
- //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Selected Chip :%x", ChipNum);
- Adapter->SelectedChip = ChipNum ;
+ /* BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Selected Chip :%x", ChipNum); */
+ Adapter->SelectedChip = ChipNum;
- //bit[13..12] will select the appropriate chip
+ /* bit[13..12] will select the appropriate chip */
rdmalt(Adapter, FLASH_CONFIG_REG, &FlashConfig, 4);
rdmalt(Adapter, FLASH_GPIO_CONFIG_REG, &GPIOConfig, 4);
-
{
- switch(ChipNum)
- {
+ switch (ChipNum) {
case 0:
PartNum = 0;
break;
}
}
/* In case the bits already written in the FLASH_CONFIG_REG is same as what the user desired,
- nothing to do... can return immediately.
- ASSUMPTION: FLASH_GPIO_CONFIG_REG will be in sync with FLASH_CONFIG_REG.
- Even if the chip goes to low power mode, it should wake with values in each register in sync with each other.
- These values are not written by host other than during CHIP_SELECT.
- */
- if(PartNum == ((FlashConfig >> CHIP_SELECT_BIT12) & 0x3))
+ * nothing to do... can return immediately.
+ * ASSUMPTION: FLASH_GPIO_CONFIG_REG will be in sync with FLASH_CONFIG_REG.
+ * Even if the chip goes to low power mode, it should wake with values in each register in sync with each other.
+ * These values are not written by host other than during CHIP_SELECT.
+ */
+ if (PartNum == ((FlashConfig >> CHIP_SELECT_BIT12) & 0x3))
return STATUS_SUCCESS;
- //clearing the bit[13..12]
+ /* clearing the bit[13..12] */
FlashConfig &= 0xFFFFCFFF;
- FlashConfig = (FlashConfig | (PartNum<<CHIP_SELECT_BIT12)); //00
+ FlashConfig = (FlashConfig | (PartNum<<CHIP_SELECT_BIT12)); /* 00 */
- wrmalt(Adapter,FLASH_GPIO_CONFIG_REG, &GPIOConfig, 4);
+ wrmalt(Adapter, FLASH_GPIO_CONFIG_REG, &GPIOConfig, 4);
udelay(100);
- wrmalt(Adapter,FLASH_CONFIG_REG, &FlashConfig, 4);
+ wrmalt(Adapter, FLASH_CONFIG_REG, &FlashConfig, 4);
udelay(100);
return STATUS_SUCCESS;
-
}
-INT ReadDSDSignature(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL dsd)
-{
- UINT uiDSDsig = 0;
- //UINT sigoffsetInMap = 0;
- //DSD_HEADER dsdHeader = {0};
+int ReadDSDSignature(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL dsd)
+{
+ unsigned int uiDSDsig = 0;
+ /* unsigned int sigoffsetInMap = 0;
+ * DSD_HEADER dsdHeader = {0};
+ */
- //sigoffsetInMap =(PUCHAR)&(dsdHeader.DSDImageMagicNumber) -(PUCHAR)&dsdHeader;
+ /* sigoffsetInMap =(PUCHAR)&(dsdHeader.DSDImageMagicNumber) -(PUCHAR)&dsdHeader; */
- if(dsd != DSD0 && dsd != DSD1 && dsd != DSD2)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"passed section value is not for DSDs");
- return STATUS_FAILURE;
- }
- BcmFlash2xBulkRead(Adapter,
- &uiDSDsig,
- dsd,
- Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER,DSDImageMagicNumber),
- SIGNATURE_SIZE);
+ if (dsd != DSD0 && dsd != DSD1 && dsd != DSD2) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "passed section value is not for DSDs");
+ return STATUS_FAILURE;
+ }
+ BcmFlash2xBulkRead(Adapter,
+ &uiDSDsig,
+ dsd,
+ Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImageMagicNumber),
+ SIGNATURE_SIZE);
- uiDSDsig = ntohl(uiDSDsig);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"DSD SIG :%x", uiDSDsig);
+ uiDSDsig = ntohl(uiDSDsig);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD SIG :%x", uiDSDsig);
- return uiDSDsig ;
+ return uiDSDsig;
}
-INT ReadDSDPriority(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL dsd)
+
+int ReadDSDPriority(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL dsd)
{
- //UINT priOffsetInMap = 0 ;
+ /* unsigned int priOffsetInMap = 0 ; */
unsigned int uiDSDPri = STATUS_FAILURE;
- //DSD_HEADER dsdHeader = {0};
- //priOffsetInMap = (PUCHAR)&(dsdHeader.DSDImagePriority) -(PUCHAR)&dsdHeader;
- if(IsSectionWritable(Adapter,dsd))
- {
- if(ReadDSDSignature(Adapter,dsd)== DSD_IMAGE_MAGIC_NUMBER)
- {
+ /* DSD_HEADER dsdHeader = {0};
+ * priOffsetInMap = (PUCHAR)&(dsdHeader.DSDImagePriority) -(PUCHAR)&dsdHeader;
+ */
+ if (IsSectionWritable(Adapter, dsd)) {
+ if (ReadDSDSignature(Adapter, dsd) == DSD_IMAGE_MAGIC_NUMBER) {
BcmFlash2xBulkRead(Adapter,
- &uiDSDPri,
- dsd,
- Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader +FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImagePriority),
- 4);
+ &uiDSDPri,
+ dsd,
+ Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + FIELD_OFFSET_IN_HEADER(PDSD_HEADER, DSDImagePriority),
+ 4);
uiDSDPri = ntohl(uiDSDPri);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"DSD<%x> Priority :%x", dsd, uiDSDPri);
-
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "DSD<%x> Priority :%x", dsd, uiDSDPri);
}
}
+
return uiDSDPri;
}
-FLASH2X_SECTION_VAL getHighestPriDSD(PMINI_ADAPTER Adapter)
+
+FLASH2X_SECTION_VAL getHighestPriDSD(struct bcm_mini_adapter *Adapter)
{
- INT DSDHighestPri = STATUS_FAILURE;
- INT DsdPri= 0 ;
- FLASH2X_SECTION_VAL HighestPriDSD = 0 ;
+ int DSDHighestPri = STATUS_FAILURE;
+ int DsdPri = 0;
+ FLASH2X_SECTION_VAL HighestPriDSD = 0;
- if(IsSectionWritable(Adapter,DSD2))
- {
- DSDHighestPri = ReadDSDPriority(Adapter,DSD2);
- HighestPriDSD = DSD2 ;
+ if (IsSectionWritable(Adapter, DSD2)) {
+ DSDHighestPri = ReadDSDPriority(Adapter, DSD2);
+ HighestPriDSD = DSD2;
}
- if(IsSectionWritable(Adapter,DSD1))
- {
- DsdPri = ReadDSDPriority(Adapter,DSD1);
- if(DSDHighestPri < DsdPri)
- {
- DSDHighestPri = DsdPri ;
+
+ if (IsSectionWritable(Adapter, DSD1)) {
+ DsdPri = ReadDSDPriority(Adapter, DSD1);
+ if (DSDHighestPri < DsdPri) {
+ DSDHighestPri = DsdPri;
HighestPriDSD = DSD1;
- }
+ }
}
- if(IsSectionWritable(Adapter,DSD0))
- {
- DsdPri = ReadDSDPriority(Adapter,DSD0);
- if(DSDHighestPri < DsdPri)
- {
- DSDHighestPri = DsdPri ;
+
+ if (IsSectionWritable(Adapter, DSD0)) {
+ DsdPri = ReadDSDPriority(Adapter, DSD0);
+ if (DSDHighestPri < DsdPri) {
+ DSDHighestPri = DsdPri;
HighestPriDSD = DSD0;
- }
+ }
}
- if(HighestPriDSD)
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Highest DSD :%x , and its Pri :%x", HighestPriDSD, DSDHighestPri);
- return HighestPriDSD ;
+ if (HighestPriDSD)
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Highest DSD :%x , and its Pri :%x", HighestPriDSD, DSDHighestPri);
+
+ return HighestPriDSD;
}
-INT ReadISOSignature(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL iso)
+int ReadISOSignature(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL iso)
{
- UINT uiISOsig = 0;
- //UINT sigoffsetInMap = 0;
- //ISO_HEADER ISOHeader = {0};
-
-
- //sigoffsetInMap =(PUCHAR)&(ISOHeader.ISOImageMagicNumber) -(PUCHAR)&ISOHeader;
-
- if(iso != ISO_IMAGE1 && iso != ISO_IMAGE2)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"passed section value is not for ISOs");
- return STATUS_FAILURE;
- }
- BcmFlash2xBulkRead(Adapter,
- &uiISOsig,
- iso,
- 0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER,ISOImageMagicNumber),
- SIGNATURE_SIZE);
+ unsigned int uiISOsig = 0;
+ /* unsigned int sigoffsetInMap = 0;
+ * ISO_HEADER ISOHeader = {0};
+ * sigoffsetInMap =(PUCHAR)&(ISOHeader.ISOImageMagicNumber) -(PUCHAR)&ISOHeader;
+ */
+ if (iso != ISO_IMAGE1 && iso != ISO_IMAGE2) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "passed section value is not for ISOs");
+ return STATUS_FAILURE;
+ }
+ BcmFlash2xBulkRead(Adapter,
+ &uiISOsig,
+ iso,
+ 0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImageMagicNumber),
+ SIGNATURE_SIZE);
- uiISOsig = ntohl(uiISOsig);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"ISO SIG :%x", uiISOsig);
+ uiISOsig = ntohl(uiISOsig);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO SIG :%x", uiISOsig);
- return uiISOsig ;
+ return uiISOsig;
}
-INT ReadISOPriority(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL iso)
-{
+int ReadISOPriority(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL iso)
+{
unsigned int ISOPri = STATUS_FAILURE;
- if(IsSectionWritable(Adapter,iso))
- {
- if(ReadISOSignature(Adapter,iso)== ISO_IMAGE_MAGIC_NUMBER)
- {
+ if (IsSectionWritable(Adapter, iso)) {
+ if (ReadISOSignature(Adapter, iso) == ISO_IMAGE_MAGIC_NUMBER) {
BcmFlash2xBulkRead(Adapter,
- &ISOPri,
- iso,
- 0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImagePriority),
- 4);
+ &ISOPri,
+ iso,
+ 0 + FIELD_OFFSET_IN_HEADER(PISO_HEADER, ISOImagePriority),
+ 4);
ISOPri = ntohl(ISOPri);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"ISO<%x> Priority :%x", iso, ISOPri);
-
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "ISO<%x> Priority :%x", iso, ISOPri);
}
}
+
return ISOPri;
}
-FLASH2X_SECTION_VAL getHighestPriISO(PMINI_ADAPTER Adapter)
+
+FLASH2X_SECTION_VAL getHighestPriISO(struct bcm_mini_adapter *Adapter)
{
- INT ISOHighestPri = STATUS_FAILURE;
- INT ISOPri= 0 ;
- FLASH2X_SECTION_VAL HighestPriISO = NO_SECTION_VAL ;
+ int ISOHighestPri = STATUS_FAILURE;
+ int ISOPri = 0;
+ FLASH2X_SECTION_VAL HighestPriISO = NO_SECTION_VAL;
- if(IsSectionWritable(Adapter,ISO_IMAGE2))
- {
- ISOHighestPri = ReadISOPriority(Adapter,ISO_IMAGE2);
- HighestPriISO = ISO_IMAGE2 ;
+ if (IsSectionWritable(Adapter, ISO_IMAGE2)) {
+ ISOHighestPri = ReadISOPriority(Adapter, ISO_IMAGE2);
+ HighestPriISO = ISO_IMAGE2;
}
- if(IsSectionWritable(Adapter,ISO_IMAGE1))
- {
- ISOPri = ReadISOPriority(Adapter,ISO_IMAGE1);
- if(ISOHighestPri < ISOPri)
- {
- ISOHighestPri = ISOPri ;
+
+ if (IsSectionWritable(Adapter, ISO_IMAGE1)) {
+ ISOPri = ReadISOPriority(Adapter, ISO_IMAGE1);
+ if (ISOHighestPri < ISOPri) {
+ ISOHighestPri = ISOPri;
HighestPriISO = ISO_IMAGE1;
- }
+ }
}
- if(HighestPriISO)
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Highest ISO :%x and its Pri :%x",HighestPriISO,ISOHighestPri);
- return HighestPriISO ;
+ if (HighestPriISO)
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Highest ISO :%x and its Pri :%x", HighestPriISO, ISOHighestPri);
+
+ return HighestPriISO;
}
-INT WriteToFlashWithoutSectorErase(PMINI_ADAPTER Adapter,
- PUINT pBuff,
- FLASH2X_SECTION_VAL eFlash2xSectionVal,
- UINT uiOffset,
- UINT uiNumBytes
- )
+
+int WriteToFlashWithoutSectorErase(struct bcm_mini_adapter *Adapter,
+ PUINT pBuff,
+ FLASH2X_SECTION_VAL eFlash2xSectionVal,
+ unsigned int uiOffset,
+ unsigned int uiNumBytes)
{
-#if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
- UINT uiTemp = 0, value = 0 ;
- UINT i = 0;
- UINT uiPartOffset = 0;
-#endif
- UINT uiStartOffset = 0;
- //Adding section start address
- INT Status = STATUS_SUCCESS;
+ #if !defined(BCM_SHM_INTERFACE) || defined(FLASH_DIRECT_ACCESS)
+ unsigned int uiTemp = 0, value = 0;
+ unsigned int i = 0;
+ unsigned int uiPartOffset = 0;
+ #endif
+ unsigned int uiStartOffset = 0;
+ /* Adding section start address */
+ int Status = STATUS_SUCCESS;
PUCHAR pcBuff = (PUCHAR)pBuff;
- if(uiNumBytes % Adapter->ulFlashWriteSize)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Writing without Sector Erase for non-FlashWriteSize number of bytes 0x%x\n", uiNumBytes);
+ if (uiNumBytes % Adapter->ulFlashWriteSize) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Writing without Sector Erase for non-FlashWriteSize number of bytes 0x%x\n", uiNumBytes);
return STATUS_FAILURE;
}
- uiStartOffset = BcmGetSectionValStartOffset(Adapter,eFlash2xSectionVal);
+ uiStartOffset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectionVal);
- if(IsSectionExistInVendorInfo(Adapter,eFlash2xSectionVal))
- {
+ if (IsSectionExistInVendorInfo(Adapter, eFlash2xSectionVal))
return vendorextnWriteSectionWithoutErase(Adapter, pcBuff, eFlash2xSectionVal, uiOffset, uiNumBytes);
- }
uiOffset = uiOffset + uiStartOffset;
-#if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
- Status = bcmflash_raw_writenoerase((uiOffset/FLASH_PART_SIZE),(uiOffset % FLASH_PART_SIZE), pcBuff,uiNumBytes);
-#else
- rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
- value = 0;
- wrmalt(Adapter, 0x0f000C80,&value, sizeof(value));
+ #if defined(BCM_SHM_INTERFACE) && !defined(FLASH_DIRECT_ACCESS)
+ Status = bcmflash_raw_writenoerase((uiOffset / FLASH_PART_SIZE), (uiOffset % FLASH_PART_SIZE), pcBuff, uiNumBytes);
+ #else
+ rdmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
+ value = 0;
+ wrmalt(Adapter, 0x0f000C80, &value, sizeof(value));
- Adapter->SelectedChip = RESET_CHIP_SELECT;
- BcmDoChipSelect(Adapter,uiOffset);
- uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
+ Adapter->SelectedChip = RESET_CHIP_SELECT;
+ BcmDoChipSelect(Adapter, uiOffset);
+ uiPartOffset = (uiOffset & (FLASH_PART_SIZE - 1)) + GetFlashBaseAddr(Adapter);
- for(i = 0 ; i< uiNumBytes; i += Adapter->ulFlashWriteSize)
- {
- if(Adapter->ulFlashWriteSize == BYTE_WRITE_SUPPORT)
- Status = flashByteWrite(Adapter,uiPartOffset, pcBuff);
- else
- Status = flashWrite(Adapter,uiPartOffset, pcBuff);
+ for (i = 0 ; i < uiNumBytes; i += Adapter->ulFlashWriteSize) {
+ if (Adapter->ulFlashWriteSize == BYTE_WRITE_SUPPORT)
+ Status = flashByteWrite(Adapter, uiPartOffset, pcBuff);
+ else
+ Status = flashWrite(Adapter, uiPartOffset, pcBuff);
- if(Status != STATUS_SUCCESS)
- break;
+ if (Status != STATUS_SUCCESS)
+ break;
- pcBuff = pcBuff + Adapter->ulFlashWriteSize;
- uiPartOffset = uiPartOffset + Adapter->ulFlashWriteSize;
- }
- wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
- Adapter->SelectedChip = RESET_CHIP_SELECT;
-#endif
+ pcBuff = pcBuff + Adapter->ulFlashWriteSize;
+ uiPartOffset = uiPartOffset + Adapter->ulFlashWriteSize;
+ }
+ wrmalt(Adapter, 0x0f000C80, &uiTemp, sizeof(uiTemp));
+ Adapter->SelectedChip = RESET_CHIP_SELECT;
+ #endif
return Status;
}
-BOOLEAN IsSectionExistInFlash(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL section)
+BOOLEAN IsSectionExistInFlash(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL section)
{
+ BOOLEAN SectionPresent = FALSE;
+
+ switch (section) {
+ case ISO_IMAGE1:
+ if ((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start != UNINIT_PTR_IN_CS) &&
+ (IsNonCDLessDevice(Adapter) == FALSE))
+ SectionPresent = TRUE;
+ break;
+ case ISO_IMAGE2:
+ if ((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start != UNINIT_PTR_IN_CS) &&
+ (IsNonCDLessDevice(Adapter) == FALSE))
+ SectionPresent = TRUE;
+ break;
+ case DSD0:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart != UNINIT_PTR_IN_CS)
+ SectionPresent = TRUE;
+ break;
+ case DSD1:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start != UNINIT_PTR_IN_CS)
+ SectionPresent = TRUE;
+ break;
+ case DSD2:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start != UNINIT_PTR_IN_CS)
+ SectionPresent = TRUE;
+ break;
+ case VSA0:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart != UNINIT_PTR_IN_CS)
+ SectionPresent = TRUE;
+ break;
+ case VSA1:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start != UNINIT_PTR_IN_CS)
+ SectionPresent = TRUE;
+ break;
+ case VSA2:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start != UNINIT_PTR_IN_CS)
+ SectionPresent = TRUE;
+ break;
+ case SCSI:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
+ SectionPresent = TRUE;
+ break;
+ case CONTROL_SECTION:
+ if (Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart != UNINIT_PTR_IN_CS)
+ SectionPresent = TRUE;
+ break;
+ default:
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section Does not exist in Flash 2.x");
+ SectionPresent = FALSE;
+ }
+
+ return SectionPresent;
+}
- BOOLEAN SectionPresent = FALSE ;
+int IsSectionWritable(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL Section)
+{
+ int offset = STATUS_FAILURE;
+ int Status = FALSE;
- switch(section)
- {
+ if (IsSectionExistInFlash(Adapter, Section) == FALSE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section <%d> does not exixt", Section);
+ return FALSE;
+ }
- case ISO_IMAGE1 :
- if((Adapter->psFlash2xCSInfo->OffsetISOImage1Part1Start != UNINIT_PTR_IN_CS) &&
- (IsNonCDLessDevice(Adapter) == FALSE))
- SectionPresent = TRUE ;
- break;
- case ISO_IMAGE2 :
- if((Adapter->psFlash2xCSInfo->OffsetISOImage2Part1Start != UNINIT_PTR_IN_CS) &&
- (IsNonCDLessDevice(Adapter) == FALSE))
- SectionPresent = TRUE ;
- break;
- case DSD0 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForDSDStart != UNINIT_PTR_IN_CS)
- SectionPresent = TRUE ;
- break;
- case DSD1 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD1Start != UNINIT_PTR_IN_CS)
- SectionPresent = TRUE ;
- break;
- case DSD2 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForDSD2Start != UNINIT_PTR_IN_CS)
- SectionPresent = TRUE ;
- break;
- case VSA0 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForVSAStart != UNINIT_PTR_IN_CS)
- SectionPresent = TRUE ;
- break;
- case VSA1 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA1Start != UNINIT_PTR_IN_CS)
- SectionPresent = TRUE ;
- break;
- case VSA2 :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForVSA2Start != UNINIT_PTR_IN_CS)
- SectionPresent = TRUE ;
- break;
- case SCSI :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForScsiFirmware != UNINIT_PTR_IN_CS)
- SectionPresent = TRUE ;
- break;
- case CONTROL_SECTION :
- if(Adapter->psFlash2xCSInfo->OffsetFromZeroForControlSectionStart != UNINIT_PTR_IN_CS)
- SectionPresent = TRUE ;
- break;
- default :
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Section Does not exist in Flash 2.x");
- SectionPresent = FALSE;
+ offset = BcmGetSectionValStartOffset(Adapter, Section);
+ if (offset == INVALID_OFFSET) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section<%d> does not exixt", Section);
+ return FALSE;
}
- return SectionPresent ;
-}
-INT IsSectionWritable(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL Section)
-{
- INT offset = STATUS_FAILURE;
- INT Status = FALSE;
- if(IsSectionExistInFlash(Adapter,Section) == FALSE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Section <%d> does not exixt", Section);
- return FALSE;
- }
- offset = BcmGetSectionValStartOffset(Adapter,Section);
- if(offset == INVALID_OFFSET)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Section<%d> does not exixt", Section);
- return FALSE;
- }
- if(IsSectionExistInVendorInfo(Adapter,Section))
- {
- return !(Adapter->psFlash2xVendorInfo->VendorSection[Section].AccessFlags & FLASH2X_SECTION_RO);
- }
+ if (IsSectionExistInVendorInfo(Adapter, Section))
+ return !(Adapter->psFlash2xVendorInfo->VendorSection[Section].AccessFlags & FLASH2X_SECTION_RO);
- Status = IsOffsetWritable(Adapter,offset);
- return Status ;
+ Status = IsOffsetWritable(Adapter, offset);
+ return Status;
}
-static INT CorruptDSDSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal)
+static int CorruptDSDSig(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal)
{
-
PUCHAR pBuff = NULL;
- UINT sig = 0;
- UINT uiOffset = 0;
- UINT BlockStatus = 0;
- UINT uiSectAlignAddr = 0;
+ unsigned int sig = 0;
+ unsigned int uiOffset = 0;
+ unsigned int BlockStatus = 0;
+ unsigned int uiSectAlignAddr = 0;
Adapter->bSigCorrupted = FALSE;
-
- if(Adapter->bAllDSDWriteAllow == FALSE)
- {
- if(IsSectionWritable(Adapter,eFlash2xSectionVal) != TRUE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Section is not Writable...Hence can't Corrupt signature");
+ if (Adapter->bAllDSDWriteAllow == FALSE) {
+ if (IsSectionWritable(Adapter, eFlash2xSectionVal) != TRUE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section is not Writable...Hence can't Corrupt signature");
return SECTOR_IS_NOT_WRITABLE;
}
}
pBuff = (PUCHAR)kzalloc(MAX_RW_SIZE, GFP_KERNEL);
- if(pBuff == NULL)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Can't allocate memorey");
- return -ENOMEM ;
+ if (!pBuff) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Can't allocate memorey");
+ return -ENOMEM;
}
uiOffset = Adapter->psFlash2xCSInfo->OffsetFromDSDStartForDSDHeader + sizeof(DSD_HEADER);
- uiOffset -= MAX_RW_SIZE ;
-
- BcmFlash2xBulkRead(Adapter, (PUINT)pBuff,eFlash2xSectionVal,uiOffset,MAX_RW_SIZE);
+ uiOffset -= MAX_RW_SIZE;
+ BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, eFlash2xSectionVal, uiOffset, MAX_RW_SIZE);
- sig = *((PUINT)(pBuff +12));
- sig =ntohl(sig);
- BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,pBuff,MAX_RW_SIZE);
- //Now corrupting the sig by corrupting 4th last Byte.
+ sig = *((PUINT)(pBuff + 12));
+ sig = ntohl(sig);
+ BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pBuff, MAX_RW_SIZE);
+ /* Now corrupting the sig by corrupting 4th last Byte. */
*(pBuff + 12) = 0;
- if(sig == DSD_IMAGE_MAGIC_NUMBER)
- {
+ if (sig == DSD_IMAGE_MAGIC_NUMBER) {
Adapter->bSigCorrupted = TRUE;
- if(Adapter->ulFlashWriteSize == BYTE_WRITE_SUPPORT)
- {
- uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize -1);
- BlockStatus = BcmFlashUnProtectBlock(Adapter,uiSectAlignAddr,Adapter->uiSectorSize);
-
- WriteToFlashWithoutSectorErase(Adapter,(PUINT)(pBuff + 12),eFlash2xSectionVal,
- (uiOffset + 12),BYTE_WRITE_SUPPORT);
- if(BlockStatus)
- {
- BcmRestoreBlockProtectStatus(Adapter,BlockStatus);
+ if (Adapter->ulFlashWriteSize == BYTE_WRITE_SUPPORT) {
+ uiSectAlignAddr = uiOffset & ~(Adapter->uiSectorSize - 1);
+ BlockStatus = BcmFlashUnProtectBlock(Adapter, uiSectAlignAddr, Adapter->uiSectorSize);
+
+ WriteToFlashWithoutSectorErase(Adapter, (PUINT)(pBuff + 12), eFlash2xSectionVal,
+ (uiOffset + 12), BYTE_WRITE_SUPPORT);
+ if (BlockStatus) {
+ BcmRestoreBlockProtectStatus(Adapter, BlockStatus);
BlockStatus = 0;
}
+ } else {
+ WriteToFlashWithoutSectorErase(Adapter, (PUINT)pBuff, eFlash2xSectionVal,
+ uiOffset, MAX_RW_SIZE);
}
- else
- {
- WriteToFlashWithoutSectorErase(Adapter,(PUINT)pBuff,eFlash2xSectionVal,
- uiOffset ,MAX_RW_SIZE);
- }
- }
- else
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"BCM Signature is not present in header");
+ } else {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "BCM Signature is not present in header");
kfree(pBuff);
+
return STATUS_FAILURE;
}
kfree(pBuff);
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Corrupted the signature");
- return STATUS_SUCCESS ;
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Corrupted the signature");
+
+ return STATUS_SUCCESS;
}
-static INT CorruptISOSig(PMINI_ADAPTER Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal)
+static int CorruptISOSig(struct bcm_mini_adapter *Adapter, FLASH2X_SECTION_VAL eFlash2xSectionVal)
{
-
PUCHAR pBuff = NULL;
- UINT sig = 0;
- UINT uiOffset = 0;
+ unsigned int sig = 0;
+ unsigned int uiOffset = 0;
Adapter->bSigCorrupted = FALSE;
- if(IsSectionWritable(Adapter,eFlash2xSectionVal) != TRUE)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Section is not Writable...Hence can't Corrupt signature");
+ if (IsSectionWritable(Adapter, eFlash2xSectionVal) != TRUE) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Section is not Writable...Hence can't Corrupt signature");
return SECTOR_IS_NOT_WRITABLE;
}
pBuff = (PUCHAR)kzalloc(MAX_RW_SIZE, GFP_KERNEL);
- if(pBuff == NULL)
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Can't allocate memorey");
- return -ENOMEM ;
+ if (!pBuff) {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Can't allocate memorey");
+ return -ENOMEM;
}
uiOffset = 0;
- BcmFlash2xBulkRead(Adapter, (PUINT)pBuff,eFlash2xSectionVal,uiOffset, MAX_RW_SIZE);
+ BcmFlash2xBulkRead(Adapter, (PUINT)pBuff, eFlash2xSectionVal, uiOffset, MAX_RW_SIZE);
sig = *((PUINT)pBuff);
- sig =ntohl(sig);
+ sig = ntohl(sig);
- //corrupt signature
+ /* corrupt signature */
*pBuff = 0;
- if(sig == ISO_IMAGE_MAGIC_NUMBER)
- {
+ if (sig == ISO_IMAGE_MAGIC_NUMBER) {
Adapter->bSigCorrupted = TRUE;
- WriteToFlashWithoutSectorErase(Adapter,(PUINT)pBuff,eFlash2xSectionVal,
- uiOffset ,Adapter->ulFlashWriteSize);
- }
- else
- {
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"BCM Signature is not present in header");
+ WriteToFlashWithoutSectorErase(Adapter, (PUINT)pBuff, eFlash2xSectionVal,
+ uiOffset, Adapter->ulFlashWriteSize);
+ } else {
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "BCM Signature is not present in header");
kfree(pBuff);
+
return STATUS_FAILURE;
}
- BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,"Corrupted the signature");
- BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL,pBuff,MAX_RW_SIZE);
+ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, "Corrupted the signature");
+ BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, NVM_RW, DBG_LVL_ALL, pBuff, MAX_RW_SIZE);
kfree(pBuff);
- return STATUS_SUCCESS ;
+ return STATUS_SUCCESS;
}
-BOOLEAN IsNonCDLessDevice(PMINI_ADAPTER Adapter)
+BOOLEAN IsNonCDLessDevice(struct bcm_mini_adapter *Adapter)
{
- if(Adapter->psFlash2xCSInfo->IsCDLessDeviceBootSig == NON_CDLESS_DEVICE_BOOT_SIG)
+ if (Adapter->psFlash2xCSInfo->IsCDLessDeviceBootSig == NON_CDLESS_DEVICE_BOOT_SIG)
return TRUE;
else
- return FALSE ;
+ return FALSE;
}
-
static int compare_packet_info(void const *a, void const *b)
{
- PacketInfo const *pa = a;
- PacketInfo const *pb = b;
+ struct bcm_packet_info const *pa = a;
+ struct bcm_packet_info const *pb = b;
if (!pa->bValid || !pb->bValid)
return 0;
return pa->u8TrafficPriority - pb->u8TrafficPriority;
}
-VOID SortPackInfo(PMINI_ADAPTER Adapter)
+VOID SortPackInfo(struct bcm_mini_adapter *Adapter)
{
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG,
DBG_LVL_ALL, "<=======");
- sort(Adapter->PackInfo, NO_OF_QUEUES, sizeof(PacketInfo),
+ sort(Adapter->PackInfo, NO_OF_QUEUES, sizeof(struct bcm_packet_info),
compare_packet_info, NULL);
}
static int compare_classifiers(void const *a, void const *b)
{
- S_CLASSIFIER_RULE const *pa = a;
- S_CLASSIFIER_RULE const *pb = b;
+ struct bcm_classifier_rule const *pa = a;
+ struct bcm_classifier_rule const *pb = b;
if (!pa->bUsed || !pb->bUsed)
return 0;
return pa->u8ClassifierRulePriority - pb->u8ClassifierRulePriority;
}
-VOID SortClassifiers(PMINI_ADAPTER Adapter)
+VOID SortClassifiers(struct bcm_mini_adapter *Adapter)
{
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CONN_MSG,
DBG_LVL_ALL, "<=======");
sort(Adapter->astClassifierTable, MAX_CLASSIFIERS,
- sizeof(S_CLASSIFIER_RULE), compare_classifiers, NULL);
+ sizeof(struct bcm_classifier_rule), compare_classifiers, NULL);
}
// STATUS_SUCCESS/STATUS_FAILURE
//
//-----------------------------------------------------------------------------
-INT vendorextnInit(PMINI_ADAPTER Adapter)
+INT vendorextnInit(struct bcm_mini_adapter *Adapter)
{
return STATUS_SUCCESS;
}
// STATUS_SUCCESS/STATUS_FAILURE
//
//-----------------------------------------------------------------------------
-INT vendorextnExit(PMINI_ADAPTER Adapter)
+INT vendorextnExit(struct bcm_mini_adapter *Adapter)
{
return STATUS_SUCCESS;
}
// STATUS_SUCCESS/STATUS_FAILURE as per the IOCTL return value
//
//--------------------------------------------------------------------------
-INT vendorextnIoctl(PMINI_ADAPTER Adapter, UINT cmd, ULONG arg)
+INT vendorextnIoctl(struct bcm_mini_adapter *Adapter, UINT cmd, ULONG arg)
{
return CONTINUE_COMMON_PATH;
}
#define CONTINUE_COMMON_PATH 0xFFFF
INT vendorextnGetSectionInfo(PVOID pContext,PFLASH2X_VENDORSPECIFIC_INFO pVendorInfo);
-INT vendorextnExit(PMINI_ADAPTER Adapter);
-INT vendorextnInit(PMINI_ADAPTER Adapter);
-INT vendorextnIoctl(PMINI_ADAPTER Adapter, UINT cmd, ULONG arg);
+INT vendorextnExit(struct bcm_mini_adapter *Adapter);
+INT vendorextnInit(struct bcm_mini_adapter *Adapter);
+INT vendorextnIoctl(struct bcm_mini_adapter *Adapter, UINT cmd, ULONG arg);
INT vendorextnReadSection(PVOID pContext, PUCHAR pBuffer, FLASH2X_SECTION_VAL SectionVal,
UINT offset, UINT numOfBytes);
INT vendorextnWriteSection(PVOID pContext, PUCHAR pBuffer, FLASH2X_SECTION_VAL SectionVal,
config USB_G_CCG
tristate "Configurable Composite Gadget (STAGING)"
- depends on STAGING && !USB_ZERO && !USB_ZERO_HNPTEST && !USB_AUDIO && !GADGET_UAC1 && !USB_ETH && !USB_ETH_RNDIS && !USB_ETH_EEM && !USB_G_NCM && !USB_GADGETFS && !USB_FUNCTIONFS && !USB_FUNCTIONFS_ETH && !USB_FUNCTIONFS_RNDIS && !USB_FUNCTIONFS_GENERIC && !USB_FILE_STORAGE && !USB_FILE_STORAGE_TEST && !USB_MASS_STORAGE && !USB_G_SERIAL && !USB_MIDI_GADGET && !USB_G_PRINTER && !USB_CDC_COMPOSITE && !USB_G_NOKIA && !USB_G_ACM_MS && !USB_G_MULTI && !USB_G_MULTI_RNDIS && !USB_G_MULTI_CDC && !USB_G_HID && !USB_G_DBGP && !USB_G_WEBCAM
+ depends on STAGING && BLOCK && !USB_ZERO && !USB_ZERO_HNPTEST && !USB_AUDIO && !GADGET_UAC1 && !USB_ETH && !USB_ETH_RNDIS && !USB_ETH_EEM && !USB_G_NCM && !USB_GADGETFS && !USB_FUNCTIONFS && !USB_FUNCTIONFS_ETH && !USB_FUNCTIONFS_RNDIS && !USB_FUNCTIONFS_GENERIC && !USB_FILE_STORAGE && !USB_FILE_STORAGE_TEST && !USB_MASS_STORAGE && !USB_G_SERIAL && !USB_MIDI_GADGET && !USB_G_PRINTER && !USB_CDC_COMPOSITE && !USB_G_NOKIA && !USB_G_ACM_MS && !USB_G_MULTI && !USB_G_MULTI_RNDIS && !USB_G_MULTI_CDC && !USB_G_HID && !USB_G_DBGP && !USB_G_WEBCAM
help
The Configurable Composite Gadget supports multiple USB
functions: acm, mass storage, rndis and FunctionFS.
Enable support a wide range of data acquisition devices
for Linux.
+if COMEDI
+
config COMEDI_DEBUG
bool "Comedi debugging"
- depends on COMEDI != n
---help---
This is an option for use by developers; most people should
say N here. This enables comedi core and driver debugging.
config COMEDI_DEFAULT_BUF_SIZE_KB
int "Comedi default initial asynchronous buffer size in KiB"
default "2048"
- depends on COMEDI != n
---help---
This is the default asynchronous buffer size which is used for
commands running in the background in kernel space. This
config COMEDI_DEFAULT_BUF_MAXSIZE_KB
int "Comedi default maximum asynchronous buffer size in KiB"
default "20480"
- depends on COMEDI != n
---help---
This is the default maximum asynchronous buffer size which can
be requested by a userspace program without root privileges.
channels running at 100 kHz has 2-4 seconds of buffer.
menuconfig COMEDI_MISC_DRIVERS
- tristate "Comedi misc drivers"
- depends on COMEDI
+ bool "Comedi misc drivers"
---help---
Enable comedi misc drivers to be built
endif # COMEDI_MISC_DRIVERS
menuconfig COMEDI_ISA_DRIVERS
- tristate "Comedi ISA and PC/104 drivers"
- depends on COMEDI && ISA
+ bool "Comedi ISA and PC/104 drivers"
+ depends on ISA
---help---
Enable comedi ISA and PC/104 drivers to be built
kernel: saying N will just cause the configurator to skip all
the questions about ISA and PC/104 comedi drivers.
-if COMEDI_ISA_DRIVERS && ISA
+if COMEDI_ISA_DRIVERS
config COMEDI_ACL7225B
tristate "ADlink NuDAQ ACL-7225b and compatibles support"
config COMEDI_AMPLC_DIO200_ISA
tristate "Amplicon PC212E/PC214E/PC215E/PC218E/PC272E"
select COMEDI_AMPLC_DIO200
- depends on COMEDI_ISA_DRIVERS
---help---
Enable support for Amplicon PC212E, PC214E, PC215E, PC218E and
PC272E ISA DIO boards
config COMEDI_NI_AT_A2150
tristate "NI AT-A2150 ISA card support"
- depends on COMEDI_NI_COMMON
depends on VIRT_TO_BUS
---help---
Enable support for National Instruments AT-A2150 cards
config COMEDI_NI_AT_AO
tristate "NI AT-AO-6/10 EISA card support"
- depends on COMEDI_NI_COMMON
---help---
Enable support for National Instruments AT-AO-6/10 cards
config COMEDI_NI_ATMIO
tristate "NI AT-MIO E series ISA-PNP card support"
- depends on ISAPNP && COMEDI_NI_TIO && COMEDI_NI_COMMON
+ depends on ISAPNP
select COMEDI_8255
+ select COMEDI_NI_TIO
---help---
Enable support for National Instruments AT-MIO E series cards
National Instruments AT-MIO-16E-1 (ni_atmio),
config COMEDI_NI_ATMIO16D
tristate "NI AT-MIO16/AT-MIO16D series ISA-PNP card support"
- depends on ISAPNP && COMEDI_NI_COMMON
+ depends on ISAPNP
select COMEDI_8255
---help---
Enable support for National Instruments AT-MIO16/AT-MIO16D cards.
endif # COMEDI_ISA_DRIVERS
menuconfig COMEDI_PCI_DRIVERS
- tristate "Comedi PCI drivers"
- depends on COMEDI && PCI
+ bool "Comedi PCI drivers"
+ depends on PCI
---help---
Enable comedi PCI drivers to be built
kernel: saying N will just cause the configurator to skip all
the questions about PCI comedi drivers.
-if COMEDI_PCI_DRIVERS && PCI
+if COMEDI_PCI_DRIVERS
config COMEDI_ADDI_APCI_035
tristate "ADDI-DATA APCI_035 support"
config COMEDI_ADL_PCI6208
tristate "ADLink PCI-6208A support"
- select COMEDI_8255
---help---
Enable support for ADLink PCI-6208A cards
config COMEDI_ADL_PCI7296
tristate "ADLink PCI-7296 96 ch. digital io board support"
+ select COMEDI_8255
---help---
Enable support for ADlink PCI-7296 96 ch. digital io board support
config COMEDI_NI_6527
tristate "NI 6527 support"
- depends on COMEDI_MITE
+ select COMEDI_MITE
---help---
Enable support for the National Instruments 6527 PCI card
config COMEDI_NI_65XX
tristate "NI 65xx static dio PCI card support"
- depends on COMEDI_MITE
+ select COMEDI_MITE
---help---
Enable support for National Instruments 65xx static dio boards.
Supported devices: National Instruments PCI-6509 (ni_65xx),
config COMEDI_NI_660X
tristate "NI 660x counter/timer PCI card support"
- depends on COMEDI_NI_TIO && COMEDI_NI_COMMON
+ select COMEDI_NI_TIOCMD
---help---
Enable support for National Instruments PCI-6601 (ni_660x), PCI-6602,
PXI-6602 and PXI-6608.
config COMEDI_NI_670X
tristate "NI 670x PCI card support"
- depends on COMEDI_MITE
+ select COMEDI_MITE
---help---
Enable support for National Instruments PCI-6703 and PCI-6704
To compile this driver as a module, choose M here: the module will be
called ni_670x.
+config COMEDI_NI_LABPC
+ tristate "NI Lab-PC and compatibles ISA and PCI support"
+ select COMEDI_MITE
+ select COMEDI_8255
+ select COMEDI_FC
+ depends on VIRT_TO_BUS
+ ---help---
+ Enable support for National Instruments Lab-PC and compatibles
+ Lab-PC-1200, Lab-PC-1200AI, Lab-PC+ and PCI-1200.
+ Kernel-level ISA plug-and-play support for the lab-pc-1200 boards has
+ not yet been added to the driver.
+
+ To compile this driver as a module, choose M here: the module will be
+ called ni_labpc.
+
config COMEDI_NI_PCIDIO
tristate "NI PCI-DIO32HS, PCI-DIO96, PCI-6533, PCI-6503 support"
- depends on COMEDI_MITE
+ select COMEDI_MITE
select COMEDI_8255
---help---
Enable support for National Instruments PCI-DIO-32HS, PXI-6533,
config COMEDI_NI_PCIMIO
tristate "NI PCI-MIO-E series and M series support"
- depends on COMEDI_NI_TIO && COMEDI_NI_COMMON
+ select COMEDI_NI_TIOCMD
select COMEDI_8255
select COMEDI_FC
---help---
config COMEDI_RTD520
tristate "Real Time Devices PCI4520/DM7520 support"
- select COMEDI_8255
---help---
Enable support for Real Time Devices PCI4520/DM7520
To compile this driver as a module, choose M here: the module will be
called ssv_dnp.
+config COMEDI_MITE
+ tristate
+
+config COMEDI_NI_TIOCMD
+ tristate
+ select COMEDI_NI_TIO
+ select COMEDI_MITE
+
endif # COMEDI_PCI_DRIVERS
menuconfig COMEDI_PCMCIA_DRIVERS
- tristate "Comedi PCMCIA drivers"
- depends on COMEDI && (PCMCIA || PCCARD)
+ bool "Comedi PCMCIA drivers"
+ depends on PCMCIA
---help---
Enable comedi PCMCIA and PCCARD drivers to be built
kernel: saying N will just cause the configurator to skip all
the questions about PCMCIA comedi drivers.
-if COMEDI_PCMCIA_DRIVERS && PCMCIA
+if COMEDI_PCMCIA_DRIVERS
config COMEDI_CB_DAS16_CS
tristate "CB DAS16 series PCMCIA support"
config COMEDI_NI_DAQ_700_CS
tristate "NI DAQCard-700 PCMCIA support"
- depends on COMEDI_NI_COMMON
---help---
Enable support for the National Instruments PCMCIA DAQCard-700 DIO
config COMEDI_NI_DAQ_DIO24_CS
tristate "NI DAQ-Card DIO-24 PCMCIA support"
- depends on COMEDI_NI_COMMON
select COMEDI_8255
---help---
Enable support for the National Instruments PCMCIA DAQ-Card DIO-24
config COMEDI_NI_MIO_CS
tristate "NI DAQCard E series PCMCIA support"
- depends on COMEDI_NI_TIO && COMEDI_NI_COMMON
+ select COMEDI_NI_TIO
select COMEDI_8255
select COMEDI_FC
---help---
endif # COMEDI_PCMCIA_DRIVERS
menuconfig COMEDI_USB_DRIVERS
- tristate "Comedi USB drivers"
- depends on COMEDI && USB
+ bool "Comedi USB drivers"
+ depends on USB
---help---
Enable comedi USB drivers to be built
kernel: saying N will just cause the configurator to skip all
the questions about USB comedi drivers.
-if COMEDI_USB_DRIVERS && USB
+if COMEDI_USB_DRIVERS
config COMEDI_DT9812
tristate "DataTranslation DT9812 USB module support"
endif # COMEDI_USB_DRIVERS
-menuconfig COMEDI_NI_COMMON
- tristate "Comedi National Instruments card support"
- depends on COMEDI
- ---help---
- Enable comedi support for National Instruments cards.
- Modules in this section are used by many comedi NI drivers.
-
- Note that the answer to this question won't directly affect the
- kernel: saying N will just cause the configurator to skip all
- the questions about National Instruments cards.
-
-if COMEDI_NI_COMMON
-
-config COMEDI_MITE
- tristate "NI Mite PCI interface chip support"
- depends on PCI
- ---help---
- Enable support for National Instruments Mite PCI interface chip
-
- To compile this driver as a module, choose M here: the module will be
- called mite.
-
-config COMEDI_NI_TIO
- tristate "NI general purpose counter support"
- depends on COMEDI_MITE
- ---help---
- Enable support for National Instruments general purpose counters.
- This module is not used directly by end-users. Rather, it
- is used by other drivers (for example ni_660x and ni_pcimio)
- to provide support for NI's general purpose counters.
-
- To compile this driver as a modules, choose M here: two modules will
- be build: ni_tio and ni_tiocmd.
-
-config COMEDI_NI_LABPC
- tristate "NI Lab-PC and compatibles ISA and PCI support"
- depends on COMEDI_MITE
- select COMEDI_8255
- select COMEDI_FC
- depends on VIRT_TO_BUS
- ---help---
- Enable support for National Instruments Lab-PC and compatibles
- Lab-PC-1200, Lab-PC-1200AI, Lab-PC+ and PCI-1200.
- Kernel-level ISA plug-and-play support for the lab-pc-1200 boards has
- not yet been added to the driver.
-
- To compile this driver as a module, choose M here: the module will be
- called ni_labpc.
-
-endif # COMEDI_NI_COMMON
-
config COMEDI_8255
tristate "Generic 8255 support"
- depends on COMEDI
---help---
Enable generic 8255 support.
called 8255.
config COMEDI_FC
- tristate "Comedi shared functions for low-level driver support"
- depends on COMEDI
- ---help---
- Enable support for shared functions for low-level drivers.
- This module is not used directly by end-users. Rather, it
- is used by many other comedi drivers.
-
- To compile this driver as a module, choose M here: the module will be
- called comedi_fc.
+ tristate
config COMEDI_AMPLC_DIO200
tristate
- depends on COMEDI
select COMEDI_8255
config COMEDI_AMPLC_PC236
tristate
- depends on COMEDI
select COMEDI_8255
config COMEDI_AMPLC_PC263
tristate
- depends on COMEDI
config COMEDI_DAS08
tristate
- depends on COMEDI
select COMEDI_8255
+
+config COMEDI_NI_TIO
+ tristate
+
+endif # COMEDI
#define __NO_VERSION__
#include <linux/uaccess.h>
+#include <linux/compat.h>
+#include <linux/fs.h>
#include "comedi.h"
#include "comedi_compat32.h"
#ifndef _COMEDI_COMPAT32_H
#define _COMEDI_COMPAT32_H
-#include <linux/compat.h>
-#include <linux/fs.h>
-
#ifdef CONFIG_COMPAT
+struct file;
extern long comedi_compat_ioctl(struct file *file, unsigned int cmd,
unsigned long arg);
#else /* CONFIG_COMPAT */
-#define comedi_compat_ioctl 0 /* NULL */
+#define comedi_compat_ioctl NULL
#endif /* CONFIG_COMPAT */
#undef DEBUG
#define __NO_VERSION__
-#include "comedi_fops.h"
#include "comedi_compat32.h"
#include <linux/module.h>
#include <linux/io.h>
#include <linux/uaccess.h>
-#include "internal.h"
+#include "comedi_internal.h"
MODULE_AUTHOR("http://www.comedi.org");
MODULE_DESCRIPTION("Comedi core module");
static struct comedi_device_file_info
*comedi_file_info_table[COMEDI_NUM_MINORS];
-static int do_devconfig_ioctl(struct comedi_device *dev,
- struct comedi_devconfig __user *arg);
-static int do_bufconfig_ioctl(struct comedi_device *dev,
- struct comedi_bufconfig __user *arg);
-static int do_devinfo_ioctl(struct comedi_device *dev,
- struct comedi_devinfo __user *arg,
- struct file *file);
-static int do_subdinfo_ioctl(struct comedi_device *dev,
- struct comedi_subdinfo __user *arg, void *file);
-static int do_chaninfo_ioctl(struct comedi_device *dev,
- struct comedi_chaninfo __user *arg);
-static int do_bufinfo_ioctl(struct comedi_device *dev,
- struct comedi_bufinfo __user *arg, void *file);
-static int do_cmd_ioctl(struct comedi_device *dev,
- struct comedi_cmd __user *arg, void *file);
-static int do_lock_ioctl(struct comedi_device *dev, unsigned int arg,
- void *file);
-static int do_unlock_ioctl(struct comedi_device *dev, unsigned int arg,
- void *file);
-static int do_cancel_ioctl(struct comedi_device *dev, unsigned int arg,
- void *file);
-static int do_cmdtest_ioctl(struct comedi_device *dev,
- struct comedi_cmd __user *arg, void *file);
-static int do_insnlist_ioctl(struct comedi_device *dev,
- struct comedi_insnlist __user *arg, void *file);
-static int do_insn_ioctl(struct comedi_device *dev,
- struct comedi_insn __user *arg, void *file);
-static int do_poll_ioctl(struct comedi_device *dev, unsigned int subd,
- void *file);
-
static void do_become_nonbusy(struct comedi_device *dev,
struct comedi_subdevice *s);
static int do_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
/* sysfs attribute files */
-static const unsigned bytes_per_kibi = 1024;
-
static ssize_t show_max_read_buffer_kb(struct device *dev,
struct device_attribute *attr, char *buf)
{
- ssize_t retval;
struct comedi_device_file_info *info = dev_get_drvdata(dev);
- unsigned max_buffer_size_kb = 0;
- struct comedi_subdevice *const read_subdevice =
- comedi_get_read_subdevice(info);
+ struct comedi_subdevice *s = comedi_get_read_subdevice(info);
+ unsigned int size = 0;
mutex_lock(&info->device->mutex);
- if (read_subdevice &&
- (read_subdevice->subdev_flags & SDF_CMD_READ) &&
- read_subdevice->async) {
- max_buffer_size_kb = read_subdevice->async->max_bufsize /
- bytes_per_kibi;
- }
- retval = snprintf(buf, PAGE_SIZE, "%i\n", max_buffer_size_kb);
+ if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
+ size = s->async->max_bufsize / 1024;
mutex_unlock(&info->device->mutex);
- return retval;
+ return snprintf(buf, PAGE_SIZE, "%i\n", size);
}
static ssize_t store_max_read_buffer_kb(struct device *dev,
const char *buf, size_t count)
{
struct comedi_device_file_info *info = dev_get_drvdata(dev);
- unsigned int new_max_size_kb;
- unsigned int new_max_size;
- int ret;
- struct comedi_subdevice *const read_subdevice =
- comedi_get_read_subdevice(info);
-
- ret = kstrtouint(buf, 10, &new_max_size_kb);
- if (ret)
- return ret;
- if (new_max_size_kb > (UINT_MAX / bytes_per_kibi))
+ struct comedi_subdevice *s = comedi_get_read_subdevice(info);
+ unsigned int size;
+ int err;
+
+ err = kstrtouint(buf, 10, &size);
+ if (err)
+ return err;
+ if (size > (UINT_MAX / 1024))
return -EINVAL;
- new_max_size = new_max_size_kb * bytes_per_kibi;
+ size *= 1024;
mutex_lock(&info->device->mutex);
- if (read_subdevice == NULL ||
- (read_subdevice->subdev_flags & SDF_CMD_READ) == 0 ||
- read_subdevice->async == NULL) {
- mutex_unlock(&info->device->mutex);
- return -EINVAL;
- }
- read_subdevice->async->max_bufsize = new_max_size;
+ if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
+ s->async->max_bufsize = size;
+ else
+ err = -EINVAL;
mutex_unlock(&info->device->mutex);
- return count;
+ return err ? err : count;
}
static ssize_t show_read_buffer_kb(struct device *dev,
struct device_attribute *attr, char *buf)
{
- ssize_t retval;
struct comedi_device_file_info *info = dev_get_drvdata(dev);
- unsigned buffer_size_kb = 0;
- struct comedi_subdevice *const read_subdevice =
- comedi_get_read_subdevice(info);
+ struct comedi_subdevice *s = comedi_get_read_subdevice(info);
+ unsigned int size = 0;
mutex_lock(&info->device->mutex);
- if (read_subdevice &&
- (read_subdevice->subdev_flags & SDF_CMD_READ) &&
- read_subdevice->async) {
- buffer_size_kb = read_subdevice->async->prealloc_bufsz /
- bytes_per_kibi;
- }
- retval = snprintf(buf, PAGE_SIZE, "%i\n", buffer_size_kb);
+ if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
+ size = s->async->prealloc_bufsz / 1024;
mutex_unlock(&info->device->mutex);
- return retval;
+ return snprintf(buf, PAGE_SIZE, "%i\n", size);
}
static ssize_t store_read_buffer_kb(struct device *dev,
const char *buf, size_t count)
{
struct comedi_device_file_info *info = dev_get_drvdata(dev);
- unsigned int new_size_kb;
- unsigned int new_size;
- int retval;
- int ret;
- struct comedi_subdevice *const read_subdevice =
- comedi_get_read_subdevice(info);
-
- ret = kstrtouint(buf, 10, &new_size_kb);
- if (ret)
- return ret;
- if (new_size_kb > (UINT_MAX / bytes_per_kibi))
+ struct comedi_subdevice *s = comedi_get_read_subdevice(info);
+ unsigned int size;
+ int err;
+
+ err = kstrtouint(buf, 10, &size);
+ if (err)
+ return err;
+ if (size > (UINT_MAX / 1024))
return -EINVAL;
- new_size = new_size_kb * bytes_per_kibi;
+ size *= 1024;
mutex_lock(&info->device->mutex);
- if (read_subdevice == NULL ||
- (read_subdevice->subdev_flags & SDF_CMD_READ) == 0 ||
- read_subdevice->async == NULL) {
- mutex_unlock(&info->device->mutex);
- return -EINVAL;
- }
- retval = resize_async_buffer(info->device, read_subdevice,
- read_subdevice->async, new_size);
+ if (s && (s->subdev_flags & SDF_CMD_READ) && s->async)
+ err = resize_async_buffer(info->device, s, s->async, size);
+ else
+ err = -EINVAL;
mutex_unlock(&info->device->mutex);
- if (retval < 0)
- return retval;
- return count;
+ return err ? err : count;
}
static ssize_t show_max_write_buffer_kb(struct device *dev,
struct device_attribute *attr,
char *buf)
{
- ssize_t retval;
struct comedi_device_file_info *info = dev_get_drvdata(dev);
- unsigned max_buffer_size_kb = 0;
- struct comedi_subdevice *const write_subdevice =
- comedi_get_write_subdevice(info);
+ struct comedi_subdevice *s = comedi_get_write_subdevice(info);
+ unsigned int size = 0;
mutex_lock(&info->device->mutex);
- if (write_subdevice &&
- (write_subdevice->subdev_flags & SDF_CMD_WRITE) &&
- write_subdevice->async) {
- max_buffer_size_kb = write_subdevice->async->max_bufsize /
- bytes_per_kibi;
- }
- retval = snprintf(buf, PAGE_SIZE, "%i\n", max_buffer_size_kb);
+ if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
+ size = s->async->max_bufsize / 1024;
mutex_unlock(&info->device->mutex);
- return retval;
+ return snprintf(buf, PAGE_SIZE, "%i\n", size);
}
static ssize_t store_max_write_buffer_kb(struct device *dev,
const char *buf, size_t count)
{
struct comedi_device_file_info *info = dev_get_drvdata(dev);
- unsigned int new_max_size_kb;
- unsigned int new_max_size;
- int ret;
- struct comedi_subdevice *const write_subdevice =
- comedi_get_write_subdevice(info);
-
- ret = kstrtouint(buf, 10, &new_max_size_kb);
- if (ret)
- return ret;
- if (new_max_size_kb > (UINT_MAX / bytes_per_kibi))
+ struct comedi_subdevice *s = comedi_get_write_subdevice(info);
+ unsigned int size;
+ int err;
+
+ err = kstrtouint(buf, 10, &size);
+ if (err)
+ return err;
+ if (size > (UINT_MAX / 1024))
return -EINVAL;
- new_max_size = new_max_size_kb * bytes_per_kibi;
+ size *= 1024;
mutex_lock(&info->device->mutex);
- if (write_subdevice == NULL ||
- (write_subdevice->subdev_flags & SDF_CMD_WRITE) == 0 ||
- write_subdevice->async == NULL) {
- mutex_unlock(&info->device->mutex);
- return -EINVAL;
- }
- write_subdevice->async->max_bufsize = new_max_size;
+ if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
+ s->async->max_bufsize = size;
+ else
+ err = -EINVAL;
mutex_unlock(&info->device->mutex);
- return count;
+ return err ? err : count;
}
static ssize_t show_write_buffer_kb(struct device *dev,
struct device_attribute *attr, char *buf)
{
- ssize_t retval;
struct comedi_device_file_info *info = dev_get_drvdata(dev);
- unsigned buffer_size_kb = 0;
- struct comedi_subdevice *const write_subdevice =
- comedi_get_write_subdevice(info);
+ struct comedi_subdevice *s = comedi_get_write_subdevice(info);
+ unsigned int size = 0;
mutex_lock(&info->device->mutex);
- if (write_subdevice &&
- (write_subdevice->subdev_flags & SDF_CMD_WRITE) &&
- write_subdevice->async) {
- buffer_size_kb = write_subdevice->async->prealloc_bufsz /
- bytes_per_kibi;
- }
- retval = snprintf(buf, PAGE_SIZE, "%i\n", buffer_size_kb);
+ if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
+ size = s->async->prealloc_bufsz / 1024;
mutex_unlock(&info->device->mutex);
- return retval;
+ return snprintf(buf, PAGE_SIZE, "%i\n", size);
}
static ssize_t store_write_buffer_kb(struct device *dev,
const char *buf, size_t count)
{
struct comedi_device_file_info *info = dev_get_drvdata(dev);
- unsigned int new_size_kb;
- unsigned int new_size;
- int retval;
- int ret;
- struct comedi_subdevice *const write_subdevice =
- comedi_get_write_subdevice(info);
-
- ret = kstrtouint(buf, 10, &new_size_kb);
- if (ret)
- return ret;
- if (new_size_kb > (UINT_MAX / bytes_per_kibi))
+ struct comedi_subdevice *s = comedi_get_write_subdevice(info);
+ unsigned int size;
+ int err;
+
+ err = kstrtouint(buf, 10, &size);
+ if (err)
+ return err;
+ if (size > (UINT_MAX / 1024))
return -EINVAL;
- new_size = ((uint64_t) new_size_kb) * bytes_per_kibi;
+ size *= 1024;
mutex_lock(&info->device->mutex);
- if (write_subdevice == NULL ||
- (write_subdevice->subdev_flags & SDF_CMD_WRITE) == 0 ||
- write_subdevice->async == NULL) {
- mutex_unlock(&info->device->mutex);
- return -EINVAL;
- }
- retval = resize_async_buffer(info->device, write_subdevice,
- write_subdevice->async, new_size);
+ if (s && (s->subdev_flags & SDF_CMD_WRITE) && s->async)
+ err = resize_async_buffer(info->device, s, s->async, size);
+ else
+ err = -EINVAL;
mutex_unlock(&info->device->mutex);
- if (retval < 0)
- return retval;
- return count;
+ return err ? err : count;
}
static struct device_attribute comedi_dev_attrs[] = {
__ATTR_NULL
};
-static long comedi_unlocked_ioctl(struct file *file, unsigned int cmd,
- unsigned long arg)
-{
- const unsigned minor = iminor(file->f_dentry->d_inode);
- struct comedi_device_file_info *dev_file_info =
- comedi_get_device_file_info(minor);
- struct comedi_device *dev;
- int rc;
-
- if (dev_file_info == NULL || dev_file_info->device == NULL)
- return -ENODEV;
- dev = dev_file_info->device;
-
- mutex_lock(&dev->mutex);
-
- /* Device config is special, because it must work on
- * an unconfigured device. */
- if (cmd == COMEDI_DEVCONFIG) {
- rc = do_devconfig_ioctl(dev,
- (struct comedi_devconfig __user *)arg);
- goto done;
- }
-
- if (!dev->attached) {
- DPRINTK("no driver configured on /dev/comedi%i\n", dev->minor);
- rc = -ENODEV;
- goto done;
- }
-
- switch (cmd) {
- case COMEDI_BUFCONFIG:
- rc = do_bufconfig_ioctl(dev,
- (struct comedi_bufconfig __user *)arg);
- break;
- case COMEDI_DEVINFO:
- rc = do_devinfo_ioctl(dev, (struct comedi_devinfo __user *)arg,
- file);
- break;
- case COMEDI_SUBDINFO:
- rc = do_subdinfo_ioctl(dev,
- (struct comedi_subdinfo __user *)arg,
- file);
- break;
- case COMEDI_CHANINFO:
- rc = do_chaninfo_ioctl(dev, (void __user *)arg);
- break;
- case COMEDI_RANGEINFO:
- rc = do_rangeinfo_ioctl(dev, (void __user *)arg);
- break;
- case COMEDI_BUFINFO:
- rc = do_bufinfo_ioctl(dev,
- (struct comedi_bufinfo __user *)arg,
- file);
- break;
- case COMEDI_LOCK:
- rc = do_lock_ioctl(dev, arg, file);
- break;
- case COMEDI_UNLOCK:
- rc = do_unlock_ioctl(dev, arg, file);
- break;
- case COMEDI_CANCEL:
- rc = do_cancel_ioctl(dev, arg, file);
- break;
- case COMEDI_CMD:
- rc = do_cmd_ioctl(dev, (struct comedi_cmd __user *)arg, file);
- break;
- case COMEDI_CMDTEST:
- rc = do_cmdtest_ioctl(dev, (struct comedi_cmd __user *)arg,
- file);
- break;
- case COMEDI_INSNLIST:
- rc = do_insnlist_ioctl(dev,
- (struct comedi_insnlist __user *)arg,
- file);
- break;
- case COMEDI_INSN:
- rc = do_insn_ioctl(dev, (struct comedi_insn __user *)arg,
- file);
- break;
- case COMEDI_POLL:
- rc = do_poll_ioctl(dev, arg, file);
- break;
- default:
- rc = -ENOTTY;
- break;
- }
-
-done:
- mutex_unlock(&dev->mutex);
- return rc;
-}
-
/*
COMEDI_DEVCONFIG
device config ioctl
return -EINVAL;
}
+static long comedi_unlocked_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ const unsigned minor = iminor(file->f_dentry->d_inode);
+ struct comedi_device_file_info *dev_file_info =
+ comedi_get_device_file_info(minor);
+ struct comedi_device *dev;
+ int rc;
+
+ if (dev_file_info == NULL || dev_file_info->device == NULL)
+ return -ENODEV;
+ dev = dev_file_info->device;
+
+ mutex_lock(&dev->mutex);
+
+ /* Device config is special, because it must work on
+ * an unconfigured device. */
+ if (cmd == COMEDI_DEVCONFIG) {
+ rc = do_devconfig_ioctl(dev,
+ (struct comedi_devconfig __user *)arg);
+ goto done;
+ }
+
+ if (!dev->attached) {
+ DPRINTK("no driver configured on /dev/comedi%i\n", dev->minor);
+ rc = -ENODEV;
+ goto done;
+ }
+
+ switch (cmd) {
+ case COMEDI_BUFCONFIG:
+ rc = do_bufconfig_ioctl(dev,
+ (struct comedi_bufconfig __user *)arg);
+ break;
+ case COMEDI_DEVINFO:
+ rc = do_devinfo_ioctl(dev, (struct comedi_devinfo __user *)arg,
+ file);
+ break;
+ case COMEDI_SUBDINFO:
+ rc = do_subdinfo_ioctl(dev,
+ (struct comedi_subdinfo __user *)arg,
+ file);
+ break;
+ case COMEDI_CHANINFO:
+ rc = do_chaninfo_ioctl(dev, (void __user *)arg);
+ break;
+ case COMEDI_RANGEINFO:
+ rc = do_rangeinfo_ioctl(dev, (void __user *)arg);
+ break;
+ case COMEDI_BUFINFO:
+ rc = do_bufinfo_ioctl(dev,
+ (struct comedi_bufinfo __user *)arg,
+ file);
+ break;
+ case COMEDI_LOCK:
+ rc = do_lock_ioctl(dev, arg, file);
+ break;
+ case COMEDI_UNLOCK:
+ rc = do_unlock_ioctl(dev, arg, file);
+ break;
+ case COMEDI_CANCEL:
+ rc = do_cancel_ioctl(dev, arg, file);
+ break;
+ case COMEDI_CMD:
+ rc = do_cmd_ioctl(dev, (struct comedi_cmd __user *)arg, file);
+ break;
+ case COMEDI_CMDTEST:
+ rc = do_cmdtest_ioctl(dev, (struct comedi_cmd __user *)arg,
+ file);
+ break;
+ case COMEDI_INSNLIST:
+ rc = do_insnlist_ioctl(dev,
+ (struct comedi_insnlist __user *)arg,
+ file);
+ break;
+ case COMEDI_INSN:
+ rc = do_insn_ioctl(dev, (struct comedi_insn __user *)arg,
+ file);
+ break;
+ case COMEDI_POLL:
+ rc = do_poll_ioctl(dev, arg, file);
+ break;
+ default:
+ rc = -ENOTTY;
+ break;
+ }
+
+done:
+ mutex_unlock(&dev->mutex);
+ return rc;
+}
+
static int do_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
{
int ret = 0;
return fasync_helper(fd, file, on, &dev->async_queue);
}
-const struct file_operations comedi_fops = {
+static const struct file_operations comedi_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = comedi_unlocked_ioctl,
.compat_ioctl = comedi_compat_ioctl,
.llseek = noop_llseek,
};
-struct class *comedi_class;
+static struct class *comedi_class;
static struct cdev comedi_cdev;
static void comedi_cleanup_legacy_minors(void)
+++ /dev/null
-
-#ifndef _COMEDI_FOPS_H
-#define _COMEDI_FOPS_H
-#include <linux/types.h>
-
-extern struct class *comedi_class;
-extern const struct file_operations comedi_fops;
-extern bool comedi_autoconfig;
-extern struct comedi_driver *comedi_drivers;
-
-#endif /* _COMEDI_FOPS_H */
--- /dev/null
+#ifndef _COMEDI_INTERNAL_H
+#define _COMEDI_INTERNAL_H
+
+#include <linux/types.h>
+
+/*
+ * various internal comedi stuff
+ */
+int do_rangeinfo_ioctl(struct comedi_device *dev,
+ struct comedi_rangeinfo __user *arg);
+int insn_inval(struct comedi_device *dev, struct comedi_subdevice *s,
+ struct comedi_insn *insn, unsigned int *data);
+int comedi_alloc_board_minor(struct device *hardware_device);
+void comedi_free_board_minor(unsigned minor);
+int comedi_find_board_minor(struct device *hardware_device);
+void comedi_reset_async_buf(struct comedi_async *async);
+int comedi_buf_alloc(struct comedi_device *dev, struct comedi_subdevice *s,
+ unsigned long new_size);
+
+extern unsigned int comedi_default_buf_size_kb;
+extern unsigned int comedi_default_buf_maxsize_kb;
+extern bool comedi_autoconfig;
+extern struct comedi_driver *comedi_drivers;
+
+#endif /* _COMEDI_INTERNAL_H */
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/timer.h>
+#include <linux/pci.h>
#include "comedi.h"
unsigned runflags;
spinlock_t spin_lock;
- int io_bits;
+ unsigned int io_bits;
unsigned int maxdata; /* if maxdata==0, use list */
const unsigned int *maxdata_list; /* list is channel specific */
unsigned int x);
};
-struct pci_dev;
struct usb_interface;
struct comedi_driver {
return info->device->write_subdev;
}
+int comedi_alloc_subdevices(struct comedi_device *, int);
+
void comedi_device_detach(struct comedi_device *dev);
int comedi_device_attach(struct comedi_device *dev,
struct comedi_devconfig *it);
module_driver(__comedi_driver, comedi_driver_register, \
comedi_driver_unregister)
-struct pci_driver;
+int comedi_pci_enable(struct pci_dev *, const char *);
+void comedi_pci_disable(struct pci_dev *);
int comedi_pci_driver_register(struct comedi_driver *, struct pci_driver *);
void comedi_pci_driver_unregister(struct comedi_driver *, struct pci_driver *);
/* some silly little inline functions */
-static inline int alloc_subdevices(struct comedi_device *dev,
- unsigned int num_subdevices)
-{
- unsigned i;
-
- dev->n_subdevices = num_subdevices;
- dev->subdevices =
- kcalloc(num_subdevices, sizeof(struct comedi_subdevice),
- GFP_KERNEL);
- if (!dev->subdevices)
- return -ENOMEM;
- for (i = 0; i < num_subdevices; ++i) {
- dev->subdevices[i].device = dev;
- dev->subdevices[i].async_dma_dir = DMA_NONE;
- spin_lock_init(&dev->subdevices[i].spin_lock);
- dev->subdevices[i].minor = -1;
- }
- return 0;
-}
-
static inline int alloc_private(struct comedi_device *dev, int size)
{
dev->private = kzalloc(size, GFP_KERNEL);
struct comedi_driver *driver);
void comedi_usb_auto_unconfig(struct usb_interface *intf);
-#ifdef CONFIG_COMEDI_PCI_DRIVERS
-#define CONFIG_COMEDI_PCI
-#endif
-#ifdef CONFIG_COMEDI_PCI_DRIVERS_MODULE
-#define CONFIG_COMEDI_PCI
-#endif
-#ifdef CONFIG_COMEDI_PCMCIA_DRIVERS
-#define CONFIG_COMEDI_PCMCIA
-#endif
-#ifdef CONFIG_COMEDI_PCMCIA_DRIVERS_MODULE
-#define CONFIG_COMEDI_PCMCIA
-#endif
-
#endif /* _COMEDIDEV_H */
#define _GNU_SOURCE
#define __NO_VERSION__
-#include "comedi_fops.h"
#include <linux/device.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/io.h>
#include "comedidev.h"
-#include "internal.h"
+#include "comedi_internal.h"
static int postconfig(struct comedi_device *dev);
static int insn_rw_emulate_bits(struct comedi_device *dev,
struct comedi_driver *comedi_drivers;
+int comedi_alloc_subdevices(struct comedi_device *dev, int num_subdevices)
+{
+ struct comedi_subdevice *s;
+ int i;
+
+ if (num_subdevices < 1)
+ return -EINVAL;
+
+ s = kcalloc(num_subdevices, sizeof(*s), GFP_KERNEL);
+ if (!s)
+ return -ENOMEM;
+ dev->subdevices = s;
+ dev->n_subdevices = num_subdevices;
+
+ for (i = 0; i < num_subdevices; ++i) {
+ s = dev->subdevices + i;
+ s->device = dev;
+ s->async_dma_dir = DMA_NONE;
+ spin_lock_init(&s->spin_lock);
+ s->minor = -1;
+ }
+ return 0;
+}
+EXPORT_SYMBOL_GPL(comedi_alloc_subdevices);
+
static void cleanup_device(struct comedi_device *dev)
{
int i;
return 0;
}
-/* generic recognize function for drivers
- * that register their supported board names */
+/*
+ * Generic recognize function for drivers that register their supported
+ * board names.
+ *
+ * 'driv->board_name' points to a 'const char *' member within the
+ * zeroth element of an array of some private board information
+ * structure, say 'struct foo_board' containing a member 'const char
+ * *board_name' that is initialized to point to a board name string that
+ * is one of the candidates matched against this function's 'name'
+ * parameter.
+ *
+ * 'driv->offset' is the size of the private board information
+ * structure, say 'sizeof(struct foo_board)', and 'driv->num_names' is
+ * the length of the array of private board information structures.
+ *
+ * If one of the board names in the array of private board information
+ * structures matches the name supplied to this function, the function
+ * returns a pointer to the pointer to the board name, otherwise it
+ * returns NULL. The return value ends up in the 'board_ptr' member of
+ * a 'struct comedi_device' that the low-level comedi driver's
+ * 'attach()' hook can convert to a point to a particular element of its
+ * array of private board information structures by subtracting the
+ * offset of the member that points to the board name. (No subtraction
+ * is required if the board name pointer is the first member of the
+ * private board information structure, which is generally the case.)
+ */
static void *comedi_recognize(struct comedi_driver *driv, const char *name)
{
- unsigned i;
- const char *const *name_ptr = driv->board_name;
+ char **name_ptr = (char **)driv->board_name;
+ int i;
+
for (i = 0; i < driv->num_names; i++) {
if (strcmp(*name_ptr, name) == 0)
- return (void *)name_ptr;
- name_ptr =
- (const char *const *)((const char *)name_ptr +
- driv->offset);
+ return name_ptr;
+ name_ptr = (void *)name_ptr + driv->offset;
}
return NULL;
return 1;
}
-static inline unsigned long uvirt_to_kva(pgd_t *pgd, unsigned long adr)
-{
- unsigned long ret = 0UL;
- pmd_t *pmd;
- pte_t *ptep, pte;
- pud_t *pud;
-
- if (!pgd_none(*pgd)) {
- pud = pud_offset(pgd, adr);
- pmd = pmd_offset(pud, adr);
- if (!pmd_none(*pmd)) {
- ptep = pte_offset_kernel(pmd, adr);
- pte = *ptep;
- if (pte_present(pte)) {
- ret = (unsigned long)
- page_address(pte_page(pte));
- ret |= (adr & (PAGE_SIZE - 1));
- }
- }
- }
- return ret;
-}
-
-static inline unsigned long kvirt_to_kva(unsigned long adr)
-{
- unsigned long va, kva;
-
- va = adr;
- kva = uvirt_to_kva(pgd_offset_k(va), va);
-
- return kva;
-}
-
int comedi_buf_alloc(struct comedi_device *dev, struct comedi_subdevice *s,
unsigned long new_size)
{
comedi_free_board_minor(minor);
}
+/**
+ * comedi_pci_enable() - Enable the PCI device and request the regions.
+ * @pdev: pci_dev struct
+ * @res_name: name for the requested reqource
+ */
+int comedi_pci_enable(struct pci_dev *pdev, const char *res_name)
+{
+ int rc;
+
+ rc = pci_enable_device(pdev);
+ if (rc < 0)
+ return rc;
+
+ rc = pci_request_regions(pdev, res_name);
+ if (rc < 0)
+ pci_disable_device(pdev);
+
+ return rc;
+}
+EXPORT_SYMBOL_GPL(comedi_pci_enable);
+
+/**
+ * comedi_pci_disable() - Release the regions and disable the PCI device.
+ * @pdev: pci_dev struct
+ *
+ * This must be matched with a previous successful call to comedi_pci_enable().
+ */
+void comedi_pci_disable(struct pci_dev *pdev)
+{
+ pci_release_regions(pdev);
+ pci_disable_device(pdev);
+}
+EXPORT_SYMBOL_GPL(comedi_pci_disable);
+
static int comedi_old_pci_auto_config(struct pci_dev *pcidev,
struct comedi_driver *driver)
{
set up the subdevice in the attach function of the driver by
calling:
- subdev_8255_init(device, subdevice, callback_function, arg)
+ subdev_8255_init(device, subdevice, io_function, iobase)
device and subdevice are pointers to the device and subdevice
- structures. callback_function will be called to provide the
+ structures. io_function will be called to provide the
low-level input/output to the device, i.e., actual register
- access. callback_function will be called with the value of arg
+ access. io_function will be called with the value of iobase
as the last parameter. If the 8255 device is mapped as 4
- consecutive I/O ports, you can use NULL for callback_function
- and the I/O port base for arg, and an internal function will
+ consecutive I/O ports, you can use NULL for io_function
+ and the I/O port base for iobase, and an internal function will
handle the register access.
In addition, if the main driver handles interrupts, you can
#include <linux/slab.h>
#include "8255.h"
-#define _8255_SIZE 4
+#define _8255_SIZE 4
-#define _8255_DATA 0
-#define _8255_CR 3
+#define _8255_DATA 0
+#define _8255_CR 3
#define CR_C_LO_IO 0x01
#define CR_B_IO 0x02
#define CR_A_MODE(a) ((a)<<5)
#define CR_CW 0x80
-struct subdev_8255_struct {
- unsigned long cb_arg;
- int (*cb_func) (int, int, int, unsigned long);
- int have_irq;
+struct subdev_8255_private {
+ unsigned long iobase;
+ int (*io) (int, int, int, unsigned long);
};
-#define CALLBACK_ARG (((struct subdev_8255_struct *)s->private)->cb_arg)
-#define CALLBACK_FUNC (((struct subdev_8255_struct *)s->private)->cb_func)
-#define subdevpriv ((struct subdev_8255_struct *)s->private)
+static int subdev_8255_io(int dir, int port, int data, unsigned long iobase)
+{
+ if (dir) {
+ outb(data, iobase + port);
+ return 0;
+ } else {
+ return inb(iobase + port);
+ }
+}
void subdev_8255_interrupt(struct comedi_device *dev,
struct comedi_subdevice *s)
{
+ struct subdev_8255_private *spriv = s->private;
+ unsigned long iobase = spriv->iobase;
short d;
- d = CALLBACK_FUNC(0, _8255_DATA, 0, CALLBACK_ARG);
- d |= (CALLBACK_FUNC(0, _8255_DATA + 1, 0, CALLBACK_ARG) << 8);
+ d = spriv->io(0, _8255_DATA, 0, iobase);
+ d |= (spriv->io(0, _8255_DATA + 1, 0, iobase) << 8);
comedi_buf_put(s->async, d);
s->async->events |= COMEDI_CB_EOS;
}
EXPORT_SYMBOL(subdev_8255_interrupt);
-static int subdev_8255_cb(int dir, int port, int data, unsigned long arg)
-{
- unsigned long iobase = arg;
-
- if (dir) {
- outb(data, iobase + port);
- return 0;
- } else {
- return inb(iobase + port);
- }
-}
-
static int subdev_8255_insn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (data[0]) {
- s->state &= ~data[0];
- s->state |= (data[0] & data[1]);
-
- if (data[0] & 0xff)
- CALLBACK_FUNC(1, _8255_DATA, s->state & 0xff,
- CALLBACK_ARG);
- if (data[0] & 0xff00)
- CALLBACK_FUNC(1, _8255_DATA + 1, (s->state >> 8) & 0xff,
- CALLBACK_ARG);
- if (data[0] & 0xff0000)
- CALLBACK_FUNC(1, _8255_DATA + 2,
- (s->state >> 16) & 0xff, CALLBACK_ARG);
+ struct subdev_8255_private *spriv = s->private;
+ unsigned long iobase = spriv->iobase;
+ unsigned int mask;
+ unsigned int bits;
+ unsigned int v;
+
+ mask = data[0];
+ bits = data[1];
+
+ if (mask) {
+ v = s->state;
+ v &= ~mask;
+ v |= (bits & mask);
+
+ if (mask & 0xff)
+ spriv->io(1, _8255_DATA, v & 0xff, iobase);
+ if (mask & 0xff00)
+ spriv->io(1, _8255_DATA + 1, (v >> 8) & 0xff, iobase);
+ if (mask & 0xff0000)
+ spriv->io(1, _8255_DATA + 2, (v >> 16) & 0xff, iobase);
+
+ s->state = v;
}
- data[1] = CALLBACK_FUNC(0, _8255_DATA, 0, CALLBACK_ARG);
- data[1] |= (CALLBACK_FUNC(0, _8255_DATA + 1, 0, CALLBACK_ARG) << 8);
- data[1] |= (CALLBACK_FUNC(0, _8255_DATA + 2, 0, CALLBACK_ARG) << 16);
+ v = spriv->io(0, _8255_DATA, 0, iobase);
+ v |= (spriv->io(0, _8255_DATA + 1, 0, iobase) << 8);
+ v |= (spriv->io(0, _8255_DATA + 2, 0, iobase) << 16);
+
+ data[1] = v;
- return 2;
+ return insn->n;
}
-static void do_config(struct comedi_device *dev, struct comedi_subdevice *s)
+static void subdev_8255_do_config(struct comedi_device *dev,
+ struct comedi_subdevice *s)
{
+ struct subdev_8255_private *spriv = s->private;
+ unsigned long iobase = spriv->iobase;
int config;
config = CR_CW;
config |= CR_C_LO_IO;
if (!(s->io_bits & 0xf00000))
config |= CR_C_HI_IO;
- CALLBACK_FUNC(1, _8255_CR, config, CALLBACK_ARG);
+
+ spriv->io(1, _8255_CR, config, iobase);
}
static int subdev_8255_insn_config(struct comedi_device *dev,
return -EINVAL;
}
- do_config(dev, s);
+ subdev_8255_do_config(dev, s);
return 1;
}
}
int subdev_8255_init(struct comedi_device *dev, struct comedi_subdevice *s,
- int (*cb) (int, int, int, unsigned long),
- unsigned long arg)
+ int (*io) (int, int, int, unsigned long),
+ unsigned long iobase)
{
- s->type = COMEDI_SUBD_DIO;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = 24;
- s->range_table = &range_digital;
- s->maxdata = 1;
-
- s->private = kmalloc(sizeof(struct subdev_8255_struct), GFP_KERNEL);
- if (!s->private)
+ struct subdev_8255_private *spriv;
+
+ spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
+ if (!spriv)
return -ENOMEM;
- CALLBACK_ARG = arg;
- if (cb == NULL)
- CALLBACK_FUNC = subdev_8255_cb;
- else
- CALLBACK_FUNC = cb;
- s->insn_bits = subdev_8255_insn;
- s->insn_config = subdev_8255_insn_config;
+ spriv->iobase = iobase;
+ spriv->io = io ? io : subdev_8255_io;
+
+ s->private = spriv;
+
+ s->type = COMEDI_SUBD_DIO;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ s->n_chan = 24;
+ s->range_table = &range_digital;
+ s->maxdata = 1;
+ s->insn_bits = subdev_8255_insn;
+ s->insn_config = subdev_8255_insn_config;
- s->state = 0;
- s->io_bits = 0;
- do_config(dev, s);
+ s->state = 0;
+ s->io_bits = 0;
+
+ subdev_8255_do_config(dev, s);
return 0;
}
EXPORT_SYMBOL(subdev_8255_init);
int subdev_8255_init_irq(struct comedi_device *dev, struct comedi_subdevice *s,
- int (*cb) (int, int, int, unsigned long),
- unsigned long arg)
+ int (*io) (int, int, int, unsigned long),
+ unsigned long iobase)
{
int ret;
- ret = subdev_8255_init(dev, s, cb, arg);
- if (ret < 0)
+ ret = subdev_8255_init(dev, s, io, iobase);
+ if (ret)
return ret;
- s->do_cmdtest = subdev_8255_cmdtest;
- s->do_cmd = subdev_8255_cmd;
- s->cancel = subdev_8255_cancel;
-
- subdevpriv->have_irq = 1;
+ s->do_cmdtest = subdev_8255_cmdtest;
+ s->do_cmd = subdev_8255_cmd;
+ s->cancel = subdev_8255_cancel;
return 0;
}
static int dev_8255_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ struct comedi_subdevice *s;
int ret;
unsigned long iobase;
int i;
break;
}
if (i == 0) {
- printk(KERN_WARNING
- "comedi%d: 8255: no devices specified\n", dev->minor);
+ dev_warn(dev->class_dev, "no devices specified\n");
return -EINVAL;
}
- ret = alloc_subdevices(dev, i);
- if (ret < 0) {
- /* FIXME this printk call should give a proper message, the
- * below line just maintains previous functionality */
- printk("comedi%d: 8255:", dev->minor);
+ ret = comedi_alloc_subdevices(dev, i);
+ if (ret)
return ret;
- }
-
- printk(KERN_INFO "comedi%d: 8255:", dev->minor);
for (i = 0; i < dev->n_subdevices; i++) {
+ s = dev->subdevices + i;
iobase = it->options[i];
- printk(" 0x%04lx", iobase);
if (!request_region(iobase, _8255_SIZE, "8255")) {
- printk(" (I/O port conflict)");
+ dev_warn(dev->class_dev,
+ "0x%04lx (I/O port conflict)\n", iobase);
- dev->subdevices[i].type = COMEDI_SUBD_UNUSED;
+ s->type = COMEDI_SUBD_UNUSED;
} else {
- subdev_8255_init(dev, dev->subdevices + i, NULL,
- iobase);
+ ret = subdev_8255_init(dev, s, NULL, iobase);
+ if (ret)
+ return ret;
+ dev_info(dev->class_dev, "0x%04lx\n", iobase);
}
}
- printk("\n");
-
return 0;
}
static void dev_8255_detach(struct comedi_device *dev)
{
- int i;
- unsigned long iobase;
struct comedi_subdevice *s;
+ struct subdev_8255_private *spriv;
+ int i;
for (i = 0; i < dev->n_subdevices; i++) {
s = dev->subdevices + i;
if (s->type != COMEDI_SUBD_UNUSED) {
- iobase = CALLBACK_ARG;
- release_region(iobase, _8255_SIZE);
+ spriv = s->private;
+ release_region(spriv->iobase, _8255_SIZE);
}
subdev_8255_cleanup(dev, s);
}
#include "../comedidev.h"
int subdev_8255_init(struct comedi_device *dev, struct comedi_subdevice *s,
- int (*cb) (int, int, int, unsigned long),
- unsigned long arg);
+ int (*io) (int, int, int, unsigned long),
+ unsigned long iobase);
int subdev_8255_init_irq(struct comedi_device *dev, struct comedi_subdevice *s,
- int (*cb) (int, int, int, unsigned long),
- unsigned long arg);
+ int (*io) (int, int, int, unsigned long),
+ unsigned long iobase);
void subdev_8255_cleanup(struct comedi_device *dev, struct comedi_subdevice *s);
void subdev_8255_interrupt(struct comedi_device *dev,
struct comedi_subdevice *s);
obj-$(CONFIG_COMEDI_POC) += poc.o
# Comedi PCI drivers
-obj-$(CONFIG_COMEDI_PCI_DRIVERS) += 8255.o
obj-$(CONFIG_COMEDI_ADDI_APCI_035) += addi_apci_035.o
obj-$(CONFIG_COMEDI_ADDI_APCI_1032) += addi_apci_1032.o
obj-$(CONFIG_COMEDI_ADDI_APCI_1500) += addi_apci_1500.o
# Comedi NI drivers
obj-$(CONFIG_COMEDI_MITE) += mite.o
obj-$(CONFIG_COMEDI_NI_TIO) += ni_tio.o
-obj-$(CONFIG_COMEDI_NI_TIO) += ni_tiocmd.o
+obj-$(CONFIG_COMEDI_NI_TIOCMD) += ni_tiocmd.o
obj-$(CONFIG_COMEDI_NI_LABPC) += ni_labpc.o
obj-$(CONFIG_COMEDI_8255) += 8255.o
int io_range; /* len of I/O space */
};
-#define this_board ((const struct boardtype *)dev->board_ptr)
-
static int acl7225b_do_insn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
data[1] = s->state;
- return 2;
+ return insn->n;
}
static int acl7225b_di_insn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inb(dev->iobase + (unsigned long)s->private) |
(inb(dev->iobase + (unsigned long)s->private + 1) << 8);
- return 2;
+ return insn->n;
}
static int acl7225b_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ const struct boardtype *board = comedi_board(dev);
struct comedi_subdevice *s;
int iobase, iorange;
+ int ret;
iobase = it->options[0];
- iorange = this_board->io_range;
+ iorange = board->io_range;
printk(KERN_INFO "comedi%d: acl7225b: board=%s 0x%04x\n", dev->minor,
- this_board->name, iobase);
+ board->name, iobase);
if (!request_region(iobase, iorange, "acl7225b")) {
printk(KERN_ERR "comedi%d: request_region failed - I/O port conflict\n",
dev->minor);
return -EIO;
}
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
dev->iobase = iobase;
dev->irq = 0;
- if (alloc_subdevices(dev, 3) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* Relays outputs */
static void acl7225b_detach(struct comedi_device *dev)
{
+ const struct boardtype *board = comedi_board(dev);
+
if (dev->iobase)
- release_region(dev->iobase, this_board->io_range);
+ release_region(dev->iobase, board->io_range);
}
static const struct boardtype boardtypes[] = {
#include "../../comedidev.h"
-#include "../comedi_pci.h"
-
-#ifdef PCI_SUPPORT_VER1
-#error No support for 2.1.55 and older
-#endif
-
/* written on base0 */
#define FIFO_ADVANCE_ON_BYTE_2 0x20000000
devpriv->s_BoardInfos.ui_Address = io_addr[2];
#endif
} else {
- /* Update-0.7.57->0.7.68dev->n_subdevices = 7; */
n_subdevices = 7;
- ret = alloc_subdevices(dev, n_subdevices);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, n_subdevices);
+ if (ret)
return ret;
/* Allocate and Initialise AI Subdevice Structures */
#include <linux/pci.h>
#include "../../comedidev.h"
-#ifdef PCI_SUPPORT_VER1
-#error Sorry, no support for 2.1.55 and older! :-((((
-#endif
-
/***********Added by sarath for compatibility with APCI3120
*************************/
int ret = 0;
int n_subdevices = 9;
- /* Update-0.7.57->0.7.68dev->n_subdevices = 9; */
- ret = alloc_subdevices(dev, n_subdevices);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, n_subdevices);
+ if (ret)
return;
/* Allocate and Initialise Timer Subdevice Structures */
* options that are used with comedi_config.
*/
#include "../comedidev.h"
-#include "comedi_pci.h"
/* Board descriptions */
struct pci6208_board {
* struct comedi_subdevice *s, */
/* struct comedi_insn *insn,unsigned int *data) */
/* { */
-/* if(insn->n!=2)return -EINVAL; */
-
/* The insn data is a mask in data[0] and the new data
* in data[1], each channel cooresponding to a bit. */
/* if(data[0]){ */
* it was a purely digital output subdevice */
/* data[1]=s->state; */
-/* return 2; */
+/* return insn->n; */
/* } */
/* static int pci6208_dio_insn_config(struct comedi_device *dev,
dev->iobase = io_base;
dev->board_name = thisboard->name;
- if (alloc_subdevices(dev, 2) < 0)
- return -ENOMEM;
+ retval = comedi_alloc_subdevices(dev, 2);
+ if (retval)
+ return retval;
s = dev->subdevices + 0;
/* analog output subdevice */
#include "../comedidev.h"
#include <linux/kernel.h>
-#include "comedi_pci.h"
#define PCI7230_DI 0x00
#define PCI7230_DO 0x00
struct comedi_insn *insn,
unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
outl((s->state << 16) & 0xffffffff, dev->iobase + PCI7230_DO);
}
- return 2;
+ return insn->n;
}
static int adl_pci7230_di_insn_bits(struct comedi_device *dev,
struct comedi_insn *insn,
unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inl(dev->iobase + PCI7230_DI) & 0xffffffff;
- return 2;
+ return insn->n;
}
-static int adl_pci7230_attach(struct comedi_device *dev,
+static struct pci_dev *adl_pci7230_find_pci(struct comedi_device *dev,
struct comedi_devconfig *it)
{
struct pci_dev *pcidev = NULL;
+ int bus = it->options[0];
+ int slot = it->options[1];
+
+ for_each_pci_dev(pcidev) {
+ if (pcidev->vendor != PCI_VENDOR_ID_ADLINK ||
+ pcidev->device != PCI_DEVICE_ID_PCI7230)
+ continue;
+ if (bus || slot) {
+ /* requested particular bus/slot */
+ if (pcidev->bus->number != bus ||
+ PCI_SLOT(pcidev->devfn) != slot)
+ continue;
+ }
+ return pcidev;
+ }
+ printk(KERN_ERR "comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
+ dev->minor, bus, slot);
+ return NULL;
+}
+
+static int adl_pci7230_attach(struct comedi_device *dev,
+ struct comedi_devconfig *it)
+{
struct comedi_subdevice *s;
- int bus, slot;
+ int ret;
printk(KERN_INFO "comedi%d: adl_pci7230\n", dev->minor);
dev->board_name = "pci7230";
- bus = it->options[0];
- slot = it->options[1];
if (alloc_private(dev, sizeof(struct adl_pci7230_private)) < 0)
return -ENOMEM;
- if (alloc_subdevices(dev, 2) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 2);
+ if (ret)
+ return ret;
- for_each_pci_dev(pcidev) {
- if (pcidev->vendor == PCI_VENDOR_ID_ADLINK &&
- pcidev->device == PCI_DEVICE_ID_PCI7230) {
- if (bus || slot) {
- /* requested particular bus/slot */
- if (pcidev->bus->number != bus ||
- PCI_SLOT(pcidev->devfn) != slot) {
- continue;
- }
- }
- devpriv->pci_dev = pcidev;
- break;
- }
- }
- if (pcidev == NULL) {
- printk(KERN_ERR "comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
- dev->minor, bus, slot);
+ devpriv->pci_dev = adl_pci7230_find_pci(dev, it);
+ if (!devpriv->pci_dev)
return -EIO;
- }
- if (comedi_pci_enable(pcidev, "adl_pci7230") < 0) {
+
+ if (comedi_pci_enable(devpriv->pci_dev, "adl_pci7230") < 0) {
printk(KERN_ERR "comedi%d: Failed to enable PCI device and request regions\n",
dev->minor);
return -EIO;
}
- dev->iobase = pci_resource_start(pcidev, 2);
+ dev->iobase = pci_resource_start(devpriv->pci_dev, 2);
printk(KERN_DEBUG "comedi: base addr %4lx\n", dev->iobase);
s = dev->subdevices + 0;
#include "../comedidev.h"
#include <linux/kernel.h>
-#include "comedi_pci.h"
#include "8255.h"
/* #include "8253.h" */
#define devpriv ((struct adl_pci7296_private *)dev->private)
+static struct pci_dev *adl_pci7296_find_pci(struct comedi_device *dev,
+ struct comedi_devconfig *it)
+{
+ struct pci_dev *pcidev = NULL;
+ int bus = it->options[0];
+ int slot = it->options[1];
+
+ for_each_pci_dev(pcidev) {
+ if (pcidev->vendor != PCI_VENDOR_ID_ADLINK ||
+ pcidev->device != PCI_DEVICE_ID_PCI7296)
+ continue;
+ if (bus || slot) {
+ /* requested particular bus/slot */
+ if (pcidev->bus->number != bus ||
+ PCI_SLOT(pcidev->devfn) != slot)
+ continue;
+ }
+ return pcidev;
+ }
+ printk(KERN_ERR
+ "comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
+ dev->minor, bus, slot);
+ return NULL;
+}
+
static int adl_pci7296_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
- struct pci_dev *pcidev = NULL;
struct comedi_subdevice *s;
- int bus, slot;
int ret;
printk(KERN_INFO "comedi%d: attach adl_pci7432\n", dev->minor);
dev->board_name = "pci7432";
- bus = it->options[0];
- slot = it->options[1];
if (alloc_private(dev, sizeof(struct adl_pci7296_private)) < 0)
return -ENOMEM;
- if (alloc_subdevices(dev, 4) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
+ return ret;
- for_each_pci_dev(pcidev) {
- if (pcidev->vendor == PCI_VENDOR_ID_ADLINK &&
- pcidev->device == PCI_DEVICE_ID_PCI7296) {
- if (bus || slot) {
- /* requested particular bus/slot */
- if (pcidev->bus->number != bus
- || PCI_SLOT(pcidev->devfn) != slot) {
- continue;
- }
- }
- devpriv->pci_dev = pcidev;
- if (comedi_pci_enable(pcidev, "adl_pci7296") < 0) {
- printk(KERN_ERR "comedi%d: Failed to enable PCI device and request regions\n",
- dev->minor);
- return -EIO;
- }
-
- dev->iobase = pci_resource_start(pcidev, 2);
- printk(KERN_INFO "comedi: base addr %4lx\n",
- dev->iobase);
-
- /* four 8255 digital io subdevices */
- s = dev->subdevices + 0;
- subdev_8255_init(dev, s, NULL,
- (unsigned long)(dev->iobase));
-
- s = dev->subdevices + 1;
- ret = subdev_8255_init(dev, s, NULL,
- (unsigned long)(dev->iobase +
- PORT2A));
- if (ret < 0)
- return ret;
-
- s = dev->subdevices + 2;
- ret = subdev_8255_init(dev, s, NULL,
- (unsigned long)(dev->iobase +
- PORT3A));
- if (ret < 0)
- return ret;
-
- s = dev->subdevices + 3;
- ret = subdev_8255_init(dev, s, NULL,
- (unsigned long)(dev->iobase +
- PORT4A));
- if (ret < 0)
- return ret;
-
- printk(KERN_DEBUG "comedi%d: adl_pci7432 attached\n",
- dev->minor);
-
- return 1;
- }
+ devpriv->pci_dev = adl_pci7296_find_pci(dev, it);
+ if (!devpriv->pci_dev)
+ return -EIO;
+
+ if (comedi_pci_enable(devpriv->pci_dev, "adl_pci7296") < 0) {
+ printk(KERN_ERR
+ "comedi%d: Failed to enable PCI device and request regions\n",
+ dev->minor);
+ return -EIO;
}
- printk(KERN_ERR "comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
- dev->minor, bus, slot);
- return -EIO;
+ dev->iobase = pci_resource_start(devpriv->pci_dev, 2);
+ printk(KERN_INFO "comedi: base addr %4lx\n", dev->iobase);
+
+ /* four 8255 digital io subdevices */
+ s = dev->subdevices + 0;
+ subdev_8255_init(dev, s, NULL, (unsigned long)(dev->iobase));
+
+ s = dev->subdevices + 1;
+ ret = subdev_8255_init(dev, s, NULL,
+ (unsigned long)(dev->iobase + PORT2A));
+ if (ret < 0)
+ return ret;
+
+ s = dev->subdevices + 2;
+ ret = subdev_8255_init(dev, s, NULL,
+ (unsigned long)(dev->iobase + PORT3A));
+ if (ret < 0)
+ return ret;
+
+ s = dev->subdevices + 3;
+ ret = subdev_8255_init(dev, s, NULL,
+ (unsigned long)(dev->iobase + PORT4A));
+ if (ret < 0)
+ return ret;
+
+ printk(KERN_DEBUG "comedi%d: adl_pci7432 attached\n", dev->minor);
+
+ return 0;
}
static void adl_pci7296_detach(struct comedi_device *dev)
#include "../comedidev.h"
#include <linux/kernel.h>
-#include "comedi_pci.h"
#define PCI7432_DI 0x00
#define PCI7432_DO 0x00
printk(KERN_DEBUG "comedi: pci7432_do_insn_bits called\n");
printk(KERN_DEBUG "comedi: data0: %8x data1: %8x\n", data[0], data[1]);
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
dev->iobase + PCI7432_DO);
outl(s->state & 0xffffffff, dev->iobase + PCI7432_DO);
}
- return 2;
+ return insn->n;
}
static int adl_pci7432_di_insn_bits(struct comedi_device *dev,
printk(KERN_DEBUG "comedi: pci7432_di_insn_bits called\n");
printk(KERN_DEBUG "comedi: data0: %8x data1: %8x\n", data[0], data[1]);
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inl(dev->iobase + PCI7432_DI) & 0xffffffff;
printk(KERN_DEBUG "comedi: data1 %8x\n", data[1]);
- return 2;
+ return insn->n;
+}
+
+static struct pci_dev *adl_pci7432_find_pci(struct comedi_device *dev,
+ struct comedi_devconfig *it)
+{
+ struct pci_dev *pcidev = NULL;
+ int bus = it->options[0];
+ int slot = it->options[1];
+
+ for_each_pci_dev(pcidev) {
+ if (pcidev->vendor != PCI_VENDOR_ID_ADLINK ||
+ pcidev->device != PCI_DEVICE_ID_PCI7432)
+ continue;
+ if (bus || slot) {
+ /* requested particular bus/slot */
+ if (pcidev->bus->number != bus ||
+ PCI_SLOT(pcidev->devfn) != slot)
+ continue;
+ }
+ return pcidev;
+ }
+ printk(KERN_ERR
+ "comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
+ dev->minor, bus, slot);
+ return NULL;
}
static int adl_pci7432_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
- struct pci_dev *pcidev = NULL;
struct comedi_subdevice *s;
- int bus, slot;
+ int ret;
printk(KERN_INFO "comedi%d: attach adl_pci7432\n", dev->minor);
dev->board_name = "pci7432";
- bus = it->options[0];
- slot = it->options[1];
if (alloc_private(dev, sizeof(struct adl_pci7432_private)) < 0)
return -ENOMEM;
- if (alloc_subdevices(dev, 2) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 2);
+ if (ret)
+ return ret;
- for_each_pci_dev(pcidev) {
- if (pcidev->vendor == PCI_VENDOR_ID_ADLINK &&
- pcidev->device == PCI_DEVICE_ID_PCI7432) {
- if (bus || slot) {
- /* requested particular bus/slot */
- if (pcidev->bus->number != bus
- || PCI_SLOT(pcidev->devfn) != slot) {
- continue;
- }
- }
- devpriv->pci_dev = pcidev;
- if (comedi_pci_enable(pcidev, "adl_pci7432") < 0) {
- printk(KERN_ERR "comedi%d: Failed to enable PCI device and request regions\n",
- dev->minor);
- return -EIO;
- }
- dev->iobase = pci_resource_start(pcidev, 2);
- printk(KERN_INFO "comedi: base addr %4lx\n",
- dev->iobase);
-
- s = dev->subdevices + 0;
- s->type = COMEDI_SUBD_DI;
- s->subdev_flags =
- SDF_READABLE | SDF_GROUND | SDF_COMMON;
- s->n_chan = 32;
- s->maxdata = 1;
- s->len_chanlist = 32;
- s->io_bits = 0x00000000;
- s->range_table = &range_digital;
- s->insn_bits = adl_pci7432_di_insn_bits;
-
- s = dev->subdevices + 1;
- s->type = COMEDI_SUBD_DO;
- s->subdev_flags =
- SDF_WRITABLE | SDF_GROUND | SDF_COMMON;
- s->n_chan = 32;
- s->maxdata = 1;
- s->len_chanlist = 32;
- s->io_bits = 0xffffffff;
- s->range_table = &range_digital;
- s->insn_bits = adl_pci7432_do_insn_bits;
-
- printk(KERN_DEBUG "comedi%d: adl_pci7432 attached\n",
- dev->minor);
- return 1;
- }
- }
+ devpriv->pci_dev = adl_pci7432_find_pci(dev, it);
+ if (!devpriv->pci_dev)
+ return -EIO;
- printk(KERN_ERR "comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
- dev->minor, bus, slot);
- return -EIO;
+ if (comedi_pci_enable(devpriv->pci_dev, "adl_pci7432") < 0) {
+ printk(KERN_ERR "comedi%d: Failed to enable PCI device and request regions\n",
+ dev->minor);
+ return -EIO;
+ }
+ dev->iobase = pci_resource_start(devpriv->pci_dev, 2);
+ printk(KERN_INFO "comedi: base addr %4lx\n", dev->iobase);
+
+ s = dev->subdevices + 0;
+ s->type = COMEDI_SUBD_DI;
+ s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_COMMON;
+ s->n_chan = 32;
+ s->maxdata = 1;
+ s->len_chanlist = 32;
+ s->io_bits = 0x00000000;
+ s->range_table = &range_digital;
+ s->insn_bits = adl_pci7432_di_insn_bits;
+
+ s = dev->subdevices + 1;
+ s->type = COMEDI_SUBD_DO;
+ s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_COMMON;
+ s->n_chan = 32;
+ s->maxdata = 1;
+ s->len_chanlist = 32;
+ s->io_bits = 0xffffffff;
+ s->range_table = &range_digital;
+ s->insn_bits = adl_pci7432_do_insn_bits;
+
+ printk(KERN_DEBUG "comedi%d: adl_pci7432 attached\n", dev->minor);
+ return 0;
}
static void adl_pci7432_detach(struct comedi_device *dev)
#include <linux/kernel.h>
#include <linux/delay.h>
#include "comedi_fc.h"
-#include "comedi_pci.h"
#include "8253.h"
#define PCI8164_AXIS_X 0x00
return 2;
}
+static struct pci_dev *adl_pci8164_find_pci(struct comedi_device *dev,
+ struct comedi_devconfig *it)
+{
+ struct pci_dev *pcidev = NULL;
+ int bus = it->options[0];
+ int slot = it->options[1];
+
+ for_each_pci_dev(pcidev) {
+ if (pcidev->vendor != PCI_VENDOR_ID_ADLINK ||
+ pcidev->device != PCI_DEVICE_ID_PCI8164)
+ continue;
+ if (bus || slot) {
+ /* requested particular bus/slot */
+ if (pcidev->bus->number != bus ||
+ PCI_SLOT(pcidev->devfn) != slot)
+ continue;
+ }
+ return pcidev;
+ }
+ printk(KERN_ERR
+ "comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
+ dev->minor, bus, slot);
+ return NULL;
+}
+
static int adl_pci8164_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
- struct pci_dev *pcidev = NULL;
struct comedi_subdevice *s;
- int bus, slot;
+ int ret;
printk(KERN_INFO "comedi: attempt to attach...\n");
printk(KERN_INFO "comedi%d: adl_pci8164\n", dev->minor);
dev->board_name = "pci8164";
- bus = it->options[0];
- slot = it->options[1];
if (alloc_private(dev, sizeof(struct adl_pci8164_private)) < 0)
return -ENOMEM;
- if (alloc_subdevices(dev, 4) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
+ return ret;
- for_each_pci_dev(pcidev) {
- if (pcidev->vendor == PCI_VENDOR_ID_ADLINK &&
- pcidev->device == PCI_DEVICE_ID_PCI8164) {
- if (bus || slot) {
- /* requested particular bus/slot */
- if (pcidev->bus->number != bus
- || PCI_SLOT(pcidev->devfn) != slot)
- continue;
- }
- devpriv->pci_dev = pcidev;
- if (comedi_pci_enable(pcidev, "adl_pci8164") < 0) {
- printk(KERN_ERR "comedi%d: Failed to enable "
- "PCI device and request regions\n", dev->minor);
- return -EIO;
- }
- dev->iobase = pci_resource_start(pcidev, 2);
- printk(KERN_DEBUG "comedi: base addr %4lx\n",
- dev->iobase);
-
- s = dev->subdevices + 0;
- s->type = COMEDI_SUBD_PROC;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = 4;
- s->maxdata = 0xffff;
- s->len_chanlist = 4;
- /* s->range_table = &range_axis; */
- s->insn_read = adl_pci8164_insn_read_msts;
- s->insn_write = adl_pci8164_insn_write_cmd;
-
- s = dev->subdevices + 1;
- s->type = COMEDI_SUBD_PROC;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = 4;
- s->maxdata = 0xffff;
- s->len_chanlist = 4;
- /* s->range_table = &range_axis; */
- s->insn_read = adl_pci8164_insn_read_ssts;
- s->insn_write = adl_pci8164_insn_write_otp;
-
- s = dev->subdevices + 2;
- s->type = COMEDI_SUBD_PROC;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = 4;
- s->maxdata = 0xffff;
- s->len_chanlist = 4;
- /* s->range_table = &range_axis; */
- s->insn_read = adl_pci8164_insn_read_buf0;
- s->insn_write = adl_pci8164_insn_write_buf0;
-
- s = dev->subdevices + 3;
- s->type = COMEDI_SUBD_PROC;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = 4;
- s->maxdata = 0xffff;
- s->len_chanlist = 4;
- /* s->range_table = &range_axis; */
- s->insn_read = adl_pci8164_insn_read_buf1;
- s->insn_write = adl_pci8164_insn_write_buf1;
-
- printk(KERN_INFO "comedi: attached\n");
-
- return 1;
- }
- }
+ devpriv->pci_dev = adl_pci8164_find_pci(dev, it);
+ if (!devpriv->pci_dev)
+ return -EIO;
- printk(KERN_ERR "comedi%d: no supported board found!"
- "(req. bus/slot : %d/%d)\n", dev->minor, bus, slot);
- return -EIO;
+ if (comedi_pci_enable(devpriv->pci_dev, "adl_pci8164") < 0) {
+ printk(KERN_ERR "comedi%d: Failed to enable "
+ "PCI device and request regions\n", dev->minor);
+ return -EIO;
+ }
+ dev->iobase = pci_resource_start(devpriv->pci_dev, 2);
+ printk(KERN_DEBUG "comedi: base addr %4lx\n", dev->iobase);
+
+ s = dev->subdevices + 0;
+ s->type = COMEDI_SUBD_PROC;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ s->n_chan = 4;
+ s->maxdata = 0xffff;
+ s->len_chanlist = 4;
+ /* s->range_table = &range_axis; */
+ s->insn_read = adl_pci8164_insn_read_msts;
+ s->insn_write = adl_pci8164_insn_write_cmd;
+
+ s = dev->subdevices + 1;
+ s->type = COMEDI_SUBD_PROC;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ s->n_chan = 4;
+ s->maxdata = 0xffff;
+ s->len_chanlist = 4;
+ /* s->range_table = &range_axis; */
+ s->insn_read = adl_pci8164_insn_read_ssts;
+ s->insn_write = adl_pci8164_insn_write_otp;
+
+ s = dev->subdevices + 2;
+ s->type = COMEDI_SUBD_PROC;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ s->n_chan = 4;
+ s->maxdata = 0xffff;
+ s->len_chanlist = 4;
+ /* s->range_table = &range_axis; */
+ s->insn_read = adl_pci8164_insn_read_buf0;
+ s->insn_write = adl_pci8164_insn_write_buf0;
+
+ s = dev->subdevices + 3;
+ s->type = COMEDI_SUBD_PROC;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ s->n_chan = 4;
+ s->maxdata = 0xffff;
+ s->len_chanlist = 4;
+ /* s->range_table = &range_axis; */
+ s->insn_read = adl_pci8164_insn_read_buf1;
+ s->insn_write = adl_pci8164_insn_write_buf1;
+
+ printk(KERN_INFO "comedi: attached\n");
+ return 0;
}
static void adl_pci8164_detach(struct comedi_device *dev)
#include <linux/interrupt.h>
#include "8253.h"
-#include "comedi_pci.h"
#include "comedi_fc.h"
#define PCI9111_DRIVER_NAME "adl_pci9111"
bits = pci9111_di_get_bits();
data[1] = bits;
- return 2;
+ return insn->n;
}
/* Digital outputs */
data[1] = bits;
- return 2;
+ return insn->n;
}
/* ------------------------------------------------------------------ */
return 0;
}
-/* Attach */
-/* - Register PCI device */
-/* - Declare device driver capability */
+static struct pci_dev *pci9111_find_pci(struct comedi_device *dev,
+ struct comedi_devconfig *it)
+{
+ struct pci_dev *pcidev = NULL;
+ int bus = it->options[0];
+ int slot = it->options[1];
+ int i;
+
+ for_each_pci_dev(pcidev) {
+ if (pcidev->vendor != PCI_VENDOR_ID_ADLINK)
+ continue;
+ for (i = 0; i < pci9111_board_nbr; i++) {
+ if (pcidev->device != pci9111_boards[i].device_id)
+ continue;
+ if (bus || slot) {
+ /* requested particular bus/slot */
+ if (pcidev->bus->number != bus ||
+ PCI_SLOT(pcidev->devfn) != slot)
+ continue;
+ }
+ dev->board_ptr = pci9111_boards + i;
+ printk(KERN_ERR
+ "comedi%d: found %s (b:s:f=%d:%d:%d), irq=%d\n",
+ dev->minor, pci9111_boards[i].name,
+ pcidev->bus->number, PCI_SLOT(pcidev->devfn),
+ PCI_FUNC(pcidev->devfn), pcidev->irq);
+ return pcidev;
+ }
+ }
+ printk(KERN_ERR
+ "comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
+ dev->minor, bus, slot);
+ return NULL;
+}
static int pci9111_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
struct comedi_subdevice *subdevice;
unsigned long io_base, io_range, lcr_io_base, lcr_io_range;
- struct pci_dev *pci_device = NULL;
- int error, i;
+ int error;
const struct pci9111_board *board;
if (alloc_private(dev, sizeof(struct pci9111_private_data)) < 0)
printk(KERN_ERR "comedi%d: " PCI9111_DRIVER_NAME " driver\n",
dev->minor);
- for_each_pci_dev(pci_device) {
- if (pci_device->vendor == PCI_VENDOR_ID_ADLINK) {
- for (i = 0; i < pci9111_board_nbr; i++) {
- if (pci9111_boards[i].device_id ==
- pci_device->device) {
- /* was a particular bus/slot
- * requested? */
- if ((it->options[0] != 0)
- || (it->options[1] != 0)) {
- /* are we on the wrong
- * bus/slot? */
- if (pci_device->bus->number !=
- it->options[0]
- ||
- PCI_SLOT(pci_device->devfn)
- != it->options[1]) {
- continue;
- }
- }
-
- dev->board_ptr = pci9111_boards + i;
- board =
- (struct pci9111_board *)
- dev->board_ptr;
- dev_private->pci_device = pci_device;
- goto found;
- }
- }
- }
- }
-
- printk(KERN_ERR
- "comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
- dev->minor, it->options[0], it->options[1]);
- return -EIO;
-
-found:
-
- printk(KERN_ERR "comedi%d: found %s (b:s:f=%d:%d:%d) , irq=%d\n",
- dev->minor,
- pci9111_boards[i].name,
- pci_device->bus->number,
- PCI_SLOT(pci_device->devfn),
- PCI_FUNC(pci_device->devfn), pci_device->irq);
+ dev_private->pci_device = pci9111_find_pci(dev, it);
+ if (!dev_private->pci_device)
+ return -EIO;
+ board = (struct pci9111_board *)dev->board_ptr;
/* TODO: Warn about non-tested boards. */
/* Read local configuration register base address
* [PCI_BASE_ADDRESS #1]. */
- lcr_io_base = pci_resource_start(pci_device, 1);
- lcr_io_range = pci_resource_len(pci_device, 1);
+ lcr_io_base = pci_resource_start(dev_private->pci_device, 1);
+ lcr_io_range = pci_resource_len(dev_private->pci_device, 1);
printk
("comedi%d: local configuration registers at address 0x%4lx [0x%4lx]\n",
dev->minor, lcr_io_base, lcr_io_range);
/* Enable PCI device and request regions */
- if (comedi_pci_enable(pci_device, PCI9111_DRIVER_NAME) < 0) {
+ if (comedi_pci_enable(dev_private->pci_device, PCI9111_DRIVER_NAME) < 0) {
printk
("comedi%d: Failed to enable PCI device and request regions\n",
dev->minor);
}
/* Read PCI6308 register base address [PCI_BASE_ADDRESS #2]. */
- io_base = pci_resource_start(pci_device, 2);
- io_range = pci_resource_len(pci_device, 2);
+ io_base = pci_resource_start(dev_private->pci_device, 2);
+ io_range = pci_resource_len(dev_private->pci_device, 2);
printk(KERN_ERR "comedi%d: 6503 registers at address 0x%4lx [0x%4lx]\n",
dev->minor, io_base, io_range);
/* Irq setup */
dev->irq = 0;
- if (pci_device->irq > 0) {
- if (request_irq(pci_device->irq, pci9111_interrupt,
+ if (dev_private->pci_device->irq > 0) {
+ dev->irq = dev_private->pci_device->irq;
+
+ if (request_irq(dev->irq, pci9111_interrupt,
IRQF_SHARED, PCI9111_DRIVER_NAME, dev) != 0) {
printk(KERN_ERR
"comedi%d: unable to allocate irq %u\n",
- dev->minor, pci_device->irq);
+ dev->minor, dev->irq);
return -EINVAL;
}
}
- dev->irq = pci_device->irq;
/* TODO: Add external multiplexer setup (according to option[2]). */
- error = alloc_subdevices(dev, 4);
- if (error < 0)
+ error = comedi_alloc_subdevices(dev, 4);
+ if (error)
return error;
subdevice = dev->subdevices + 0;
#include "amcc_s5933.h"
#include "8253.h"
-#include "comedi_pci.h"
#include "comedi_fc.h"
#define PCI_VENDOR_ID_AMCC 0x10e8
short *ai_data;
short ao_data[2]; /* data output buffer */
unsigned int ai_scans; /* number of scans to do */
- char dma_doublebuf; /* we can use double buffring */
+ char dma_doublebuf; /* we can use double buffering */
unsigned int dma_actbuf; /* which buffer is used now */
short *dmabuf_virt[2]; /*
* pointers to begin of
{
data[1] = inl(dev->iobase + PCI9118_DI) & 0xf;
- return 2;
+ return insn->n;
}
/*
}
data[1] = s->state;
- return 2;
+ return insn->n;
}
/*
"can't be mixtured!");
return 0;
}
- if ((!devpriv->usemux) & (differencial) &
+ if (!devpriv->usemux && differencial &&
(CR_CHAN(chanlist[i]) >= this_board->n_aichand)) {
comedi_error(dev,
"If AREF_DIFF is used then is "
return 0;
}
+static struct pci_dev *pci9118_find_pci(struct comedi_device *dev,
+ struct comedi_devconfig *it)
+{
+ struct pci_dev *pcidev = NULL;
+ int bus = it->options[0];
+ int slot = it->options[1];
+
+ for_each_pci_dev(pcidev) {
+ if (pcidev->vendor != PCI_VENDOR_ID_AMCC)
+ continue;
+ if (pcidev->device != this_board->device_id)
+ continue;
+ if (bus || slot) {
+ /* requested particular bus/slot */
+ if (pcidev->bus->number != bus ||
+ PCI_SLOT(pcidev->devfn) != slot)
+ continue;
+ }
+ /*
+ * Look for device that isn't in use.
+ * Enable PCI device and request regions.
+ */
+ if (comedi_pci_enable(pcidev, "adl_pci9118"))
+ continue;
+ printk(KERN_ERR ", b:s:f=%d:%d:%d, io=0x%4lx, 0x%4lx",
+ pcidev->bus->number,
+ PCI_SLOT(pcidev->devfn),
+ PCI_FUNC(pcidev->devfn),
+ (unsigned long)pci_resource_start(pcidev, 2),
+ (unsigned long)pci_resource_start(pcidev, 0));
+ return pcidev;
+ }
+ printk(KERN_ERR
+ "comedi%d: no supported board found! (req. bus/slot : %d/%d)\n",
+ dev->minor, bus, slot);
+ return NULL;
+}
+
static int pci9118_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
int ret, pages, i;
unsigned short master;
unsigned int irq;
- unsigned long iobase_a, iobase_9;
- struct pci_dev *pcidev;
- int opt_bus, opt_slot;
- const char *errstr;
- unsigned char pci_bus, pci_slot, pci_func;
u16 u16w;
printk("comedi%d: adl_pci9118: board=%s", dev->minor, this_board->name);
- opt_bus = it->options[0];
- opt_slot = it->options[1];
if (it->options[3] & 1)
master = 0; /* user don't want use bus master */
else
return -ENOMEM;
}
- /* Look for matching PCI device */
- errstr = "not found!";
- pcidev = NULL;
- while (NULL != (pcidev = pci_get_device(PCI_VENDOR_ID_AMCC,
- this_board->device_id,
- pcidev))) {
- /* Found matching vendor/device. */
- if (opt_bus || opt_slot) {
- /* Check bus/slot. */
- if (opt_bus != pcidev->bus->number
- || opt_slot != PCI_SLOT(pcidev->devfn))
- continue; /* no match */
- }
- /*
- * Look for device that isn't in use.
- * Enable PCI device and request regions.
- */
- if (comedi_pci_enable(pcidev, "adl_pci9118")) {
- errstr =
- "failed to enable PCI device and request regions!";
- continue;
- }
- break;
- }
-
- if (!pcidev) {
- if (opt_bus || opt_slot) {
- printk(KERN_ERR " - Card at b:s %d:%d %s\n",
- opt_bus, opt_slot, errstr);
- } else {
- printk(KERN_ERR " - Card %s\n", errstr);
- }
+ devpriv->pcidev = pci9118_find_pci(dev, it);
+ if (!devpriv->pcidev)
return -EIO;
- }
if (master)
- pci_set_master(pcidev);
+ pci_set_master(devpriv->pcidev);
+ irq = devpriv->pcidev->irq;
+ devpriv->iobase_a = pci_resource_start(devpriv->pcidev, 0);
+ dev->iobase = pci_resource_start(devpriv->pcidev, 2);
- pci_bus = pcidev->bus->number;
- pci_slot = PCI_SLOT(pcidev->devfn);
- pci_func = PCI_FUNC(pcidev->devfn);
- irq = pcidev->irq;
- iobase_a = pci_resource_start(pcidev, 0);
- iobase_9 = pci_resource_start(pcidev, 2);
-
- printk(KERN_ERR ", b:s:f=%d:%d:%d, io=0x%4lx, 0x%4lx", pci_bus,
- pci_slot, pci_func, iobase_9, iobase_a);
-
- dev->iobase = iobase_9;
dev->board_name = this_board->name;
- devpriv->pcidev = pcidev;
- devpriv->iobase_a = iobase_a;
-
pci9118_reset(dev);
if (it->options[3] & 2)
pci_write_config_word(devpriv->pcidev, PCI_COMMAND, u16w | 64);
/* Enable parity check for parity error */
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
s = dev->subdevices + 0;
int do_chans;
};
-#define thisboard ((const struct adq12b_board *)dev->board_ptr)
-
struct adq12b_private {
int unipolar; /* option 2 of comedi_config (1 is iobase) */
int differential; /* option 3 of comedi_config */
/* only bits 0-4 have information about digital inputs */
data[1] = (inb(dev->iobase + ADQ12B_STINR) & (0x1f));
- return 2;
+ return insn->n;
}
static int adq12b_do_insn_bits(struct comedi_device *dev,
data[1] = devpriv->digital_state;
- return 2;
+ return insn->n;
}
static int adq12b_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct adq12b_board *board = comedi_board(dev);
struct comedi_subdevice *s;
unsigned long iobase;
int unipolar, differential;
+ int ret;
iobase = it->options[0];
unipolar = it->options[1];
}
dev->iobase = iobase;
-/*
- * Initialize dev->board_name. Note that we can use the "thisboard"
- * macro now, since we just initialized it in the last line.
- */
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
/*
* Allocate the private structure area. alloc_private() is a
devpriv->last_channel = -1;
devpriv->last_range = -1;
-/*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- if (alloc_subdevices(dev, 3) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* analog input subdevice */
s->type = COMEDI_SUBD_AI;
if (differential) {
s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF;
- s->n_chan = thisboard->ai_diff_chans;
+ s->n_chan = board->ai_diff_chans;
} else {
s->subdev_flags = SDF_READABLE | SDF_GROUND;
- s->n_chan = thisboard->ai_se_chans;
+ s->n_chan = board->ai_se_chans;
}
if (unipolar)
else
s->range_table = &range_adq12b_ai_bipolar;
- s->maxdata = (1 << thisboard->ai_bits) - 1;
+ s->maxdata = (1 << board->ai_bits) - 1;
s->len_chanlist = 4; /* This is the maximum chanlist length that
the board can handle */
/* digital input subdevice */
s->type = COMEDI_SUBD_DI;
s->subdev_flags = SDF_READABLE;
- s->n_chan = thisboard->di_chans;
+ s->n_chan = board->di_chans;
s->maxdata = 1;
s->range_table = &range_digital;
s->insn_bits = adq12b_di_insn_bits;
/* digital output subdevice */
s->type = COMEDI_SUBD_DO;
s->subdev_flags = SDF_WRITABLE;
- s->n_chan = thisboard->do_chans;
+ s->n_chan = board->do_chans;
s->maxdata = 1;
s->range_table = &range_digital;
s->insn_bits = adq12b_do_insn_bits;
#include "../comedidev.h"
-#include "comedi_pci.h"
-
#include "8253.h"
#include "amcc_s5933.h"
{
data[1] = inw(dev->iobase + PCI171x_DI);
- return 2;
+ return insn->n;
}
/*
}
data[1] = s->state;
- return 2;
+ return insn->n;
}
/*
int i;
int board_index;
- dev_info(dev->hw_dev, "comedi%d: adv_pci1710:\n", dev->minor);
+ dev_info(dev->class_dev, DRV_NAME ": attach\n");
opt_bus = it->options[0];
opt_slot = it->options[1];
if (!pcidev) {
if (opt_bus || opt_slot) {
- dev_err(dev->hw_dev, "- Card at b:s %d:%d %s\n",
+ dev_err(dev->class_dev, "- Card at b:s %d:%d %s\n",
opt_bus, opt_slot, errstr);
} else {
- dev_err(dev->hw_dev, "- Card %s\n", errstr);
+ dev_err(dev->class_dev, "- Card %s\n", errstr);
}
return -EIO;
}
irq = pcidev->irq;
iobase = pci_resource_start(pcidev, 2);
- dev_dbg(dev->hw_dev, "b:s:f=%d:%d:%d, io=0x%4lx\n", pci_bus, pci_slot,
- pci_func, iobase);
+ dev_dbg(dev->class_dev, "b:s:f=%d:%d:%d, io=0x%4lx\n",
+ pci_bus, pci_slot, pci_func, iobase);
dev->iobase = iobase;
if (this_board->n_counter)
n_subdevices++;
- ret = alloc_subdevices(dev, n_subdevices);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, n_subdevices);
+ if (ret)
return ret;
pci1710_reset(dev);
if (request_irq(irq, interrupt_service_pci1710,
IRQF_SHARED, "Advantech PCI-1710",
dev)) {
- dev_dbg(dev->hw_dev, "unable to allocate IRQ %d, DISABLING IT",
+ dev_dbg(dev->class_dev,
+ "unable to allocate IRQ %d, DISABLING IT",
irq);
irq = 0; /* Can't use IRQ */
} else {
- dev_dbg(dev->hw_dev, "irq=%u", irq);
+ dev_dbg(dev->class_dev, "irq=%u", irq);
}
} else {
- dev_dbg(dev->hw_dev, "IRQ disabled");
+ dev_dbg(dev->class_dev, "IRQ disabled");
}
} else {
irq = 0;
#include "../comedidev.h"
-#include "comedi_pci.h"
-
#define PCI_VENDOR_ID_ADVANTECH 0x13fe /* Advantech PCI vendor ID */
/* hardware types of the cards */
outw(s->state, dev->iobase + PCI1723_WRITE_DIGITAL_OUTPUT_CMD);
}
data[1] = inw(dev->iobase + PCI1723_READ_DIGITAL_INPUT_DATA);
- return 2;
+ return insn->n;
}
static int pci1723_attach(struct comedi_device *dev,
if (this_board->n_diochan)
n_subdevices++;
- ret = alloc_subdevices(dev, n_subdevices);
- if (ret < 0) {
- printk(" - Allocation failed!\n");
+ ret = comedi_alloc_subdevices(dev, n_subdevices);
+ if (ret)
return ret;
- }
pci1723_reset(dev);
subdev = 0;
#include <linux/delay.h>
-#include "comedi_pci.h"
#include "8255.h"
#include "8253.h"
data[1] |= inb(dev->iobase + d->addr + i) << (8 * i);
- return 2;
+ return insn->n;
}
/*
for (i = 0; i < d->regs; i++)
data[1] |= inw(dev->iobase + d->addr + 2 * i) << (16 * i);
- return 2;
+ return insn->n;
}
/*
}
data[1] = s->state;
- return 2;
+ return insn->n;
}
/*
}
data[1] = s->state;
- return 2;
+ return insn->n;
}
/*
{
data[1] = inb(dev->iobase + IMB3);
- return 2;
+ return insn->n;
}
/*
}
data[1] = s->state;
- return 2;
+ return insn->n;
}
/*
}
if (!dev->board_ptr) {
- dev_err(dev->hw_dev, "Error: Requested type of the card was not found!\n");
+ dev_err(dev->class_dev,
+ "Error: Requested type of the card was not found!\n");
return -EIO;
}
if (comedi_pci_enable(pcidev, dev->driver->driver_name)) {
- dev_err(dev->hw_dev, "Error: Can't enable PCI device and request regions!\n");
+ dev_err(dev->class_dev,
+ "Error: Can't enable PCI device and request regions!\n");
return -EIO;
}
iobase = pci_resource_start(pcidev, this_board->main_pci_region);
- dev_dbg(dev->hw_dev, "b:s:f=%d:%d:%d, io=0x%4lx\n",
+ dev_dbg(dev->class_dev, "b:s:f=%d:%d:%d, io=0x%4lx\n",
pcidev->bus->number, PCI_SLOT(pcidev->devfn),
PCI_FUNC(pcidev->devfn), iobase);
n_subdevices++;
}
- ret = alloc_subdevices(dev, n_subdevices);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, n_subdevices);
+ if (ret)
return ret;
subdev = 0;
.name = "aio_aio12_8"},
};
-#define thisboard ((const struct aio12_8_boardtype *) dev->board_ptr)
-
struct aio12_8_private {
unsigned int ao_readback[4];
};
static int aio_aio12_8_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ const struct aio12_8_boardtype *board = comedi_board(dev);
int iobase;
struct comedi_subdevice *s;
+ int ret;
iobase = it->options[0];
if (!request_region(iobase, 24, "aio_aio12_8")) {
return -EIO;
}
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
dev->iobase = iobase;
if (alloc_private(dev, sizeof(struct aio12_8_private)) < 0)
return -ENOMEM;
- if (alloc_subdevices(dev, 3) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
+ return ret;
s = &dev->subdevices[0];
s->type = COMEDI_SUBD_AI;
.do_ = 16},
};
-#define thisboard ((const struct aio_iiro_16_board *) dev->board_ptr)
-
struct aio_iiro_16_private {
int data;
struct pci_dev *pci_dev;
struct comedi_insn *insn,
unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= data[0] & data[1];
data[1] = s->state;
- return 2;
+ return insn->n;
}
static int aio_iiro_16_dio_insn_bits_read(struct comedi_device *dev,
struct comedi_insn *insn,
unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = 0;
data[1] |= inb(dev->iobase + AIO_IIRO_16_INPUT_0_7);
data[1] |= inb(dev->iobase + AIO_IIRO_16_INPUT_8_15) << 8;
- return 2;
+ return insn->n;
}
static int aio_iiro_16_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ const struct aio_iiro_16_board *board = comedi_board(dev);
int iobase;
struct comedi_subdevice *s;
+ int ret;
printk(KERN_INFO "comedi%d: aio_iiro_16: ", dev->minor);
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
iobase = it->options[0];
if (alloc_private(dev, sizeof(struct aio_iiro_16_private)) < 0)
return -ENOMEM;
- if (alloc_subdevices(dev, 2) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 2);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
s->type = COMEDI_SUBD_DIO;
#include "../comedidev.h"
-#include "comedi_pci.h"
-
#include "8255.h"
#include "8253.h"
#define DIO200_DRIVER_NAME "amplc_dio200"
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA_MODULE
-#define CONFIG_COMEDI_AMPLC_DIO200_ISA
-#endif
-
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI_MODULE
-#define CONFIG_COMEDI_AMPLC_DIO200_PCI
-#endif
-
/* PCI IDs */
#define PCI_VENDOR_ID_AMPLICON 0x14dc
#define PCI_DEVICE_ID_AMPLICON_PCI272 0x000a
};
enum dio200_layout {
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_ISA)
pc212_layout,
pc214_layout,
#endif
pc215_layout,
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_ISA)
pc218_layout,
#endif
pc272_layout
};
static const struct dio200_board dio200_boards[] = {
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_ISA)
{
.name = "pc212e",
.bustype = isa_bustype,
.layout = pc272_layout,
},
#endif
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_PCI)
{
.name = "pci215",
.devid = PCI_DEVICE_ID_AMPLICON_PCI215,
};
static const struct dio200_layout_struct dio200_layouts[] = {
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_ISA)
[pc212_layout] = {
.n_subdevs = 6,
.sdtype = {sd_8255, sd_8254, sd_8254, sd_8254,
.has_int_sce = 1,
.has_clk_gat_sce = 1,
},
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_ISA)
[pc218_layout] = {
.n_subdevs = 7,
.sdtype = {sd_8254, sd_8254, sd_8255, sd_8254,
},
};
-/*
- * PCI driver table.
- */
-
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI
-static DEFINE_PCI_DEVICE_TABLE(dio200_pci_table) = {
- { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI215) },
- { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI272) },
- {0}
-};
-
-MODULE_DEVICE_TABLE(pci, dio200_pci_table);
-#endif /* CONFIG_COMEDI_AMPLC_DIO200_PCI */
-
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((const struct dio200_board *)dev->board_ptr)
-#define thislayout (&dio200_layouts[((struct dio200_board *) \
- dev->board_ptr)->layout])
-
/* this structure is for data unique to this hardware driver. If
several hardware drivers keep similar information in this structure,
feel free to suggest moving the variable to the struct comedi_device struct.
*/
struct dio200_private {
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI
struct pci_dev *pci_dev; /* PCI device */
-#endif
int intr_sd;
};
-#define devpriv ((struct dio200_private *)dev->private)
-
struct dio200_subdev_8254 {
unsigned long iobase; /* Counter base address */
unsigned long clk_sce_iobase; /* CLK_SCE base address */
};
/*
- * The struct comedi_driver structure tells the Comedi core module
- * which functions to call to configure/deconfigure (attach/detach)
- * the board, and also about the kernel module that contains
- * the device code.
+ * This function looks for a board matching the supplied PCI device.
*/
-static int dio200_attach(struct comedi_device *dev,
- struct comedi_devconfig *it);
-static void dio200_detach(struct comedi_device *dev);
-static struct comedi_driver driver_amplc_dio200 = {
- .driver_name = DIO200_DRIVER_NAME,
- .module = THIS_MODULE,
- .attach = dio200_attach,
- .detach = dio200_detach,
- .board_name = &dio200_boards[0].name,
- .offset = sizeof(struct dio200_board),
- .num_names = ARRAY_SIZE(dio200_boards),
-};
-
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI
-static int __devinit driver_amplc_dio200_pci_probe(struct pci_dev *dev,
- const struct pci_device_id
- *ent)
-{
- return comedi_pci_auto_config(dev, &driver_amplc_dio200);
-}
-
-static void __devexit driver_amplc_dio200_pci_remove(struct pci_dev *dev)
-{
- comedi_pci_auto_unconfig(dev);
-}
-
-static struct pci_driver driver_amplc_dio200_pci_driver = {
- .id_table = dio200_pci_table,
- .probe = &driver_amplc_dio200_pci_probe,
- .remove = __devexit_p(&driver_amplc_dio200_pci_remove)
-};
-
-static int __init driver_amplc_dio200_init_module(void)
-{
- int retval;
-
- retval = comedi_driver_register(&driver_amplc_dio200);
- if (retval < 0)
- return retval;
-
- driver_amplc_dio200_pci_driver.name =
- (char *)driver_amplc_dio200.driver_name;
- return pci_register_driver(&driver_amplc_dio200_pci_driver);
-}
-
-static void __exit driver_amplc_dio200_cleanup_module(void)
+static const struct dio200_board *
+dio200_find_pci_board(struct pci_dev *pci_dev)
{
- pci_unregister_driver(&driver_amplc_dio200_pci_driver);
- comedi_driver_unregister(&driver_amplc_dio200);
-}
+ unsigned int i;
-module_init(driver_amplc_dio200_init_module);
-module_exit(driver_amplc_dio200_cleanup_module);
-#else
-static int __init driver_amplc_dio200_init_module(void)
-{
- return comedi_driver_register(&driver_amplc_dio200);
-}
-
-static void __exit driver_amplc_dio200_cleanup_module(void)
-{
- comedi_driver_unregister(&driver_amplc_dio200);
+ for (i = 0; i < ARRAY_SIZE(dio200_boards); i++)
+ if (dio200_boards[i].bustype == pci_bustype &&
+ pci_dev->device == dio200_boards[i].devid)
+ return &dio200_boards[i];
+ return NULL;
}
-module_init(driver_amplc_dio200_init_module);
-module_exit(driver_amplc_dio200_cleanup_module);
-#endif
-
/*
* This function looks for a PCI device matching the requested board name,
* bus and slot.
*/
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI
-static int
-dio200_find_pci(struct comedi_device *dev, int bus, int slot,
- struct pci_dev **pci_dev_p)
+static struct pci_dev *
+dio200_find_pci(struct comedi_device *dev, int bus, int slot)
{
+ const struct dio200_board *thisboard = comedi_board(dev);
struct pci_dev *pci_dev = NULL;
- *pci_dev_p = NULL;
-
/* Look for matching PCI device. */
for (pci_dev = pci_get_device(PCI_VENDOR_ID_AMPLICON, PCI_ANY_ID, NULL);
pci_dev != NULL;
continue;
}
if (thisboard->model == anypci_model) {
- /* Match any supported model. */
- int i;
-
- for (i = 0; i < ARRAY_SIZE(dio200_boards); i++) {
- if (dio200_boards[i].bustype != pci_bustype)
- continue;
- if (pci_dev->device == dio200_boards[i].devid) {
- /* Change board_ptr to matched board. */
- dev->board_ptr = &dio200_boards[i];
- break;
- }
- }
- if (i == ARRAY_SIZE(dio200_boards))
+ /* Wildcard board matches any supported PCI board. */
+ const struct dio200_board *foundboard;
+
+ foundboard = dio200_find_pci_board(pci_dev);
+ if (foundboard == NULL)
continue;
+ /* Replace wildcard board_ptr. */
+ dev->board_ptr = foundboard;
+ thisboard = comedi_board(dev);
} else {
/* Match specific model name. */
if (pci_dev->device != thisboard->devid)
}
/* Found a match. */
- *pci_dev_p = pci_dev;
- return 0;
+ return pci_dev;
}
/* No match found. */
if (bus || slot) {
- printk(KERN_ERR
- "comedi%d: error! no %s found at pci %02x:%02x!\n",
- dev->minor, thisboard->name, bus, slot);
+ dev_err(dev->class_dev,
+ "error! no %s found at pci %02x:%02x!\n",
+ thisboard->name, bus, slot);
} else {
- printk(KERN_ERR "comedi%d: error! no %s found!\n",
- dev->minor, thisboard->name);
+ dev_err(dev->class_dev, "error! no %s found!\n",
+ thisboard->name);
}
- return -EIO;
+ return NULL;
}
-#endif
/*
* This function checks and requests an I/O region, reporting an error
* if there is a conflict.
*/
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA
static int
-dio200_request_region(unsigned minor, unsigned long from, unsigned long extent)
+dio200_request_region(struct comedi_device *dev,
+ unsigned long from, unsigned long extent)
{
if (!from || !request_region(from, extent, DIO200_DRIVER_NAME)) {
- printk(KERN_ERR "comedi%d: I/O port conflict (%#lx,%lu)!\n",
- minor, from, extent);
+ dev_err(dev->class_dev, "I/O port conflict (%#lx,%lu)!\n",
+ from, extent);
return -EIO;
}
return 0;
}
-#endif
/*
* 'insn_bits' function for an 'INTERRUPT' subdevice.
data[0] = 0;
}
- return 2;
+ return insn->n;
}
/*
subpriv = kzalloc(sizeof(*subpriv), GFP_KERNEL);
if (!subpriv) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
+ dev_err(dev->class_dev, "error! out of memory!\n");
return -ENOMEM;
}
subpriv->iobase = iobase;
static irqreturn_t dio200_interrupt(int irq, void *d)
{
struct comedi_device *dev = d;
+ struct dio200_private *devpriv = dev->private;
int handled;
if (!dev->attached)
subpriv = kzalloc(sizeof(*subpriv), GFP_KERNEL);
if (!subpriv) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
+ dev_err(dev->class_dev, "error! out of memory!\n");
return -ENOMEM;
}
kfree(subpriv);
}
-/*
- * Attach is called by the Comedi core to configure the driver
- * for a particular board. If you specified a board_name array
- * in the driver structure, dev->board_ptr contains that
- * address.
- */
-static int dio200_attach(struct comedi_device *dev, struct comedi_devconfig *it)
+static void dio200_report_attach(struct comedi_device *dev, unsigned int irq)
+{
+ const struct dio200_board *thisboard = comedi_board(dev);
+ struct dio200_private *devpriv = dev->private;
+ char tmpbuf[60];
+ int tmplen;
+
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_ISA) &&
+ thisboard->bustype == isa_bustype)
+ tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
+ "(base %#lx) ", dev->iobase);
+ else if (IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_PCI) &&
+ thisboard->bustype == pci_bustype)
+ tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
+ "(pci %s) ", pci_name(devpriv->pci_dev));
+ else
+ tmplen = 0;
+ if (irq)
+ tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
+ "(irq %u%s) ", irq,
+ (dev->irq ? "" : " UNAVAILABLE"));
+ else
+ tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
+ "(no irq) ");
+ dev_info(dev->class_dev, "%s %sattached\n", dev->board_name, tmpbuf);
+}
+
+static int dio200_common_attach(struct comedi_device *dev, unsigned long iobase,
+ unsigned int irq, unsigned long req_irq_flags)
{
+ const struct dio200_board *thisboard = comedi_board(dev);
+ struct dio200_private *devpriv = dev->private;
+ const struct dio200_layout_struct *layout =
+ &dio200_layouts[thisboard->layout];
struct comedi_subdevice *s;
- unsigned long iobase = 0;
- unsigned int irq = 0;
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI
- struct pci_dev *pci_dev = NULL;
- int bus = 0, slot = 0;
-#endif
- const struct dio200_layout_struct *layout;
- int share_irq = 0;
int sdx;
- unsigned n;
+ unsigned int n;
int ret;
- printk(KERN_DEBUG "comedi%d: %s: attach\n", dev->minor,
- DIO200_DRIVER_NAME);
-
- ret = alloc_private(dev, sizeof(struct dio200_private));
- if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
- return ret;
- }
-
- /* Process options. */
- switch (thisboard->bustype) {
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA
- case isa_bustype:
- iobase = it->options[0];
- irq = it->options[1];
- share_irq = 0;
- break;
-#endif
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI
- case pci_bustype:
- bus = it->options[0];
- slot = it->options[1];
- share_irq = 1;
-
- ret = dio200_find_pci(dev, bus, slot, &pci_dev);
- if (ret < 0)
- return ret;
- devpriv->pci_dev = pci_dev;
- break;
-#endif
- default:
- printk(KERN_ERR
- "comedi%d: %s: BUG! cannot determine board type!\n",
- dev->minor, DIO200_DRIVER_NAME);
- return -EINVAL;
- break;
- }
-
devpriv->intr_sd = -1;
-
- /* Enable device and reserve I/O spaces. */
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI
- if (pci_dev) {
- ret = comedi_pci_enable(pci_dev, DIO200_DRIVER_NAME);
- if (ret < 0) {
- printk(KERN_ERR
- "comedi%d: error! cannot enable PCI device and request regions!\n",
- dev->minor);
- return ret;
- }
- iobase = pci_resource_start(pci_dev, 2);
- irq = pci_dev->irq;
- } else
-#endif
- {
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA
- ret = dio200_request_region(dev->minor, iobase, DIO200_IO_SIZE);
- if (ret < 0)
- return ret;
-#endif
- }
dev->iobase = iobase;
+ dev->board_name = thisboard->name;
- layout = thislayout;
-
- ret = alloc_subdevices(dev, layout->n_subdevs);
- if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
+ ret = comedi_alloc_subdevices(dev, layout->n_subdevs);
+ if (ret)
return ret;
- }
for (n = 0; n < dev->n_subdevices; n++) {
s = &dev->subdevices[n];
layout->has_clk_gat_sce);
if (ret < 0)
return ret;
-
break;
case sd_8255:
/* digital i/o subdevice (8255) */
iobase + layout->sdinfo[n]);
if (ret < 0)
return ret;
-
break;
case sd_intr:
/* 'INTERRUPT' subdevice */
has_int_sce);
if (ret < 0)
return ret;
-
devpriv->intr_sd = n;
} else {
s->type = COMEDI_SUBD_UNUSED;
break;
}
}
-
sdx = devpriv->intr_sd;
if (sdx >= 0 && sdx < dev->n_subdevices)
dev->read_subdev = &dev->subdevices[sdx];
-
- dev->board_name = thisboard->name;
-
if (irq) {
- unsigned long flags = share_irq ? IRQF_SHARED : 0;
-
- if (request_irq(irq, dio200_interrupt, flags,
+ if (request_irq(irq, dio200_interrupt, req_irq_flags,
DIO200_DRIVER_NAME, dev) >= 0) {
dev->irq = irq;
} else {
- printk(KERN_WARNING
- "comedi%d: warning! irq %u unavailable!\n",
- dev->minor, irq);
+ dev_warn(dev->class_dev,
+ "warning! irq %u unavailable!\n", irq);
}
}
+ dio200_report_attach(dev, irq);
+ return 1;
+}
- printk(KERN_INFO "comedi%d: %s ", dev->minor, dev->board_name);
- switch (thisboard->bustype) {
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA
- case isa_bustype:
- printk("(base %#lx) ", iobase);
- break;
-#endif
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI
- case pci_bustype:
- printk("(pci %s) ", pci_name(pci_dev));
- break;
-#endif
- default:
- break;
+static int dio200_pci_common_attach(struct comedi_device *dev,
+ struct pci_dev *pci_dev)
+{
+ struct dio200_private *devpriv = dev->private;
+ unsigned long iobase;
+ int ret;
+
+ devpriv->pci_dev = pci_dev;
+ ret = comedi_pci_enable(pci_dev, DIO200_DRIVER_NAME);
+ if (ret < 0) {
+ dev_err(dev->class_dev,
+ "error! cannot enable PCI device and request regions!\n");
+ return ret;
}
- if (irq)
- printk("(irq %u%s) ", irq, (dev->irq ? "" : " UNAVAILABLE"));
- else
- printk("(no irq) ");
+ iobase = pci_resource_start(pci_dev, 2);
+ return dio200_common_attach(dev, iobase, pci_dev->irq, IRQF_SHARED);
+}
+
+/*
+ * Attach is called by the Comedi core to configure the driver
+ * for a particular board. If you specified a board_name array
+ * in the driver structure, dev->board_ptr contains that
+ * address.
+ */
+static int dio200_attach(struct comedi_device *dev, struct comedi_devconfig *it)
+{
+ const struct dio200_board *thisboard = comedi_board(dev);
+ int ret;
- printk("attached\n");
+ dev_info(dev->class_dev, DIO200_DRIVER_NAME ": attach\n");
- return 1;
+ ret = alloc_private(dev, sizeof(struct dio200_private));
+ if (ret < 0) {
+ dev_err(dev->class_dev, "error! out of memory!\n");
+ return ret;
+ }
+
+ /* Process options and reserve resources according to bus type. */
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_ISA) &&
+ thisboard->bustype == isa_bustype) {
+ unsigned long iobase;
+ unsigned int irq;
+
+ iobase = it->options[0];
+ irq = it->options[1];
+ ret = dio200_request_region(dev, iobase, DIO200_IO_SIZE);
+ if (ret < 0)
+ return ret;
+ return dio200_common_attach(dev, iobase, irq, 0);
+ } else if (IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_PCI) &&
+ thisboard->bustype == pci_bustype) {
+ struct pci_dev *pci_dev;
+ int bus, slot;
+
+ bus = it->options[0];
+ slot = it->options[1];
+ pci_dev = dio200_find_pci(dev, bus, slot);
+ if (pci_dev == NULL)
+ return -EIO;
+ return dio200_pci_common_attach(dev, pci_dev);
+ } else {
+ dev_err(dev->class_dev, DIO200_DRIVER_NAME
+ ": BUG! cannot determine board type!\n");
+ return -EINVAL;
+ }
+}
+
+/*
+ * The attach_pci hook (if non-NULL) is called at PCI probe time in preference
+ * to the "manual" attach hook. dev->board_ptr is NULL on entry. There should
+ * be a board entry matching the supplied PCI device.
+ */
+static int __devinit dio200_attach_pci(struct comedi_device *dev,
+ struct pci_dev *pci_dev)
+{
+ int ret;
+
+ if (!IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_PCI))
+ return -EINVAL;
+
+ dev_info(dev->class_dev, DIO200_DRIVER_NAME ": attach pci %s\n",
+ pci_name(pci_dev));
+ ret = alloc_private(dev, sizeof(struct dio200_private));
+ if (ret < 0) {
+ dev_err(dev->class_dev, "error! out of memory!\n");
+ return ret;
+ }
+ dev->board_ptr = dio200_find_pci_board(pci_dev);
+ if (dev->board_ptr == NULL) {
+ dev_err(dev->class_dev, "BUG! cannot determine board type!\n");
+ return -EINVAL;
+ }
+ return dio200_pci_common_attach(dev, pci_dev);
}
static void dio200_detach(struct comedi_device *dev)
{
+ const struct dio200_board *thisboard = comedi_board(dev);
+ struct dio200_private *devpriv = dev->private;
const struct dio200_layout_struct *layout;
unsigned n;
if (dev->irq)
free_irq(dev->irq, dev);
if (dev->subdevices) {
- layout = thislayout;
+ layout = &dio200_layouts[thisboard->layout];
for (n = 0; n < dev->n_subdevices; n++) {
struct comedi_subdevice *s = &dev->subdevices[n];
switch (layout->sdtype[n]) {
}
}
if (devpriv) {
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_PCI
- if (devpriv->pci_dev) {
- if (dev->iobase)
- comedi_pci_disable(devpriv->pci_dev);
- pci_dev_put(devpriv->pci_dev);
- } else
-#endif
- {
-#ifdef CONFIG_COMEDI_AMPLC_DIO200_ISA
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_PCI) &&
+ thisboard->bustype == pci_bustype) {
+ if (devpriv->pci_dev) {
+ if (dev->iobase)
+ comedi_pci_disable(devpriv->pci_dev);
+ pci_dev_put(devpriv->pci_dev);
+ }
+ } else if (IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_ISA) &&
+ thisboard->bustype == isa_bustype) {
if (dev->iobase)
release_region(dev->iobase, DIO200_IO_SIZE);
-#endif
}
}
}
+/*
+ * The struct comedi_driver structure tells the Comedi core module
+ * which functions to call to configure/deconfigure (attach/detach)
+ * the board, and also about the kernel module that contains
+ * the device code.
+ */
+static struct comedi_driver amplc_dio200_driver = {
+ .driver_name = DIO200_DRIVER_NAME,
+ .module = THIS_MODULE,
+ .attach = dio200_attach,
+ .attach_pci = dio200_attach_pci,
+ .detach = dio200_detach,
+ .board_name = &dio200_boards[0].name,
+ .offset = sizeof(struct dio200_board),
+ .num_names = ARRAY_SIZE(dio200_boards),
+};
+
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_DIO200_PCI)
+static DEFINE_PCI_DEVICE_TABLE(dio200_pci_table) = {
+ { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI215) },
+ { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI272) },
+ {0}
+};
+
+MODULE_DEVICE_TABLE(pci, dio200_pci_table);
+
+static int __devinit amplc_dio200_pci_probe(struct pci_dev *dev,
+ const struct pci_device_id
+ *ent)
+{
+ return comedi_pci_auto_config(dev, &lc_dio200_driver);
+}
+
+static void __devexit amplc_dio200_pci_remove(struct pci_dev *dev)
+{
+ comedi_pci_auto_unconfig(dev);
+}
+
+static struct pci_driver amplc_dio200_pci_driver = {
+ .name = DIO200_DRIVER_NAME,
+ .id_table = dio200_pci_table,
+ .probe = &lc_dio200_pci_probe,
+ .remove = __devexit_p(&lc_dio200_pci_remove)
+};
+module_comedi_pci_driver(amplc_dio200_driver, amplc_dio200_pci_driver);
+#else
+module_comedi_driver(amplc_dio200_driver);
+#endif
+
MODULE_AUTHOR("Comedi http://www.comedi.org");
MODULE_DESCRIPTION("Comedi low-level driver");
MODULE_LICENSE("GPL");
#include "../comedidev.h"
-#include "comedi_pci.h"
-
#include "8255.h"
#include "plx9052.h"
#define PC236_DRIVER_NAME "amplc_pc236"
-#ifdef CONFIG_COMEDI_AMPLC_PC236_ISA_MODULE
-#define CONFIG_COMEDI_AMPLC_PC236_ISA
-#endif
-
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI_MODULE
-#define CONFIG_COMEDI_AMPLC_PC236_PCI
-#endif
-
/* PCI236 PCI configuration register information */
#define PCI_VENDOR_ID_AMPLICON 0x14dc
#define PCI_DEVICE_ID_AMPLICON_PCI236 0x0009
struct pc236_board {
const char *name;
- const char *fancy_name;
unsigned short devid;
enum pc236_bustype bustype;
enum pc236_model model;
};
static const struct pc236_board pc236_boards[] = {
-#ifdef CONFIG_COMEDI_AMPLC_PC236_ISA
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_ISA)
{
- .name = "pc36at",
- .fancy_name = "PC36AT",
- .bustype = isa_bustype,
- .model = pc36at_model,
- },
+ .name = "pc36at",
+ .bustype = isa_bustype,
+ .model = pc36at_model,
+ },
#endif
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI)
{
- .name = "pci236",
- .fancy_name = "PCI236",
- .devid = PCI_DEVICE_ID_AMPLICON_PCI236,
- .bustype = pci_bustype,
- .model = pci236_model,
- },
+ .name = "pci236",
+ .devid = PCI_DEVICE_ID_AMPLICON_PCI236,
+ .bustype = pci_bustype,
+ .model = pci236_model,
+ },
{
- .name = PC236_DRIVER_NAME,
- .fancy_name = PC236_DRIVER_NAME,
- .devid = PCI_DEVICE_ID_INVALID,
- .bustype = pci_bustype,
- .model = anypci_model, /* wildcard */
- },
+ .name = PC236_DRIVER_NAME,
+ .devid = PCI_DEVICE_ID_INVALID,
+ .bustype = pci_bustype,
+ .model = anypci_model, /* wildcard */
+ },
#endif
};
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
-static DEFINE_PCI_DEVICE_TABLE(pc236_pci_table) = {
- { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI236) },
- {0}
-};
-
-MODULE_DEVICE_TABLE(pci, pc236_pci_table);
-#endif /* CONFIG_COMEDI_AMPLC_PC236_PCI */
-
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((const struct pc236_board *)dev->board_ptr)
-
/* this structure is for data unique to this hardware driver. If
several hardware drivers keep similar information in this structure,
feel free to suggest moving the variable to the struct comedi_device struct.
*/
struct pc236_private {
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
/* PCI device */
struct pci_dev *pci_dev;
unsigned long lcr_iobase; /* PLX PCI9052 config registers in PCIBAR1 */
-#endif
int enable_irq;
};
-#define devpriv ((struct pc236_private *)dev->private)
-
/*
- * The struct comedi_driver structure tells the Comedi core module
- * which functions to call to configure/deconfigure (attach/detach)
- * the board, and also about the kernel module that contains
- * the device code.
+ * This function looks for a board matching the supplied PCI device.
*/
-static int pc236_attach(struct comedi_device *dev, struct comedi_devconfig *it);
-static void pc236_detach(struct comedi_device *dev);
-static struct comedi_driver driver_amplc_pc236 = {
- .driver_name = PC236_DRIVER_NAME,
- .module = THIS_MODULE,
- .attach = pc236_attach,
- .detach = pc236_detach,
- .board_name = &pc236_boards[0].name,
- .offset = sizeof(struct pc236_board),
- .num_names = ARRAY_SIZE(pc236_boards),
-};
-
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
-static int __devinit driver_amplc_pc236_pci_probe(struct pci_dev *dev,
- const struct pci_device_id
- *ent)
-{
- return comedi_pci_auto_config(dev, &driver_amplc_pc236);
-}
-
-static void __devexit driver_amplc_pc236_pci_remove(struct pci_dev *dev)
-{
- comedi_pci_auto_unconfig(dev);
-}
-
-static struct pci_driver driver_amplc_pc236_pci_driver = {
- .id_table = pc236_pci_table,
- .probe = &driver_amplc_pc236_pci_probe,
- .remove = __devexit_p(&driver_amplc_pc236_pci_remove)
-};
-
-static int __init driver_amplc_pc236_init_module(void)
-{
- int retval;
-
- retval = comedi_driver_register(&driver_amplc_pc236);
- if (retval < 0)
- return retval;
-
- driver_amplc_pc236_pci_driver.name =
- (char *)driver_amplc_pc236.driver_name;
- return pci_register_driver(&driver_amplc_pc236_pci_driver);
-}
-
-static void __exit driver_amplc_pc236_cleanup_module(void)
-{
- pci_unregister_driver(&driver_amplc_pc236_pci_driver);
- comedi_driver_unregister(&driver_amplc_pc236);
-}
-
-module_init(driver_amplc_pc236_init_module);
-module_exit(driver_amplc_pc236_cleanup_module);
-#else
-static int __init driver_amplc_pc236_init_module(void)
+static const struct pc236_board *pc236_find_pci_board(struct pci_dev *pci_dev)
{
- return comedi_driver_register(&driver_amplc_pc236);
-}
+ unsigned int i;
-static void __exit driver_amplc_pc236_cleanup_module(void)
-{
- comedi_driver_unregister(&driver_amplc_pc236);
+ for (i = 0; i < ARRAY_SIZE(pc236_boards); i++)
+ if (pc236_boards[i].bustype == pci_bustype &&
+ pci_dev->device == pc236_boards[i].devid)
+ return &pc236_boards[i];
+ return NULL;
}
-module_init(driver_amplc_pc236_init_module);
-module_exit(driver_amplc_pc236_cleanup_module);
-#endif
-
-#ifdef CONFIG_COMEDI_AMPLC_PC236_ISA
-static int pc236_request_region(unsigned minor, unsigned long from,
- unsigned long extent);
-#endif
-static void pc236_intr_disable(struct comedi_device *dev);
-static void pc236_intr_enable(struct comedi_device *dev);
-static int pc236_intr_check(struct comedi_device *dev);
-static int pc236_intr_insn(struct comedi_device *dev,
- struct comedi_subdevice *s, struct comedi_insn *insn,
- unsigned int *data);
-static int pc236_intr_cmdtest(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_cmd *cmd);
-static int pc236_intr_cmd(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static int pc236_intr_cancel(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static irqreturn_t pc236_interrupt(int irq, void *d);
-
/*
* This function looks for a PCI device matching the requested board name,
* bus and slot.
*/
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
-static int
-pc236_find_pci(struct comedi_device *dev, int bus, int slot,
- struct pci_dev **pci_dev_p)
+static struct pci_dev *
+pc236_find_pci(struct comedi_device *dev, int bus, int slot)
{
+ const struct pc236_board *thisboard = comedi_board(dev);
struct pci_dev *pci_dev = NULL;
- *pci_dev_p = NULL;
-
/* Look for matching PCI device. */
for (pci_dev = pci_get_device(PCI_VENDOR_ID_AMPLICON, PCI_ANY_ID, NULL);
pci_dev != NULL;
continue;
}
if (thisboard->model == anypci_model) {
- /* Match any supported model. */
- int i;
-
- for (i = 0; i < ARRAY_SIZE(pc236_boards); i++) {
- if (pc236_boards[i].bustype != pci_bustype)
- continue;
- if (pci_dev->device == pc236_boards[i].devid) {
- /* Change board_ptr to matched board. */
- dev->board_ptr = &pc236_boards[i];
- break;
- }
- }
- if (i == ARRAY_SIZE(pc236_boards))
+ /* Wildcard board matches any supported PCI board. */
+ const struct pc236_board *foundboard;
+ foundboard = pc236_find_pci_board(pci_dev);
+ if (foundboard == NULL)
continue;
+ /* Replace wildcard board_ptr. */
+ dev->board_ptr = thisboard = foundboard;
} else {
/* Match specific model name. */
if (pci_dev->device != thisboard->devid)
}
/* Found a match. */
- *pci_dev_p = pci_dev;
- return 0;
+ return pci_dev;
}
/* No match found. */
if (bus || slot) {
- printk(KERN_ERR
- "comedi%d: error! no %s found at pci %02x:%02x!\n",
- dev->minor, thisboard->name, bus, slot);
+ dev_err(dev->class_dev,
+ "error! no %s found at pci %02x:%02x!\n",
+ thisboard->name, bus, slot);
} else {
- printk(KERN_ERR "comedi%d: error! no %s found!\n",
- dev->minor, thisboard->name);
- }
- return -EIO;
-}
-#endif
-
-/*
- * Attach is called by the Comedi core to configure the driver
- * for a particular board. If you specified a board_name array
- * in the driver structure, dev->board_ptr contains that
- * address.
- */
-static int pc236_attach(struct comedi_device *dev, struct comedi_devconfig *it)
-{
- struct comedi_subdevice *s;
- unsigned long iobase = 0;
- unsigned int irq = 0;
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
- struct pci_dev *pci_dev = NULL;
- int bus = 0, slot = 0;
-#endif
- int share_irq = 0;
- int ret;
-
- printk(KERN_DEBUG "comedi%d: %s: attach\n", dev->minor,
- PC236_DRIVER_NAME);
-/*
- * Allocate the private structure area. alloc_private() is a
- * convenient macro defined in comedidev.h.
- */
- ret = alloc_private(dev, sizeof(struct pc236_private));
- if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
- return ret;
- }
- /* Process options. */
- switch (thisboard->bustype) {
-#ifdef CONFIG_COMEDI_AMPLC_PC236_ISA
- case isa_bustype:
- iobase = it->options[0];
- irq = it->options[1];
- share_irq = 0;
- break;
-#endif
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
- case pci_bustype:
- bus = it->options[0];
- slot = it->options[1];
- share_irq = 1;
-
- ret = pc236_find_pci(dev, bus, slot, &pci_dev);
- if (ret < 0)
- return ret;
- devpriv->pci_dev = pci_dev;
- break;
-#endif
- default:
- printk(KERN_ERR
- "comedi%d: %s: BUG! cannot determine board type!\n",
- dev->minor, PC236_DRIVER_NAME);
- return -EINVAL;
- break;
- }
-
-/*
- * Initialize dev->board_name.
- */
- dev->board_name = thisboard->name;
-
- /* Enable device and reserve I/O spaces. */
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
- if (pci_dev) {
-
- ret = comedi_pci_enable(pci_dev, PC236_DRIVER_NAME);
- if (ret < 0) {
- printk(KERN_ERR
- "comedi%d: error! cannot enable PCI device and request regions!\n",
- dev->minor);
- return ret;
- }
- devpriv->lcr_iobase = pci_resource_start(pci_dev, 1);
- iobase = pci_resource_start(pci_dev, 2);
- irq = pci_dev->irq;
- } else
-#endif
- {
-#ifdef CONFIG_COMEDI_AMPLC_PC236_ISA
- ret = pc236_request_region(dev->minor, iobase, PC236_IO_SIZE);
- if (ret < 0)
- return ret;
-#endif
- }
- dev->iobase = iobase;
-
-/*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- ret = alloc_subdevices(dev, 2);
- if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
- return ret;
- }
-
- s = dev->subdevices + 0;
- /* digital i/o subdevice (8255) */
- ret = subdev_8255_init(dev, s, NULL, iobase);
- if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
- return ret;
- }
- s = dev->subdevices + 1;
- dev->read_subdev = s;
- s->type = COMEDI_SUBD_UNUSED;
- pc236_intr_disable(dev);
- if (irq) {
- unsigned long flags = share_irq ? IRQF_SHARED : 0;
-
- if (request_irq(irq, pc236_interrupt, flags,
- PC236_DRIVER_NAME, dev) >= 0) {
- dev->irq = irq;
- s->type = COMEDI_SUBD_DI;
- s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
- s->n_chan = 1;
- s->maxdata = 1;
- s->range_table = &range_digital;
- s->insn_bits = pc236_intr_insn;
- s->do_cmdtest = pc236_intr_cmdtest;
- s->do_cmd = pc236_intr_cmd;
- s->cancel = pc236_intr_cancel;
- }
- }
- printk(KERN_INFO "comedi%d: %s ", dev->minor, dev->board_name);
- switch (thisboard->bustype) {
-#ifdef CONFIG_COMEDI_AMPLC_PC236_ISA
- case isa_bustype:
- printk("(base %#lx) ", iobase);
- break;
-#endif
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
- case pci_bustype:
- printk("(pci %s) ", pci_name(pci_dev));
- break;
-#endif
- default:
- break;
- }
- if (irq)
- printk("(irq %u%s) ", irq, (dev->irq ? "" : " UNAVAILABLE"));
- else
- printk("(no irq) ");
-
- printk("attached\n");
-
- return 1;
-}
-
-static void pc236_detach(struct comedi_device *dev)
-{
- if (devpriv)
- pc236_intr_disable(dev);
- if (dev->irq)
- free_irq(dev->irq, dev);
- if (dev->subdevices)
- subdev_8255_cleanup(dev, dev->subdevices + 0);
- if (devpriv) {
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
- if (devpriv->pci_dev) {
- if (dev->iobase)
- comedi_pci_disable(devpriv->pci_dev);
- pci_dev_put(devpriv->pci_dev);
- } else
-#endif
- {
-#ifdef CONFIG_COMEDI_AMPLC_PC236_ISA
- if (dev->iobase)
- release_region(dev->iobase, PC236_IO_SIZE);
-#endif
- }
+ dev_err(dev->class_dev, "error! no %s found!\n",
+ thisboard->name);
}
+ return NULL;
}
/*
* This function checks and requests an I/O region, reporting an error
* if there is a conflict.
*/
-#ifdef CONFIG_COMEDI_AMPLC_PC236_ISA
-static int pc236_request_region(unsigned minor, unsigned long from,
+static int pc236_request_region(struct comedi_device *dev, unsigned long from,
unsigned long extent)
{
if (!from || !request_region(from, extent, PC236_DRIVER_NAME)) {
- printk(KERN_ERR "comedi%d: I/O port conflict (%#lx,%lu)!\n",
- minor, from, extent);
+ dev_err(dev->class_dev, "I/O port conflict (%#lx,%lu)!\n",
+ from, extent);
return -EIO;
}
return 0;
}
-#endif
/*
* This function is called to mark the interrupt as disabled (no command
*/
static void pc236_intr_disable(struct comedi_device *dev)
{
+ struct pc236_private *devpriv = dev->private;
unsigned long flags;
spin_lock_irqsave(&dev->spinlock, flags);
devpriv->enable_irq = 0;
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
- if (devpriv->lcr_iobase)
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI) && devpriv->lcr_iobase)
outl(PCI236_INTR_DISABLE, devpriv->lcr_iobase + PLX9052_INTCSR);
-#endif
spin_unlock_irqrestore(&dev->spinlock, flags);
}
*/
static void pc236_intr_enable(struct comedi_device *dev)
{
+ struct pc236_private *devpriv = dev->private;
unsigned long flags;
spin_lock_irqsave(&dev->spinlock, flags);
devpriv->enable_irq = 1;
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
- if (devpriv->lcr_iobase)
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI) && devpriv->lcr_iobase)
outl(PCI236_INTR_ENABLE, devpriv->lcr_iobase + PLX9052_INTCSR);
-#endif
spin_unlock_irqrestore(&dev->spinlock, flags);
}
*/
static int pc236_intr_check(struct comedi_device *dev)
{
+ struct pc236_private *devpriv = dev->private;
int retval = 0;
unsigned long flags;
spin_lock_irqsave(&dev->spinlock, flags);
if (devpriv->enable_irq) {
retval = 1;
-#ifdef CONFIG_COMEDI_AMPLC_PC236_PCI
- if (devpriv->lcr_iobase) {
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI) &&
+ devpriv->lcr_iobase) {
if ((inl(devpriv->lcr_iobase + PLX9052_INTCSR)
& PLX9052_INTCSR_LI1STAT_MASK)
== PLX9052_INTCSR_LI1STAT_INACTIVE) {
devpriv->lcr_iobase + PLX9052_INTCSR);
}
}
-#endif
}
spin_unlock_irqrestore(&dev->spinlock, flags);
unsigned int *data)
{
data[1] = 0;
- return 2;
+ return insn->n;
}
/*
return IRQ_RETVAL(handled);
}
+static void pc236_report_attach(struct comedi_device *dev, unsigned int irq)
+{
+ const struct pc236_board *thisboard = comedi_board(dev);
+ char tmpbuf[60];
+ int tmplen;
+
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_ISA) &&
+ thisboard->bustype == isa_bustype)
+ tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
+ "(base %#lx) ", dev->iobase);
+ else if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI) &&
+ thisboard->bustype == pci_bustype) {
+ struct pc236_private *devpriv = dev->private;
+ struct pci_dev *pci_dev = devpriv->pci_dev;
+ tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
+ "(pci %s) ", pci_name(pci_dev));
+ } else
+ tmplen = 0;
+ if (irq)
+ tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
+ "(irq %u%s) ", irq,
+ (dev->irq ? "" : " UNAVAILABLE"));
+ else
+ tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
+ "(no irq) ");
+ dev_info(dev->class_dev, "%s %sattached\n",
+ dev->board_name, tmpbuf);
+}
+
+static int pc236_common_attach(struct comedi_device *dev, unsigned long iobase,
+ unsigned int irq, unsigned long req_irq_flags)
+{
+ const struct pc236_board *thisboard = comedi_board(dev);
+ struct comedi_subdevice *s;
+ int ret;
+
+ dev->board_name = thisboard->name;
+ dev->iobase = iobase;
+
+ ret = comedi_alloc_subdevices(dev, 2);
+ if (ret)
+ return ret;
+
+ s = dev->subdevices + 0;
+ /* digital i/o subdevice (8255) */
+ ret = subdev_8255_init(dev, s, NULL, iobase);
+ if (ret < 0) {
+ dev_err(dev->class_dev, "error! out of memory!\n");
+ return ret;
+ }
+ s = dev->subdevices + 1;
+ dev->read_subdev = s;
+ s->type = COMEDI_SUBD_UNUSED;
+ pc236_intr_disable(dev);
+ if (irq) {
+ if (request_irq(irq, pc236_interrupt, req_irq_flags,
+ PC236_DRIVER_NAME, dev) >= 0) {
+ dev->irq = irq;
+ s->type = COMEDI_SUBD_DI;
+ s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
+ s->n_chan = 1;
+ s->maxdata = 1;
+ s->range_table = &range_digital;
+ s->insn_bits = pc236_intr_insn;
+ s->do_cmdtest = pc236_intr_cmdtest;
+ s->do_cmd = pc236_intr_cmd;
+ s->cancel = pc236_intr_cancel;
+ }
+ }
+ pc236_report_attach(dev, irq);
+ return 1;
+}
+
+static int pc236_pci_common_attach(struct comedi_device *dev,
+ struct pci_dev *pci_dev)
+{
+ struct pc236_private *devpriv = dev->private;
+ unsigned long iobase;
+ int ret;
+
+ devpriv->pci_dev = pci_dev;
+ ret = comedi_pci_enable(pci_dev, PC236_DRIVER_NAME);
+ if (ret < 0) {
+ dev_err(dev->class_dev,
+ "error! cannot enable PCI device and request regions!\n");
+ return ret;
+ }
+ devpriv->lcr_iobase = pci_resource_start(pci_dev, 1);
+ iobase = pci_resource_start(pci_dev, 2);
+ return pc236_common_attach(dev, iobase, pci_dev->irq, IRQF_SHARED);
+}
+
+/*
+ * Attach is called by the Comedi core to configure the driver
+ * for a particular board. If you specified a board_name array
+ * in the driver structure, dev->board_ptr contains that
+ * address.
+ */
+static int pc236_attach(struct comedi_device *dev, struct comedi_devconfig *it)
+{
+ const struct pc236_board *thisboard = comedi_board(dev);
+ int ret;
+
+ dev_info(dev->class_dev, PC236_DRIVER_NAME ": attach\n");
+ ret = alloc_private(dev, sizeof(struct pc236_private));
+ if (ret < 0) {
+ dev_err(dev->class_dev, "error! out of memory!\n");
+ return ret;
+ }
+ /* Process options according to bus type. */
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_ISA) &&
+ thisboard->bustype == isa_bustype) {
+ unsigned long iobase = it->options[0];
+ unsigned int irq = it->options[1];
+ ret = pc236_request_region(dev, iobase, PC236_IO_SIZE);
+ if (ret < 0)
+ return ret;
+ return pc236_common_attach(dev, iobase, irq, 0);
+ } else if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI) &&
+ thisboard->bustype == pci_bustype) {
+ int bus = it->options[0];
+ int slot = it->options[1];
+ struct pci_dev *pci_dev;
+
+ pci_dev = pc236_find_pci(dev, bus, slot);
+ if (pci_dev == NULL)
+ return -EIO;
+ return pc236_pci_common_attach(dev, pci_dev);
+ } else {
+ dev_err(dev->class_dev, PC236_DRIVER_NAME
+ ": BUG! cannot determine board type!\n");
+ return -EINVAL;
+ }
+}
+
+/*
+ * The attach_pci hook (if non-NULL) is called at PCI probe time in preference
+ * to the "manual" attach hook. dev->board_ptr is NULL on entry. There should
+ * be a board entry matching the supplied PCI device.
+ */
+static int __devinit pc236_attach_pci(struct comedi_device *dev,
+ struct pci_dev *pci_dev)
+{
+ int ret;
+
+ if (!IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI))
+ return -EINVAL;
+
+ dev_info(dev->class_dev, PC236_DRIVER_NAME ": attach pci %s\n",
+ pci_name(pci_dev));
+ ret = alloc_private(dev, sizeof(struct pc236_private));
+ if (ret < 0) {
+ dev_err(dev->class_dev, "error! out of memory!\n");
+ return ret;
+ }
+ dev->board_ptr = pc236_find_pci_board(pci_dev);
+ if (dev->board_ptr == NULL) {
+ dev_err(dev->class_dev, "BUG! cannot determine board type!\n");
+ return -EINVAL;
+ }
+ return pc236_pci_common_attach(dev, pci_dev);
+}
+
+static void pc236_detach(struct comedi_device *dev)
+{
+ struct pc236_private *devpriv = dev->private;
+
+ if (devpriv)
+ pc236_intr_disable(dev);
+ if (dev->irq)
+ free_irq(dev->irq, dev);
+ if (dev->subdevices)
+ subdev_8255_cleanup(dev, dev->subdevices + 0);
+ if (devpriv) {
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI) &&
+ devpriv->pci_dev) {
+ if (dev->iobase)
+ comedi_pci_disable(devpriv->pci_dev);
+ pci_dev_put(devpriv->pci_dev);
+ } else if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_ISA)) {
+ if (dev->iobase)
+ release_region(dev->iobase, PC236_IO_SIZE);
+ }
+ }
+}
+
+/*
+ * The struct comedi_driver structure tells the Comedi core module
+ * which functions to call to configure/deconfigure (attach/detach)
+ * the board, and also about the kernel module that contains
+ * the device code.
+ */
+static struct comedi_driver amplc_pc236_driver = {
+ .driver_name = PC236_DRIVER_NAME,
+ .module = THIS_MODULE,
+ .attach = pc236_attach,
+ .attach_pci = pc236_attach_pci,
+ .detach = pc236_detach,
+ .board_name = &pc236_boards[0].name,
+ .offset = sizeof(struct pc236_board),
+ .num_names = ARRAY_SIZE(pc236_boards),
+};
+
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI)
+static DEFINE_PCI_DEVICE_TABLE(pc236_pci_table) = {
+ { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI236) },
+ {0}
+};
+
+MODULE_DEVICE_TABLE(pci, pc236_pci_table);
+
+static int __devinit amplc_pc236_pci_probe(struct pci_dev *dev,
+ const struct pci_device_id *ent)
+{
+ return comedi_pci_auto_config(dev, &lc_pc236_driver);
+}
+
+static void __devexit amplc_pc236_pci_remove(struct pci_dev *dev)
+{
+ comedi_pci_auto_unconfig(dev);
+}
+
+static struct pci_driver amplc_pc236_pci_driver = {
+ .name = PC236_DRIVER_NAME,
+ .id_table = pc236_pci_table,
+ .probe = &lc_pc236_pci_probe,
+ .remove = __devexit_p(&lc_pc236_pci_remove)
+};
+
+module_comedi_pci_driver(amplc_pc236_driver, amplc_pc236_pci_driver);
+#else
+module_comedi_driver(amplc_pc236_driver);
+#endif
+
MODULE_AUTHOR("Comedi http://www.comedi.org");
MODULE_DESCRIPTION("Comedi low-level driver");
MODULE_LICENSE("GPL");
#include "../comedidev.h"
-#include "comedi_pci.h"
-
#define PC263_DRIVER_NAME "amplc_pc263"
-#ifdef CONFIG_COMEDI_AMPLC_PC263_ISA_MODULE
-#define CONFIG_COMEDI_AMPLC_PC263_ISA
-#endif
-
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI_MODULE
-#define CONFIG_COMEDI_AMPLC_PC263_PCI
-#endif
-
/* PCI263 PCI configuration register information */
#define PCI_VENDOR_ID_AMPLICON 0x14dc
#define PCI_DEVICE_ID_AMPLICON_PCI263 0x000c
struct pc263_board {
const char *name;
- const char *fancy_name;
unsigned short devid;
enum pc263_bustype bustype;
enum pc263_model model;
};
static const struct pc263_board pc263_boards[] = {
-#ifdef CONFIG_COMEDI_AMPLC_PC263_ISA
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_PC263_ISA)
{
- .name = "pc263",
- .fancy_name = "PC263",
- .bustype = isa_bustype,
- .model = pc263_model,
- },
+ .name = "pc263",
+ .bustype = isa_bustype,
+ .model = pc263_model,
+ },
#endif
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_PC263_PCI)
{
- .name = "pci263",
- .fancy_name = "PCI263",
- .devid = PCI_DEVICE_ID_AMPLICON_PCI263,
- .bustype = pci_bustype,
- .model = pci263_model,
- },
+ .name = "pci263",
+ .devid = PCI_DEVICE_ID_AMPLICON_PCI263,
+ .bustype = pci_bustype,
+ .model = pci263_model,
+ },
{
- .name = PC263_DRIVER_NAME,
- .fancy_name = PC263_DRIVER_NAME,
- .devid = PCI_DEVICE_ID_INVALID,
- .bustype = pci_bustype,
- .model = anypci_model, /* wildcard */
- },
+ .name = PC263_DRIVER_NAME,
+ .devid = PCI_DEVICE_ID_INVALID,
+ .bustype = pci_bustype,
+ .model = anypci_model, /* wildcard */
+ },
#endif
};
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
-static DEFINE_PCI_DEVICE_TABLE(pc263_pci_table) = {
- { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI263) },
- {0}
-};
-
-MODULE_DEVICE_TABLE(pci, pc263_pci_table);
-#endif /* CONFIG_COMEDI_AMPLC_PC263_PCI */
-
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((const struct pc263_board *)dev->board_ptr)
-
/* this structure is for data unique to this hardware driver. If
several hardware drivers keep similar information in this structure,
feel free to suggest moving the variable to the struct comedi_device struct.
*/
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
struct pc263_private {
/* PCI device. */
struct pci_dev *pci_dev;
};
-#define devpriv ((struct pc263_private *)dev->private)
-#endif /* CONFIG_COMEDI_AMPLC_PC263_PCI */
-
/*
- * The struct comedi_driver structure tells the Comedi core module
- * which functions to call to configure/deconfigure (attach/detach)
- * the board, and also about the kernel module that contains
- * the device code.
+ * This function looks for a board matching the supplied PCI device.
*/
-static int pc263_attach(struct comedi_device *dev, struct comedi_devconfig *it);
-static void pc263_detach(struct comedi_device *dev);
-static struct comedi_driver driver_amplc_pc263 = {
- .driver_name = PC263_DRIVER_NAME,
- .module = THIS_MODULE,
- .attach = pc263_attach,
- .detach = pc263_detach,
- .board_name = &pc263_boards[0].name,
- .offset = sizeof(struct pc263_board),
- .num_names = ARRAY_SIZE(pc263_boards),
-};
+static const struct pc263_board *pc263_find_pci_board(struct pci_dev *pci_dev)
+{
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(pc263_boards); i++)
+ if (pc263_boards[i].bustype == pci_bustype &&
+ pci_dev->device == pc263_boards[i].devid)
+ return &pc263_boards[i];
+ return NULL;
+}
-#ifdef CONFIG_COMEDI_AMPLC_PC263_ISA
-static int pc263_request_region(unsigned minor, unsigned long from,
- unsigned long extent);
-#endif
-static int pc263_dio_insn_bits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int pc263_dio_insn_config(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
/*
* This function looks for a PCI device matching the requested board name,
* bus and slot.
*/
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
-static int
-pc263_find_pci(struct comedi_device *dev, int bus, int slot,
- struct pci_dev **pci_dev_p)
+static struct pci_dev *
+pc263_find_pci(struct comedi_device *dev, int bus, int slot)
{
+ const struct pc263_board *thisboard = comedi_board(dev);
struct pci_dev *pci_dev = NULL;
- *pci_dev_p = NULL;
-
/* Look for matching PCI device. */
for (pci_dev = pci_get_device(PCI_VENDOR_ID_AMPLICON, PCI_ANY_ID, NULL);
pci_dev != NULL;
continue;
}
if (thisboard->model == anypci_model) {
- /* Match any supported model. */
- int i;
-
- for (i = 0; i < ARRAY_SIZE(pc263_boards); i++) {
- if (pc263_boards[i].bustype != pci_bustype)
- continue;
- if (pci_dev->device == pc263_boards[i].devid) {
- /* Change board_ptr to matched board. */
- dev->board_ptr = &pc263_boards[i];
- break;
- }
- }
- if (i == ARRAY_SIZE(pc263_boards))
+ /* Wildcard board matches any supported PCI board. */
+ const struct pc263_board *foundboard;
+ foundboard = pc263_find_pci_board(pci_dev);
+ if (foundboard == NULL)
continue;
+ /* Replace wildcard board_ptr. */
+ dev->board_ptr = thisboard = foundboard;
} else {
/* Match specific model name. */
if (pci_dev->device != thisboard->devid)
}
/* Found a match. */
- *pci_dev_p = pci_dev;
- return 0;
+ return pci_dev;
}
/* No match found. */
if (bus || slot) {
- printk(KERN_ERR
- "comedi%d: error! no %s found at pci %02x:%02x!\n",
- dev->minor, thisboard->name, bus, slot);
+ dev_err(dev->class_dev,
+ "error! no %s found at pci %02x:%02x!\n",
+ thisboard->name, bus, slot);
} else {
- printk(KERN_ERR "comedi%d: error! no %s found!\n",
- dev->minor, thisboard->name);
+ dev_err(dev->class_dev, "error! no %s found!\n",
+ thisboard->name);
}
- return -EIO;
+ return NULL;
}
-#endif
-
/*
- * Attach is called by the Comedi core to configure the driver
- * for a particular board. If you specified a board_name array
- * in the driver structure, dev->board_ptr contains that
- * address.
+ * This function checks and requests an I/O region, reporting an error
+ * if there is a conflict.
*/
-static int pc263_attach(struct comedi_device *dev, struct comedi_devconfig *it)
+static int pc263_request_region(struct comedi_device *dev, unsigned long from,
+ unsigned long extent)
{
- struct comedi_subdevice *s;
- unsigned long iobase = 0;
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
- struct pci_dev *pci_dev = NULL;
- int bus = 0, slot = 0;
-#endif
- int ret;
-
- printk(KERN_DEBUG "comedi%d: %s: attach\n", dev->minor,
- PC263_DRIVER_NAME);
-/*
- * Allocate the private structure area. alloc_private() is a
- * convenient macro defined in comedidev.h.
- */
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
- ret = alloc_private(dev, sizeof(struct pc263_private));
- if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
- return ret;
+ if (!from || !request_region(from, extent, PC263_DRIVER_NAME)) {
+ dev_err(dev->class_dev, "I/O port conflict (%#lx,%lu)!\n",
+ from, extent);
+ return -EIO;
}
-#endif
- /* Process options. */
- switch (thisboard->bustype) {
-#ifdef CONFIG_COMEDI_AMPLC_PC263_ISA
- case isa_bustype:
- iobase = it->options[0];
- break;
-#endif
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
- case pci_bustype:
- bus = it->options[0];
- slot = it->options[1];
+ return 0;
+}
- ret = pc263_find_pci(dev, bus, slot, &pci_dev);
- if (ret < 0)
- return ret;
- devpriv->pci_dev = pci_dev;
- break;
-#endif
- default:
- printk(KERN_ERR
- "comedi%d: %s: BUG! cannot determine board type!\n",
- dev->minor, PC263_DRIVER_NAME);
- return -EINVAL;
- break;
+static int pc263_do_insn_bits(struct comedi_device *dev,
+ struct comedi_subdevice *s,
+ struct comedi_insn *insn, unsigned int *data)
+{
+ /* The insn data is a mask in data[0] and the new data
+ * in data[1], each channel cooresponding to a bit. */
+ if (data[0]) {
+ s->state &= ~data[0];
+ s->state |= data[0] & data[1];
+ /* Write out the new digital output lines */
+ outb(s->state & 0xFF, dev->iobase);
+ outb(s->state >> 8, dev->iobase + 1);
}
+ return insn->n;
+}
-/*
- * Initialize dev->board_name.
- */
- dev->board_name = thisboard->name;
+static void pc263_report_attach(struct comedi_device *dev)
+{
+ const struct pc263_board *thisboard = comedi_board(dev);
+ struct pc263_private *devpriv = dev->private;
+ char tmpbuf[40];
+
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC263_ISA) &&
+ thisboard->bustype == isa_bustype)
+ snprintf(tmpbuf, sizeof(tmpbuf), "(base %#lx) ", dev->iobase);
+ else if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC263_PCI) &&
+ thisboard->bustype == pci_bustype)
+ snprintf(tmpbuf, sizeof(tmpbuf), "(pci %s) ",
+ pci_name(devpriv->pci_dev));
+ else
+ tmpbuf[0] = '\0';
+ dev_info(dev->class_dev, "%s %sattached\n", dev->board_name, tmpbuf);
+}
- /* Enable device and reserve I/O spaces. */
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
- if (pci_dev) {
- ret = comedi_pci_enable(pci_dev, PC263_DRIVER_NAME);
- if (ret < 0) {
- printk(KERN_ERR
- "comedi%d: error! cannot enable PCI device and "
- "request regions!\n",
- dev->minor);
- return ret;
- }
- iobase = pci_resource_start(pci_dev, 2);
- } else
-#endif
- {
-#ifdef CONFIG_COMEDI_AMPLC_PC263_ISA
- ret = pc263_request_region(dev->minor, iobase, PC263_IO_SIZE);
- if (ret < 0)
- return ret;
-#endif
- }
+static int pc263_common_attach(struct comedi_device *dev, unsigned long iobase)
+{
+ const struct pc263_board *thisboard = comedi_board(dev);
+ struct comedi_subdevice *s;
+ int ret;
+
+ dev->board_name = thisboard->name;
dev->iobase = iobase;
-/*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- ret = alloc_subdevices(dev, 1);
- if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
return ret;
- }
s = dev->subdevices + 0;
- /* digital i/o subdevice */
- s->type = COMEDI_SUBD_DIO;
+ /* digital output subdevice */
+ s->type = COMEDI_SUBD_DO;
s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
s->n_chan = 16;
s->maxdata = 1;
s->range_table = &range_digital;
- s->insn_bits = pc263_dio_insn_bits;
- s->insn_config = pc263_dio_insn_config;
- /* all outputs */
- s->io_bits = 0xffff;
+ s->insn_bits = pc263_do_insn_bits;
/* read initial relay state */
- s->state = inb(dev->iobase);
- s->state = s->state | (inb(dev->iobase) << 8);
-
- printk(KERN_INFO "comedi%d: %s ", dev->minor, dev->board_name);
- switch (thisboard->bustype) {
-#ifdef CONFIG_COMEDI_AMPLC_PC263_ISA
- case isa_bustype:
- printk("(base %#lx) ", iobase);
- break;
-#endif
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
- printk("(pci %s) ", pci_name(pci_dev));
- break;
-#endif
- default:
- break;
- }
-
- printk("attached\n");
+ s->state = inb(dev->iobase) | (inb(dev->iobase + 1) << 8);
+ pc263_report_attach(dev);
return 1;
}
-static void pc263_detach(struct comedi_device *dev)
+static int pc263_pci_common_attach(struct comedi_device *dev,
+ struct pci_dev *pci_dev)
{
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
- if (devpriv)
-#endif
- {
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
- if (devpriv->pci_dev) {
- if (dev->iobase)
- comedi_pci_disable(devpriv->pci_dev);
- pci_dev_put(devpriv->pci_dev);
- } else
-#endif
- {
-#ifdef CONFIG_COMEDI_AMPLC_PC263_ISA
- if (dev->iobase)
- release_region(dev->iobase, PC263_IO_SIZE);
-#endif
- }
+ struct pc263_private *devpriv = dev->private;
+ unsigned long iobase;
+ int ret;
+
+ devpriv->pci_dev = pci_dev;
+ ret = comedi_pci_enable(pci_dev, PC263_DRIVER_NAME);
+ if (ret < 0) {
+ dev_err(dev->class_dev,
+ "error! cannot enable PCI device and request regions!\n");
+ return ret;
}
+ iobase = pci_resource_start(pci_dev, 2);
+ return pc263_common_attach(dev, iobase);
}
/*
- * This function checks and requests an I/O region, reporting an error
- * if there is a conflict.
+ * Attach is called by the Comedi core to configure the driver
+ * for a particular board. If you specified a board_name array
+ * in the driver structure, dev->board_ptr contains that
+ * address.
*/
-#ifdef CONFIG_COMEDI_AMPLC_PC263_ISA
-static int pc263_request_region(unsigned minor, unsigned long from,
- unsigned long extent)
+static int pc263_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
- if (!from || !request_region(from, extent, PC263_DRIVER_NAME)) {
- printk(KERN_ERR "comedi%d: I/O port conflict (%#lx,%lu)!\n",
- minor, from, extent);
- return -EIO;
+ const struct pc263_board *thisboard = comedi_board(dev);
+ int ret;
+
+ dev_info(dev->class_dev, PC263_DRIVER_NAME ": attach\n");
+
+ /* Process options and reserve resources according to bus type. */
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC263_ISA) &&
+ thisboard->bustype == isa_bustype) {
+ unsigned long iobase = it->options[0];
+ ret = pc263_request_region(dev, iobase, PC263_IO_SIZE);
+ if (ret < 0)
+ return ret;
+ return pc263_common_attach(dev, iobase);
+ } else if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC263_PCI) &&
+ thisboard->bustype == pci_bustype) {
+ struct pci_dev *pci_dev;
+ int bus, slot;
+
+ ret = alloc_private(dev, sizeof(struct pc263_private));
+ if (ret < 0) {
+ dev_err(dev->class_dev, "error! out of memory!\n");
+ return ret;
+ }
+ bus = it->options[0];
+ slot = it->options[1];
+ pci_dev = pc263_find_pci(dev, bus, slot);
+ if (pci_dev == NULL)
+ return -EIO;
+ return pc263_pci_common_attach(dev, pci_dev);
+ } else {
+ dev_err(dev->class_dev, PC263_DRIVER_NAME
+ ": BUG! cannot determine board type!\n");
+ return -EINVAL;
}
- return 0;
}
-#endif
-
-/* DIO devices are slightly special. Although it is possible to
- * implement the insn_read/insn_write interface, it is much more
- * useful to applications if you implement the insn_bits interface.
- * This allows packed reading/writing of the DIO channels. The
- * comedi core can convert between insn_bits and insn_read/write */
-static int pc263_dio_insn_bits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data)
+/*
+ * The attach_pci hook (if non-NULL) is called at PCI probe time in preference
+ * to the "manual" attach hook. dev->board_ptr is NULL on entry. There should
+ * be a board entry matching the supplied PCI device.
+ */
+static int __devinit pc263_attach_pci(struct comedi_device *dev,
+ struct pci_dev *pci_dev)
{
- if (insn->n != 2)
+ int ret;
+
+ if (!IS_ENABLED(CONFIG_COMEDI_AMPLC_PC263_PCI))
return -EINVAL;
- /* The insn data is a mask in data[0] and the new data
- * in data[1], each channel cooresponding to a bit. */
- if (data[0]) {
- s->state &= ~data[0];
- s->state |= data[0] & data[1];
- /* Write out the new digital output lines */
- outb(s->state & 0xFF, dev->iobase);
- outb(s->state >> 8, dev->iobase + 1);
+ dev_info(dev->class_dev, PC263_DRIVER_NAME ": attach pci %s\n",
+ pci_name(pci_dev));
+ ret = alloc_private(dev, sizeof(struct pc263_private));
+ if (ret < 0) {
+ dev_err(dev->class_dev, "error! out of memory!\n");
+ return ret;
}
-
- /* on return, data[1] contains the value of the digital
- * input and output lines. */
- /* or we could just return the software copy of the output values if
- * it was a purely digital output subdevice */
- data[1] = s->state;
-
- return 2;
+ dev->board_ptr = pc263_find_pci_board(pci_dev);
+ if (dev->board_ptr == NULL) {
+ dev_err(dev->class_dev, "BUG! cannot determine board type!\n");
+ return -EINVAL;
+ }
+ return pc263_pci_common_attach(dev, pci_dev);
}
-static int pc263_dio_insn_config(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data)
+static void pc263_detach(struct comedi_device *dev)
{
- if (insn->n != 1)
- return -EINVAL;
- return 1;
+ struct pc263_private *devpriv = dev->private;
+
+ if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC263_PCI) && devpriv &&
+ devpriv->pci_dev) {
+ if (dev->iobase)
+ comedi_pci_disable(devpriv->pci_dev);
+ pci_dev_put(devpriv->pci_dev);
+ } else if (IS_ENABLED(CONFIG_COMEDI_AMPLC_PC263_ISA)) {
+ if (dev->iobase)
+ release_region(dev->iobase, PC263_IO_SIZE);
+ }
}
/*
- * A convenient macro that defines init_module() and cleanup_module(),
- * as necessary.
+ * The struct comedi_driver structure tells the Comedi core module
+ * which functions to call to configure/deconfigure (attach/detach)
+ * the board, and also about the kernel module that contains
+ * the device code.
*/
-#ifdef CONFIG_COMEDI_AMPLC_PC263_PCI
-static int __devinit driver_amplc_pc263_pci_probe(struct pci_dev *dev,
+static struct comedi_driver amplc_pc263_driver = {
+ .driver_name = PC263_DRIVER_NAME,
+ .module = THIS_MODULE,
+ .attach = pc263_attach,
+ .attach_pci = pc263_attach_pci,
+ .detach = pc263_detach,
+ .board_name = &pc263_boards[0].name,
+ .offset = sizeof(struct pc263_board),
+ .num_names = ARRAY_SIZE(pc263_boards),
+};
+
+#if IS_ENABLED(CONFIG_COMEDI_AMPLC_PC263_PCI)
+static DEFINE_PCI_DEVICE_TABLE(pc263_pci_table) = {
+ { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI263) },
+ {0}
+};
+MODULE_DEVICE_TABLE(pci, pc263_pci_table);
+
+static int __devinit amplc_pc263_pci_probe(struct pci_dev *dev,
const struct pci_device_id
*ent)
{
- return comedi_pci_auto_config(dev, &driver_amplc_pc263);
+ return comedi_pci_auto_config(dev, &lc_pc263_driver);
}
-static void __devexit driver_amplc_pc263_pci_remove(struct pci_dev *dev)
+static void __devexit amplc_pc263_pci_remove(struct pci_dev *dev)
{
comedi_pci_auto_unconfig(dev);
}
-static struct pci_driver driver_amplc_pc263_pci_driver = {
+static struct pci_driver amplc_pc263_pci_driver = {
+ .name = PC263_DRIVER_NAME,
.id_table = pc263_pci_table,
- .probe = &driver_amplc_pc263_pci_probe,
- .remove = __devexit_p(&driver_amplc_pc263_pci_remove)
+ .probe = &lc_pc263_pci_probe,
+ .remove = __devexit_p(&lc_pc263_pci_remove)
};
-
-static int __init driver_amplc_pc263_init_module(void)
-{
- int retval;
-
- retval = comedi_driver_register(&driver_amplc_pc263);
- if (retval < 0)
- return retval;
-
- driver_amplc_pc263_pci_driver.name =
- (char *)driver_amplc_pc263.driver_name;
- return pci_register_driver(&driver_amplc_pc263_pci_driver);
-}
-
-static void __exit driver_amplc_pc263_cleanup_module(void)
-{
- pci_unregister_driver(&driver_amplc_pc263_pci_driver);
- comedi_driver_unregister(&driver_amplc_pc263);
-}
-
-module_init(driver_amplc_pc263_init_module);
-module_exit(driver_amplc_pc263_cleanup_module);
+module_comedi_pci_driver(amplc_pc263_driver, amplc_pc263_pci_driver);
#else
-static int __init driver_amplc_pc263_init_module(void)
-{
- return comedi_driver_register(&driver_amplc_pc263);
-}
-
-static void __exit driver_amplc_pc263_cleanup_module(void)
-{
- comedi_driver_unregister(&driver_amplc_pc263);
-}
-
-module_init(driver_amplc_pc263_init_module);
-module_exit(driver_amplc_pc263_cleanup_module);
+module_comedi_driver(amplc_pc263_driver);
#endif
MODULE_AUTHOR("Comedi http://www.comedi.org");
#include "../comedidev.h"
-#include "comedi_pci.h"
-
#include "comedi_fc.h"
#include "8253.h"
/* Combine old and new bits. */
#define COMBINE(old, new, mask) (((old) & ~(mask)) | ((new) & (mask)))
-/* A generic null function pointer value. */
-#define NULLFUNC 0
-
/* Current CPU. XXX should this be hard_smp_processor_id()? */
#define THISCPU smp_processor_id()
},
};
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((struct pci224_board *)dev->board_ptr)
-
/* this structure is for data unique to this hardware driver. If
several hardware drivers keep similar information in this structure,
feel free to suggest moving the variable to the struct comedi_device struct. */
unsigned char intsce;
};
-#define devpriv ((struct pci224_private *)dev->private)
-
/*
* Called from the 'insn_write' function to perform a single write.
*/
pci224_ao_set_data(struct comedi_device *dev, int chan, int range,
unsigned int data)
{
+ const struct pci224_board *thisboard = comedi_board(dev);
+ struct pci224_private *devpriv = dev->private;
unsigned short mangled;
/* Store unmangled data for readback. */
pci224_ao_insn_read(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ struct pci224_private *devpriv = dev->private;
int i;
int chan;
static void pci224_ao_stop(struct comedi_device *dev,
struct comedi_subdevice *s)
{
+ struct pci224_private *devpriv = dev->private;
unsigned long flags;
if (!test_and_clear_bit(AO_CMD_STARTED, &devpriv->state))
static void pci224_ao_start(struct comedi_device *dev,
struct comedi_subdevice *s)
{
+ struct pci224_private *devpriv = dev->private;
struct comedi_cmd *cmd = &s->async->cmd;
unsigned long flags;
static void pci224_ao_handle_fifo(struct comedi_device *dev,
struct comedi_subdevice *s)
{
+ struct pci224_private *devpriv = dev->private;
struct comedi_cmd *cmd = &s->async->cmd;
unsigned int num_scans;
unsigned int room;
/* Nothing left to put in the FIFO. */
pci224_ao_stop(dev, s);
s->async->events |= COMEDI_CB_OVERFLOW;
- printk(KERN_ERR "comedi%d: "
- "AO buffer underrun\n", dev->minor);
+ dev_err(dev->class_dev, "AO buffer underrun\n");
}
}
/* Determine how many new scans can be put in the FIFO. */
if (trignum != 0)
return -EINVAL;
- s->async->inttrig = NULLFUNC;
+ s->async->inttrig = NULL;
pci224_ao_start(dev, s);
return 1;
pci224_ao_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_cmd *cmd)
{
+ struct pci224_private *devpriv = dev->private;
int err = 0;
unsigned int tmp;
*/
static int pci224_ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
{
+ struct pci224_private *devpriv = dev->private;
struct comedi_cmd *cmd = &s->async->cmd;
int range;
unsigned int i, j;
pci224_ao_munge(struct comedi_device *dev, struct comedi_subdevice *s,
void *data, unsigned int num_bytes, unsigned int chan_index)
{
+ const struct pci224_board *thisboard = comedi_board(dev);
+ struct pci224_private *devpriv = dev->private;
struct comedi_async *async = s->async;
short *array = data;
unsigned int length = num_bytes / sizeof(*array);
static irqreturn_t pci224_interrupt(int irq, void *d)
{
struct comedi_device *dev = d;
+ struct pci224_private *devpriv = dev->private;
struct comedi_subdevice *s = &dev->subdevices[0];
struct comedi_cmd *cmd;
unsigned char intstat, valid_intstat;
* This function looks for a PCI device matching the requested board name,
* bus and slot.
*/
-static int
-pci224_find_pci(struct comedi_device *dev, int bus, int slot,
- struct pci_dev **pci_dev_p)
+static struct pci_dev *
+pci224_find_pci(struct comedi_device *dev, int bus, int slot)
{
+ const struct pci224_board *thisboard = comedi_board(dev);
struct pci_dev *pci_dev = NULL;
- *pci_dev_p = NULL;
-
/* Look for matching PCI device. */
for (pci_dev = pci_get_device(PCI_VENDOR_ID_AMPLICON, PCI_ANY_ID, NULL);
pci_dev != NULL;
continue;
/* Change board_ptr to matched board. */
dev->board_ptr = board_ptr;
+ thisboard = comedi_board(dev);
} else {
/* Match specific model name. */
if (thisboard->devid != pci_dev->device)
}
/* Found a match. */
- *pci_dev_p = pci_dev;
- return 0;
+ return pci_dev;
}
/* No match found. */
if (bus || slot) {
- printk(KERN_ERR "comedi%d: error! "
- "no %s found at pci %02x:%02x!\n",
- dev->minor, thisboard->name, bus, slot);
+ dev_err(dev->class_dev,
+ "error! no %s found at pci %02x:%02x!\n",
+ thisboard->name, bus, slot);
} else {
- printk(KERN_ERR "comedi%d: error! no %s found!\n",
- dev->minor, thisboard->name);
+ dev_err(dev->class_dev, "error! no %s found!\n",
+ thisboard->name);
}
- return -EIO;
+ return NULL;
+}
+
+static void pci224_report_attach(struct comedi_device *dev, unsigned int irq)
+{
+ struct pci224_private *devpriv = dev->private;
+ char tmpbuf[30];
+
+ if (irq)
+ snprintf(tmpbuf, sizeof(tmpbuf), "irq %u%s", irq,
+ (dev->irq ? "" : " UNAVAILABLE"));
+ else
+ snprintf(tmpbuf, sizeof(tmpbuf), "no irq");
+ dev_info(dev->class_dev, "%s (pci %s) (%s) attached\n",
+ dev->board_name, pci_name(devpriv->pci_dev), tmpbuf);
}
/*
static int pci224_attach_common(struct comedi_device *dev,
struct pci_dev *pci_dev, int *options)
{
+ const struct pci224_board *thisboard = comedi_board(dev);
+ struct pci224_private *devpriv = dev->private;
struct comedi_subdevice *s;
unsigned int irq;
unsigned n;
devpriv->pci_dev = pci_dev;
ret = comedi_pci_enable(pci_dev, DRIVER_NAME);
if (ret < 0) {
- printk(KERN_ERR
- "comedi%d: error! cannot enable PCI device "
- "and request regions!\n", dev->minor);
+ dev_err(dev->class_dev,
+ "error! cannot enable PCI device and request regions!\n"
+ );
return ret;
}
spin_lock_init(&devpriv->ao_spinlock);
outw(devpriv->daccon | PCI224_DACCON_FIFORESET,
dev->iobase + PCI224_DACCON);
- /* Allocate subdevices. There is only one! */
- ret = alloc_subdevices(dev, 1);
- if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
return ret;
- }
s = dev->subdevices + 0;
/* Analog output subdevice. */
if (options) {
for (n = 2; n < 3 + s->n_chan; n++) {
if (options[n] < 0 || options[n] > 1) {
- printk(KERN_WARNING
- "comedi%d: %s: warning! bad options[%u]=%d\n",
- dev->minor, DRIVER_NAME, n,
- options[n]);
+ dev_warn(dev->class_dev, DRIVER_NAME
+ ": warning! bad options[%u]=%d\n",
+ n, options[n]);
}
}
}
devpriv->hwrange = hwrange_pci224_external;
} else {
if (options && options[2] != 0) {
- printk(KERN_WARNING "comedi%d: %s: warning! "
- "bad options[2]=%d\n",
- dev->minor, DRIVER_NAME, options[2]);
+ dev_warn(dev->class_dev, DRIVER_NAME
+ ": warning! bad options[2]=%d\n",
+ options[2]);
}
s->range_table = &range_pci224_internal;
devpriv->hwrange = hwrange_pci224_internal;
ret = request_irq(irq, pci224_interrupt, IRQF_SHARED,
DRIVER_NAME, dev);
if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! "
- "unable to allocate irq %u\n", dev->minor, irq);
+ dev_err(dev->class_dev,
+ "error! unable to allocate irq %u\n", irq);
return ret;
} else {
dev->irq = irq;
}
}
- printk(KERN_INFO "comedi%d: %s ", dev->minor, dev->board_name);
- printk("(pci %s) ", pci_name(pci_dev));
- if (irq)
- printk("(irq %u%s) ", irq, (dev->irq ? "" : " UNAVAILABLE"));
- else
- printk("(no irq) ");
-
-
- printk("attached\n");
-
+ pci224_report_attach(dev, irq);
return 1;
}
int bus, slot;
int ret;
- printk(KERN_DEBUG "comedi%d: %s: attach\n", dev->minor, DRIVER_NAME);
+ dev_info(dev->class_dev, DRIVER_NAME ": attach\n");
bus = it->options[0];
slot = it->options[1];
ret = alloc_private(dev, sizeof(struct pci224_private));
if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
+ dev_err(dev->class_dev, "error! out of memory!\n");
return ret;
}
- ret = pci224_find_pci(dev, bus, slot, &pci_dev);
- if (ret < 0)
- return ret;
+ pci_dev = pci224_find_pci(dev, bus, slot);
+ if (pci_dev == NULL)
+ return -EIO;
return pci224_attach_common(dev, pci_dev, it->options);
}
-static int
+static int __devinit
pci224_attach_pci(struct comedi_device *dev, struct pci_dev *pci_dev)
{
int ret;
- printk(KERN_DEBUG "comedi%d: %s: attach_pci %s\n", dev->minor,
- DRIVER_NAME, pci_name(pci_dev));
+ dev_info(dev->class_dev, DRIVER_NAME ": attach_pci %s\n",
+ pci_name(pci_dev));
ret = alloc_private(dev, sizeof(struct pci224_private));
if (ret < 0) {
- printk(KERN_ERR "comedi%d: error! out of memory!\n",
- dev->minor);
+ dev_err(dev->class_dev, "error! out of memory!\n");
return ret;
}
dev->board_ptr = pci224_find_pci_board(pci_dev);
if (dev->board_ptr == NULL) {
- printk(KERN_ERR
- "comedi%d: %s: BUG! cannot determine board type!\n",
- dev->minor, DRIVER_NAME);
+ dev_err(dev->class_dev,
+ DRIVER_NAME ": BUG! cannot determine board type!\n");
return -EINVAL;
}
return pci224_attach_common(dev, pci_dev, NULL);
static void pci224_detach(struct comedi_device *dev)
{
+ struct pci224_private *devpriv = dev->private;
+
if (dev->irq)
free_irq(dev->irq, dev);
if (dev->subdevices) {
#include <linux/delay.h>
#include <linux/interrupt.h>
-#include "comedi_pci.h"
#include "8253.h"
#include "8255.h"
/* Combine old and new bits. */
#define COMBINE(old, new, mask) (((old) & ~(mask)) | ((new) & (mask)))
-/* A generic null function pointer value. */
-#define NULLFUNC 0
-
/* Current CPU. XXX should this be hard_smp_processor_id()? */
#define THISCPU smp_processor_id()
},
};
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define n_pci230_boards ARRAY_SIZE(pci230_boards)
-#define thisboard ((const struct pci230_board *)dev->board_ptr)
-
/* this structure is for data unique to this hardware driver. If
several hardware drivers keep similar information in this structure,
feel free to suggest moving the variable to the struct comedi_device struct. */
unsigned char res_owner[NUM_RESOURCES]; /* Shared resource owners. */
};
-#define devpriv ((struct pci230_private *)dev->private)
-
/* PCI230 clock source periods in ns */
static const unsigned int pci230_timebase[8] = {
[CLK_10MHZ] = TIMEBASE_10MHZ,
/* PCI230 daccon bipolar flag for each analogue output range. */
static const unsigned char pci230_ao_bipolar[2] = { 0, 1 };
-static int pci230_ai_rinsn(struct comedi_device *dev,
- struct comedi_subdevice *s, struct comedi_insn *insn,
- unsigned int *data);
-static int pci230_ao_winsn(struct comedi_device *dev,
- struct comedi_subdevice *s, struct comedi_insn *insn,
- unsigned int *data);
-static int pci230_ao_rinsn(struct comedi_device *dev,
- struct comedi_subdevice *s, struct comedi_insn *insn,
- unsigned int *data);
-static void pci230_ct_setup_ns_mode(struct comedi_device *dev, unsigned int ct,
- unsigned int mode, uint64_t ns,
- unsigned int round);
-static void pci230_ns_to_single_timer(unsigned int *ns, unsigned int round);
-static void pci230_cancel_ct(struct comedi_device *dev, unsigned int ct);
-static irqreturn_t pci230_interrupt(int irq, void *d);
-static int pci230_ao_cmdtest(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_cmd *cmd);
-static int pci230_ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
-static int pci230_ao_cancel(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static void pci230_ao_stop(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static void pci230_handle_ao_nofifo(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static int pci230_handle_ao_fifo(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static int pci230_ai_cmdtest(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_cmd *cmd);
-static int pci230_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
-static int pci230_ai_cancel(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static void pci230_ai_stop(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static void pci230_handle_ai(struct comedi_device *dev,
- struct comedi_subdevice *s);
-
static short pci230_ai_read(struct comedi_device *dev)
{
- /* Read sample. */
- short data = (short)inw(dev->iobase + PCI230_ADCDATA);
+ const struct pci230_board *thisboard = comedi_board(dev);
+ struct pci230_private *devpriv = dev->private;
+ short data;
+ /* Read sample. */
+ data = (short)inw(dev->iobase + PCI230_ADCDATA);
/* PCI230 is 12 bit - stored in upper bits of 16 bit register (lower
* four bits reserved for expansion). */
/* PCI230+ is 16 bit AI. */
static inline unsigned short pci230_ao_mangle_datum(struct comedi_device *dev,
short datum)
{
+ const struct pci230_board *thisboard = comedi_board(dev);
+ struct pci230_private *devpriv = dev->private;
+
/* If a bipolar range was specified, mangle it (straight binary->twos
* complement). */
if (devpriv->ao_bipolar)
datum ^= 1 << (thisboard->ao_bits - 1);
-
/* PCI230 is 12 bit - stored in upper bits of 16 bit register (lower
* four bits reserved for expansion). */
/* PCI230+ is also 12 bit AO. */
static inline void pci230_ao_write_nofifo(struct comedi_device *dev,
short datum, unsigned int chan)
{
+ struct pci230_private *devpriv = dev->private;
+
/* Store unmangled datum to be read back later. */
devpriv->ao_readback[chan] = datum;
static inline void pci230_ao_write_fifo(struct comedi_device *dev, short datum,
unsigned int chan)
{
+ struct pci230_private *devpriv = dev->private;
+
/* Store unmangled datum to be read back later. */
devpriv->ao_readback[chan] = datum;
dev->iobase + PCI230P2_DACDATA);
}
-/*
- * Attach is called by the Comedi core to configure the driver
- * for a particular board. If you specified a board_name array
- * in the driver structure, dev->board_ptr contains that
- * address.
- */
-static int pci230_attach(struct comedi_device *dev, struct comedi_devconfig *it)
-{
- struct comedi_subdevice *s;
- unsigned long iobase1, iobase2;
- /* PCI230's I/O spaces 1 and 2 respectively. */
- struct pci_dev *pci_dev = NULL;
- int i = 0, irq_hdl, rc;
-
- printk("comedi%d: amplc_pci230: attach %s %d,%d\n", dev->minor,
- thisboard->name, it->options[0], it->options[1]);
-
- /* Allocate the private structure area using alloc_private().
- * Macro defined in comedidev.h - memsets struct fields to 0. */
- if ((alloc_private(dev, sizeof(struct pci230_private))) < 0)
- return -ENOMEM;
-
- spin_lock_init(&devpriv->isr_spinlock);
- spin_lock_init(&devpriv->res_spinlock);
- spin_lock_init(&devpriv->ai_stop_spinlock);
- spin_lock_init(&devpriv->ao_stop_spinlock);
- /* Find card */
- for_each_pci_dev(pci_dev) {
- if (it->options[0] || it->options[1]) {
- /* Match against bus/slot options. */
- if (it->options[0] != pci_dev->bus->number ||
- it->options[1] != PCI_SLOT(pci_dev->devfn))
- continue;
- }
- if (pci_dev->vendor != PCI_VENDOR_ID_AMPLICON)
- continue;
- if (thisboard->id == PCI_DEVICE_ID_INVALID) {
- /* The name was specified as "amplc_pci230" which is
- * used to match any supported device. Replace the
- * current dev->board_ptr with one that matches the
- * PCI device ID. */
- for (i = 0; i < n_pci230_boards; i++) {
- if (pci_dev->device == pci230_boards[i].id) {
- if (pci230_boards[i].min_hwver > 0) {
- /* Check for a '+' model.
- * First check length of
- * registers. */
- if (pci_resource_len(pci_dev, 3)
- < 32) {
- /* Not a '+' model. */
- continue;
- }
- /* TODO: temporarily enable the
- * PCI device and read the
- * hardware version register.
- * For now assume it's okay. */
- }
- /* Change board_ptr to matched board */
- dev->board_ptr = &pci230_boards[i];
- break;
- }
- }
- if (i < n_pci230_boards)
- break;
- } else {
- /* The name was specified as a specific device name.
- * The current dev->board_ptr is correct. Check
- * whether it matches the PCI device ID. */
- if (thisboard->id == pci_dev->device) {
- /* Check minimum hardware version. */
- if (thisboard->min_hwver > 0) {
- /* Looking for a '+' model. First
- * check length of registers. */
- if (pci_resource_len(pci_dev, 3) < 32) {
- /* Not a '+' model. */
- continue;
- }
- /* TODO: temporarily enable the PCI
- * device and read the hardware version
- * register. For now, assume it's
- * okay. */
- break;
- } else {
- break;
- }
- }
- }
- }
- if (!pci_dev) {
- printk("comedi%d: No %s card found\n", dev->minor,
- thisboard->name);
- return -EIO;
- }
- devpriv->pci_dev = pci_dev;
-
- /*
- * Initialize dev->board_name.
- */
- dev->board_name = thisboard->name;
-
- /* Enable PCI device and reserve I/O spaces. */
- if (comedi_pci_enable(pci_dev, "amplc_pci230") < 0) {
- printk("comedi%d: failed to enable PCI device "
- "and request regions\n", dev->minor);
- return -EIO;
- }
-
- /* Read base addresses of the PCI230's two I/O regions from PCI
- * configuration register. */
- iobase1 = pci_resource_start(pci_dev, 2);
- iobase2 = pci_resource_start(pci_dev, 3);
-
- printk("comedi%d: %s I/O region 1 0x%04lx I/O region 2 0x%04lx\n",
- dev->minor, dev->board_name, iobase1, iobase2);
-
- devpriv->iobase1 = iobase1;
- dev->iobase = iobase2;
-
- /* Read bits of DACCON register - only the output range. */
- devpriv->daccon = inw(dev->iobase + PCI230_DACCON) & PCI230_DAC_OR_MASK;
-
- /* Read hardware version register and set extended function register
- * if they exist. */
- if (pci_resource_len(pci_dev, 3) >= 32) {
- unsigned short extfunc = 0;
-
- devpriv->hwver = inw(dev->iobase + PCI230P_HWVER);
- if (devpriv->hwver < thisboard->min_hwver) {
- printk("comedi%d: %s - bad hardware version "
- "- got %u, need %u\n", dev->minor,
- dev->board_name, devpriv->hwver,
- thisboard->min_hwver);
- return -EIO;
- }
- if (devpriv->hwver > 0) {
- if (!thisboard->have_dio) {
- /* No DIO ports. Route counters' external gates
- * to the EXTTRIG signal (PCI260+ pin 17).
- * (Otherwise, they would be routed to DIO
- * inputs PC0, PC1 and PC2 which don't exist
- * on PCI260[+].) */
- extfunc |= PCI230P_EXTFUNC_GAT_EXTTRIG;
- }
- if ((thisboard->ao_chans > 0)
- && (devpriv->hwver >= 2)) {
- /* Enable DAC FIFO functionality. */
- extfunc |= PCI230P2_EXTFUNC_DACFIFO;
- }
- }
- outw(extfunc, dev->iobase + PCI230P_EXTFUNC);
- if ((extfunc & PCI230P2_EXTFUNC_DACFIFO) != 0) {
- /* Temporarily enable DAC FIFO, reset it and disable
- * FIFO wraparound. */
- outw(devpriv->daccon | PCI230P2_DAC_FIFO_EN
- | PCI230P2_DAC_FIFO_RESET,
- dev->iobase + PCI230_DACCON);
- /* Clear DAC FIFO channel enable register. */
- outw(0, dev->iobase + PCI230P2_DACEN);
- /* Disable DAC FIFO. */
- outw(devpriv->daccon, dev->iobase + PCI230_DACCON);
- }
- }
-
- /* Disable board's interrupts. */
- outb(0, devpriv->iobase1 + PCI230_INT_SCE);
-
- /* Set ADC to a reasonable state. */
- devpriv->adcg = 0;
- devpriv->adccon = PCI230_ADC_TRIG_NONE | PCI230_ADC_IM_SE
- | PCI230_ADC_IR_BIP;
- outw(1 << 0, dev->iobase + PCI230_ADCEN);
- outw(devpriv->adcg, dev->iobase + PCI230_ADCG);
- outw(devpriv->adccon | PCI230_ADC_FIFO_RESET,
- dev->iobase + PCI230_ADCCON);
-
- /* Register the interrupt handler. */
- irq_hdl = request_irq(devpriv->pci_dev->irq, pci230_interrupt,
- IRQF_SHARED, "amplc_pci230", dev);
- if (irq_hdl < 0) {
- printk("comedi%d: unable to register irq, "
- "commands will not be available %d\n", dev->minor,
- devpriv->pci_dev->irq);
- } else {
- dev->irq = devpriv->pci_dev->irq;
- printk("comedi%d: registered irq %u\n", dev->minor,
- devpriv->pci_dev->irq);
- }
-
- /*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- if (alloc_subdevices(dev, 3) < 0)
- return -ENOMEM;
-
- s = dev->subdevices + 0;
- /* analog input subdevice */
- s->type = COMEDI_SUBD_AI;
- s->subdev_flags = SDF_READABLE | SDF_DIFF | SDF_GROUND;
- s->n_chan = thisboard->ai_chans;
- s->maxdata = (1 << thisboard->ai_bits) - 1;
- s->range_table = &pci230_ai_range;
- s->insn_read = &pci230_ai_rinsn;
- s->len_chanlist = 256; /* but there are restrictions. */
- /* Only register commands if the interrupt handler is installed. */
- if (irq_hdl == 0) {
- dev->read_subdev = s;
- s->subdev_flags |= SDF_CMD_READ;
- s->do_cmd = &pci230_ai_cmd;
- s->do_cmdtest = &pci230_ai_cmdtest;
- s->cancel = pci230_ai_cancel;
- }
-
- s = dev->subdevices + 1;
- /* analog output subdevice */
- if (thisboard->ao_chans > 0) {
- s->type = COMEDI_SUBD_AO;
- s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
- s->n_chan = thisboard->ao_chans;
- s->maxdata = (1 << thisboard->ao_bits) - 1;
- s->range_table = &pci230_ao_range;
- s->insn_write = &pci230_ao_winsn;
- s->insn_read = &pci230_ao_rinsn;
- s->len_chanlist = thisboard->ao_chans;
- /* Only register commands if the interrupt handler is
- * installed. */
- if (irq_hdl == 0) {
- dev->write_subdev = s;
- s->subdev_flags |= SDF_CMD_WRITE;
- s->do_cmd = &pci230_ao_cmd;
- s->do_cmdtest = &pci230_ao_cmdtest;
- s->cancel = pci230_ao_cancel;
- }
- } else {
- s->type = COMEDI_SUBD_UNUSED;
- }
-
- s = dev->subdevices + 2;
- /* digital i/o subdevice */
- if (thisboard->have_dio) {
- rc = subdev_8255_init(dev, s, NULL,
- (devpriv->iobase1 + PCI230_PPI_X_BASE));
- if (rc < 0)
- return rc;
- } else {
- s->type = COMEDI_SUBD_UNUSED;
- }
-
- printk("comedi%d: attached\n", dev->minor);
-
- return 1;
-}
-
-static void pci230_detach(struct comedi_device *dev)
-{
- if (dev->subdevices && thisboard->have_dio)
- subdev_8255_cleanup(dev, dev->subdevices + 2);
- if (dev->irq)
- free_irq(dev->irq, dev);
- if (devpriv) {
- if (devpriv->pci_dev) {
- if (dev->iobase)
- comedi_pci_disable(devpriv->pci_dev);
- pci_dev_put(devpriv->pci_dev);
- }
- }
-}
-
static int get_resources(struct comedi_device *dev, unsigned int res_mask,
unsigned char owner)
{
+ struct pci230_private *devpriv = dev->private;
int ok;
unsigned int i;
unsigned int b;
static void put_resources(struct comedi_device *dev, unsigned int res_mask,
unsigned char owner)
{
+ struct pci230_private *devpriv = dev->private;
unsigned int i;
unsigned int b;
unsigned long irqflags;
put_resources(dev, (1U << NUM_RESOURCES) - 1, owner);
}
-/*
- * COMEDI_SUBD_AI instruction;
- */
-static int pci230_ai_rinsn(struct comedi_device *dev,
- struct comedi_subdevice *s, struct comedi_insn *insn,
- unsigned int *data)
+static unsigned int divide_ns(uint64_t ns, unsigned int timebase,
+ unsigned int round_mode)
{
- unsigned int n, i;
- unsigned int chan, range, aref;
- unsigned int gainshift;
- unsigned int status;
- unsigned short adccon, adcen;
-
- /* Unpack channel and range. */
- chan = CR_CHAN(insn->chanspec);
- range = CR_RANGE(insn->chanspec);
- aref = CR_AREF(insn->chanspec);
- if (aref == AREF_DIFF) {
- /* Differential. */
- if (chan >= s->n_chan / 2) {
- DPRINTK("comedi%d: amplc_pci230: ai_rinsn: "
- "differential channel number out of range "
- "0 to %u\n", dev->minor, (s->n_chan / 2) - 1);
- return -EINVAL;
- }
- }
+ uint64_t div;
+ unsigned int rem;
- /* Use Z2-CT2 as a conversion trigger instead of the built-in
- * software trigger, as otherwise triggering of differential channels
- * doesn't work properly for some versions of PCI230/260. Also set
- * FIFO mode because the ADC busy bit only works for software triggers.
+ div = ns;
+ rem = do_div(div, timebase);
+ round_mode &= TRIG_ROUND_MASK;
+ switch (round_mode) {
+ default:
+ case TRIG_ROUND_NEAREST:
+ div += (rem + (timebase / 2)) / timebase;
+ break;
+ case TRIG_ROUND_DOWN:
+ break;
+ case TRIG_ROUND_UP:
+ div += (rem + timebase - 1) / timebase;
+ break;
+ }
+ return div > UINT_MAX ? UINT_MAX : (unsigned int)div;
+}
+
+/* Given desired period in ns, returns the required internal clock source
+ * and gets the initial count. */
+static unsigned int pci230_choose_clk_count(uint64_t ns, unsigned int *count,
+ unsigned int round_mode)
+{
+ unsigned int clk_src, cnt;
+
+ for (clk_src = CLK_10MHZ;; clk_src++) {
+ cnt = divide_ns(ns, pci230_timebase[clk_src], round_mode);
+ if ((cnt <= 65536) || (clk_src == CLK_1KHZ))
+ break;
+
+ }
+ *count = cnt;
+ return clk_src;
+}
+
+static void pci230_ns_to_single_timer(unsigned int *ns, unsigned int round)
+{
+ unsigned int count;
+ unsigned int clk_src;
+
+ clk_src = pci230_choose_clk_count(*ns, &count, round);
+ *ns = count * pci230_timebase[clk_src];
+ return;
+}
+
+static void pci230_ct_setup_ns_mode(struct comedi_device *dev, unsigned int ct,
+ unsigned int mode, uint64_t ns,
+ unsigned int round)
+{
+ struct pci230_private *devpriv = dev->private;
+ unsigned int clk_src;
+ unsigned int count;
+
+ /* Set mode. */
+ i8254_set_mode(devpriv->iobase1 + PCI230_Z2_CT_BASE, 0, ct, mode);
+ /* Determine clock source and count. */
+ clk_src = pci230_choose_clk_count(ns, &count, round);
+ /* Program clock source. */
+ outb(CLK_CONFIG(ct, clk_src), devpriv->iobase1 + PCI230_ZCLK_SCE);
+ /* Set initial count. */
+ if (count >= 65536)
+ count = 0;
+
+ i8254_write(devpriv->iobase1 + PCI230_Z2_CT_BASE, 0, ct, count);
+}
+
+static void pci230_cancel_ct(struct comedi_device *dev, unsigned int ct)
+{
+ struct pci230_private *devpriv = dev->private;
+
+ i8254_set_mode(devpriv->iobase1 + PCI230_Z2_CT_BASE, 0, ct,
+ I8254_MODE1);
+ /* Counter ct, 8254 mode 1, initial count not written. */
+}
+
+/*
+ * COMEDI_SUBD_AI instruction;
+ */
+static int pci230_ai_rinsn(struct comedi_device *dev,
+ struct comedi_subdevice *s, struct comedi_insn *insn,
+ unsigned int *data)
+{
+ struct pci230_private *devpriv = dev->private;
+ unsigned int n, i;
+ unsigned int chan, range, aref;
+ unsigned int gainshift;
+ unsigned int status;
+ unsigned short adccon, adcen;
+
+ /* Unpack channel and range. */
+ chan = CR_CHAN(insn->chanspec);
+ range = CR_RANGE(insn->chanspec);
+ aref = CR_AREF(insn->chanspec);
+ if (aref == AREF_DIFF) {
+ /* Differential. */
+ if (chan >= s->n_chan / 2) {
+ DPRINTK("comedi%d: amplc_pci230: ai_rinsn: "
+ "differential channel number out of range "
+ "0 to %u\n", dev->minor, (s->n_chan / 2) - 1);
+ return -EINVAL;
+ }
+ }
+
+ /* Use Z2-CT2 as a conversion trigger instead of the built-in
+ * software trigger, as otherwise triggering of differential channels
+ * doesn't work properly for some versions of PCI230/260. Also set
+ * FIFO mode because the ADC busy bit only works for software triggers.
*/
adccon = PCI230_ADC_TRIG_Z2CT2 | PCI230_ADC_FIFO_EN;
/* Set Z2-CT2 output low to avoid any false triggers. */
udelay(1);
}
if (i == TIMEOUT) {
- /* printk() should be used instead of printk()
- * whenever the code can be called from real-time. */
- printk("timeout\n");
+ dev_err(dev->class_dev, "timeout\n");
return -ETIMEDOUT;
}
struct comedi_subdevice *s, struct comedi_insn *insn,
unsigned int *data)
{
+ struct pci230_private *devpriv = dev->private;
int i;
int chan, range;
struct comedi_subdevice *s, struct comedi_insn *insn,
unsigned int *data)
{
+ struct pci230_private *devpriv = dev->private;
int i;
int chan = CR_CHAN(insn->chanspec);
static int pci230_ao_cmdtest(struct comedi_device *dev,
struct comedi_subdevice *s, struct comedi_cmd *cmd)
{
+ const struct pci230_board *thisboard = comedi_board(dev);
+ struct pci230_private *devpriv = dev->private;
int err = 0;
unsigned int tmp;
return 0;
}
-static int pci230_ao_inttrig_scan_begin(struct comedi_device *dev,
- struct comedi_subdevice *s,
- unsigned int trig_num)
+static void pci230_ao_stop(struct comedi_device *dev,
+ struct comedi_subdevice *s)
{
+ struct pci230_private *devpriv = dev->private;
unsigned long irqflags;
-
- if (trig_num != 0)
- return -EINVAL;
+ unsigned char intsrc;
+ int started;
+ struct comedi_cmd *cmd;
spin_lock_irqsave(&devpriv->ao_stop_spinlock, irqflags);
- if (test_bit(AO_CMD_STARTED, &devpriv->state)) {
- /* Perform scan. */
- if (devpriv->hwver < 2) {
- /* Not using DAC FIFO. */
- spin_unlock_irqrestore(&devpriv->ao_stop_spinlock,
- irqflags);
- pci230_handle_ao_nofifo(dev, s);
- comedi_event(dev, s);
- } else {
- /* Using DAC FIFO. */
- /* Read DACSWTRIG register to trigger conversion. */
- inw(dev->iobase + PCI230P2_DACSWTRIG);
- spin_unlock_irqrestore(&devpriv->ao_stop_spinlock,
- irqflags);
- }
- /* Delay. Should driver be responsible for this? */
- /* XXX TODO: See if DAC busy bit can be used. */
- udelay(8);
+ started = test_and_clear_bit(AO_CMD_STARTED, &devpriv->state);
+ spin_unlock_irqrestore(&devpriv->ao_stop_spinlock, irqflags);
+ if (!started)
+ return;
+ cmd = &s->async->cmd;
+ if (cmd->scan_begin_src == TRIG_TIMER) {
+ /* Stop scan rate generator. */
+ pci230_cancel_ct(dev, 1);
}
-
- return 1;
+ /* Determine interrupt source. */
+ if (devpriv->hwver < 2) {
+ /* Not using DAC FIFO. Using CT1 interrupt. */
+ intsrc = PCI230_INT_ZCLK_CT1;
+ } else {
+ /* Using DAC FIFO interrupt. */
+ intsrc = PCI230P2_INT_DAC;
+ }
+ /* Disable interrupt and wait for interrupt routine to finish running
+ * unless we are called from the interrupt routine. */
+ spin_lock_irqsave(&devpriv->isr_spinlock, irqflags);
+ devpriv->int_en &= ~intsrc;
+ while (devpriv->intr_running && devpriv->intr_cpuid != THISCPU) {
+ spin_unlock_irqrestore(&devpriv->isr_spinlock, irqflags);
+ spin_lock_irqsave(&devpriv->isr_spinlock, irqflags);
+ }
+ if (devpriv->ier != devpriv->int_en) {
+ devpriv->ier = devpriv->int_en;
+ outb(devpriv->ier, devpriv->iobase1 + PCI230_INT_SCE);
+ }
+ spin_unlock_irqrestore(&devpriv->isr_spinlock, irqflags);
+ if (devpriv->hwver >= 2) {
+ /* Using DAC FIFO. Reset FIFO, clear underrun error,
+ * disable FIFO. */
+ devpriv->daccon &= PCI230_DAC_OR_MASK;
+ outw(devpriv->daccon | PCI230P2_DAC_FIFO_RESET
+ | PCI230P2_DAC_FIFO_UNDERRUN_CLEAR,
+ dev->iobase + PCI230_DACCON);
+ }
+ /* Release resources. */
+ put_all_resources(dev, OWNER_AOCMD);
}
-static void pci230_ao_start(struct comedi_device *dev,
- struct comedi_subdevice *s)
+static void pci230_handle_ao_nofifo(struct comedi_device *dev,
+ struct comedi_subdevice *s)
{
+ struct pci230_private *devpriv = dev->private;
+ short data;
+ int i, ret;
struct comedi_async *async = s->async;
struct comedi_cmd *cmd = &async->cmd;
- unsigned long irqflags;
-
- set_bit(AO_CMD_STARTED, &devpriv->state);
- if (!devpriv->ao_continuous && (devpriv->ao_scan_count == 0)) {
- /* An empty acquisition! */
- async->events |= COMEDI_CB_EOA;
- pci230_ao_stop(dev, s);
- comedi_event(dev, s);
- } else {
- if (devpriv->hwver >= 2) {
- /* Using DAC FIFO. */
- unsigned short scantrig;
- int run;
-
- /* Preload FIFO data. */
- run = pci230_handle_ao_fifo(dev, s);
- comedi_event(dev, s);
- if (!run) {
- /* Stopped. */
- return;
- }
- /* Set scan trigger source. */
- switch (cmd->scan_begin_src) {
- case TRIG_TIMER:
- scantrig = PCI230P2_DAC_TRIG_Z2CT1;
- break;
- case TRIG_EXT:
- /* Trigger on EXTTRIG/EXTCONVCLK pin. */
- if ((cmd->scan_begin_arg & CR_INVERT) == 0) {
- /* +ve edge */
- scantrig = PCI230P2_DAC_TRIG_EXTP;
- } else {
- /* -ve edge */
- scantrig = PCI230P2_DAC_TRIG_EXTN;
- }
- break;
- case TRIG_INT:
- scantrig = PCI230P2_DAC_TRIG_SW;
- break;
- default:
- /* Shouldn't get here. */
- scantrig = PCI230P2_DAC_TRIG_NONE;
- break;
- }
- devpriv->daccon = (devpriv->daccon
- & ~PCI230P2_DAC_TRIG_MASK) |
- scantrig;
- outw(devpriv->daccon, dev->iobase + PCI230_DACCON);
+ if (!devpriv->ao_continuous && (devpriv->ao_scan_count == 0))
+ return;
+ for (i = 0; i < cmd->chanlist_len; i++) {
+ /* Read sample from Comedi's circular buffer. */
+ ret = comedi_buf_get(s->async, &data);
+ if (ret == 0) {
+ s->async->events |= COMEDI_CB_OVERFLOW;
+ pci230_ao_stop(dev, s);
+ comedi_error(dev, "AO buffer underrun");
+ return;
}
- switch (cmd->scan_begin_src) {
- case TRIG_TIMER:
- if (devpriv->hwver < 2) {
- /* Not using DAC FIFO. */
- /* Enable CT1 timer interrupt. */
- spin_lock_irqsave(&devpriv->isr_spinlock,
- irqflags);
- devpriv->int_en |= PCI230_INT_ZCLK_CT1;
- devpriv->ier |= PCI230_INT_ZCLK_CT1;
- outb(devpriv->ier,
- devpriv->iobase1 + PCI230_INT_SCE);
- spin_unlock_irqrestore(&devpriv->isr_spinlock,
- irqflags);
- }
- /* Set CT1 gate high to start counting. */
- outb(GAT_CONFIG(1, GAT_VCC),
- devpriv->iobase1 + PCI230_ZGAT_SCE);
- break;
- case TRIG_INT:
+ /* Write value to DAC. */
+ pci230_ao_write_nofifo(dev, data, CR_CHAN(cmd->chanlist[i]));
+ }
+ async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOS;
+ if (!devpriv->ao_continuous) {
+ devpriv->ao_scan_count--;
+ if (devpriv->ao_scan_count == 0) {
+ /* End of acquisition. */
+ async->events |= COMEDI_CB_EOA;
+ pci230_ao_stop(dev, s);
+ }
+ }
+}
+
+/* Loads DAC FIFO (if using it) from buffer. */
+/* Returns 0 if AO finished due to completion or error, 1 if still going. */
+static int pci230_handle_ao_fifo(struct comedi_device *dev,
+ struct comedi_subdevice *s)
+{
+ struct pci230_private *devpriv = dev->private;
+ struct comedi_async *async = s->async;
+ struct comedi_cmd *cmd = &async->cmd;
+ unsigned int num_scans;
+ unsigned int room;
+ unsigned short dacstat;
+ unsigned int i, n;
+ unsigned int bytes_per_scan;
+ unsigned int events = 0;
+ int running;
+
+ /* Get DAC FIFO status. */
+ dacstat = inw(dev->iobase + PCI230_DACCON);
+ /* Determine number of scans available in buffer. */
+ bytes_per_scan = cmd->chanlist_len * sizeof(short);
+ num_scans = comedi_buf_read_n_available(async) / bytes_per_scan;
+ if (!devpriv->ao_continuous) {
+ /* Fixed number of scans. */
+ if (num_scans > devpriv->ao_scan_count)
+ num_scans = devpriv->ao_scan_count;
+ if (devpriv->ao_scan_count == 0) {
+ /* End of acquisition. */
+ events |= COMEDI_CB_EOA;
+ }
+ }
+ if (events == 0) {
+ /* Check for FIFO underrun. */
+ if ((dacstat & PCI230P2_DAC_FIFO_UNDERRUN_LATCHED) != 0) {
+ comedi_error(dev, "AO FIFO underrun");
+ events |= COMEDI_CB_OVERFLOW | COMEDI_CB_ERROR;
+ }
+ /* Check for buffer underrun if FIFO less than half full
+ * (otherwise there will be loads of "DAC FIFO not half full"
+ * interrupts). */
+ if ((num_scans == 0)
+ && ((dacstat & PCI230P2_DAC_FIFO_HALF) == 0)) {
+ comedi_error(dev, "AO buffer underrun");
+ events |= COMEDI_CB_OVERFLOW | COMEDI_CB_ERROR;
+ }
+ }
+ if (events == 0) {
+ /* Determine how much room is in the FIFO (in samples). */
+ if ((dacstat & PCI230P2_DAC_FIFO_FULL) != 0)
+ room = PCI230P2_DAC_FIFOROOM_FULL;
+ else if ((dacstat & PCI230P2_DAC_FIFO_HALF) != 0)
+ room = PCI230P2_DAC_FIFOROOM_HALFTOFULL;
+ else if ((dacstat & PCI230P2_DAC_FIFO_EMPTY) != 0)
+ room = PCI230P2_DAC_FIFOROOM_EMPTY;
+ else
+ room = PCI230P2_DAC_FIFOROOM_ONETOHALF;
+ /* Convert room to number of scans that can be added. */
+ room /= cmd->chanlist_len;
+ /* Determine number of scans to process. */
+ if (num_scans > room)
+ num_scans = room;
+ /* Process scans. */
+ for (n = 0; n < num_scans; n++) {
+ for (i = 0; i < cmd->chanlist_len; i++) {
+ short datum;
+
+ comedi_buf_get(async, &datum);
+ pci230_ao_write_fifo(dev, datum,
+ CR_CHAN(cmd->chanlist[i]));
+ }
+ }
+ events |= COMEDI_CB_EOS | COMEDI_CB_BLOCK;
+ if (!devpriv->ao_continuous) {
+ devpriv->ao_scan_count -= num_scans;
+ if (devpriv->ao_scan_count == 0) {
+ /* All data for the command has been written
+ * to FIFO. Set FIFO interrupt trigger level
+ * to 'empty'. */
+ devpriv->daccon = (devpriv->daccon
+ &
+ ~PCI230P2_DAC_INT_FIFO_MASK)
+ | PCI230P2_DAC_INT_FIFO_EMPTY;
+ outw(devpriv->daccon,
+ dev->iobase + PCI230_DACCON);
+ }
+ }
+ /* Check if FIFO underrun occurred while writing to FIFO. */
+ dacstat = inw(dev->iobase + PCI230_DACCON);
+ if ((dacstat & PCI230P2_DAC_FIFO_UNDERRUN_LATCHED) != 0) {
+ comedi_error(dev, "AO FIFO underrun");
+ events |= COMEDI_CB_OVERFLOW | COMEDI_CB_ERROR;
+ }
+ }
+ if ((events & (COMEDI_CB_EOA | COMEDI_CB_ERROR | COMEDI_CB_OVERFLOW))
+ != 0) {
+ /* Stopping AO due to completion or error. */
+ pci230_ao_stop(dev, s);
+ running = 0;
+ } else {
+ running = 1;
+ }
+ async->events |= events;
+ return running;
+}
+
+static int pci230_ao_inttrig_scan_begin(struct comedi_device *dev,
+ struct comedi_subdevice *s,
+ unsigned int trig_num)
+{
+ struct pci230_private *devpriv = dev->private;
+ unsigned long irqflags;
+
+ if (trig_num != 0)
+ return -EINVAL;
+
+ spin_lock_irqsave(&devpriv->ao_stop_spinlock, irqflags);
+ if (test_bit(AO_CMD_STARTED, &devpriv->state)) {
+ /* Perform scan. */
+ if (devpriv->hwver < 2) {
+ /* Not using DAC FIFO. */
+ spin_unlock_irqrestore(&devpriv->ao_stop_spinlock,
+ irqflags);
+ pci230_handle_ao_nofifo(dev, s);
+ comedi_event(dev, s);
+ } else {
+ /* Using DAC FIFO. */
+ /* Read DACSWTRIG register to trigger conversion. */
+ inw(dev->iobase + PCI230P2_DACSWTRIG);
+ spin_unlock_irqrestore(&devpriv->ao_stop_spinlock,
+ irqflags);
+ }
+ /* Delay. Should driver be responsible for this? */
+ /* XXX TODO: See if DAC busy bit can be used. */
+ udelay(8);
+ } else {
+ spin_unlock_irqrestore(&devpriv->ao_stop_spinlock, irqflags);
+ }
+
+ return 1;
+}
+
+static void pci230_ao_start(struct comedi_device *dev,
+ struct comedi_subdevice *s)
+{
+ struct pci230_private *devpriv = dev->private;
+ struct comedi_async *async = s->async;
+ struct comedi_cmd *cmd = &async->cmd;
+ unsigned long irqflags;
+
+ set_bit(AO_CMD_STARTED, &devpriv->state);
+ if (!devpriv->ao_continuous && (devpriv->ao_scan_count == 0)) {
+ /* An empty acquisition! */
+ async->events |= COMEDI_CB_EOA;
+ pci230_ao_stop(dev, s);
+ comedi_event(dev, s);
+ } else {
+ if (devpriv->hwver >= 2) {
+ /* Using DAC FIFO. */
+ unsigned short scantrig;
+ int run;
+
+ /* Preload FIFO data. */
+ run = pci230_handle_ao_fifo(dev, s);
+ comedi_event(dev, s);
+ if (!run) {
+ /* Stopped. */
+ return;
+ }
+ /* Set scan trigger source. */
+ switch (cmd->scan_begin_src) {
+ case TRIG_TIMER:
+ scantrig = PCI230P2_DAC_TRIG_Z2CT1;
+ break;
+ case TRIG_EXT:
+ /* Trigger on EXTTRIG/EXTCONVCLK pin. */
+ if ((cmd->scan_begin_arg & CR_INVERT) == 0) {
+ /* +ve edge */
+ scantrig = PCI230P2_DAC_TRIG_EXTP;
+ } else {
+ /* -ve edge */
+ scantrig = PCI230P2_DAC_TRIG_EXTN;
+ }
+ break;
+ case TRIG_INT:
+ scantrig = PCI230P2_DAC_TRIG_SW;
+ break;
+ default:
+ /* Shouldn't get here. */
+ scantrig = PCI230P2_DAC_TRIG_NONE;
+ break;
+ }
+ devpriv->daccon = (devpriv->daccon
+ & ~PCI230P2_DAC_TRIG_MASK) |
+ scantrig;
+ outw(devpriv->daccon, dev->iobase + PCI230_DACCON);
+
+ }
+ switch (cmd->scan_begin_src) {
+ case TRIG_TIMER:
+ if (devpriv->hwver < 2) {
+ /* Not using DAC FIFO. */
+ /* Enable CT1 timer interrupt. */
+ spin_lock_irqsave(&devpriv->isr_spinlock,
+ irqflags);
+ devpriv->int_en |= PCI230_INT_ZCLK_CT1;
+ devpriv->ier |= PCI230_INT_ZCLK_CT1;
+ outb(devpriv->ier,
+ devpriv->iobase1 + PCI230_INT_SCE);
+ spin_unlock_irqrestore(&devpriv->isr_spinlock,
+ irqflags);
+ }
+ /* Set CT1 gate high to start counting. */
+ outb(GAT_CONFIG(1, GAT_VCC),
+ devpriv->iobase1 + PCI230_ZGAT_SCE);
+ break;
+ case TRIG_INT:
async->inttrig = pci230_ao_inttrig_scan_begin;
break;
}
if (trig_num != 0)
return -EINVAL;
- s->async->inttrig = NULLFUNC;
+ s->async->inttrig = NULL;
pci230_ao_start(dev, s);
return 1;
static int pci230_ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
{
+ struct pci230_private *devpriv = dev->private;
unsigned short daccon;
unsigned int range;
return 0;
}
+static int pci230_ao_cancel(struct comedi_device *dev,
+ struct comedi_subdevice *s)
+{
+ pci230_ao_stop(dev, s);
+ return 0;
+}
+
static int pci230_ai_check_scan_period(struct comedi_cmd *cmd)
{
unsigned int min_scan_period, chanlist_len;
static int pci230_ai_cmdtest(struct comedi_device *dev,
struct comedi_subdevice *s, struct comedi_cmd *cmd)
{
+ const struct pci230_board *thisboard = comedi_board(dev);
+ struct pci230_private *devpriv = dev->private;
int err = 0;
unsigned int tmp;
(s->n_chan / 2) - 1);
}
if ((errors & buggy_chan0_err) != 0) {
- /* Use printk instead of DPRINTK here. */
- printk("comedi: comedi%d: amplc_pci230: "
- "ai_cmdtest: Buggy PCI230+/260+ "
- "h/w version %u requires first channel "
- "of multi-channel sequence to be 0 "
- "(corrected in h/w version 4)\n",
- dev->minor, devpriv->hwver);
+ dev_info(dev->class_dev,
+ "amplc_pci230: ai_cmdtest: Buggy PCI230+/260+ h/w version %u requires first channel of multi-channel sequence to be 0 (corrected in h/w version 4)\n",
+ devpriv->hwver);
}
}
}
static void pci230_ai_update_fifo_trigger_level(struct comedi_device *dev,
struct comedi_subdevice *s)
{
+ struct pci230_private *devpriv = dev->private;
struct comedi_cmd *cmd = &s->async->cmd;
unsigned int scanlen = cmd->scan_end_arg;
unsigned int wake;
struct comedi_subdevice *s,
unsigned int trig_num)
{
+ struct pci230_private *devpriv = dev->private;
unsigned long irqflags;
if (trig_num != 0)
struct comedi_subdevice *s,
unsigned int trig_num)
{
+ struct pci230_private *devpriv = dev->private;
unsigned long irqflags;
unsigned char zgat;
return 1;
}
-static void pci230_ai_start(struct comedi_device *dev,
- struct comedi_subdevice *s)
+static void pci230_ai_stop(struct comedi_device *dev,
+ struct comedi_subdevice *s)
{
+ struct pci230_private *devpriv = dev->private;
unsigned long irqflags;
- unsigned short conv;
- struct comedi_async *async = s->async;
- struct comedi_cmd *cmd = &async->cmd;
-
- set_bit(AI_CMD_STARTED, &devpriv->state);
- if (!devpriv->ai_continuous && (devpriv->ai_scan_count == 0)) {
- /* An empty acquisition! */
- async->events |= COMEDI_CB_EOA;
- pci230_ai_stop(dev, s);
- comedi_event(dev, s);
- } else {
- /* Enable ADC FIFO trigger level interrupt. */
- spin_lock_irqsave(&devpriv->isr_spinlock, irqflags);
- devpriv->int_en |= PCI230_INT_ADC;
- devpriv->ier |= PCI230_INT_ADC;
- outb(devpriv->ier, devpriv->iobase1 + PCI230_INT_SCE);
- spin_unlock_irqrestore(&devpriv->isr_spinlock, irqflags);
+ struct comedi_cmd *cmd;
+ int started;
- /* Update conversion trigger source which is currently set
+ spin_lock_irqsave(&devpriv->ai_stop_spinlock, irqflags);
+ started = test_and_clear_bit(AI_CMD_STARTED, &devpriv->state);
+ spin_unlock_irqrestore(&devpriv->ai_stop_spinlock, irqflags);
+ if (!started)
+ return;
+ cmd = &s->async->cmd;
+ if (cmd->convert_src == TRIG_TIMER) {
+ /* Stop conversion rate generator. */
+ pci230_cancel_ct(dev, 2);
+ }
+ if (cmd->scan_begin_src != TRIG_FOLLOW) {
+ /* Stop scan period monostable. */
+ pci230_cancel_ct(dev, 0);
+ }
+ spin_lock_irqsave(&devpriv->isr_spinlock, irqflags);
+ /* Disable ADC interrupt and wait for interrupt routine to finish
+ * running unless we are called from the interrupt routine. */
+ devpriv->int_en &= ~PCI230_INT_ADC;
+ while (devpriv->intr_running && devpriv->intr_cpuid != THISCPU) {
+ spin_unlock_irqrestore(&devpriv->isr_spinlock, irqflags);
+ spin_lock_irqsave(&devpriv->isr_spinlock, irqflags);
+ }
+ if (devpriv->ier != devpriv->int_en) {
+ devpriv->ier = devpriv->int_en;
+ outb(devpriv->ier, devpriv->iobase1 + PCI230_INT_SCE);
+ }
+ spin_unlock_irqrestore(&devpriv->isr_spinlock, irqflags);
+ /* Reset FIFO, disable FIFO and set start conversion source to none.
+ * Keep se/diff and bip/uni settings */
+ devpriv->adccon = (devpriv->adccon & (PCI230_ADC_IR_MASK
+ | PCI230_ADC_IM_MASK)) |
+ PCI230_ADC_TRIG_NONE;
+ outw(devpriv->adccon | PCI230_ADC_FIFO_RESET,
+ dev->iobase + PCI230_ADCCON);
+ /* Release resources. */
+ put_all_resources(dev, OWNER_AICMD);
+}
+
+static void pci230_ai_start(struct comedi_device *dev,
+ struct comedi_subdevice *s)
+{
+ struct pci230_private *devpriv = dev->private;
+ unsigned long irqflags;
+ unsigned short conv;
+ struct comedi_async *async = s->async;
+ struct comedi_cmd *cmd = &async->cmd;
+
+ set_bit(AI_CMD_STARTED, &devpriv->state);
+ if (!devpriv->ai_continuous && (devpriv->ai_scan_count == 0)) {
+ /* An empty acquisition! */
+ async->events |= COMEDI_CB_EOA;
+ pci230_ai_stop(dev, s);
+ comedi_event(dev, s);
+ } else {
+ /* Enable ADC FIFO trigger level interrupt. */
+ spin_lock_irqsave(&devpriv->isr_spinlock, irqflags);
+ devpriv->int_en |= PCI230_INT_ADC;
+ devpriv->ier |= PCI230_INT_ADC;
+ outb(devpriv->ier, devpriv->iobase1 + PCI230_INT_SCE);
+ spin_unlock_irqrestore(&devpriv->isr_spinlock, irqflags);
+
+ /* Update conversion trigger source which is currently set
* to CT2 output, which is currently stuck high. */
switch (cmd->convert_src) {
default:
if (trig_num != 0)
return -EINVAL;
- s->async->inttrig = NULLFUNC;
+ s->async->inttrig = NULL;
pci230_ai_start(dev, s);
return 1;
}
+static void pci230_handle_ai(struct comedi_device *dev,
+ struct comedi_subdevice *s)
+{
+ struct pci230_private *devpriv = dev->private;
+ unsigned int events = 0;
+ unsigned int status_fifo;
+ unsigned int i;
+ unsigned int todo;
+ unsigned int fifoamount;
+ struct comedi_async *async = s->async;
+ unsigned int scanlen = async->cmd.scan_end_arg;
+
+ /* Determine number of samples to read. */
+ if (devpriv->ai_continuous) {
+ todo = PCI230_ADC_FIFOLEVEL_HALFFULL;
+ } else if (devpriv->ai_scan_count == 0) {
+ todo = 0;
+ } else if ((devpriv->ai_scan_count > PCI230_ADC_FIFOLEVEL_HALFFULL)
+ || (scanlen > PCI230_ADC_FIFOLEVEL_HALFFULL)) {
+ todo = PCI230_ADC_FIFOLEVEL_HALFFULL;
+ } else {
+ todo = (devpriv->ai_scan_count * scanlen)
+ - devpriv->ai_scan_pos;
+ if (todo > PCI230_ADC_FIFOLEVEL_HALFFULL)
+ todo = PCI230_ADC_FIFOLEVEL_HALFFULL;
+ }
+ if (todo == 0)
+ return;
+ fifoamount = 0;
+ for (i = 0; i < todo; i++) {
+ if (fifoamount == 0) {
+ /* Read FIFO state. */
+ status_fifo = inw(dev->iobase + PCI230_ADCCON);
+ if ((status_fifo & PCI230_ADC_FIFO_FULL_LATCHED) != 0) {
+ /* Report error otherwise FIFO overruns will go
+ * unnoticed by the caller. */
+ comedi_error(dev, "AI FIFO overrun");
+ events |= COMEDI_CB_OVERFLOW | COMEDI_CB_ERROR;
+ break;
+ } else if ((status_fifo & PCI230_ADC_FIFO_EMPTY) != 0) {
+ /* FIFO empty. */
+ break;
+ } else if ((status_fifo & PCI230_ADC_FIFO_HALF) != 0) {
+ /* FIFO half full. */
+ fifoamount = PCI230_ADC_FIFOLEVEL_HALFFULL;
+ } else {
+ /* FIFO not empty. */
+ if (devpriv->hwver > 0) {
+ /* Read PCI230+/260+ ADC FIFO level. */
+ fifoamount = inw(dev->iobase
+ + PCI230P_ADCFFLEV);
+ if (fifoamount == 0) {
+ /* Shouldn't happen. */
+ break;
+ }
+ } else {
+ fifoamount = 1;
+ }
+ }
+ }
+ /* Read sample and store in Comedi's circular buffer. */
+ if (comedi_buf_put(async, pci230_ai_read(dev)) == 0) {
+ events |= COMEDI_CB_ERROR | COMEDI_CB_OVERFLOW;
+ comedi_error(dev, "AI buffer overflow");
+ break;
+ }
+ fifoamount--;
+ devpriv->ai_scan_pos++;
+ if (devpriv->ai_scan_pos == scanlen) {
+ /* End of scan. */
+ devpriv->ai_scan_pos = 0;
+ devpriv->ai_scan_count--;
+ async->events |= COMEDI_CB_EOS;
+ }
+ }
+ if (!devpriv->ai_continuous && (devpriv->ai_scan_count == 0)) {
+ /* End of acquisition. */
+ events |= COMEDI_CB_EOA;
+ } else {
+ /* More samples required, tell Comedi to block. */
+ events |= COMEDI_CB_BLOCK;
+ }
+ async->events |= events;
+ if ((async->events & (COMEDI_CB_EOA | COMEDI_CB_ERROR |
+ COMEDI_CB_OVERFLOW)) != 0) {
+ /* disable hardware conversions */
+ pci230_ai_stop(dev, s);
+ } else {
+ /* update FIFO interrupt trigger level */
+ pci230_ai_update_fifo_trigger_level(dev, s);
+ }
+}
+
static int pci230_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
{
+ struct pci230_private *devpriv = dev->private;
unsigned int i, chan, range, diff;
unsigned int res_mask;
unsigned short adccon, adcen;
return 0;
}
-static unsigned int divide_ns(uint64_t ns, unsigned int timebase,
- unsigned int round_mode)
-{
- uint64_t div;
- unsigned int rem;
-
- div = ns;
- rem = do_div(div, timebase);
- round_mode &= TRIG_ROUND_MASK;
- switch (round_mode) {
- default:
- case TRIG_ROUND_NEAREST:
- div += (rem + (timebase / 2)) / timebase;
- break;
- case TRIG_ROUND_DOWN:
- break;
- case TRIG_ROUND_UP:
- div += (rem + timebase - 1) / timebase;
- break;
- }
- return div > UINT_MAX ? UINT_MAX : (unsigned int)div;
-}
-
-/* Given desired period in ns, returns the required internal clock source
- * and gets the initial count. */
-static unsigned int pci230_choose_clk_count(uint64_t ns, unsigned int *count,
- unsigned int round_mode)
-{
- unsigned int clk_src, cnt;
-
- for (clk_src = CLK_10MHZ;; clk_src++) {
- cnt = divide_ns(ns, pci230_timebase[clk_src], round_mode);
- if ((cnt <= 65536) || (clk_src == CLK_1KHZ))
- break;
-
- }
- *count = cnt;
- return clk_src;
-}
-
-static void pci230_ns_to_single_timer(unsigned int *ns, unsigned int round)
-{
- unsigned int count;
- unsigned int clk_src;
-
- clk_src = pci230_choose_clk_count(*ns, &count, round);
- *ns = count * pci230_timebase[clk_src];
- return;
-}
-
-static void pci230_ct_setup_ns_mode(struct comedi_device *dev, unsigned int ct,
- unsigned int mode, uint64_t ns,
- unsigned int round)
-{
- unsigned int clk_src;
- unsigned int count;
-
- /* Set mode. */
- i8254_set_mode(devpriv->iobase1 + PCI230_Z2_CT_BASE, 0, ct, mode);
- /* Determine clock source and count. */
- clk_src = pci230_choose_clk_count(ns, &count, round);
- /* Program clock source. */
- outb(CLK_CONFIG(ct, clk_src), devpriv->iobase1 + PCI230_ZCLK_SCE);
- /* Set initial count. */
- if (count >= 65536)
- count = 0;
-
- i8254_write(devpriv->iobase1 + PCI230_Z2_CT_BASE, 0, ct, count);
-}
-
-static void pci230_cancel_ct(struct comedi_device *dev, unsigned int ct)
+static int pci230_ai_cancel(struct comedi_device *dev,
+ struct comedi_subdevice *s)
{
- i8254_set_mode(devpriv->iobase1 + PCI230_Z2_CT_BASE, 0, ct,
- I8254_MODE1);
- /* Counter ct, 8254 mode 1, initial count not written. */
+ pci230_ai_stop(dev, s);
+ return 0;
}
/* Interrupt handler */
{
unsigned char status_int, valid_status_int;
struct comedi_device *dev = (struct comedi_device *)d;
+ struct pci230_private *devpriv = dev->private;
struct comedi_subdevice *s;
unsigned long irqflags;
return IRQ_HANDLED;
}
-static void pci230_handle_ao_nofifo(struct comedi_device *dev,
- struct comedi_subdevice *s)
+/* Check if PCI device matches a specific board. */
+static bool pci230_match_pci_board(const struct pci230_board *board,
+ struct pci_dev *pci_dev)
{
- short data;
- int i, ret;
- struct comedi_async *async = s->async;
- struct comedi_cmd *cmd = &async->cmd;
-
- if (!devpriv->ao_continuous && (devpriv->ao_scan_count == 0))
- return;
+ /* assume pci_dev->device != PCI_DEVICE_ID_INVALID */
+ if (board->id != pci_dev->device)
+ return false;
+ if (board->min_hwver == 0)
+ return true;
+ /* Looking for a '+' model. First check length of registers. */
+ if (pci_resource_len(pci_dev, 3) < 32)
+ return false; /* Not a '+' model. */
+ /* TODO: temporarily enable PCI device and read the hardware version
+ * register. For now, assume it's okay. */
+ return true;
+}
+/* Look for board matching PCI device. */
+static const struct pci230_board *pci230_find_pci_board(struct pci_dev *pci_dev)
+{
+ unsigned int i;
- for (i = 0; i < cmd->chanlist_len; i++) {
- /* Read sample from Comedi's circular buffer. */
- ret = comedi_buf_get(s->async, &data);
- if (ret == 0) {
- s->async->events |= COMEDI_CB_OVERFLOW;
- pci230_ao_stop(dev, s);
- comedi_error(dev, "AO buffer underrun");
- return;
- }
- /* Write value to DAC. */
- pci230_ao_write_nofifo(dev, data, CR_CHAN(cmd->chanlist[i]));
- }
+ for (i = 0; i < ARRAY_SIZE(pci230_boards); i++)
+ if (pci230_match_pci_board(&pci230_boards[i], pci_dev))
+ return &pci230_boards[i];
+ return NULL;
+}
- async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOS;
- if (!devpriv->ao_continuous) {
- devpriv->ao_scan_count--;
- if (devpriv->ao_scan_count == 0) {
- /* End of acquisition. */
- async->events |= COMEDI_CB_EOA;
- pci230_ao_stop(dev, s);
- }
- }
-}
-
-/* Loads DAC FIFO (if using it) from buffer. */
-/* Returns 0 if AO finished due to completion or error, 1 if still going. */
-static int pci230_handle_ao_fifo(struct comedi_device *dev,
- struct comedi_subdevice *s)
+/* Look for PCI device matching requested board name, bus and slot. */
+static struct pci_dev *pci230_find_pci(struct comedi_device *dev,
+ int bus, int slot)
{
- struct comedi_async *async = s->async;
- struct comedi_cmd *cmd = &async->cmd;
- unsigned int num_scans;
- unsigned int room;
- unsigned short dacstat;
- unsigned int i, n;
- unsigned int bytes_per_scan;
- unsigned int events = 0;
- int running;
-
- /* Get DAC FIFO status. */
- dacstat = inw(dev->iobase + PCI230_DACCON);
+ const struct pci230_board *thisboard = comedi_board(dev);
+ struct pci_dev *pci_dev = NULL;
- /* Determine number of scans available in buffer. */
- bytes_per_scan = cmd->chanlist_len * sizeof(short);
- num_scans = comedi_buf_read_n_available(async) / bytes_per_scan;
- if (!devpriv->ao_continuous) {
- /* Fixed number of scans. */
- if (num_scans > devpriv->ao_scan_count)
- num_scans = devpriv->ao_scan_count;
+ for_each_pci_dev(pci_dev) {
+ /* Check vendor ID (same for all supported PCI boards). */
+ if (pci_dev->vendor != PCI_VENDOR_ID_AMPLICON)
+ continue;
+ /* If bus/slot specified, check them. */
+ if ((bus || slot) &&
+ (bus != pci_dev->bus->number ||
+ slot != PCI_SLOT(pci_dev->devfn)))
+ continue;
+ if (thisboard->id == PCI_DEVICE_ID_INVALID) {
+ /* Wildcard board matches any supported PCI board. */
+ const struct pci230_board *foundboard;
- if (devpriv->ao_scan_count == 0) {
- /* End of acquisition. */
- events |= COMEDI_CB_EOA;
- }
- }
- if (events == 0) {
- /* Check for FIFO underrun. */
- if ((dacstat & PCI230P2_DAC_FIFO_UNDERRUN_LATCHED) != 0) {
- comedi_error(dev, "AO FIFO underrun");
- events |= COMEDI_CB_OVERFLOW | COMEDI_CB_ERROR;
- }
- /* Check for buffer underrun if FIFO less than half full
- * (otherwise there will be loads of "DAC FIFO not half full"
- * interrupts). */
- if ((num_scans == 0)
- && ((dacstat & PCI230P2_DAC_FIFO_HALF) == 0)) {
- comedi_error(dev, "AO buffer underrun");
- events |= COMEDI_CB_OVERFLOW | COMEDI_CB_ERROR;
+ foundboard = pci230_find_pci_board(pci_dev);
+ if (foundboard == NULL)
+ continue;
+ /* Replace wildcard board_ptr. */
+ dev->board_ptr = foundboard;
+ thisboard = comedi_board(dev);
+ } else {
+ /* Need to match a specific board. */
+ if (!pci230_match_pci_board(thisboard, pci_dev))
+ continue;
}
- }
- if (events == 0) {
- /* Determine how much room is in the FIFO (in samples). */
- if ((dacstat & PCI230P2_DAC_FIFO_FULL) != 0)
- room = PCI230P2_DAC_FIFOROOM_FULL;
- else if ((dacstat & PCI230P2_DAC_FIFO_HALF) != 0)
- room = PCI230P2_DAC_FIFOROOM_HALFTOFULL;
- else if ((dacstat & PCI230P2_DAC_FIFO_EMPTY) != 0)
- room = PCI230P2_DAC_FIFOROOM_EMPTY;
- else
- room = PCI230P2_DAC_FIFOROOM_ONETOHALF;
-
- /* Convert room to number of scans that can be added. */
- room /= cmd->chanlist_len;
- /* Determine number of scans to process. */
- if (num_scans > room)
- num_scans = room;
+ /* Found a matching PCI device. */
+ return pci_dev;
+ }
+ /* No matching PCI device found. */
+ if (bus || slot)
+ dev_err(dev->class_dev,
+ "error! no %s found at pci %02x:%02x\n",
+ thisboard->name, bus, slot);
+ else
+ dev_err(dev->class_dev,
+ "error! no %s found\n", thisboard->name);
+ return NULL;
+}
- /* Process scans. */
- for (n = 0; n < num_scans; n++) {
- for (i = 0; i < cmd->chanlist_len; i++) {
- short datum;
+static int pci230_alloc_private(struct comedi_device *dev)
+{
+ struct pci230_private *devpriv;
+ int err;
- comedi_buf_get(async, &datum);
- pci230_ao_write_fifo(dev, datum,
- CR_CHAN(cmd->chanlist[i]));
- }
- }
- events |= COMEDI_CB_EOS | COMEDI_CB_BLOCK;
- if (!devpriv->ao_continuous) {
- devpriv->ao_scan_count -= num_scans;
- if (devpriv->ao_scan_count == 0) {
- /* All data for the command has been written
- * to FIFO. Set FIFO interrupt trigger level
- * to 'empty'. */
- devpriv->daccon = (devpriv->daccon
- &
- ~PCI230P2_DAC_INT_FIFO_MASK)
- | PCI230P2_DAC_INT_FIFO_EMPTY;
- outw(devpriv->daccon,
- dev->iobase + PCI230_DACCON);
- }
- }
- /* Check if FIFO underrun occurred while writing to FIFO. */
- dacstat = inw(dev->iobase + PCI230_DACCON);
- if ((dacstat & PCI230P2_DAC_FIFO_UNDERRUN_LATCHED) != 0) {
- comedi_error(dev, "AO FIFO underrun");
- events |= COMEDI_CB_OVERFLOW | COMEDI_CB_ERROR;
- }
+ /* sets dev->private to allocated memory */
+ err = alloc_private(dev, sizeof(struct pci230_private));
+ if (err) {
+ dev_err(dev->class_dev, "error! out of memory!\n");
+ return err;
}
- if ((events & (COMEDI_CB_EOA | COMEDI_CB_ERROR | COMEDI_CB_OVERFLOW))
- != 0) {
- /* Stopping AO due to completion or error. */
- pci230_ao_stop(dev, s);
- running = 0;
- } else {
- running = 1;
- }
- async->events |= events;
- return running;
+ devpriv = dev->private;
+ spin_lock_init(&devpriv->isr_spinlock);
+ spin_lock_init(&devpriv->res_spinlock);
+ spin_lock_init(&devpriv->ai_stop_spinlock);
+ spin_lock_init(&devpriv->ao_stop_spinlock);
+ return 0;
}
-static void pci230_handle_ai(struct comedi_device *dev,
- struct comedi_subdevice *s)
+/* Common part of attach and attach_pci. */
+static int pci230_attach_common(struct comedi_device *dev,
+ struct pci_dev *pci_dev)
{
- unsigned int events = 0;
- unsigned int status_fifo;
- unsigned int i;
- unsigned int todo;
- unsigned int fifoamount;
- struct comedi_async *async = s->async;
- unsigned int scanlen = async->cmd.scan_end_arg;
-
- /* Determine number of samples to read. */
- if (devpriv->ai_continuous) {
- todo = PCI230_ADC_FIFOLEVEL_HALFFULL;
- } else if (devpriv->ai_scan_count == 0) {
- todo = 0;
- } else if ((devpriv->ai_scan_count > PCI230_ADC_FIFOLEVEL_HALFFULL)
- || (scanlen > PCI230_ADC_FIFOLEVEL_HALFFULL)) {
- todo = PCI230_ADC_FIFOLEVEL_HALFFULL;
- } else {
- todo = (devpriv->ai_scan_count * scanlen)
- - devpriv->ai_scan_pos;
- if (todo > PCI230_ADC_FIFOLEVEL_HALFFULL)
- todo = PCI230_ADC_FIFOLEVEL_HALFFULL;
+ const struct pci230_board *thisboard = comedi_board(dev);
+ struct pci230_private *devpriv = dev->private;
+ struct comedi_subdevice *s;
+ unsigned long iobase1, iobase2;
+ /* PCI230's I/O spaces 1 and 2 respectively. */
+ int irq_hdl, rc;
+ devpriv->pci_dev = pci_dev;
+ dev->board_name = thisboard->name;
+ /* Enable PCI device and reserve I/O spaces. */
+ if (comedi_pci_enable(pci_dev, "amplc_pci230") < 0) {
+ dev_err(dev->class_dev,
+ "failed to enable PCI device and request regions\n");
+ return -EIO;
}
+ /* Read base addresses of the PCI230's two I/O regions from PCI
+ * configuration register. */
+ iobase1 = pci_resource_start(pci_dev, 2);
+ iobase2 = pci_resource_start(pci_dev, 3);
+ dev_dbg(dev->class_dev,
+ "%s I/O region 1 0x%04lx I/O region 2 0x%04lx\n",
+ dev->board_name, iobase1, iobase2);
+ devpriv->iobase1 = iobase1;
+ dev->iobase = iobase2;
+ /* Read bits of DACCON register - only the output range. */
+ devpriv->daccon = inw(dev->iobase + PCI230_DACCON) & PCI230_DAC_OR_MASK;
+ /* Read hardware version register and set extended function register
+ * if they exist. */
+ if (pci_resource_len(pci_dev, 3) >= 32) {
+ unsigned short extfunc = 0;
- if (todo == 0)
- return;
-
-
- fifoamount = 0;
- for (i = 0; i < todo; i++) {
- if (fifoamount == 0) {
- /* Read FIFO state. */
- status_fifo = inw(dev->iobase + PCI230_ADCCON);
-
- if ((status_fifo & PCI230_ADC_FIFO_FULL_LATCHED) != 0) {
- /* Report error otherwise FIFO overruns will go
- * unnoticed by the caller. */
- comedi_error(dev, "AI FIFO overrun");
- events |= COMEDI_CB_OVERFLOW | COMEDI_CB_ERROR;
- break;
- } else if ((status_fifo & PCI230_ADC_FIFO_EMPTY) != 0) {
- /* FIFO empty. */
- break;
- } else if ((status_fifo & PCI230_ADC_FIFO_HALF) != 0) {
- /* FIFO half full. */
- fifoamount = PCI230_ADC_FIFOLEVEL_HALFFULL;
- } else {
- /* FIFO not empty. */
- if (devpriv->hwver > 0) {
- /* Read PCI230+/260+ ADC FIFO level. */
- fifoamount = inw(dev->iobase
- + PCI230P_ADCFFLEV);
- if (fifoamount == 0) {
- /* Shouldn't happen. */
- break;
- }
- } else {
- fifoamount = 1;
- }
- }
+ devpriv->hwver = inw(dev->iobase + PCI230P_HWVER);
+ if (devpriv->hwver < thisboard->min_hwver) {
+ dev_err(dev->class_dev,
+ "%s - bad hardware version - got %u, need %u\n",
+ dev->board_name, devpriv->hwver,
+ thisboard->min_hwver);
+ return -EIO;
}
-
- /* Read sample and store in Comedi's circular buffer. */
- if (comedi_buf_put(async, pci230_ai_read(dev)) == 0) {
- events |= COMEDI_CB_ERROR | COMEDI_CB_OVERFLOW;
- comedi_error(dev, "AI buffer overflow");
- break;
+ if (devpriv->hwver > 0) {
+ if (!thisboard->have_dio) {
+ /* No DIO ports. Route counters' external gates
+ * to the EXTTRIG signal (PCI260+ pin 17).
+ * (Otherwise, they would be routed to DIO
+ * inputs PC0, PC1 and PC2 which don't exist
+ * on PCI260[+].) */
+ extfunc |= PCI230P_EXTFUNC_GAT_EXTTRIG;
+ }
+ if ((thisboard->ao_chans > 0)
+ && (devpriv->hwver >= 2)) {
+ /* Enable DAC FIFO functionality. */
+ extfunc |= PCI230P2_EXTFUNC_DACFIFO;
+ }
}
- fifoamount--;
- devpriv->ai_scan_pos++;
- if (devpriv->ai_scan_pos == scanlen) {
- /* End of scan. */
- devpriv->ai_scan_pos = 0;
- devpriv->ai_scan_count--;
- async->events |= COMEDI_CB_EOS;
+ outw(extfunc, dev->iobase + PCI230P_EXTFUNC);
+ if ((extfunc & PCI230P2_EXTFUNC_DACFIFO) != 0) {
+ /* Temporarily enable DAC FIFO, reset it and disable
+ * FIFO wraparound. */
+ outw(devpriv->daccon | PCI230P2_DAC_FIFO_EN
+ | PCI230P2_DAC_FIFO_RESET,
+ dev->iobase + PCI230_DACCON);
+ /* Clear DAC FIFO channel enable register. */
+ outw(0, dev->iobase + PCI230P2_DACEN);
+ /* Disable DAC FIFO. */
+ outw(devpriv->daccon, dev->iobase + PCI230_DACCON);
}
}
-
- if (!devpriv->ai_continuous && (devpriv->ai_scan_count == 0)) {
- /* End of acquisition. */
- events |= COMEDI_CB_EOA;
+ /* Disable board's interrupts. */
+ outb(0, devpriv->iobase1 + PCI230_INT_SCE);
+ /* Set ADC to a reasonable state. */
+ devpriv->adcg = 0;
+ devpriv->adccon = PCI230_ADC_TRIG_NONE | PCI230_ADC_IM_SE
+ | PCI230_ADC_IR_BIP;
+ outw(1 << 0, dev->iobase + PCI230_ADCEN);
+ outw(devpriv->adcg, dev->iobase + PCI230_ADCG);
+ outw(devpriv->adccon | PCI230_ADC_FIFO_RESET,
+ dev->iobase + PCI230_ADCCON);
+ /* Register the interrupt handler. */
+ irq_hdl = request_irq(devpriv->pci_dev->irq, pci230_interrupt,
+ IRQF_SHARED, "amplc_pci230", dev);
+ if (irq_hdl < 0) {
+ dev_warn(dev->class_dev,
+ "unable to register irq %u, commands will not be available\n",
+ devpriv->pci_dev->irq);
} else {
- /* More samples required, tell Comedi to block. */
- events |= COMEDI_CB_BLOCK;
+ dev->irq = devpriv->pci_dev->irq;
+ dev_dbg(dev->class_dev, "registered irq %u\n",
+ devpriv->pci_dev->irq);
}
- async->events |= events;
- if ((async->events & (COMEDI_CB_EOA | COMEDI_CB_ERROR |
- COMEDI_CB_OVERFLOW)) != 0) {
- /* disable hardware conversions */
- pci230_ai_stop(dev, s);
- } else {
- /* update FIFO interrupt trigger level */
- pci230_ai_update_fifo_trigger_level(dev, s);
- }
-}
+ rc = comedi_alloc_subdevices(dev, 3);
+ if (rc)
+ return rc;
-static void pci230_ao_stop(struct comedi_device *dev,
- struct comedi_subdevice *s)
-{
- unsigned long irqflags;
- unsigned char intsrc;
- int started;
- struct comedi_cmd *cmd;
-
- spin_lock_irqsave(&devpriv->ao_stop_spinlock, irqflags);
- started = test_and_clear_bit(AO_CMD_STARTED, &devpriv->state);
- spin_unlock_irqrestore(&devpriv->ao_stop_spinlock, irqflags);
- if (!started)
- return;
-
-
- cmd = &s->async->cmd;
- if (cmd->scan_begin_src == TRIG_TIMER) {
- /* Stop scan rate generator. */
- pci230_cancel_ct(dev, 1);
+ s = dev->subdevices + 0;
+ /* analog input subdevice */
+ s->type = COMEDI_SUBD_AI;
+ s->subdev_flags = SDF_READABLE | SDF_DIFF | SDF_GROUND;
+ s->n_chan = thisboard->ai_chans;
+ s->maxdata = (1 << thisboard->ai_bits) - 1;
+ s->range_table = &pci230_ai_range;
+ s->insn_read = &pci230_ai_rinsn;
+ s->len_chanlist = 256; /* but there are restrictions. */
+ /* Only register commands if the interrupt handler is installed. */
+ if (irq_hdl == 0) {
+ dev->read_subdev = s;
+ s->subdev_flags |= SDF_CMD_READ;
+ s->do_cmd = &pci230_ai_cmd;
+ s->do_cmdtest = &pci230_ai_cmdtest;
+ s->cancel = pci230_ai_cancel;
}
-
- /* Determine interrupt source. */
- if (devpriv->hwver < 2) {
- /* Not using DAC FIFO. Using CT1 interrupt. */
- intsrc = PCI230_INT_ZCLK_CT1;
+ s = dev->subdevices + 1;
+ /* analog output subdevice */
+ if (thisboard->ao_chans > 0) {
+ s->type = COMEDI_SUBD_AO;
+ s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
+ s->n_chan = thisboard->ao_chans;
+ s->maxdata = (1 << thisboard->ao_bits) - 1;
+ s->range_table = &pci230_ao_range;
+ s->insn_write = &pci230_ao_winsn;
+ s->insn_read = &pci230_ao_rinsn;
+ s->len_chanlist = thisboard->ao_chans;
+ /* Only register commands if the interrupt handler is
+ * installed. */
+ if (irq_hdl == 0) {
+ dev->write_subdev = s;
+ s->subdev_flags |= SDF_CMD_WRITE;
+ s->do_cmd = &pci230_ao_cmd;
+ s->do_cmdtest = &pci230_ao_cmdtest;
+ s->cancel = pci230_ao_cancel;
+ }
} else {
- /* Using DAC FIFO interrupt. */
- intsrc = PCI230P2_INT_DAC;
- }
- /* Disable interrupt and wait for interrupt routine to finish running
- * unless we are called from the interrupt routine. */
- spin_lock_irqsave(&devpriv->isr_spinlock, irqflags);
- devpriv->int_en &= ~intsrc;
- while (devpriv->intr_running && devpriv->intr_cpuid != THISCPU) {
- spin_unlock_irqrestore(&devpriv->isr_spinlock, irqflags);
- spin_lock_irqsave(&devpriv->isr_spinlock, irqflags);
- }
- if (devpriv->ier != devpriv->int_en) {
- devpriv->ier = devpriv->int_en;
- outb(devpriv->ier, devpriv->iobase1 + PCI230_INT_SCE);
+ s->type = COMEDI_SUBD_UNUSED;
}
- spin_unlock_irqrestore(&devpriv->isr_spinlock, irqflags);
-
- if (devpriv->hwver >= 2) {
- /* Using DAC FIFO. Reset FIFO, clear underrun error,
- * disable FIFO. */
- devpriv->daccon &= PCI230_DAC_OR_MASK;
- outw(devpriv->daccon | PCI230P2_DAC_FIFO_RESET
- | PCI230P2_DAC_FIFO_UNDERRUN_CLEAR,
- dev->iobase + PCI230_DACCON);
+ s = dev->subdevices + 2;
+ /* digital i/o subdevice */
+ if (thisboard->have_dio) {
+ rc = subdev_8255_init(dev, s, NULL,
+ (devpriv->iobase1 + PCI230_PPI_X_BASE));
+ if (rc < 0)
+ return rc;
+ } else {
+ s->type = COMEDI_SUBD_UNUSED;
}
-
- /* Release resources. */
- put_all_resources(dev, OWNER_AOCMD);
+ dev_info(dev->class_dev, "attached\n");
+ return 1;
}
-static int pci230_ao_cancel(struct comedi_device *dev,
- struct comedi_subdevice *s)
+static int pci230_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
- pci230_ao_stop(dev, s);
- return 0;
+ const struct pci230_board *thisboard = comedi_board(dev);
+ struct pci_dev *pci_dev;
+ int rc;
+
+ dev_info(dev->class_dev, "amplc_pci230: attach %s %d,%d\n",
+ thisboard->name, it->options[0], it->options[1]);
+ rc = pci230_alloc_private(dev); /* sets dev->private */
+ if (rc)
+ return rc;
+ /* Find card. */
+ pci_dev = pci230_find_pci(dev, it->options[0], it->options[1]);
+ if (!pci_dev)
+ return -EIO;
+ return pci230_attach_common(dev, pci_dev);
}
-static void pci230_ai_stop(struct comedi_device *dev,
- struct comedi_subdevice *s)
+static int __devinit pci230_attach_pci(struct comedi_device *dev,
+ struct pci_dev *pci_dev)
{
- unsigned long irqflags;
- struct comedi_cmd *cmd;
- int started;
-
- spin_lock_irqsave(&devpriv->ai_stop_spinlock, irqflags);
- started = test_and_clear_bit(AI_CMD_STARTED, &devpriv->state);
- spin_unlock_irqrestore(&devpriv->ai_stop_spinlock, irqflags);
- if (!started)
- return;
-
-
- cmd = &s->async->cmd;
- if (cmd->convert_src == TRIG_TIMER) {
- /* Stop conversion rate generator. */
- pci230_cancel_ct(dev, 2);
- }
- if (cmd->scan_begin_src != TRIG_FOLLOW) {
- /* Stop scan period monostable. */
- pci230_cancel_ct(dev, 0);
- }
-
- spin_lock_irqsave(&devpriv->isr_spinlock, irqflags);
- /* Disable ADC interrupt and wait for interrupt routine to finish
- * running unless we are called from the interrupt routine. */
- devpriv->int_en &= ~PCI230_INT_ADC;
- while (devpriv->intr_running && devpriv->intr_cpuid != THISCPU) {
- spin_unlock_irqrestore(&devpriv->isr_spinlock, irqflags);
- spin_lock_irqsave(&devpriv->isr_spinlock, irqflags);
- }
- if (devpriv->ier != devpriv->int_en) {
- devpriv->ier = devpriv->int_en;
- outb(devpriv->ier, devpriv->iobase1 + PCI230_INT_SCE);
+ int rc;
+
+ dev_info(dev->class_dev, "amplc_pci230: attach pci %s\n",
+ pci_name(pci_dev));
+ rc = pci230_alloc_private(dev); /* sets dev->private */
+ if (rc)
+ return rc;
+ dev->board_ptr = pci230_find_pci_board(pci_dev);
+ if (dev->board_ptr == NULL) {
+ dev_err(dev->class_dev,
+ "amplc_pci230: BUG! cannot determine board type!\n");
+ return -EINVAL;
}
- spin_unlock_irqrestore(&devpriv->isr_spinlock, irqflags);
-
- /* Reset FIFO, disable FIFO and set start conversion source to none.
- * Keep se/diff and bip/uni settings */
- devpriv->adccon = (devpriv->adccon & (PCI230_ADC_IR_MASK
- | PCI230_ADC_IM_MASK)) |
- PCI230_ADC_TRIG_NONE;
- outw(devpriv->adccon | PCI230_ADC_FIFO_RESET,
- dev->iobase + PCI230_ADCCON);
-
- /* Release resources. */
- put_all_resources(dev, OWNER_AICMD);
+ return pci230_attach_common(dev, pci_dev);
}
-static int pci230_ai_cancel(struct comedi_device *dev,
- struct comedi_subdevice *s)
+static void pci230_detach(struct comedi_device *dev)
{
- pci230_ai_stop(dev, s);
- return 0;
+ const struct pci230_board *thisboard = comedi_board(dev);
+ struct pci230_private *devpriv = dev->private;
+
+ if (dev->subdevices && thisboard->have_dio)
+ subdev_8255_cleanup(dev, dev->subdevices + 2);
+ if (dev->irq)
+ free_irq(dev->irq, dev);
+ if (devpriv) {
+ if (devpriv->pci_dev) {
+ if (dev->iobase)
+ comedi_pci_disable(devpriv->pci_dev);
+ pci_dev_put(devpriv->pci_dev);
+ }
+ }
}
static struct comedi_driver amplc_pci230_driver = {
.driver_name = "amplc_pci230",
.module = THIS_MODULE,
.attach = pci230_attach,
+ .attach_pci = pci230_attach_pci,
.detach = pci230_detach,
.board_name = &pci230_boards[0].name,
.offset = sizeof(pci230_boards[0]),
dev->iobase = iobase;
dev->board_name = "c6xdigio";
- result = alloc_subdevices(dev, 2); /* 3 with encoder_init write */
- if (result < 0)
+ result = comedi_alloc_subdevices(dev, 2);
+ if (result)
return result;
/* Make sure that PnP ports get activated */
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ PCMCIA support code for this driver is adapted from the dummy_cs.c
+ driver of the Linux PCMCIA Card Services package.
+
+ The initial developer of the original code is David A. Hinds
+ <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
+ are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
+
*/
/*
Driver: cb_das16_cs
#include <linux/slab.h>
#include "../comedidev.h"
#include <linux/delay.h>
-#include <linux/pci.h>
#include <pcmcia/cistpl.h>
#include <pcmcia/ds.h>
int device_id;
int n_ao_chans;
};
+
static const struct das16cs_board das16cs_boards[] = {
{
- .device_id = 0x0000, /* unknown */
- .name = "PC-CARD DAS16/16",
- .n_ao_chans = 0,
- },
- {
- .device_id = 0x0039,
- .name = "PC-CARD DAS16/16-AO",
- .n_ao_chans = 2,
- },
- {
- .device_id = 0x4009,
- .name = "PCM-DAS16s/16",
- .n_ao_chans = 0,
- },
+ .name = "PC-CARD DAS16/16-AO",
+ .device_id = 0x0039,
+ .n_ao_chans = 2,
+ }, {
+ .name = "PCM-DAS16s/16",
+ .device_id = 0x4009,
+ .n_ao_chans = 0,
+ }, {
+ .name = "PC-CARD DAS16/16",
+ .device_id = 0x0000, /* unknown */
+ .n_ao_chans = 0,
+ },
};
-#define n_boards ARRAY_SIZE(das16cs_boards)
-#define thisboard ((const struct das16cs_board *)dev->board_ptr)
-
struct das16cs_private {
- struct pcmcia_device *link;
-
unsigned int ao_readback[2];
unsigned short status1;
unsigned short status2;
};
-#define devpriv ((struct das16cs_private *)dev->private)
-
-static int das16cs_attach(struct comedi_device *dev,
- struct comedi_devconfig *it);
-static void das16cs_detach(struct comedi_device *dev);
-static struct comedi_driver driver_das16cs = {
- .driver_name = "cb_das16_cs",
- .module = THIS_MODULE,
- .attach = das16cs_attach,
- .detach = das16cs_detach,
-};
static struct pcmcia_device *cur_dev;
-static const struct comedi_lrange das16cs_ai_range = { 4, {
- RANGE(-10, 10),
- RANGE(-5, 5),
- RANGE(-2.5, 2.5),
- RANGE(-1.25, 1.25),
- }
-};
-
-static irqreturn_t das16cs_interrupt(int irq, void *d);
-static int das16cs_ai_rinsn(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das16cs_ai_cmd(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static int das16cs_ai_cmdtest(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_cmd *cmd);
-static int das16cs_ao_winsn(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das16cs_ao_rinsn(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das16cs_dio_insn_bits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das16cs_dio_insn_config(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn,
- unsigned int *data);
-static int das16cs_timer_insn_read(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn,
- unsigned int *data);
-static int das16cs_timer_insn_config(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn,
- unsigned int *data);
-
-static const struct das16cs_board *das16cs_probe(struct comedi_device *dev,
- struct pcmcia_device *link)
-{
- int i;
-
- for (i = 0; i < n_boards; i++) {
- if (das16cs_boards[i].device_id == link->card_id)
- return das16cs_boards + i;
- }
-
- dev_dbg(dev->hw_dev, "unknown board!\n");
-
- return NULL;
-}
-
-static int das16cs_attach(struct comedi_device *dev,
- struct comedi_devconfig *it)
-{
- struct pcmcia_device *link;
- struct comedi_subdevice *s;
- int ret;
- int i;
-
- dev_dbg(dev->hw_dev, "comedi%d: cb_das16_cs: attached\n", dev->minor);
-
- link = cur_dev; /* XXX hack */
- if (!link)
- return -EIO;
-
- dev->iobase = link->resource[0]->start;
- dev_dbg(dev->hw_dev, "I/O base=0x%04lx\n", dev->iobase);
-
- dev_dbg(dev->hw_dev, "fingerprint:\n");
- for (i = 0; i < 48; i += 2)
- dev_dbg(dev->hw_dev, "%04x\n", inw(dev->iobase + i));
-
-
- ret = request_irq(link->irq, das16cs_interrupt,
- IRQF_SHARED, "cb_das16_cs", dev);
- if (ret < 0)
- return ret;
-
- dev->irq = link->irq;
-
- dev_dbg(dev->hw_dev, "irq=%u\n", dev->irq);
-
- dev->board_ptr = das16cs_probe(dev, link);
- if (!dev->board_ptr)
- return -EIO;
-
- dev->board_name = thisboard->name;
-
- if (alloc_private(dev, sizeof(struct das16cs_private)) < 0)
- return -ENOMEM;
-
- if (alloc_subdevices(dev, 4) < 0)
- return -ENOMEM;
-
- s = dev->subdevices + 0;
- dev->read_subdev = s;
- /* analog input subdevice */
- s->type = COMEDI_SUBD_AI;
- s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ;
- s->n_chan = 16;
- s->maxdata = 0xffff;
- s->range_table = &das16cs_ai_range;
- s->len_chanlist = 16;
- s->insn_read = das16cs_ai_rinsn;
- s->do_cmd = das16cs_ai_cmd;
- s->do_cmdtest = das16cs_ai_cmdtest;
-
- s = dev->subdevices + 1;
- /* analog output subdevice */
- if (thisboard->n_ao_chans) {
- s->type = COMEDI_SUBD_AO;
- s->subdev_flags = SDF_WRITABLE;
- s->n_chan = thisboard->n_ao_chans;
- s->maxdata = 0xffff;
- s->range_table = &range_bipolar10;
- s->insn_write = &das16cs_ao_winsn;
- s->insn_read = &das16cs_ao_rinsn;
- }
-
- s = dev->subdevices + 2;
- /* digital i/o subdevice */
- if (1) {
- s->type = COMEDI_SUBD_DIO;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = 8;
- s->maxdata = 1;
- s->range_table = &range_digital;
- s->insn_bits = das16cs_dio_insn_bits;
- s->insn_config = das16cs_dio_insn_config;
- } else {
- s->type = COMEDI_SUBD_UNUSED;
- }
-
- s = dev->subdevices + 3;
- /* timer subdevice */
- if (0) {
- s->type = COMEDI_SUBD_TIMER;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = 1;
- s->maxdata = 0xff;
- s->range_table = &range_unknown;
- s->insn_read = das16cs_timer_insn_read;
- s->insn_config = das16cs_timer_insn_config;
- } else {
- s->type = COMEDI_SUBD_UNUSED;
+static const struct comedi_lrange das16cs_ai_range = {
+ 4, {
+ BIP_RANGE(10),
+ BIP_RANGE(5),
+ BIP_RANGE(2.5),
+ BIP_RANGE(1.25),
}
-
-
- return 1;
-}
-
-static void das16cs_detach(struct comedi_device *dev)
-{
- if (dev->irq)
- free_irq(dev->irq, dev);
-}
+};
static irqreturn_t das16cs_interrupt(int irq, void *d)
{
return IRQ_HANDLED;
}
-/*
- * "instructions" read/write data in "one-shot" or "software-triggered"
- * mode.
- */
static int das16cs_ai_rinsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ struct das16cs_private *devpriv = dev->private;
+ int chan = CR_CHAN(insn->chanspec);
+ int range = CR_RANGE(insn->chanspec);
+ int aref = CR_AREF(insn->chanspec);
int i;
int to;
- int aref;
- int range;
- int chan;
- static int range_bits[] = { 0x800, 0x000, 0x100, 0x200 };
- chan = CR_CHAN(insn->chanspec);
- aref = CR_AREF(insn->chanspec);
- range = CR_RANGE(insn->chanspec);
-
- outw(chan, dev->iobase + 2);
+ outw(chan, dev->iobase + DAS16CS_DIO_MUX);
devpriv->status1 &= ~0xf320;
devpriv->status1 |= (aref == AREF_DIFF) ? 0 : 0x0020;
- outw(devpriv->status1, dev->iobase + 4);
+ outw(devpriv->status1, dev->iobase + DAS16CS_MISC1);
devpriv->status2 &= ~0xff00;
- devpriv->status2 |= range_bits[range];
- outw(devpriv->status2, dev->iobase + 6);
+ switch (range) {
+ case 0:
+ devpriv->status2 |= 0x800;
+ break;
+ case 1:
+ devpriv->status2 |= 0x000;
+ break;
+ case 2:
+ devpriv->status2 |= 0x100;
+ break;
+ case 3:
+ devpriv->status2 |= 0x200;
+ break;
+ }
+ outw(devpriv->status2, dev->iobase + DAS16CS_MISC2);
for (i = 0; i < insn->n; i++) {
- outw(0, dev->iobase);
+ outw(0, dev->iobase + DAS16CS_ADC_DATA);
#define TIMEOUT 1000
for (to = 0; to < TIMEOUT; to++) {
- if (inw(dev->iobase + 4) & 0x0080)
+ if (inw(dev->iobase + DAS16CS_MISC1) & 0x0080)
break;
}
if (to == TIMEOUT) {
- dev_dbg(dev->hw_dev, "cb_das16_cs: ai timeout\n");
+ dev_dbg(dev->class_dev, "cb_das16_cs: ai timeout\n");
return -ETIME;
}
- data[i] = (unsigned short)inw(dev->iobase + 0);
+ data[i] = inw(dev->iobase + DAS16CS_ADC_DATA);
}
return i;
int err = 0;
int tmp;
- /* cmdtest tests a particular command to see if it is valid.
- * Using the cmdtest ioctl, a user can create a valid cmd
- * and then have it executes by the cmd ioctl.
- *
- * cmdtest returns 1,2,3,4 or 0, depending on which tests
- * the command passes. */
-
/* step 1: make sure trigger sources are trivially valid */
tmp = cmd->start_src;
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ struct das16cs_private *devpriv = dev->private;
int i;
int chan = CR_CHAN(insn->chanspec);
unsigned short status1;
devpriv->ao_readback[chan] = data[i];
d = data[i];
- outw(devpriv->status1, dev->iobase + 4);
+ outw(devpriv->status1, dev->iobase + DAS16CS_MISC1);
udelay(1);
status1 = devpriv->status1 & ~0xf;
else
status1 |= 0x0008;
-/* printk("0x%04x\n",status1);*/
- outw(status1, dev->iobase + 4);
+ outw(status1, dev->iobase + DAS16CS_MISC1);
udelay(1);
for (bit = 15; bit >= 0; bit--) {
int b = (d >> bit) & 0x1;
b <<= 1;
-/* printk("0x%04x\n",status1 | b | 0x0000);*/
- outw(status1 | b | 0x0000, dev->iobase + 4);
+ outw(status1 | b | 0x0000, dev->iobase + DAS16CS_MISC1);
udelay(1);
-/* printk("0x%04x\n",status1 | b | 0x0004);*/
- outw(status1 | b | 0x0004, dev->iobase + 4);
+ outw(status1 | b | 0x0004, dev->iobase + DAS16CS_MISC1);
udelay(1);
}
-/* make high both DAC0CS and DAC1CS to load
- new data and update analog output*/
- outw(status1 | 0x9, dev->iobase + 4);
+ /*
+ * Make both DAC0CS and DAC1CS high to load
+ * the new data and update analog the output
+ */
+ outw(status1 | 0x9, dev->iobase + DAS16CS_MISC1);
}
return i;
}
-/* AO subdevices should have a read insn as well as a write insn.
- * Usually this means copying a value stored in devpriv. */
static int das16cs_ao_rinsn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ struct das16cs_private *devpriv = dev->private;
int i;
int chan = CR_CHAN(insn->chanspec);
return i;
}
-/* DIO devices are slightly special. Although it is possible to
- * implement the insn_read/insn_write interface, it is much more
- * useful to applications if you implement the insn_bits interface.
- * This allows packed reading/writing of the DIO channels. The
- * comedi core can convert between insn_bits and insn_read/write */
static int das16cs_dio_insn_bits(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= data[0] & data[1];
- outw(s->state, dev->iobase + 16);
+ outw(s->state, dev->iobase + DAS16CS_DIO);
}
- /* on return, data[1] contains the value of the digital
- * input and output lines. */
- data[1] = inw(dev->iobase + 16);
+ data[1] = inw(dev->iobase + DAS16CS_DIO);
- return 2;
+ return insn->n;
}
static int das16cs_dio_insn_config(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ struct das16cs_private *devpriv = dev->private;
int chan = CR_CHAN(insn->chanspec);
int bits;
devpriv->status2 |= (s->io_bits & 0xf0) ? 0x0080 : 0;
devpriv->status2 |= (s->io_bits & 0x0f) ? 0x0040 : 0;
- outw(devpriv->status2, dev->iobase + 6);
+ outw(devpriv->status2, dev->iobase + DAS16CS_MISC2);
return insn->n;
}
-static int das16cs_timer_insn_read(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data)
-{
- return -EINVAL;
-}
-
-static int das16cs_timer_insn_config(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn,
- unsigned int *data)
+static const struct das16cs_board *das16cs_probe(struct comedi_device *dev,
+ struct pcmcia_device *link)
{
- return -EINVAL;
-}
-
-/* PCMCIA stuff */
-
-/*======================================================================
-
- The following pcmcia code for the pcm-das08 is adapted from the
- dummy_cs.c driver of the Linux PCMCIA Card Services package.
-
- The initial developer of the original code is David A. Hinds
- <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
- are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
-
-======================================================================*/
-
-#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
-
-static void das16cs_pcmcia_config(struct pcmcia_device *link);
-static void das16cs_pcmcia_release(struct pcmcia_device *link);
-static int das16cs_pcmcia_suspend(struct pcmcia_device *p_dev);
-static int das16cs_pcmcia_resume(struct pcmcia_device *p_dev);
+ int i;
-/*
- The attach() and detach() entry points are used to create and destroy
- "instances" of the driver, where each instance represents everything
- needed to manage one actual PCMCIA card.
-*/
+ for (i = 0; i < ARRAY_SIZE(das16cs_boards); i++) {
+ if (das16cs_boards[i].device_id == link->card_id)
+ return das16cs_boards + i;
+ }
-static int das16cs_pcmcia_attach(struct pcmcia_device *);
-static void das16cs_pcmcia_detach(struct pcmcia_device *);
+ dev_dbg(dev->class_dev, "unknown board!\n");
-/*
- You'll also need to prototype all the functions that will actually
- be used to talk to your device. See 'memory_cs' for a good example
- of a fully self-sufficient driver; the other drivers rely more or
- less on other parts of the kernel.
-*/
+ return NULL;
+}
-struct local_info_t {
+static int das16cs_attach(struct comedi_device *dev,
+ struct comedi_devconfig *it)
+{
+ const struct das16cs_board *thisboard;
struct pcmcia_device *link;
- int stop;
- struct bus_operations *bus;
-};
-
-/*======================================================================
+ struct comedi_subdevice *s;
+ int ret;
- das16cs_pcmcia_attach() creates an "instance" of the driver, allocating
- local data structures for one device. The device is registered
- with Card Services.
+ link = cur_dev; /* XXX hack */
+ if (!link)
+ return -EIO;
- The dev_link structure is initialized, but we don't actually
- configure the card at this point -- we wait until we receive a
- card insertion event.
+ dev->board_ptr = das16cs_probe(dev, link);
+ if (!dev->board_ptr)
+ return -EIO;
+ thisboard = comedi_board(dev);
-======================================================================*/
+ dev->board_name = thisboard->name;
-static int das16cs_pcmcia_attach(struct pcmcia_device *link)
-{
- struct local_info_t *local;
+ dev->iobase = link->resource[0]->start;
- dev_dbg(&link->dev, "das16cs_pcmcia_attach()\n");
+ ret = request_irq(link->irq, das16cs_interrupt,
+ IRQF_SHARED, "cb_das16_cs", dev);
+ if (ret < 0)
+ return ret;
+ dev->irq = link->irq;
- /* Allocate space for private device-specific data */
- local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
- if (!local)
+ if (alloc_private(dev, sizeof(struct das16cs_private)) < 0)
return -ENOMEM;
- local->link = link;
- link->priv = local;
- cur_dev = link;
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
+ return ret;
- das16cs_pcmcia_config(link);
+ s = dev->subdevices + 0;
+ dev->read_subdev = s;
+ /* analog input subdevice */
+ s->type = COMEDI_SUBD_AI;
+ s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ;
+ s->n_chan = 16;
+ s->maxdata = 0xffff;
+ s->range_table = &das16cs_ai_range;
+ s->len_chanlist = 16;
+ s->insn_read = das16cs_ai_rinsn;
+ s->do_cmd = das16cs_ai_cmd;
+ s->do_cmdtest = das16cs_ai_cmdtest;
+
+ s = dev->subdevices + 1;
+ /* analog output subdevice */
+ if (thisboard->n_ao_chans) {
+ s->type = COMEDI_SUBD_AO;
+ s->subdev_flags = SDF_WRITABLE;
+ s->n_chan = thisboard->n_ao_chans;
+ s->maxdata = 0xffff;
+ s->range_table = &range_bipolar10;
+ s->insn_write = &das16cs_ao_winsn;
+ s->insn_read = &das16cs_ao_rinsn;
+ } else {
+ s->type = COMEDI_SUBD_UNUSED;
+ }
+
+ s = dev->subdevices + 2;
+ /* digital i/o subdevice */
+ s->type = COMEDI_SUBD_DIO;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ s->n_chan = 8;
+ s->maxdata = 1;
+ s->range_table = &range_digital;
+ s->insn_bits = das16cs_dio_insn_bits;
+ s->insn_config = das16cs_dio_insn_config;
+
+ dev_info(dev->class_dev, "%s: %s, I/O base=0x%04lx, irq=%u\n",
+ dev->driver->driver_name, dev->board_name,
+ dev->iobase, dev->irq);
return 0;
-} /* das16cs_pcmcia_attach */
+}
-static void das16cs_pcmcia_detach(struct pcmcia_device *link)
+static void das16cs_detach(struct comedi_device *dev)
{
- dev_dbg(&link->dev, "das16cs_pcmcia_detach\n");
-
- ((struct local_info_t *)link->priv)->stop = 1;
- das16cs_pcmcia_release(link);
- /* This points to the parent struct local_info_t struct */
- kfree(link->priv);
-} /* das16cs_pcmcia_detach */
+ if (dev->irq)
+ free_irq(dev->irq, dev);
+}
+static struct comedi_driver driver_das16cs = {
+ .driver_name = "cb_das16_cs",
+ .module = THIS_MODULE,
+ .attach = das16cs_attach,
+ .detach = das16cs_detach,
+};
static int das16cs_pcmcia_config_loop(struct pcmcia_device *p_dev,
void *priv_data)
return pcmcia_request_io(p_dev);
}
-static void das16cs_pcmcia_config(struct pcmcia_device *link)
+static int das16cs_pcmcia_attach(struct pcmcia_device *link)
{
int ret;
- dev_dbg(&link->dev, "das16cs_pcmcia_config\n");
-
/* Do we need to allocate an interrupt? */
link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
ret = pcmcia_loop_config(link, das16cs_pcmcia_config_loop, NULL);
- if (ret) {
- dev_warn(&link->dev, "no configuration found\n");
+ if (ret)
goto failed;
- }
if (!link->irq)
goto failed;
if (ret)
goto failed;
- return;
+ cur_dev = link;
+ return 0;
failed:
- das16cs_pcmcia_release(link);
-} /* das16cs_pcmcia_config */
-
-static void das16cs_pcmcia_release(struct pcmcia_device *link)
-{
- dev_dbg(&link->dev, "das16cs_pcmcia_release\n");
pcmcia_disable_device(link);
-} /* das16cs_pcmcia_release */
-
-static int das16cs_pcmcia_suspend(struct pcmcia_device *link)
-{
- struct local_info_t *local = link->priv;
-
- /* Mark the device as stopped, to block IO until later */
- local->stop = 1;
-
- return 0;
-} /* das16cs_pcmcia_suspend */
+ return ret;
+}
-static int das16cs_pcmcia_resume(struct pcmcia_device *link)
+static void das16cs_pcmcia_detach(struct pcmcia_device *link)
{
- struct local_info_t *local = link->priv;
-
- local->stop = 0;
- return 0;
-} /* das16cs_pcmcia_resume */
-
-/*====================================================================*/
+ pcmcia_disable_device(link);
+ cur_dev = NULL;
+}
static const struct pcmcia_device_id das16cs_id_table[] = {
PCMCIA_DEVICE_MANF_CARD(0x01c5, 0x0039),
PCMCIA_DEVICE_MANF_CARD(0x01c5, 0x4009),
PCMCIA_DEVICE_NULL
};
-
MODULE_DEVICE_TABLE(pcmcia, das16cs_id_table);
-MODULE_AUTHOR("David A. Schleef <ds@schleef.org>");
-MODULE_DESCRIPTION("Comedi driver for Computer Boards PC-CARD DAS16/16");
-MODULE_LICENSE("GPL");
-struct pcmcia_driver das16cs_driver = {
- .probe = das16cs_pcmcia_attach,
- .remove = das16cs_pcmcia_detach,
- .suspend = das16cs_pcmcia_suspend,
- .resume = das16cs_pcmcia_resume,
- .id_table = das16cs_id_table,
- .owner = THIS_MODULE,
- .name = "cb_das16_cs",
+static struct pcmcia_driver das16cs_driver = {
+ .name = "cb_das16_cs",
+ .owner = THIS_MODULE,
+ .probe = das16cs_pcmcia_attach,
+ .remove = das16cs_pcmcia_detach,
+ .id_table = das16cs_id_table,
};
-static int __init init_das16cs_pcmcia_cs(void)
-{
- pcmcia_register_driver(&das16cs_driver);
- return 0;
-}
-
-static void __exit exit_das16cs_pcmcia_cs(void)
-{
- pr_debug("das16cs_pcmcia_cs: unloading\n");
- pcmcia_unregister_driver(&das16cs_driver);
-}
-
-int __init init_module(void)
+static int __init das16cs_init(void)
{
int ret;
- ret = init_das16cs_pcmcia_cs();
+ ret = comedi_driver_register(&driver_das16cs);
if (ret < 0)
return ret;
- return comedi_driver_register(&driver_das16cs);
-}
-
-void __exit cleanup_module(void)
-{
- exit_das16cs_pcmcia_cs();
- comedi_driver_unregister(&driver_das16cs);
-}
+ ret = pcmcia_register_driver(&das16cs_driver);
+ if (ret < 0) {
+ comedi_driver_unregister(&driver_das16cs);
+ return ret;
+ }
-#else
-static int __init driver_das16cs_init_module(void)
-{
- return comedi_driver_register(&driver_das16cs);
+ return 0;
}
+module_init(das16cs_init);
-static void __exit driver_das16cs_cleanup_module(void)
+static void __exit das16cs_exit(void)
{
+ pcmcia_unregister_driver(&das16cs_driver);
comedi_driver_unregister(&driver_das16cs);
}
+module_exit(das16cs_exit);
-module_init(driver_das16cs_init_module);
-module_exit(driver_das16cs_cleanup_module);
-#endif /* CONFIG_PCMCIA */
+MODULE_AUTHOR("David A. Schleef <ds@schleef.org>");
+MODULE_DESCRIPTION("Comedi driver for Computer Boards PC-CARD DAS16/16");
+MODULE_LICENSE("GPL");
AI Triggering:
For start_src == TRIG_EXT, the A/D EXTERNAL TRIGGER IN (pin 45) is used.
For 1602 series, the start_arg is interpreted as follows:
- start_arg == 0 => gated triger (level high)
- start_arg == CR_INVERT => gated triger (level low)
+ start_arg == 0 => gated trigger (level high)
+ start_arg == CR_INVERT => gated trigger (level low)
start_arg == CR_EDGE => Rising edge
start_arg == CR_EDGE | CR_INVERT => Falling edge
For the other boards the trigger will be done on rising edge
#include "8253.h"
#include "8255.h"
#include "amcc_s5933.h"
-#include "comedi_pci.h"
#include "comedi_fc.h"
#undef CB_PCIDAS_DEBUG /* disable debugging code */
struct pci_dev *pcidev = NULL;
int index;
int i;
+ int ret;
/*
* Allocate the private structure area.
}
}
- dev_err(dev->hw_dev, "No supported ComputerBoards/MeasurementComputing card found on requested position\n");
+ dev_err(dev->class_dev,
+ "No supported ComputerBoards/MeasurementComputing card found on requested position\n");
return -EIO;
found:
- dev_dbg(dev->hw_dev, "Found %s on bus %i, slot %i\n",
+ dev_dbg(dev->class_dev, "Found %s on bus %i, slot %i\n",
cb_pcidas_boards[index].name, pcidev->bus->number,
PCI_SLOT(pcidev->devfn));
* Enable PCI device and reserve I/O ports.
*/
if (comedi_pci_enable(pcidev, "cb_pcidas")) {
- dev_err(dev->hw_dev, "Failed to enable PCI device and request regions\n");
+ dev_err(dev->class_dev,
+ "Failed to enable PCI device and request regions\n");
return -EIO;
}
/*
/* get irq */
if (request_irq(devpriv->pci_dev->irq, cb_pcidas_interrupt,
IRQF_SHARED, "cb_pcidas", dev)) {
- dev_dbg(dev->hw_dev, "unable to allocate irq %d\n",
+ dev_dbg(dev->class_dev, "unable to allocate irq %d\n",
devpriv->pci_dev->irq);
return -EINVAL;
}
/* Initialize dev->board_name */
dev->board_name = thisboard->name;
-/*
- * Allocate the subdevice structures.
- */
- if (alloc_subdevices(dev, 7) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 7);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* analog input subdevice */
unsigned int source = data[1];
if (source >= num_calibration_sources) {
- dev_err(dev->hw_dev, "invalid calibration source: %i\n",
+ dev_err(dev->class_dev, "invalid calibration source: %i\n",
source);
return -EINVAL;
}
outw(bits, devpriv->control_status + ADCMUX_CONT);
#ifdef CB_PCIDAS_DEBUG
- dev_dbg(dev->hw_dev, "comedi: sent 0x%x to adcmux control\n", bits);
+ dev_dbg(dev->class_dev, "sent 0x%x to adcmux control\n", bits);
#endif
/* load counters */
devpriv->adc_fifo_bits |= INT_FHF; /* interrupt fifo half full */
}
#ifdef CB_PCIDAS_DEBUG
- dev_dbg(dev->hw_dev, "comedi: adc_fifo_bits are 0x%x\n",
+ dev_dbg(dev->class_dev, "adc_fifo_bits are 0x%x\n",
devpriv->adc_fifo_bits);
#endif
/* enable (and clear) interrupts */
bits |= BURSTE;
outw(bits, devpriv->control_status + TRIG_CONTSTAT);
#ifdef CB_PCIDAS_DEBUG
- dev_dbg(dev->hw_dev, "comedi: sent 0x%x to trig control\n", bits);
+ dev_dbg(dev->class_dev, "sent 0x%x to trig control\n", bits);
#endif
return 0;
spin_lock_irqsave(&dev->spinlock, flags);
devpriv->adc_fifo_bits |= DAEMIE | DAHFIE;
#ifdef CB_PCIDAS_DEBUG
- dev_dbg(dev->hw_dev, "comedi: adc_fifo_bits are 0x%x\n",
+ dev_dbg(dev->class_dev, "adc_fifo_bits are 0x%x\n",
devpriv->adc_fifo_bits);
#endif
/* enable and clear interrupts */
devpriv->ao_control_bits |= DAC_START | DACEN | DAC_EMPTY;
outw(devpriv->ao_control_bits, devpriv->control_status + DAC_CSR);
#ifdef CB_PCIDAS_DEBUG
- dev_dbg(dev->hw_dev, "comedi: sent 0x%x to dac control\n",
+ dev_dbg(dev->class_dev, "sent 0x%x to dac control\n",
devpriv->ao_control_bits);
#endif
spin_unlock_irqrestore(&dev->spinlock, flags);
s5933_status = inl(devpriv->s5933_config + AMCC_OP_REG_INTCSR);
#ifdef CB_PCIDAS_DEBUG
- dev_dbg(dev->hw_dev, "intcsr 0x%x\n", s5933_status);
- dev_dbg(dev->hw_dev, "mbef 0x%x\n",
+ dev_dbg(dev->class_dev, "intcsr 0x%x\n", s5933_status);
+ dev_dbg(dev->class_dev, "mbef 0x%x\n",
inl(devpriv->s5933_config + AMCC_OP_REG_MBEF));
#endif
#include <linux/delay.h>
#include <linux/interrupt.h>
-#include "comedi_pci.h"
#include "8253.h"
#include "8255.h"
#include "plx9080.h"
static void check_adc_timing(struct comedi_device *dev, struct comedi_cmd *cmd);
static unsigned int get_divisor(unsigned int ns, unsigned int flags);
static void i2c_write(struct comedi_device *dev, unsigned int address,
- const uint8_t * data, unsigned int length);
+ const uint8_t *data, unsigned int length);
static void caldac_write(struct comedi_device *dev, unsigned int channel,
unsigned int value);
static int caldac_8800_write(struct comedi_device *dev, unsigned int address,
}
static void set_dac_range_bits(struct comedi_device *dev,
- volatile uint16_t * bits, unsigned int channel,
+ volatile uint16_t *bits, unsigned int channel,
unsigned int range)
{
unsigned int code = board(dev)->ao_range_code[range];
struct comedi_subdevice *s;
void __iomem *dio_8255_iobase;
int i;
+ int ret;
- if (alloc_subdevices(dev, 10) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 10);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* analog input subdevice */
return -EIO;
}
- dev_dbg(dev->hw_dev, "Found %s on bus %i, slot %i\n", board(dev)->name,
- pcidev->bus->number, PCI_SLOT(pcidev->devfn));
+ dev_dbg(dev->class_dev, "Found %s on bus %i, slot %i\n",
+ board(dev)->name, pcidev->bus->number, PCI_SLOT(pcidev->devfn));
if (comedi_pci_enable(pcidev, dev->driver->driver_name)) {
- dev_warn(dev->hw_dev, "failed to enable PCI device and request regions\n");
+ dev_warn(dev->class_dev,
+ "failed to enable PCI device and request regions\n");
return -EIO;
}
pci_set_master(pcidev);
if (!priv(dev)->plx9080_iobase || !priv(dev)->main_iobase
|| !priv(dev)->dio_counter_iobase) {
- dev_warn(dev->hw_dev, "failed to remap io memory\n");
+ dev_warn(dev->class_dev, "failed to remap io memory\n");
return -ENOMEM;
}
priv(dev)->hw_revision =
hw_revision(dev, readw(priv(dev)->main_iobase + HW_STATUS_REG));
- dev_dbg(dev->hw_dev, "stc hardware revision %i\n",
+ dev_dbg(dev->class_dev, "stc hardware revision %i\n",
priv(dev)->hw_revision);
init_plx9080(dev);
init_stc_registers(dev);
/* get irq */
if (request_irq(pcidev->irq, handle_interrupt, IRQF_SHARED,
"cb_pcidas64", dev)) {
- dev_dbg(dev->hw_dev, "unable to allocate irq %u\n",
+ dev_dbg(dev->class_dev, "unable to allocate irq %u\n",
pcidev->irq);
return -EINVAL;
}
dev->irq = pcidev->irq;
- dev_dbg(dev->hw_dev, "irq %u\n", dev->irq);
+ dev_dbg(dev->class_dev, "irq %u\n", dev->irq);
retval = setup_subdevices(dev);
if (retval < 0)
else
num_calibration_sources = 8;
if (source >= num_calibration_sources) {
- dev_dbg(dev->hw_dev, "invalid calibration source: %i\n",
+ dev_dbg(dev->class_dev, "invalid calibration source: %i\n",
source);
return -EINVAL;
}
}
if (num_samples < 0) {
- dev_err(dev->hw_dev, "cb_pcidas64: bug! num_samples < 0\n");
+ dev_err(dev->class_dev,
+ "cb_pcidas64: bug! num_samples < 0\n");
break;
}
data[1] = bits;
data[0] = 0;
- return 2;
+ return insn->n;
}
static int do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
data[1] = s->state;
- return 2;
+ return insn->n;
}
static int dio_60xx_config_insn(struct comedi_device *dev,
data[1] = readb(priv(dev)->dio_counter_iobase + DIO_DATA_60XX_REG);
- return 2;
+ return insn->n;
}
static void caldac_write(struct comedi_device *dev, unsigned int channel,
}
static void i2c_write(struct comedi_device *dev, unsigned int address,
- const uint8_t * data, unsigned int length)
+ const uint8_t *data, unsigned int length)
{
unsigned int i;
uint8_t bitstream;
#include "../comedidev.h"
-#include "comedi_pci.h"
#include "8255.h"
-
/* PCI vendor number of ComputerBoards */
#define PCI_VENDOR_ID_CB 0x1307
#define EEPROM_SIZE 128 /* number of entries in eeprom */
struct comedi_subdevice *s;
struct pci_dev *pcidev = NULL;
int index;
-
+ int ret;
/*
* Allocate the private structure area.
}
}
if (!pcidev) {
- dev_err(dev->hw_dev, "Not a ComputerBoards/MeasurementComputing card on requested position\n");
+ dev_err(dev->class_dev,
+ "Not a ComputerBoards/MeasurementComputing card on requested position\n");
return -EIO;
}
found:
devpriv->pci_dev = pcidev;
dev->board_ptr = cb_pcidda_boards + index;
/* "thisboard" macro can be used from here. */
- dev_dbg(dev->hw_dev, "Found %s at requested position\n",
+ dev_dbg(dev->class_dev, "Found %s at requested position\n",
thisboard->name);
/*
* Enable PCI device and request regions.
*/
if (comedi_pci_enable(pcidev, thisboard->name)) {
- dev_err(dev->hw_dev, "cb_pcidda: failed to enable PCI device and request regions\n");
+ dev_err(dev->class_dev,
+ "cb_pcidda: failed to enable PCI device and request regions\n");
return -EIO;
}
*/
dev->board_name = thisboard->name;
-/*
- * Allocate the subdevice structures.
- */
- if (alloc_subdevices(dev, 3) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* analog output subdevice */
s = dev->subdevices + 2;
subdev_8255_init(dev, s, NULL, devpriv->digitalio + PORT2A);
- dev_dbg(dev->hw_dev, "eeprom:\n");
+ dev_dbg(dev->class_dev, "eeprom:\n");
for (index = 0; index < EEPROM_SIZE; index++) {
devpriv->eeprom_data[index] = cb_pcidda_read_eeprom(dev, index);
- dev_dbg(dev->hw_dev, "%i:0x%x\n", index,
+ dev_dbg(dev->class_dev, "%i:0x%x\n", index,
devpriv->eeprom_data[index]);
}
/*------------------------------ HEADER FILES ---------------------------------*/
#include "../comedidev.h"
-#include "comedi_pci.h"
#include "8255.h"
/*-------------------------- MACROS and DATATYPES -----------------------------*/
struct pci_dev *pcidev = NULL;
int index;
int i;
+ int ret;
/*
* Allocate the private structure area. alloc_private() is a
}
}
- dev_err(dev->hw_dev, "No supported ComputerBoards/MeasurementComputing card found on requested position\n");
+ dev_err(dev->class_dev,
+ "No supported ComputerBoards/MeasurementComputing card found on requested position\n");
return -EIO;
found:
dev->board_name = thisboard->name;
devpriv->pci_dev = pcidev;
- dev_dbg(dev->hw_dev, "Found %s on bus %i, slot %i\n", thisboard->name,
- devpriv->pci_dev->bus->number,
+ dev_dbg(dev->class_dev, "Found %s on bus %i, slot %i\n",
+ thisboard->name, devpriv->pci_dev->bus->number,
PCI_SLOT(devpriv->pci_dev->devfn));
if (comedi_pci_enable(pcidev, thisboard->name))
return -EIO;
pci_resource_start(devpriv->pci_dev,
pcidio_boards[index].dioregs_badrindex);
-/*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- if (alloc_subdevices(dev, thisboard->n_8255) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, thisboard->n_8255);
+ if (ret)
+ return ret;
for (i = 0; i < thisboard->n_8255; i++) {
subdev_8255_init(dev, dev->subdevices + i,
NULL, devpriv->dio_reg_base + i * 4);
- dev_dbg(dev->hw_dev, "subdev %d: base = 0x%lx\n", i,
+ dev_dbg(dev->class_dev, "subdev %d: base = 0x%lx\n", i,
devpriv->dio_reg_base + i * 4);
}
#include <linux/delay.h>
#include <linux/interrupt.h>
-#include "comedi_pci.h"
#include "plx9052.h"
#include "8255.h"
struct comedi_subdevice *s;
struct pci_dev *pcidev = NULL;
int index;
+ int ret;
/* int i; */
/*
}
}
- dev_err(dev->hw_dev, "No supported ComputerBoards/MeasurementComputing card found on requested position\n");
+ dev_err(dev->class_dev,
+ "No supported ComputerBoards/MeasurementComputing card found on requested position\n");
return -EIO;
found:
- dev_dbg(dev->hw_dev, "Found %s on bus %i, slot %i\n",
+ dev_dbg(dev->class_dev, "Found %s on bus %i, slot %i\n",
cb_pcimdas_boards[index].name, pcidev->bus->number,
PCI_SLOT(pcidev->devfn));
case 0x56:
break;
default:
- dev_dbg(dev->hw_dev, "THIS CARD IS UNSUPPORTED.\n"
+ dev_dbg(dev->class_dev, "THIS CARD IS UNSUPPORTED.\n");
+ dev_dbg(dev->class_dev,
"PLEASE REPORT USAGE TO <mocelet@sucs.org>\n");
}
if (comedi_pci_enable(pcidev, "cb_pcimdas")) {
- dev_err(dev->hw_dev, "Failed to enable PCI device and request regions\n");
+ dev_err(dev->class_dev,
+ "Failed to enable PCI device and request regions\n");
return -EIO;
}
devpriv->BADR3 = pci_resource_start(devpriv->pci_dev, 3);
devpriv->BADR4 = pci_resource_start(devpriv->pci_dev, 4);
- dev_dbg(dev->hw_dev, "devpriv->BADR0 = 0x%lx\n", devpriv->BADR0);
- dev_dbg(dev->hw_dev, "devpriv->BADR1 = 0x%lx\n", devpriv->BADR1);
- dev_dbg(dev->hw_dev, "devpriv->BADR2 = 0x%lx\n", devpriv->BADR2);
- dev_dbg(dev->hw_dev, "devpriv->BADR3 = 0x%lx\n", devpriv->BADR3);
- dev_dbg(dev->hw_dev, "devpriv->BADR4 = 0x%lx\n", devpriv->BADR4);
+ dev_dbg(dev->class_dev, "devpriv->BADR0 = 0x%lx\n", devpriv->BADR0);
+ dev_dbg(dev->class_dev, "devpriv->BADR1 = 0x%lx\n", devpriv->BADR1);
+ dev_dbg(dev->class_dev, "devpriv->BADR2 = 0x%lx\n", devpriv->BADR2);
+ dev_dbg(dev->class_dev, "devpriv->BADR3 = 0x%lx\n", devpriv->BADR3);
+ dev_dbg(dev->class_dev, "devpriv->BADR4 = 0x%lx\n", devpriv->BADR4);
/* Dont support IRQ yet */
/* get irq */
/* Initialize dev->board_name */
dev->board_name = thisboard->name;
-/*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- if (alloc_subdevices(dev, 3) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* dev->read_subdev=s; */
#include "../comedidev.h"
-#include "comedi_pci.h"
-
#include "8255.h"
/* device ids of the cards we support -- currently only 1 card supported */
*/
dev->board_name = thisboard->name;
-/*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- if (alloc_subdevices(dev, 2) < 0)
- return -ENOMEM;
+ err = comedi_alloc_subdevices(dev, 2);
+ if (err)
+ return err;
s = dev->subdevices + 0;
{
#define LSAMPL_BITS (sizeof(unsigned int)*8)
unsigned nchans = LSAMPL_BITS, num_done = 0, i;
- if (insn->n != 2)
- return -EINVAL;
if (devpriv->nchans < nchans)
nchans = devpriv->nchans;
struct comedi_devconfig *it)
{
struct comedi_subdevice *s;
+ int ret;
LOG_MSG("comedi%d\n", dev->minor);
*/
dev->board_name = devpriv->name;
- /*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- if (alloc_subdevices(dev, 1) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
s->type = COMEDI_SUBD_DIO;
data[1] = inb(dev->iobase + PARPORT_A);
- return 2;
+ return insn->n;
}
static int parport_insn_config_a(struct comedi_device *dev,
data[1] = (inb(dev->iobase + PARPORT_B) >> 3);
- return 2;
+ return insn->n;
}
static int parport_insn_c(struct comedi_device *dev, struct comedi_subdevice *s,
data[1] = devpriv->c_data & 0xf;
- return 2;
+ return insn->n;
}
static int parport_intr_insn(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n < 1)
- return -EINVAL;
-
data[1] = 0;
- return 2;
+ return insn->n;
}
static int parport_intr_cmdtest(struct comedi_device *dev,
}
dev->board_name = "parport";
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
+
ret = alloc_private(dev, sizeof(struct parport_private));
if (ret < 0)
return ret;
+++ /dev/null
-/*
- comedi/drivers/comedi_pci.h
- Various PCI functions for drivers.
-
- Copyright (C) 2007 MEV Ltd. <http://www.mev.co.uk/>
-
- COMEDI - Linux Control and Measurement Device Interface
- Copyright (C) 2000 David A. Schleef <ds@schleef.org>
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
-
-#ifndef _COMEDI_PCI_H_
-#define _COMEDI_PCI_H_
-
-#include <linux/pci.h>
-
-/*
- * Enable the PCI device and request the regions.
- */
-static inline int comedi_pci_enable(struct pci_dev *pdev, const char *res_name)
-{
- int rc;
-
- rc = pci_enable_device(pdev);
- if (rc < 0)
- return rc;
-
- rc = pci_request_regions(pdev, res_name);
- if (rc < 0)
- pci_disable_device(pdev);
-
- return rc;
-}
-
-/*
- * Release the regions and disable the PCI device.
- *
- * This must be matched with a previous successful call to comedi_pci_enable().
- */
-static inline void comedi_pci_disable(struct pci_dev *pdev)
-{
- pci_release_regions(pdev);
- pci_disable_device(pdev);
-}
-
-#endif
#define N_CHANS 8
-#define thisboard ((const struct waveform_board *)dev->board_ptr)
-
/* Data unique to this driver */
struct waveform_private {
struct timer_list timer;
static int waveform_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ const struct waveform_board *board = comedi_board(dev);
struct comedi_subdevice *s;
int amplitude = it->options[0];
int period = it->options[1];
int i;
+ int ret;
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
if (alloc_private(dev, sizeof(struct waveform_private)) < 0)
return -ENOMEM;
devpriv->uvolt_amplitude = amplitude;
devpriv->usec_period = period;
- dev->n_subdevices = 2;
- if (alloc_subdevices(dev, dev->n_subdevices) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 2);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
dev->read_subdev = s;
/* analog input subdevice */
s->type = COMEDI_SUBD_AI;
s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
- s->n_chan = thisboard->ai_chans;
- s->maxdata = (1 << thisboard->ai_bits) - 1;
+ s->n_chan = board->ai_chans;
+ s->maxdata = (1 << board->ai_bits) - 1;
s->range_table = &waveform_ai_ranges;
s->len_chanlist = s->n_chan * 2;
s->insn_read = waveform_ai_insn_read;
/* analog output subdevice (loopback) */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITEABLE | SDF_GROUND;
- s->n_chan = thisboard->ai_chans;
- s->maxdata = (1 << thisboard->ai_bits) - 1;
+ s->n_chan = board->ai_chans;
+ s->maxdata = (1 << board->ai_bits) - 1;
s->range_table = &waveform_ai_ranges;
s->len_chanlist = s->n_chan * 2;
s->insn_write = waveform_ao_insn_write;
#include "../comedidev.h"
-#include "comedi_pci.h"
-
enum contec_model {
PIO1616L = 0,
};
struct comedi_insn *insn, unsigned int *data)
{
- dev_dbg(dev->hw_dev, "contec_do_insn_bits called\n");
- dev_dbg(dev->hw_dev, "data: %d %d\n", data[0], data[1]);
-
- if (insn->n != 2)
- return -EINVAL;
+ dev_dbg(dev->class_dev, "contec_do_insn_bits called\n");
+ dev_dbg(dev->class_dev, "data: %d %d\n", data[0], data[1]);
if (data[0]) {
s->state &= ~data[0];
s->state |= data[0] & data[1];
- dev_dbg(dev->hw_dev, "out: %d on %lx\n", s->state,
+ dev_dbg(dev->class_dev, "out: %d on %lx\n", s->state,
dev->iobase + thisboard->out_offs);
outw(s->state, dev->iobase + thisboard->out_offs);
}
- return 2;
+ return insn->n;
}
static int contec_di_insn_bits(struct comedi_device *dev,
struct comedi_insn *insn, unsigned int *data)
{
- dev_dbg(dev->hw_dev, "contec_di_insn_bits called\n");
- dev_dbg(dev->hw_dev, "data: %d %d\n", data[0], data[1]);
-
- if (insn->n != 2)
- return -EINVAL;
+ dev_dbg(dev->class_dev, "contec_di_insn_bits called\n");
+ dev_dbg(dev->class_dev, "data: %d %d\n", data[0], data[1]);
data[1] = inw(dev->iobase + thisboard->in_offs);
- return 2;
+ return insn->n;
}
static int contec_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
struct pci_dev *pcidev = NULL;
struct comedi_subdevice *s;
+ int ret;
printk("comedi%d: contec: ", dev->minor);
if (alloc_private(dev, sizeof(struct contec_private)) < 0)
return -ENOMEM;
- if (alloc_subdevices(dev, 2) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 2);
+ if (ret)
+ return ret;
for_each_pci_dev(pcidev) {
if (pcidev->vendor == PCI_VENDOR_ID_CONTEC &&
#include <linux/delay.h>
#include <linux/interrupt.h>
-#include "comedi_pci.h"
#include "8255.h"
#define DAQBOARD2000_SUBSYSTEM_IDS2 0x00021616 /* Daqboard/2000 - 2 Dacs */
static void daqboard2000_resetLocalBus(struct comedi_device *dev)
{
- dev_dbg(dev->hw_dev, "daqboard2000_resetLocalBus\n");
+ dev_dbg(dev->class_dev, "daqboard2000_resetLocalBus\n");
writel(DAQBOARD2000_SECRLocalBusHi, devpriv->plx + 0x6c);
udelay(10000);
writel(DAQBOARD2000_SECRLocalBusLo, devpriv->plx + 0x6c);
static void daqboard2000_reloadPLX(struct comedi_device *dev)
{
- dev_dbg(dev->hw_dev, "daqboard2000_reloadPLX\n");
+ dev_dbg(dev->class_dev, "daqboard2000_reloadPLX\n");
writel(DAQBOARD2000_SECRReloadLo, devpriv->plx + 0x6c);
udelay(10000);
writel(DAQBOARD2000_SECRReloadHi, devpriv->plx + 0x6c);
static void daqboard2000_pulseProgPin(struct comedi_device *dev)
{
- dev_dbg(dev->hw_dev, "daqboard2000_pulseProgPin 1\n");
+ dev_dbg(dev->class_dev, "daqboard2000_pulseProgPin 1\n");
writel(DAQBOARD2000_SECRProgPinHi, devpriv->plx + 0x6c);
udelay(10000);
writel(DAQBOARD2000_SECRProgPinLo, devpriv->plx + 0x6c);
secr = readl(devpriv->plx + 0x6c);
if (!(secr & DAQBOARD2000_EEPROM_PRESENT)) {
#ifdef DEBUG_EEPROM
- dev_dbg(dev->hw_dev, "no serial eeprom\n");
+ dev_dbg(dev->class_dev, "no serial eeprom\n");
#endif
return -EIO;
}
for (retry = 0; retry < 3; retry++) {
#ifdef DEBUG_EEPROM
- dev_dbg(dev->hw_dev, "Programming EEPROM try %x\n", retry);
+ dev_dbg(dev->class_dev, "Programming EEPROM try %x\n", retry);
#endif
daqboard2000_resetLocalBus(dev);
if (cpld_array[i] == 0xff
&& cpld_array[i + 1] == 0x20) {
#ifdef DEBUG_EEPROM
- dev_dbg(dev->hw_dev, "Preamble found at %d\n",
- i);
+ dev_dbg(dev->class_dev,
+ "Preamble found at %d\n", i);
#endif
break;
}
}
if (i >= len) {
#ifdef DEBUG_EEPROM
- dev_dbg(dev->hw_dev, "Programmed\n");
+ dev_dbg(dev->class_dev, "Programmed\n");
#endif
daqboard2000_resetLocalBus(dev);
daqboard2000_reloadPLX(dev);
}
if (!card) {
if (bus || slot)
- dev_err(dev->hw_dev, "no daqboard2000 found at bus/slot: %d/%d\n",
+ dev_err(dev->class_dev,
+ "no daqboard2000 found at bus/slot: %d/%d\n",
bus, slot);
else
- dev_err(dev->hw_dev, "no daqboard2000 found\n");
+ dev_err(dev->class_dev, "no daqboard2000 found\n");
return -EIO;
} else {
u32 id;
subsystem_device << 16) | card->subsystem_vendor;
for (i = 0; i < ARRAY_SIZE(boardtypes); i++) {
if (boardtypes[i].id == id) {
- dev_dbg(dev->hw_dev, "%s\n",
+ dev_dbg(dev->class_dev, "%s\n",
boardtypes[i].name);
dev->board_ptr = boardtypes + i;
}
result = comedi_pci_enable(card, "daqboard2000");
if (result < 0) {
- dev_err(dev->hw_dev, "failed to enable PCI device and request regions\n");
+ dev_err(dev->class_dev,
+ "failed to enable PCI device and request regions\n");
return -EIO;
}
devpriv->got_regions = 1;
if (!devpriv->plx || !devpriv->daq)
return -ENOMEM;
- result = alloc_subdevices(dev, 3);
- if (result < 0)
- goto out;
+ result = comedi_alloc_subdevices(dev, 3);
+ if (result)
+ return result;
readl(devpriv->plx + 0x6c);
if (aux_data && aux_len) {
result = initialize_daqboard2000(dev, aux_data, aux_len);
} else {
- dev_dbg(dev->hw_dev, "no FPGA initialization code, aborting\n");
+ dev_dbg(dev->class_dev,
+ "no FPGA initialization code, aborting\n");
result = -EIO;
}
if (result < 0)
* [ComputerBoards] DAS08 (isa-das08), DAS08-PGM (das08-pgm),
* DAS08-PGH (das08-pgh), DAS08-PGL (das08-pgl), DAS08-AOH (das08-aoh),
* DAS08-AOL (das08-aol), DAS08-AOM (das08-aom), DAS08/JR-AO (das08/jr-ao),
- * DAS08/JR-16-AO (das08jr-16-ao), PCI-DAS08 (das08),
+ * DAS08/JR-16-AO (das08jr-16-ao), PCI-DAS08 (pci-das08 or das08),
* PC104-DAS08 (pc104-das08), DAS08/JR/16 (das08jr/16)
* Status: works
*
#include <linux/delay.h>
-#include "comedi_pci.h"
#include "8255.h"
#include "das08.h"
#define DRV_NAME "das08"
-#ifdef CONFIG_COMEDI_DAS08_ISA_MODULE
-#define CONFIG_COMEDI_DAS08_ISA
-#endif
-#ifdef CONFIG_COMEDI_DAS08_PCI_MODULE
-#define CONFIG_COMEDI_DAS08_PCI
-#endif
-#ifdef CONFIG_COMEDI_DAS08_CS_MODULE
-#define CONFIG_COMEDI_DAS08_CS
-#endif
-
-#if defined(CONFIG_COMEDI_DAS08_ISA) || defined(CONFIG_COMEDI_DAS08_PCI)
-#define DO_COMEDI_DRIVER_REGISTER
-#endif
+#define DO_COMEDI_DRIVER_REGISTER \
+ (IS_ENABLED(CONFIG_COMEDI_DAS08_ISA) || \
+ IS_ENABLED(CONFIG_COMEDI_DAS08_PCI))
#define PCI_VENDOR_ID_COMPUTERBOARDS 0x1307
#define PCI_DEVICE_ID_PCIDAS08 0x29
/* gainlist same as _pgx_ below */
-static int das08_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das08_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das08_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-#ifdef CONFIG_COMEDI_DAS08_ISA
-static int das08jr_di_rbits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das08jr_do_wbits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das08jr_ao_winsn(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das08ao_ao_winsn(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-#endif
-static void i8254_set_mode_low(unsigned int base, int channel,
- unsigned int mode);
-
static const struct comedi_lrange range_das08_pgl = { 9, {
BIP_RANGE(10),
BIP_RANGE(5),
das08_pgm_gainlist,
};
-#ifdef DO_COMEDI_DRIVER_REGISTER
-static const struct das08_board_struct das08_boards[] = {
-#ifdef CONFIG_COMEDI_DAS08_ISA
- {
- .name = "isa-das08", /* cio-das08.pdf */
- .bustype = isa,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_pg_none,
- .ai_encoding = das08_encode12,
- .ao = NULL,
- .ao_nbits = 12,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 4,
- .i8255_offset = 8,
- .i8254_offset = 4,
- .iosize = 16, /* unchecked */
- },
- {
- .name = "das08-pgm", /* cio-das08pgx.pdf */
- .bustype = isa,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_pgm,
- .ai_encoding = das08_encode12,
- .ao = NULL,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 4,
- .i8255_offset = 0,
- .i8254_offset = 0x04,
- .iosize = 16, /* unchecked */
- },
- {
- .name = "das08-pgh", /* cio-das08pgx.pdf */
- .bustype = isa,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_pgh,
- .ai_encoding = das08_encode12,
- .ao = NULL,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 4,
- .i8255_offset = 0,
- .i8254_offset = 0x04,
- .iosize = 16, /* unchecked */
- },
- {
- .name = "das08-pgl", /* cio-das08pgx.pdf */
- .bustype = isa,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_pgl,
- .ai_encoding = das08_encode12,
- .ao = NULL,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 4,
- .i8255_offset = 0,
- .i8254_offset = 0x04,
- .iosize = 16, /* unchecked */
- },
- {
- .name = "das08-aoh", /* cio-das08_aox.pdf */
- .bustype = isa,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_pgh,
- .ai_encoding = das08_encode12,
- .ao = das08ao_ao_winsn, /* 8 */
- .ao_nbits = 12,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 4,
- .i8255_offset = 0x0c,
- .i8254_offset = 0x04,
- .iosize = 16, /* unchecked */
- },
- {
- .name = "das08-aol", /* cio-das08_aox.pdf */
- .bustype = isa,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_pgl,
- .ai_encoding = das08_encode12,
- .ao = das08ao_ao_winsn, /* 8 */
- .ao_nbits = 12,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 4,
- .i8255_offset = 0x0c,
- .i8254_offset = 0x04,
- .iosize = 16, /* unchecked */
- },
- {
- .name = "das08-aom", /* cio-das08_aox.pdf */
- .bustype = isa,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_pgm,
- .ai_encoding = das08_encode12,
- .ao = das08ao_ao_winsn, /* 8 */
- .ao_nbits = 12,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 4,
- .i8255_offset = 0x0c,
- .i8254_offset = 0x04,
- .iosize = 16, /* unchecked */
- },
- {
- .name = "das08/jr-ao", /* cio-das08-jr-ao.pdf */
- .bustype = isa,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_pg_none,
- .ai_encoding = das08_encode12,
- .ao = das08jr_ao_winsn,
- .ao_nbits = 12,
- .di = das08jr_di_rbits,
- .do_ = das08jr_do_wbits,
- .do_nchan = 8,
- .i8255_offset = 0,
- .i8254_offset = 0,
- .iosize = 16, /* unchecked */
- },
- {
- .name = "das08jr-16-ao", /* cio-das08jr-16-ao.pdf */
- .bustype = isa,
- .ai = das08_ai_rinsn,
- .ai_nbits = 16,
- .ai_pg = das08_pg_none,
- .ai_encoding = das08_encode12,
- .ao = das08jr_ao_winsn,
- .ao_nbits = 16,
- .di = das08jr_di_rbits,
- .do_ = das08jr_do_wbits,
- .do_nchan = 8,
- .i8255_offset = 0,
- .i8254_offset = 0x04,
- .iosize = 16, /* unchecked */
- },
- {
- .name = "pc104-das08",
- .bustype = pc104,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_pg_none,
- .ai_encoding = das08_encode12,
- .ao = NULL,
- .ao_nbits = 0,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 4,
- .i8255_offset = 0,
- .i8254_offset = 4,
- .iosize = 16, /* unchecked */
- },
-#if 0
- {
- .name = "das08/f",
- },
- {
- .name = "das08jr",
- },
-#endif
- {
- .name = "das08jr/16",
- .bustype = isa,
- .ai = das08_ai_rinsn,
- .ai_nbits = 16,
- .ai_pg = das08_pg_none,
- .ai_encoding = das08_encode16,
- .ao = NULL,
- .ao_nbits = 0,
- .di = das08jr_di_rbits,
- .do_ = das08jr_do_wbits,
- .do_nchan = 8,
- .i8255_offset = 0,
- .i8254_offset = 0,
- .iosize = 16, /* unchecked */
- },
-#if 0
- {
- .name = "das48-pga", /* cio-das48-pga.pdf */
- },
- {
- .name = "das08-pga-g2", /* a KM board */
- },
-#endif
-#endif /* CONFIG_COMEDI_DAS08_ISA */
-#ifdef CONFIG_COMEDI_DAS08_PCI
- {
- .name = "das08", /* pci-das08 */
- .id = PCI_DEVICE_ID_PCIDAS08,
- .bustype = pci,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_bipolar5,
- .ai_encoding = das08_encode12,
- .ao = NULL,
- .ao_nbits = 0,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 4,
- .i8255_offset = 0,
- .i8254_offset = 4,
- .iosize = 8,
- },
-#endif /* CONFIG_COMEDI_DAS08_PCI */
-};
-#endif /* DO_COMEDI_DRIVER_REGISTER */
-
-#ifdef CONFIG_COMEDI_DAS08_CS
-struct das08_board_struct das08_cs_boards[NUM_DAS08_CS_BOARDS] = {
- {
- .name = "pcm-das08",
- .id = 0x0, /* XXX */
- .bustype = pcmcia,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_bipolar5,
- .ai_encoding = das08_pcm_encode12,
- .ao = NULL,
- .ao_nbits = 0,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 3,
- .i8255_offset = 0,
- .i8254_offset = 0,
- .iosize = 16,
- },
- /* duplicate so driver name can be used also */
- {
- .name = "das08_cs",
- .id = 0x0, /* XXX */
- .bustype = pcmcia,
- .ai = das08_ai_rinsn,
- .ai_nbits = 12,
- .ai_pg = das08_bipolar5,
- .ai_encoding = das08_pcm_encode12,
- .ao = NULL,
- .ao_nbits = 0,
- .di = das08_di_rbits,
- .do_ = das08_do_wbits,
- .do_nchan = 3,
- .i8255_offset = 0,
- .i8254_offset = 0,
- .iosize = 16,
- },
-};
-#endif
-
-#ifdef CONFIG_COMEDI_DAS08_PCI
-static DEFINE_PCI_DEVICE_TABLE(das08_pci_table) = {
- { PCI_DEVICE(PCI_VENDOR_ID_COMPUTERBOARDS, PCI_DEVICE_ID_PCIDAS08) },
- {0}
-};
-
-MODULE_DEVICE_TABLE(pci, das08_pci_table);
-#endif
-
-#define devpriv ((struct das08_private_struct *)dev->private)
-#define thisboard ((const struct das08_board_struct *)dev->board_ptr)
-
#define TIMEOUT 100000
static int das08_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ const struct das08_board_struct *thisboard = comedi_board(dev);
+ struct das08_private_struct *devpriv = dev->private;
int i, n;
int chan;
int range;
/* clear over-range bits for 16-bit boards */
if (thisboard->ai_nbits == 16)
if (inb(dev->iobase + DAS08_MSB) & 0x80)
- printk(KERN_INFO "das08: over-range\n");
+ dev_info(dev->class_dev, "over-range\n");
/* trigger conversion */
outb_p(0, dev->iobase + DAS08_TRIG_12BIT);
break;
}
if (i == TIMEOUT) {
- printk(KERN_ERR "das08: timeout\n");
+ dev_err(dev->class_dev, "timeout\n");
return -ETIME;
}
msb = inb(dev->iobase + DAS08_MSB);
data[0] = 0;
data[1] = DAS08_IP(inb(dev->iobase + DAS08_STATUS));
- return 2;
+ return insn->n;
}
static int das08_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ struct das08_private_struct *devpriv = dev->private;
int wbits;
/* get current settings of digital output lines */
data[1] = wbits;
- return 2;
+ return insn->n;
}
-#ifdef CONFIG_COMEDI_DAS08_ISA
-static int das08jr_di_rbits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data)
+static int __maybe_unused
+das08jr_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s,
+ struct comedi_insn *insn, unsigned int *data)
{
data[0] = 0;
data[1] = inb(dev->iobase + DAS08JR_DIO);
- return 2;
+ return insn->n;
}
-#endif
-#ifdef CONFIG_COMEDI_DAS08_ISA
-static int das08jr_do_wbits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data)
+static int __maybe_unused
+das08jr_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
+ struct comedi_insn *insn, unsigned int *data)
{
+ struct das08_private_struct *devpriv = dev->private;
+
/* null bits we are going to set */
devpriv->do_bits &= ~data[0];
/* set new bit values */
data[1] = devpriv->do_bits;
- return 2;
+ return insn->n;
}
-#endif
-#ifdef CONFIG_COMEDI_DAS08_ISA
-static int das08jr_ao_winsn(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data)
+static int __maybe_unused
+das08jr_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
+ struct comedi_insn *insn, unsigned int *data)
{
int n;
int lsb, msb;
return n;
}
-#endif
/*
*
* a different method to force an update.
*
*/
-#ifdef CONFIG_COMEDI_DAS08_ISA
-static int das08ao_ao_winsn(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data)
+static int __maybe_unused
+das08ao_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
+ struct comedi_insn *insn, unsigned int *data)
{
int n;
int lsb, msb;
return n;
}
-#endif
static unsigned int i8254_read_channel_low(unsigned int base, int chan)
{
i8254_write_channel_low(st->iobase, chan, value);
}
-static void i8254_initialize(struct i8254_struct *st)
-{
- int i;
- for (i = 0; i < 3; ++i)
- i8254_set_mode_low(st->iobase, i, st->mode[i]);
-}
-
static void i8254_set_mode_low(unsigned int base, int channel,
unsigned int mode)
{
return i8254_read_status_low(st->iobase, chan);
}
+static void i8254_initialize(struct i8254_struct *st)
+{
+ int i;
+ for (i = 0; i < 3; ++i)
+ i8254_set_mode_low(st->iobase, i, st->mode[i]);
+}
+
static int das08_counter_read(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ struct das08_private_struct *devpriv = dev->private;
int chan = insn->chanspec;
-
- /* printk("Reading counter channel %d ",chan); */
data[0] = i8254_read_channel(&devpriv->i8254, chan);
- /* printk("=> 0x%08X\n",data[0]); */
-
return 1;
}
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ struct das08_private_struct *devpriv = dev->private;
int chan = insn->chanspec;
-
- /* printk("Writing counter channel %d with 0x%04X\n",chan,data[0]); */
i8254_write_channel(&devpriv->i8254, chan, data[0]);
-
return 1;
}
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ struct das08_private_struct *devpriv = dev->private;
int chan = insn->chanspec;
if (insn->n != 2)
return 2;
}
-#ifdef DO_COMEDI_DRIVER_REGISTER
-static int das08_attach(struct comedi_device *dev, struct comedi_devconfig *it);
+#if DO_COMEDI_DRIVER_REGISTER
+static const struct das08_board_struct das08_boards[] = {
+#if IS_ENABLED(CONFIG_COMEDI_DAS08_ISA)
+ {
+ .name = "isa-das08", /* cio-das08.pdf */
+ .bustype = isa,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_pg_none,
+ .ai_encoding = das08_encode12,
+ .ao = NULL,
+ .ao_nbits = 12,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 4,
+ .i8255_offset = 8,
+ .i8254_offset = 4,
+ .iosize = 16, /* unchecked */
+ },
+ {
+ .name = "das08-pgm", /* cio-das08pgx.pdf */
+ .bustype = isa,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_pgm,
+ .ai_encoding = das08_encode12,
+ .ao = NULL,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 4,
+ .i8255_offset = 0,
+ .i8254_offset = 0x04,
+ .iosize = 16, /* unchecked */
+ },
+ {
+ .name = "das08-pgh", /* cio-das08pgx.pdf */
+ .bustype = isa,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_pgh,
+ .ai_encoding = das08_encode12,
+ .ao = NULL,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 4,
+ .i8255_offset = 0,
+ .i8254_offset = 0x04,
+ .iosize = 16, /* unchecked */
+ },
+ {
+ .name = "das08-pgl", /* cio-das08pgx.pdf */
+ .bustype = isa,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_pgl,
+ .ai_encoding = das08_encode12,
+ .ao = NULL,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 4,
+ .i8255_offset = 0,
+ .i8254_offset = 0x04,
+ .iosize = 16, /* unchecked */
+ },
+ {
+ .name = "das08-aoh", /* cio-das08_aox.pdf */
+ .bustype = isa,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_pgh,
+ .ai_encoding = das08_encode12,
+ .ao = das08ao_ao_winsn, /* 8 */
+ .ao_nbits = 12,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 4,
+ .i8255_offset = 0x0c,
+ .i8254_offset = 0x04,
+ .iosize = 16, /* unchecked */
+ },
+ {
+ .name = "das08-aol", /* cio-das08_aox.pdf */
+ .bustype = isa,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_pgl,
+ .ai_encoding = das08_encode12,
+ .ao = das08ao_ao_winsn, /* 8 */
+ .ao_nbits = 12,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 4,
+ .i8255_offset = 0x0c,
+ .i8254_offset = 0x04,
+ .iosize = 16, /* unchecked */
+ },
+ {
+ .name = "das08-aom", /* cio-das08_aox.pdf */
+ .bustype = isa,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_pgm,
+ .ai_encoding = das08_encode12,
+ .ao = das08ao_ao_winsn, /* 8 */
+ .ao_nbits = 12,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 4,
+ .i8255_offset = 0x0c,
+ .i8254_offset = 0x04,
+ .iosize = 16, /* unchecked */
+ },
+ {
+ .name = "das08/jr-ao", /* cio-das08-jr-ao.pdf */
+ .bustype = isa,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_pg_none,
+ .ai_encoding = das08_encode12,
+ .ao = das08jr_ao_winsn,
+ .ao_nbits = 12,
+ .di = das08jr_di_rbits,
+ .do_ = das08jr_do_wbits,
+ .do_nchan = 8,
+ .i8255_offset = 0,
+ .i8254_offset = 0,
+ .iosize = 16, /* unchecked */
+ },
+ {
+ .name = "das08jr-16-ao", /* cio-das08jr-16-ao.pdf */
+ .bustype = isa,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 16,
+ .ai_pg = das08_pg_none,
+ .ai_encoding = das08_encode12,
+ .ao = das08jr_ao_winsn,
+ .ao_nbits = 16,
+ .di = das08jr_di_rbits,
+ .do_ = das08jr_do_wbits,
+ .do_nchan = 8,
+ .i8255_offset = 0,
+ .i8254_offset = 0x04,
+ .iosize = 16, /* unchecked */
+ },
+ {
+ .name = "pc104-das08",
+ .bustype = pc104,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_pg_none,
+ .ai_encoding = das08_encode12,
+ .ao = NULL,
+ .ao_nbits = 0,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 4,
+ .i8255_offset = 0,
+ .i8254_offset = 4,
+ .iosize = 16, /* unchecked */
+ },
+#if 0
+ {
+ .name = "das08/f",
+ },
+ {
+ .name = "das08jr",
+ },
+#endif
+ {
+ .name = "das08jr/16",
+ .bustype = isa,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 16,
+ .ai_pg = das08_pg_none,
+ .ai_encoding = das08_encode16,
+ .ao = NULL,
+ .ao_nbits = 0,
+ .di = das08jr_di_rbits,
+ .do_ = das08jr_do_wbits,
+ .do_nchan = 8,
+ .i8255_offset = 0,
+ .i8254_offset = 0,
+ .iosize = 16, /* unchecked */
+ },
+#if 0
+ {
+ .name = "das48-pga", /* cio-das48-pga.pdf */
+ },
+ {
+ .name = "das08-pga-g2", /* a KM board */
+ },
+#endif
+#endif /* IS_ENABLED(CONFIG_COMEDI_DAS08_ISA) */
+#if IS_ENABLED(CONFIG_COMEDI_DAS08_PCI)
+ {
+ .name = "pci-das08", /* pci-das08 */
+ .id = PCI_DEVICE_ID_PCIDAS08,
+ .bustype = pci,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_bipolar5,
+ .ai_encoding = das08_encode12,
+ .ao = NULL,
+ .ao_nbits = 0,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 4,
+ .i8255_offset = 0,
+ .i8254_offset = 4,
+ .iosize = 8,
+ },
+ { /* wildcard entry matches any supported PCI device */
+ .name = DRV_NAME,
+ .id = PCI_ANY_ID,
+ .bustype = pci,
+ },
+#endif /* IS_ENABLED(CONFIG_COMEDI_DAS08_PCI) */
+};
+#endif /* DO_COMEDI_DRIVER_REGISTER */
-static struct comedi_driver driver_das08 = {
- .driver_name = DRV_NAME,
- .module = THIS_MODULE,
- .attach = das08_attach,
- .detach = das08_common_detach,
- .board_name = &das08_boards[0].name,
- .num_names = sizeof(das08_boards) / sizeof(struct das08_board_struct),
- .offset = sizeof(struct das08_board_struct),
+#if IS_ENABLED(CONFIG_COMEDI_DAS08_CS)
+struct das08_board_struct das08_cs_boards[NUM_DAS08_CS_BOARDS] = {
+ {
+ .name = "pcm-das08",
+ .id = 0x0, /* XXX */
+ .bustype = pcmcia,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_bipolar5,
+ .ai_encoding = das08_pcm_encode12,
+ .ao = NULL,
+ .ao_nbits = 0,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 3,
+ .i8255_offset = 0,
+ .i8254_offset = 0,
+ .iosize = 16,
+ },
+ /* duplicate so driver name can be used also */
+ {
+ .name = "das08_cs",
+ .id = 0x0, /* XXX */
+ .bustype = pcmcia,
+ .ai = das08_ai_rinsn,
+ .ai_nbits = 12,
+ .ai_pg = das08_bipolar5,
+ .ai_encoding = das08_pcm_encode12,
+ .ao = NULL,
+ .ao_nbits = 0,
+ .di = das08_di_rbits,
+ .do_ = das08_do_wbits,
+ .do_nchan = 3,
+ .i8255_offset = 0,
+ .i8254_offset = 0,
+ .iosize = 16,
+ },
};
+EXPORT_SYMBOL_GPL(das08_cs_boards);
#endif
int das08_common_attach(struct comedi_device *dev, unsigned long iobase)
{
+ const struct das08_board_struct *thisboard = comedi_board(dev);
+ struct das08_private_struct *devpriv = dev->private;
struct comedi_subdevice *s;
int ret;
- /* allocate ioports for non-pcmcia, non-pci boards */
- if ((thisboard->bustype != pcmcia) && (thisboard->bustype != pci)) {
- printk(KERN_INFO " iobase 0x%lx\n", iobase);
- if (!request_region(iobase, thisboard->iosize, DRV_NAME)) {
- printk(KERN_ERR " I/O port conflict\n");
- return -EIO;
- }
- }
dev->iobase = iobase;
dev->board_name = thisboard->name;
- ret = alloc_subdevices(dev, 6);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 6);
+ if (ret)
return ret;
s = dev->subdevices + 0;
}
EXPORT_SYMBOL_GPL(das08_common_attach);
-#ifdef DO_COMEDI_DRIVER_REGISTER
-static int das08_attach(struct comedi_device *dev, struct comedi_devconfig *it)
+static int das08_pci_attach_common(struct comedi_device *dev,
+ struct pci_dev *pdev)
{
- int ret;
unsigned long iobase;
-#ifdef CONFIG_COMEDI_DAS08_PCI
- unsigned long pci_iobase = 0;
- struct pci_dev *pdev = NULL;
+ unsigned long pci_iobase;
+ struct das08_private_struct *devpriv = dev->private;
+
+ if (!IS_ENABLED(CONFIG_COMEDI_DAS08_PCI))
+ return -EINVAL;
+
+ devpriv->pdev = pdev;
+ /* enable PCI device and reserve I/O spaces */
+ if (comedi_pci_enable(pdev, dev->driver->driver_name)) {
+ dev_err(dev->class_dev,
+ "Error enabling PCI device and requesting regions\n");
+ return -EIO;
+ }
+ /* read base addresses */
+ pci_iobase = pci_resource_start(pdev, 1);
+ iobase = pci_resource_start(pdev, 2);
+ dev_info(dev->class_dev, "pcibase 0x%lx iobase 0x%lx\n",
+ pci_iobase, iobase);
+ devpriv->pci_iobase = pci_iobase;
+#if 0
+ /* We could enable pci-das08's interrupt here to make it possible
+ * to do timed input in this driver, but there is little point since
+ * conversions would have to be started by the interrupt handler
+ * so you might as well use comedi_rt_timer to emulate commands
+ */
+ /* set source of interrupt trigger to counter2 output */
+ outb(CNTRL_INTR | CNTRL_DIR, pci_iobase + CNTRL);
+ /* Enable local interrupt 1 and pci interrupt */
+ outw(INTR1_ENABLE | PCI_INTR_ENABLE, pci_iobase + INTCSR);
+#endif
+ return das08_common_attach(dev, iobase);
+}
+
+static const struct das08_board_struct *
+das08_find_pci_board(struct pci_dev *pdev)
+{
+#if DO_COMEDI_DRIVER_REGISTER
+ unsigned int i;
+ for (i = 0; i < ARRAY_SIZE(das08_boards); i++)
+ if (das08_boards[i].bustype == pci &&
+ pdev->device == das08_boards[i].id)
+ return &das08_boards[i];
#endif
+ return NULL;
+}
+
+/* only called in the PCI probe path, via comedi_pci_auto_config() */
+static int __devinit __maybe_unused
+das08_attach_pci(struct comedi_device *dev, struct pci_dev *pdev)
+{
+ int ret;
+ if (!IS_ENABLED(CONFIG_COMEDI_DAS08_PCI))
+ return -EINVAL;
ret = alloc_private(dev, sizeof(struct das08_private_struct));
if (ret < 0)
return ret;
+ dev_info(dev->class_dev, "attach pci %s\n", pci_name(pdev));
+ dev->board_ptr = das08_find_pci_board(pdev);
+ if (dev->board_ptr == NULL) {
+ dev_err(dev->class_dev, "BUG! cannot determine board type!\n");
+ return -EINVAL;
+ }
+ return das08_pci_attach_common(dev, pdev);
+}
- printk(KERN_INFO "comedi%d: das08: ", dev->minor);
-#ifdef CONFIG_COMEDI_DAS08_PCI
- /* deal with a pci board */
- if (thisboard->bustype == pci) {
- if (it->options[0] || it->options[1]) {
- printk("bus %i slot %i ",
- it->options[0], it->options[1]);
- }
- printk("\n");
- /* find card */
- for_each_pci_dev(pdev) {
- if (pdev->vendor == PCI_VENDOR_ID_COMPUTERBOARDS
- && pdev->device == PCI_DEVICE_ID_PCIDAS08) {
- if (it->options[0] || it->options[1]) {
- if (pdev->bus->number == it->options[0]
- && PCI_SLOT(pdev->devfn) ==
- it->options[1]) {
- break;
- }
- } else {
- break;
- }
- }
+static struct pci_dev *das08_find_pci(struct comedi_device *dev,
+ int bus, int slot)
+{
+ const struct das08_board_struct *thisboard = comedi_board(dev);
+ struct pci_dev *pdev;
+ unsigned int matchid;
+
+ if (bus || slot)
+ dev_dbg(dev->class_dev, "Looking for %s at PCI %02X:%02X\n",
+ thisboard->name, bus, slot);
+ else
+ dev_dbg(dev->class_dev, "Looking for %s on PCI buses\n",
+ thisboard->name);
+
+ matchid = thisboard->id;
+ pdev = NULL;
+ for_each_pci_dev(pdev) {
+ if ((bus || slot) &&
+ (bus != pdev->bus->number || slot != PCI_SLOT(pdev->devfn)))
+ continue;
+ if (pdev->vendor != PCI_VENDOR_ID_COMPUTERBOARDS)
+ continue;
+ if (matchid == PCI_ANY_ID) {
+ /* wildcard board matches any supported PCI board */
+ const struct das08_board_struct *foundboard;
+ foundboard = das08_find_pci_board(pdev);
+ if (foundboard == NULL)
+ continue;
+ /* replace wildcard board_ptr */
+ dev->board_ptr = thisboard = foundboard;
+ } else {
+ /* match specific PCI board */
+ if (pdev->device != matchid)
+ continue;
}
- if (!pdev) {
- printk(KERN_ERR "No pci das08 cards found\n");
+ /* found a match */
+ dev_info(dev->class_dev, "Found %s at PCI %s\n",
+ thisboard->name, pci_name(pdev));
+ return pdev;
+ }
+ /* no match found */
+ if (bus || slot)
+ dev_err(dev->class_dev,
+ "No %s cards found at PCI %02X:%02X\n",
+ thisboard->name, bus, slot);
+ else
+ dev_err(dev->class_dev, "No %s cards found on PCI buses\n",
+ thisboard->name);
+ return NULL;
+}
+
+static int __maybe_unused
+das08_attach(struct comedi_device *dev, struct comedi_devconfig *it)
+{
+ const struct das08_board_struct *thisboard = comedi_board(dev);
+ struct das08_private_struct *devpriv;
+ int ret;
+ unsigned long iobase;
+
+ ret = alloc_private(dev, sizeof(struct das08_private_struct));
+ if (ret < 0)
+ return ret;
+ devpriv = dev->private;
+
+ dev_info(dev->class_dev, "attach\n");
+ if (IS_ENABLED(CONFIG_COMEDI_DAS08_PCI) && thisboard->bustype == pci) {
+ struct pci_dev *pdev;
+ pdev = das08_find_pci(dev, it->options[0], it->options[1]);
+ if (pdev == NULL)
return -EIO;
- }
- devpriv->pdev = pdev;
- /* enable PCI device and reserve I/O spaces */
- if (comedi_pci_enable(pdev, DRV_NAME)) {
- printk(KERN_ERR " Error enabling PCI device and "
- "requesting regions\n");
+ return das08_pci_attach_common(dev, pdev);
+ } else if (IS_ENABLED(CONFIG_COMEDI_DAS08_ISA) &&
+ (thisboard->bustype == isa || thisboard->bustype == pc104)) {
+ iobase = it->options[0];
+ dev_info(dev->class_dev, "iobase 0x%lx\n", iobase);
+ if (!request_region(iobase, thisboard->iosize, DRV_NAME)) {
+ dev_err(dev->class_dev, "I/O port conflict\n");
return -EIO;
}
- /* read base addresses */
- pci_iobase = pci_resource_start(pdev, 1);
- iobase = pci_resource_start(pdev, 2);
- printk(KERN_INFO "pcibase 0x%lx iobase 0x%lx\n",
- pci_iobase, iobase);
- devpriv->pci_iobase = pci_iobase;
-#if 0
-/* We could enable to pci-das08's interrupt here to make it possible
- * to do timed input in this driver, but there is little point since
- * conversions would have to be started by the interrupt handler
- * so you might as well use comedi_rt_timer to emulate commands
- */
- /* set source of interrupt trigger to counter2 output */
- outb(CNTRL_INTR | CNTRL_DIR, pci_iobase + CNTRL);
- /* Enable local interrupt 1 and pci interrupt */
- outw(INTR1_ENABLE | PCI_INTR_ENABLE, pci_iobase + INTCSR);
-#endif
+ return das08_common_attach(dev, iobase);
} else
-#endif /* CONFIG_COMEDI_DAS08_PCI */
- {
- iobase = it->options[0];
- }
- printk(KERN_INFO "\n");
-
- return das08_common_attach(dev, iobase);
+ return -EIO;
}
-#endif /* DO_COMEDI_DRIVER_REGISTER */
void das08_common_detach(struct comedi_device *dev)
{
if (dev->subdevices)
subdev_8255_cleanup(dev, dev->subdevices + 4);
- if ((thisboard->bustype != pcmcia) && (thisboard->bustype != pci)) {
+}
+EXPORT_SYMBOL_GPL(das08_common_detach);
+
+static void __maybe_unused das08_detach(struct comedi_device *dev)
+{
+ const struct das08_board_struct *thisboard = comedi_board(dev);
+ struct das08_private_struct *devpriv = dev->private;
+
+ das08_common_detach(dev);
+ if (IS_ENABLED(CONFIG_COMEDI_DAS08_ISA) &&
+ (thisboard->bustype == isa || thisboard->bustype == pc104)) {
if (dev->iobase)
release_region(dev->iobase, thisboard->iosize);
- }
-#ifdef CONFIG_COMEDI_DAS08_PCI
- if (devpriv) {
- if (devpriv->pdev) {
+ } else if (IS_ENABLED(CONFIG_COMEDI_DAS08_PCI) &&
+ thisboard->bustype == pci) {
+ if (devpriv && devpriv->pdev) {
if (devpriv->pci_iobase)
comedi_pci_disable(devpriv->pdev);
-
pci_dev_put(devpriv->pdev);
}
}
-#endif
}
-EXPORT_SYMBOL_GPL(das08_common_detach);
-#ifdef CONFIG_COMEDI_DAS08_PCI
-static int __devinit driver_das08_pci_probe(struct pci_dev *dev,
+#if DO_COMEDI_DRIVER_REGISTER
+static struct comedi_driver das08_driver = {
+ .driver_name = DRV_NAME,
+ .module = THIS_MODULE,
+ .attach = das08_attach,
+ .attach_pci = das08_attach_pci,
+ .detach = das08_detach,
+ .board_name = &das08_boards[0].name,
+ .num_names = sizeof(das08_boards) / sizeof(struct das08_board_struct),
+ .offset = sizeof(struct das08_board_struct),
+};
+#endif
+
+#if IS_ENABLED(CONFIG_COMEDI_DAS08_PCI)
+static DEFINE_PCI_DEVICE_TABLE(das08_pci_table) = {
+ { PCI_DEVICE(PCI_VENDOR_ID_COMPUTERBOARDS, PCI_DEVICE_ID_PCIDAS08) },
+ {0}
+};
+
+MODULE_DEVICE_TABLE(pci, das08_pci_table);
+
+static int __devinit das08_pci_probe(struct pci_dev *dev,
const struct pci_device_id *ent)
{
- return comedi_pci_auto_config(dev, &driver_das08);
+ return comedi_pci_auto_config(dev, &das08_driver);
}
-static void __devexit driver_das08_pci_remove(struct pci_dev *dev)
+static void __devexit das08_pci_remove(struct pci_dev *dev)
{
comedi_pci_auto_unconfig(dev);
}
-static struct pci_driver driver_das08_pci_driver = {
+static struct pci_driver das08_pci_driver = {
.id_table = das08_pci_table,
- .probe = &driver_das08_pci_probe,
- .remove = __devexit_p(&driver_das08_pci_remove)
+ .name = DRV_NAME,
+ .probe = &das08_pci_probe,
+ .remove = __devexit_p(&das08_pci_remove)
};
#endif /* CONFIG_COMEDI_DAS08_PCI */
-static int __init driver_das08_init_module(void)
-{
- int retval = 0;
-
-#ifdef DO_COMEDI_DRIVER_REGISTER
- retval = comedi_driver_register(&driver_das08);
- if (retval < 0)
- return retval;
-#endif
-#ifdef CONFIG_COMEDI_DAS08_PCI
- driver_das08_pci_driver.name = (char *)driver_das08.driver_name;
- retval = pci_register_driver(&driver_das08_pci_driver);
+#if DO_COMEDI_DRIVER_REGISTER
+#if IS_ENABLED(CONFIG_COMEDI_DAS08_PCI)
+module_comedi_pci_driver(das08_driver, das08_pci_driver);
+#else
+module_comedi_driver(das08_driver);
#endif
- return retval;
+#else /* DO_COMEDI_DRIVER_REGISTER */
+static int __init das08_init(void)
+{
+ return 0;
}
-static void __exit driver_das08_cleanup_module(void)
+static void __exit das08_exit(void)
{
-#ifdef CONFIG_COMEDI_DAS08_PCI
- pci_unregister_driver(&driver_das08_pci_driver);
-#endif
-#ifdef DO_COMEDI_DRIVER_REGISTER
- comedi_driver_unregister(&driver_das08);
-#endif
}
-module_init(driver_das08_init_module);
-module_exit(driver_das08_cleanup_module);
-
-#ifdef CONFIG_COMEDI_DAS08_CS
-EXPORT_SYMBOL_GPL(das08_cs_boards);
-#endif
+module_init(das08_init);
+module_exit(das08_exit);
+#endif /* DO_COMEDI_DRIVER_REGISTER */
MODULE_AUTHOR("Comedi http://www.comedi.org");
MODULE_DESCRIPTION("Comedi low-level driver");
if (ret < 0)
return ret;
- dev_info(dev->hw_dev, "comedi%d: das08_cs:\n", dev->minor);
+ dev_info(dev->class_dev, "das08_cs: attach\n");
/* deal with a pci board */
if (thisboard->bustype == pcmcia) {
if (link == NULL) {
- dev_err(dev->hw_dev, "no pcmcia cards found\n");
+ dev_err(dev->class_dev, "no pcmcia cards found\n");
return -EIO;
}
iobase = link->resource[0]->start;
} else {
- dev_err(dev->hw_dev, "bug! board does not have PCMCIA bustype\n");
+ dev_err(dev->class_dev,
+ "bug! board does not have PCMCIA bustype\n");
return -EINVAL;
}
volatile short timer_mode; /* true if using timer mode */
};
#define devpriv ((struct das16_private_struct *)(dev->private))
-#define thisboard ((struct das16_board *)(dev->board_ptr))
static int das16_cmd_test(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_cmd *cmd)
{
+ const struct das16_board *board = comedi_board(dev);
int err = 0, tmp;
int gain, start_chan, i;
int mask;
tmp = cmd->scan_begin_src;
mask = TRIG_FOLLOW;
/* if board supports burst mode */
- if (thisboard->size > 0x400)
+ if (board->size > 0x400)
mask |= TRIG_TIMER | TRIG_EXT;
cmd->scan_begin_src &= mask;
if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
tmp = cmd->convert_src;
mask = TRIG_TIMER | TRIG_EXT;
/* if board supports burst mode */
- if (thisboard->size > 0x400)
+ if (board->size > 0x400)
mask |= TRIG_NOW;
cmd->convert_src &= mask;
if (!cmd->convert_src || tmp != cmd->convert_src)
/* check against maximum frequency */
if (cmd->scan_begin_src == TRIG_TIMER) {
if (cmd->scan_begin_arg <
- thisboard->ai_speed * cmd->chanlist_len) {
+ board->ai_speed * cmd->chanlist_len) {
cmd->scan_begin_arg =
- thisboard->ai_speed * cmd->chanlist_len;
+ board->ai_speed * cmd->chanlist_len;
err++;
}
}
if (cmd->convert_src == TRIG_TIMER) {
- if (cmd->convert_arg < thisboard->ai_speed) {
- cmd->convert_arg = thisboard->ai_speed;
+ if (cmd->convert_arg < board->ai_speed) {
+ cmd->convert_arg = board->ai_speed;
err++;
}
}
static int das16_cmd_exec(struct comedi_device *dev, struct comedi_subdevice *s)
{
+ const struct das16_board *board = comedi_board(dev);
struct comedi_async *async = s->async;
struct comedi_cmd *cmd = &async->cmd;
unsigned int byte;
cmd->stop_arg * cmd->chanlist_len * sizeof(uint16_t);
/* disable conversions for das1600 mode */
- if (thisboard->size > 0x400)
+ if (board->size > 0x400)
outb(DAS1600_CONV_DISABLE, dev->iobase + DAS1600_CONV);
/* set scan limits */
/* set gain (this is also burst rate register but according to
* computer boards manual, burst rate does nothing, even on
* keithley cards) */
- if (thisboard->ai_pg != das16_pg_none) {
+ if (board->ai_pg != das16_pg_none) {
range = CR_RANGE(cmd->chanlist[0]);
- outb((das16_gainlists[thisboard->ai_pg])[range],
+ outb((das16_gainlists[board->ai_pg])[range],
dev->iobase + DAS16_GAIN);
}
/* enable counters */
byte = 0;
/* Enable burst mode if appropriate. */
- if (thisboard->size > 0x400) {
+ if (board->size > 0x400) {
if (cmd->convert_src == TRIG_NOW) {
outb(DAS1600_BURST_VAL, dev->iobase + DAS1600_BURST);
/* set burst length */
outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
/* Enable conversions if using das1600 mode */
- if (thisboard->size > 0x400)
+ if (board->size > 0x400)
outb(0, dev->iobase + DAS1600_CONV);
static int das16_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
{
+ const struct das16_board *board = comedi_board(dev);
unsigned long flags;
spin_lock_irqsave(&dev->spinlock, flags);
}
/* disable burst mode */
- if (thisboard->size > 0x400)
+ if (board->size > 0x400)
outb(0, dev->iobase + DAS1600_BURST);
static int das16_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ const struct das16_board *board = comedi_board(dev);
int i, n;
int range;
int chan;
outb(chan, dev->iobase + DAS16_MUX);
/* set gain */
- if (thisboard->ai_pg != das16_pg_none) {
+ if (board->ai_pg != das16_pg_none) {
range = CR_RANGE(insn->chanspec);
- outb((das16_gainlists[thisboard->ai_pg])[range],
+ outb((das16_gainlists[board->ai_pg])[range],
dev->iobase + DAS16_GAIN);
}
}
msb = inb(dev->iobase + DAS16_AI_MSB);
lsb = inb(dev->iobase + DAS16_AI_LSB);
- if (thisboard->ai_nbits == 12)
+ if (board->ai_nbits == 12)
data[n] = ((lsb >> 4) & 0xf) | (msb << 4);
else
data[n] = lsb | (msb << 8);
data[1] = bits;
data[0] = 0;
- return 2;
+ return insn->n;
}
static int das16_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
outb(s->state, dev->iobase + DAS16_DIO);
- return 2;
+ return insn->n;
}
static int das16_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ const struct das16_board *board = comedi_board(dev);
int i;
int lsb, msb;
int chan;
chan = CR_CHAN(insn->chanspec);
for (i = 0; i < insn->n; i++) {
- if (thisboard->ao_nbits == 12) {
+ if (board->ao_nbits == 12) {
lsb = (data[i] << 4) & 0xff;
msb = (data[i] >> 4) & 0xff;
} else {
static void das16_interrupt(struct comedi_device *dev)
{
+ const struct das16_board *board = comedi_board(dev);
unsigned long dma_flags, spin_flags;
struct comedi_subdevice *s = dev->read_subdev;
struct comedi_async *async;
set_dma_count(devpriv->dma_chan, devpriv->dma_transfer_size);
enable_dma(devpriv->dma_chan);
/* reenable conversions for das1600 mode, (stupid hardware) */
- if (thisboard->size > 0x400 && devpriv->timer_mode == 0)
+ if (board->size > 0x400 && devpriv->timer_mode == 0)
outb(0x00, dev->iobase + DAS1600_CONV);
}
static int das16_probe(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct das16_board *board = comedi_board(dev);
int status;
int diobits;
diobits = inb(dev->iobase + DAS16_DIO) & 0xf0;
printk(KERN_INFO " id bits are 0x%02x\n", diobits);
- if (thisboard->id != diobits) {
+ if (board->id != diobits) {
printk(KERN_INFO " requested board's id bits are 0x%x (ignore)\n",
- thisboard->id);
+ board->id);
}
return 0;
unsigned int num_bytes,
unsigned int start_chan_index)
{
+ const struct das16_board *board = comedi_board(dev);
unsigned int i, num_samples = num_bytes / sizeof(short);
short *data = array;
for (i = 0; i < num_samples; i++) {
data[i] = le16_to_cpu(data[i]);
- if (thisboard->ai_nbits == 12)
+ if (board->ai_nbits == 12)
data[i] = (data[i] >> 4) & 0xfff;
}
*/
static int das16_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct das16_board *board = comedi_board(dev);
struct comedi_subdevice *s;
int ret;
unsigned int irq;
if (ret < 0)
return ret;
- if (thisboard->size < 0x400) {
- printk(" 0x%04lx-0x%04lx\n", iobase, iobase + thisboard->size);
- if (!request_region(iobase, thisboard->size, "das16")) {
+ if (board->size < 0x400) {
+ printk(" 0x%04lx-0x%04lx\n", iobase, iobase + board->size);
+ if (!request_region(iobase, board->size, "das16")) {
printk(KERN_ERR " I/O port conflict\n");
return -EIO;
}
printk(KERN_INFO " 0x%04lx-0x%04lx 0x%04lx-0x%04lx\n",
iobase, iobase + 0x0f,
iobase + 0x400,
- iobase + 0x400 + (thisboard->size & 0x3ff));
+ iobase + 0x400 + (board->size & 0x3ff));
if (!request_region(iobase, 0x10, "das16")) {
printk(KERN_ERR " I/O port conflict: 0x%04lx-0x%04lx\n",
iobase, iobase + 0x0f);
return -EIO;
}
- if (!request_region(iobase + 0x400, thisboard->size & 0x3ff,
+ if (!request_region(iobase + 0x400, board->size & 0x3ff,
"das16")) {
release_region(iobase, 0x10);
printk(KERN_ERR " I/O port conflict: 0x%04lx-0x%04lx\n",
iobase + 0x400,
- iobase + 0x400 + (thisboard->size & 0x3ff));
+ iobase + 0x400 + (board->size & 0x3ff));
return -EIO;
}
}
printk(KERN_ERR " id bits do not match selected board, aborting\n");
return -EINVAL;
}
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
/* get master clock speed */
- if (thisboard->size < 0x400) {
+ if (board->size < 0x400) {
if (it->options[3])
devpriv->clockbase = 1000 / it->options[3];
else
}
/* get any user-defined input range */
- if (thisboard->ai_pg == das16_pg_none &&
+ if (board->ai_pg == das16_pg_none &&
(it->options[4] || it->options[5])) {
/* allocate single-range range table */
devpriv->user_ai_range_table =
}
devpriv->timer_mode = timer_mode ? 1 : 0;
- ret = alloc_subdevices(dev, 5);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 5);
+ if (ret)
return ret;
s = dev->subdevices + 0;
dev->read_subdev = s;
/* ai */
- if (thisboard->ai) {
+ if (board->ai) {
s->type = COMEDI_SUBD_AI;
s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
if (devpriv->ai_singleended) {
s->len_chanlist = 8;
s->subdev_flags |= SDF_DIFF;
}
- s->maxdata = (1 << thisboard->ai_nbits) - 1;
+ s->maxdata = (1 << board->ai_nbits) - 1;
if (devpriv->user_ai_range_table) { /* user defined ai range */
s->range_table = devpriv->user_ai_range_table;
} else if (devpriv->ai_unipolar) {
- s->range_table = das16_ai_uni_lranges[thisboard->ai_pg];
+ s->range_table = das16_ai_uni_lranges[board->ai_pg];
} else {
- s->range_table = das16_ai_bip_lranges[thisboard->ai_pg];
+ s->range_table = das16_ai_bip_lranges[board->ai_pg];
}
- s->insn_read = thisboard->ai;
+ s->insn_read = board->ai;
s->do_cmdtest = das16_cmd_test;
s->do_cmd = das16_cmd_exec;
s->cancel = das16_cancel;
s = dev->subdevices + 1;
/* ao */
- if (thisboard->ao) {
+ if (board->ao) {
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE;
s->n_chan = 2;
- s->maxdata = (1 << thisboard->ao_nbits) - 1;
+ s->maxdata = (1 << board->ao_nbits) - 1;
/* user defined ao range */
if (devpriv->user_ao_range_table)
s->range_table = devpriv->user_ao_range_table;
else
s->range_table = &range_unknown;
- s->insn_write = thisboard->ao;
+ s->insn_write = board->ao;
} else {
s->type = COMEDI_SUBD_UNUSED;
}
s = dev->subdevices + 2;
/* di */
- if (thisboard->di) {
+ if (board->di) {
s->type = COMEDI_SUBD_DI;
s->subdev_flags = SDF_READABLE;
s->n_chan = 4;
s->maxdata = 1;
s->range_table = &range_digital;
- s->insn_bits = thisboard->di;
+ s->insn_bits = board->di;
} else {
s->type = COMEDI_SUBD_UNUSED;
}
s = dev->subdevices + 3;
/* do */
- if (thisboard->do_) {
+ if (board->do_) {
s->type = COMEDI_SUBD_DO;
s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
s->n_chan = 4;
s->maxdata = 1;
s->range_table = &range_digital;
- s->insn_bits = thisboard->do_;
+ s->insn_bits = board->do_;
/* initialize digital output lines */
outb(s->state, dev->iobase + DAS16_DIO);
} else {
s = dev->subdevices + 4;
/* 8255 */
- if (thisboard->i8255_offset != 0) {
+ if (board->i8255_offset != 0) {
subdev_8255_init(dev, s, NULL, (dev->iobase +
- thisboard->i8255_offset));
+ board->i8255_offset));
} else {
s->type = COMEDI_SUBD_UNUSED;
}
outb(devpriv->control_state, dev->iobase + DAS16_CONTROL);
/* turn on das1600 mode if available */
- if (thisboard->size > 0x400) {
+ if (board->size > 0x400) {
outb(DAS1600_ENABLE_VAL, dev->iobase + DAS1600_ENABLE);
outb(0, dev->iobase + DAS1600_CONV);
outb(0, dev->iobase + DAS1600_BURST);
static void das16_detach(struct comedi_device *dev)
{
+ const struct das16_board *board = comedi_board(dev);
+
das16_reset(dev);
if (dev->subdevices)
subdev_8255_cleanup(dev, dev->subdevices + 4);
if (dev->irq)
free_irq(dev->irq, dev);
if (dev->iobase) {
- if (thisboard->size < 0x400) {
- release_region(dev->iobase, thisboard->size);
+ if (board->size < 0x400) {
+ release_region(dev->iobase, board->size);
} else {
release_region(dev->iobase, 0x10);
release_region(dev->iobase + 0x400,
- thisboard->size & 0x3ff);
+ board->size & 0x3ff);
}
}
}
unsigned int divisor2; /* divides master clock to obtain conversion speed */
};
#define devpriv ((struct das16m1_private_struct *)(dev->private))
-#define thisboard ((const struct das16m1_board *)(dev->board_ptr))
static inline short munge_sample(short data)
{
static int das16m1_cmd_test(struct comedi_device *dev,
struct comedi_subdevice *s, struct comedi_cmd *cmd)
{
+ const struct das16m1_board *board = comedi_board(dev);
unsigned int err = 0, tmp, i;
/* make sure triggers are valid */
}
if (cmd->convert_src == TRIG_TIMER) {
- if (cmd->convert_arg < thisboard->ai_speed) {
- cmd->convert_arg = thisboard->ai_speed;
+ if (cmd->convert_arg < board->ai_speed) {
+ cmd->convert_arg = board->ai_speed;
err++;
}
}
data[1] = bits;
data[0] = 0;
- return 2;
+ return insn->n;
}
static int das16m1_do_wbits(struct comedi_device *dev,
outb(devpriv->do_bits, dev->iobase + DAS16M1_DIO);
- return 2;
+ return insn->n;
}
static void das16m1_handler(struct comedi_device *dev, unsigned int status)
static int das16m1_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ const struct das16m1_board *board = comedi_board(dev);
struct comedi_subdevice *s;
int ret;
unsigned int irq;
if (ret < 0)
return ret;
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
if (!request_region(iobase, DAS16M1_SIZE, dev->driver->driver_name)) {
comedi_error(dev, "I/O port conflict\n");
return -EINVAL;
}
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
s = dev->subdevices + 0;
das1802hr, das1802hr_da, das1801hc, das1802hc, das1801ao, das1802ao
};
-static int das1800_probe(struct comedi_device *dev);
-static int das1800_cancel(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static irqreturn_t das1800_interrupt(int irq, void *d);
-static int das1800_ai_poll(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static void das1800_ai_handler(struct comedi_device *dev);
-static void das1800_handle_dma(struct comedi_device *dev,
- struct comedi_subdevice *s, unsigned int status);
-static void das1800_flush_dma(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static void das1800_flush_dma_channel(struct comedi_device *dev,
- struct comedi_subdevice *s,
- unsigned int channel, uint16_t *buffer);
-static void das1800_handle_fifo_half_full(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static void das1800_handle_fifo_not_empty(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static int das1800_ai_do_cmdtest(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_cmd *cmd);
-static int das1800_ai_do_cmd(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static int das1800_ai_rinsn(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das1800_ao_winsn(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das1800_di_rbits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int das1800_do_wbits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-
-static int das1800_set_frequency(struct comedi_device *dev);
-static unsigned int burst_convert_arg(unsigned int convert_arg, int round_mode);
-static unsigned int suggest_transfer_size(struct comedi_cmd *cmd);
-
/* analog input ranges */
static const struct comedi_lrange range_ai_das1801 = {
8,
};
*/
-static int das1800_init_dma(struct comedi_device *dev, unsigned int dma0,
- unsigned int dma1)
+static inline uint16_t munge_bipolar_sample(const struct comedi_device *dev,
+ uint16_t sample)
{
- unsigned long flags;
+ sample += 1 << (thisboard->resolution - 1);
+ return sample;
+}
- /* need an irq to do dma */
- if (dev->irq && dma0) {
- /* encode dma0 and dma1 into 2 digit hexadecimal for switch */
- switch ((dma0 & 0x7) | (dma1 << 4)) {
- case 0x5: /* dma0 == 5 */
- devpriv->dma_bits |= DMA_CH5;
- break;
- case 0x6: /* dma0 == 6 */
- devpriv->dma_bits |= DMA_CH6;
- break;
- case 0x7: /* dma0 == 7 */
- devpriv->dma_bits |= DMA_CH7;
- break;
- case 0x65: /* dma0 == 5, dma1 == 6 */
- devpriv->dma_bits |= DMA_CH5_CH6;
- break;
- case 0x76: /* dma0 == 6, dma1 == 7 */
- devpriv->dma_bits |= DMA_CH6_CH7;
- break;
- case 0x57: /* dma0 == 7, dma1 == 5 */
- devpriv->dma_bits |= DMA_CH7_CH5;
- break;
- default:
- dev_err(dev->hw_dev, " only supports dma channels 5 through 7\n"
- " Dual dma only allows the following combinations:\n"
- " dma 5,6 / 6,7 / or 7,5\n");
- return -EINVAL;
- break;
- }
- if (request_dma(dma0, dev->driver->driver_name)) {
- dev_err(dev->hw_dev, "failed to allocate dma channel %i\n",
- dma0);
- return -EINVAL;
- }
- devpriv->dma0 = dma0;
- devpriv->dma_current = dma0;
- if (dma1) {
- if (request_dma(dma1, dev->driver->driver_name)) {
- dev_err(dev->hw_dev, "failed to allocate dma channel %i\n",
- dma1);
- return -EINVAL;
- }
- devpriv->dma1 = dma1;
- }
- devpriv->ai_buf0 = kmalloc(DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA);
- if (devpriv->ai_buf0 == NULL)
- return -ENOMEM;
- devpriv->dma_current_buf = devpriv->ai_buf0;
- if (dma1) {
- devpriv->ai_buf1 =
- kmalloc(DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA);
- if (devpriv->ai_buf1 == NULL)
- return -ENOMEM;
- }
- flags = claim_dma_lock();
- disable_dma(devpriv->dma0);
- set_dma_mode(devpriv->dma0, DMA_MODE_READ);
- if (dma1) {
- disable_dma(devpriv->dma1);
- set_dma_mode(devpriv->dma1, DMA_MODE_READ);
- }
- release_dma_lock(flags);
+static void munge_data(struct comedi_device *dev, uint16_t * array,
+ unsigned int num_elements)
+{
+ unsigned int i;
+ int unipolar;
+
+ /* see if card is using a unipolar or bipolar range so we can munge data correctly */
+ unipolar = inb(dev->iobase + DAS1800_CONTROL_C) & UB;
+
+ /* convert to unsigned type if we are in a bipolar mode */
+ if (!unipolar) {
+ for (i = 0; i < num_elements; i++)
+ array[i] = munge_bipolar_sample(dev, array[i]);
}
- return 0;
}
-static int das1800_attach(struct comedi_device *dev,
- struct comedi_devconfig *it)
+static void das1800_handle_fifo_half_full(struct comedi_device *dev,
+ struct comedi_subdevice *s)
{
- struct comedi_subdevice *s;
- unsigned long iobase = it->options[0];
- unsigned int irq = it->options[1];
- unsigned int dma0 = it->options[2];
- unsigned int dma1 = it->options[3];
- unsigned long iobase2;
- int board;
- int retval;
+ int numPoints = 0; /* number of points to read */
+ struct comedi_cmd *cmd = &s->async->cmd;
- /* allocate and initialize dev->private */
- if (alloc_private(dev, sizeof(struct das1800_private)) < 0)
- return -ENOMEM;
+ numPoints = FIFO_SIZE / 2;
+ /* if we only need some of the points */
+ if (cmd->stop_src == TRIG_COUNT && devpriv->count < numPoints)
+ numPoints = devpriv->count;
+ insw(dev->iobase + DAS1800_FIFO, devpriv->ai_buf0, numPoints);
+ munge_data(dev, devpriv->ai_buf0, numPoints);
+ cfc_write_array_to_buffer(s, devpriv->ai_buf0,
+ numPoints * sizeof(devpriv->ai_buf0[0]));
+ if (cmd->stop_src == TRIG_COUNT)
+ devpriv->count -= numPoints;
+ return;
+}
- printk(KERN_DEBUG "comedi%d: %s: io 0x%lx", dev->minor,
- dev->driver->driver_name, iobase);
- if (irq) {
- printk(KERN_CONT ", irq %u", irq);
- if (dma0) {
- printk(KERN_CONT ", dma %u", dma0);
- if (dma1)
- printk(KERN_CONT " and %u", dma1);
- }
- }
- printk(KERN_CONT "\n");
+static void das1800_handle_fifo_not_empty(struct comedi_device *dev,
+ struct comedi_subdevice *s)
+{
+ short dpnt;
+ int unipolar;
+ struct comedi_cmd *cmd = &s->async->cmd;
- if (iobase == 0) {
- dev_err(dev->hw_dev, "io base address required\n");
- return -EINVAL;
- }
+ unipolar = inb(dev->iobase + DAS1800_CONTROL_C) & UB;
- /* check if io addresses are available */
- if (!request_region(iobase, DAS1800_SIZE, dev->driver->driver_name)) {
- printk
- (" I/O port conflict: failed to allocate ports 0x%lx to 0x%lx\n",
- iobase, iobase + DAS1800_SIZE - 1);
- return -EIO;
+ while (inb(dev->iobase + DAS1800_STATUS) & FNE) {
+ if (cmd->stop_src == TRIG_COUNT && devpriv->count == 0)
+ break;
+ dpnt = inw(dev->iobase + DAS1800_FIFO);
+ /* convert to unsigned type if we are in a bipolar mode */
+ if (!unipolar)
+ ;
+ dpnt = munge_bipolar_sample(dev, dpnt);
+ cfc_write_to_buffer(s, dpnt);
+ if (cmd->stop_src == TRIG_COUNT)
+ devpriv->count--;
}
- dev->iobase = iobase;
- board = das1800_probe(dev);
- if (board < 0) {
- dev_err(dev->hw_dev, "unable to determine board type\n");
- return -ENODEV;
- }
+ return;
+}
- dev->board_ptr = das1800_boards + board;
- dev->board_name = thisboard->name;
+/* Utility function used by das1800_flush_dma() and das1800_handle_dma().
+ * Assumes dma lock is held */
+static void das1800_flush_dma_channel(struct comedi_device *dev,
+ struct comedi_subdevice *s,
+ unsigned int channel, uint16_t *buffer)
+{
+ unsigned int num_bytes, num_samples;
+ struct comedi_cmd *cmd = &s->async->cmd;
- /* if it is an 'ao' board with fancy analog out then we need extra io ports */
- if (thisboard->ao_ability == 2) {
- iobase2 = iobase + IOBASE2;
- if (!request_region(iobase2, DAS1800_SIZE,
- dev->driver->driver_name)) {
- printk
- (" I/O port conflict: failed to allocate ports 0x%lx to 0x%lx\n",
- iobase2, iobase2 + DAS1800_SIZE - 1);
- return -EIO;
- }
- devpriv->iobase2 = iobase2;
- }
+ disable_dma(channel);
- /* grab our IRQ */
- if (irq) {
- if (request_irq(irq, das1800_interrupt, 0,
- dev->driver->driver_name, dev)) {
- dev_dbg(dev->hw_dev, "unable to allocate irq %u\n",
- irq);
- return -EINVAL;
- }
- }
- dev->irq = irq;
+ /* clear flip-flop to make sure 2-byte registers
+ * get set correctly */
+ clear_dma_ff(channel);
- /* set bits that tell card which irq to use */
- switch (irq) {
- case 0:
- break;
- case 3:
- devpriv->irq_dma_bits |= 0x8;
- break;
- case 5:
- devpriv->irq_dma_bits |= 0x10;
- break;
- case 7:
- devpriv->irq_dma_bits |= 0x18;
- break;
- case 10:
- devpriv->irq_dma_bits |= 0x28;
- break;
- case 11:
- devpriv->irq_dma_bits |= 0x30;
- break;
- case 15:
- devpriv->irq_dma_bits |= 0x38;
- break;
- default:
- dev_err(dev->hw_dev, "irq out of range\n");
- return -EINVAL;
- break;
- }
+ /* figure out how many points to read */
+ num_bytes = devpriv->dma_transfer_size - get_dma_residue(channel);
+ num_samples = num_bytes / sizeof(short);
- retval = das1800_init_dma(dev, dma0, dma1);
- if (retval < 0)
- return retval;
+ /* if we only need some of the points */
+ if (cmd->stop_src == TRIG_COUNT && devpriv->count < num_samples)
+ num_samples = devpriv->count;
- if (devpriv->ai_buf0 == NULL) {
- devpriv->ai_buf0 =
- kmalloc(FIFO_SIZE * sizeof(uint16_t), GFP_KERNEL);
- if (devpriv->ai_buf0 == NULL)
- return -ENOMEM;
- }
+ munge_data(dev, buffer, num_samples);
+ cfc_write_array_to_buffer(s, buffer, num_bytes);
+ if (s->async->cmd.stop_src == TRIG_COUNT)
+ devpriv->count -= num_samples;
- if (alloc_subdevices(dev, 4) < 0)
- return -ENOMEM;
+ return;
+}
- /* analog input subdevice */
- s = dev->subdevices + 0;
- dev->read_subdev = s;
- s->type = COMEDI_SUBD_AI;
- s->subdev_flags = SDF_READABLE | SDF_DIFF | SDF_GROUND | SDF_CMD_READ;
- if (thisboard->common)
- s->subdev_flags |= SDF_COMMON;
- s->n_chan = thisboard->qram_len;
- s->len_chanlist = thisboard->qram_len;
- s->maxdata = (1 << thisboard->resolution) - 1;
- s->range_table = thisboard->range_ai;
- s->do_cmd = das1800_ai_do_cmd;
- s->do_cmdtest = das1800_ai_do_cmdtest;
- s->insn_read = das1800_ai_rinsn;
- s->poll = das1800_ai_poll;
- s->cancel = das1800_cancel;
-
- /* analog out */
- s = dev->subdevices + 1;
- if (thisboard->ao_ability == 1) {
- s->type = COMEDI_SUBD_AO;
- s->subdev_flags = SDF_WRITABLE;
- s->n_chan = thisboard->ao_n_chan;
- s->maxdata = (1 << thisboard->resolution) - 1;
- s->range_table = &range_ao_1;
- s->insn_write = das1800_ao_winsn;
- } else {
- s->type = COMEDI_SUBD_UNUSED;
- }
-
- /* di */
- s = dev->subdevices + 2;
- s->type = COMEDI_SUBD_DI;
- s->subdev_flags = SDF_READABLE;
- s->n_chan = 4;
- s->maxdata = 1;
- s->range_table = &range_digital;
- s->insn_bits = das1800_di_rbits;
-
- /* do */
- s = dev->subdevices + 3;
- s->type = COMEDI_SUBD_DO;
- s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
- s->n_chan = thisboard->do_n_chan;
- s->maxdata = 1;
- s->range_table = &range_digital;
- s->insn_bits = das1800_do_wbits;
-
- das1800_cancel(dev, dev->read_subdev);
-
- /* initialize digital out channels */
- outb(devpriv->do_bits, dev->iobase + DAS1800_DIGITAL);
-
- /* initialize analog out channels */
- if (thisboard->ao_ability == 1) {
- /* select 'update' dac channel for baseAddress + 0x0 */
- outb(DAC(thisboard->ao_n_chan - 1),
- dev->iobase + DAS1800_SELECT);
- outw(devpriv->ao_update_bits, dev->iobase + DAS1800_DAC);
- }
-
- return 0;
-};
-
-static void das1800_detach(struct comedi_device *dev)
-{
- if (dev->iobase)
- release_region(dev->iobase, DAS1800_SIZE);
- if (dev->irq)
- free_irq(dev->irq, dev);
- if (dev->private) {
- if (devpriv->iobase2)
- release_region(devpriv->iobase2, DAS1800_SIZE);
- if (devpriv->dma0)
- free_dma(devpriv->dma0);
- if (devpriv->dma1)
- free_dma(devpriv->dma1);
- kfree(devpriv->ai_buf0);
- kfree(devpriv->ai_buf1);
- }
-};
-
-/* probes and checks das-1800 series board type
- */
-static int das1800_probe(struct comedi_device *dev)
+/* flushes remaining data from board when external trigger has stopped acquisition
+ * and we are using dma transfers */
+static void das1800_flush_dma(struct comedi_device *dev,
+ struct comedi_subdevice *s)
{
- int id;
- int board;
+ unsigned long flags;
+ const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
- id = (inb(dev->iobase + DAS1800_DIGITAL) >> 4) & 0xf; /* get id bits */
- board = ((struct das1800_board *)dev->board_ptr) - das1800_boards;
+ flags = claim_dma_lock();
+ das1800_flush_dma_channel(dev, s, devpriv->dma_current,
+ devpriv->dma_current_buf);
- switch (id) {
- case 0x3:
- if (board == das1801st_da || board == das1802st_da ||
- board == das1701st_da || board == das1702st_da) {
- dev_dbg(dev->hw_dev, "Board model: %s\n",
- das1800_boards[board].name);
- return board;
- }
- printk
- (" Board model (probed, not recommended): das-1800st-da series\n");
- return das1801st;
- break;
- case 0x4:
- if (board == das1802hr_da || board == das1702hr_da) {
- dev_dbg(dev->hw_dev, "Board model: %s\n",
- das1800_boards[board].name);
- return board;
- }
- printk
- (" Board model (probed, not recommended): das-1802hr-da\n");
- return das1802hr;
- break;
- case 0x5:
- if (board == das1801ao || board == das1802ao ||
- board == das1701ao || board == das1702ao) {
- dev_dbg(dev->hw_dev, "Board model: %s\n",
- das1800_boards[board].name);
- return board;
- }
- printk
- (" Board model (probed, not recommended): das-1800ao series\n");
- return das1801ao;
- break;
- case 0x6:
- if (board == das1802hr || board == das1702hr) {
- dev_dbg(dev->hw_dev, "Board model: %s\n",
- das1800_boards[board].name);
- return board;
- }
- printk
- (" Board model (probed, not recommended): das-1802hr\n");
- return das1802hr;
- break;
- case 0x7:
- if (board == das1801st || board == das1802st ||
- board == das1701st || board == das1702st) {
- dev_dbg(dev->hw_dev, "Board model: %s\n",
- das1800_boards[board].name);
- return board;
- }
- printk
- (" Board model (probed, not recommended): das-1800st series\n");
- return das1801st;
- break;
- case 0x8:
- if (board == das1801hc || board == das1802hc) {
- dev_dbg(dev->hw_dev, "Board model: %s\n",
- das1800_boards[board].name);
- return board;
+ if (dual_dma) {
+ /* switch to other channel and flush it */
+ if (devpriv->dma_current == devpriv->dma0) {
+ devpriv->dma_current = devpriv->dma1;
+ devpriv->dma_current_buf = devpriv->ai_buf1;
+ } else {
+ devpriv->dma_current = devpriv->dma0;
+ devpriv->dma_current_buf = devpriv->ai_buf0;
}
- printk
- (" Board model (probed, not recommended): das-1800hc series\n");
- return das1801hc;
- break;
- default:
- printk
- (" Board model: probe returned 0x%x (unknown, please report)\n",
- id);
- return board;
- break;
+ das1800_flush_dma_channel(dev, s, devpriv->dma_current,
+ devpriv->dma_current_buf);
}
- return -1;
-}
-static int das1800_ai_poll(struct comedi_device *dev,
- struct comedi_subdevice *s)
-{
- unsigned long flags;
+ release_dma_lock(flags);
- /* prevent race with interrupt handler */
- spin_lock_irqsave(&dev->spinlock, flags);
- das1800_ai_handler(dev);
- spin_unlock_irqrestore(&dev->spinlock, flags);
+ /* get any remaining samples in fifo */
+ das1800_handle_fifo_not_empty(dev, s);
- return s->async->buf_write_count - s->async->buf_read_count;
+ return;
}
-static irqreturn_t das1800_interrupt(int irq, void *d)
+static void das1800_handle_dma(struct comedi_device *dev,
+ struct comedi_subdevice *s, unsigned int status)
{
- struct comedi_device *dev = d;
- unsigned int status;
-
- if (dev->attached == 0) {
- comedi_error(dev, "premature interrupt");
- return IRQ_HANDLED;
- }
+ unsigned long flags;
+ const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
- /* Prevent race with das1800_ai_poll() on multi processor systems.
- * Also protects indirect addressing in das1800_ai_handler */
- spin_lock(&dev->spinlock);
- status = inb(dev->iobase + DAS1800_STATUS);
+ flags = claim_dma_lock();
+ das1800_flush_dma_channel(dev, s, devpriv->dma_current,
+ devpriv->dma_current_buf);
+ /* re-enable dma channel */
+ set_dma_addr(devpriv->dma_current,
+ virt_to_bus(devpriv->dma_current_buf));
+ set_dma_count(devpriv->dma_current, devpriv->dma_transfer_size);
+ enable_dma(devpriv->dma_current);
+ release_dma_lock(flags);
- /* if interrupt was not caused by das-1800 */
- if (!(status & INT)) {
- spin_unlock(&dev->spinlock);
- return IRQ_NONE;
+ if (status & DMATC) {
+ /* clear DMATC interrupt bit */
+ outb(CLEAR_INTR_MASK & ~DMATC, dev->iobase + DAS1800_STATUS);
+ /* switch dma channels for next time, if appropriate */
+ if (dual_dma) {
+ /* read data from the other channel next time */
+ if (devpriv->dma_current == devpriv->dma0) {
+ devpriv->dma_current = devpriv->dma1;
+ devpriv->dma_current_buf = devpriv->ai_buf1;
+ } else {
+ devpriv->dma_current = devpriv->dma0;
+ devpriv->dma_current_buf = devpriv->ai_buf0;
+ }
+ }
}
- /* clear the interrupt status bit INT */
- outb(CLEAR_INTR_MASK & ~INT, dev->iobase + DAS1800_STATUS);
- /* handle interrupt */
- das1800_ai_handler(dev);
- spin_unlock(&dev->spinlock);
- return IRQ_HANDLED;
+ return;
+}
+
+static int das1800_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
+{
+ outb(0x0, dev->iobase + DAS1800_STATUS); /* disable conversions */
+ outb(0x0, dev->iobase + DAS1800_CONTROL_B); /* disable interrupts and dma */
+ outb(0x0, dev->iobase + DAS1800_CONTROL_A); /* disable and clear fifo and stop triggering */
+ if (devpriv->dma0)
+ disable_dma(devpriv->dma0);
+ if (devpriv->dma1)
+ disable_dma(devpriv->dma1);
+ return 0;
}
/* the guts of the interrupt handler, that is shared with das1800_ai_poll */
return;
}
-static void das1800_handle_dma(struct comedi_device *dev,
- struct comedi_subdevice *s, unsigned int status)
+static int das1800_ai_poll(struct comedi_device *dev,
+ struct comedi_subdevice *s)
{
unsigned long flags;
- const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
- flags = claim_dma_lock();
- das1800_flush_dma_channel(dev, s, devpriv->dma_current,
- devpriv->dma_current_buf);
- /* re-enable dma channel */
- set_dma_addr(devpriv->dma_current,
- virt_to_bus(devpriv->dma_current_buf));
- set_dma_count(devpriv->dma_current, devpriv->dma_transfer_size);
- enable_dma(devpriv->dma_current);
- release_dma_lock(flags);
-
- if (status & DMATC) {
- /* clear DMATC interrupt bit */
- outb(CLEAR_INTR_MASK & ~DMATC, dev->iobase + DAS1800_STATUS);
- /* switch dma channels for next time, if appropriate */
- if (dual_dma) {
- /* read data from the other channel next time */
- if (devpriv->dma_current == devpriv->dma0) {
- devpriv->dma_current = devpriv->dma1;
- devpriv->dma_current_buf = devpriv->ai_buf1;
- } else {
- devpriv->dma_current = devpriv->dma0;
- devpriv->dma_current_buf = devpriv->ai_buf0;
- }
- }
- }
-
- return;
-}
+ /* prevent race with interrupt handler */
+ spin_lock_irqsave(&dev->spinlock, flags);
+ das1800_ai_handler(dev);
+ spin_unlock_irqrestore(&dev->spinlock, flags);
-static inline uint16_t munge_bipolar_sample(const struct comedi_device *dev,
- uint16_t sample)
-{
- sample += 1 << (thisboard->resolution - 1);
- return sample;
+ return s->async->buf_write_count - s->async->buf_read_count;
}
-static void munge_data(struct comedi_device *dev, uint16_t * array,
- unsigned int num_elements)
+static irqreturn_t das1800_interrupt(int irq, void *d)
{
- unsigned int i;
- int unipolar;
-
- /* see if card is using a unipolar or bipolar range so we can munge data correctly */
- unipolar = inb(dev->iobase + DAS1800_CONTROL_C) & UB;
+ struct comedi_device *dev = d;
+ unsigned int status;
- /* convert to unsigned type if we are in a bipolar mode */
- if (!unipolar) {
- for (i = 0; i < num_elements; i++)
- array[i] = munge_bipolar_sample(dev, array[i]);
+ if (dev->attached == 0) {
+ comedi_error(dev, "premature interrupt");
+ return IRQ_HANDLED;
}
-}
-
-/* Utility function used by das1800_flush_dma() and das1800_handle_dma().
- * Assumes dma lock is held */
-static void das1800_flush_dma_channel(struct comedi_device *dev,
- struct comedi_subdevice *s,
- unsigned int channel, uint16_t *buffer)
-{
- unsigned int num_bytes, num_samples;
- struct comedi_cmd *cmd = &s->async->cmd;
-
- disable_dma(channel);
-
- /* clear flip-flop to make sure 2-byte registers
- * get set correctly */
- clear_dma_ff(channel);
-
- /* figure out how many points to read */
- num_bytes = devpriv->dma_transfer_size - get_dma_residue(channel);
- num_samples = num_bytes / sizeof(short);
-
- /* if we only need some of the points */
- if (cmd->stop_src == TRIG_COUNT && devpriv->count < num_samples)
- num_samples = devpriv->count;
-
- munge_data(dev, buffer, num_samples);
- cfc_write_array_to_buffer(s, buffer, num_bytes);
- if (s->async->cmd.stop_src == TRIG_COUNT)
- devpriv->count -= num_samples;
-
- return;
-}
-
-/* flushes remaining data from board when external trigger has stopped acquisition
- * and we are using dma transfers */
-static void das1800_flush_dma(struct comedi_device *dev,
- struct comedi_subdevice *s)
-{
- unsigned long flags;
- const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
- flags = claim_dma_lock();
- das1800_flush_dma_channel(dev, s, devpriv->dma_current,
- devpriv->dma_current_buf);
+ /* Prevent race with das1800_ai_poll() on multi processor systems.
+ * Also protects indirect addressing in das1800_ai_handler */
+ spin_lock(&dev->spinlock);
+ status = inb(dev->iobase + DAS1800_STATUS);
- if (dual_dma) {
- /* switch to other channel and flush it */
- if (devpriv->dma_current == devpriv->dma0) {
- devpriv->dma_current = devpriv->dma1;
- devpriv->dma_current_buf = devpriv->ai_buf1;
- } else {
- devpriv->dma_current = devpriv->dma0;
- devpriv->dma_current_buf = devpriv->ai_buf0;
- }
- das1800_flush_dma_channel(dev, s, devpriv->dma_current,
- devpriv->dma_current_buf);
+ /* if interrupt was not caused by das-1800 */
+ if (!(status & INT)) {
+ spin_unlock(&dev->spinlock);
+ return IRQ_NONE;
}
+ /* clear the interrupt status bit INT */
+ outb(CLEAR_INTR_MASK & ~INT, dev->iobase + DAS1800_STATUS);
+ /* handle interrupt */
+ das1800_ai_handler(dev);
- release_dma_lock(flags);
-
- /* get any remaining samples in fifo */
- das1800_handle_fifo_not_empty(dev, s);
-
- return;
-}
-
-static void das1800_handle_fifo_half_full(struct comedi_device *dev,
- struct comedi_subdevice *s)
-{
- int numPoints = 0; /* number of points to read */
- struct comedi_cmd *cmd = &s->async->cmd;
-
- numPoints = FIFO_SIZE / 2;
- /* if we only need some of the points */
- if (cmd->stop_src == TRIG_COUNT && devpriv->count < numPoints)
- numPoints = devpriv->count;
- insw(dev->iobase + DAS1800_FIFO, devpriv->ai_buf0, numPoints);
- munge_data(dev, devpriv->ai_buf0, numPoints);
- cfc_write_array_to_buffer(s, devpriv->ai_buf0,
- numPoints * sizeof(devpriv->ai_buf0[0]));
- if (cmd->stop_src == TRIG_COUNT)
- devpriv->count -= numPoints;
- return;
+ spin_unlock(&dev->spinlock);
+ return IRQ_HANDLED;
}
-static void das1800_handle_fifo_not_empty(struct comedi_device *dev,
- struct comedi_subdevice *s)
+/* converts requested conversion timing to timing compatible with
+ * hardware, used only when card is in 'burst mode'
+ */
+static unsigned int burst_convert_arg(unsigned int convert_arg, int round_mode)
{
- short dpnt;
- int unipolar;
- struct comedi_cmd *cmd = &s->async->cmd;
+ unsigned int micro_sec;
- unipolar = inb(dev->iobase + DAS1800_CONTROL_C) & UB;
+ /* in burst mode, the maximum conversion time is 64 microseconds */
+ if (convert_arg > 64000)
+ convert_arg = 64000;
- while (inb(dev->iobase + DAS1800_STATUS) & FNE) {
- if (cmd->stop_src == TRIG_COUNT && devpriv->count == 0)
- break;
- dpnt = inw(dev->iobase + DAS1800_FIFO);
- /* convert to unsigned type if we are in a bipolar mode */
- if (!unipolar)
- ;
- dpnt = munge_bipolar_sample(dev, dpnt);
- cfc_write_to_buffer(s, dpnt);
- if (cmd->stop_src == TRIG_COUNT)
- devpriv->count--;
+ /* the conversion time must be an integral number of microseconds */
+ switch (round_mode) {
+ case TRIG_ROUND_NEAREST:
+ default:
+ micro_sec = (convert_arg + 500) / 1000;
+ break;
+ case TRIG_ROUND_DOWN:
+ micro_sec = convert_arg / 1000;
+ break;
+ case TRIG_ROUND_UP:
+ micro_sec = (convert_arg - 1) / 1000 + 1;
+ break;
}
- return;
-}
-
-static int das1800_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
-{
- outb(0x0, dev->iobase + DAS1800_STATUS); /* disable conversions */
- outb(0x0, dev->iobase + DAS1800_CONTROL_B); /* disable interrupts and dma */
- outb(0x0, dev->iobase + DAS1800_CONTROL_A); /* disable and clear fifo and stop triggering */
- if (devpriv->dma0)
- disable_dma(devpriv->dma0);
- if (devpriv->dma1)
- disable_dma(devpriv->dma1);
- return 0;
+ /* return number of nanoseconds */
+ return micro_sec * 1000;
}
/* test analog input cmd */
return 0;
}
-/* analog input cmd interface */
-
-/* first, some utility functions used in the main ai_do_cmd() */
-
/* returns appropriate bits for control register a, depending on command */
static int control_a_bits(struct comedi_cmd cmd)
{
return control_c;
}
+/* loads counters with divisor1, divisor2 from private structure */
+static int das1800_set_frequency(struct comedi_device *dev)
+{
+ int err = 0;
+
+ /* counter 1, mode 2 */
+ if (i8254_load(dev->iobase + DAS1800_COUNTER, 0, 1, devpriv->divisor1,
+ 2))
+ err++;
+ /* counter 2, mode 2 */
+ if (i8254_load(dev->iobase + DAS1800_COUNTER, 0, 2, devpriv->divisor2,
+ 2))
+ err++;
+ if (err)
+ return -1;
+
+ return 0;
+}
+
/* sets up counters */
static int setup_counters(struct comedi_device *dev, struct comedi_cmd cmd)
{
return 0;
}
+/* utility function that suggests a dma transfer size based on the conversion period 'ns' */
+static unsigned int suggest_transfer_size(struct comedi_cmd *cmd)
+{
+ unsigned int size = DMA_BUF_SIZE;
+ static const int sample_size = 2; /* size in bytes of one sample from board */
+ unsigned int fill_time = 300000000; /* target time in nanoseconds for filling dma buffer */
+ unsigned int max_size; /* maximum size we will allow for a transfer */
+
+ /* make dma buffer fill in 0.3 seconds for timed modes */
+ switch (cmd->scan_begin_src) {
+ case TRIG_FOLLOW: /* not in burst mode */
+ if (cmd->convert_src == TRIG_TIMER)
+ size = (fill_time / cmd->convert_arg) * sample_size;
+ break;
+ case TRIG_TIMER:
+ size = (fill_time / (cmd->scan_begin_arg * cmd->chanlist_len)) *
+ sample_size;
+ break;
+ default:
+ size = DMA_BUF_SIZE;
+ break;
+ }
+
+ /* set a minimum and maximum size allowed */
+ max_size = DMA_BUF_SIZE;
+ /* if we are taking limited number of conversions, limit transfer size to that */
+ if (cmd->stop_src == TRIG_COUNT &&
+ cmd->stop_arg * cmd->chanlist_len * sample_size < max_size)
+ max_size = cmd->stop_arg * cmd->chanlist_len * sample_size;
+
+ if (size > max_size)
+ size = max_size;
+ if (size < sample_size)
+ size = sample_size;
+
+ return size;
+}
+
/* sets up dma */
static void setup_dma(struct comedi_device *dev, struct comedi_cmd cmd)
{
data[1] = inb(dev->iobase + DAS1800_DIGITAL) & 0xf;
data[0] = 0;
- return 2;
+ return insn->n;
}
/* writes to digital output channels */
data[1] = devpriv->do_bits;
- return 2;
+ return insn->n;
}
-/* loads counters with divisor1, divisor2 from private structure */
-static int das1800_set_frequency(struct comedi_device *dev)
+static int das1800_init_dma(struct comedi_device *dev, unsigned int dma0,
+ unsigned int dma1)
{
- int err = 0;
-
- /* counter 1, mode 2 */
- if (i8254_load(dev->iobase + DAS1800_COUNTER, 0, 1, devpriv->divisor1,
- 2))
- err++;
- /* counter 2, mode 2 */
- if (i8254_load(dev->iobase + DAS1800_COUNTER, 0, 2, devpriv->divisor2,
- 2))
- err++;
- if (err)
- return -1;
+ unsigned long flags;
+ /* need an irq to do dma */
+ if (dev->irq && dma0) {
+ /* encode dma0 and dma1 into 2 digit hexadecimal for switch */
+ switch ((dma0 & 0x7) | (dma1 << 4)) {
+ case 0x5: /* dma0 == 5 */
+ devpriv->dma_bits |= DMA_CH5;
+ break;
+ case 0x6: /* dma0 == 6 */
+ devpriv->dma_bits |= DMA_CH6;
+ break;
+ case 0x7: /* dma0 == 7 */
+ devpriv->dma_bits |= DMA_CH7;
+ break;
+ case 0x65: /* dma0 == 5, dma1 == 6 */
+ devpriv->dma_bits |= DMA_CH5_CH6;
+ break;
+ case 0x76: /* dma0 == 6, dma1 == 7 */
+ devpriv->dma_bits |= DMA_CH6_CH7;
+ break;
+ case 0x57: /* dma0 == 7, dma1 == 5 */
+ devpriv->dma_bits |= DMA_CH7_CH5;
+ break;
+ default:
+ dev_err(dev->class_dev,
+ "only supports dma channels 5 through 7\n");
+ dev_err(dev->class_dev,
+ "Dual dma only allows the following combinations:\n");
+ dev_err(dev->class_dev,
+ "dma 5,6 / 6,7 / or 7,5\n");
+ return -EINVAL;
+ break;
+ }
+ if (request_dma(dma0, dev->driver->driver_name)) {
+ dev_err(dev->class_dev,
+ "failed to allocate dma channel %i\n", dma0);
+ return -EINVAL;
+ }
+ devpriv->dma0 = dma0;
+ devpriv->dma_current = dma0;
+ if (dma1) {
+ if (request_dma(dma1, dev->driver->driver_name)) {
+ dev_err(dev->class_dev,
+ "failed to allocate dma channel %i\n",
+ dma1);
+ return -EINVAL;
+ }
+ devpriv->dma1 = dma1;
+ }
+ devpriv->ai_buf0 = kmalloc(DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA);
+ if (devpriv->ai_buf0 == NULL)
+ return -ENOMEM;
+ devpriv->dma_current_buf = devpriv->ai_buf0;
+ if (dma1) {
+ devpriv->ai_buf1 =
+ kmalloc(DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA);
+ if (devpriv->ai_buf1 == NULL)
+ return -ENOMEM;
+ }
+ flags = claim_dma_lock();
+ disable_dma(devpriv->dma0);
+ set_dma_mode(devpriv->dma0, DMA_MODE_READ);
+ if (dma1) {
+ disable_dma(devpriv->dma1);
+ set_dma_mode(devpriv->dma1, DMA_MODE_READ);
+ }
+ release_dma_lock(flags);
+ }
return 0;
}
-/* converts requested conversion timing to timing compatible with
- * hardware, used only when card is in 'burst mode'
- */
-static unsigned int burst_convert_arg(unsigned int convert_arg, int round_mode)
+static int das1800_probe(struct comedi_device *dev)
{
- unsigned int micro_sec;
+ int id;
+ int board;
- /* in burst mode, the maximum conversion time is 64 microseconds */
- if (convert_arg > 64000)
- convert_arg = 64000;
+ id = (inb(dev->iobase + DAS1800_DIGITAL) >> 4) & 0xf; /* get id bits */
+ board = ((struct das1800_board *)dev->board_ptr) - das1800_boards;
- /* the conversion time must be an integral number of microseconds */
- switch (round_mode) {
- case TRIG_ROUND_NEAREST:
- default:
- micro_sec = (convert_arg + 500) / 1000;
+ switch (id) {
+ case 0x3:
+ if (board == das1801st_da || board == das1802st_da ||
+ board == das1701st_da || board == das1702st_da) {
+ dev_dbg(dev->class_dev, "Board model: %s\n",
+ das1800_boards[board].name);
+ return board;
+ }
+ printk
+ (" Board model (probed, not recommended): das-1800st-da series\n");
+ return das1801st;
break;
- case TRIG_ROUND_DOWN:
- micro_sec = convert_arg / 1000;
+ case 0x4:
+ if (board == das1802hr_da || board == das1702hr_da) {
+ dev_dbg(dev->class_dev, "Board model: %s\n",
+ das1800_boards[board].name);
+ return board;
+ }
+ printk
+ (" Board model (probed, not recommended): das-1802hr-da\n");
+ return das1802hr;
break;
- case TRIG_ROUND_UP:
- micro_sec = (convert_arg - 1) / 1000 + 1;
+ case 0x5:
+ if (board == das1801ao || board == das1802ao ||
+ board == das1701ao || board == das1702ao) {
+ dev_dbg(dev->class_dev, "Board model: %s\n",
+ das1800_boards[board].name);
+ return board;
+ }
+ printk
+ (" Board model (probed, not recommended): das-1800ao series\n");
+ return das1801ao;
+ break;
+ case 0x6:
+ if (board == das1802hr || board == das1702hr) {
+ dev_dbg(dev->class_dev, "Board model: %s\n",
+ das1800_boards[board].name);
+ return board;
+ }
+ printk
+ (" Board model (probed, not recommended): das-1802hr\n");
+ return das1802hr;
+ break;
+ case 0x7:
+ if (board == das1801st || board == das1802st ||
+ board == das1701st || board == das1702st) {
+ dev_dbg(dev->class_dev, "Board model: %s\n",
+ das1800_boards[board].name);
+ return board;
+ }
+ printk
+ (" Board model (probed, not recommended): das-1800st series\n");
+ return das1801st;
+ break;
+ case 0x8:
+ if (board == das1801hc || board == das1802hc) {
+ dev_dbg(dev->class_dev, "Board model: %s\n",
+ das1800_boards[board].name);
+ return board;
+ }
+ printk
+ (" Board model (probed, not recommended): das-1800hc series\n");
+ return das1801hc;
+ break;
+ default:
+ printk
+ (" Board model: probe returned 0x%x (unknown, please report)\n",
+ id);
+ return board;
break;
}
-
- /* return number of nanoseconds */
- return micro_sec * 1000;
+ return -1;
}
-/* utility function that suggests a dma transfer size based on the conversion period 'ns' */
-static unsigned int suggest_transfer_size(struct comedi_cmd *cmd)
+static int das1800_attach(struct comedi_device *dev,
+ struct comedi_devconfig *it)
{
- unsigned int size = DMA_BUF_SIZE;
- static const int sample_size = 2; /* size in bytes of one sample from board */
- unsigned int fill_time = 300000000; /* target time in nanoseconds for filling dma buffer */
- unsigned int max_size; /* maximum size we will allow for a transfer */
+ struct comedi_subdevice *s;
+ unsigned long iobase = it->options[0];
+ unsigned int irq = it->options[1];
+ unsigned int dma0 = it->options[2];
+ unsigned int dma1 = it->options[3];
+ unsigned long iobase2;
+ int board;
+ int retval;
- /* make dma buffer fill in 0.3 seconds for timed modes */
- switch (cmd->scan_begin_src) {
- case TRIG_FOLLOW: /* not in burst mode */
- if (cmd->convert_src == TRIG_TIMER)
- size = (fill_time / cmd->convert_arg) * sample_size;
+ /* allocate and initialize dev->private */
+ if (alloc_private(dev, sizeof(struct das1800_private)) < 0)
+ return -ENOMEM;
+
+ printk(KERN_DEBUG "comedi%d: %s: io 0x%lx", dev->minor,
+ dev->driver->driver_name, iobase);
+ if (irq) {
+ printk(KERN_CONT ", irq %u", irq);
+ if (dma0) {
+ printk(KERN_CONT ", dma %u", dma0);
+ if (dma1)
+ printk(KERN_CONT " and %u", dma1);
+ }
+ }
+ printk(KERN_CONT "\n");
+
+ if (iobase == 0) {
+ dev_err(dev->class_dev, "io base address required\n");
+ return -EINVAL;
+ }
+
+ /* check if io addresses are available */
+ if (!request_region(iobase, DAS1800_SIZE, dev->driver->driver_name)) {
+ printk
+ (" I/O port conflict: failed to allocate ports 0x%lx to 0x%lx\n",
+ iobase, iobase + DAS1800_SIZE - 1);
+ return -EIO;
+ }
+ dev->iobase = iobase;
+
+ board = das1800_probe(dev);
+ if (board < 0) {
+ dev_err(dev->class_dev, "unable to determine board type\n");
+ return -ENODEV;
+ }
+
+ dev->board_ptr = das1800_boards + board;
+ dev->board_name = thisboard->name;
+
+ /* if it is an 'ao' board with fancy analog out then we need extra io ports */
+ if (thisboard->ao_ability == 2) {
+ iobase2 = iobase + IOBASE2;
+ if (!request_region(iobase2, DAS1800_SIZE,
+ dev->driver->driver_name)) {
+ printk
+ (" I/O port conflict: failed to allocate ports 0x%lx to 0x%lx\n",
+ iobase2, iobase2 + DAS1800_SIZE - 1);
+ return -EIO;
+ }
+ devpriv->iobase2 = iobase2;
+ }
+
+ /* grab our IRQ */
+ if (irq) {
+ if (request_irq(irq, das1800_interrupt, 0,
+ dev->driver->driver_name, dev)) {
+ dev_dbg(dev->class_dev, "unable to allocate irq %u\n",
+ irq);
+ return -EINVAL;
+ }
+ }
+ dev->irq = irq;
+
+ /* set bits that tell card which irq to use */
+ switch (irq) {
+ case 0:
break;
- case TRIG_TIMER:
- size = (fill_time / (cmd->scan_begin_arg * cmd->chanlist_len)) *
- sample_size;
+ case 3:
+ devpriv->irq_dma_bits |= 0x8;
+ break;
+ case 5:
+ devpriv->irq_dma_bits |= 0x10;
+ break;
+ case 7:
+ devpriv->irq_dma_bits |= 0x18;
+ break;
+ case 10:
+ devpriv->irq_dma_bits |= 0x28;
+ break;
+ case 11:
+ devpriv->irq_dma_bits |= 0x30;
+ break;
+ case 15:
+ devpriv->irq_dma_bits |= 0x38;
break;
default:
- size = DMA_BUF_SIZE;
+ dev_err(dev->class_dev, "irq out of range\n");
+ return -EINVAL;
break;
}
- /* set a minimum and maximum size allowed */
- max_size = DMA_BUF_SIZE;
- /* if we are taking limited number of conversions, limit transfer size to that */
- if (cmd->stop_src == TRIG_COUNT &&
- cmd->stop_arg * cmd->chanlist_len * sample_size < max_size)
- max_size = cmd->stop_arg * cmd->chanlist_len * sample_size;
+ retval = das1800_init_dma(dev, dma0, dma1);
+ if (retval < 0)
+ return retval;
- if (size > max_size)
- size = max_size;
- if (size < sample_size)
- size = sample_size;
+ if (devpriv->ai_buf0 == NULL) {
+ devpriv->ai_buf0 =
+ kmalloc(FIFO_SIZE * sizeof(uint16_t), GFP_KERNEL);
+ if (devpriv->ai_buf0 == NULL)
+ return -ENOMEM;
+ }
- return size;
-}
+ retval = comedi_alloc_subdevices(dev, 4);
+ if (retval)
+ return retval;
+
+ /* analog input subdevice */
+ s = dev->subdevices + 0;
+ dev->read_subdev = s;
+ s->type = COMEDI_SUBD_AI;
+ s->subdev_flags = SDF_READABLE | SDF_DIFF | SDF_GROUND | SDF_CMD_READ;
+ if (thisboard->common)
+ s->subdev_flags |= SDF_COMMON;
+ s->n_chan = thisboard->qram_len;
+ s->len_chanlist = thisboard->qram_len;
+ s->maxdata = (1 << thisboard->resolution) - 1;
+ s->range_table = thisboard->range_ai;
+ s->do_cmd = das1800_ai_do_cmd;
+ s->do_cmdtest = das1800_ai_do_cmdtest;
+ s->insn_read = das1800_ai_rinsn;
+ s->poll = das1800_ai_poll;
+ s->cancel = das1800_cancel;
+
+ /* analog out */
+ s = dev->subdevices + 1;
+ if (thisboard->ao_ability == 1) {
+ s->type = COMEDI_SUBD_AO;
+ s->subdev_flags = SDF_WRITABLE;
+ s->n_chan = thisboard->ao_n_chan;
+ s->maxdata = (1 << thisboard->resolution) - 1;
+ s->range_table = &range_ao_1;
+ s->insn_write = das1800_ao_winsn;
+ } else {
+ s->type = COMEDI_SUBD_UNUSED;
+ }
+
+ /* di */
+ s = dev->subdevices + 2;
+ s->type = COMEDI_SUBD_DI;
+ s->subdev_flags = SDF_READABLE;
+ s->n_chan = 4;
+ s->maxdata = 1;
+ s->range_table = &range_digital;
+ s->insn_bits = das1800_di_rbits;
+
+ /* do */
+ s = dev->subdevices + 3;
+ s->type = COMEDI_SUBD_DO;
+ s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
+ s->n_chan = thisboard->do_n_chan;
+ s->maxdata = 1;
+ s->range_table = &range_digital;
+ s->insn_bits = das1800_do_wbits;
+
+ das1800_cancel(dev, dev->read_subdev);
+
+ /* initialize digital out channels */
+ outb(devpriv->do_bits, dev->iobase + DAS1800_DIGITAL);
+
+ /* initialize analog out channels */
+ if (thisboard->ao_ability == 1) {
+ /* select 'update' dac channel for baseAddress + 0x0 */
+ outb(DAC(thisboard->ao_n_chan - 1),
+ dev->iobase + DAS1800_SELECT);
+ outw(devpriv->ao_update_bits, dev->iobase + DAS1800_DAC);
+ }
+
+ return 0;
+};
+
+static void das1800_detach(struct comedi_device *dev)
+{
+ if (dev->iobase)
+ release_region(dev->iobase, DAS1800_SIZE);
+ if (dev->irq)
+ free_irq(dev->irq, dev);
+ if (dev->private) {
+ if (devpriv->iobase2)
+ release_region(devpriv->iobase2, DAS1800_SIZE);
+ if (devpriv->dma0)
+ free_dma(devpriv->dma0);
+ if (devpriv->dma1)
+ free_dma(devpriv->dma1);
+ kfree(devpriv->ai_buf0);
+ kfree(devpriv->ai_buf1);
+ }
+};
static struct comedi_driver das1800_driver = {
.driver_name = "das1800",
struct comedi_subdevice *s = dev->subdevices;
if (!dev->attached || devpriv->das6402_ignoreirq) {
- dev_warn(dev->hw_dev, "BUG: spurious interrupt\n");
+ dev_warn(dev->class_dev, "BUG: spurious interrupt\n");
return IRQ_HANDLED;
}
#ifdef DEBUG
*/
devpriv->das6402_ignoreirq = 1;
- dev_dbg(dev->hw_dev, "Stopping acquisition\n");
+ dev_dbg(dev->class_dev, "Stopping acquisition\n");
devpriv->das6402_ignoreirq = 1;
outb_p(0x02, dev->iobase + 10); /* disable external trigging */
outw_p(SCANL, dev->iobase + 2); /* resets the card fifo */
struct comedi_subdevice *s, comedi_trig * it)
{
devpriv->das6402_ignoreirq = 1;
- dev_dbg(dev->hw_dev, "Starting acquisition\n");
+ dev_dbg(dev->class_dev, "Starting acquisition\n");
outb_p(0x03, dev->iobase + 10); /* enable external trigging */
outw_p(SCANL, dev->iobase + 2); /* resets the card fifo */
outb_p(IRQ | CONVSRC | BURSTEN | INTE, dev->iobase + 9);
iobase = 0x300;
if (!request_region(iobase, DAS6402_SIZE, "das6402")) {
- dev_err(dev->hw_dev, "I/O port conflict\n");
+ dev_err(dev->class_dev, "I/O port conflict\n");
return -EIO;
}
dev->iobase = iobase;
/* should do a probe here */
irq = it->options[0];
- dev_dbg(dev->hw_dev, "( irq = %u )\n", irq);
+ dev_dbg(dev->class_dev, "( irq = %u )\n", irq);
ret = request_irq(irq, intr_handler, 0, "das6402", dev);
if (ret < 0)
return ret;
if (ret < 0)
return ret;
- ret = alloc_subdevices(dev, 1);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
return ret;
/* ai subdevice */
switch (id_bits) {
case 0x0:
if (board == das800) {
- dev_dbg(dev->hw_dev, "Board model: DAS-800\n");
+ dev_dbg(dev->class_dev, "Board model: DAS-800\n");
return board;
}
if (board == ciodas800) {
- dev_dbg(dev->hw_dev, "Board model: CIO-DAS800\n");
+ dev_dbg(dev->class_dev, "Board model: CIO-DAS800\n");
return board;
}
- dev_dbg(dev->hw_dev, "Board model (probed): DAS-800\n");
+ dev_dbg(dev->class_dev, "Board model (probed): DAS-800\n");
return das800;
break;
case 0x2:
if (board == das801) {
- dev_dbg(dev->hw_dev, "Board model: DAS-801\n");
+ dev_dbg(dev->class_dev, "Board model: DAS-801\n");
return board;
}
if (board == ciodas801) {
- dev_dbg(dev->hw_dev, "Board model: CIO-DAS801\n");
+ dev_dbg(dev->class_dev, "Board model: CIO-DAS801\n");
return board;
}
- dev_dbg(dev->hw_dev, "Board model (probed): DAS-801\n");
+ dev_dbg(dev->class_dev, "Board model (probed): DAS-801\n");
return das801;
break;
case 0x3:
if (board == das802) {
- dev_dbg(dev->hw_dev, "Board model: DAS-802\n");
+ dev_dbg(dev->class_dev, "Board model: DAS-802\n");
return board;
}
if (board == ciodas802) {
- dev_dbg(dev->hw_dev, "Board model: CIO-DAS802\n");
+ dev_dbg(dev->class_dev, "Board model: CIO-DAS802\n");
return board;
}
if (board == ciodas80216) {
- dev_dbg(dev->hw_dev, "Board model: CIO-DAS802/16\n");
+ dev_dbg(dev->class_dev, "Board model: CIO-DAS802/16\n");
return board;
}
- dev_dbg(dev->hw_dev, "Board model (probed): DAS-802\n");
+ dev_dbg(dev->class_dev, "Board model (probed): DAS-802\n");
return das802;
break;
default:
- dev_dbg(dev->hw_dev, "Board model: probe returned 0x%x (unknown)\n",
+ dev_dbg(dev->class_dev,
+ "Board model: probe returned 0x%x (unknown)\n",
id_bits);
return board;
break;
/* otherwise, stop taking data */
} else {
spin_unlock_irqrestore(&dev->spinlock, irq_flags);
- disable_das800(dev); /* diable hardware triggered conversions */
+ disable_das800(dev); /* disable hardware triggered conversions */
async->events |= COMEDI_CB_EOA;
}
comedi_event(dev, s);
unsigned int irq = it->options[1];
unsigned long irq_flags;
int board;
+ int ret;
- dev_info(dev->hw_dev, "comedi%d: das800: io 0x%lx\n", dev->minor,
- iobase);
+ dev_info(dev->class_dev, "das800: io 0x%lx\n", iobase);
if (irq)
- dev_dbg(dev->hw_dev, "irq %u\n", irq);
+ dev_dbg(dev->class_dev, "irq %u\n", irq);
/* allocate and initialize dev->private */
if (alloc_private(dev, sizeof(struct das800_private)) < 0)
return -ENOMEM;
if (iobase == 0) {
- dev_err(dev->hw_dev, "io base address required for das800\n");
+ dev_err(dev->class_dev,
+ "io base address required for das800\n");
return -EINVAL;
}
/* check if io addresses are available */
if (!request_region(iobase, DAS800_SIZE, "das800")) {
- dev_err(dev->hw_dev, "I/O port conflict\n");
+ dev_err(dev->class_dev, "I/O port conflict\n");
return -EIO;
}
dev->iobase = iobase;
board = das800_probe(dev);
if (board < 0) {
- dev_dbg(dev->hw_dev, "unable to determine board type\n");
+ dev_dbg(dev->class_dev, "unable to determine board type\n");
return -ENODEV;
}
dev->board_ptr = das800_boards + board;
/* grab our IRQ */
if (irq == 1 || irq > 7) {
- dev_err(dev->hw_dev, "irq out of range\n");
+ dev_err(dev->class_dev, "irq out of range\n");
return -EINVAL;
}
if (irq) {
if (request_irq(irq, das800_interrupt, 0, "das800", dev)) {
- dev_err(dev->hw_dev, "unable to allocate irq %u\n",
+ dev_err(dev->class_dev, "unable to allocate irq %u\n",
irq);
return -EINVAL;
}
dev->board_name = thisboard->name;
- if (alloc_subdevices(dev, 3) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
+ return ret;
/* analog input subdevice */
s = dev->subdevices + 0;
data[1] = bits;
data[0] = 0;
- return 2;
+ return insn->n;
}
static int das800_do_wbits(struct comedi_device *dev,
data[1] = wbits;
- return 2;
+ return insn->n;
}
/* loads counters with divisor1, divisor2 from private structure */
},
};
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((const struct dmm32at_board *)dev->board_ptr)
-
/* this structure is for data unique to this hardware driver. If
* several hardware drivers keep similar information in this structure,
* feel free to suggest moving the variable to the struct comedi_device struct.
static int dmm32at_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ const struct dmm32at_board *board = comedi_board(dev);
int ret;
struct comedi_subdevice *s;
unsigned char aihi, ailo, fifostat, aistat, intstat, airback;
iobase, irq);
/* register address space */
- if (!request_region(iobase, DMM32AT_MEMSIZE, thisboard->name)) {
+ if (!request_region(iobase, DMM32AT_MEMSIZE, board->name)) {
printk(KERN_ERR "comedi%d: dmm32at: I/O port conflict\n",
dev->minor);
return -EIO;
/* board is there, register interrupt */
if (irq) {
- ret = request_irq(irq, dmm32at_isr, 0, thisboard->name, dev);
+ ret = request_irq(irq, dmm32at_isr, 0, board->name, dev);
if (ret < 0) {
printk(KERN_ERR "dmm32at: irq conflict\n");
return ret;
dev->irq = irq;
}
-/*
- * If you can probe the device to determine what device in a series
- * it is, this is the place to do it. Otherwise, dev->board_ptr
- * should already be initialized.
- */
- /* dev->board_ptr = dmm32at_probe(dev); */
-
-/*
- * Initialize dev->board_name. Note that we can use the "thisboard"
- * macro now, since we just initialized it in the last line.
- */
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
/*
* Allocate the private structure area. alloc_private() is a
if (alloc_private(dev, sizeof(struct dmm32at_private)) < 0)
return -ENOMEM;
-/*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- if (alloc_subdevices(dev, 3) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
dev->read_subdev = s;
s->type = COMEDI_SUBD_AI;
/* we support single-ended (ground) and differential */
s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ;
- s->n_chan = thisboard->ai_chans;
- s->maxdata = (1 << thisboard->ai_bits) - 1;
- s->range_table = thisboard->ai_ranges;
+ s->n_chan = board->ai_chans;
+ s->maxdata = (1 << board->ai_bits) - 1;
+ s->range_table = board->ai_ranges;
s->len_chanlist = 32; /* This is the maximum chanlist length that
the board can handle */
s->insn_read = dmm32at_ai_rinsn;
/* analog output subdevice */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE;
- s->n_chan = thisboard->ao_chans;
- s->maxdata = (1 << thisboard->ao_bits) - 1;
- s->range_table = thisboard->ao_ranges;
+ s->n_chan = board->ao_chans;
+ s->maxdata = (1 << board->ao_bits) - 1;
+ s->range_table = board->ao_ranges;
s->insn_write = dmm32at_ao_winsn;
s->insn_read = dmm32at_ao_rinsn;
s = dev->subdevices + 2;
/* digital i/o subdevice */
- if (thisboard->have_dio) {
+ if (board->have_dio) {
/* get access to the DIO regs */
dmm_outb(dev, DMM32AT_CNTRL, DMM32AT_DIOACC);
/* set up the subdevice */
s->type = COMEDI_SUBD_DIO;
s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = thisboard->dio_chans;
+ s->n_chan = board->dio_chans;
s->maxdata = 1;
s->state = 0;
s->range_table = &range_digital;
{
unsigned char diobits;
- if (insn->n != 2)
- return -EINVAL;
-
/* The insn data is a mask in data[0] and the new data
* in data[1], each channel cooresponding to a bit. */
if (data[0]) {
* it was a purely digital output subdevice */
/* data[1]=s->state; */
- return 2;
+ return insn->n;
}
static int dmm32at_dio_insn_config(struct comedi_device *dev,
if (s == dev->subdevices + 4)
which = 1;
- if (insn->n != 2)
- return -EINVAL;
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
dt2801_writedata(dev, which);
dt2801_readdata(dev, data + 1);
- return 2;
+ return insn->n;
}
static int dt2801_dio_insn_config(struct comedi_device *dev,
printk("dt2801: %s at port 0x%lx", boardtype.name, iobase);
n_ai_chans = probe_number_of_ai_chans(dev);
- printk(" (ai channels = %d)", n_ai_chans);
+ printk(" (ai channels = %d)\n", n_ai_chans);
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
goto out;
ret = alloc_private(dev, sizeof(struct dt2801_private));
if (ret < 0)
- goto out;
+ return ret;
dev->board_name = boardtype.name;
ret = 0;
out:
- printk("\n");
-
return ret;
}
const struct comedi_lrange *unip_5;
};
-#define this_board ((const struct dt2811_board *)dev->board_ptr)
-
enum { card_2811_pgh, card_2811_pgl };
struct dt2811_private {
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inb(dev->iobase + DT2811_DIO);
- return 2;
+ return insn->n;
}
static int dt2811_do_insn_bits(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
s->state &= ~data[0];
s->state |= data[0] & data[1];
outb(s->state, dev->iobase + DT2811_DIO);
data[1] = s->state;
- return 2;
+ return insn->n;
}
/*
/* unsigned long irqs; */
/* long flags; */
+ const struct dt2811_board *board = comedi_board(dev);
int ret;
struct comedi_subdevice *s;
unsigned long iobase;
}
dev->iobase = iobase;
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
#if 0
outb(0, dev->iobase + DT2811_ADCSR);
}
#endif
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
ret = alloc_private(dev, sizeof(struct dt2811_private));
switch (it->options[3]) {
case 0:
default:
- s->range_table = this_board->bip_5;
+ s->range_table = board->bip_5;
break;
case 1:
- s->range_table = this_board->bip_2_5;
+ s->range_table = board->bip_2_5;
break;
case 2:
- s->range_table = this_board->unip_5;
+ s->range_table = board->unip_5;
break;
}
#endif
}
- ret = alloc_subdevices(dev, 1);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
return ret;
ret = alloc_private(dev, sizeof(struct dt2814_private));
int i;
const struct comedi_lrange *current_range_type, *voltage_range_type;
unsigned long iobase;
+ int ret;
iobase = it->options[0];
printk(KERN_INFO "comedi%d: dt2815: 0x%04lx ", dev->minor, iobase);
dev->iobase = iobase;
dev->board_name = "dt2815";
- if (alloc_subdevices(dev, 1) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
+
if (alloc_private(dev, sizeof(struct dt2815_private)) < 0)
return -ENOMEM;
data[1] |= (inb(dev->iobase + DT2817_DATA + 2) << 16);
data[1] |= (inb(dev->iobase + DT2817_DATA + 3) << 24);
- return 2;
+ return insn->n;
}
static int dt2817_attach(struct comedi_device *dev, struct comedi_devconfig *it)
dev->iobase = iobase;
dev->board_name = "dt2817";
- ret = alloc_subdevices(dev, 1);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
return ret;
s = dev->subdevices + 0;
int dabits;
};
-#define this_board ((const struct dt282x_board *)dev->board_ptr)
-
struct dt282x_private {
int ad_2scomp; /* we have 2's comp jumper set */
int da0_2scomp; /* same, for DAC0 */
static int dt282x_ai_cmdtest(struct comedi_device *dev,
struct comedi_subdevice *s, struct comedi_cmd *cmd)
{
+ const struct dt282x_board *board = comedi_board(dev);
int err = 0;
int tmp;
cmd->convert_arg = SLOWEST_TIMER;
err++;
}
- if (cmd->convert_arg < this_board->ai_speed) {
- cmd->convert_arg = this_board->ai_speed;
+ if (cmd->convert_arg < board->ai_speed) {
+ cmd->convert_arg = board->ai_speed;
err++;
}
if (cmd->scan_end_arg != cmd->chanlist_len) {
static int dt282x_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
{
+ const struct dt282x_board *board = comedi_board(dev);
struct comedi_cmd *cmd = &s->async->cmd;
int timer;
dt282x_disable_dma(dev);
- if (cmd->convert_arg < this_board->ai_speed)
- cmd->convert_arg = this_board->ai_speed;
+ if (cmd->convert_arg < board->ai_speed)
+ cmd->convert_arg = board->ai_speed;
timer = dt282x_ns_to_timer(&cmd->convert_arg, TRIG_ROUND_NEAREST);
outw(timer, dev->iobase + DT2821_TMRCTR);
}
data[1] = inw(dev->iobase + DT2821_DIODAT);
- return 2;
+ return insn->n;
}
static int dt282x_dio_insn_config(struct comedi_device *dev,
*/
static int dt282x_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct dt282x_board *board = comedi_board(dev);
int i, irq;
int ret;
struct comedi_subdevice *s;
unsigned long iobase;
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
iobase = it->options[opt_iobase];
if (!iobase)
if (ret < 0)
return ret;
- ret = alloc_subdevices(dev, 3);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
return ret;
s = dev->subdevices + 0;
#include "../comedidev.h"
#include <linux/delay.h>
-#include "comedi_pci.h"
-
#define PCI_VENDOR_ID_DT 0x1116
static const struct comedi_lrange range_dt3000_ai = { 4, {
struct pci_dev *pci_dev;
resource_size_t phys_addr;
- void *io_addr;
+ void __iomem *io_addr;
unsigned int lock;
unsigned int ao_readback[2];
unsigned int ai_front;
if ((status & DT3000_COMPLETION_MASK) == DT3000_NOERROR)
return 0;
- dev_dbg(dev->hw_dev, "dt3k_send_cmd() timeout/error status=0x%04x\n",
+ dev_dbg(dev->class_dev, "dt3k_send_cmd() timeout/error status=0x%04x\n",
status);
return -ETIME;
if (count < 0)
count += AI_FIFO_DEPTH;
- dev_dbg(dev->hw_dev, "reading %d samples\n", count);
+ dev_dbg(dev->class_dev, "reading %d samples\n", count);
rear = devpriv->ai_rear;
int ret;
unsigned int mode;
- dev_dbg(dev->hw_dev, "dt3k_ai_cmd:\n");
+ dev_dbg(dev->class_dev, "dt3k_ai_cmd:\n");
for (i = 0; i < cmd->chanlist_len; i++) {
chan = CR_CHAN(cmd->chanlist[i]);
range = CR_RANGE(cmd->chanlist[i]);
aref = CR_AREF(cmd->chanlist[0]);
writew(cmd->scan_end_arg, devpriv->io_addr + DPR_Params(0));
- dev_dbg(dev->hw_dev, "param[0]=0x%04x\n", cmd->scan_end_arg);
+ dev_dbg(dev->class_dev, "param[0]=0x%04x\n", cmd->scan_end_arg);
if (cmd->convert_src == TRIG_TIMER) {
divider = dt3k_ns_to_timer(50, &cmd->convert_arg,
cmd->flags & TRIG_ROUND_MASK);
writew((divider >> 16), devpriv->io_addr + DPR_Params(1));
- dev_dbg(dev->hw_dev, "param[1]=0x%04x\n", divider >> 16);
+ dev_dbg(dev->class_dev, "param[1]=0x%04x\n", divider >> 16);
writew((divider & 0xffff), devpriv->io_addr + DPR_Params(2));
- dev_dbg(dev->hw_dev, "param[2]=0x%04x\n", divider & 0xffff);
+ dev_dbg(dev->class_dev, "param[2]=0x%04x\n", divider & 0xffff);
} else {
/* not supported */
}
tscandiv = dt3k_ns_to_timer(100, &cmd->scan_begin_arg,
cmd->flags & TRIG_ROUND_MASK);
writew((tscandiv >> 16), devpriv->io_addr + DPR_Params(3));
- dev_dbg(dev->hw_dev, "param[3]=0x%04x\n", tscandiv >> 16);
+ dev_dbg(dev->class_dev, "param[3]=0x%04x\n", tscandiv >> 16);
writew((tscandiv & 0xffff), devpriv->io_addr + DPR_Params(4));
- dev_dbg(dev->hw_dev, "param[4]=0x%04x\n", tscandiv & 0xffff);
+ dev_dbg(dev->class_dev, "param[4]=0x%04x\n", tscandiv & 0xffff);
} else {
/* not supported */
}
mode = DT3000_AD_RETRIG_INTERNAL | 0 | 0;
writew(mode, devpriv->io_addr + DPR_Params(5));
- dev_dbg(dev->hw_dev, "param[5]=0x%04x\n", mode);
+ dev_dbg(dev->class_dev, "param[5]=0x%04x\n", mode);
writew(aref == AREF_DIFF, devpriv->io_addr + DPR_Params(6));
- dev_dbg(dev->hw_dev, "param[6]=0x%04x\n", aref == AREF_DIFF);
+ dev_dbg(dev->class_dev, "param[6]=0x%04x\n", aref == AREF_DIFF);
writew(AI_FIFO_DEPTH / 2, devpriv->io_addr + DPR_Params(7));
- dev_dbg(dev->hw_dev, "param[7]=0x%04x\n", AI_FIFO_DEPTH / 2);
+ dev_dbg(dev->class_dev, "param[7]=0x%04x\n", AI_FIFO_DEPTH / 2);
writew(SUBS_AI, devpriv->io_addr + DPR_SubSys);
ret = dt3k_send_cmd(dev, CMD_CONFIG);
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= data[1] & data[0];
}
data[1] = dt3k_readsingle(dev, SUBS_DIN, 0, 0);
- return 2;
+ return insn->n;
}
static int dt3k_mem_insn_read(struct comedi_device *dev,
int bus, slot;
int ret = 0;
- dev_dbg(dev->hw_dev, "dt3000:\n");
+ dev_dbg(dev->class_dev, "dt3000:\n");
bus = it->options[0];
slot = it->options[1];
if (ret < 0)
return ret;
if (ret == 0) {
- dev_warn(dev->hw_dev, "no DT board found\n");
+ dev_warn(dev->class_dev, "no DT board found\n");
return -ENODEV;
}
if (request_irq(devpriv->pci_dev->irq, dt3k_interrupt, IRQF_SHARED,
"dt3000", dev)) {
- dev_err(dev->hw_dev, "unable to allocate IRQ %u\n",
+ dev_err(dev->class_dev, "unable to allocate IRQ %u\n",
devpriv->pci_dev->irq);
return -EINVAL;
}
dev->irq = devpriv->pci_dev->irq;
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
s = dev->subdevices;
{
int i;
struct comedi_subdevice *s;
+ int ret;
dev->board_name = "dt9812";
devpriv->serial = it->options[0];
- /* Allocate subdevices */
- if (alloc_subdevices(dev, 4) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
+ return ret;
/* digital input subdevice */
s = dev->subdevices + 0;
*/
#include "../comedidev.h"
-#include "comedi_pci.h"
#include <linux/mutex.h>
#define PCI_VENDOR_ID_DYNALOG 0x10b5
for (counter = 0; counter < READ_TIMEOUT; counter++) {
d = inw_p(devpriv->BADR2);
- /* check if read is successfull if the EOC bit is set */
+ /* check if read is successful if the EOC bit is set */
if (d & (1 << 15))
goto conv_finish;
}
{
u16 d = 0;
- if (insn->n != 2)
- return -EINVAL;
-
mutex_lock(&devpriv->mutex);
smp_mb();
d = inw_p(devpriv->BADR3);
data[1] = d;
data[0] = s->state;
mutex_unlock(&devpriv->mutex);
- return 2;
+ return insn->n;
}
/* digital output bit interface */
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
/* The insn data is a mask in data[0] and the new data
* in data[1], each channel cooresponding to a bit.
* s->state contains the previous write data
*/
data[1] = s->state;
mutex_unlock(&devpriv->mutex);
- return 2;
+ return insn->n;
}
/******************************************************************************/
struct pci_dev *pcidev;
unsigned int opt_bus, opt_slot;
int board_index, i;
+ int ret;
mutex_lock(&start_stop_sem);
devpriv->BADR4 = pci_resource_start(pcidev, 4);
devpriv->BADR5 = pci_resource_start(pcidev, 5);
- if (alloc_subdevices(dev, 4) < 0) {
- printk(KERN_ERR "comedi: dyna_pci10xx: "
- "failed allocating subdevices\n");
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret) {
mutex_unlock(&start_stop_sem);
- return -ENOMEM;
+ return ret;
}
/* analog input */
static int fl512_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
unsigned long iobase;
+ int ret;
/* pointer to the subdevice: Analog in, Analog out,
(not made ->and Digital IO) */
printk(KERN_DEBUG "malloc ok\n");
#endif
- if (alloc_subdevices(dev, 2) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 2);
+ if (ret)
+ return ret;
/*
* this if the definitions of the supdevices, 2 have been defined
#include "../comedidev.h"
#include <linux/delay.h>
-#include "comedi_pci.h"
#include "plx9080.h"
#include "comedi_fc.h"
resource_size_t plx9080_phys_iobase;
resource_size_t hpdi_phys_iobase;
/* base addresses (ioremapped) */
- void *plx9080_iobase;
- void *hpdi_iobase;
+ void __iomem *plx9080_iobase;
+ void __iomem *hpdi_iobase;
uint32_t *dio_buffer[NUM_DMA_BUFFERS]; /* dma buffers */
/* physical addresses of dma buffers */
dma_addr_t dio_buffer_phys_addr[NUM_DMA_BUFFERS];
static void init_plx9080(struct comedi_device *dev)
{
uint32_t bits;
- void *plx_iobase = priv(dev)->plx9080_iobase;
+ void __iomem *plx_iobase = priv(dev)->plx9080_iobase;
/* plx9080 dump */
DEBUG_PRINT(" plx interrupt status 0x%x\n",
static int setup_subdevices(struct comedi_device *dev)
{
struct comedi_subdevice *s;
+ int ret;
- if (alloc_subdevices(dev, 1) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* analog input subdevice */
printk(KERN_WARNING " irq %u\n", dev->irq);
- /* alocate pci dma buffers */
+ /* allocate pci dma buffers */
for (i = 0; i < NUM_DMA_BUFFERS; i++) {
priv(dev)->dio_buffer[i] =
pci_alloc_consistent(priv(dev)->hw_dev, DMA_BUFFER_SIZE,
if ((priv(dev)) && (priv(dev)->hw_dev)) {
if (priv(dev)->plx9080_iobase) {
disable_plx_interrupts(dev);
- iounmap((void *)priv(dev)->plx9080_iobase);
+ iounmap(priv(dev)->plx9080_iobase);
}
if (priv(dev)->hpdi_iobase)
- iounmap((void *)priv(dev)->hpdi_iobase);
+ iounmap(priv(dev)->hpdi_iobase);
/* free pci dma buffers */
for (i = 0; i < NUM_DMA_BUFFERS; i++) {
if (priv(dev)->dio_buffer[i])
uint32_t next_transfer_addr;
int j;
int num_samples = 0;
- void *pci_addr_reg;
+ void __iomem *pci_addr_reg;
if (channel)
pci_addr_reg =
struct icp_multi_private {
struct pcilst_struct *card; /* pointer to card */
char valid; /* card is usable */
- void *io_addr; /* Pointer to mapped io address */
+ void __iomem *io_addr; /* Pointer to mapped io address */
resource_size_t phys_iobase; /* Physical io address */
unsigned int AdcCmdStatus; /* ADC Command/Status register */
unsigned int DacCmdStatus; /* DAC Command/Status register */
{
data[1] = readw(devpriv->io_addr + ICP_MULTI_DI);
- return 2;
+ return insn->n;
}
/*
#ifdef ICP_MULTI_EXTDEBUG
printk(KERN_DEBUG "icp multi EDBG: END: icp_multi_insn_bits_do(...)\n");
#endif
- return 2;
+ return insn->n;
}
/*
printk(KERN_WARNING
"icp_multi EDBG: BGN: icp_multi_attach(...)\n");
- /* Alocate private data storage space */
+ /* Allocate private data storage space */
ret = alloc_private(dev, sizeof(struct icp_multi_private));
if (ret < 0)
return ret;
if (this_board->n_ctrs)
n_subdevices++;
- ret = alloc_subdevices(dev, n_subdevices);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, n_subdevices);
+ if (ret)
return ret;
icp_multi_reset(dev);
#define _ICP_MULTI_H_
#include "../comedidev.h"
-#include "comedi_pci.h"
/****************************************************************************/
#define PCI20341_SCANLIST 0x80 /* Channel/Gain Scan List */
union pci20xxx_subdev_private {
- void *iobase;
+ void __iomem *iobase;
struct {
- void *iobase;
+ void __iomem *iobase;
const struct comedi_lrange *ao_range_list[2];
/* range of channels of ao module */
unsigned int last_data[2];
} pci20006;
struct {
- void *iobase;
+ void __iomem *iobase;
int timebase;
int settling_time;
int ai_gain;
struct pci20xxx_private {
- void *ioaddr;
+ void __iomem *ioaddr;
union pci20xxx_subdev_private subdev_private[PCI20000_MODULES];
};
struct comedi_subdevice *s;
union pci20xxx_subdev_private *sdp;
- ret = alloc_subdevices(dev, 1 + PCI20000_MODULES);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 1 + PCI20000_MODULES);
+ if (ret)
return ret;
ret = alloc_private(dev, sizeof(struct pci20xxx_private));
if (ret < 0)
return ret;
- devpriv->ioaddr = (void *)(unsigned long)it->options[0];
+ devpriv->ioaddr = (void __iomem *)(unsigned long)it->options[0];
dev->board_name = "pci20kc";
/* Check PCI-20001 C-2A Carrier Board ID */
data[1] |= readb(devpriv->ioaddr + PCI20000_DIO_2) << 16;
data[1] |= readb(devpriv->ioaddr + PCI20000_DIO_3) << 24;
- return 2;
+ return insn->n;
}
static void pci20xxx_dio_config(struct comedi_device *dev,
#include <linux/slab.h>
#include <linux/timer.h>
#include <linux/kernel.h>
-#include "comedi_pci.h"
#include "jr3_pci.h"
#define PCI_VENDOR_ID_JR3 0x1762
int i;
struct jr3_pci_dev_private *devpriv = dev->private;
- dev_dbg(dev->hw_dev, "jr3_pci_open\n");
+ dev_dbg(dev->class_dev, "jr3_pci_open\n");
for (i = 0; i < devpriv->n_channels; i++) {
struct jr3_pci_subdev_private *p;
p = dev->subdevices[i].private;
if (p) {
- dev_dbg(dev->hw_dev, "serial: %p %d (%d)\n", p,
+ dev_dbg(dev->class_dev, "serial: %p %d (%d)\n", p,
p->serial_no, p->channel_no);
}
}
break;
more = more
&& read_idm_word(data, size, &pos, &addr);
- dev_dbg(dev->hw_dev, "Loading#%d %4.4x bytes at %4.4x\n",
+ dev_dbg(dev->class_dev,
+ "Loading#%d %4.4x bytes at %4.4x\n",
i, count, addr);
while (more && count > 0) {
if (addr & 0x4000) {
opt_slot = it->options[1];
if (sizeof(struct jr3_channel) != 0xc00) {
- dev_err(dev->hw_dev, "sizeof(struct jr3_channel) = %x [expected %x]\n",
+ dev_err(dev->class_dev,
+ "sizeof(struct jr3_channel) = %x [expected %x]\n",
(unsigned)sizeof(struct jr3_channel), 0xc00);
return -EINVAL;
}
}
}
if (!card) {
- dev_err(dev->hw_dev, "no jr3_pci found\n");
+ dev_err(dev->class_dev, "no jr3_pci found\n");
return -EIO;
} else {
devpriv->pci_dev = card;
if (!devpriv->iobase)
return -ENOMEM;
- result = alloc_subdevices(dev, devpriv->n_channels);
- if (result < 0)
- goto out;
+ result = comedi_alloc_subdevices(dev, devpriv->n_channels);
+ if (result)
+ return result;
dev->open = jr3_pci_open;
for (i = 0; i < devpriv->n_channels; i++) {
p = dev->subdevices[i].private;
p->channel = &devpriv->iobase->channel[i].data;
- dev_dbg(dev->hw_dev, "p->channel %p %p (%tx)\n",
+ dev_dbg(dev->class_dev, "p->channel %p %p (%tx)\n",
p->channel, devpriv->iobase,
((char *)(p->channel) -
(char *)(devpriv->iobase)));
devpriv->iobase->channel[0].reset = 0;
result = comedi_load_firmware(dev, "jr3pci.idm", jr3_download_firmware);
- dev_dbg(dev->hw_dev, "Firmare load %d\n", result);
+ dev_dbg(dev->class_dev, "Firmare load %d\n", result);
if (result < 0)
goto out;
*/
msleep_interruptible(25);
for (i = 0; i < 0x18; i++) {
- dev_dbg(dev->hw_dev, "%c\n",
+ dev_dbg(dev->class_dev, "%c\n",
get_u16(&devpriv->iobase->channel[0].
data.copyright[i]) >> 8);
}
#include "../comedidev.h"
-#include "comedi_pci.h"
-
#define CNT_DRIVER_NAME "ke_counter"
#define PCI_VENDOR_ID_KOLTER 0x1001
#define CNT_CARD_DEVICE_ID 0x0014
io_base = pci_resource_start(pci_device, 0);
dev->iobase = io_base;
- /* allocate the subdevice structures */
- error = alloc_subdevices(dev, 1);
- if (error < 0)
+ error = comedi_alloc_subdevices(dev, 1);
+ if (error)
return error;
subdevice = dev->subdevices + 0;
#include <linux/list.h>
#include <linux/spinlock.h>
-#include "comedi_pci.h"
#include "me4000.h"
#if 0
/* file removed due to GPL incompatibility */
struct comedi_subdevice *s,
struct comedi_cmd *cmd);
-/*-----------------------------------------------------------------------------
- Meilhaus inline functions
- ---------------------------------------------------------------------------*/
-
-static inline void me4000_outb(struct comedi_device *dev, unsigned char value,
- unsigned long port)
-{
- PORT_PDEBUG("--> 0x%02X port 0x%04lX\n", value, port);
- outb(value, port);
-}
-
-static inline void me4000_outl(struct comedi_device *dev, unsigned long value,
- unsigned long port)
-{
- PORT_PDEBUG("--> 0x%08lX port 0x%04lX\n", value, port);
- outl(value, port);
-}
-
-static inline unsigned long me4000_inl(struct comedi_device *dev,
- unsigned long port)
-{
- unsigned long value;
- value = inl(port);
- PORT_PDEBUG("<-- 0x%08lX port 0x%04lX\n", value, port);
- return value;
-}
-
-static inline unsigned char me4000_inb(struct comedi_device *dev,
- unsigned long port)
-{
- unsigned char value;
- value = inb(port);
- PORT_PDEBUG("<-- 0x%08X port 0x%04lX\n", value, port);
- return value;
-}
-
static const struct comedi_lrange me4000_ai_range = {
4,
{
int result, i;
struct me4000_board *board;
- CALL_PDEBUG("In me4000_probe()\n");
-
/* Allocate private memory */
if (alloc_private(dev, sizeof(struct me4000_info)) < 0)
return -ENOMEM;
static int get_registers(struct comedi_device *dev, struct pci_dev *pci_dev_p)
{
-
- CALL_PDEBUG("In get_registers()\n");
-
/*--------------------------- plx regbase -------------------------------*/
info->plx_regbase = pci_resource_start(pci_dev_p, 1);
{
int result;
- CALL_PDEBUG("In init_board_info()\n");
-
/* Init spin locks */
/* spin_lock_init(&info->preload_lock); */
/* spin_lock_init(&info->ai_ctrl_lock); */
{
int i;
- CALL_PDEBUG("In init_ao_context()\n");
-
for (i = 0; i < thisboard->ao.count; i++) {
/* spin_lock_init(&info->ao_context[i].use_lock); */
info->ao_context[i].irq = info->irq;
static int init_ai_context(struct comedi_device *dev)
{
-
- CALL_PDEBUG("In init_ai_context()\n");
-
info->ai_context.irq = info->irq;
info->ai_context.ctrl_reg = info->me4000_regbase + ME4000_AI_CTRL_REG;
static int init_dio_context(struct comedi_device *dev)
{
-
- CALL_PDEBUG("In init_dio_context()\n");
-
info->dio_context.dir_reg = info->me4000_regbase + ME4000_DIO_DIR_REG;
info->dio_context.ctrl_reg = info->me4000_regbase + ME4000_DIO_CTRL_REG;
info->dio_context.port_0_reg =
static int init_cnt_context(struct comedi_device *dev)
{
-
- CALL_PDEBUG("In init_cnt_context()\n");
-
info->cnt_context.ctrl_reg = info->timer_regbase + ME4000_CNT_CTRL_REG;
info->cnt_context.counter_0_reg =
info->timer_regbase + ME4000_CNT_COUNTER_0_REG;
int idx = 0;
int size = 0;
- CALL_PDEBUG("In xilinx_download()\n");
-
init_waitqueue_head(&queue);
/*
{
unsigned long icr;
- CALL_PDEBUG("In reset_board()\n");
-
/* Make a hardware reset */
- icr = me4000_inl(dev, info->plx_regbase + PLX_ICR);
+ icr = inl(info->plx_regbase + PLX_ICR);
icr |= 0x40000000;
- me4000_outl(dev, icr, info->plx_regbase + PLX_ICR);
+ outl(icr, info->plx_regbase + PLX_ICR);
icr &= ~0x40000000;
- me4000_outl(dev, icr, info->plx_regbase + PLX_ICR);
+ outl(icr, info->plx_regbase + PLX_ICR);
/* 0x8000 to the DACs means an output voltage of 0V */
- me4000_outl(dev, 0x8000,
- info->me4000_regbase + ME4000_AO_00_SINGLE_REG);
- me4000_outl(dev, 0x8000,
- info->me4000_regbase + ME4000_AO_01_SINGLE_REG);
- me4000_outl(dev, 0x8000,
- info->me4000_regbase + ME4000_AO_02_SINGLE_REG);
- me4000_outl(dev, 0x8000,
- info->me4000_regbase + ME4000_AO_03_SINGLE_REG);
+ outl(0x8000, info->me4000_regbase + ME4000_AO_00_SINGLE_REG);
+ outl(0x8000, info->me4000_regbase + ME4000_AO_01_SINGLE_REG);
+ outl(0x8000, info->me4000_regbase + ME4000_AO_02_SINGLE_REG);
+ outl(0x8000, info->me4000_regbase + ME4000_AO_03_SINGLE_REG);
/* Set both stop bits in the analog input control register */
- me4000_outl(dev,
- ME4000_AI_CTRL_BIT_IMMEDIATE_STOP | ME4000_AI_CTRL_BIT_STOP,
- info->me4000_regbase + ME4000_AI_CTRL_REG);
+ outl(ME4000_AI_CTRL_BIT_IMMEDIATE_STOP | ME4000_AI_CTRL_BIT_STOP,
+ info->me4000_regbase + ME4000_AI_CTRL_REG);
/* Set both stop bits in the analog output control register */
- me4000_outl(dev,
- ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
- info->me4000_regbase + ME4000_AO_00_CTRL_REG);
- me4000_outl(dev,
- ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
- info->me4000_regbase + ME4000_AO_01_CTRL_REG);
- me4000_outl(dev,
- ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
- info->me4000_regbase + ME4000_AO_02_CTRL_REG);
- me4000_outl(dev,
- ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
- info->me4000_regbase + ME4000_AO_03_CTRL_REG);
+ outl(ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
+ info->me4000_regbase + ME4000_AO_00_CTRL_REG);
+ outl(ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
+ info->me4000_regbase + ME4000_AO_01_CTRL_REG);
+ outl(ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
+ info->me4000_regbase + ME4000_AO_02_CTRL_REG);
+ outl(ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
+ info->me4000_regbase + ME4000_AO_03_CTRL_REG);
/* Enable interrupts on the PLX */
- me4000_outl(dev, 0x43, info->plx_regbase + PLX_INTCSR);
+ outl(0x43, info->plx_regbase + PLX_INTCSR);
/* Set the adustment register for AO demux */
- me4000_outl(dev, ME4000_AO_DEMUX_ADJUST_VALUE,
+ outl(ME4000_AO_DEMUX_ADJUST_VALUE,
info->me4000_regbase + ME4000_AO_DEMUX_ADJUST_REG);
/*
* Set digital I/O direction for port 0
* to output on isolated versions
*/
- if (!(me4000_inl(dev, info->me4000_regbase + ME4000_DIO_DIR_REG) & 0x1)) {
- me4000_outl(dev, 0x1,
- info->me4000_regbase + ME4000_DIO_CTRL_REG);
- }
+ if (!(inl(info->me4000_regbase + ME4000_DIO_DIR_REG) & 0x1))
+ outl(0x1, info->me4000_regbase + ME4000_DIO_CTRL_REG);
return 0;
}
unsigned long tmp;
long lval;
- CALL_PDEBUG("In me4000_ai_insn_read()\n");
-
if (insn->n == 0) {
return 0;
} else if (insn->n > 1) {
entry |= ME4000_AI_LIST_LAST_ENTRY;
/* Clear channel list, data fifo and both stop bits */
- tmp = me4000_inl(dev, info->ai_context.ctrl_reg);
+ tmp = inl(info->ai_context.ctrl_reg);
tmp &= ~(ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
ME4000_AI_CTRL_BIT_DATA_FIFO |
ME4000_AI_CTRL_BIT_STOP | ME4000_AI_CTRL_BIT_IMMEDIATE_STOP);
- me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
+ outl(tmp, info->ai_context.ctrl_reg);
/* Set the acquisition mode to single */
tmp &= ~(ME4000_AI_CTRL_BIT_MODE_0 | ME4000_AI_CTRL_BIT_MODE_1 |
ME4000_AI_CTRL_BIT_MODE_2);
- me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
+ outl(tmp, info->ai_context.ctrl_reg);
/* Enable channel list and data fifo */
tmp |= ME4000_AI_CTRL_BIT_CHANNEL_FIFO | ME4000_AI_CTRL_BIT_DATA_FIFO;
- me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
+ outl(tmp, info->ai_context.ctrl_reg);
/* Generate channel list entry */
- me4000_outl(dev, entry, info->ai_context.channel_list_reg);
+ outl(entry, info->ai_context.channel_list_reg);
/* Set the timer to maximum sample rate */
- me4000_outl(dev, ME4000_AI_MIN_TICKS, info->ai_context.chan_timer_reg);
- me4000_outl(dev, ME4000_AI_MIN_TICKS,
- info->ai_context.chan_pre_timer_reg);
+ outl(ME4000_AI_MIN_TICKS, info->ai_context.chan_timer_reg);
+ outl(ME4000_AI_MIN_TICKS, info->ai_context.chan_pre_timer_reg);
/* Start conversion by dummy read */
- me4000_inl(dev, info->ai_context.start_reg);
+ inl(info->ai_context.start_reg);
/* Wait until ready */
udelay(10);
- if (!
- (me4000_inl(dev, info->ai_context.status_reg) &
+ if (!(inl(info->ai_context.status_reg) &
ME4000_AI_STATUS_BIT_EF_DATA)) {
printk(KERN_ERR
"comedi%d: me4000: me4000_ai_insn_read(): "
}
/* Read value from data fifo */
- lval = me4000_inl(dev, info->ai_context.data_reg) & 0xFFFF;
+ lval = inl(info->ai_context.data_reg) & 0xFFFF;
data[0] = lval ^ 0x8000;
return 1;
{
unsigned long tmp;
- CALL_PDEBUG("In me4000_ai_cancel()\n");
-
/* Stop any running conversion */
- tmp = me4000_inl(dev, info->ai_context.ctrl_reg);
+ tmp = inl(info->ai_context.ctrl_reg);
tmp &= ~(ME4000_AI_CTRL_BIT_STOP | ME4000_AI_CTRL_BIT_IMMEDIATE_STOP);
- me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
+ outl(tmp, info->ai_context.ctrl_reg);
/* Clear the control register */
- me4000_outl(dev, 0x0, info->ai_context.ctrl_reg);
+ outl(0x0, info->ai_context.ctrl_reg);
return 0;
}
int aref;
int i;
- CALL_PDEBUG("In ai_check_chanlist()\n");
-
/* Check whether a channel list is available */
if (!cmd->chanlist_len) {
printk(KERN_ERR
int rest;
- CALL_PDEBUG("In ai_round_cmd_args()\n");
-
*init_ticks = 0;
*scan_ticks = 0;
*chan_ticks = 0;
- PDEBUG("ai_round_cmd_arg(): start_arg = %d\n", cmd->start_arg);
- PDEBUG("ai_round_cmd_arg(): scan_begin_arg = %d\n",
- cmd->scan_begin_arg);
- PDEBUG("ai_round_cmd_arg(): convert_arg = %d\n", cmd->convert_arg);
-
if (cmd->start_arg) {
*init_ticks = (cmd->start_arg * 33) / 1000;
rest = (cmd->start_arg * 33) % 1000;
- if (cmd->flags & TRIG_ROUND_NEAREST) {
+ if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_NEAREST) {
if (rest > 33)
(*init_ticks)++;
- } else if (cmd->flags & TRIG_ROUND_UP) {
+ } else if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_UP) {
if (rest)
(*init_ticks)++;
}
*scan_ticks = (cmd->scan_begin_arg * 33) / 1000;
rest = (cmd->scan_begin_arg * 33) % 1000;
- if (cmd->flags & TRIG_ROUND_NEAREST) {
+ if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_NEAREST) {
if (rest > 33)
(*scan_ticks)++;
- } else if (cmd->flags & TRIG_ROUND_UP) {
+ } else if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_UP) {
if (rest)
(*scan_ticks)++;
}
*chan_ticks = (cmd->convert_arg * 33) / 1000;
rest = (cmd->convert_arg * 33) % 1000;
- if (cmd->flags & TRIG_ROUND_NEAREST) {
+ if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_NEAREST) {
if (rest > 33)
(*chan_ticks)++;
- } else if (cmd->flags & TRIG_ROUND_UP) {
+ } else if ((cmd->flags & TRIG_ROUND_MASK) == TRIG_ROUND_UP) {
if (rest)
(*chan_ticks)++;
}
}
- PDEBUG("ai_round_cmd_args(): init_ticks = %d\n", *init_ticks);
- PDEBUG("ai_round_cmd_args(): scan_ticks = %d\n", *scan_ticks);
- PDEBUG("ai_round_cmd_args(): chan_ticks = %d\n", *chan_ticks);
-
return 0;
}
unsigned int init_ticks,
unsigned int scan_ticks, unsigned int chan_ticks)
{
-
- CALL_PDEBUG("In ai_write_timer()\n");
-
- me4000_outl(dev, init_ticks - 1,
- info->ai_context.scan_pre_timer_low_reg);
- me4000_outl(dev, 0x0, info->ai_context.scan_pre_timer_high_reg);
+ outl(init_ticks - 1, info->ai_context.scan_pre_timer_low_reg);
+ outl(0x0, info->ai_context.scan_pre_timer_high_reg);
if (scan_ticks) {
- me4000_outl(dev, scan_ticks - 1,
- info->ai_context.scan_timer_low_reg);
- me4000_outl(dev, 0x0, info->ai_context.scan_timer_high_reg);
+ outl(scan_ticks - 1, info->ai_context.scan_timer_low_reg);
+ outl(0x0, info->ai_context.scan_timer_high_reg);
}
- me4000_outl(dev, chan_ticks - 1, info->ai_context.chan_pre_timer_reg);
- me4000_outl(dev, chan_ticks - 1, info->ai_context.chan_timer_reg);
+ outl(chan_ticks - 1, info->ai_context.chan_pre_timer_reg);
+ outl(chan_ticks - 1, info->ai_context.chan_timer_reg);
}
static int ai_prepare(struct comedi_device *dev,
unsigned long tmp = 0;
- CALL_PDEBUG("In ai_prepare()\n");
-
/* Write timer arguments */
ai_write_timer(dev, init_ticks, scan_ticks, chan_ticks);
/* Reset control register */
- me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
+ outl(tmp, info->ai_context.ctrl_reg);
/* Start sources */
if ((cmd->start_src == TRIG_EXT &&
/* Stop triggers */
if (cmd->stop_src == TRIG_COUNT) {
- me4000_outl(dev, cmd->chanlist_len * cmd->stop_arg,
+ outl(cmd->chanlist_len * cmd->stop_arg,
info->ai_context.sample_counter_reg);
tmp |= ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ;
} else if (cmd->stop_src == TRIG_NONE &&
cmd->scan_end_src == TRIG_COUNT) {
- me4000_outl(dev, cmd->scan_end_arg,
+ outl(cmd->scan_end_arg,
info->ai_context.sample_counter_reg);
tmp |= ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ;
} else {
}
/* Write the setup to the control register */
- me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
+ outl(tmp, info->ai_context.ctrl_reg);
/* Write the channel list */
ai_write_chanlist(dev, s, cmd);
unsigned int aref;
int i;
- CALL_PDEBUG("In ai_write_chanlist()\n");
-
for (i = 0; i < cmd->chanlist_len; i++) {
chan = CR_CHAN(cmd->chanlist[i]);
rang = CR_RANGE(cmd->chanlist[i]);
else
entry |= ME4000_AI_LIST_INPUT_SINGLE_ENDED;
- me4000_outl(dev, entry, info->ai_context.channel_list_reg);
+ outl(entry, info->ai_context.channel_list_reg);
}
return 0;
unsigned int chan_ticks = 0;
struct comedi_cmd *cmd = &s->async->cmd;
- CALL_PDEBUG("In me4000_ai_do_cmd()\n");
-
/* Reset the analog input */
err = me4000_ai_cancel(dev, s);
if (err)
return err;
/* Start acquistion by dummy read */
- me4000_inl(dev, info->ai_context.start_reg);
+ inl(info->ai_context.start_reg);
return 0;
}
unsigned int scan_ticks;
int err = 0;
- CALL_PDEBUG("In me4000_ai_do_cmd_test()\n");
-
- PDEBUG("me4000_ai_do_cmd_test(): subdev = %d\n", cmd->subdev);
- PDEBUG("me4000_ai_do_cmd_test(): flags = %08X\n", cmd->flags);
- PDEBUG("me4000_ai_do_cmd_test(): start_src = %08X\n",
- cmd->start_src);
- PDEBUG("me4000_ai_do_cmd_test(): start_arg = %d\n",
- cmd->start_arg);
- PDEBUG("me4000_ai_do_cmd_test(): scan_begin_src = %08X\n",
- cmd->scan_begin_src);
- PDEBUG("me4000_ai_do_cmd_test(): scan_begin_arg = %d\n",
- cmd->scan_begin_arg);
- PDEBUG("me4000_ai_do_cmd_test(): convert_src = %08X\n",
- cmd->convert_src);
- PDEBUG("me4000_ai_do_cmd_test(): convert_arg = %d\n",
- cmd->convert_arg);
- PDEBUG("me4000_ai_do_cmd_test(): scan_end_src = %08X\n",
- cmd->scan_end_src);
- PDEBUG("me4000_ai_do_cmd_test(): scan_end_arg = %d\n",
- cmd->scan_end_arg);
- PDEBUG("me4000_ai_do_cmd_test(): stop_src = %08X\n",
- cmd->stop_src);
- PDEBUG("me4000_ai_do_cmd_test(): stop_arg = %d\n", cmd->stop_arg);
- PDEBUG("me4000_ai_do_cmd_test(): chanlist = %d\n",
- (unsigned int)cmd->chanlist);
- PDEBUG("me4000_ai_do_cmd_test(): chanlist_len = %d\n",
- cmd->chanlist_len);
-
/* Only rounding flags are implemented */
cmd->flags &= TRIG_ROUND_NEAREST | TRIG_ROUND_UP | TRIG_ROUND_DOWN;
int c = 0;
long lval;
- ISR_PDEBUG("me4000_ai_isr() is executed\n");
-
- if (!dev->attached) {
- ISR_PDEBUG("me4000_ai_isr() premature interrupt\n");
+ if (!dev->attached)
return IRQ_NONE;
- }
/* Reset all events */
s->async->events = 0;
return IRQ_HANDLED;
}
- if (me4000_inl(dev,
- ai_context->irq_status_reg) &
+ if (inl(ai_context->irq_status_reg) &
ME4000_IRQ_STATUS_BIT_AI_HF) {
- ISR_PDEBUG
- ("me4000_ai_isr(): Fifo half full interrupt occurred\n");
-
/* Read status register to find out what happened */
- tmp = me4000_inl(dev, ai_context->ctrl_reg);
+ tmp = inl(ai_context->ctrl_reg);
if (!(tmp & ME4000_AI_STATUS_BIT_FF_DATA) &&
!(tmp & ME4000_AI_STATUS_BIT_HF_DATA) &&
(tmp & ME4000_AI_STATUS_BIT_EF_DATA)) {
- ISR_PDEBUG("me4000_ai_isr(): Fifo full\n");
c = ME4000_AI_FIFO_COUNT;
/*
tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
ME4000_AI_CTRL_BIT_SC_IRQ);
- me4000_outl(dev, tmp, ai_context->ctrl_reg);
+ outl(tmp, ai_context->ctrl_reg);
s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
} else if ((tmp & ME4000_AI_STATUS_BIT_FF_DATA)
&& !(tmp & ME4000_AI_STATUS_BIT_HF_DATA)
&& (tmp & ME4000_AI_STATUS_BIT_EF_DATA)) {
- ISR_PDEBUG("me4000_ai_isr(): Fifo half full\n");
-
s->async->events |= COMEDI_CB_BLOCK;
c = ME4000_AI_FIFO_COUNT / 2;
tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
ME4000_AI_CTRL_BIT_SC_IRQ);
- me4000_outl(dev, tmp, ai_context->ctrl_reg);
+ outl(tmp, ai_context->ctrl_reg);
s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
"Undefined FIFO state\n", dev->minor);
}
- ISR_PDEBUG("me4000_ai_isr(): Try to read %d values\n", c);
-
for (i = 0; i < c; i++) {
/* Read value from data fifo */
lval = inl(ai_context->data_reg) & 0xFFFF;
tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
ME4000_AI_CTRL_BIT_SC_IRQ);
- me4000_outl(dev, tmp, ai_context->ctrl_reg);
+ outl(tmp, ai_context->ctrl_reg);
s->async->events |= COMEDI_CB_OVERFLOW;
}
/* Work is done, so reset the interrupt */
- ISR_PDEBUG("me4000_ai_isr(): Reset fifo half full interrupt\n");
tmp |= ME4000_AI_CTRL_BIT_HF_IRQ_RESET;
- me4000_outl(dev, tmp, ai_context->ctrl_reg);
+ outl(tmp, ai_context->ctrl_reg);
tmp &= ~ME4000_AI_CTRL_BIT_HF_IRQ_RESET;
- me4000_outl(dev, tmp, ai_context->ctrl_reg);
+ outl(tmp, ai_context->ctrl_reg);
}
- if (me4000_inl(dev,
- ai_context->irq_status_reg) & ME4000_IRQ_STATUS_BIT_SC) {
- ISR_PDEBUG
- ("me4000_ai_isr(): Sample counter interrupt occurred\n");
-
+ if (inl(ai_context->irq_status_reg) & ME4000_IRQ_STATUS_BIT_SC) {
s->async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOA;
/*
* Acquisition is complete, so stop
* conversion and disable all interrupts
*/
- tmp = me4000_inl(dev, ai_context->ctrl_reg);
+ tmp = inl(ai_context->ctrl_reg);
tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ);
- me4000_outl(dev, tmp, ai_context->ctrl_reg);
+ outl(tmp, ai_context->ctrl_reg);
/* Poll data until fifo empty */
while (inl(ai_context->ctrl_reg) & ME4000_AI_STATUS_BIT_EF_DATA) {
}
/* Work is done, so reset the interrupt */
- ISR_PDEBUG
- ("me4000_ai_isr(): Reset interrupt from sample counter\n");
tmp |= ME4000_AI_CTRL_BIT_SC_IRQ_RESET;
- me4000_outl(dev, tmp, ai_context->ctrl_reg);
+ outl(tmp, ai_context->ctrl_reg);
tmp &= ~ME4000_AI_CTRL_BIT_SC_IRQ_RESET;
- me4000_outl(dev, tmp, ai_context->ctrl_reg);
+ outl(tmp, ai_context->ctrl_reg);
}
- ISR_PDEBUG("me4000_ai_isr(): Events = 0x%X\n", s->async->events);
-
if (s->async->events)
comedi_event(dev, s);
int aref = CR_AREF(insn->chanspec);
unsigned long tmp;
- CALL_PDEBUG("In me4000_ao_insn_write()\n");
-
if (insn->n == 0) {
return 0;
} else if (insn->n > 1) {
}
/* Stop any running conversion */
- tmp = me4000_inl(dev, info->ao_context[chan].ctrl_reg);
+ tmp = inl(info->ao_context[chan].ctrl_reg);
tmp |= ME4000_AO_CTRL_BIT_IMMEDIATE_STOP;
- me4000_outl(dev, tmp, info->ao_context[chan].ctrl_reg);
+ outl(tmp, info->ao_context[chan].ctrl_reg);
/* Clear control register and set to single mode */
- me4000_outl(dev, 0x0, info->ao_context[chan].ctrl_reg);
+ outl(0x0, info->ao_context[chan].ctrl_reg);
/* Write data value */
- me4000_outl(dev, data[0], info->ao_context[chan].single_reg);
+ outl(data[0], info->ao_context[chan].single_reg);
/* Store in the mirror */
info->ao_context[chan].mirror = data[0];
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
-
- CALL_PDEBUG("In me4000_dio_insn_bits()\n");
-
- /* Length of data must be 2 (mask and new data, see below) */
- if (insn->n == 0)
- return 0;
-
- if (insn->n != 2) {
- printk
- ("comedi%d: me4000: me4000_dio_insn_bits(): "
- "Invalid instruction length\n", dev->minor);
- return -EINVAL;
- }
-
/*
* The insn data consists of a mask in data[0] and the new data
* in data[1]. The mask defines which bits we are concerning about.
s->state |= data[0] & data[1];
/* Write out the new digital output lines */
- me4000_outl(dev, (s->state >> 0) & 0xFF,
+ outl((s->state >> 0) & 0xFF,
info->dio_context.port_0_reg);
- me4000_outl(dev, (s->state >> 8) & 0xFF,
+ outl((s->state >> 8) & 0xFF,
info->dio_context.port_1_reg);
- me4000_outl(dev, (s->state >> 16) & 0xFF,
+ outl((s->state >> 16) & 0xFF,
info->dio_context.port_2_reg);
- me4000_outl(dev, (s->state >> 24) & 0xFF,
+ outl((s->state >> 24) & 0xFF,
info->dio_context.port_3_reg);
}
/* On return, data[1] contains the value of
the digital input and output lines. */
- data[1] =
- ((me4000_inl(dev, info->dio_context.port_0_reg) & 0xFF) << 0) |
- ((me4000_inl(dev, info->dio_context.port_1_reg) & 0xFF) << 8) |
- ((me4000_inl(dev, info->dio_context.port_2_reg) & 0xFF) << 16) |
- ((me4000_inl(dev, info->dio_context.port_3_reg) & 0xFF) << 24);
+ data[1] = ((inl(info->dio_context.port_0_reg) & 0xFF) << 0) |
+ ((inl(info->dio_context.port_1_reg) & 0xFF) << 8) |
+ ((inl(info->dio_context.port_2_reg) & 0xFF) << 16) |
+ ((inl(info->dio_context.port_3_reg) & 0xFF) << 24);
- return 2;
+ return insn->n;
}
static int me4000_dio_insn_config(struct comedi_device *dev,
unsigned long tmp;
int chan = CR_CHAN(insn->chanspec);
- CALL_PDEBUG("In me4000_dio_insn_config()\n");
-
switch (data[0]) {
default:
return -EINVAL;
* On the ME-4000 it is only possible to switch port wise (8 bit)
*/
- tmp = me4000_inl(dev, info->dio_context.ctrl_reg);
+ tmp = inl(info->dio_context.ctrl_reg);
if (data[0] == INSN_CONFIG_DIO_OUTPUT) {
if (chan < 8) {
* If one the first port is a fixed output
* port and the second is a fixed input port.
*/
- if (!me4000_inl(dev, info->dio_context.dir_reg))
+ if (!inl(info->dio_context.dir_reg))
return -ENODEV;
s->io_bits |= 0xFF00;
* If one the first port is a fixed output
* port and the second is a fixed input port.
*/
- if (!me4000_inl(dev, info->dio_context.dir_reg))
+ if (!inl(info->dio_context.dir_reg))
return -ENODEV;
s->io_bits &= ~0xFF;
}
}
- me4000_outl(dev, tmp, info->dio_context.ctrl_reg);
+ outl(tmp, info->dio_context.ctrl_reg);
return 1;
}
static int cnt_reset(struct comedi_device *dev, unsigned int channel)
{
-
- CALL_PDEBUG("In cnt_reset()\n");
-
switch (channel) {
case 0:
- me4000_outb(dev, 0x30, info->cnt_context.ctrl_reg);
- me4000_outb(dev, 0x00, info->cnt_context.counter_0_reg);
- me4000_outb(dev, 0x00, info->cnt_context.counter_0_reg);
+ outb(0x30, info->cnt_context.ctrl_reg);
+ outb(0x00, info->cnt_context.counter_0_reg);
+ outb(0x00, info->cnt_context.counter_0_reg);
break;
case 1:
- me4000_outb(dev, 0x70, info->cnt_context.ctrl_reg);
- me4000_outb(dev, 0x00, info->cnt_context.counter_1_reg);
- me4000_outb(dev, 0x00, info->cnt_context.counter_1_reg);
+ outb(0x70, info->cnt_context.ctrl_reg);
+ outb(0x00, info->cnt_context.counter_1_reg);
+ outb(0x00, info->cnt_context.counter_1_reg);
break;
case 2:
- me4000_outb(dev, 0xB0, info->cnt_context.ctrl_reg);
- me4000_outb(dev, 0x00, info->cnt_context.counter_2_reg);
- me4000_outb(dev, 0x00, info->cnt_context.counter_2_reg);
+ outb(0xB0, info->cnt_context.ctrl_reg);
+ outb(0x00, info->cnt_context.counter_2_reg);
+ outb(0x00, info->cnt_context.counter_2_reg);
break;
default:
printk(KERN_ERR
{
int tmp = 0;
- CALL_PDEBUG("In cnt_config()\n");
-
switch (channel) {
case 0:
tmp |= ME4000_CNT_COUNTER_0;
/* Write the control word */
tmp |= 0x30;
- me4000_outb(dev, tmp, info->cnt_context.ctrl_reg);
+ outb(tmp, info->cnt_context.ctrl_reg);
return 0;
}
int err;
- CALL_PDEBUG("In me4000_cnt_insn_config()\n");
-
switch (data[0]) {
case GPCT_RESET:
if (insn->n != 1) {
unsigned short tmp;
- CALL_PDEBUG("In me4000_cnt_insn_read()\n");
-
if (insn->n == 0)
return 0;
switch (insn->chanspec) {
case 0:
- tmp = me4000_inb(dev, info->cnt_context.counter_0_reg);
+ tmp = inb(info->cnt_context.counter_0_reg);
data[0] = tmp;
- tmp = me4000_inb(dev, info->cnt_context.counter_0_reg);
+ tmp = inb(info->cnt_context.counter_0_reg);
data[0] |= tmp << 8;
break;
case 1:
- tmp = me4000_inb(dev, info->cnt_context.counter_1_reg);
+ tmp = inb(info->cnt_context.counter_1_reg);
data[0] = tmp;
- tmp = me4000_inb(dev, info->cnt_context.counter_1_reg);
+ tmp = inb(info->cnt_context.counter_1_reg);
data[0] |= tmp << 8;
break;
case 2:
- tmp = me4000_inb(dev, info->cnt_context.counter_2_reg);
+ tmp = inb(info->cnt_context.counter_2_reg);
data[0] = tmp;
- tmp = me4000_inb(dev, info->cnt_context.counter_2_reg);
+ tmp = inb(info->cnt_context.counter_2_reg);
data[0] |= tmp << 8;
break;
default:
unsigned short tmp;
- CALL_PDEBUG("In me4000_cnt_insn_write()\n");
-
if (insn->n == 0) {
return 0;
} else if (insn->n > 1) {
switch (insn->chanspec) {
case 0:
tmp = data[0] & 0xFF;
- me4000_outb(dev, tmp, info->cnt_context.counter_0_reg);
+ outb(tmp, info->cnt_context.counter_0_reg);
tmp = (data[0] >> 8) & 0xFF;
- me4000_outb(dev, tmp, info->cnt_context.counter_0_reg);
+ outb(tmp, info->cnt_context.counter_0_reg);
break;
case 1:
tmp = data[0] & 0xFF;
- me4000_outb(dev, tmp, info->cnt_context.counter_1_reg);
+ outb(tmp, info->cnt_context.counter_1_reg);
tmp = (data[0] >> 8) & 0xFF;
- me4000_outb(dev, tmp, info->cnt_context.counter_1_reg);
+ outb(tmp, info->cnt_context.counter_1_reg);
break;
case 2:
tmp = data[0] & 0xFF;
- me4000_outb(dev, tmp, info->cnt_context.counter_2_reg);
+ outb(tmp, info->cnt_context.counter_2_reg);
tmp = (data[0] >> 8) & 0xFF;
- me4000_outb(dev, tmp, info->cnt_context.counter_2_reg);
+ outb(tmp, info->cnt_context.counter_2_reg);
break;
default:
printk(KERN_ERR
struct comedi_subdevice *s;
int result;
- CALL_PDEBUG("In me4000_attach()\n");
-
result = me4000_probe(dev, it);
if (result)
return result;
- /*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h. It relies on
- * n_subdevices being set correctly.
- */
- if (alloc_subdevices(dev, 4) < 0)
- return -ENOMEM;
+ result = comedi_alloc_subdevices(dev, 4);
+ if (result)
+ return result;
/*=========================================================================
Analog input subdevice
* Check for optoisolated ME-4000 version. If one the first
* port is a fixed output port and the second is a fixed input port.
*/
- if (!me4000_inl(dev, info->dio_context.dir_reg)) {
+ if (!inl(info->dio_context.dir_reg)) {
s->io_bits |= 0xFF;
- me4000_outl(dev, ME4000_DIO_CTRL_BIT_MODE_0,
- info->dio_context.dir_reg);
+ outl(ME4000_DIO_CTRL_BIT_MODE_0, info->dio_context.dir_reg);
}
/*=========================================================================
#ifndef _ME4000_H_
#define _ME4000_H_
-/*=============================================================================
- Debug section
- ===========================================================================*/
-
-#undef ME4000_CALL_DEBUG /* Debug function entry and exit */
-#undef ME4000_PORT_DEBUG /* Debug port access */
-#undef ME4000_ISR_DEBUG /* Debug the interrupt service routine */
-#undef ME4000_DEBUG /* General purpose debug masseges */
-
-#ifdef ME4000_CALL_DEBUG
-#undef CALL_PDEBUG
-#define CALL_PDEBUG(fmt, args...) printk(KERN_DEBUG"comedi%d: me4000: " fmt, dev->minor, ##args)
-#else
-# define CALL_PDEBUG(fmt, args...) /* no debugging, do nothing */
-#endif
-
-#ifdef ME4000_PORT_DEBUG
-#undef PORT_PDEBUG
-#define PORT_PDEBUG(fmt, args...) printk(KERN_DEBUG"comedi%d: me4000: " fmt, dev->minor, ##args)
-#else
-#define PORT_PDEBUG(fmt, args...) /* no debugging, do nothing */
-#endif
-
-#ifdef ME4000_ISR_DEBUG
-#undef ISR_PDEBUG
-#define ISR_PDEBUG(fmt, args...) printk(KERN_DEBUG"comedi%d: me4000: " fmt, dev->minor, ##args)
-#else
-#define ISR_PDEBUG(fmt, args...) /* no debugging, do nothing */
-#endif
-
-#ifdef ME4000_DEBUG
-#undef PDEBUG
-#define PDEBUG(fmt, args...) printk(KERN_DEBUG"comedi%d: me4000: " fmt, dev->minor, ##args)
-#else
-#define PDEBUG(fmt, args...) /* no debugging, do nothing */
-#endif
-
/*=============================================================================
PCI vendor and device IDs
===========================================================================*/
#include <linux/sched.h>
#include "../comedidev.h"
-#include "comedi_pci.h"
-
/*#include "me2600_fw.h" */
#define ME_DRIVER_NAME "me_daq"
data[1] |= readw(dev_private->me_regbase + ME_DIO_PORT_B) << 16;
}
- return 2;
+ return insn->n;
}
/*
me_reset(dev);
- /* device driver capabilities */
- error = alloc_subdevices(dev, 3);
- if (error < 0)
+ error = comedi_alloc_subdevices(dev, 3);
+ if (error)
return error;
subdevice = dev->subdevices + 0;
#include "mite.h"
#include "comedi_fc.h"
-#include "comedi_pci.h"
#include "../comedidev.h"
{
struct comedi_subdevice *s;
unsigned long iobase;
+ int ret;
iobase = it->options[0];
printk(KERN_INFO "comedi%d: mpc624 [0x%04lx, ", dev->minor, iobase);
devpriv->ulConvertionRate = MPC624_SPEED_3_52_kHz;
}
- /* Subdevices structures */
- if (alloc_subdevices(dev, 1) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
s->type = COMEDI_SUBD_AI;
p = cpm_pdat((int)s->private);
- return 2;
+ return insn->n;
}
static int mpc8260cpm_attach(struct comedi_device *dev,
{
struct comedi_subdevice *s;
int i;
+ int ret;
printk("comedi%d: mpc8260cpm: ", dev->minor);
if (alloc_private(dev, sizeof(struct mpc8260cpm_private)) < 0)
return -ENOMEM;
- if (alloc_subdevices(dev, 4) < 0)
- return -ENOMEM;
+ ret =comedi_alloc_subdevices(dev, 4);
+ if (ret)
+ return ret;
for (i = 0; i < 4; i++) {
s = dev->subdevices + i;
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inw(dev->iobase + MULTIQ3_DIGIN_PORT);
- return 2;
+ return insn->n;
}
static int multiq3_do_insn_bits(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
outw(s->state, dev->iobase + MULTIQ3_DIGOUT_PORT);
data[1] = s->state;
- return 2;
+ return insn->n;
}
static int multiq3_encoder_insn_read(struct comedi_device *dev,
else
printk(KERN_WARNING "comedi%d: no irq\n", dev->minor);
dev->board_name = "multiq3";
- result = alloc_subdevices(dev, 5);
- if (result < 0)
+
+ result = comedi_alloc_subdevices(dev, 5);
+ if (result)
return result;
result = alloc_private(dev, sizeof(struct multiq3_private));
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = readb(devpriv->mite->daq_io_addr + Port_Register(0));
data[1] |= readb(devpriv->mite->daq_io_addr + Port_Register(1)) << 8;
data[1] |= readb(devpriv->mite->daq_io_addr + Port_Register(2)) << 16;
- return 2;
+ return insn->n;
}
static int ni6527_do_insn_bits(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
}
data[1] = s->state;
- return 2;
+ return insn->n;
}
static irqreturn_t ni6527_interrupt(int irq, void *d)
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n < 1)
- return -EINVAL;
-
data[1] = 0;
- return 2;
+ return insn->n;
}
static int ni6527_intr_insn_config(struct comedi_device *dev,
printk(KERN_INFO "comedi board: %s, ID=0x%02x\n", dev->board_name,
readb(devpriv->mite->daq_io_addr + ID_Register));
- ret = alloc_subdevices(dev, 3);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
return ret;
s = dev->subdevices + 0;
const unsigned max_ports_per_bitfield = 5;
unsigned read_bits = 0;
unsigned j;
- if (insn->n != 2)
- return -EINVAL;
+
base_bitfield_channel = CR_CHAN(insn->chanspec);
for (j = 0; j < max_ports_per_bitfield; ++j) {
const unsigned port_offset =
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n < 1)
- return -EINVAL;
-
data[1] = 0;
- return 2;
+ return insn->n;
}
static int ni_65xx_intr_insn_config(struct comedi_device *dev,
printk(KERN_INFO " ID=0x%02x",
readb(private(dev)->mite->daq_io_addr + ID_Register));
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
s = dev->subdevices + 0;
printk(KERN_INFO " %s ", dev->board_name);
- dev->n_subdevices = 2 + NI_660X_MAX_NUM_COUNTERS;
-
- if (alloc_subdevices(dev, dev->n_subdevices) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 2 + NI_660X_MAX_NUM_COUNTERS);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* Old GENERAL-PURPOSE COUNTER/TIME (GPCT) subdevice, no longer used */
data[1] =
(ni_660x_read_register(dev, 0,
DIO32Input) >> base_bitfield_channel);
- return 2;
+ return insn->n;
}
static void ni_660x_select_pfi_output(struct comedi_device *dev,
dev->irq = mite_irq(devpriv->mite);
printk(KERN_INFO " %s", dev->board_name);
- if (alloc_subdevices(dev, 2) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 2);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* analog output subdevice */
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
/* The insn data is a mask in data[0] and the new data
* in data[1], each channel cooresponding to a bit. */
if (data[0]) {
* input lines. */
data[1] = readl(devpriv->mite->daq_io_addr + DIO_PORT0_DATA_OFFSET);
- return 2;
+ return insn->n;
}
static int ni_670x_dio_insn_config(struct comedi_device *dev,
unsigned int dma = it->options[2];
static const int timeout = 2000;
int i;
+ int ret;
printk("comedi%d: %s: io 0x%lx", dev->minor, dev->driver->driver_name,
iobase);
dev->board_ptr = a2150_boards + a2150_probe(dev);
dev->board_name = thisboard->name;
- if (alloc_subdevices(dev, 1) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
/* analog input subdevice */
s = dev->subdevices + 0;
int n_ao_chans;
};
-#define thisboard ((struct atao_board *)dev->board_ptr)
-
struct atao_private {
unsigned short cfg1;
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= data[0] & data[1];
data[1] = inw(dev->iobase + ATAO_DIN);
- return 2;
+ return insn->n;
}
static int atao_dio_insn_config(struct comedi_device *dev,
static int atao_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct atao_board *board = comedi_board(dev);
struct comedi_subdevice *s;
unsigned long iobase;
int ao_unipolar;
+ int ret;
iobase = it->options[0];
if (iobase == 0)
}
dev->iobase = iobase;
- /* dev->board_ptr = atao_probe(dev); */
-
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
if (alloc_private(dev, sizeof(struct atao_private)) < 0)
return -ENOMEM;
- if (alloc_subdevices(dev, 4) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* analog output subdevice */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE;
- s->n_chan = thisboard->n_ao_chans;
+ s->n_chan = board->n_ao_chans;
s->maxdata = (1 << 12) - 1;
if (ao_unipolar)
s->range_table = &range_unipolar10;
int has_8255;
};
-#define boardtype ((const struct atmio16_board_t *)dev->board_ptr)
-
/* range structs */
static const struct comedi_lrange range_atmio16d_ai_10_bipolar = { 4, {
BIP_RANGE
struct comedi_device *dev = d;
struct comedi_subdevice *s = dev->subdevices + 0;
-#ifdef DEBUG1
- printk(KERN_DEBUG "atmio16d_interrupt!\n");
-#endif
-
comedi_buf_put(s->async, inw(dev->iobase + AD_FIFO_REG));
comedi_event(dev, s);
struct comedi_cmd *cmd)
{
int err = 0, tmp;
-#ifdef DEBUG1
- printk(KERN_DEBUG "atmio16d_ai_cmdtest\n");
-#endif
+
/* make sure triggers are valid */
tmp = cmd->start_src;
cmd->start_src &= TRIG_NOW;
unsigned int timer, base_clock;
unsigned int sample_count, tmp, chan, gain;
int i;
-#ifdef DEBUG1
- printk(KERN_DEBUG "atmio16d_ai_cmd\n");
-#endif
+
/* This is slowly becoming a working command interface. *
* It is still uber-experimental */
int gain;
int status;
-#ifdef DEBUG1
- printk(KERN_DEBUG "atmio16d_ai_insn_read\n");
-#endif
chan = CR_CHAN(insn->chanspec);
gain = CR_RANGE(insn->chanspec);
for (t = 0; t < ATMIO16D_TIMEOUT; t++) {
/* check conversion status */
status = inw(dev->iobase + STAT_REG);
-#ifdef DEBUG1
- printk(KERN_DEBUG "status=%x\n", status);
-#endif
if (status & STAT_AD_CONVAVAIL) {
/* read the data now */
data[i] = inw(dev->iobase + AD_FIFO_REG);
struct comedi_insn *insn, unsigned int *data)
{
int i;
-#ifdef DEBUG1
- printk(KERN_DEBUG "atmio16d_ao_insn_read\n");
-#endif
for (i = 0; i < insn->n; i++)
data[i] = devpriv->ao_readback[CR_CHAN(insn->chanspec)];
int i;
int chan;
int d;
-#ifdef DEBUG1
- printk(KERN_DEBUG "atmio16d_ao_insn_write\n");
-#endif
chan = CR_CHAN(insn->chanspec);
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] | data[1]);
}
data[1] = inw(dev->iobase + MIO_16_DIG_IN_REG);
- return 2;
+ return insn->n;
}
static int atmio16d_dio_insn_config(struct comedi_device *dev,
static int atmio16d_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ const struct atmio16_board_t *board = comedi_board(dev);
unsigned int irq;
unsigned long iobase;
int ret;
}
dev->iobase = iobase;
- /* board name */
- dev->board_name = boardtype->name;
+ dev->board_name = board->name;
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
ret = alloc_private(dev, sizeof(struct atmio16d_private));
/* 8255 subdevice */
s++;
- if (boardtype->has_8255)
+ if (board->has_8255)
subdev_8255_init(dev, s, NULL, dev->iobase);
else
s->type = COMEDI_SUBD_UNUSED;
static void atmio16d_detach(struct comedi_device *dev)
{
- if (dev->subdevices && boardtype->has_8255)
+ const struct atmio16_board_t *board = comedi_board(dev);
+
+ if (dev->subdevices && board->has_8255)
subdev_8255_cleanup(dev, dev->subdevices + 3);
if (dev->irq)
free_irq(dev->irq, dev);
Direction configuration: channels 0-7 output, 8-15 input (8225 device
emu as port A output, port B input, port C N/A).
-
-IRQ is assigned but not used.
*/
#include <linux/interrupt.h>
static struct pcmcia_device *pcmcia_cur_dev;
-#define DIO700_SIZE 8 /* size of io region used by board */
-
-static int dio700_attach(struct comedi_device *dev,
- struct comedi_devconfig *it);
-static void dio700_detach(struct comedi_device *dev);
-
-enum dio700_bustype { pcmcia_bustype };
-
struct dio700_board {
const char *name;
- int device_id; /* device id for pcmcia board */
- enum dio700_bustype bustype; /* PCMCIA */
- int have_dio; /* have daqcard-700 dio */
- /* function pointers so we can use inb/outb or readb/writeb */
- /* as appropriate */
- unsigned int (*read_byte) (unsigned int address);
- void (*write_byte) (unsigned int byte, unsigned int address);
-};
-
-static const struct dio700_board dio700_boards[] = {
- {
- .name = "daqcard-700",
- /* 0x10b is manufacturer id, 0x4743 is device id */
- .device_id = 0x4743,
- .bustype = pcmcia_bustype,
- .have_dio = 1,
- },
- {
- .name = "ni_daq_700",
- /* 0x10b is manufacturer id, 0x4743 is device id */
- .device_id = 0x4743,
- .bustype = pcmcia_bustype,
- .have_dio = 1,
- },
-};
-
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((const struct dio700_board *)dev->board_ptr)
-
-struct dio700_private {
-
- int data; /* number of data points left to be taken */
};
-#define devpriv ((struct dio700_private *)dev->private)
-
-static struct comedi_driver driver_dio700 = {
- .driver_name = "ni_daq_700",
- .module = THIS_MODULE,
- .attach = dio700_attach,
- .detach = dio700_detach,
- .num_names = ARRAY_SIZE(dio700_boards),
- .board_name = &dio700_boards[0].name,
- .offset = sizeof(struct dio700_board),
-};
-
-/* the real driver routines */
-
-#define _700_SIZE 8
-
-#define _700_DATA 0
-
#define DIO_W 0x04
#define DIO_R 0x05
-struct subdev_700_struct {
- unsigned long cb_arg;
- int (*cb_func) (int, int, int, unsigned long);
- int have_irq;
-};
-
-#define CALLBACK_ARG (((struct subdev_700_struct *)s->private)->cb_arg)
-#define CALLBACK_FUNC (((struct subdev_700_struct *)s->private)->cb_func)
-#define subdevpriv ((struct subdev_700_struct *)s->private)
-
-static void do_config(struct comedi_device *dev, struct comedi_subdevice *s);
-
-void subdev_700_interrupt(struct comedi_device *dev, struct comedi_subdevice *s)
-{
- short d;
-
- d = CALLBACK_FUNC(0, _700_DATA, 0, CALLBACK_ARG);
-
- comedi_buf_put(s->async, d);
- s->async->events |= COMEDI_CB_EOS;
-
- comedi_event(dev, s);
-}
-EXPORT_SYMBOL(subdev_700_interrupt);
-
-static int subdev_700_cb(int dir, int port, int data, unsigned long arg)
-{
- /* port is always A for output and B for input (8255 emu) */
- unsigned long iobase = arg;
-
- if (dir) {
- outb(data, iobase + DIO_W);
- return 0;
- } else {
- return inb(iobase + DIO_R);
- }
-}
-
static int subdev_700_insn(struct comedi_device *dev,
struct comedi_subdevice *s, struct comedi_insn *insn,
unsigned int *data)
s->state |= (data[0] & data[1]);
if (data[0] & 0xff)
- CALLBACK_FUNC(1, _700_DATA, s->state & 0xff,
- CALLBACK_ARG);
+ outb(s->state & 0xff, dev->iobase + DIO_W);
}
data[1] = s->state & 0xff;
- data[1] |= CALLBACK_FUNC(0, _700_DATA, 0, CALLBACK_ARG) << 8;
+ data[1] |= inb(dev->iobase + DIO_R);
- return 2;
+ return insn->n;
}
static int subdev_700_insn_config(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ unsigned int chan = 1 << CR_CHAN(insn->chanspec);
switch (data[0]) {
case INSN_CONFIG_DIO_INPUT:
case INSN_CONFIG_DIO_OUTPUT:
break;
case INSN_CONFIG_DIO_QUERY:
- data[1] =
- (s->
- io_bits & (1 << CR_CHAN(insn->chanspec))) ? COMEDI_OUTPUT :
- COMEDI_INPUT;
- return insn->n;
+ data[1] = (s->io_bits & chan) ? COMEDI_OUTPUT : COMEDI_INPUT;
break;
default:
return -EINVAL;
}
- return 1;
-}
-
-static void do_config(struct comedi_device *dev, struct comedi_subdevice *s)
-{ /* use powerup defaults */
- return;
-}
-
-static int subdev_700_cmdtest(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_cmd *cmd)
-{
- int err = 0;
- unsigned int tmp;
-
- /* step 1 */
-
- tmp = cmd->start_src;
- cmd->start_src &= TRIG_NOW;
- if (!cmd->start_src || tmp != cmd->start_src)
- err++;
-
- tmp = cmd->scan_begin_src;
- cmd->scan_begin_src &= TRIG_EXT;
- if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
- err++;
-
- tmp = cmd->convert_src;
- cmd->convert_src &= TRIG_FOLLOW;
- if (!cmd->convert_src || tmp != cmd->convert_src)
- err++;
-
- tmp = cmd->scan_end_src;
- cmd->scan_end_src &= TRIG_COUNT;
- if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
- err++;
-
- tmp = cmd->stop_src;
- cmd->stop_src &= TRIG_NONE;
- if (!cmd->stop_src || tmp != cmd->stop_src)
- err++;
-
- if (err)
- return 1;
-
- /* step 2 */
-
- if (err)
- return 2;
-
- /* step 3 */
-
- if (cmd->start_arg != 0) {
- cmd->start_arg = 0;
- err++;
- }
- if (cmd->scan_begin_arg != 0) {
- cmd->scan_begin_arg = 0;
- err++;
- }
- if (cmd->convert_arg != 0) {
- cmd->convert_arg = 0;
- err++;
- }
- if (cmd->scan_end_arg != 1) {
- cmd->scan_end_arg = 1;
- err++;
- }
- if (cmd->stop_arg != 0) {
- cmd->stop_arg = 0;
- err++;
- }
-
- if (err)
- return 3;
-
- /* step 4 */
-
- if (err)
- return 4;
-
- return 0;
-}
-
-static int subdev_700_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
-{
- /* FIXME */
-
- return 0;
-}
-
-static int subdev_700_cancel(struct comedi_device *dev,
- struct comedi_subdevice *s)
-{
- /* FIXME */
-
- return 0;
-}
-
-int subdev_700_init(struct comedi_device *dev, struct comedi_subdevice *s,
- int (*cb) (int, int, int, unsigned long), unsigned long arg)
-{
- s->type = COMEDI_SUBD_DIO;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = 16;
- s->range_table = &range_digital;
- s->maxdata = 1;
-
- s->private = kmalloc(sizeof(struct subdev_700_struct), GFP_KERNEL);
- if (!s->private)
- return -ENOMEM;
-
- CALLBACK_ARG = arg;
- if (cb == NULL)
- CALLBACK_FUNC = subdev_700_cb;
- else
- CALLBACK_FUNC = cb;
-
- s->insn_bits = subdev_700_insn;
- s->insn_config = subdev_700_insn_config;
-
- s->state = 0;
- s->io_bits = 0x00ff;
- do_config(dev, s);
-
- return 0;
-}
-EXPORT_SYMBOL(subdev_700_init);
-
-int subdev_700_init_irq(struct comedi_device *dev, struct comedi_subdevice *s,
- int (*cb) (int, int, int, unsigned long),
- unsigned long arg)
-{
- int ret;
-
- ret = subdev_700_init(dev, s, cb, arg);
- if (ret < 0)
- return ret;
-
- s->do_cmdtest = subdev_700_cmdtest;
- s->do_cmd = subdev_700_cmd;
- s->cancel = subdev_700_cancel;
-
- subdevpriv->have_irq = 1;
-
- return 0;
+ return insn->n;
}
-EXPORT_SYMBOL(subdev_700_init_irq);
-
-void subdev_700_cleanup(struct comedi_device *dev, struct comedi_subdevice *s)
-{
- if (s->private)
- if (subdevpriv->have_irq)
-
- kfree(s->private);
-}
-EXPORT_SYMBOL(subdev_700_cleanup);
static int dio700_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct dio700_board *thisboard = comedi_board(dev);
struct comedi_subdevice *s;
- unsigned long iobase = 0;
-#ifdef incomplete
- unsigned int irq = 0;
-#endif
struct pcmcia_device *link;
+ int ret;
- /* allocate and initialize dev->private */
- if (alloc_private(dev, sizeof(struct dio700_private)) < 0)
- return -ENOMEM;
-
- /* get base address, irq etc. based on bustype */
- switch (thisboard->bustype) {
- case pcmcia_bustype:
- link = pcmcia_cur_dev; /* XXX hack */
- if (!link)
- return -EIO;
- iobase = link->resource[0]->start;
-#ifdef incomplete
- irq = link->irq;
-#endif
- break;
- default:
- printk(KERN_ERR "bug! couldn't determine board type\n");
- return -EINVAL;
- break;
- }
- printk(KERN_ERR "comedi%d: ni_daq_700: %s, io 0x%lx", dev->minor,
- thisboard->name, iobase);
-#ifdef incomplete
- if (irq)
- printk(", irq %u", irq);
-
-#endif
-
- printk("\n");
+ link = pcmcia_cur_dev; /* XXX hack */
+ if (!link)
+ return -EIO;
- if (iobase == 0) {
- printk(KERN_ERR "io base address is zero!\n");
+ dev->iobase = link->resource[0]->start;
+ if (!dev->iobase) {
+ dev_err(dev->class_dev, "io base address is zero!\n");
return -EINVAL;
}
- dev->iobase = iobase;
-
-#ifdef incomplete
- /* grab our IRQ */
- dev->irq = irq;
-#endif
-
dev->board_name = thisboard->name;
- if (alloc_subdevices(dev, 1) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
/* DAQCard-700 dio */
s = dev->subdevices + 0;
- subdev_700_init(dev, s, NULL, dev->iobase);
+ s->type = COMEDI_SUBD_DIO;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ s->n_chan = 16;
+ s->range_table = &range_digital;
+ s->maxdata = 1;
+ s->insn_bits = subdev_700_insn;
+ s->insn_config = subdev_700_insn_config;
+
+ s->state = 0;
+ s->io_bits = 0x00ff;
+
+ dev_info(dev->class_dev, "%s: %s, io 0x%lx\n",
+ dev->driver->driver_name,
+ dev->board_name,
+ dev->iobase);
return 0;
-};
+}
static void dio700_detach(struct comedi_device *dev)
{
- if (dev->subdevices)
- subdev_700_cleanup(dev, dev->subdevices + 0);
- if (thisboard->bustype != pcmcia_bustype && dev->iobase)
- release_region(dev->iobase, DIO700_SIZE);
- if (dev->irq)
- free_irq(dev->irq, dev);
-};
-
-static void dio700_config(struct pcmcia_device *link);
-static void dio700_release(struct pcmcia_device *link);
-static int dio700_cs_suspend(struct pcmcia_device *p_dev);
-static int dio700_cs_resume(struct pcmcia_device *p_dev);
-
-static int dio700_cs_attach(struct pcmcia_device *);
-static void dio700_cs_detach(struct pcmcia_device *);
+ /* nothing to cleanup */
+}
-struct local_info_t {
- struct pcmcia_device *link;
- int stop;
- struct bus_operations *bus;
+static const struct dio700_board dio700_boards[] = {
+ {
+ .name = "daqcard-700",
+ }, {
+ .name = "ni_daq_700",
+ },
};
-static int dio700_cs_attach(struct pcmcia_device *link)
-{
- struct local_info_t *local;
-
- printk(KERN_INFO "ni_daq_700: cs-attach\n");
-
- dev_dbg(&link->dev, "dio700_cs_attach()\n");
-
- /* Allocate space for private device-specific data */
- local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
- if (!local)
- return -ENOMEM;
- local->link = link;
- link->priv = local;
-
- pcmcia_cur_dev = link;
-
- dio700_config(link);
-
- return 0;
-} /* dio700_cs_attach */
-
-static void dio700_cs_detach(struct pcmcia_device *link)
-{
- ((struct local_info_t *)link->priv)->stop = 1;
- dio700_release(link);
-
- /* This points to the parent struct local_info_t struct */
- kfree(link->priv);
-}
+static struct comedi_driver driver_dio700 = {
+ .driver_name = "ni_daq_700",
+ .module = THIS_MODULE,
+ .attach = dio700_attach,
+ .detach = dio700_detach,
+ .board_name = &dio700_boards[0].name,
+ .num_names = ARRAY_SIZE(dio700_boards),
+ .offset = sizeof(struct dio700_board),
+};
static int dio700_pcmcia_config_loop(struct pcmcia_device *p_dev,
void *priv_data)
return pcmcia_request_io(p_dev);
}
-static void dio700_config(struct pcmcia_device *link)
+static int dio700_cs_attach(struct pcmcia_device *link)
{
int ret;
- printk(KERN_INFO "ni_daq_700: cs-config\n");
-
- dev_dbg(&link->dev, "dio700_config\n");
-
link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_AUDIO |
CONF_AUTO_SET_IO;
ret = pcmcia_loop_config(link, dio700_pcmcia_config_loop, NULL);
- if (ret) {
- dev_warn(&link->dev, "no configuration found\n");
+ if (ret)
goto failed;
- }
if (!link->irq)
goto failed;
ret = pcmcia_enable_device(link);
- if (ret != 0)
+ if (ret)
goto failed;
- return;
+ pcmcia_cur_dev = link;
+ return 0;
failed:
- printk(KERN_INFO "ni_daq_700 cs failed");
- dio700_release(link);
-
-} /* dio700_config */
-
-static void dio700_release(struct pcmcia_device *link)
-{
- dev_dbg(&link->dev, "dio700_release\n");
-
pcmcia_disable_device(link);
-} /* dio700_release */
-
-static int dio700_cs_suspend(struct pcmcia_device *link)
-{
- struct local_info_t *local = link->priv;
-
- /* Mark the device as stopped, to block IO until later */
- local->stop = 1;
- return 0;
-} /* dio700_cs_suspend */
+ return ret;
+}
-static int dio700_cs_resume(struct pcmcia_device *link)
+static void dio700_cs_detach(struct pcmcia_device *link)
{
- struct local_info_t *local = link->priv;
-
- local->stop = 0;
- return 0;
-} /* dio700_cs_resume */
-
-/*====================================================================*/
+ pcmcia_disable_device(link);
+ pcmcia_cur_dev = NULL;
+}
static const struct pcmcia_device_id dio700_cs_ids[] = {
- /* N.B. These IDs should match those in dio700_boards */
- PCMCIA_DEVICE_MANF_CARD(0x010b, 0x4743), /* daqcard-700 */
+ PCMCIA_DEVICE_MANF_CARD(0x010b, 0x4743),
PCMCIA_DEVICE_NULL
};
-
-
MODULE_DEVICE_TABLE(pcmcia, dio700_cs_ids);
-MODULE_AUTHOR("Fred Brooks <nsaspook@nsaspook.com>");
-MODULE_DESCRIPTION("Comedi driver for National Instruments "
- "PCMCIA DAQCard-700 DIO");
-MODULE_LICENSE("GPL");
-struct pcmcia_driver dio700_cs_driver = {
- .probe = dio700_cs_attach,
- .remove = dio700_cs_detach,
- .suspend = dio700_cs_suspend,
- .resume = dio700_cs_resume,
- .id_table = dio700_cs_ids,
- .owner = THIS_MODULE,
- .name = "ni_daq_700",
+static struct pcmcia_driver dio700_cs_driver = {
+ .name = "ni_daq_700",
+ .owner = THIS_MODULE,
+ .probe = dio700_cs_attach,
+ .remove = dio700_cs_detach,
+ .id_table = dio700_cs_ids,
};
-static int __init init_dio700_cs(void)
-{
- pcmcia_register_driver(&dio700_cs_driver);
- return 0;
-}
-
-static void __exit exit_dio700_cs(void)
-{
- pr_debug("ni_daq_700: unloading\n");
- pcmcia_unregister_driver(&dio700_cs_driver);
-}
-
-int __init init_module(void)
+static int __init dio700_cs_init(void)
{
int ret;
- ret = init_dio700_cs();
+ ret = comedi_driver_register(&driver_dio700);
if (ret < 0)
return ret;
- return comedi_driver_register(&driver_dio700);
+ ret = pcmcia_register_driver(&dio700_cs_driver);
+ if (ret < 0) {
+ comedi_driver_unregister(&driver_dio700);
+ return ret;
+ }
+
+ return 0;
}
+module_init(dio700_cs_init);
-void __exit cleanup_module(void)
+static void __exit dio700_cs_exit(void)
{
- exit_dio700_cs();
+ pcmcia_unregister_driver(&dio700_cs_driver);
comedi_driver_unregister(&driver_dio700);
}
+module_exit(dio700_cs_exit);
+
+MODULE_AUTHOR("Fred Brooks <nsaspook@nsaspook.com>");
+MODULE_DESCRIPTION(
+ "Comedi driver for National Instruments PCMCIA DAQCard-700 DIO");
+MODULE_LICENSE("GPL");
unsigned int irq = 0;
#endif
struct pcmcia_device *link;
+ int ret;
/* allocate and initialize dev->private */
if (alloc_private(dev, sizeof(struct dio24_private)) < 0)
dev->board_name = thisboard->name;
- if (alloc_subdevices(dev, 1) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
/* 8255 dio */
s = dev->subdevices + 0;
unsigned long dma_flags;
#endif
short lsb, msb;
+ int ret;
printk(KERN_ERR "comedi%d: ni_labpc: %s, io 0x%lx", dev->minor,
thisboard->name,
dev->board_name = thisboard->name;
- if (alloc_subdevices(dev, 5) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 5);
+ if (ret)
+ return ret;
/* analog input subdevice */
s = dev->subdevices + 0;
break;
default:
comedi_error(dev, "bug with start_src");
+ spin_unlock_irqrestore(&dev->spinlock, flags);
return -1;
break;
}
break;
default:
comedi_error(dev, "bug with stop_src");
+ spin_unlock_irqrestore(&dev->spinlock, flags);
return -1;
}
devpriv->write_byte(devpriv->command2_bits, dev->iobase + COMMAND2_REG);
#ifdef DEBUG_DIO
printk("ni_dio_insn_bits() mask=0x%x bits=0x%x\n", data[0], data[1]);
#endif
- if (insn->n != 2)
- return -EINVAL;
+
if (data[0]) {
/* Perform check to make sure we're not using the
serial part of the dio */
}
data[1] = devpriv->stc_readw(dev, DIO_Parallel_Input_Register);
- return 2;
+ return insn->n;
}
static int ni_m_series_dio_insn_config(struct comedi_device *dev,
printk("ni_m_series_dio_insn_bits() mask=0x%x bits=0x%x\n", data[0],
data[1]);
#endif
- if (insn->n != 2)
- return -EINVAL;
+
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
}
data[1] = ni_readl(M_Offset_Static_Digital_Input);
- return 2;
+ return insn->n;
}
static int ni_cdio_cmdtest(struct comedi_device *dev,
struct comedi_subdevice *s;
unsigned j;
enum ni_gpct_variant counter_variant;
+ int ret;
if (boardtype.n_aochan > MAX_N_AO_CHAN) {
printk("bug! boardtype.n_aochan > MAX_N_AO_CHAN\n");
return -EINVAL;
}
- if (alloc_subdevices(dev, NI_NUM_SUBDEVICES) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, NI_NUM_SUBDEVICES);
+ if (ret)
+ return ret;
/* analog input subdevice */
ni_writew(s->state, M_Offset_PFI_DO);
}
data[1] = ni_readw(M_Offset_PFI_DI);
- return 2;
+ return insn->n;
}
static int ni_pfi_insn_config(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = 0;
- return 2;
+ return insn->n;
}
/* Find best multiplier/divider to try and get the PLL running at 80 MHz
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
}
data[1] = readl(devpriv->mite->daq_io_addr + Port_IO(0));
- return 2;
+ return insn->n;
}
static int ni_pcidio_cmdtest(struct comedi_device *dev,
else
n_subdevices = 1;
- ret = alloc_subdevices(dev, n_subdevices);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, n_subdevices);
+ if (ret)
return ret;
if (!this_board->is_diodaq) {
{
int ret;
- dev_info(dev->hw_dev, "comedi%d: ni_pcimio:\n", dev->minor);
+ dev_info(dev->class_dev, "ni_pcimio: attach\n");
ret = ni_alloc_private(dev);
if (ret < 0)
if (ret < 0)
return ret;
- dev_dbg(dev->hw_dev, "%s\n", boardtype.name);
+ dev_dbg(dev->class_dev, "%s\n", boardtype.name);
dev->board_name = boardtype.name;
if (boardtype.reg_type & ni_reg_m_series_mask) {
const struct comedi_lrange *ai_range_type;
};
-#define this_board ((const struct pcl711_board *)dev->board_ptr)
-
struct pcl711_private {
int board;
int lo, hi;
int data;
struct comedi_device *dev = d;
+ const struct pcl711_board *board = comedi_board(dev);
struct comedi_subdevice *s = dev->subdevices + 0;
if (!dev->attached) {
/* FIXME! Nothing else sets ntrig! */
if (!(--devpriv->ntrig)) {
- if (this_board->is_8112)
+ if (board->is_8112)
outb(1, dev->iobase + PCL711_MODE);
else
outb(0, dev->iobase + PCL711_MODE);
static void pcl711_set_changain(struct comedi_device *dev, int chan)
{
+ const struct pcl711_board *board = comedi_board(dev);
int chan_register;
outb(CR_RANGE(chan), dev->iobase + PCL711_GAIN);
chan_register = CR_CHAN(chan);
- if (this_board->is_8112) {
+ if (board->is_8112) {
/*
* Set the correct channel. The two channel banks are switched
static int pcl711_ai_insn(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ const struct pcl711_board *board = comedi_board(dev);
int i, n;
int hi, lo;
*/
outb(1, dev->iobase + PCL711_MODE);
- if (!this_board->is_8112)
+ if (!board->is_8112)
outb(0, dev->iobase + PCL711_SOFTTRIG);
i = PCL711_TIMEOUT;
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inb(dev->iobase + PCL711_DI_LO) |
(inb(dev->iobase + PCL711_DI_HI) << 8);
- return 2;
+ return insn->n;
}
/* Digital port write - Untested on 8112 */
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= data[0] & data[1];
data[1] = s->state;
- return 2;
+ return insn->n;
}
static int pcl711_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct pcl711_board *board = comedi_board(dev);
int ret;
unsigned long iobase;
unsigned int irq;
/* there should be a sanity check here */
- /* set up some name stuff */
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
/* grab our IRQ */
irq = it->options[1];
- if (irq > this_board->maxirq) {
+ if (irq > board->maxirq) {
printk(KERN_ERR "irq out of range\n");
return -EINVAL;
}
}
dev->irq = irq;
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
ret = alloc_private(dev, sizeof(struct pcl711_private));
/* AI subdevice */
s->type = COMEDI_SUBD_AI;
s->subdev_flags = SDF_READABLE | SDF_GROUND;
- s->n_chan = this_board->n_aichan;
+ s->n_chan = board->n_aichan;
s->maxdata = 0xfff;
s->len_chanlist = 1;
- s->range_table = this_board->ai_range_type;
+ s->range_table = board->ai_range_type;
s->insn_read = pcl711_ai_insn;
if (irq) {
dev->read_subdev = s;
/* AO subdevice */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE;
- s->n_chan = this_board->n_aochan;
+ s->n_chan = board->n_aochan;
s->maxdata = 0xfff;
s->len_chanlist = 1;
s->range_table = &range_bipolar5;
this is the "base value" for the mode register, which is
used for the irq on the PCL711
*/
- if (this_board->is_pcl711b)
+ if (board->is_pcl711b)
devpriv->mode = (dev->irq << 4);
/* clear DAC */
char is_pet48;
};
-#define this_board ((const struct pcl724_board *)dev->board_ptr)
-
static int subdev_8255_cb(int dir, int port, int data, unsigned long arg)
{
unsigned long iobase = arg;
static int pcl724_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct pcl724_board *board = comedi_board(dev);
unsigned long iobase;
unsigned int iorange;
int ret, i, n_subdevices;
#endif
iobase = it->options[0];
- iorange = this_board->io_range;
- if ((this_board->can_have96) && ((it->options[1] == 1)
+ iorange = board->io_range;
+ if ((board->can_have96) && ((it->options[1] == 1)
|| (it->options[1] == 96)))
iorange = PCL722_96_SIZE; /* PCL-724 in 96 DIO configuration */
printk(KERN_INFO "comedi%d: pcl724: board=%s, 0x%03lx ", dev->minor,
- this_board->name, iobase);
+ board->name, iobase);
if (!request_region(iobase, iorange, "pcl724")) {
printk("I/O port conflict\n");
return -EIO;
dev->iobase = iobase;
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
#ifdef PCL724_IRQ
irq = 0;
- if (this_board->IRQbits != 0) { /* board support IRQ */
+ if (board->IRQbits != 0) { /* board support IRQ */
irq = it->options[1];
if (irq) { /* we want to use IRQ */
- if (((1 << irq) & this_board->IRQbits) == 0) {
+ if (((1 << irq) & board->IRQbits) == 0) {
printk(KERN_WARNING
", IRQ %u is out of allowed range, "
"DISABLING IT", irq);
printk("\n");
- n_subdevices = this_board->numofports;
- if ((this_board->can_have96) && ((it->options[1] == 1)
+ n_subdevices = board->numofports;
+ if ((board->can_have96) && ((it->options[1] == 1)
|| (it->options[1] == 96)))
n_subdevices = 4; /* PCL-724 in 96 DIO configuration */
- ret = alloc_subdevices(dev, n_subdevices);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, n_subdevices);
+ if (ret)
return ret;
for (i = 0; i < dev->n_subdevices; i++) {
- if (this_board->is_pet48) {
+ if (board->is_pet48) {
subdev_8255_init(dev, dev->subdevices + i,
subdev_8255mapped_cb,
(unsigned long)(dev->iobase +
static void pcl724_detach(struct comedi_device *dev)
{
+ const struct pcl724_board *board = comedi_board(dev);
int i;
for (i = 0; i < dev->n_subdevices; i++)
if (dev->irq)
free_irq(dev->irq, dev);
#endif
- release_region(dev->iobase, this_board->io_range);
+ release_region(dev->iobase, board->io_range);
}
static const struct pcl724_board boardtypes[] = {
static int pcl725_do_insn(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
data[1] = s->state;
- return 2;
+ return insn->n;
}
static int pcl725_di_insn(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inb(dev->iobase + PCL725_DI);
- return 2;
+ return insn->n;
}
static int pcl725_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
struct comedi_subdevice *s;
unsigned long iobase;
+ int ret;
iobase = it->options[0];
printk(KERN_INFO "comedi%d: pcl725: 0x%04lx ", dev->minor, iobase);
dev->iobase = iobase;
dev->irq = 0;
- if (alloc_subdevices(dev, 2) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 2);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* do */
&rangelist_728[0],},
};
-#define this_board ((const struct pcl726_board *)dev->board_ptr)
-
struct pcl726_private {
int bipolar[12];
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
+ const struct pcl726_board *board = comedi_board(dev);
- data[1] = inb(dev->iobase + this_board->di_lo) |
- (inb(dev->iobase + this_board->di_hi) << 8);
+ data[1] = inb(dev->iobase + board->di_lo) |
+ (inb(dev->iobase + board->di_hi) << 8);
- return 2;
+ return insn->n;
}
static int pcl726_do_insn_bits(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
+ const struct pcl726_board *board = comedi_board(dev);
if (data[0]) {
s->state &= ~data[0];
s->state |= data[0] & data[1];
}
if (data[1] & 0x00ff)
- outb(s->state & 0xff, dev->iobase + this_board->do_lo);
+ outb(s->state & 0xff, dev->iobase + board->do_lo);
if (data[1] & 0xff00)
- outb((s->state >> 8), dev->iobase + this_board->do_hi);
+ outb((s->state >> 8), dev->iobase + board->do_hi);
data[1] = s->state;
- return 2;
+ return insn->n;
}
static int pcl726_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct pcl726_board *board = comedi_board(dev);
struct comedi_subdevice *s;
unsigned long iobase;
unsigned int iorange;
#endif
iobase = it->options[0];
- iorange = this_board->io_range;
+ iorange = board->io_range;
printk(KERN_WARNING "comedi%d: pcl726: board=%s, 0x%03lx ", dev->minor,
- this_board->name, iobase);
+ board->name, iobase);
if (!request_region(iobase, iorange, "pcl726")) {
printk(KERN_WARNING "I/O port conflict\n");
return -EIO;
dev->iobase = iobase;
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
ret = alloc_private(dev, sizeof(struct pcl726_private));
if (ret < 0)
printk("\n");
- ret = alloc_subdevices(dev, 3);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
return ret;
s = dev->subdevices + 0;
/* ao */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
- s->n_chan = this_board->n_aochan;
+ s->n_chan = board->n_aochan;
s->maxdata = 0xfff;
s->len_chanlist = 1;
s->insn_write = pcl726_ao_insn;
s->insn_read = pcl726_ao_insn_read;
s->range_table_list = devpriv->rangelist;
- for (i = 0; i < this_board->n_aochan; i++) {
+ for (i = 0; i < board->n_aochan; i++) {
int j;
j = it->options[2 + 1];
- if ((j < 0) || (j >= this_board->num_of_ranges)) {
+ if ((j < 0) || (j >= board->num_of_ranges)) {
printk
("Invalid range for channel %d! Must be 0<=%d<%d\n",
- i, j, this_board->num_of_ranges - 1);
+ i, j, board->num_of_ranges - 1);
j = 0;
}
- devpriv->rangelist[i] = this_board->range_type_list[j];
+ devpriv->rangelist[i] = board->range_type_list[j];
if (devpriv->rangelist[i]->range[0].min ==
-devpriv->rangelist[i]->range[0].max)
devpriv->bipolar[i] = 1; /* bipolar range */
s = dev->subdevices + 1;
/* di */
- if (!this_board->have_dio) {
+ if (!board->have_dio) {
s->type = COMEDI_SUBD_UNUSED;
} else {
s->type = COMEDI_SUBD_DI;
s = dev->subdevices + 2;
/* do */
- if (!this_board->have_dio) {
+ if (!board->have_dio) {
s->type = COMEDI_SUBD_UNUSED;
} else {
s->type = COMEDI_SUBD_DO;
static void pcl726_detach(struct comedi_device *dev)
{
+ const struct pcl726_board *board = comedi_board(dev);
+
#ifdef ACL6126_IRQ
if (dev->irq)
free_irq(dev->irq, dev);
#endif
if (dev->iobase)
- release_region(dev->iobase, this_board->io_range);
+ release_region(dev->iobase, board->io_range);
}
static struct comedi_driver pcl726_driver = {
unsigned int io_range; /* len of I/O space */
};
-#define this_board ((const struct pcl730_board *)dev->board_ptr)
-
static int pcl730_do_insn(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
data[1] = s->state;
- return 2;
+ return insn->n;
}
static int pcl730_di_insn(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inb(dev->iobase + ((unsigned long)s->private)) |
(inb(dev->iobase + ((unsigned long)s->private) + 1) << 8);
- return 2;
+ return insn->n;
}
static int pcl730_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct pcl730_board *board = comedi_board(dev);
struct comedi_subdevice *s;
unsigned long iobase;
unsigned int iorange;
+ int ret;
iobase = it->options[0];
- iorange = this_board->io_range;
+ iorange = board->io_range;
printk(KERN_INFO "comedi%d: pcl730: board=%s 0x%04lx ", dev->minor,
- this_board->name, iobase);
+ board->name, iobase);
if (!request_region(iobase, iorange, "pcl730")) {
printk("I/O port conflict\n");
return -EIO;
}
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
dev->iobase = iobase;
dev->irq = 0;
- if (alloc_subdevices(dev, 4) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* Isolated do */
static void pcl730_detach(struct comedi_device *dev)
{
+ const struct pcl730_board *board = comedi_board(dev);
+
if (dev->iobase)
- release_region(dev->iobase, this_board->io_range);
+ release_region(dev->iobase, board->io_range);
}
static const struct pcl730_board boardtypes[] = {
#include "8253.h"
-/* if this is defined then a lot of messages is printed */
-#undef PCL812_EXTDEBUG
-
/* hardware types of the cards */
#define boardPCL812PG 0 /* and ACL-8112PG */
#define boardPCL813B 1
unsigned char haveMPC508; /* 1=board use MPC508A multiplexor */
};
-#define this_board ((const struct pcl812_board *)dev->board_ptr)
-
struct pcl812_private {
unsigned char valid; /* =1 device is OK */
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inb(dev->iobase + PCL812_DI_LO);
data[1] |= inb(dev->iobase + PCL812_DI_HI) << 8;
- return 2;
+ return insn->n;
}
/*
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= data[0] & data[1];
}
data[1] = s->state;
- return 2;
-}
-
-#ifdef PCL812_EXTDEBUG
-/*
-==============================================================================
-*/
-static void pcl812_cmdtest_out(int e, struct comedi_cmd *cmd)
-{
- printk(KERN_INFO "pcl812 e=%d startsrc=%x scansrc=%x convsrc=%x\n", e,
- cmd->start_src, cmd->scan_begin_src, cmd->convert_src);
- printk(KERN_INFO "pcl812 e=%d startarg=%d scanarg=%d convarg=%d\n", e,
- cmd->start_arg, cmd->scan_begin_arg, cmd->convert_arg);
- printk(KERN_INFO "pcl812 e=%d stopsrc=%x scanend=%x\n", e,
- cmd->stop_src, cmd->scan_end_src);
- printk(KERN_INFO "pcl812 e=%d stoparg=%d scanendarg=%d "
- "chanlistlen=%d\n", e, cmd->stop_arg, cmd->scan_end_arg,
- cmd->chanlist_len);
+ return insn->n;
}
-#endif
/*
==============================================================================
static int pcl812_ai_cmdtest(struct comedi_device *dev,
struct comedi_subdevice *s, struct comedi_cmd *cmd)
{
+ const struct pcl812_board *board = comedi_board(dev);
int err = 0;
int tmp, divisor1, divisor2;
-#ifdef PCL812_EXTDEBUG
- printk("pcl812 EDBG: BGN: pcl812_ai_cmdtest(...)\n");
- pcl812_cmdtest_out(-1, cmd);
-#endif
/* step 1: make sure trigger sources are trivially valid */
tmp = cmd->start_src;
if (!cmd->stop_src || tmp != cmd->stop_src)
err++;
- if (err) {
-#ifdef PCL812_EXTDEBUG
- pcl812_cmdtest_out(1, cmd);
- printk
- ("pcl812 EDBG: BGN: pcl812_ai_cmdtest(...) err=%d ret=1\n",
- err);
-#endif
+ if (err)
return 1;
- }
/*
* step 2: make sure trigger sources are
* unique and mutually compatible
*/
- if (cmd->start_src != TRIG_NOW) {
- cmd->start_src = TRIG_NOW;
- err++;
- }
-
- if (cmd->scan_begin_src != TRIG_FOLLOW) {
- cmd->scan_begin_src = TRIG_FOLLOW;
- err++;
- }
-
- if (devpriv->use_ext_trg) {
- if (cmd->convert_src != TRIG_EXT) {
- cmd->convert_src = TRIG_EXT;
- err++;
- }
- } else {
- if (cmd->convert_src != TRIG_TIMER) {
- cmd->convert_src = TRIG_TIMER;
- err++;
- }
- }
-
- if (cmd->scan_end_src != TRIG_COUNT) {
- cmd->scan_end_src = TRIG_COUNT;
- err++;
- }
-
if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
err++;
- if (err) {
-#ifdef PCL812_EXTDEBUG
- pcl812_cmdtest_out(2, cmd);
- printk
- ("pcl812 EDBG: BGN: pcl812_ai_cmdtest(...) err=%d ret=2\n",
- err);
-#endif
+ if (err)
return 2;
- }
/* step 3: make sure arguments are trivially compatible */
}
if (cmd->convert_src == TRIG_TIMER) {
- if (cmd->convert_arg < this_board->ai_ns_min) {
- cmd->convert_arg = this_board->ai_ns_min;
+ if (cmd->convert_arg < board->ai_ns_min) {
+ cmd->convert_arg = board->ai_ns_min;
err++;
}
} else { /* TRIG_EXT */
err++;
}
if (cmd->chanlist_len > MAX_CHANLIST_LEN) {
- cmd->chanlist_len = this_board->n_aichan;
+ cmd->chanlist_len = board->n_aichan;
err++;
}
if (cmd->scan_end_arg != cmd->chanlist_len) {
}
}
- if (err) {
-#ifdef PCL812_EXTDEBUG
- pcl812_cmdtest_out(3, cmd);
- printk
- ("pcl812 EDBG: BGN: pcl812_ai_cmdtest(...) err=%d ret=3\n",
- err);
-#endif
+ if (err)
return 3;
- }
/* step 4: fix up any arguments */
if (cmd->convert_src == TRIG_TIMER) {
tmp = cmd->convert_arg;
- i8253_cascade_ns_to_timer(this_board->i8254_osc_base, &divisor1,
+ i8253_cascade_ns_to_timer(board->i8254_osc_base, &divisor1,
&divisor2, &cmd->convert_arg,
cmd->flags & TRIG_ROUND_MASK);
- if (cmd->convert_arg < this_board->ai_ns_min)
- cmd->convert_arg = this_board->ai_ns_min;
+ if (cmd->convert_arg < board->ai_ns_min)
+ cmd->convert_arg = board->ai_ns_min;
if (tmp != cmd->convert_arg)
err++;
}
- if (err) {
-#ifdef PCL812_EXTDEBUG
- printk
- ("pcl812 EDBG: BGN: pcl812_ai_cmdtest(...) err=%d ret=4\n",
- err);
-#endif
+ if (err)
return 4;
- }
return 0;
}
*/
static int pcl812_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
{
+ const struct pcl812_board *board = comedi_board(dev);
unsigned int divisor1 = 0, divisor2 = 0, i, dma_flags, bytes;
struct comedi_cmd *cmd = &s->async->cmd;
-#ifdef PCL812_EXTDEBUG
- printk(KERN_DEBUG "pcl812 EDBG: BGN: pcl812_ai_cmd(...)\n");
-#endif
-
if (cmd->start_src != TRIG_NOW)
return -EINVAL;
if (cmd->scan_begin_src != TRIG_FOLLOW)
return -EINVAL;
if (cmd->convert_src == TRIG_TIMER) {
- if (cmd->convert_arg < this_board->ai_ns_min)
- cmd->convert_arg = this_board->ai_ns_min;
- i8253_cascade_ns_to_timer(this_board->i8254_osc_base,
+ if (cmd->convert_arg < board->ai_ns_min)
+ cmd->convert_arg = board->ai_ns_min;
+ i8253_cascade_ns_to_timer(board->i8254_osc_base,
&divisor1, &divisor2,
&cmd->convert_arg,
cmd->flags & TRIG_ROUND_MASK);
set_dma_count(devpriv->dma, devpriv->dmabytestomove[0]);
release_dma_lock(dma_flags);
enable_dma(devpriv->dma);
-#ifdef PCL812_EXTDEBUG
- printk
- ("pcl812 EDBG: DMA %d PTR 0x%0x/0x%0x LEN %u/%u EOS %d\n",
- devpriv->dma, devpriv->hwdmaptr[0],
- devpriv->hwdmaptr[1], devpriv->dmabytestomove[0],
- devpriv->dmabytestomove[1], devpriv->ai_eos);
-#endif
}
switch (cmd->convert_src) {
else /* let's go! */
outb(devpriv->mode_reg_int | 6, dev->iobase + PCL812_MODE);
-#ifdef PCL812_EXTDEBUG
- printk(KERN_DEBUG "pcl812 EDBG: END: pcl812_ai_cmd(...)\n");
-#endif
-
return 0;
}
int len, bufptr;
short *ptr;
-#ifdef PCL812_EXTDEBUG
- printk(KERN_DEBUG "pcl812 EDBG: BGN: interrupt_pcl812_ai_dma(...)\n");
-#endif
ptr = (short *)devpriv->dmabuf[devpriv->next_dma_buf];
len = (devpriv->dmabytestomove[devpriv->next_dma_buf] >> 1) -
devpriv->ai_poll_ptr;
transfer_from_dma_buf(dev, s, ptr, bufptr, len);
-#ifdef PCL812_EXTDEBUG
- printk(KERN_DEBUG "pcl812 EDBG: END: interrupt_pcl812_ai_dma(...)\n");
-#endif
return IRQ_HANDLED;
}
static void start_pacer(struct comedi_device *dev, int mode,
unsigned int divisor1, unsigned int divisor2)
{
-#ifdef PCL812_EXTDEBUG
- printk(KERN_DEBUG "pcl812 EDBG: BGN: start_pacer(%d,%u,%u)\n", mode,
- divisor1, divisor2);
-#endif
outb(0xb4, dev->iobase + PCL812_CTRCTL);
outb(0x74, dev->iobase + PCL812_CTRCTL);
udelay(1);
outb(divisor1 & 0xff, dev->iobase + PCL812_CTR1);
outb((divisor1 >> 8) & 0xff, dev->iobase + PCL812_CTR1);
}
-#ifdef PCL812_EXTDEBUG
- printk(KERN_DEBUG "pcl812 EDBG: END: start_pacer(...)\n");
-#endif
}
/*
*/
static void free_resources(struct comedi_device *dev)
{
+ const struct pcl812_board *board = comedi_board(dev);
if (dev->private) {
if (devpriv->dmabuf[0])
if (dev->irq)
free_irq(dev->irq, dev);
if (dev->iobase)
- release_region(dev->iobase, this_board->io_range);
+ release_region(dev->iobase, board->io_range);
}
/*
static int pcl812_ai_cancel(struct comedi_device *dev,
struct comedi_subdevice *s)
{
-#ifdef PCL812_EXTDEBUG
- printk(KERN_DEBUG "pcl812 EDBG: BGN: pcl812_ai_cancel(...)\n");
-#endif
if (devpriv->ai_dma)
disable_dma(devpriv->dma);
outb(0, dev->iobase + PCL812_CLRINT); /* clear INT request */
outb(devpriv->mode_reg_int | 0, dev->iobase + PCL812_MODE);
start_pacer(dev, -1, 0, 0); /* stop 8254 */
outb(0, dev->iobase + PCL812_CLRINT); /* clear INT request */
-#ifdef PCL812_EXTDEBUG
- printk(KERN_DEBUG "pcl812 EDBG: END: pcl812_ai_cancel(...)\n");
-#endif
return 0;
}
*/
static void pcl812_reset(struct comedi_device *dev)
{
-#ifdef PCL812_EXTDEBUG
- printk(KERN_DEBUG "pcl812 EDBG: BGN: pcl812_reset(...)\n");
-#endif
+ const struct pcl812_board *board = comedi_board(dev);
+
outb(0, dev->iobase + PCL812_MUX);
outb(0 + devpriv->range_correction, dev->iobase + PCL812_GAIN);
devpriv->old_chan_reg = -1; /* invalidate chain/gain memory */
devpriv->old_gain_reg = -1;
- switch (this_board->board_type) {
+ switch (board->board_type) {
case boardPCL812PG:
case boardPCL812:
case boardACL8112:
break;
}
udelay(5);
-#ifdef PCL812_EXTDEBUG
- printk(KERN_DEBUG "pcl812 EDBG: END: pcl812_reset(...)\n");
-#endif
}
static int pcl812_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct pcl812_board *board = comedi_board(dev);
int ret, subdev;
unsigned long iobase;
unsigned int irq;
iobase = it->options[0];
printk(KERN_INFO "comedi%d: pcl812: board=%s, ioport=0x%03lx",
- dev->minor, this_board->name, iobase);
+ dev->minor, board->name, iobase);
- if (!request_region(iobase, this_board->io_range, "pcl812")) {
+ if (!request_region(iobase, board->io_range, "pcl812")) {
printk("I/O port conflict\n");
return -EIO;
}
return ret; /* Can't alloc mem */
}
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
irq = 0;
- if (this_board->IRQbits != 0) { /* board support IRQ */
+ if (board->IRQbits != 0) { /* board support IRQ */
irq = it->options[1];
if (irq) { /* we want to use IRQ */
- if (((1 << irq) & this_board->IRQbits) == 0) {
+ if (((1 << irq) & board->IRQbits) == 0) {
printk
(", IRQ %u is out of allowed range, "
"DISABLING IT", irq);
devpriv->dma = dma;
if (!dev->irq)
goto no_dma; /* if we haven't IRQ, we can't use DMA */
- if (this_board->DMAbits != 0) { /* board support DMA */
+ if (board->DMAbits != 0) { /* board support DMA */
dma = it->options[2];
- if (((1 << dma) & this_board->DMAbits) == 0) {
+ if (((1 << dma) & board->DMAbits) == 0) {
printk(", DMA is out of allowed range, FAIL!\n");
return -EINVAL; /* Bad DMA */
}
no_dma:
n_subdevices = 0;
- if (this_board->n_aichan > 0)
+ if (board->n_aichan > 0)
n_subdevices++;
- if (this_board->n_aochan > 0)
+ if (board->n_aochan > 0)
n_subdevices++;
- if (this_board->n_dichan > 0)
+ if (board->n_dichan > 0)
n_subdevices++;
- if (this_board->n_dochan > 0)
+ if (board->n_dochan > 0)
n_subdevices++;
- ret = alloc_subdevices(dev, n_subdevices);
- if (ret < 0) {
+ ret = comedi_alloc_subdevices(dev, n_subdevices);
+ if (ret) {
free_resources(dev);
return ret;
}
subdev = 0;
/* analog input */
- if (this_board->n_aichan > 0) {
+ if (board->n_aichan > 0) {
s = dev->subdevices + subdev;
s->type = COMEDI_SUBD_AI;
s->subdev_flags = SDF_READABLE;
- switch (this_board->board_type) {
+ switch (board->board_type) {
case boardA821:
if (it->options[2] == 1) {
- s->n_chan = this_board->n_aichan_diff;
+ s->n_chan = board->n_aichan_diff;
s->subdev_flags |= SDF_DIFF;
devpriv->use_diff = 1;
} else {
- s->n_chan = this_board->n_aichan;
+ s->n_chan = board->n_aichan;
s->subdev_flags |= SDF_GROUND;
}
break;
case boardACL8112:
case boardACL8216:
if (it->options[4] == 1) {
- s->n_chan = this_board->n_aichan_diff;
+ s->n_chan = board->n_aichan_diff;
s->subdev_flags |= SDF_DIFF;
devpriv->use_diff = 1;
} else {
- s->n_chan = this_board->n_aichan;
+ s->n_chan = board->n_aichan;
s->subdev_flags |= SDF_GROUND;
}
break;
default:
- s->n_chan = this_board->n_aichan;
+ s->n_chan = board->n_aichan;
s->subdev_flags |= SDF_GROUND;
break;
}
- s->maxdata = this_board->ai_maxdata;
+ s->maxdata = board->ai_maxdata;
s->len_chanlist = MAX_CHANLIST_LEN;
- s->range_table = this_board->rangelist_ai;
- if (this_board->board_type == boardACL8216)
+ s->range_table = board->rangelist_ai;
+ if (board->board_type == boardACL8216)
s->insn_read = acl8216_ai_insn_read;
else
s->insn_read = pcl812_ai_insn_read;
- devpriv->use_MPC = this_board->haveMPC508;
+ devpriv->use_MPC = board->haveMPC508;
s->cancel = pcl812_ai_cancel;
if (dev->irq) {
dev->read_subdev = s;
s->do_cmd = pcl812_ai_cmd;
s->poll = pcl812_ai_poll;
}
- switch (this_board->board_type) {
+ switch (board->board_type) {
case boardPCL812PG:
if (it->options[4] == 1)
s->range_table = &range_pcl812pg2_ai;
}
/* analog output */
- if (this_board->n_aochan > 0) {
+ if (board->n_aochan > 0) {
s = dev->subdevices + subdev;
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
- s->n_chan = this_board->n_aochan;
+ s->n_chan = board->n_aochan;
s->maxdata = 0xfff;
s->len_chanlist = 1;
- s->range_table = this_board->rangelist_ao;
+ s->range_table = board->rangelist_ao;
s->insn_read = pcl812_ao_insn_read;
s->insn_write = pcl812_ao_insn_write;
- switch (this_board->board_type) {
+ switch (board->board_type) {
case boardA821:
if (it->options[3] == 1)
s->range_table = &range_unipolar10;
}
/* digital input */
- if (this_board->n_dichan > 0) {
+ if (board->n_dichan > 0) {
s = dev->subdevices + subdev;
s->type = COMEDI_SUBD_DI;
s->subdev_flags = SDF_READABLE;
- s->n_chan = this_board->n_dichan;
+ s->n_chan = board->n_dichan;
s->maxdata = 1;
- s->len_chanlist = this_board->n_dichan;
+ s->len_chanlist = board->n_dichan;
s->range_table = &range_digital;
s->insn_bits = pcl812_di_insn_bits;
subdev++;
}
/* digital output */
- if (this_board->n_dochan > 0) {
+ if (board->n_dochan > 0) {
s = dev->subdevices + subdev;
s->type = COMEDI_SUBD_DO;
s->subdev_flags = SDF_WRITABLE;
- s->n_chan = this_board->n_dochan;
+ s->n_chan = board->n_dochan;
s->maxdata = 1;
- s->len_chanlist = this_board->n_dochan;
+ s->len_chanlist = board->n_dochan;
s->range_table = &range_digital;
s->insn_bits = pcl812_do_insn_bits;
subdev++;
}
- switch (this_board->board_type) {
+ switch (board->board_type) {
case boardACL8216:
devpriv->ai_is16b = 1;
case boardPCL812PG:
};
#define devpriv ((struct pcl816_private *)dev->private)
-#define this_board ((const struct pcl816_board *)dev->board_ptr)
#ifdef unused
static int RTC_lock; /* RTC lock */
}
outb(0, dev->iobase + PCL816_CLRINT); /* clear INT request */
- if ((!dev->irq) | (!devpriv->irq_free) | (!devpriv->irq_blocked) |
- (!devpriv->int816_mode)) {
+ if (!dev->irq || !devpriv->irq_free || !devpriv->irq_blocked ||
+ !devpriv->int816_mode) {
if (devpriv->irq_was_now_closed) {
devpriv->irq_was_now_closed = 0;
/* comedi_error(dev,"last IRQ.."); */
static int pcl816_ai_cmdtest(struct comedi_device *dev,
struct comedi_subdevice *s, struct comedi_cmd *cmd)
{
+ const struct pcl816_board *board = comedi_board(dev);
int err = 0;
int tmp, divisor1 = 0, divisor2 = 0;
* are unique and mutually compatible
*/
- if (cmd->start_src != TRIG_NOW) {
- cmd->start_src = TRIG_NOW;
- err++;
- }
-
- if (cmd->scan_begin_src != TRIG_FOLLOW) {
- cmd->scan_begin_src = TRIG_FOLLOW;
- err++;
- }
-
if (cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_TIMER) {
cmd->convert_src = TRIG_TIMER;
err++;
}
- if (cmd->scan_end_src != TRIG_COUNT) {
- cmd->scan_end_src = TRIG_COUNT;
- err++;
- }
-
if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
err++;
err++;
}
if (cmd->convert_src == TRIG_TIMER) {
- if (cmd->convert_arg < this_board->ai_ns_min) {
- cmd->convert_arg = this_board->ai_ns_min;
+ if (cmd->convert_arg < board->ai_ns_min) {
+ cmd->convert_arg = board->ai_ns_min;
err++;
}
} else { /* TRIG_EXT */
/* step 4: fix up any arguments */
if (cmd->convert_src == TRIG_TIMER) {
tmp = cmd->convert_arg;
- i8253_cascade_ns_to_timer(this_board->i8254_osc_base,
+ i8253_cascade_ns_to_timer(board->i8254_osc_base,
&divisor1, &divisor2,
&cmd->convert_arg,
cmd->flags & TRIG_ROUND_MASK);
- if (cmd->convert_arg < this_board->ai_ns_min)
- cmd->convert_arg = this_board->ai_ns_min;
+ if (cmd->convert_arg < board->ai_ns_min)
+ cmd->convert_arg = board->ai_ns_min;
if (tmp != cmd->convert_arg)
err++;
}
static int pcl816_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
{
+ const struct pcl816_board *board = comedi_board(dev);
unsigned int divisor1 = 0, divisor2 = 0, dma_flags, bytes, dmairq;
struct comedi_cmd *cmd = &s->async->cmd;
unsigned int seglen;
return -EBUSY;
if (cmd->convert_src == TRIG_TIMER) {
- if (cmd->convert_arg < this_board->ai_ns_min)
- cmd->convert_arg = this_board->ai_ns_min;
+ if (cmd->convert_arg < board->ai_ns_min)
+ cmd->convert_arg = board->ai_ns_min;
- i8253_cascade_ns_to_timer(this_board->i8254_osc_base, &divisor1,
+ i8253_cascade_ns_to_timer(board->i8254_osc_base, &divisor1,
&divisor2, &cmd->convert_arg,
cmd->flags & TRIG_ROUND_MASK);
static int pcl816_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct pcl816_board *board = comedi_board(dev);
int ret;
unsigned long iobase;
unsigned int irq, dma;
/* claim our I/O space */
iobase = it->options[0];
printk("comedi%d: pcl816: board=%s, ioport=0x%03lx", dev->minor,
- this_board->name, iobase);
+ board->name, iobase);
- if (!request_region(iobase, this_board->io_range, "pcl816")) {
+ if (!request_region(iobase, board->io_range, "pcl816")) {
printk("I/O port conflict\n");
return -EIO;
}
if (ret < 0)
return ret; /* Can't alloc mem */
- /* set up some name stuff */
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
/* grab our IRQ */
irq = 0;
- if (this_board->IRQbits != 0) { /* board support IRQ */
+ if (board->IRQbits != 0) { /* board support IRQ */
irq = it->options[1];
if (irq) { /* we want to use IRQ */
- if (((1 << irq) & this_board->IRQbits) == 0) {
+ if (((1 << irq) & board->IRQbits) == 0) {
printk
(", IRQ %u is out of allowed range, "
"DISABLING IT", irq);
if ((devpriv->irq_free == 0) && (devpriv->dma_rtc == 0))
goto no_dma; /* if we haven't IRQ, we can't use DMA */
- if (this_board->DMAbits != 0) { /* board support DMA */
+ if (board->DMAbits != 0) { /* board support DMA */
dma = it->options[2];
if (dma < 1)
goto no_dma; /* DMA disabled */
- if (((1 << dma) & this_board->DMAbits) == 0) {
+ if (((1 << dma) & board->DMAbits) == 0) {
printk(", DMA is out of allowed range, FAIL!\n");
return -EINVAL; /* Bad DMA */
}
no_dma:
-/* if (this_board->n_aochan > 0)
+/* if (board->n_aochan > 0)
subdevs[1] = COMEDI_SUBD_AO;
- if (this_board->n_dichan > 0)
+ if (board->n_dichan > 0)
subdevs[2] = COMEDI_SUBD_DI;
- if (this_board->n_dochan > 0)
+ if (board->n_dochan > 0)
subdevs[3] = COMEDI_SUBD_DO;
*/
- ret = alloc_subdevices(dev, 1);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
return ret;
s = dev->subdevices + 0;
- if (this_board->n_aichan > 0) {
+ if (board->n_aichan > 0) {
s->type = COMEDI_SUBD_AI;
devpriv->sub_ai = s;
dev->read_subdev = s;
s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
- s->n_chan = this_board->n_aichan;
+ s->n_chan = board->n_aichan;
s->subdev_flags |= SDF_DIFF;
/* printk (", %dchans DIFF DAC - %d", s->n_chan, i); */
- s->maxdata = this_board->ai_maxdata;
- s->len_chanlist = this_board->ai_chanlist;
- s->range_table = this_board->ai_range_type;
+ s->maxdata = board->ai_maxdata;
+ s->len_chanlist = board->ai_chanlist;
+ s->range_table = board->ai_range_type;
s->cancel = pcl816_ai_cancel;
s->do_cmdtest = pcl816_ai_cmdtest;
s->do_cmd = pcl816_ai_cmd;
#if 0
case COMEDI_SUBD_AO:
s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
- s->n_chan = this_board->n_aochan;
- s->maxdata = this_board->ao_maxdata;
- s->len_chanlist = this_board->ao_chanlist;
- s->range_table = this_board->ao_range_type;
+ s->n_chan = board->n_aochan;
+ s->maxdata = board->ao_maxdata;
+ s->len_chanlist = board->ao_chanlist;
+ s->range_table = board->ao_range_type;
break;
case COMEDI_SUBD_DI:
s->subdev_flags = SDF_READABLE;
- s->n_chan = this_board->n_dichan;
+ s->n_chan = board->n_dichan;
s->maxdata = 1;
- s->len_chanlist = this_board->n_dichan;
+ s->len_chanlist = board->n_dichan;
s->range_table = &range_digital;
break;
case COMEDI_SUBD_DO:
s->subdev_flags = SDF_WRITABLE;
- s->n_chan = this_board->n_dochan;
+ s->n_chan = board->n_dochan;
s->maxdata = 1;
- s->len_chanlist = this_board->n_dochan;
+ s->len_chanlist = board->n_dochan;
s->range_table = &range_digital;
break;
#endif
static void pcl816_detach(struct comedi_device *dev)
{
+ const struct pcl816_board *board = comedi_board(dev);
+
if (dev->private) {
pcl816_ai_cancel(dev, devpriv->sub_ai);
pcl816_reset(dev);
if (dev->irq)
free_irq(dev->irq, dev);
if (dev->iobase)
- release_region(dev->iobase, this_board->io_range);
+ release_region(dev->iobase, board->io_range);
#ifdef unused
if (devpriv->dma_rtc)
RTC_lock--;
};
#define devpriv ((struct pcl818_private *)dev->private)
-#define this_board ((const struct pcl818_board *)dev->board_ptr)
/*
==============================================================================
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inb(dev->iobase + PCL818_DI_LO) |
(inb(dev->iobase + PCL818_DI_HI) << 8);
- return 2;
+ return insn->n;
}
/*
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
data[1] = s->state;
- return 2;
+ return insn->n;
}
/*
int divisor1 = 0, divisor2 = 0;
unsigned int seglen;
- dev_dbg(dev->hw_dev, "pcl818_ai_cmd_mode()\n");
+ dev_dbg(dev->class_dev, "pcl818_ai_cmd_mode()\n");
if ((!dev->irq) && (!devpriv->dma_rtc)) {
comedi_error(dev, "IRQ not defined!");
return -EINVAL;
break;
}
#endif
- dev_dbg(dev->hw_dev, "pcl818_ai_cmd_mode() end\n");
+ dev_dbg(dev->class_dev, "pcl818_ai_cmd_mode() end\n");
return 0;
}
static int ai_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_cmd *cmd)
{
+ const struct pcl818_board *board = comedi_board(dev);
int err = 0;
int tmp, divisor1 = 0, divisor2 = 0;
/* step 2: make sure trigger sources are unique and mutually compatible */
- if (cmd->start_src != TRIG_NOW) {
- cmd->start_src = TRIG_NOW;
- err++;
- }
- if (cmd->scan_begin_src != TRIG_FOLLOW) {
- cmd->scan_begin_src = TRIG_FOLLOW;
- err++;
- }
if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
err++;
- if (cmd->scan_end_src != TRIG_COUNT) {
- cmd->scan_end_src = TRIG_COUNT;
- err++;
- }
-
if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
err++;
}
if (cmd->convert_src == TRIG_TIMER) {
- if (cmd->convert_arg < this_board->ns_min) {
- cmd->convert_arg = this_board->ns_min;
+ if (cmd->convert_arg < board->ns_min) {
+ cmd->convert_arg = board->ns_min;
err++;
}
} else { /* TRIG_EXT */
i8253_cascade_ns_to_timer(devpriv->i8253_osc_base, &divisor1,
&divisor2, &cmd->convert_arg,
cmd->flags & TRIG_ROUND_MASK);
- if (cmd->convert_arg < this_board->ns_min)
- cmd->convert_arg = this_board->ns_min;
+ if (cmd->convert_arg < board->ns_min)
+ cmd->convert_arg = board->ns_min;
if (tmp != cmd->convert_arg)
err++;
}
struct comedi_cmd *cmd = &s->async->cmd;
int retval;
- dev_dbg(dev->hw_dev, "pcl818_ai_cmd()\n");
+ dev_dbg(dev->class_dev, "pcl818_ai_cmd()\n");
devpriv->ai_n_chan = cmd->chanlist_len;
devpriv->ai_chanlist = cmd->chanlist;
devpriv->ai_flags = cmd->flags;
if (cmd->convert_src == TRIG_TIMER) { /* mode 1 */
devpriv->ai_timer1 = cmd->convert_arg;
retval = pcl818_ai_cmd_mode(1, dev, s);
- dev_dbg(dev->hw_dev, "pcl818_ai_cmd() end\n");
+ dev_dbg(dev->class_dev, "pcl818_ai_cmd() end\n");
return retval;
}
if (cmd->convert_src == TRIG_EXT) { /* mode 3 */
struct comedi_subdevice *s)
{
if (devpriv->irq_blocked > 0) {
- dev_dbg(dev->hw_dev, "pcl818_ai_cancel()\n");
+ dev_dbg(dev->class_dev, "pcl818_ai_cancel()\n");
devpriv->irq_was_now_closed = 1;
switch (devpriv->ai_mode) {
}
end:
- dev_dbg(dev->hw_dev, "pcl818_ai_cancel() end\n");
+ dev_dbg(dev->class_dev, "pcl818_ai_cancel() end\n");
return 0;
}
*/
static void pcl818_reset(struct comedi_device *dev)
{
+ const struct pcl818_board *board = comedi_board(dev);
+
if (devpriv->usefifo) { /* FIFO shutdown */
outb(0, dev->iobase + PCL818_FI_INTCLR);
outb(0, dev->iobase + PCL818_FI_FLUSH);
outb(0xb0, dev->iobase + PCL818_CTRCTL); /* Stop pacer */
outb(0x70, dev->iobase + PCL818_CTRCTL);
outb(0x30, dev->iobase + PCL818_CTRCTL);
- if (this_board->is_818) {
+ if (board->is_818) {
outb(0, dev->iobase + PCL818_RANGE);
} else {
outb(0, dev->iobase + PCL718_DA2_LO);
static int pcl818_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct pcl818_board *board = comedi_board(dev);
int ret;
unsigned long iobase;
unsigned int irq;
iobase = it->options[0];
printk
("comedi%d: pcl818: board=%s, ioport=0x%03lx",
- dev->minor, this_board->name, iobase);
- devpriv->io_range = this_board->io_range;
- if ((this_board->fifo) && (it->options[2] == -1)) { /* we've board with FIFO and we want to use FIFO */
+ dev->minor, board->name, iobase);
+ devpriv->io_range = board->io_range;
+ if ((board->fifo) && (it->options[2] == -1)) {
+ /* we've board with FIFO and we want to use FIFO */
devpriv->io_range = PCLx1xFIFO_RANGE;
devpriv->usefifo = 1;
}
return -EIO;
}
- /* set up some name stuff */
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
+
/* grab our IRQ */
irq = 0;
- if (this_board->IRQbits != 0) { /* board support IRQ */
+ if (board->IRQbits != 0) { /* board support IRQ */
irq = it->options[1];
if (irq) { /* we want to use IRQ */
- if (((1 << irq) & this_board->IRQbits) == 0) {
+ if (((1 << irq) & board->IRQbits) == 0) {
printk
(", IRQ %u is out of allowed range, DISABLING IT",
irq);
devpriv->dma = dma;
if ((devpriv->irq_free == 0) && (devpriv->dma_rtc == 0))
goto no_dma; /* if we haven't IRQ, we can't use DMA */
- if (this_board->DMAbits != 0) { /* board support DMA */
+ if (board->DMAbits != 0) { /* board support DMA */
dma = it->options[2];
if (dma < 1)
goto no_dma; /* DMA disabled */
- if (((1 << dma) & this_board->DMAbits) == 0) {
+ if (((1 << dma) & board->DMAbits) == 0) {
printk(KERN_ERR "DMA is out of allowed range, FAIL!\n");
return -EINVAL; /* Bad DMA */
}
no_dma:
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
s = dev->subdevices + 0;
- if (!this_board->n_aichan_se) {
+ if (!board->n_aichan_se) {
s->type = COMEDI_SUBD_UNUSED;
} else {
s->type = COMEDI_SUBD_AI;
devpriv->sub_ai = s;
s->subdev_flags = SDF_READABLE;
if (check_single_ended(dev->iobase)) {
- s->n_chan = this_board->n_aichan_se;
+ s->n_chan = board->n_aichan_se;
s->subdev_flags |= SDF_COMMON | SDF_GROUND;
printk(", %dchans S.E. DAC", s->n_chan);
} else {
- s->n_chan = this_board->n_aichan_diff;
+ s->n_chan = board->n_aichan_diff;
s->subdev_flags |= SDF_DIFF;
printk(", %dchans DIFF DAC", s->n_chan);
}
- s->maxdata = this_board->ai_maxdata;
+ s->maxdata = board->ai_maxdata;
s->len_chanlist = s->n_chan;
- s->range_table = this_board->ai_range_type;
+ s->range_table = board->ai_range_type;
s->cancel = pcl818_ai_cancel;
s->insn_read = pcl818_ai_insn_read;
if ((irq) || (devpriv->dma_rtc)) {
s->do_cmdtest = ai_cmdtest;
s->do_cmd = ai_cmd;
}
- if (this_board->is_818) {
+ if (board->is_818) {
if ((it->options[4] == 1) || (it->options[4] == 10))
s->range_table = &range_pcl818l_h_ai; /* secondary range list jumper selectable */
} else {
}
s = dev->subdevices + 1;
- if (!this_board->n_aochan) {
+ if (!board->n_aochan) {
s->type = COMEDI_SUBD_UNUSED;
} else {
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
- s->n_chan = this_board->n_aochan;
- s->maxdata = this_board->ao_maxdata;
- s->len_chanlist = this_board->n_aochan;
- s->range_table = this_board->ao_range_type;
+ s->n_chan = board->n_aochan;
+ s->maxdata = board->ao_maxdata;
+ s->len_chanlist = board->n_aochan;
+ s->range_table = board->ao_range_type;
s->insn_read = pcl818_ao_insn_read;
s->insn_write = pcl818_ao_insn_write;
#ifdef unused
}
#endif
#endif
- if (this_board->is_818) {
+ if (board->is_818) {
if ((it->options[4] == 1) || (it->options[4] == 10))
s->range_table = &range_unipolar10;
if (it->options[4] == 2)
}
s = dev->subdevices + 2;
- if (!this_board->n_dichan) {
+ if (!board->n_dichan) {
s->type = COMEDI_SUBD_UNUSED;
} else {
s->type = COMEDI_SUBD_DI;
s->subdev_flags = SDF_READABLE;
- s->n_chan = this_board->n_dichan;
+ s->n_chan = board->n_dichan;
s->maxdata = 1;
- s->len_chanlist = this_board->n_dichan;
+ s->len_chanlist = board->n_dichan;
s->range_table = &range_digital;
s->insn_bits = pcl818_di_insn_bits;
}
s = dev->subdevices + 3;
- if (!this_board->n_dochan) {
+ if (!board->n_dochan) {
s->type = COMEDI_SUBD_UNUSED;
} else {
s->type = COMEDI_SUBD_DO;
s->subdev_flags = SDF_WRITABLE;
- s->n_chan = this_board->n_dochan;
+ s->n_chan = board->n_dochan;
s->maxdata = 1;
- s->len_chanlist = this_board->n_dochan;
+ s->len_chanlist = board->n_dochan;
s->range_table = &range_digital;
s->insn_bits = pcl818_do_insn_bits;
}
devpriv->i8253_osc_base = 1000;
/* max sampling speed */
- devpriv->ns_min = this_board->ns_min;
+ devpriv->ns_min = board->ns_min;
- if (!this_board->is_818) {
+ if (!board->is_818) {
if ((it->options[6] == 1) || (it->options[6] == 100))
devpriv->ns_min = 10000; /* extended PCL718 to 100kHz DAC */
}
int dio_2;
};
-#define this_board ((const struct pcm3724_board *)dev->board_ptr)
-
-/* (setq c-basic-offset 8) */
-
static int subdev_8255_cb(int dir, int port, int data, unsigned long arg)
{
unsigned long iobase = arg;
static int pcm3724_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ const struct pcm3724_board *board = comedi_board(dev);
unsigned long iobase;
unsigned int iorange;
int ret, i, n_subdevices;
iobase = it->options[0];
- iorange = this_board->io_range;
+ iorange = board->io_range;
ret = alloc_private(dev, sizeof(struct priv_pcm3724));
if (ret < 0)
((struct priv_pcm3724 *)(dev->private))->dio_2 = 0;
printk(KERN_INFO "comedi%d: pcm3724: board=%s, 0x%03lx ", dev->minor,
- this_board->name, iobase);
+ board->name, iobase);
if (!iobase || !request_region(iobase, iorange, "pcm3724")) {
printk("I/O port conflict\n");
return -EIO;
}
dev->iobase = iobase;
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
printk(KERN_INFO "\n");
- n_subdevices = this_board->numofports;
+ n_subdevices = board->numofports;
- ret = alloc_subdevices(dev, n_subdevices);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, n_subdevices);
+ if (ret)
return ret;
for (i = 0; i < dev->n_subdevices; i++) {
static void pcm3724_detach(struct comedi_device *dev)
{
+ const struct pcm3724_board *board = comedi_board(dev);
int i;
if (dev->subdevices) {
subdev_8255_cleanup(dev, dev->subdevices + i);
}
if (dev->iobase)
- release_region(dev->iobase, this_board->io_range);
+ release_region(dev->iobase, board->io_range);
}
static const struct pcm3724_board boardtypes[] = {
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
}
data[1] = s->state;
- return 2;
+ return insn->n;
}
static int pcm3730_di_insn_bits(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
data[1] = inb(dev->iobase + (unsigned long)(s->private));
- return 2;
+ return insn->n;
}
static int pcm3730_attach(struct comedi_device *dev,
{
struct comedi_subdevice *s;
unsigned long iobase;
+ int ret;
iobase = it->options[0];
printk(KERN_INFO "comedi%d: pcm3730: 0x%04lx ", dev->minor, iobase);
dev->iobase = dev->iobase;
dev->irq = 0;
- if (alloc_subdevices(dev, 6) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 6);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
s->type = COMEDI_SUBD_DO;
int n_ai_bits;
};
-#define this_board ((const struct pcmad_board_struct *)(dev->board_ptr))
-
struct pcmad_priv_struct {
int differential;
int twos_comp;
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
+ const struct pcmad_board_struct *board = comedi_board(dev);
int i;
int chan;
int n;
data[n] |= (inb(dev->iobase + PCMAD_MSB) << 8);
if (devpriv->twos_comp)
- data[n] ^= (1 << (this_board->n_ai_bits - 1));
+ data[n] ^= (1 << (board->n_ai_bits - 1));
}
return n;
*/
static int pcmad_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct pcmad_board_struct *board = comedi_board(dev);
int ret;
struct comedi_subdevice *s;
unsigned long iobase;
printk(KERN_CONT "\n");
dev->iobase = iobase;
- ret = alloc_subdevices(dev, 1);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
return ret;
ret = alloc_private(dev, sizeof(struct pcmad_priv_struct));
if (ret < 0)
return ret;
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
s = dev->subdevices + 0;
s->type = COMEDI_SUBD_AI;
s->n_chan = 16; /* XXX */
s->len_chanlist = 1;
s->insn_read = pcmad_ai_insn_read;
- s->maxdata = (1 << this_board->n_ai_bits) - 1;
+ s->maxdata = (1 << board->n_ai_bits) - 1;
s->range_table = &range_unknown;
return 0;
}
};
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((const struct pcmda12_board *)dev->board_ptr)
-
struct pcmda12_private {
unsigned int ao_readback[CHANS];
static int pcmda12_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ const struct pcmda12_board *board = comedi_board(dev);
struct comedi_subdevice *s;
unsigned long iobase;
+ int ret;
iobase = it->options[0];
printk(KERN_INFO
}
dev->iobase = iobase;
-/*
- * Initialize dev->board_name. Note that we can use the "thisboard"
- * macro now, since we just initialized it in the last line.
- */
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
/*
* Allocate the private structure area. alloc_private() is a
devpriv->simultaneous_xfer_mode = it->options[1];
- /*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- *
- * Allocate 2 subdevs (32 + 16 DIO lines) or 3 32 DIO subdevs for the
- * 96-channel version of the board.
- */
- if (alloc_subdevices(dev, 1) < 0) {
- printk(KERN_ERR "cannot allocate subdevice data structures\n");
- return -ENOMEM;
- }
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
s = dev->subdevices;
s->private = NULL;
RANGE(-2.5, 2.5), RANGE(-2.5, 7.5)}
};
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((const struct pcmmio_board *)dev->board_ptr)
-
/* this structure is for data unique to this subdevice. */
struct pcmmio_subdev_private {
struct comedi_insn *insn, unsigned int *data)
{
int byte_no;
- if (insn->n != 2)
- return -EINVAL;
/* NOTE:
reading a 0 means this channel was high
printk(KERN_DEBUG "s->state %08x data_out %08x\n", s->state, data[1]);
#endif
- return 2;
+ return insn->n;
}
/* The input or output configuration of each digital line is
static void switch_page(struct comedi_device *dev, int asic, int page)
{
- if (asic < 0 || asic >= thisboard->dio_num_asics)
+ const struct pcmmio_board *board = comedi_board(dev);
+
+ if (asic < 0 || asic >= board->dio_num_asics)
return; /* paranoia */
if (page < 0 || page >= NUM_PAGES)
return; /* more paranoia */
static void init_asics(struct comedi_device *dev)
{ /* sets up an
ASIC chip to defaults */
+ const struct pcmmio_board *board = comedi_board(dev);
int asic;
- for (asic = 0; asic < thisboard->dio_num_asics; ++asic) {
+ for (asic = 0; asic < board->dio_num_asics; ++asic) {
int port, page;
unsigned long baseaddr = devpriv->asics[asic].iobase;
#ifdef notused
static void lock_port(struct comedi_device *dev, int asic, int port)
{
- if (asic < 0 || asic >= thisboard->dio_num_asics)
+ const struct pcmmio_board *board = comedi_board(dev);
+
+ if (asic < 0 || asic >= board->dio_num_asics)
return; /* paranoia */
if (port < 0 || port >= PORTS_PER_ASIC)
return; /* more paranoia */
static void unlock_port(struct comedi_device *dev, int asic, int port)
{
- if (asic < 0 || asic >= thisboard->dio_num_asics)
+ const struct pcmmio_board *board = comedi_board(dev);
+
+ if (asic < 0 || asic >= board->dio_num_asics)
return; /* paranoia */
if (port < 0 || port >= PORTS_PER_ASIC)
return; /* more paranoia */
subpriv->dio.intr.enabled_mask = 0;
subpriv->dio.intr.active = 0;
- s->async->inttrig = 0;
+ s->async->inttrig = NULL;
nports = subpriv->dio.intr.num_asic_chans / CHANS_PER_PORT;
firstport = subpriv->dio.intr.asic_chan / CHANS_PER_PORT;
switch_page(dev, asic, PAGE_ENAB);
return -EINVAL;
spin_lock_irqsave(&subpriv->dio.intr.spinlock, flags);
- s->async->inttrig = 0;
+ s->async->inttrig = NULL;
if (subpriv->dio.intr.active)
event = pcmmio_start_intr(dev, s);
spin_unlock_irqrestore(&subpriv->dio.intr.spinlock, flags);
static int pcmmio_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct pcmmio_board *board = comedi_board(dev);
struct comedi_subdevice *s;
int sdev_no, chans_left, n_dio_subdevs, n_subdevs, port, asic,
thisasic_chanct = 0;
unsigned long iobase;
unsigned int irq[MAX_ASICS];
+ int ret;
iobase = it->options[0];
irq[0] = it->options[1];
dev->iobase = iobase;
if (!iobase || !request_region(iobase,
- thisboard->total_iosize,
+ board->total_iosize,
dev->driver->driver_name)) {
printk(KERN_ERR "comedi%d: I/O port conflict\n", dev->minor);
return -EIO;
}
-/*
- * Initialize dev->board_name. Note that we can use the "thisboard"
- * macro now, since we just initialized it in the last line.
- */
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
/*
* Allocate the private structure area. alloc_private() is a
spin_lock_init(&devpriv->asics[asic].spinlock);
}
- chans_left = CHANS_PER_ASIC * thisboard->dio_num_asics;
+ chans_left = CHANS_PER_ASIC * board->dio_num_asics;
n_dio_subdevs = CALC_N_DIO_SUBDEVS(chans_left);
n_subdevs = n_dio_subdevs + 2;
devpriv->sprivs =
dev->minor);
return -ENOMEM;
}
- /*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- *
- * Allocate 1 AI + 1 AO + 2 DIO subdevs (24 lines per DIO)
- */
- if (alloc_subdevices(dev, n_subdevs) < 0) {
- printk(KERN_ERR "comedi%d: cannot allocate subdevice data structures\n",
- dev->minor);
- return -ENOMEM;
- }
+
+ ret = comedi_alloc_subdevices(dev, n_subdevs);
+ if (ret)
+ return ret;
/* First, AI */
sdev_no = 0;
s = dev->subdevices + sdev_no;
s->private = devpriv->sprivs + sdev_no;
- s->maxdata = (1 << thisboard->ai_bits) - 1;
- s->range_table = thisboard->ai_range_table;
+ s->maxdata = (1 << board->ai_bits) - 1;
+ s->range_table = board->ai_range_table;
s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF;
s->type = COMEDI_SUBD_AI;
- s->n_chan = thisboard->n_ai_chans;
+ s->n_chan = board->n_ai_chans;
s->len_chanlist = s->n_chan;
- s->insn_read = thisboard->ai_rinsn;
+ s->insn_read = board->ai_rinsn;
subpriv->iobase = dev->iobase + 0;
/* initialize the resource enable register by clearing it */
outb(0, subpriv->iobase + 3);
++sdev_no;
s = dev->subdevices + sdev_no;
s->private = devpriv->sprivs + sdev_no;
- s->maxdata = (1 << thisboard->ao_bits) - 1;
- s->range_table = thisboard->ao_range_table;
+ s->maxdata = (1 << board->ao_bits) - 1;
+ s->range_table = board->ao_range_table;
s->subdev_flags = SDF_READABLE;
s->type = COMEDI_SUBD_AO;
- s->n_chan = thisboard->n_ao_chans;
+ s->n_chan = board->n_ao_chans;
s->len_chanlist = s->n_chan;
- s->insn_read = thisboard->ao_rinsn;
- s->insn_write = thisboard->ao_winsn;
+ s->insn_read = board->ao_rinsn;
+ s->insn_write = board->ao_winsn;
subpriv->iobase = dev->iobase + 8;
/* initialize the resource enable register by clearing it */
outb(0, subpriv->iobase + 3);
for (asic = 0; irq[0] && asic < MAX_ASICS; ++asic) {
if (irq[asic]
&& request_irq(irq[asic], interrupt_pcmmio,
- IRQF_SHARED, thisboard->name, dev)) {
+ IRQF_SHARED, board->name, dev)) {
int i;
/* unroll the allocated irqs.. */
for (i = asic - 1; i >= 0; --i) {
if (irq[0]) {
printk(KERN_DEBUG "comedi%d: irq: %u\n", dev->minor, irq[0]);
- if (thisboard->dio_num_asics == 2 && irq[1])
+ if (board->dio_num_asics == 2 && irq[1])
printk(KERN_DEBUG "comedi%d: second ASIC irq: %u\n",
dev->minor, irq[1]);
} else {
static void pcmmio_detach(struct comedi_device *dev)
{
+ const struct pcmmio_board *board = comedi_board(dev);
int i;
if (dev->iobase)
- release_region(dev->iobase, thisboard->total_iosize);
+ release_region(dev->iobase, board->total_iosize);
for (i = 0; i < MAX_ASICS; ++i) {
if (devpriv && devpriv->asics[i].irq)
free_irq(devpriv->asics[i].irq, dev);
const int num_ports;
};
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((const struct pcmuio_board *)dev->board_ptr)
-
/* this structure is for data unique to this subdevice. */
struct pcmuio_subdev_private {
/* mapping of halfwords (bytes) in port/chanarray to iobase */
struct comedi_insn *insn, unsigned int *data)
{
int byte_no;
- if (insn->n != 2)
- return -EINVAL;
/* NOTE:
reading a 0 means this channel was high
#ifdef DAMMIT_ITS_BROKEN
/* DEBUG */
- dev_dbg(dev->hw_dev, "write mask: %08x data: %08x\n", data[0],
+ dev_dbg(dev->class_dev, "write mask: %08x data: %08x\n", data[0],
data[1]);
#endif
}
#ifdef DAMMIT_ITS_BROKEN
/* DEBUG */
- dev_dbg(dev->hw_dev, "data_out_byte %02x\n", (unsigned)byte);
+ dev_dbg(dev->class_dev, "data_out_byte %02x\n", (unsigned)byte);
#endif
/* save the digital input lines for this byte.. */
s->state |= ((unsigned int)byte) << offset;
#ifdef DAMMIT_ITS_BROKEN
/* DEBUG */
- dev_dbg(dev->hw_dev, "s->state %08x data_out %08x\n", s->state,
+ dev_dbg(dev->class_dev, "s->state %08x data_out %08x\n", s->state,
data[1]);
#endif
- return 2;
+ return insn->n;
}
/* The input or output configuration of each digital line is
static void switch_page(struct comedi_device *dev, int asic, int page)
{
- if (asic < 0 || asic >= thisboard->num_asics)
+ const struct pcmuio_board *board = comedi_board(dev);
+
+ if (asic < 0 || asic >= board->num_asics)
return; /* paranoia */
if (page < 0 || page >= NUM_PAGES)
return; /* more paranoia */
static void init_asics(struct comedi_device *dev)
{ /* sets up an
ASIC chip to defaults */
+ const struct pcmuio_board *board = comedi_board(dev);
int asic;
- for (asic = 0; asic < thisboard->num_asics; ++asic) {
+ for (asic = 0; asic < board->num_asics; ++asic) {
int port, page;
unsigned long baseaddr = dev->iobase + asic * ASIC_IOSIZE;
#ifdef notused
static void lock_port(struct comedi_device *dev, int asic, int port)
{
- if (asic < 0 || asic >= thisboard->num_asics)
+ const struct pcmuio_board *board = comedi_board(dev);
+
+ if (asic < 0 || asic >= board->num_asics)
return; /* paranoia */
if (port < 0 || port >= PORTS_PER_ASIC)
return; /* more paranoia */
static void unlock_port(struct comedi_device *dev, int asic, int port)
{
- if (asic < 0 || asic >= thisboard->num_asics)
+ const struct pcmuio_board *board = comedi_board(dev);
+
+ if (asic < 0 || asic >= board->num_asics)
return; /* paranoia */
if (port < 0 || port >= PORTS_PER_ASIC)
return; /* more paranoia */
static int pcmuio_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct pcmuio_board *board = comedi_board(dev);
struct comedi_subdevice *s;
int sdev_no, chans_left, n_subdevs, port, asic, thisasic_chanct = 0;
unsigned long iobase;
unsigned int irq[MAX_ASICS];
+ int ret;
iobase = it->options[0];
irq[0] = it->options[1];
irq[1] = it->options[2];
- dev_dbg(dev->hw_dev, "comedi%d: %s: io: %lx attached\n", dev->minor,
+ dev_dbg(dev->class_dev, "%s: io: %lx attach\n",
dev->driver->driver_name, iobase);
dev->iobase = iobase;
if (!iobase || !request_region(iobase,
- thisboard->num_asics * ASIC_IOSIZE,
+ board->num_asics * ASIC_IOSIZE,
dev->driver->driver_name)) {
- dev_err(dev->hw_dev, "I/O port conflict\n");
+ dev_err(dev->class_dev, "I/O port conflict\n");
return -EIO;
}
-/*
- * Initialize dev->board_name. Note that we can use the "thisboard"
- * macro now, since we just initialized it in the last line.
- */
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
/*
* Allocate the private structure area. alloc_private() is a
* convenient macro defined in comedidev.h.
*/
if (alloc_private(dev, sizeof(struct pcmuio_private)) < 0) {
- dev_warn(dev->hw_dev, "cannot allocate private data structure\n");
+ dev_warn(dev->class_dev,
+ "cannot allocate private data structure\n");
return -ENOMEM;
}
spin_lock_init(&devpriv->asics[asic].spinlock);
}
- chans_left = CHANS_PER_ASIC * thisboard->num_asics;
+ chans_left = CHANS_PER_ASIC * board->num_asics;
n_subdevs = CALC_N_SUBDEVS(chans_left);
devpriv->sprivs =
kcalloc(n_subdevs, sizeof(struct pcmuio_subdev_private),
GFP_KERNEL);
if (!devpriv->sprivs) {
- dev_warn(dev->hw_dev, "cannot allocate subdevice private data structures\n");
- return -ENOMEM;
- }
- /*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- *
- * Allocate 2 subdevs (32 + 16 DIO lines) or 3 32 DIO subdevs for the
- * 96-channel version of the board.
- */
- if (alloc_subdevices(dev, n_subdevs) < 0) {
- dev_dbg(dev->hw_dev, "cannot allocate subdevice data structures\n");
+ dev_warn(dev->class_dev,
+ "cannot allocate subdevice private data structures\n");
return -ENOMEM;
}
+ ret = comedi_alloc_subdevices(dev, n_subdevs);
+ if (ret)
+ return ret;
+
port = 0;
asic = 0;
for (sdev_no = 0; sdev_no < (int)dev->n_subdevices; ++sdev_no) {
for (asic = 0; irq[0] && asic < MAX_ASICS; ++asic) {
if (irq[asic]
&& request_irq(irq[asic], interrupt_pcmuio,
- IRQF_SHARED, thisboard->name, dev)) {
+ IRQF_SHARED, board->name, dev)) {
int i;
/* unroll the allocated irqs.. */
for (i = asic - 1; i >= 0; --i) {
irqs.. */
if (irq[0]) {
- dev_dbg(dev->hw_dev, "irq: %u\n", irq[0]);
- if (irq[1] && thisboard->num_asics == 2)
- dev_dbg(dev->hw_dev, "second ASIC irq: %u\n", irq[1]);
+ dev_dbg(dev->class_dev, "irq: %u\n", irq[0]);
+ if (irq[1] && board->num_asics == 2)
+ dev_dbg(dev->class_dev, "second ASIC irq: %u\n",
+ irq[1]);
} else {
- dev_dbg(dev->hw_dev, "(IRQ mode disabled)\n");
+ dev_dbg(dev->class_dev, "(IRQ mode disabled)\n");
}
static void pcmuio_detach(struct comedi_device *dev)
{
+ const struct pcmuio_board *board = comedi_board(dev);
int i;
if (dev->iobase)
- release_region(dev->iobase, ASIC_IOSIZE * thisboard->num_asics);
+ release_region(dev->iobase, ASIC_IOSIZE * board->num_asics);
for (i = 0; i < MAX_ASICS; ++i) {
if (devpriv->asics[i].irq)
free_irq(devpriv->asics[i].irq, dev);
const struct comedi_lrange *range;
};
-#define this_board ((const struct boarddef_struct *)dev->board_ptr)
-
static int readback_insn(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
data[1] = inb(dev->iobase + 0);
data[1] |= (inb(dev->iobase + 1) << 8);
data[1] |= (inb(dev->iobase + 2) << 16);
data[1] |= (inb(dev->iobase + 3) << 24);
- return 2;
+ return insn->n;
}
static int pcl734_insn_bits(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
if (data[0]) {
s->state &= ~data[0];
s->state |= (data[0] & data[1]);
}
data[1] = s->state;
- return 2;
+ return insn->n;
}
static int poc_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct boarddef_struct *board = comedi_board(dev);
struct comedi_subdevice *s;
unsigned long iobase;
unsigned int iosize;
+ int ret;
iobase = it->options[0];
printk(KERN_INFO "comedi%d: poc: using %s iobase 0x%lx\n", dev->minor,
- this_board->name, iobase);
+ board->name, iobase);
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
if (iobase == 0) {
printk(KERN_ERR "io base address required\n");
return -EINVAL;
}
- iosize = this_board->iosize;
+ iosize = board->iosize;
/* check if io addresses are available */
if (!request_region(iobase, iosize, "dac02")) {
printk(KERN_ERR "I/O port conflict: failed to allocate ports "
}
dev->iobase = iobase;
- if (alloc_subdevices(dev, 1) < 0)
- return -ENOMEM;
- if (alloc_private(dev, sizeof(unsigned int) * this_board->n_chan) < 0)
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
+
+ if (alloc_private(dev, sizeof(unsigned int) * board->n_chan) < 0)
return -ENOMEM;
/* analog output subdevice */
s = dev->subdevices + 0;
- s->type = this_board->type;
- s->n_chan = this_board->n_chan;
- s->maxdata = (1 << this_board->n_bits) - 1;
- s->range_table = this_board->range;
- s->insn_write = this_board->winsn;
- s->insn_read = this_board->rinsn;
- s->insn_bits = this_board->insnbits;
+ s->type = board->type;
+ s->n_chan = board->n_chan;
+ s->maxdata = (1 << board->n_bits) - 1;
+ s->range_table = board->range;
+ s->insn_write = board->winsn;
+ s->insn_read = board->rinsn;
+ s->insn_bits = board->insnbits;
if (s->type == COMEDI_SUBD_AO || s->type == COMEDI_SUBD_DO)
s->subdev_flags = SDF_WRITABLE;
static void poc_detach(struct comedi_device *dev)
{
+ const struct boarddef_struct *board = comedi_board(dev);
+
if (dev->iobase)
- release_region(dev->iobase, this_board->iosize);
+ release_region(dev->iobase, board->iosize);
}
static const struct boarddef_struct boards[] = {
dev->iobase = local->link->resource[0]->start;
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
printk(KERN_INFO "comedi%d: attaching daqp%d (io 0x%04lx)\n",
#include <linux/delay.h>
#include "../comedidev.h"
-#include "comedi_pci.h"
#define DRV_NAME "rtd520"
#define RtdDma1Status(dev) \
readb(devpriv->lcfg+LCFG_DMACSR1)
-static int rtd_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int rtd_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int rtd_ao_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int rtd_dio_insn_bits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int rtd_dio_insn_config(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int rtd_ai_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
- struct comedi_cmd *cmd);
-static int rtd_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
-static int rtd_ai_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
/*
- * static int rtd_ai_poll(struct comedi_device *dev,
- * struct comedi_subdevice *s);
- */
-static int rtd_ns_to_timer(unsigned int *ns, int roundMode);
-static irqreturn_t rtd_interrupt(int irq, void *d);
-static int rtd520_probe_fifo_depth(struct comedi_device *dev);
+ Given a desired period and the clock period (both in ns),
+ return the proper counter value (divider-1).
+ Sets the original period to be the true value.
+ Note: you have to check if the value is larger than the counter range!
+*/
+static int rtd_ns_to_timer_base(unsigned int *nanosec, /* desired period (in ns) */
+ int round_mode, int base)
+{ /* clock period (in ns) */
+ int divider;
+
+ switch (round_mode) {
+ case TRIG_ROUND_NEAREST:
+ default:
+ divider = (*nanosec + base / 2) / base;
+ break;
+ case TRIG_ROUND_DOWN:
+ divider = (*nanosec) / base;
+ break;
+ case TRIG_ROUND_UP:
+ divider = (*nanosec + base - 1) / base;
+ break;
+ }
+ if (divider < 2)
+ divider = 2; /* min is divide by 2 */
+
+ /* Note: we don't check for max, because different timers
+ have different ranges */
+
+ *nanosec = base * divider;
+ return divider - 1; /* countdown is divisor+1 */
+}
/*
- * Attach is called by the Comedi core to configure the driver
- * for a particular board. If you specified a board_name array
- * in the driver structure, dev->board_ptr contains that
- * address.
- */
-static int rtd_attach(struct comedi_device *dev, struct comedi_devconfig *it)
-{ /* board name and options flags */
- struct comedi_subdevice *s;
- struct pci_dev *pcidev;
- int ret;
- resource_size_t physLas0; /* configuration */
- resource_size_t physLas1; /* data area */
- resource_size_t physLcfg; /* PLX9080 */
-#ifdef USE_DMA
- int index;
-#endif
+ Given a desired period (in ns),
+ return the proper counter value (divider-1) for the internal clock.
+ Sets the original period to be the true value.
+*/
+static int rtd_ns_to_timer(unsigned int *ns, int round_mode)
+{
+ return rtd_ns_to_timer_base(ns, round_mode, RTD_CLOCK_BASE);
+}
- printk(KERN_INFO "comedi%d: rtd520 attaching.\n", dev->minor);
+/*
+ Convert a single comedi channel-gain entry to a RTD520 table entry
+*/
+static unsigned short rtdConvertChanGain(struct comedi_device *dev,
+ unsigned int comediChan, int chanIndex)
+{ /* index in channel list */
+ unsigned int chan, range, aref;
+ unsigned short r = 0;
-#if defined(CONFIG_COMEDI_DEBUG) && defined(USE_DMA)
- /* You can set this a load time: modprobe comedi comedi_debug=1 */
- if (0 == comedi_debug) /* force DMA debug printks */
- comedi_debug = 1;
-#endif
+ chan = CR_CHAN(comediChan);
+ range = CR_RANGE(comediChan);
+ aref = CR_AREF(comediChan);
- /*
- * Allocate the private structure area. alloc_private() is a
- * convenient macro defined in comedidev.h.
- */
- if (alloc_private(dev, sizeof(struct rtdPrivate)) < 0)
- return -ENOMEM;
+ r |= chan & 0xf;
- /*
- * Probe the device to determine what device in the series it is.
- */
- for (pcidev = pci_get_device(PCI_VENDOR_ID_RTD, PCI_ANY_ID, NULL);
- pcidev != NULL;
- pcidev = pci_get_device(PCI_VENDOR_ID_RTD, PCI_ANY_ID, pcidev)) {
- int i;
+ /* Note: we also setup the channel list bipolar flag array */
+ if (range < thisboard->range10Start) { /* first batch are +-5 */
+ r |= 0x000; /* +-5 range */
+ r |= (range & 0x7) << 4; /* gain */
+ CHAN_ARRAY_SET(devpriv->chanBipolar, chanIndex);
+ } else if (range < thisboard->rangeUniStart) { /* second batch are +-10 */
+ r |= 0x100; /* +-10 range */
+ /* gain */
+ r |= ((range - thisboard->range10Start) & 0x7) << 4;
+ CHAN_ARRAY_SET(devpriv->chanBipolar, chanIndex);
+ } else { /* last batch is +10 */
+ r |= 0x200; /* +10 range */
+ /* gain */
+ r |= ((range - thisboard->rangeUniStart) & 0x7) << 4;
+ CHAN_ARRAY_CLEAR(devpriv->chanBipolar, chanIndex);
+ }
- if (it->options[0] || it->options[1]) {
- if (pcidev->bus->number != it->options[0]
- || PCI_SLOT(pcidev->devfn) != it->options[1]) {
- continue;
- }
- }
- for (i = 0; i < ARRAY_SIZE(rtd520Boards); ++i) {
- if (pcidev->device == rtd520Boards[i].device_id) {
- dev->board_ptr = &rtd520Boards[i];
- break;
- }
+ switch (aref) {
+ case AREF_GROUND: /* on-board ground */
+ break;
+
+ case AREF_COMMON:
+ r |= 0x80; /* ref external analog common */
+ break;
+
+ case AREF_DIFF:
+ r |= 0x400; /* differential inputs */
+ break;
+
+ case AREF_OTHER: /* ??? */
+ break;
+ }
+ /*printk ("chan=%d r=%d a=%d -> 0x%x\n",
+ chan, range, aref, r); */
+ return r;
+}
+
+/*
+ Setup the channel-gain table from a comedi list
+*/
+static void rtd_load_channelgain_list(struct comedi_device *dev,
+ unsigned int n_chan, unsigned int *list)
+{
+ if (n_chan > 1) { /* setup channel gain table */
+ int ii;
+ RtdClearCGT(dev);
+ RtdEnableCGT(dev, 1); /* enable table */
+ for (ii = 0; ii < n_chan; ii++) {
+ RtdWriteCGTable(dev, rtdConvertChanGain(dev, list[ii],
+ ii));
}
- if (dev->board_ptr)
- break; /* found one */
+ } else { /* just use the channel gain latch */
+ RtdEnableCGT(dev, 0); /* disable table, enable latch */
+ RtdWriteCGLatch(dev, rtdConvertChanGain(dev, list[0], 0));
}
- if (!pcidev) {
- if (it->options[0] && it->options[1]) {
- printk(KERN_INFO "No RTD card at bus=%d slot=%d.\n",
- it->options[0], it->options[1]);
- } else {
- printk(KERN_INFO "No RTD card found.\n");
+}
+
+/* determine fifo size by doing adc conversions until the fifo half
+empty status flag clears */
+static int rtd520_probe_fifo_depth(struct comedi_device *dev)
+{
+ unsigned int chanspec = CR_PACK(0, 0, AREF_GROUND);
+ unsigned i;
+ static const unsigned limit = 0x2000;
+ unsigned fifo_size = 0;
+
+ RtdAdcClearFifo(dev);
+ rtd_load_channelgain_list(dev, 1, &chanspec);
+ RtdAdcConversionSource(dev, 0); /* software */
+ /* convert samples */
+ for (i = 0; i < limit; ++i) {
+ unsigned fifo_status;
+ /* trigger conversion */
+ RtdAdcStart(dev);
+ udelay(1);
+ fifo_status = RtdFifoStatus(dev);
+ if ((fifo_status & FS_ADC_HEMPTY) == 0) {
+ fifo_size = 2 * i;
+ break;
}
+ }
+ if (i == limit) {
+ printk(KERN_INFO "\ncomedi: %s: failed to probe fifo size.\n",
+ DRV_NAME);
return -EIO;
}
- devpriv->pci_dev = pcidev;
- dev->board_name = thisboard->name;
-
- ret = comedi_pci_enable(pcidev, DRV_NAME);
- if (ret < 0) {
- printk(KERN_INFO "Failed to enable PCI device and request regions.\n");
- return ret;
+ RtdAdcClearFifo(dev);
+ if (fifo_size != 0x400 && fifo_size != 0x2000) {
+ printk
+ (KERN_INFO "\ncomedi: %s: unexpected fifo size of %i, expected 1024 or 8192.\n",
+ DRV_NAME, fifo_size);
+ return -EIO;
}
- devpriv->got_regions = 1;
-
- /*
- * Initialize base addresses
- */
- /* Get the physical address from PCI config */
- physLas0 = pci_resource_start(devpriv->pci_dev, LAS0_PCIINDEX);
- physLas1 = pci_resource_start(devpriv->pci_dev, LAS1_PCIINDEX);
- physLcfg = pci_resource_start(devpriv->pci_dev, LCFG_PCIINDEX);
- /* Now have the kernel map this into memory */
- /* ASSUME page aligned */
- devpriv->las0 = ioremap_nocache(physLas0, LAS0_PCISIZE);
- devpriv->las1 = ioremap_nocache(physLas1, LAS1_PCISIZE);
- devpriv->lcfg = ioremap_nocache(physLcfg, LCFG_PCISIZE);
+ return fifo_size;
+}
- if (!devpriv->las0 || !devpriv->las1 || !devpriv->lcfg)
- return -ENOMEM;
+/*
+ "instructions" read/write data in "one-shot" or "software-triggered"
+ mode (simplest case).
+ This doesn't use interrupts.
+ Note, we don't do any settling delays. Use a instruction list to
+ select, delay, then read.
+ */
+static int rtd_ai_rinsn(struct comedi_device *dev,
+ struct comedi_subdevice *s, struct comedi_insn *insn,
+ unsigned int *data)
+{
+ int n, ii;
+ int stat;
- DPRINTK("%s: LAS0=%llx, LAS1=%llx, CFG=%llx.\n", dev->board_name,
- (unsigned long long)physLas0, (unsigned long long)physLas1,
- (unsigned long long)physLcfg);
- { /* The RTD driver does this */
- unsigned char pci_latency;
- u16 revision;
- /*uint32_t epld_version; */
+ /* clear any old fifo data */
+ RtdAdcClearFifo(dev);
- pci_read_config_word(devpriv->pci_dev, PCI_REVISION_ID,
- &revision);
- DPRINTK("%s: PCI revision %d.\n", dev->board_name, revision);
+ /* write channel to multiplexer and clear channel gain table */
+ rtd_load_channelgain_list(dev, 1, &insn->chanspec);
- pci_read_config_byte(devpriv->pci_dev,
- PCI_LATENCY_TIMER, &pci_latency);
- if (pci_latency < 32) {
- printk(KERN_INFO "%s: PCI latency changed from %d to %d\n",
- dev->board_name, pci_latency, 32);
- pci_write_config_byte(devpriv->pci_dev,
- PCI_LATENCY_TIMER, 32);
- } else {
- DPRINTK("rtd520: PCI latency = %d\n", pci_latency);
- }
-
- /*
- * Undocumented EPLD version (doesn't match RTD driver results)
- */
- /*DPRINTK ("rtd520: Reading epld from %p\n",
- devpriv->las0+0);
- epld_version = readl (devpriv->las0+0);
- if ((epld_version & 0xF0) >> 4 == 0x0F) {
- DPRINTK("rtd520: pre-v8 EPLD. (%x)\n", epld_version);
- } else {
- DPRINTK("rtd520: EPLD version %x.\n", epld_version >> 4);
- } */
- }
-
- /* Show board configuration */
- printk(KERN_INFO "%s:", dev->board_name);
-
- /*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- if (alloc_subdevices(dev, 4) < 0)
- return -ENOMEM;
-
-
- s = dev->subdevices + 0;
- dev->read_subdev = s;
- /* analog input subdevice */
- s->type = COMEDI_SUBD_AI;
- s->subdev_flags =
- SDF_READABLE | SDF_GROUND | SDF_COMMON | SDF_DIFF | SDF_CMD_READ;
- s->n_chan = thisboard->aiChans;
- s->maxdata = (1 << thisboard->aiBits) - 1;
- if (thisboard->aiMaxGain <= 32)
- s->range_table = &rtd_ai_7520_range;
- else
- s->range_table = &rtd_ai_4520_range;
-
- s->len_chanlist = RTD_MAX_CHANLIST; /* devpriv->fifoLen */
- s->insn_read = rtd_ai_rinsn;
- s->do_cmd = rtd_ai_cmd;
- s->do_cmdtest = rtd_ai_cmdtest;
- s->cancel = rtd_ai_cancel;
- /* s->poll = rtd_ai_poll; *//* not ready yet */
-
- s = dev->subdevices + 1;
- /* analog output subdevice */
- s->type = COMEDI_SUBD_AO;
- s->subdev_flags = SDF_WRITABLE;
- s->n_chan = 2;
- s->maxdata = (1 << thisboard->aiBits) - 1;
- s->range_table = &rtd_ao_range;
- s->insn_write = rtd_ao_winsn;
- s->insn_read = rtd_ao_rinsn;
-
- s = dev->subdevices + 2;
- /* digital i/o subdevice */
- s->type = COMEDI_SUBD_DIO;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- /* we only support port 0 right now. Ignoring port 1 and user IO */
- s->n_chan = 8;
- s->maxdata = 1;
- s->range_table = &range_digital;
- s->insn_bits = rtd_dio_insn_bits;
- s->insn_config = rtd_dio_insn_config;
-
- /* timer/counter subdevices (not currently supported) */
- s = dev->subdevices + 3;
- s->type = COMEDI_SUBD_COUNTER;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = 3;
- s->maxdata = 0xffff;
-
- /* initialize board, per RTD spec */
- /* also, initialize shadow registers */
- RtdResetBoard(dev);
- udelay(100); /* needed? */
- RtdPlxInterruptWrite(dev, 0);
- RtdInterruptMask(dev, 0); /* and sets shadow */
- RtdInterruptClearMask(dev, ~0); /* and sets shadow */
- RtdInterruptClear(dev); /* clears bits set by mask */
- RtdInterruptOverrunClear(dev);
- RtdClearCGT(dev);
- RtdAdcClearFifo(dev);
- RtdDacClearFifo(dev, 0);
- RtdDacClearFifo(dev, 1);
- /* clear digital IO fifo */
- RtdDioStatusWrite(dev, 0); /* safe state, set shadow */
- RtdUtcCtrlPut(dev, 0, 0x30); /* safe state, set shadow */
- RtdUtcCtrlPut(dev, 1, 0x30); /* safe state, set shadow */
- RtdUtcCtrlPut(dev, 2, 0x30); /* safe state, set shadow */
- RtdUtcCtrlPut(dev, 3, 0); /* safe state, set shadow */
- /* TODO: set user out source ??? */
-
- /* check if our interrupt is available and get it */
- ret = request_irq(devpriv->pci_dev->irq, rtd_interrupt,
- IRQF_SHARED, DRV_NAME, dev);
-
- if (ret < 0) {
- printk("Could not get interrupt! (%u)\n",
- devpriv->pci_dev->irq);
- return ret;
- }
- dev->irq = devpriv->pci_dev->irq;
- printk(KERN_INFO "( irq=%u )", dev->irq);
-
- ret = rtd520_probe_fifo_depth(dev);
- if (ret < 0)
- return ret;
-
- devpriv->fifoLen = ret;
- printk("( fifoLen=%d )", devpriv->fifoLen);
-
-#ifdef USE_DMA
- if (dev->irq > 0) {
- printk("( DMA buff=%d )\n", DMA_CHAIN_COUNT);
- /*
- * The PLX9080 has 2 DMA controllers, but there could be
- * 4 sources: ADC, digital, DAC1, and DAC2. Since only the
- * ADC supports cmd mode right now, this isn't an issue (yet)
- */
- devpriv->dma0Offset = 0;
-
- for (index = 0; index < DMA_CHAIN_COUNT; index++) {
- devpriv->dma0Buff[index] =
- pci_alloc_consistent(devpriv->pci_dev,
- sizeof(u16) *
- devpriv->fifoLen / 2,
- &devpriv->
- dma0BuffPhysAddr[index]);
- if (devpriv->dma0Buff[index] == NULL) {
- ret = -ENOMEM;
- goto rtd_attach_die_error;
- }
- /*DPRINTK ("buff[%d] @ %p virtual, %x PCI\n",
- index,
- devpriv->dma0Buff[index],
- devpriv->dma0BuffPhysAddr[index]); */
- }
-
- /*
- * setup DMA descriptor ring (use cpu_to_le32 for byte
- * ordering?)
- */
- devpriv->dma0Chain =
- pci_alloc_consistent(devpriv->pci_dev,
- sizeof(struct plx_dma_desc) *
- DMA_CHAIN_COUNT,
- &devpriv->dma0ChainPhysAddr);
- for (index = 0; index < DMA_CHAIN_COUNT; index++) {
- devpriv->dma0Chain[index].pci_start_addr =
- devpriv->dma0BuffPhysAddr[index];
- devpriv->dma0Chain[index].local_start_addr =
- DMALADDR_ADC;
- devpriv->dma0Chain[index].transfer_size =
- sizeof(u16) * devpriv->fifoLen / 2;
- devpriv->dma0Chain[index].next =
- (devpriv->dma0ChainPhysAddr + ((index +
- 1) %
- (DMA_CHAIN_COUNT))
- * sizeof(devpriv->dma0Chain[0]))
- | DMA_TRANSFER_BITS;
- /*DPRINTK ("ring[%d] @%lx PCI: %x, local: %x, N: 0x%x, next: %x\n",
- index,
- ((long)devpriv->dma0ChainPhysAddr
- + (index * sizeof(devpriv->dma0Chain[0]))),
- devpriv->dma0Chain[index].pci_start_addr,
- devpriv->dma0Chain[index].local_start_addr,
- devpriv->dma0Chain[index].transfer_size,
- devpriv->dma0Chain[index].next); */
- }
-
- if (devpriv->dma0Chain == NULL) {
- ret = -ENOMEM;
- goto rtd_attach_die_error;
- }
-
- RtdDma0Mode(dev, DMA_MODE_BITS);
- /* set DMA trigger source */
- RtdDma0Source(dev, DMAS_ADFIFO_HALF_FULL);
- } else {
- printk(KERN_INFO "( no IRQ->no DMA )");
- }
-#endif /* USE_DMA */
-
- if (dev->irq) { /* enable plx9080 interrupts */
- RtdPlxInterruptWrite(dev, ICS_PIE | ICS_PLIE);
- }
-
- printk("\ncomedi%d: rtd520 driver attached.\n", dev->minor);
-
- return 1;
-
-#if 0
- /* hit an error, clean up memory and return ret */
-/* rtd_attach_die_error: */
-#ifdef USE_DMA
- for (index = 0; index < DMA_CHAIN_COUNT; index++) {
- if (NULL != devpriv->dma0Buff[index]) { /* free buffer memory */
- pci_free_consistent(devpriv->pci_dev,
- sizeof(u16) * devpriv->fifoLen / 2,
- devpriv->dma0Buff[index],
- devpriv->dma0BuffPhysAddr[index]);
- devpriv->dma0Buff[index] = NULL;
- }
- }
- if (NULL != devpriv->dma0Chain) {
- pci_free_consistent(devpriv->pci_dev,
- sizeof(struct plx_dma_desc)
- * DMA_CHAIN_COUNT,
- devpriv->dma0Chain,
- devpriv->dma0ChainPhysAddr);
- devpriv->dma0Chain = NULL;
- }
-#endif /* USE_DMA */
- /* subdevices and priv are freed by the core */
- if (dev->irq) {
- /* disable interrupt controller */
- RtdPlxInterruptWrite(dev, RtdPlxInterruptRead(dev)
- & ~(ICS_PLIE | ICS_DMA0_E | ICS_DMA1_E));
- free_irq(dev->irq, dev);
- }
-
- /* release all regions that were allocated */
- if (devpriv->las0)
- iounmap(devpriv->las0);
-
- if (devpriv->las1)
- iounmap(devpriv->las1);
-
- if (devpriv->lcfg)
- iounmap(devpriv->lcfg);
-
- if (devpriv->pci_dev)
- pci_dev_put(devpriv->pci_dev);
-
- return ret;
-#endif
-}
-
-static void rtd_detach(struct comedi_device *dev)
-{
-#ifdef USE_DMA
- int index;
-#endif
-
- if (devpriv) {
- /* Shut down any board ops by resetting it */
-#ifdef USE_DMA
- if (devpriv->lcfg) {
- RtdDma0Control(dev, 0); /* disable DMA */
- RtdDma1Control(dev, 0); /* disable DMA */
- RtdPlxInterruptWrite(dev, ICS_PIE | ICS_PLIE);
- }
-#endif /* USE_DMA */
- if (devpriv->las0) {
- RtdResetBoard(dev);
- RtdInterruptMask(dev, 0);
- RtdInterruptClearMask(dev, ~0);
- RtdInterruptClear(dev); /* clears bits set by mask */
- }
-#ifdef USE_DMA
- /* release DMA */
- for (index = 0; index < DMA_CHAIN_COUNT; index++) {
- if (NULL != devpriv->dma0Buff[index]) {
- pci_free_consistent(devpriv->pci_dev,
- sizeof(u16) *
- devpriv->fifoLen / 2,
- devpriv->dma0Buff[index],
- devpriv->
- dma0BuffPhysAddr[index]);
- devpriv->dma0Buff[index] = NULL;
- }
- }
- if (NULL != devpriv->dma0Chain) {
- pci_free_consistent(devpriv->pci_dev,
- sizeof(struct plx_dma_desc) *
- DMA_CHAIN_COUNT, devpriv->dma0Chain,
- devpriv->dma0ChainPhysAddr);
- devpriv->dma0Chain = NULL;
- }
-#endif /* USE_DMA */
- if (dev->irq) {
- RtdPlxInterruptWrite(dev, RtdPlxInterruptRead(dev)
- & ~(ICS_PLIE | ICS_DMA0_E |
- ICS_DMA1_E));
- free_irq(dev->irq, dev);
- }
- if (devpriv->las0)
- iounmap(devpriv->las0);
- if (devpriv->las1)
- iounmap(devpriv->las1);
- if (devpriv->lcfg)
- iounmap(devpriv->lcfg);
- if (devpriv->pci_dev) {
- if (devpriv->got_regions)
- comedi_pci_disable(devpriv->pci_dev);
- pci_dev_put(devpriv->pci_dev);
- }
- }
-}
-
-/*
- Convert a single comedi channel-gain entry to a RTD520 table entry
-*/
-static unsigned short rtdConvertChanGain(struct comedi_device *dev,
- unsigned int comediChan, int chanIndex)
-{ /* index in channel list */
- unsigned int chan, range, aref;
- unsigned short r = 0;
-
- chan = CR_CHAN(comediChan);
- range = CR_RANGE(comediChan);
- aref = CR_AREF(comediChan);
-
- r |= chan & 0xf;
-
- /* Note: we also setup the channel list bipolar flag array */
- if (range < thisboard->range10Start) { /* first batch are +-5 */
- r |= 0x000; /* +-5 range */
- r |= (range & 0x7) << 4; /* gain */
- CHAN_ARRAY_SET(devpriv->chanBipolar, chanIndex);
- } else if (range < thisboard->rangeUniStart) { /* second batch are +-10 */
- r |= 0x100; /* +-10 range */
- /* gain */
- r |= ((range - thisboard->range10Start) & 0x7) << 4;
- CHAN_ARRAY_SET(devpriv->chanBipolar, chanIndex);
- } else { /* last batch is +10 */
- r |= 0x200; /* +10 range */
- /* gain */
- r |= ((range - thisboard->rangeUniStart) & 0x7) << 4;
- CHAN_ARRAY_CLEAR(devpriv->chanBipolar, chanIndex);
- }
-
- switch (aref) {
- case AREF_GROUND: /* on-board ground */
- break;
-
- case AREF_COMMON:
- r |= 0x80; /* ref external analog common */
- break;
-
- case AREF_DIFF:
- r |= 0x400; /* differential inputs */
- break;
-
- case AREF_OTHER: /* ??? */
- break;
- }
- /*printk ("chan=%d r=%d a=%d -> 0x%x\n",
- chan, range, aref, r); */
- return r;
-}
-
-/*
- Setup the channel-gain table from a comedi list
-*/
-static void rtd_load_channelgain_list(struct comedi_device *dev,
- unsigned int n_chan, unsigned int *list)
-{
- if (n_chan > 1) { /* setup channel gain table */
- int ii;
- RtdClearCGT(dev);
- RtdEnableCGT(dev, 1); /* enable table */
- for (ii = 0; ii < n_chan; ii++) {
- RtdWriteCGTable(dev, rtdConvertChanGain(dev, list[ii],
- ii));
- }
- } else { /* just use the channel gain latch */
- RtdEnableCGT(dev, 0); /* disable table, enable latch */
- RtdWriteCGLatch(dev, rtdConvertChanGain(dev, list[0], 0));
- }
-}
-
-/* determine fifo size by doing adc conversions until the fifo half
-empty status flag clears */
-static int rtd520_probe_fifo_depth(struct comedi_device *dev)
-{
- unsigned int chanspec = CR_PACK(0, 0, AREF_GROUND);
- unsigned i;
- static const unsigned limit = 0x2000;
- unsigned fifo_size = 0;
-
- RtdAdcClearFifo(dev);
- rtd_load_channelgain_list(dev, 1, &chanspec);
- RtdAdcConversionSource(dev, 0); /* software */
- /* convert samples */
- for (i = 0; i < limit; ++i) {
- unsigned fifo_status;
- /* trigger conversion */
- RtdAdcStart(dev);
- udelay(1);
- fifo_status = RtdFifoStatus(dev);
- if ((fifo_status & FS_ADC_HEMPTY) == 0) {
- fifo_size = 2 * i;
- break;
- }
- }
- if (i == limit) {
- printk(KERN_INFO "\ncomedi: %s: failed to probe fifo size.\n",
- DRV_NAME);
- return -EIO;
- }
- RtdAdcClearFifo(dev);
- if (fifo_size != 0x400 && fifo_size != 0x2000) {
- printk
- (KERN_INFO "\ncomedi: %s: unexpected fifo size of %i, expected 1024 or 8192.\n",
- DRV_NAME, fifo_size);
- return -EIO;
- }
- return fifo_size;
-}
-
-/*
- "instructions" read/write data in "one-shot" or "software-triggered"
- mode (simplest case).
- This doesn't use interrupts.
-
- Note, we don't do any settling delays. Use a instruction list to
- select, delay, then read.
- */
-static int rtd_ai_rinsn(struct comedi_device *dev,
- struct comedi_subdevice *s, struct comedi_insn *insn,
- unsigned int *data)
-{
- int n, ii;
- int stat;
-
- /* clear any old fifo data */
- RtdAdcClearFifo(dev);
-
- /* write channel to multiplexer and clear channel gain table */
- rtd_load_channelgain_list(dev, 1, &insn->chanspec);
-
- /* set conversion source */
- RtdAdcConversionSource(dev, 0); /* software */
+ /* set conversion source */
+ RtdAdcConversionSource(dev, 0); /* software */
/* convert n samples */
for (n = 0; n < insn->n; n++) {
DPRINTK("rtd520: unknown interrupt source!\n");
}
- if (0xffff & RtdInterruptOverrunStatus(dev)) { /* interrupt overrun */
- DPRINTK
- ("rtd520: Interrupt overrun with %ld to go! over_status=0x%x\n",
- devpriv->aiCount, 0xffff & RtdInterruptOverrunStatus(dev));
- goto abortTransfer;
+ if (0xffff & RtdInterruptOverrunStatus(dev)) { /* interrupt overrun */
+ DPRINTK
+ ("rtd520: Interrupt overrun with %ld to go! over_status=0x%x\n",
+ devpriv->aiCount, 0xffff & RtdInterruptOverrunStatus(dev));
+ goto abortTransfer;
+ }
+
+ /* clear the interrupt */
+ RtdInterruptClearMask(dev, status);
+ RtdInterruptClear(dev);
+ return IRQ_HANDLED;
+
+abortTransfer:
+ RtdAdcClearFifo(dev); /* clears full flag */
+ s->async->events |= COMEDI_CB_ERROR;
+ devpriv->aiCount = 0; /* stop and don't transfer any more */
+ /* fall into transferDone */
+
+transferDone:
+ RtdPacerStopSource(dev, 0); /* stop on SOFTWARE stop */
+ RtdPacerStop(dev); /* Stop PACER */
+ RtdAdcConversionSource(dev, 0); /* software trigger only */
+ RtdInterruptMask(dev, 0); /* mask out SAMPLE */
+#ifdef USE_DMA
+ if (devpriv->flags & DMA0_ACTIVE) {
+ RtdPlxInterruptWrite(dev, /* disable any more interrupts */
+ RtdPlxInterruptRead(dev) & ~ICS_DMA0_E);
+ abort_dma(dev, 0);
+ devpriv->flags &= ~DMA0_ACTIVE;
+ /* if Using DMA, then we should have read everything by now */
+ if (devpriv->aiCount > 0) {
+ DPRINTK("rtd520: Lost DMA data! %ld remain\n",
+ devpriv->aiCount);
+ }
+ }
+#endif /* USE_DMA */
+
+ if (devpriv->aiCount > 0) { /* there shouldn't be anything left */
+ fifoStatus = RtdFifoStatus(dev);
+ DPRINTK("rtd520: Finishing up. %ld remain, fifoStat=%x\n", devpriv->aiCount, (fifoStatus ^ 0x6666) & 0x7777); /* should read all 0s */
+ ai_read_dregs(dev, s); /* read anything left in FIFO */
+ }
+
+ s->async->events |= COMEDI_CB_EOA; /* signal end to comedi */
+ comedi_event(dev, s);
+
+ /* clear the interrupt */
+ status = RtdInterruptStatus(dev);
+ RtdInterruptClearMask(dev, status);
+ RtdInterruptClear(dev);
+
+ fifoStatus = RtdFifoStatus(dev); /* DEBUG */
+ DPRINTK
+ ("rtd520: Acquisition complete. %ld ints, intStat=%x, overStat=%x\n",
+ devpriv->intCount, status,
+ 0xffff & RtdInterruptOverrunStatus(dev));
+
+ return IRQ_HANDLED;
+}
+
+#if 0
+/*
+ return the number of samples available
+*/
+static int rtd_ai_poll(struct comedi_device *dev, struct comedi_subdevice *s)
+{
+ /* TODO: This needs to mask interrupts, read_dregs, and then re-enable */
+ /* Not sure what to do if DMA is active */
+ return s->async->buf_write_count - s->async->buf_read_count;
+}
+#endif
+
+/*
+ cmdtest tests a particular command to see if it is valid.
+ Using the cmdtest ioctl, a user can create a valid cmd
+ and then have it executed by the cmd ioctl (asyncronously).
+
+ cmdtest returns 1,2,3,4 or 0, depending on which tests
+ the command passes.
+*/
+
+static int rtd_ai_cmdtest(struct comedi_device *dev,
+ struct comedi_subdevice *s, struct comedi_cmd *cmd)
+{
+ int err = 0;
+ int tmp;
+
+ /* step 1: make sure trigger sources are trivially valid */
+
+ tmp = cmd->start_src;
+ cmd->start_src &= TRIG_NOW;
+ if (!cmd->start_src || tmp != cmd->start_src)
+ err++;
+
+ tmp = cmd->scan_begin_src;
+ cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
+ if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
+ err++;
+
+
+ tmp = cmd->convert_src;
+ cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
+ if (!cmd->convert_src || tmp != cmd->convert_src)
+ err++;
+
+
+ tmp = cmd->scan_end_src;
+ cmd->scan_end_src &= TRIG_COUNT;
+ if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
+ err++;
+
+
+ tmp = cmd->stop_src;
+ cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
+ if (!cmd->stop_src || tmp != cmd->stop_src)
+ err++;
+
+
+ if (err)
+ return 1;
+
+ /* step 2: make sure trigger sources are unique
+ and mutually compatible */
+ /* note that mutual compatibility is not an issue here */
+ if (cmd->scan_begin_src != TRIG_TIMER &&
+ cmd->scan_begin_src != TRIG_EXT) {
+ err++;
+ }
+ if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
+ err++;
+
+ if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
+ err++;
+
+ if (err)
+ return 2;
+
+ /* step 3: make sure arguments are trivially compatible */
+
+ if (cmd->start_arg != 0) {
+ cmd->start_arg = 0;
+ err++;
+ }
+
+ if (cmd->scan_begin_src == TRIG_TIMER) {
+ /* Note: these are time periods, not actual rates */
+ if (1 == cmd->chanlist_len) { /* no scanning */
+ if (cmd->scan_begin_arg < RTD_MAX_SPEED_1) {
+ cmd->scan_begin_arg = RTD_MAX_SPEED_1;
+ rtd_ns_to_timer(&cmd->scan_begin_arg,
+ TRIG_ROUND_UP);
+ err++;
+ }
+ if (cmd->scan_begin_arg > RTD_MIN_SPEED_1) {
+ cmd->scan_begin_arg = RTD_MIN_SPEED_1;
+ rtd_ns_to_timer(&cmd->scan_begin_arg,
+ TRIG_ROUND_DOWN);
+ err++;
+ }
+ } else {
+ if (cmd->scan_begin_arg < RTD_MAX_SPEED) {
+ cmd->scan_begin_arg = RTD_MAX_SPEED;
+ rtd_ns_to_timer(&cmd->scan_begin_arg,
+ TRIG_ROUND_UP);
+ err++;
+ }
+ if (cmd->scan_begin_arg > RTD_MIN_SPEED) {
+ cmd->scan_begin_arg = RTD_MIN_SPEED;
+ rtd_ns_to_timer(&cmd->scan_begin_arg,
+ TRIG_ROUND_DOWN);
+ err++;
+ }
+ }
+ } else {
+ /* external trigger */
+ /* should be level/edge, hi/lo specification here */
+ /* should specify multiple external triggers */
+ if (cmd->scan_begin_arg > 9) {
+ cmd->scan_begin_arg = 9;
+ err++;
+ }
+ }
+ if (cmd->convert_src == TRIG_TIMER) {
+ if (1 == cmd->chanlist_len) { /* no scanning */
+ if (cmd->convert_arg < RTD_MAX_SPEED_1) {
+ cmd->convert_arg = RTD_MAX_SPEED_1;
+ rtd_ns_to_timer(&cmd->convert_arg,
+ TRIG_ROUND_UP);
+ err++;
+ }
+ if (cmd->convert_arg > RTD_MIN_SPEED_1) {
+ cmd->convert_arg = RTD_MIN_SPEED_1;
+ rtd_ns_to_timer(&cmd->convert_arg,
+ TRIG_ROUND_DOWN);
+ err++;
+ }
+ } else {
+ if (cmd->convert_arg < RTD_MAX_SPEED) {
+ cmd->convert_arg = RTD_MAX_SPEED;
+ rtd_ns_to_timer(&cmd->convert_arg,
+ TRIG_ROUND_UP);
+ err++;
+ }
+ if (cmd->convert_arg > RTD_MIN_SPEED) {
+ cmd->convert_arg = RTD_MIN_SPEED;
+ rtd_ns_to_timer(&cmd->convert_arg,
+ TRIG_ROUND_DOWN);
+ err++;
+ }
+ }
+ } else {
+ /* external trigger */
+ /* see above */
+ if (cmd->convert_arg > 9) {
+ cmd->convert_arg = 9;
+ err++;
+ }
+ }
+
+#if 0
+ if (cmd->scan_end_arg != cmd->chanlist_len) {
+ cmd->scan_end_arg = cmd->chanlist_len;
+ err++;
+ }
+#endif
+ if (cmd->stop_src == TRIG_COUNT) {
+ /* TODO check for rounding error due to counter wrap */
+
+ } else {
+ /* TRIG_NONE */
+ if (cmd->stop_arg != 0) {
+ cmd->stop_arg = 0;
+ err++;
+ }
+ }
+
+ if (err)
+ return 3;
+
+
+ /* step 4: fix up any arguments */
+
+ if (cmd->chanlist_len > RTD_MAX_CHANLIST) {
+ cmd->chanlist_len = RTD_MAX_CHANLIST;
+ err++;
+ }
+ if (cmd->scan_begin_src == TRIG_TIMER) {
+ tmp = cmd->scan_begin_arg;
+ rtd_ns_to_timer(&cmd->scan_begin_arg,
+ cmd->flags & TRIG_ROUND_MASK);
+ if (tmp != cmd->scan_begin_arg)
+ err++;
+
+ }
+ if (cmd->convert_src == TRIG_TIMER) {
+ tmp = cmd->convert_arg;
+ rtd_ns_to_timer(&cmd->convert_arg,
+ cmd->flags & TRIG_ROUND_MASK);
+ if (tmp != cmd->convert_arg)
+ err++;
+
+ if (cmd->scan_begin_src == TRIG_TIMER
+ && (cmd->scan_begin_arg
+ < (cmd->convert_arg * cmd->scan_end_arg))) {
+ cmd->scan_begin_arg =
+ cmd->convert_arg * cmd->scan_end_arg;
+ err++;
+ }
}
- /* clear the interrupt */
- RtdInterruptClearMask(dev, status);
- RtdInterruptClear(dev);
- return IRQ_HANDLED;
+ if (err)
+ return 4;
-abortTransfer:
- RtdAdcClearFifo(dev); /* clears full flag */
- s->async->events |= COMEDI_CB_ERROR;
- devpriv->aiCount = 0; /* stop and don't transfer any more */
- /* fall into transferDone */
+ return 0;
+}
-transferDone:
+/*
+ Execute a analog in command with many possible triggering options.
+ The data get stored in the async structure of the subdevice.
+ This is usually done by an interrupt handler.
+ Userland gets to the data using read calls.
+*/
+static int rtd_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
+{
+ struct comedi_cmd *cmd = &s->async->cmd;
+ int timer;
+
+ /* stop anything currently running */
RtdPacerStopSource(dev, 0); /* stop on SOFTWARE stop */
- RtdPacerStop(dev); /* Stop PACER */
+ RtdPacerStop(dev); /* make sure PACER is stopped */
RtdAdcConversionSource(dev, 0); /* software trigger only */
- RtdInterruptMask(dev, 0); /* mask out SAMPLE */
+ RtdInterruptMask(dev, 0);
#ifdef USE_DMA
- if (devpriv->flags & DMA0_ACTIVE) {
+ if (devpriv->flags & DMA0_ACTIVE) { /* cancel anything running */
RtdPlxInterruptWrite(dev, /* disable any more interrupts */
RtdPlxInterruptRead(dev) & ~ICS_DMA0_E);
abort_dma(dev, 0);
devpriv->flags &= ~DMA0_ACTIVE;
- /* if Using DMA, then we should have read everything by now */
- if (devpriv->aiCount > 0) {
- DPRINTK("rtd520: Lost DMA data! %ld remain\n",
- devpriv->aiCount);
+ if (RtdPlxInterruptRead(dev) & ICS_DMA0_A) { /*clear pending int */
+ RtdDma0Control(dev, PLX_CLEAR_DMA_INTR_BIT);
}
}
+ RtdDma0Reset(dev); /* reset onboard state */
#endif /* USE_DMA */
+ RtdAdcClearFifo(dev); /* clear any old data */
+ RtdInterruptOverrunClear(dev);
+ devpriv->intCount = 0;
- if (devpriv->aiCount > 0) { /* there shouldn't be anything left */
- fifoStatus = RtdFifoStatus(dev);
- DPRINTK("rtd520: Finishing up. %ld remain, fifoStat=%x\n", devpriv->aiCount, (fifoStatus ^ 0x6666) & 0x7777); /* should read all 0s */
- ai_read_dregs(dev, s); /* read anything left in FIFO */
+ if (!dev->irq) { /* we need interrupts for this */
+ DPRINTK("rtd520: ERROR! No interrupt available!\n");
+ return -ENXIO;
}
- s->async->events |= COMEDI_CB_EOA; /* signal end to comedi */
- comedi_event(dev, s);
+ /* start configuration */
+ /* load channel list and reset CGT */
+ rtd_load_channelgain_list(dev, cmd->chanlist_len, cmd->chanlist);
- /* clear the interrupt */
- status = RtdInterruptStatus(dev);
- RtdInterruptClearMask(dev, status);
+ /* setup the common case and override if needed */
+ if (cmd->chanlist_len > 1) {
+ /*DPRINTK ("rtd520: Multi channel setup\n"); */
+ RtdPacerStartSource(dev, 0); /* software triggers pacer */
+ RtdBurstStartSource(dev, 1); /* PACER triggers burst */
+ RtdAdcConversionSource(dev, 2); /* BURST triggers ADC */
+ } else { /* single channel */
+ /*DPRINTK ("rtd520: single channel setup\n"); */
+ RtdPacerStartSource(dev, 0); /* software triggers pacer */
+ RtdAdcConversionSource(dev, 1); /* PACER triggers ADC */
+ }
+ RtdAboutCounter(dev, devpriv->fifoLen / 2 - 1); /* 1/2 FIFO */
+
+ if (TRIG_TIMER == cmd->scan_begin_src) {
+ /* scan_begin_arg is in nanoseconds */
+ /* find out how many samples to wait before transferring */
+ if (cmd->flags & TRIG_WAKE_EOS) {
+ /* this may generate un-sustainable interrupt rates */
+ /* the application is responsible for doing the right thing */
+ devpriv->transCount = cmd->chanlist_len;
+ devpriv->flags |= SEND_EOS;
+ } else {
+ /* arrange to transfer data periodically */
+ devpriv->transCount
+ =
+ (TRANS_TARGET_PERIOD * cmd->chanlist_len) /
+ cmd->scan_begin_arg;
+ if (devpriv->transCount < cmd->chanlist_len) {
+ /* transfer after each scan (and avoid 0) */
+ devpriv->transCount = cmd->chanlist_len;
+ } else { /* make a multiple of scan length */
+ devpriv->transCount =
+ (devpriv->transCount +
+ cmd->chanlist_len - 1)
+ / cmd->chanlist_len;
+ devpriv->transCount *= cmd->chanlist_len;
+ }
+ devpriv->flags |= SEND_EOS;
+ }
+ if (devpriv->transCount >= (devpriv->fifoLen / 2)) {
+ /* out of counter range, use 1/2 fifo instead */
+ devpriv->transCount = 0;
+ devpriv->flags &= ~SEND_EOS;
+ } else {
+ /* interrupt for each transfer */
+ RtdAboutCounter(dev, devpriv->transCount - 1);
+ }
+
+ DPRINTK
+ ("rtd520: scanLen=%d transferCount=%d fifoLen=%d\n scanTime(ns)=%d flags=0x%x\n",
+ cmd->chanlist_len, devpriv->transCount, devpriv->fifoLen,
+ cmd->scan_begin_arg, devpriv->flags);
+ } else { /* unknown timing, just use 1/2 FIFO */
+ devpriv->transCount = 0;
+ devpriv->flags &= ~SEND_EOS;
+ }
+ RtdPacerClockSource(dev, 1); /* use INTERNAL 8Mhz clock source */
+ RtdAboutStopEnable(dev, 1); /* just interrupt, dont stop */
+
+ /* BUG??? these look like enumerated values, but they are bit fields */
+
+ /* First, setup when to stop */
+ switch (cmd->stop_src) {
+ case TRIG_COUNT: /* stop after N scans */
+ devpriv->aiCount = cmd->stop_arg * cmd->chanlist_len;
+ if ((devpriv->transCount > 0)
+ && (devpriv->transCount > devpriv->aiCount)) {
+ devpriv->transCount = devpriv->aiCount;
+ }
+ break;
+
+ case TRIG_NONE: /* stop when cancel is called */
+ devpriv->aiCount = -1; /* read forever */
+ break;
+
+ default:
+ DPRINTK("rtd520: Warning! ignoring stop_src mode %d\n",
+ cmd->stop_src);
+ }
+
+ /* Scan timing */
+ switch (cmd->scan_begin_src) {
+ case TRIG_TIMER: /* periodic scanning */
+ timer = rtd_ns_to_timer(&cmd->scan_begin_arg,
+ TRIG_ROUND_NEAREST);
+ /* set PACER clock */
+ /*DPRINTK ("rtd520: loading %d into pacer\n", timer); */
+ RtdPacerCounter(dev, timer);
+
+ break;
+
+ case TRIG_EXT:
+ RtdPacerStartSource(dev, 1); /* EXTERNALy trigger pacer */
+ break;
+
+ default:
+ DPRINTK("rtd520: Warning! ignoring scan_begin_src mode %d\n",
+ cmd->scan_begin_src);
+ }
+
+ /* Sample timing within a scan */
+ switch (cmd->convert_src) {
+ case TRIG_TIMER: /* periodic */
+ if (cmd->chanlist_len > 1) { /* only needed for multi-channel */
+ timer = rtd_ns_to_timer(&cmd->convert_arg,
+ TRIG_ROUND_NEAREST);
+ /* setup BURST clock */
+ /*DPRINTK ("rtd520: loading %d into burst\n", timer); */
+ RtdBurstCounter(dev, timer);
+ }
+
+ break;
+
+ case TRIG_EXT: /* external */
+ RtdBurstStartSource(dev, 2); /* EXTERNALy trigger burst */
+ break;
+
+ default:
+ DPRINTK("rtd520: Warning! ignoring convert_src mode %d\n",
+ cmd->convert_src);
+ }
+ /* end configuration */
+
+ /* This doesn't seem to work. There is no way to clear an interrupt
+ that the priority controller has queued! */
+ RtdInterruptClearMask(dev, ~0); /* clear any existing flags */
RtdInterruptClear(dev);
- fifoStatus = RtdFifoStatus(dev); /* DEBUG */
- DPRINTK
- ("rtd520: Acquisition complete. %ld ints, intStat=%x, overStat=%x\n",
- devpriv->intCount, status,
- 0xffff & RtdInterruptOverrunStatus(dev));
+ /* TODO: allow multiple interrupt sources */
+ if (devpriv->transCount > 0) { /* transfer every N samples */
+ RtdInterruptMask(dev, IRQM_ADC_ABOUT_CNT);
+ DPRINTK("rtd520: Transferring every %d\n", devpriv->transCount);
+ } else { /* 1/2 FIFO transfers */
+#ifdef USE_DMA
+ devpriv->flags |= DMA0_ACTIVE;
- return IRQ_HANDLED;
+ /* point to first transfer in ring */
+ devpriv->dma0Offset = 0;
+ RtdDma0Mode(dev, DMA_MODE_BITS);
+ RtdDma0Next(dev, /* point to first block */
+ devpriv->dma0Chain[DMA_CHAIN_COUNT - 1].next);
+ RtdDma0Source(dev, DMAS_ADFIFO_HALF_FULL); /* set DMA trigger source */
+
+ RtdPlxInterruptWrite(dev, /* enable interrupt */
+ RtdPlxInterruptRead(dev) | ICS_DMA0_E);
+ /* Must be 2 steps. See PLX app note about "Starting a DMA transfer" */
+ RtdDma0Control(dev, PLX_DMA_EN_BIT); /* enable DMA (clear INTR?) */
+ RtdDma0Control(dev, PLX_DMA_EN_BIT | PLX_DMA_START_BIT); /*start DMA */
+ DPRINTK("rtd520: Using DMA0 transfers. plxInt %x RtdInt %x\n",
+ RtdPlxInterruptRead(dev), devpriv->intMask);
+#else /* USE_DMA */
+ RtdInterruptMask(dev, IRQM_ADC_ABOUT_CNT);
+ DPRINTK("rtd520: Transferring every 1/2 FIFO\n");
+#endif /* USE_DMA */
+ }
+
+ /* BUG: start_src is ASSUMED to be TRIG_NOW */
+ /* BUG? it seems like things are running before the "start" */
+ RtdPacerStart(dev); /* Start PACER */
+ return 0;
}
-#if 0
/*
- return the number of samples available
+ Stop a running data acquisition.
*/
-static int rtd_ai_poll(struct comedi_device *dev, struct comedi_subdevice *s)
+static int rtd_ai_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
{
- /* TODO: This needs to mask interrupts, read_dregs, and then re-enable */
- /* Not sure what to do if DMA is active */
- return s->async->buf_write_count - s->async->buf_read_count;
+ u16 status;
+
+ RtdPacerStopSource(dev, 0); /* stop on SOFTWARE stop */
+ RtdPacerStop(dev); /* Stop PACER */
+ RtdAdcConversionSource(dev, 0); /* software trigger only */
+ RtdInterruptMask(dev, 0);
+ devpriv->aiCount = 0; /* stop and don't transfer any more */
+#ifdef USE_DMA
+ if (devpriv->flags & DMA0_ACTIVE) {
+ RtdPlxInterruptWrite(dev, /* disable any more interrupts */
+ RtdPlxInterruptRead(dev) & ~ICS_DMA0_E);
+ abort_dma(dev, 0);
+ devpriv->flags &= ~DMA0_ACTIVE;
+ }
+#endif /* USE_DMA */
+ status = RtdInterruptStatus(dev);
+ DPRINTK
+ ("rtd520: Acquisition canceled. %ld ints, intStat=%x, overStat=%x\n",
+ devpriv->intCount, status,
+ 0xffff & RtdInterruptOverrunStatus(dev));
+ return 0;
}
-#endif
/*
- cmdtest tests a particular command to see if it is valid.
- Using the cmdtest ioctl, a user can create a valid cmd
- and then have it executed by the cmd ioctl (asyncronously).
-
- cmdtest returns 1,2,3,4 or 0, depending on which tests
- the command passes.
+ Output one (or more) analog values to a single port as fast as possible.
*/
-
-static int rtd_ai_cmdtest(struct comedi_device *dev,
- struct comedi_subdevice *s, struct comedi_cmd *cmd)
+static int rtd_ao_winsn(struct comedi_device *dev,
+ struct comedi_subdevice *s, struct comedi_insn *insn,
+ unsigned int *data)
{
- int err = 0;
- int tmp;
-
- /* step 1: make sure trigger sources are trivially valid */
-
- tmp = cmd->start_src;
- cmd->start_src &= TRIG_NOW;
- if (!cmd->start_src || tmp != cmd->start_src)
- err++;
-
- tmp = cmd->scan_begin_src;
- cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
- if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
- err++;
-
-
- tmp = cmd->convert_src;
- cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
- if (!cmd->convert_src || tmp != cmd->convert_src)
- err++;
-
-
- tmp = cmd->scan_end_src;
- cmd->scan_end_src &= TRIG_COUNT;
- if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
- err++;
-
-
- tmp = cmd->stop_src;
- cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
- if (!cmd->stop_src || tmp != cmd->stop_src)
- err++;
+ int i;
+ int chan = CR_CHAN(insn->chanspec);
+ int range = CR_RANGE(insn->chanspec);
+ /* Configure the output range (table index matches the range values) */
+ RtdDacRange(dev, chan, range);
- if (err)
- return 1;
+ /* Writing a list of values to an AO channel is probably not
+ * very useful, but that's how the interface is defined. */
+ for (i = 0; i < insn->n; ++i) {
+ int val = data[i] << 3;
+ int stat = 0; /* initialize to avoid bogus warning */
+ int ii;
- /* step 2: make sure trigger sources are unique
- and mutually compatible */
- /* note that mutual compatibility is not an issue here */
- if (cmd->scan_begin_src != TRIG_TIMER &&
- cmd->scan_begin_src != TRIG_EXT) {
- err++;
- }
- if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
- err++;
+ /* VERIFY: comedi range and offset conversions */
- if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
- err++;
+ if ((range > 1) /* bipolar */
+ && (data[i] < 2048)) {
+ /* offset and sign extend */
+ val = (((int)data[i]) - 2048) << 3;
+ } else { /* unipolor */
+ val = data[i] << 3;
+ }
- if (err)
- return 2;
+ DPRINTK
+ ("comedi: rtd520 DAC chan=%d range=%d writing %d as 0x%x\n",
+ chan, range, data[i], val);
- /* step 3: make sure arguments are trivially compatible */
+ /* a typical programming sequence */
+ RtdDacFifoPut(dev, chan, val); /* put the value in */
+ RtdDacUpdate(dev, chan); /* trigger the conversion */
- if (cmd->start_arg != 0) {
- cmd->start_arg = 0;
- err++;
- }
+ devpriv->aoValue[chan] = data[i]; /* save for read back */
- if (cmd->scan_begin_src == TRIG_TIMER) {
- /* Note: these are time periods, not actual rates */
- if (1 == cmd->chanlist_len) { /* no scanning */
- if (cmd->scan_begin_arg < RTD_MAX_SPEED_1) {
- cmd->scan_begin_arg = RTD_MAX_SPEED_1;
- rtd_ns_to_timer(&cmd->scan_begin_arg,
- TRIG_ROUND_UP);
- err++;
- }
- if (cmd->scan_begin_arg > RTD_MIN_SPEED_1) {
- cmd->scan_begin_arg = RTD_MIN_SPEED_1;
- rtd_ns_to_timer(&cmd->scan_begin_arg,
- TRIG_ROUND_DOWN);
- err++;
- }
- } else {
- if (cmd->scan_begin_arg < RTD_MAX_SPEED) {
- cmd->scan_begin_arg = RTD_MAX_SPEED;
- rtd_ns_to_timer(&cmd->scan_begin_arg,
- TRIG_ROUND_UP);
- err++;
- }
- if (cmd->scan_begin_arg > RTD_MIN_SPEED) {
- cmd->scan_begin_arg = RTD_MIN_SPEED;
- rtd_ns_to_timer(&cmd->scan_begin_arg,
- TRIG_ROUND_DOWN);
- err++;
- }
- }
- } else {
- /* external trigger */
- /* should be level/edge, hi/lo specification here */
- /* should specify multiple external triggers */
- if (cmd->scan_begin_arg > 9) {
- cmd->scan_begin_arg = 9;
- err++;
- }
- }
- if (cmd->convert_src == TRIG_TIMER) {
- if (1 == cmd->chanlist_len) { /* no scanning */
- if (cmd->convert_arg < RTD_MAX_SPEED_1) {
- cmd->convert_arg = RTD_MAX_SPEED_1;
- rtd_ns_to_timer(&cmd->convert_arg,
- TRIG_ROUND_UP);
- err++;
- }
- if (cmd->convert_arg > RTD_MIN_SPEED_1) {
- cmd->convert_arg = RTD_MIN_SPEED_1;
- rtd_ns_to_timer(&cmd->convert_arg,
- TRIG_ROUND_DOWN);
- err++;
- }
- } else {
- if (cmd->convert_arg < RTD_MAX_SPEED) {
- cmd->convert_arg = RTD_MAX_SPEED;
- rtd_ns_to_timer(&cmd->convert_arg,
- TRIG_ROUND_UP);
- err++;
- }
- if (cmd->convert_arg > RTD_MIN_SPEED) {
- cmd->convert_arg = RTD_MIN_SPEED;
- rtd_ns_to_timer(&cmd->convert_arg,
- TRIG_ROUND_DOWN);
- err++;
- }
+ for (ii = 0; ii < RTD_DAC_TIMEOUT; ++ii) {
+ stat = RtdFifoStatus(dev);
+ /* 1 -> not empty */
+ if (stat & ((0 == chan) ? FS_DAC1_NOT_EMPTY :
+ FS_DAC2_NOT_EMPTY))
+ break;
+ WAIT_QUIETLY;
}
- } else {
- /* external trigger */
- /* see above */
- if (cmd->convert_arg > 9) {
- cmd->convert_arg = 9;
- err++;
+ if (ii >= RTD_DAC_TIMEOUT) {
+ DPRINTK
+ ("rtd520: Error: DAC never finished! FifoStatus=0x%x\n",
+ stat ^ 0x6666);
+ return -ETIMEDOUT;
}
}
-#if 0
- if (cmd->scan_end_arg != cmd->chanlist_len) {
- cmd->scan_end_arg = cmd->chanlist_len;
- err++;
- }
-#endif
- if (cmd->stop_src == TRIG_COUNT) {
- /* TODO check for rounding error due to counter wrap */
+ /* return the number of samples read/written */
+ return i;
+}
- } else {
- /* TRIG_NONE */
- if (cmd->stop_arg != 0) {
- cmd->stop_arg = 0;
- err++;
- }
- }
+/* AO subdevices should have a read insn as well as a write insn.
+ * Usually this means copying a value stored in devpriv. */
+static int rtd_ao_rinsn(struct comedi_device *dev,
+ struct comedi_subdevice *s, struct comedi_insn *insn,
+ unsigned int *data)
+{
+ int i;
+ int chan = CR_CHAN(insn->chanspec);
- if (err)
- return 3;
+ for (i = 0; i < insn->n; i++)
+ data[i] = devpriv->aoValue[chan];
- /* step 4: fix up any arguments */
+ return i;
+}
- if (cmd->chanlist_len > RTD_MAX_CHANLIST) {
- cmd->chanlist_len = RTD_MAX_CHANLIST;
- err++;
- }
- if (cmd->scan_begin_src == TRIG_TIMER) {
- tmp = cmd->scan_begin_arg;
- rtd_ns_to_timer(&cmd->scan_begin_arg,
- cmd->flags & TRIG_ROUND_MASK);
- if (tmp != cmd->scan_begin_arg)
- err++;
+/*
+ Write a masked set of bits and the read back the port.
+ We track what the bits should be (i.e. we don't read the port first).
- }
- if (cmd->convert_src == TRIG_TIMER) {
- tmp = cmd->convert_arg;
- rtd_ns_to_timer(&cmd->convert_arg,
- cmd->flags & TRIG_ROUND_MASK);
- if (tmp != cmd->convert_arg)
- err++;
+ DIO devices are slightly special. Although it is possible to
+ * implement the insn_read/insn_write interface, it is much more
+ * useful to applications if you implement the insn_bits interface.
+ * This allows packed reading/writing of the DIO channels. The
+ * comedi core can convert between insn_bits and insn_read/write
+ */
+static int rtd_dio_insn_bits(struct comedi_device *dev,
+ struct comedi_subdevice *s,
+ struct comedi_insn *insn, unsigned int *data)
+{
+ /* The insn data is a mask in data[0] and the new data
+ * in data[1], each channel cooresponding to a bit. */
+ if (data[0]) {
+ s->state &= ~data[0];
+ s->state |= data[0] & data[1];
- if (cmd->scan_begin_src == TRIG_TIMER
- && (cmd->scan_begin_arg
- < (cmd->convert_arg * cmd->scan_end_arg))) {
- cmd->scan_begin_arg =
- cmd->convert_arg * cmd->scan_end_arg;
- err++;
- }
+ /* Write out the new digital output lines */
+ RtdDio0Write(dev, s->state);
}
+ /* on return, data[1] contains the value of the digital
+ * input lines. */
+ data[1] = RtdDio0Read(dev);
- if (err)
- return 4;
+ /*DPRINTK("rtd520:port_0 wrote: 0x%x read: 0x%x\n", s->state, data[1]); */
- return 0;
+ return insn->n;
}
/*
- Execute a analog in command with many possible triggering options.
- The data get stored in the async structure of the subdevice.
- This is usually done by an interrupt handler.
- Userland gets to the data using read calls.
+ Configure one bit on a IO port as Input or Output (hence the name :-).
*/
-static int rtd_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
+static int rtd_dio_insn_config(struct comedi_device *dev,
+ struct comedi_subdevice *s,
+ struct comedi_insn *insn, unsigned int *data)
{
- struct comedi_cmd *cmd = &s->async->cmd;
- int timer;
-
- /* stop anything currently running */
- RtdPacerStopSource(dev, 0); /* stop on SOFTWARE stop */
- RtdPacerStop(dev); /* make sure PACER is stopped */
- RtdAdcConversionSource(dev, 0); /* software trigger only */
- RtdInterruptMask(dev, 0);
-#ifdef USE_DMA
- if (devpriv->flags & DMA0_ACTIVE) { /* cancel anything running */
- RtdPlxInterruptWrite(dev, /* disable any more interrupts */
- RtdPlxInterruptRead(dev) & ~ICS_DMA0_E);
- abort_dma(dev, 0);
- devpriv->flags &= ~DMA0_ACTIVE;
- if (RtdPlxInterruptRead(dev) & ICS_DMA0_A) { /*clear pending int */
- RtdDma0Control(dev, PLX_CLEAR_DMA_INTR_BIT);
- }
- }
- RtdDma0Reset(dev); /* reset onboard state */
-#endif /* USE_DMA */
- RtdAdcClearFifo(dev); /* clear any old data */
- RtdInterruptOverrunClear(dev);
- devpriv->intCount = 0;
-
- if (!dev->irq) { /* we need interrupts for this */
- DPRINTK("rtd520: ERROR! No interrupt available!\n");
- return -ENXIO;
- }
-
- /* start configuration */
- /* load channel list and reset CGT */
- rtd_load_channelgain_list(dev, cmd->chanlist_len, cmd->chanlist);
+ int chan = CR_CHAN(insn->chanspec);
- /* setup the common case and override if needed */
- if (cmd->chanlist_len > 1) {
- /*DPRINTK ("rtd520: Multi channel setup\n"); */
- RtdPacerStartSource(dev, 0); /* software triggers pacer */
- RtdBurstStartSource(dev, 1); /* PACER triggers burst */
- RtdAdcConversionSource(dev, 2); /* BURST triggers ADC */
- } else { /* single channel */
- /*DPRINTK ("rtd520: single channel setup\n"); */
- RtdPacerStartSource(dev, 0); /* software triggers pacer */
- RtdAdcConversionSource(dev, 1); /* PACER triggers ADC */
+ /* The input or output configuration of each digital line is
+ * configured by a special insn_config instruction. chanspec
+ * contains the channel to be changed, and data[0] contains the
+ * value COMEDI_INPUT or COMEDI_OUTPUT. */
+ switch (data[0]) {
+ case INSN_CONFIG_DIO_OUTPUT:
+ s->io_bits |= 1 << chan; /* 1 means Out */
+ break;
+ case INSN_CONFIG_DIO_INPUT:
+ s->io_bits &= ~(1 << chan);
+ break;
+ case INSN_CONFIG_DIO_QUERY:
+ data[1] =
+ (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
+ return insn->n;
+ break;
+ default:
+ return -EINVAL;
}
- RtdAboutCounter(dev, devpriv->fifoLen / 2 - 1); /* 1/2 FIFO */
- if (TRIG_TIMER == cmd->scan_begin_src) {
- /* scan_begin_arg is in nanoseconds */
- /* find out how many samples to wait before transferring */
- if (cmd->flags & TRIG_WAKE_EOS) {
- /* this may generate un-sustainable interrupt rates */
- /* the application is responsible for doing the right thing */
- devpriv->transCount = cmd->chanlist_len;
- devpriv->flags |= SEND_EOS;
- } else {
- /* arrange to transfer data periodically */
- devpriv->transCount
- =
- (TRANS_TARGET_PERIOD * cmd->chanlist_len) /
- cmd->scan_begin_arg;
- if (devpriv->transCount < cmd->chanlist_len) {
- /* transfer after each scan (and avoid 0) */
- devpriv->transCount = cmd->chanlist_len;
- } else { /* make a multiple of scan length */
- devpriv->transCount =
- (devpriv->transCount +
- cmd->chanlist_len - 1)
- / cmd->chanlist_len;
- devpriv->transCount *= cmd->chanlist_len;
- }
- devpriv->flags |= SEND_EOS;
- }
- if (devpriv->transCount >= (devpriv->fifoLen / 2)) {
- /* out of counter range, use 1/2 fifo instead */
- devpriv->transCount = 0;
- devpriv->flags &= ~SEND_EOS;
- } else {
- /* interrupt for each transfer */
- RtdAboutCounter(dev, devpriv->transCount - 1);
- }
+ DPRINTK("rtd520: port_0_direction=0x%x (1 means out)\n", s->io_bits);
+ /* TODO support digital match interrupts and strobes */
+ RtdDioStatusWrite(dev, 0x01); /* make Dio0Ctrl point to direction */
+ RtdDio0CtrlWrite(dev, s->io_bits); /* set direction 1 means Out */
+ RtdDioStatusWrite(dev, 0); /* make Dio0Ctrl clear interrupts */
- DPRINTK
- ("rtd520: scanLen=%d transferCount=%d fifoLen=%d\n scanTime(ns)=%d flags=0x%x\n",
- cmd->chanlist_len, devpriv->transCount, devpriv->fifoLen,
- cmd->scan_begin_arg, devpriv->flags);
- } else { /* unknown timing, just use 1/2 FIFO */
- devpriv->transCount = 0;
- devpriv->flags &= ~SEND_EOS;
- }
- RtdPacerClockSource(dev, 1); /* use INTERNAL 8Mhz clock source */
- RtdAboutStopEnable(dev, 1); /* just interrupt, dont stop */
+ /* port1 can only be all input or all output */
- /* BUG??? these look like enumerated values, but they are bit fields */
+ /* there are also 2 user input lines and 2 user output lines */
- /* First, setup when to stop */
- switch (cmd->stop_src) {
- case TRIG_COUNT: /* stop after N scans */
- devpriv->aiCount = cmd->stop_arg * cmd->chanlist_len;
- if ((devpriv->transCount > 0)
- && (devpriv->transCount > devpriv->aiCount)) {
- devpriv->transCount = devpriv->aiCount;
- }
- break;
+ return 1;
+}
- case TRIG_NONE: /* stop when cancel is called */
- devpriv->aiCount = -1; /* read forever */
- break;
+static int rtd_attach(struct comedi_device *dev, struct comedi_devconfig *it)
+{ /* board name and options flags */
+ struct comedi_subdevice *s;
+ struct pci_dev *pcidev;
+ int ret;
+ resource_size_t physLas0; /* configuration */
+ resource_size_t physLas1; /* data area */
+ resource_size_t physLcfg; /* PLX9080 */
+#ifdef USE_DMA
+ int index;
+#endif
- default:
- DPRINTK("rtd520: Warning! ignoring stop_src mode %d\n",
- cmd->stop_src);
- }
+ printk(KERN_INFO "comedi%d: rtd520 attaching.\n", dev->minor);
- /* Scan timing */
- switch (cmd->scan_begin_src) {
- case TRIG_TIMER: /* periodic scanning */
- timer = rtd_ns_to_timer(&cmd->scan_begin_arg,
- TRIG_ROUND_NEAREST);
- /* set PACER clock */
- /*DPRINTK ("rtd520: loading %d into pacer\n", timer); */
- RtdPacerCounter(dev, timer);
+#if defined(CONFIG_COMEDI_DEBUG) && defined(USE_DMA)
+ /* You can set this a load time: modprobe comedi comedi_debug=1 */
+ if (0 == comedi_debug) /* force DMA debug printks */
+ comedi_debug = 1;
+#endif
- break;
+ /*
+ * Allocate the private structure area. alloc_private() is a
+ * convenient macro defined in comedidev.h.
+ */
+ if (alloc_private(dev, sizeof(struct rtdPrivate)) < 0)
+ return -ENOMEM;
- case TRIG_EXT:
- RtdPacerStartSource(dev, 1); /* EXTERNALy trigger pacer */
- break;
+ /*
+ * Probe the device to determine what device in the series it is.
+ */
+ for (pcidev = pci_get_device(PCI_VENDOR_ID_RTD, PCI_ANY_ID, NULL);
+ pcidev != NULL;
+ pcidev = pci_get_device(PCI_VENDOR_ID_RTD, PCI_ANY_ID, pcidev)) {
+ int i;
- default:
- DPRINTK("rtd520: Warning! ignoring scan_begin_src mode %d\n",
- cmd->scan_begin_src);
+ if (it->options[0] || it->options[1]) {
+ if (pcidev->bus->number != it->options[0]
+ || PCI_SLOT(pcidev->devfn) != it->options[1]) {
+ continue;
+ }
+ }
+ for (i = 0; i < ARRAY_SIZE(rtd520Boards); ++i) {
+ if (pcidev->device == rtd520Boards[i].device_id) {
+ dev->board_ptr = &rtd520Boards[i];
+ break;
+ }
+ }
+ if (dev->board_ptr)
+ break; /* found one */
}
-
- /* Sample timing within a scan */
- switch (cmd->convert_src) {
- case TRIG_TIMER: /* periodic */
- if (cmd->chanlist_len > 1) { /* only needed for multi-channel */
- timer = rtd_ns_to_timer(&cmd->convert_arg,
- TRIG_ROUND_NEAREST);
- /* setup BURST clock */
- /*DPRINTK ("rtd520: loading %d into burst\n", timer); */
- RtdBurstCounter(dev, timer);
+ if (!pcidev) {
+ if (it->options[0] && it->options[1]) {
+ printk(KERN_INFO "No RTD card at bus=%d slot=%d.\n",
+ it->options[0], it->options[1]);
+ } else {
+ printk(KERN_INFO "No RTD card found.\n");
}
-
- break;
-
- case TRIG_EXT: /* external */
- RtdBurstStartSource(dev, 2); /* EXTERNALy trigger burst */
- break;
-
- default:
- DPRINTK("rtd520: Warning! ignoring convert_src mode %d\n",
- cmd->convert_src);
+ return -EIO;
}
- /* end configuration */
+ devpriv->pci_dev = pcidev;
+ dev->board_name = thisboard->name;
- /* This doesn't seem to work. There is no way to clear an interrupt
- that the priority controller has queued! */
- RtdInterruptClearMask(dev, ~0); /* clear any existing flags */
- RtdInterruptClear(dev);
+ ret = comedi_pci_enable(pcidev, DRV_NAME);
+ if (ret < 0) {
+ printk(KERN_INFO "Failed to enable PCI device and request regions.\n");
+ return ret;
+ }
+ devpriv->got_regions = 1;
- /* TODO: allow multiple interrupt sources */
- if (devpriv->transCount > 0) { /* transfer every N samples */
- RtdInterruptMask(dev, IRQM_ADC_ABOUT_CNT);
- DPRINTK("rtd520: Transferring every %d\n", devpriv->transCount);
- } else { /* 1/2 FIFO transfers */
-#ifdef USE_DMA
- devpriv->flags |= DMA0_ACTIVE;
+ /*
+ * Initialize base addresses
+ */
+ /* Get the physical address from PCI config */
+ physLas0 = pci_resource_start(devpriv->pci_dev, LAS0_PCIINDEX);
+ physLas1 = pci_resource_start(devpriv->pci_dev, LAS1_PCIINDEX);
+ physLcfg = pci_resource_start(devpriv->pci_dev, LCFG_PCIINDEX);
+ /* Now have the kernel map this into memory */
+ /* ASSUME page aligned */
+ devpriv->las0 = ioremap_nocache(physLas0, LAS0_PCISIZE);
+ devpriv->las1 = ioremap_nocache(physLas1, LAS1_PCISIZE);
+ devpriv->lcfg = ioremap_nocache(physLcfg, LCFG_PCISIZE);
- /* point to first transfer in ring */
- devpriv->dma0Offset = 0;
- RtdDma0Mode(dev, DMA_MODE_BITS);
- RtdDma0Next(dev, /* point to first block */
- devpriv->dma0Chain[DMA_CHAIN_COUNT - 1].next);
- RtdDma0Source(dev, DMAS_ADFIFO_HALF_FULL); /* set DMA trigger source */
+ if (!devpriv->las0 || !devpriv->las1 || !devpriv->lcfg)
+ return -ENOMEM;
- RtdPlxInterruptWrite(dev, /* enable interrupt */
- RtdPlxInterruptRead(dev) | ICS_DMA0_E);
- /* Must be 2 steps. See PLX app note about "Starting a DMA transfer" */
- RtdDma0Control(dev, PLX_DMA_EN_BIT); /* enable DMA (clear INTR?) */
- RtdDma0Control(dev, PLX_DMA_EN_BIT | PLX_DMA_START_BIT); /*start DMA */
- DPRINTK("rtd520: Using DMA0 transfers. plxInt %x RtdInt %x\n",
- RtdPlxInterruptRead(dev), devpriv->intMask);
-#else /* USE_DMA */
- RtdInterruptMask(dev, IRQM_ADC_ABOUT_CNT);
- DPRINTK("rtd520: Transferring every 1/2 FIFO\n");
-#endif /* USE_DMA */
- }
- /* BUG: start_src is ASSUMED to be TRIG_NOW */
- /* BUG? it seems like things are running before the "start" */
- RtdPacerStart(dev); /* Start PACER */
- return 0;
-}
+ DPRINTK("%s: LAS0=%llx, LAS1=%llx, CFG=%llx.\n", dev->board_name,
+ (unsigned long long)physLas0, (unsigned long long)physLas1,
+ (unsigned long long)physLcfg);
+ { /* The RTD driver does this */
+ unsigned char pci_latency;
+ u16 revision;
+ /*uint32_t epld_version; */
-/*
- Stop a running data acquisition.
-*/
-static int rtd_ai_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
-{
- u16 status;
+ pci_read_config_word(devpriv->pci_dev, PCI_REVISION_ID,
+ &revision);
+ DPRINTK("%s: PCI revision %d.\n", dev->board_name, revision);
- RtdPacerStopSource(dev, 0); /* stop on SOFTWARE stop */
- RtdPacerStop(dev); /* Stop PACER */
- RtdAdcConversionSource(dev, 0); /* software trigger only */
- RtdInterruptMask(dev, 0);
- devpriv->aiCount = 0; /* stop and don't transfer any more */
-#ifdef USE_DMA
- if (devpriv->flags & DMA0_ACTIVE) {
- RtdPlxInterruptWrite(dev, /* disable any more interrupts */
- RtdPlxInterruptRead(dev) & ~ICS_DMA0_E);
- abort_dma(dev, 0);
- devpriv->flags &= ~DMA0_ACTIVE;
+ pci_read_config_byte(devpriv->pci_dev,
+ PCI_LATENCY_TIMER, &pci_latency);
+ if (pci_latency < 32) {
+ printk(KERN_INFO "%s: PCI latency changed from %d to %d\n",
+ dev->board_name, pci_latency, 32);
+ pci_write_config_byte(devpriv->pci_dev,
+ PCI_LATENCY_TIMER, 32);
+ } else {
+ DPRINTK("rtd520: PCI latency = %d\n", pci_latency);
+ }
+
+ /*
+ * Undocumented EPLD version (doesn't match RTD driver results)
+ */
+ /*DPRINTK ("rtd520: Reading epld from %p\n",
+ devpriv->las0+0);
+ epld_version = readl (devpriv->las0+0);
+ if ((epld_version & 0xF0) >> 4 == 0x0F) {
+ DPRINTK("rtd520: pre-v8 EPLD. (%x)\n", epld_version);
+ } else {
+ DPRINTK("rtd520: EPLD version %x.\n", epld_version >> 4);
+ } */
}
-#endif /* USE_DMA */
- status = RtdInterruptStatus(dev);
- DPRINTK
- ("rtd520: Acquisition canceled. %ld ints, intStat=%x, overStat=%x\n",
- devpriv->intCount, status,
- 0xffff & RtdInterruptOverrunStatus(dev));
- return 0;
-}
-/*
- Given a desired period and the clock period (both in ns),
- return the proper counter value (divider-1).
- Sets the original period to be the true value.
- Note: you have to check if the value is larger than the counter range!
-*/
-static int rtd_ns_to_timer_base(unsigned int *nanosec, /* desired period (in ns) */
- int round_mode, int base)
-{ /* clock period (in ns) */
- int divider;
+ /* Show board configuration */
+ printk(KERN_INFO "%s:", dev->board_name);
- switch (round_mode) {
- case TRIG_ROUND_NEAREST:
- default:
- divider = (*nanosec + base / 2) / base;
- break;
- case TRIG_ROUND_DOWN:
- divider = (*nanosec) / base;
- break;
- case TRIG_ROUND_UP:
- divider = (*nanosec + base - 1) / base;
- break;
- }
- if (divider < 2)
- divider = 2; /* min is divide by 2 */
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
+ return ret;
- /* Note: we don't check for max, because different timers
- have different ranges */
+ s = dev->subdevices + 0;
+ dev->read_subdev = s;
+ /* analog input subdevice */
+ s->type = COMEDI_SUBD_AI;
+ s->subdev_flags =
+ SDF_READABLE | SDF_GROUND | SDF_COMMON | SDF_DIFF | SDF_CMD_READ;
+ s->n_chan = thisboard->aiChans;
+ s->maxdata = (1 << thisboard->aiBits) - 1;
+ if (thisboard->aiMaxGain <= 32)
+ s->range_table = &rtd_ai_7520_range;
+ else
+ s->range_table = &rtd_ai_4520_range;
- *nanosec = base * divider;
- return divider - 1; /* countdown is divisor+1 */
-}
+ s->len_chanlist = RTD_MAX_CHANLIST; /* devpriv->fifoLen */
+ s->insn_read = rtd_ai_rinsn;
+ s->do_cmd = rtd_ai_cmd;
+ s->do_cmdtest = rtd_ai_cmdtest;
+ s->cancel = rtd_ai_cancel;
+ /* s->poll = rtd_ai_poll; *//* not ready yet */
-/*
- Given a desired period (in ns),
- return the proper counter value (divider-1) for the internal clock.
- Sets the original period to be the true value.
-*/
-static int rtd_ns_to_timer(unsigned int *ns, int round_mode)
-{
- return rtd_ns_to_timer_base(ns, round_mode, RTD_CLOCK_BASE);
-}
+ s = dev->subdevices + 1;
+ /* analog output subdevice */
+ s->type = COMEDI_SUBD_AO;
+ s->subdev_flags = SDF_WRITABLE;
+ s->n_chan = 2;
+ s->maxdata = (1 << thisboard->aiBits) - 1;
+ s->range_table = &rtd_ao_range;
+ s->insn_write = rtd_ao_winsn;
+ s->insn_read = rtd_ao_rinsn;
-/*
- Output one (or more) analog values to a single port as fast as possible.
-*/
-static int rtd_ao_winsn(struct comedi_device *dev,
- struct comedi_subdevice *s, struct comedi_insn *insn,
- unsigned int *data)
-{
- int i;
- int chan = CR_CHAN(insn->chanspec);
- int range = CR_RANGE(insn->chanspec);
+ s = dev->subdevices + 2;
+ /* digital i/o subdevice */
+ s->type = COMEDI_SUBD_DIO;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ /* we only support port 0 right now. Ignoring port 1 and user IO */
+ s->n_chan = 8;
+ s->maxdata = 1;
+ s->range_table = &range_digital;
+ s->insn_bits = rtd_dio_insn_bits;
+ s->insn_config = rtd_dio_insn_config;
- /* Configure the output range (table index matches the range values) */
- RtdDacRange(dev, chan, range);
+ /* timer/counter subdevices (not currently supported) */
+ s = dev->subdevices + 3;
+ s->type = COMEDI_SUBD_COUNTER;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ s->n_chan = 3;
+ s->maxdata = 0xffff;
- /* Writing a list of values to an AO channel is probably not
- * very useful, but that's how the interface is defined. */
- for (i = 0; i < insn->n; ++i) {
- int val = data[i] << 3;
- int stat = 0; /* initialize to avoid bogus warning */
- int ii;
+ /* initialize board, per RTD spec */
+ /* also, initialize shadow registers */
+ RtdResetBoard(dev);
+ udelay(100); /* needed? */
+ RtdPlxInterruptWrite(dev, 0);
+ RtdInterruptMask(dev, 0); /* and sets shadow */
+ RtdInterruptClearMask(dev, ~0); /* and sets shadow */
+ RtdInterruptClear(dev); /* clears bits set by mask */
+ RtdInterruptOverrunClear(dev);
+ RtdClearCGT(dev);
+ RtdAdcClearFifo(dev);
+ RtdDacClearFifo(dev, 0);
+ RtdDacClearFifo(dev, 1);
+ /* clear digital IO fifo */
+ RtdDioStatusWrite(dev, 0); /* safe state, set shadow */
+ RtdUtcCtrlPut(dev, 0, 0x30); /* safe state, set shadow */
+ RtdUtcCtrlPut(dev, 1, 0x30); /* safe state, set shadow */
+ RtdUtcCtrlPut(dev, 2, 0x30); /* safe state, set shadow */
+ RtdUtcCtrlPut(dev, 3, 0); /* safe state, set shadow */
+ /* TODO: set user out source ??? */
- /* VERIFY: comedi range and offset conversions */
+ /* check if our interrupt is available and get it */
+ ret = request_irq(devpriv->pci_dev->irq, rtd_interrupt,
+ IRQF_SHARED, DRV_NAME, dev);
- if ((range > 1) /* bipolar */
- && (data[i] < 2048)) {
- /* offset and sign extend */
- val = (((int)data[i]) - 2048) << 3;
- } else { /* unipolor */
- val = data[i] << 3;
- }
+ if (ret < 0) {
+ printk("Could not get interrupt! (%u)\n",
+ devpriv->pci_dev->irq);
+ return ret;
+ }
+ dev->irq = devpriv->pci_dev->irq;
+ printk(KERN_INFO "( irq=%u )", dev->irq);
- DPRINTK
- ("comedi: rtd520 DAC chan=%d range=%d writing %d as 0x%x\n",
- chan, range, data[i], val);
+ ret = rtd520_probe_fifo_depth(dev);
+ if (ret < 0)
+ return ret;
- /* a typical programming sequence */
- RtdDacFifoPut(dev, chan, val); /* put the value in */
- RtdDacUpdate(dev, chan); /* trigger the conversion */
+ devpriv->fifoLen = ret;
+ printk("( fifoLen=%d )", devpriv->fifoLen);
- devpriv->aoValue[chan] = data[i]; /* save for read back */
+#ifdef USE_DMA
+ if (dev->irq > 0) {
+ printk("( DMA buff=%d )\n", DMA_CHAIN_COUNT);
+ /*
+ * The PLX9080 has 2 DMA controllers, but there could be
+ * 4 sources: ADC, digital, DAC1, and DAC2. Since only the
+ * ADC supports cmd mode right now, this isn't an issue (yet)
+ */
+ devpriv->dma0Offset = 0;
- for (ii = 0; ii < RTD_DAC_TIMEOUT; ++ii) {
- stat = RtdFifoStatus(dev);
- /* 1 -> not empty */
- if (stat & ((0 == chan) ? FS_DAC1_NOT_EMPTY :
- FS_DAC2_NOT_EMPTY))
- break;
- WAIT_QUIETLY;
+ for (index = 0; index < DMA_CHAIN_COUNT; index++) {
+ devpriv->dma0Buff[index] =
+ pci_alloc_consistent(devpriv->pci_dev,
+ sizeof(u16) *
+ devpriv->fifoLen / 2,
+ &devpriv->
+ dma0BuffPhysAddr[index]);
+ if (devpriv->dma0Buff[index] == NULL) {
+ ret = -ENOMEM;
+ goto rtd_attach_die_error;
+ }
+ /*DPRINTK ("buff[%d] @ %p virtual, %x PCI\n",
+ index,
+ devpriv->dma0Buff[index],
+ devpriv->dma0BuffPhysAddr[index]); */
}
- if (ii >= RTD_DAC_TIMEOUT) {
- DPRINTK
- ("rtd520: Error: DAC never finished! FifoStatus=0x%x\n",
- stat ^ 0x6666);
- return -ETIMEDOUT;
+
+ /*
+ * setup DMA descriptor ring (use cpu_to_le32 for byte
+ * ordering?)
+ */
+ devpriv->dma0Chain =
+ pci_alloc_consistent(devpriv->pci_dev,
+ sizeof(struct plx_dma_desc) *
+ DMA_CHAIN_COUNT,
+ &devpriv->dma0ChainPhysAddr);
+ for (index = 0; index < DMA_CHAIN_COUNT; index++) {
+ devpriv->dma0Chain[index].pci_start_addr =
+ devpriv->dma0BuffPhysAddr[index];
+ devpriv->dma0Chain[index].local_start_addr =
+ DMALADDR_ADC;
+ devpriv->dma0Chain[index].transfer_size =
+ sizeof(u16) * devpriv->fifoLen / 2;
+ devpriv->dma0Chain[index].next =
+ (devpriv->dma0ChainPhysAddr + ((index +
+ 1) %
+ (DMA_CHAIN_COUNT))
+ * sizeof(devpriv->dma0Chain[0]))
+ | DMA_TRANSFER_BITS;
+ /*DPRINTK ("ring[%d] @%lx PCI: %x, local: %x, N: 0x%x, next: %x\n",
+ index,
+ ((long)devpriv->dma0ChainPhysAddr
+ + (index * sizeof(devpriv->dma0Chain[0]))),
+ devpriv->dma0Chain[index].pci_start_addr,
+ devpriv->dma0Chain[index].local_start_addr,
+ devpriv->dma0Chain[index].transfer_size,
+ devpriv->dma0Chain[index].next); */
}
- }
- /* return the number of samples read/written */
- return i;
-}
+ if (devpriv->dma0Chain == NULL) {
+ ret = -ENOMEM;
+ goto rtd_attach_die_error;
+ }
-/* AO subdevices should have a read insn as well as a write insn.
- * Usually this means copying a value stored in devpriv. */
-static int rtd_ao_rinsn(struct comedi_device *dev,
- struct comedi_subdevice *s, struct comedi_insn *insn,
- unsigned int *data)
-{
- int i;
- int chan = CR_CHAN(insn->chanspec);
+ RtdDma0Mode(dev, DMA_MODE_BITS);
+ /* set DMA trigger source */
+ RtdDma0Source(dev, DMAS_ADFIFO_HALF_FULL);
+ } else {
+ printk(KERN_INFO "( no IRQ->no DMA )");
+ }
+#endif /* USE_DMA */
- for (i = 0; i < insn->n; i++)
- data[i] = devpriv->aoValue[chan];
+ if (dev->irq) { /* enable plx9080 interrupts */
+ RtdPlxInterruptWrite(dev, ICS_PIE | ICS_PLIE);
+ }
+ printk("\ncomedi%d: rtd520 driver attached.\n", dev->minor);
- return i;
-}
+ return 1;
-/*
- Write a masked set of bits and the read back the port.
- We track what the bits should be (i.e. we don't read the port first).
+#if 0
+ /* hit an error, clean up memory and return ret */
+/* rtd_attach_die_error: */
+#ifdef USE_DMA
+ for (index = 0; index < DMA_CHAIN_COUNT; index++) {
+ if (NULL != devpriv->dma0Buff[index]) { /* free buffer memory */
+ pci_free_consistent(devpriv->pci_dev,
+ sizeof(u16) * devpriv->fifoLen / 2,
+ devpriv->dma0Buff[index],
+ devpriv->dma0BuffPhysAddr[index]);
+ devpriv->dma0Buff[index] = NULL;
+ }
+ }
+ if (NULL != devpriv->dma0Chain) {
+ pci_free_consistent(devpriv->pci_dev,
+ sizeof(struct plx_dma_desc)
+ * DMA_CHAIN_COUNT,
+ devpriv->dma0Chain,
+ devpriv->dma0ChainPhysAddr);
+ devpriv->dma0Chain = NULL;
+ }
+#endif /* USE_DMA */
+ /* subdevices and priv are freed by the core */
+ if (dev->irq) {
+ /* disable interrupt controller */
+ RtdPlxInterruptWrite(dev, RtdPlxInterruptRead(dev)
+ & ~(ICS_PLIE | ICS_DMA0_E | ICS_DMA1_E));
+ free_irq(dev->irq, dev);
+ }
- DIO devices are slightly special. Although it is possible to
- * implement the insn_read/insn_write interface, it is much more
- * useful to applications if you implement the insn_bits interface.
- * This allows packed reading/writing of the DIO channels. The
- * comedi core can convert between insn_bits and insn_read/write
- */
-static int rtd_dio_insn_bits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data)
-{
- if (insn->n != 2)
- return -EINVAL;
+ /* release all regions that were allocated */
+ if (devpriv->las0)
+ iounmap(devpriv->las0);
- /* The insn data is a mask in data[0] and the new data
- * in data[1], each channel cooresponding to a bit. */
- if (data[0]) {
- s->state &= ~data[0];
- s->state |= data[0] & data[1];
+ if (devpriv->las1)
+ iounmap(devpriv->las1);
- /* Write out the new digital output lines */
- RtdDio0Write(dev, s->state);
- }
- /* on return, data[1] contains the value of the digital
- * input lines. */
- data[1] = RtdDio0Read(dev);
+ if (devpriv->lcfg)
+ iounmap(devpriv->lcfg);
- /*DPRINTK("rtd520:port_0 wrote: 0x%x read: 0x%x\n", s->state, data[1]); */
+ if (devpriv->pci_dev)
+ pci_dev_put(devpriv->pci_dev);
- return 2;
+ return ret;
+#endif
}
-/*
- Configure one bit on a IO port as Input or Output (hence the name :-).
-*/
-static int rtd_dio_insn_config(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data)
+static void rtd_detach(struct comedi_device *dev)
{
- int chan = CR_CHAN(insn->chanspec);
+#ifdef USE_DMA
+ int index;
+#endif
- /* The input or output configuration of each digital line is
- * configured by a special insn_config instruction. chanspec
- * contains the channel to be changed, and data[0] contains the
- * value COMEDI_INPUT or COMEDI_OUTPUT. */
- switch (data[0]) {
- case INSN_CONFIG_DIO_OUTPUT:
- s->io_bits |= 1 << chan; /* 1 means Out */
- break;
- case INSN_CONFIG_DIO_INPUT:
- s->io_bits &= ~(1 << chan);
- break;
- case INSN_CONFIG_DIO_QUERY:
- data[1] =
- (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
- return insn->n;
- break;
- default:
- return -EINVAL;
+ if (devpriv) {
+ /* Shut down any board ops by resetting it */
+#ifdef USE_DMA
+ if (devpriv->lcfg) {
+ RtdDma0Control(dev, 0); /* disable DMA */
+ RtdDma1Control(dev, 0); /* disable DMA */
+ RtdPlxInterruptWrite(dev, ICS_PIE | ICS_PLIE);
+ }
+#endif /* USE_DMA */
+ if (devpriv->las0) {
+ RtdResetBoard(dev);
+ RtdInterruptMask(dev, 0);
+ RtdInterruptClearMask(dev, ~0);
+ RtdInterruptClear(dev); /* clears bits set by mask */
+ }
+#ifdef USE_DMA
+ /* release DMA */
+ for (index = 0; index < DMA_CHAIN_COUNT; index++) {
+ if (NULL != devpriv->dma0Buff[index]) {
+ pci_free_consistent(devpriv->pci_dev,
+ sizeof(u16) *
+ devpriv->fifoLen / 2,
+ devpriv->dma0Buff[index],
+ devpriv->
+ dma0BuffPhysAddr[index]);
+ devpriv->dma0Buff[index] = NULL;
+ }
+ }
+ if (NULL != devpriv->dma0Chain) {
+ pci_free_consistent(devpriv->pci_dev,
+ sizeof(struct plx_dma_desc) *
+ DMA_CHAIN_COUNT, devpriv->dma0Chain,
+ devpriv->dma0ChainPhysAddr);
+ devpriv->dma0Chain = NULL;
+ }
+#endif /* USE_DMA */
+ if (dev->irq) {
+ RtdPlxInterruptWrite(dev, RtdPlxInterruptRead(dev)
+ & ~(ICS_PLIE | ICS_DMA0_E |
+ ICS_DMA1_E));
+ free_irq(dev->irq, dev);
+ }
+ if (devpriv->las0)
+ iounmap(devpriv->las0);
+ if (devpriv->las1)
+ iounmap(devpriv->las1);
+ if (devpriv->lcfg)
+ iounmap(devpriv->lcfg);
+ if (devpriv->pci_dev) {
+ if (devpriv->got_regions)
+ comedi_pci_disable(devpriv->pci_dev);
+ pci_dev_put(devpriv->pci_dev);
+ }
}
-
- DPRINTK("rtd520: port_0_direction=0x%x (1 means out)\n", s->io_bits);
- /* TODO support digital match interrupts and strobes */
- RtdDioStatusWrite(dev, 0x01); /* make Dio0Ctrl point to direction */
- RtdDio0CtrlWrite(dev, s->io_bits); /* set direction 1 means Out */
- RtdDioStatusWrite(dev, 0); /* make Dio0Ctrl clear interrupts */
-
- /* port1 can only be all input or all output */
-
- /* there are also 2 user input lines and 2 user output lines */
-
- return 1;
}
static struct comedi_driver rtd520_driver = {
int has_ao;
};
-#define this_board ((const struct rti800_board *)dev->board_ptr)
-
static irqreturn_t rti800_interrupt(int irq, void *dev);
struct rti800_private {
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
data[1] = inb(dev->iobase + RTI800_DI);
- return 2;
+ return insn->n;
}
static int rti800_do_insn_bits(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
if (data[0]) {
s->state &= ~data[0];
s->state |= data[0] & data[1];
data[1] = s->state;
- return 2;
+ return insn->n;
}
/*
static int rti800_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct rti800_board *board = comedi_board(dev);
unsigned int irq;
unsigned long iobase;
int ret;
printk(KERN_INFO "( no irq )\n");
}
- dev->board_name = this_board->name;
+ dev->board_name = board->name;
- ret = alloc_subdevices(dev, 4);
- if (ret < 0)
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
return ret;
ret = alloc_private(dev, sizeof(struct rti800_private));
}
s++;
- if (this_board->has_ao) {
+ if (board->has_ao) {
/* ao subdevice (only on rti815) */
s->type = COMEDI_SUBD_AO;
s->subdev_flags = SDF_WRITABLE;
struct comedi_subdevice *s;
int i;
unsigned long iobase;
+ int ret;
iobase = it->options[0];
printk(KERN_INFO "comedi%d: rti802: 0x%04lx ", dev->minor, iobase);
dev->board_name = "rti802";
- if (alloc_subdevices(dev, 1) < 0
- || alloc_private(dev, sizeof(struct rti802_private))) {
+ if (alloc_private(dev, sizeof(struct rti802_private)))
return -ENOMEM;
- }
+
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
s = dev->subdevices;
/* ao subdevice */
#define ADDR_REG(reg) (dev->iobase + (reg))
#define ADDR_CHAN_REG(reg, chan) (dev->iobase + (reg) + (chan) * 8)
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((const struct s526_board *)dev->board_ptr)
-
/* this structure is for data unique to this hardware driver. If
several hardware drivers keep similar information in this structure,
feel free to suggest moving the variable to the struct comedi_device
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
/* The insn data is a mask in data[0] and the new data
* in data[1], each channel cooresponding to a bit. */
if (data[0]) {
* it was a purely digital output subdevice */
/* data[1]=s->state & 0xFF; */
- return 2;
+ return insn->n;
}
static int s526_dio_insn_config(struct comedi_device *dev,
static int s526_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct s526_board *board = comedi_board(dev);
struct comedi_subdevice *s;
int iobase;
int i, n;
+ int ret;
/* short value; */
/* int subdev_channel = 0; */
union cmReg cmReg;
printk(KERN_INFO "comedi%d: s526: ", dev->minor);
iobase = it->options[0];
- if (!iobase || !request_region(iobase, S526_IOSIZE, thisboard->name)) {
+ if (!iobase || !request_region(iobase, S526_IOSIZE, board->name)) {
comedi_error(dev, "I/O port conflict");
return -EIO;
}
}
***/
-/*
- * Initialize dev->board_name. Note that we can use the "thisboard"
- * macro now, since we just initialized it in the last line.
- */
- dev->board_ptr = &s526_boards[0];
-
- dev->board_name = thisboard->name;
+ dev->board_name = board->name;
/*
* Allocate the private structure area. alloc_private() is a
if (alloc_private(dev, sizeof(struct s526_private)) < 0)
return -ENOMEM;
-/*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- dev->n_subdevices = 4;
- if (alloc_subdevices(dev, dev->n_subdevices) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 4);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* GENERAL-PURPOSE COUNTER/TIME (GPCT) */
s->type = COMEDI_SUBD_COUNTER;
s->subdev_flags = SDF_READABLE | SDF_WRITABLE | SDF_LSAMPL;
/* KG: What does SDF_LSAMPL (see multiq3.c) mean? */
- s->n_chan = thisboard->gpct_chans;
+ s->n_chan = board->gpct_chans;
s->maxdata = 0x00ffffff; /* 24 bit counter */
s->insn_read = s526_gpct_rinsn;
s->insn_config = s526_gpct_insn_config;
s = dev->subdevices + 3;
/* digital i/o subdevice */
- if (thisboard->have_dio) {
+ if (board->have_dio) {
s->type = COMEDI_SUBD_DIO;
s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
s->n_chan = 8;
#include "../comedidev.h"
-#include "comedi_pci.h"
-
#include "comedi_fc.h"
#include "s626.h"
struct s626_private {
struct pci_dev *pdev;
- void *base_addr;
+ void __iomem *base_addr;
int got_regions;
short allocatedBuf;
uint8_t ai_cmd_running; /* ai_cmd is running */
#define devpriv ((struct s626_private *)dev->private)
#define diopriv ((struct dio_private *)s->private)
-/* ioctl routines */
-static int s626_ai_insn_config(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-/* static int s626_ai_rinsn(struct comedi_device *dev,struct comedi_subdevice *s,struct comedi_insn *insn,unsigned int *data); */
-static int s626_ai_insn_read(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int s626_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
-static int s626_ai_cmdtest(struct comedi_device *dev,
- struct comedi_subdevice *s, struct comedi_cmd *cmd);
-static int s626_ai_cancel(struct comedi_device *dev,
- struct comedi_subdevice *s);
-static int s626_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int s626_ao_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int s626_dio_insn_bits(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int s626_dio_insn_config(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int s626_dio_set_irq(struct comedi_device *dev, unsigned int chan);
-static int s626_dio_reset_irq(struct comedi_device *dev, unsigned int gruop,
- unsigned int mask);
-static int s626_dio_clear_irq(struct comedi_device *dev);
-static int s626_enc_insn_config(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int s626_enc_insn_read(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int s626_enc_insn_write(struct comedi_device *dev,
- struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-static int s626_ns_to_timer(int *nanosec, int round_mode);
-static int s626_ai_load_polllist(uint8_t *ppl, struct comedi_cmd *cmd);
-static int s626_ai_inttrig(struct comedi_device *dev,
- struct comedi_subdevice *s, unsigned int trignum);
-static irqreturn_t s626_irq_handler(int irq, void *d);
-static unsigned int s626_ai_reg_to_uint(int data);
-/* static unsigned int s626_uint_to_reg(struct comedi_subdevice *s, int data); */
-
-/* end ioctl routines */
-
-/* internal routines */
-static void s626_dio_init(struct comedi_device *dev);
-static void ResetADC(struct comedi_device *dev, uint8_t * ppl);
-static void LoadTrimDACs(struct comedi_device *dev);
-static void WriteTrimDAC(struct comedi_device *dev, uint8_t LogicalChan,
- uint8_t DacData);
-static uint8_t I2Cread(struct comedi_device *dev, uint8_t addr);
-static uint32_t I2Chandshake(struct comedi_device *dev, uint32_t val);
-static void SetDAC(struct comedi_device *dev, uint16_t chan, short dacdata);
-static void SendDAC(struct comedi_device *dev, uint32_t val);
-static void WriteMISC2(struct comedi_device *dev, uint16_t NewImage);
-static void DEBItransfer(struct comedi_device *dev);
-static uint16_t DEBIread(struct comedi_device *dev, uint16_t addr);
-static void DEBIwrite(struct comedi_device *dev, uint16_t addr, uint16_t wdata);
-static void DEBIreplace(struct comedi_device *dev, uint16_t addr, uint16_t mask,
- uint16_t wdata);
-static void CloseDMAB(struct comedi_device *dev, struct bufferDMA *pdma,
- size_t bsize);
-
/* COUNTER OBJECT ------------------------------------------------ */
struct enc_private {
/* Pointers to functions that differ for A and B counters: */
#define encpriv ((struct enc_private *)(dev->subdevices+5)->private)
-/* counters routines */
-static void s626_timer_load(struct comedi_device *dev, struct enc_private *k,
- int tick);
-static uint32_t ReadLatch(struct comedi_device *dev, struct enc_private *k);
-static void ResetCapFlags_A(struct comedi_device *dev, struct enc_private *k);
-static void ResetCapFlags_B(struct comedi_device *dev, struct enc_private *k);
-static uint16_t GetMode_A(struct comedi_device *dev, struct enc_private *k);
-static uint16_t GetMode_B(struct comedi_device *dev, struct enc_private *k);
-static void SetMode_A(struct comedi_device *dev, struct enc_private *k,
- uint16_t Setup, uint16_t DisableIntSrc);
-static void SetMode_B(struct comedi_device *dev, struct enc_private *k,
- uint16_t Setup, uint16_t DisableIntSrc);
-static void SetEnable_A(struct comedi_device *dev, struct enc_private *k,
- uint16_t enab);
-static void SetEnable_B(struct comedi_device *dev, struct enc_private *k,
- uint16_t enab);
-static uint16_t GetEnable_A(struct comedi_device *dev, struct enc_private *k);
-static uint16_t GetEnable_B(struct comedi_device *dev, struct enc_private *k);
-static void SetLatchSource(struct comedi_device *dev, struct enc_private *k,
- uint16_t value);
-/* static uint16_t GetLatchSource(struct comedi_device *dev, struct enc_private *k ); */
-static void SetLoadTrig_A(struct comedi_device *dev, struct enc_private *k,
- uint16_t Trig);
-static void SetLoadTrig_B(struct comedi_device *dev, struct enc_private *k,
- uint16_t Trig);
-static uint16_t GetLoadTrig_A(struct comedi_device *dev, struct enc_private *k);
-static uint16_t GetLoadTrig_B(struct comedi_device *dev, struct enc_private *k);
-static void SetIntSrc_B(struct comedi_device *dev, struct enc_private *k,
- uint16_t IntSource);
-static void SetIntSrc_A(struct comedi_device *dev, struct enc_private *k,
- uint16_t IntSource);
-static uint16_t GetIntSrc_A(struct comedi_device *dev, struct enc_private *k);
-static uint16_t GetIntSrc_B(struct comedi_device *dev, struct enc_private *k);
-/* static void SetClkMult(struct comedi_device *dev, struct enc_private *k, uint16_t value ) ; */
-/* static uint16_t GetClkMult(struct comedi_device *dev, struct enc_private *k ) ; */
-/* static void SetIndexPol(struct comedi_device *dev, struct enc_private *k, uint16_t value ); */
-/* static uint16_t GetClkPol(struct comedi_device *dev, struct enc_private *k ) ; */
-/* static void SetIndexSrc( struct comedi_device *dev,struct enc_private *k, uint16_t value ); */
-/* static uint16_t GetClkSrc( struct comedi_device *dev,struct enc_private *k ); */
-/* static void SetIndexSrc( struct comedi_device *dev,struct enc_private *k, uint16_t value ); */
-/* static uint16_t GetIndexSrc( struct comedi_device *dev,struct enc_private *k ); */
-static void PulseIndex_A(struct comedi_device *dev, struct enc_private *k);
-static void PulseIndex_B(struct comedi_device *dev, struct enc_private *k);
-static void Preload(struct comedi_device *dev, struct enc_private *k,
- uint32_t value);
-static void CountersInit(struct comedi_device *dev);
-/* end internal routines */
-
-/* Counter objects constructor. */
-
/* Counter overflow/index event flag masks for RDMISC2. */
#define INDXMASK(C) (1 << (((C) > 2) ? ((C) * 2 - 1) : ((C) * 2 + 4)))
#define OVERMASK(C) (1 << (((C) > 2) ? ((C) * 2 + 5) : ((C) * 2 + 10)))
/* Translation table to map IntSrc into equivalent RDMISC2 event flag bits. */
/* static const uint16_t EventBits[][4] = { EVBITS(0), EVBITS(1), EVBITS(2), EVBITS(3), EVBITS(4), EVBITS(5) }; */
-/* struct enc_private; */
-static struct enc_private enc_private_data[] = {
- {
- .GetEnable = GetEnable_A,
- .GetIntSrc = GetIntSrc_A,
- .GetLoadTrig = GetLoadTrig_A,
- .GetMode = GetMode_A,
- .PulseIndex = PulseIndex_A,
- .SetEnable = SetEnable_A,
- .SetIntSrc = SetIntSrc_A,
- .SetLoadTrig = SetLoadTrig_A,
- .SetMode = SetMode_A,
- .ResetCapFlags = ResetCapFlags_A,
- .MyCRA = LP_CR0A,
- .MyCRB = LP_CR0B,
- .MyLatchLsw = LP_CNTR0ALSW,
- .MyEventBits = EVBITS(0),
- },
- {
- .GetEnable = GetEnable_A,
- .GetIntSrc = GetIntSrc_A,
- .GetLoadTrig = GetLoadTrig_A,
- .GetMode = GetMode_A,
- .PulseIndex = PulseIndex_A,
- .SetEnable = SetEnable_A,
- .SetIntSrc = SetIntSrc_A,
- .SetLoadTrig = SetLoadTrig_A,
- .SetMode = SetMode_A,
- .ResetCapFlags = ResetCapFlags_A,
- .MyCRA = LP_CR1A,
- .MyCRB = LP_CR1B,
- .MyLatchLsw = LP_CNTR1ALSW,
- .MyEventBits = EVBITS(1),
- },
- {
- .GetEnable = GetEnable_A,
- .GetIntSrc = GetIntSrc_A,
- .GetLoadTrig = GetLoadTrig_A,
- .GetMode = GetMode_A,
- .PulseIndex = PulseIndex_A,
- .SetEnable = SetEnable_A,
- .SetIntSrc = SetIntSrc_A,
- .SetLoadTrig = SetLoadTrig_A,
- .SetMode = SetMode_A,
- .ResetCapFlags = ResetCapFlags_A,
- .MyCRA = LP_CR2A,
- .MyCRB = LP_CR2B,
- .MyLatchLsw = LP_CNTR2ALSW,
- .MyEventBits = EVBITS(2),
- },
- {
- .GetEnable = GetEnable_B,
- .GetIntSrc = GetIntSrc_B,
- .GetLoadTrig = GetLoadTrig_B,
- .GetMode = GetMode_B,
- .PulseIndex = PulseIndex_B,
- .SetEnable = SetEnable_B,
- .SetIntSrc = SetIntSrc_B,
- .SetLoadTrig = SetLoadTrig_B,
- .SetMode = SetMode_B,
- .ResetCapFlags = ResetCapFlags_B,
- .MyCRA = LP_CR0A,
- .MyCRB = LP_CR0B,
- .MyLatchLsw = LP_CNTR0BLSW,
- .MyEventBits = EVBITS(3),
- },
- {
- .GetEnable = GetEnable_B,
- .GetIntSrc = GetIntSrc_B,
- .GetLoadTrig = GetLoadTrig_B,
- .GetMode = GetMode_B,
- .PulseIndex = PulseIndex_B,
- .SetEnable = SetEnable_B,
- .SetIntSrc = SetIntSrc_B,
- .SetLoadTrig = SetLoadTrig_B,
- .SetMode = SetMode_B,
- .ResetCapFlags = ResetCapFlags_B,
- .MyCRA = LP_CR1A,
- .MyCRB = LP_CR1B,
- .MyLatchLsw = LP_CNTR1BLSW,
- .MyEventBits = EVBITS(4),
- },
- {
- .GetEnable = GetEnable_B,
- .GetIntSrc = GetIntSrc_B,
- .GetLoadTrig = GetLoadTrig_B,
- .GetMode = GetMode_B,
- .PulseIndex = PulseIndex_B,
- .SetEnable = SetEnable_B,
- .SetIntSrc = SetIntSrc_B,
- .SetLoadTrig = SetLoadTrig_B,
- .SetMode = SetMode_B,
- .ResetCapFlags = ResetCapFlags_B,
- .MyCRA = LP_CR2A,
- .MyCRB = LP_CR2B,
- .MyLatchLsw = LP_CNTR2BLSW,
- .MyEventBits = EVBITS(5),
- },
-};
-
/* enab/disable a function or test status bit(s) that are accessed */
/* through Main Control Registers 1 or 2. */
#define MC_ENABLE(REGADRS, CTRLWORD) writel(((uint32_t)(CTRLWORD) << 16) | (uint32_t)(CTRLWORD), devpriv->base_addr+(REGADRS))
}
};
-static int s626_attach(struct comedi_device *dev, struct comedi_devconfig *it)
+/* Execute a DEBI transfer. This must be called from within a */
+/* critical section. */
+static void DEBItransfer(struct comedi_device *dev)
{
-/* uint8_t PollList; */
-/* uint16_t AdcData; */
-/* uint16_t StartVal; */
-/* uint16_t index; */
-/* unsigned int data[16]; */
- int result;
- int i;
- int ret;
- resource_size_t resourceStart;
- dma_addr_t appdma;
- struct comedi_subdevice *s;
- struct pci_dev *pdev = NULL;
+ /* Initiate upload of shadow RAM to DEBI control register. */
+ MC_ENABLE(P_MC2, MC2_UPLD_DEBI);
- if (alloc_private(dev, sizeof(struct s626_private)) < 0)
- return -ENOMEM;
+ /* Wait for completion of upload from shadow RAM to DEBI control */
+ /* register. */
+ while (!MC_TEST(P_MC2, MC2_UPLD_DEBI))
+ ;
- for (i = 0; i < ARRAY_SIZE(s626_boards) && !pdev; i++) {
- do {
- pdev = pci_get_subsys(s626_boards[i].vendor_id,
- s626_boards[i].device_id,
- s626_boards[i].subvendor_id,
- s626_boards[i].subdevice_id,
- pdev);
+ /* Wait until DEBI transfer is done. */
+ while (RR7146(P_PSR) & PSR_DEBI_S)
+ ;
+}
- if ((it->options[0] || it->options[1]) && pdev) {
- /* matches requested bus/slot */
- if (pdev->bus->number == it->options[0] &&
- PCI_SLOT(pdev->devfn) == it->options[1])
- break;
- } else
- break;
- } while (1);
- }
- devpriv->pdev = pdev;
+/* Initialize the DEBI interface for all transfers. */
- if (pdev == NULL) {
- printk(KERN_ERR "s626_attach: Board not present!!!\n");
- return -ENODEV;
- }
+static uint16_t DEBIread(struct comedi_device *dev, uint16_t addr)
+{
+ uint16_t retval;
- result = comedi_pci_enable(pdev, "s626");
- if (result < 0) {
- printk(KERN_ERR "s626_attach: comedi_pci_enable fails\n");
- return -ENODEV;
- }
- devpriv->got_regions = 1;
+ /* Set up DEBI control register value in shadow RAM. */
+ WR7146(P_DEBICMD, DEBI_CMD_RDWORD | addr);
- resourceStart = pci_resource_start(devpriv->pdev, 0);
+ /* Execute the DEBI transfer. */
+ DEBItransfer(dev);
- devpriv->base_addr = ioremap(resourceStart, SIZEOF_ADDRESS_SPACE);
- if (devpriv->base_addr == NULL) {
- printk(KERN_ERR "s626_attach: IOREMAP failed\n");
- return -ENODEV;
- }
+ /* Fetch target register value. */
+ retval = (uint16_t) RR7146(P_DEBIAD);
- if (devpriv->base_addr) {
- /* disable master interrupt */
- writel(0, devpriv->base_addr + P_IER);
+ /* Return register value. */
+ return retval;
+}
- /* soft reset */
- writel(MC1_SOFT_RESET, devpriv->base_addr + P_MC1);
+/* Write a value to a gate array register. */
+static void DEBIwrite(struct comedi_device *dev, uint16_t addr, uint16_t wdata)
+{
- /* DMA FIXME DMA// */
- DEBUG("s626_attach: DMA ALLOCATION\n");
+ /* Set up DEBI control register value in shadow RAM. */
+ WR7146(P_DEBICMD, DEBI_CMD_WRWORD | addr);
+ WR7146(P_DEBIAD, wdata);
- /* adc buffer allocation */
- devpriv->allocatedBuf = 0;
+ /* Execute the DEBI transfer. */
+ DEBItransfer(dev);
+}
- devpriv->ANABuf.LogicalBase =
- pci_alloc_consistent(devpriv->pdev, DMABUF_SIZE, &appdma);
+/* Replace the specified bits in a gate array register. Imports: mask
+ * specifies bits that are to be preserved, wdata is new value to be
+ * or'd with the masked original.
+ */
+static void DEBIreplace(struct comedi_device *dev, uint16_t addr, uint16_t mask,
+ uint16_t wdata)
+{
- if (devpriv->ANABuf.LogicalBase == NULL) {
- printk(KERN_ERR "s626_attach: DMA Memory mapping error\n");
- return -ENOMEM;
- }
+ /* Copy target gate array register into P_DEBIAD register. */
+ WR7146(P_DEBICMD, DEBI_CMD_RDWORD | addr);
+ /* Set up DEBI control reg value in shadow RAM. */
+ DEBItransfer(dev); /* Execute the DEBI Read transfer. */
- devpriv->ANABuf.PhysicalBase = appdma;
+ /* Write back the modified image. */
+ WR7146(P_DEBICMD, DEBI_CMD_WRWORD | addr);
+ /* Set up DEBI control reg value in shadow RAM. */
- DEBUG
- ("s626_attach: AllocDMAB ADC Logical=%p, bsize=%d, Physical=0x%x\n",
- devpriv->ANABuf.LogicalBase, DMABUF_SIZE,
- (uint32_t) devpriv->ANABuf.PhysicalBase);
+ WR7146(P_DEBIAD, wdata | ((uint16_t) RR7146(P_DEBIAD) & mask));
+ /* Modify the register image. */
+ DEBItransfer(dev); /* Execute the DEBI Write transfer. */
+}
- devpriv->allocatedBuf++;
+/* ************** EEPROM ACCESS FUNCTIONS ************** */
- devpriv->RPSBuf.LogicalBase =
- pci_alloc_consistent(devpriv->pdev, DMABUF_SIZE, &appdma);
+static uint32_t I2Chandshake(struct comedi_device *dev, uint32_t val)
+{
+ /* Write I2C command to I2C Transfer Control shadow register. */
+ WR7146(P_I2CCTRL, val);
- if (devpriv->RPSBuf.LogicalBase == NULL) {
- printk(KERN_ERR "s626_attach: DMA Memory mapping error\n");
- return -ENOMEM;
- }
+ /* Upload I2C shadow registers into working registers and wait for */
+ /* upload confirmation. */
- devpriv->RPSBuf.PhysicalBase = appdma;
+ MC_ENABLE(P_MC2, MC2_UPLD_IIC);
+ while (!MC_TEST(P_MC2, MC2_UPLD_IIC))
+ ;
- DEBUG
- ("s626_attach: AllocDMAB RPS Logical=%p, bsize=%d, Physical=0x%x\n",
- devpriv->RPSBuf.LogicalBase, DMABUF_SIZE,
- (uint32_t) devpriv->RPSBuf.PhysicalBase);
+ /* Wait until I2C bus transfer is finished or an error occurs. */
+ while ((RR7146(P_I2CCTRL) & (I2C_BUSY | I2C_ERR)) == I2C_BUSY)
+ ;
- devpriv->allocatedBuf++;
+ /* Return non-zero if I2C error occurred. */
+ return RR7146(P_I2CCTRL) & I2C_ERR;
- }
+}
- dev->board_ptr = s626_boards;
- dev->board_name = thisboard->name;
+/* Read uint8_t from EEPROM. */
+static uint8_t I2Cread(struct comedi_device *dev, uint8_t addr)
+{
+ uint8_t rtnval;
- if (alloc_subdevices(dev, 6) < 0)
- return -ENOMEM;
+ /* Send EEPROM target address. */
+ if (I2Chandshake(dev, I2C_B2(I2C_ATTRSTART, I2CW)
+ /* Byte2 = I2C command: write to I2C EEPROM device. */
+ | I2C_B1(I2C_ATTRSTOP, addr)
+ /* Byte1 = EEPROM internal target address. */
+ | I2C_B0(I2C_ATTRNOP, 0))) { /* Byte0 = Not sent. */
+ /* Abort function and declare error if handshake failed. */
+ return 0;
+ }
+ /* Execute EEPROM read. */
+ if (I2Chandshake(dev, I2C_B2(I2C_ATTRSTART, I2CR)
- dev->iobase = (unsigned long)devpriv->base_addr;
- dev->irq = devpriv->pdev->irq;
+ /* Byte2 = I2C */
+ /* command: read */
+ /* from I2C EEPROM */
+ /* device. */
+ |I2C_B1(I2C_ATTRSTOP, 0)
- /* set up interrupt handler */
- if (dev->irq == 0) {
- printk(KERN_ERR " unknown irq (bad)\n");
- } else {
- ret = request_irq(dev->irq, s626_irq_handler, IRQF_SHARED,
- "s626", dev);
+ /* Byte1 receives */
+ /* uint8_t from */
+ /* EEPROM. */
+ |I2C_B0(I2C_ATTRNOP, 0))) { /* Byte0 = Not sent. */
- if (ret < 0) {
- printk(KERN_ERR " irq not available\n");
- dev->irq = 0;
- }
+ /* Abort function and declare error if handshake failed. */
+ return 0;
}
+ /* Return copy of EEPROM value. */
+ rtnval = (uint8_t) (RR7146(P_I2CCTRL) >> 16);
+ return rtnval;
+}
- DEBUG("s626_attach: -- it opts %d,%d --\n",
- it->options[0], it->options[1]);
+/* *********** DAC FUNCTIONS *********** */
- s = dev->subdevices + 0;
- /* analog input subdevice */
- dev->read_subdev = s;
- /* we support single-ended (ground) and differential */
- s->type = COMEDI_SUBD_AI;
- s->subdev_flags = SDF_READABLE | SDF_DIFF | SDF_CMD_READ;
- s->n_chan = thisboard->ai_chans;
- s->maxdata = (0xffff >> 2);
- s->range_table = &s626_range_table;
- s->len_chanlist = thisboard->ai_chans; /* This is the maximum chanlist
- length that the board can
- handle */
- s->insn_config = s626_ai_insn_config;
- s->insn_read = s626_ai_insn_read;
- s->do_cmd = s626_ai_cmd;
- s->do_cmdtest = s626_ai_cmdtest;
- s->cancel = s626_ai_cancel;
+/* Slot 0 base settings. */
+#define VECT0 (XSD2 | RSD3 | SIB_A2)
+/* Slot 0 always shifts in 0xFF and store it to FB_BUFFER2. */
- s = dev->subdevices + 1;
- /* analog output subdevice */
- s->type = COMEDI_SUBD_AO;
- s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
- s->n_chan = thisboard->ao_chans;
- s->maxdata = (0x3fff);
- s->range_table = &range_bipolar10;
- s->insn_write = s626_ao_winsn;
- s->insn_read = s626_ao_rinsn;
+/* TrimDac LogicalChan-to-PhysicalChan mapping table. */
+static uint8_t trimchan[] = { 10, 9, 8, 3, 2, 7, 6, 1, 0, 5, 4 };
- s = dev->subdevices + 2;
- /* digital I/O subdevice */
- s->type = COMEDI_SUBD_DIO;
- s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
- s->n_chan = S626_DIO_CHANNELS;
- s->maxdata = 1;
- s->io_bits = 0xffff;
- s->private = &dio_private_A;
- s->range_table = &range_digital;
- s->insn_config = s626_dio_insn_config;
- s->insn_bits = s626_dio_insn_bits;
-
- s = dev->subdevices + 3;
- /* digital I/O subdevice */
- s->type = COMEDI_SUBD_DIO;
- s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
- s->n_chan = 16;
- s->maxdata = 1;
- s->io_bits = 0xffff;
- s->private = &dio_private_B;
- s->range_table = &range_digital;
- s->insn_config = s626_dio_insn_config;
- s->insn_bits = s626_dio_insn_bits;
-
- s = dev->subdevices + 4;
- /* digital I/O subdevice */
- s->type = COMEDI_SUBD_DIO;
- s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
- s->n_chan = 16;
- s->maxdata = 1;
- s->io_bits = 0xffff;
- s->private = &dio_private_C;
- s->range_table = &range_digital;
- s->insn_config = s626_dio_insn_config;
- s->insn_bits = s626_dio_insn_bits;
-
- s = dev->subdevices + 5;
- /* encoder (counter) subdevice */
- s->type = COMEDI_SUBD_COUNTER;
- s->subdev_flags = SDF_WRITABLE | SDF_READABLE | SDF_LSAMPL;
- s->n_chan = thisboard->enc_chans;
- s->private = enc_private_data;
- s->insn_config = s626_enc_insn_config;
- s->insn_read = s626_enc_insn_read;
- s->insn_write = s626_enc_insn_write;
- s->maxdata = 0xffffff;
- s->range_table = &range_unknown;
-
- /* stop ai_command */
- devpriv->ai_cmd_running = 0;
-
- if (devpriv->base_addr && (devpriv->allocatedBuf == 2)) {
- dma_addr_t pPhysBuf;
- uint16_t chan;
-
- /* enab DEBI and audio pins, enable I2C interface. */
- MC_ENABLE(P_MC1, MC1_DEBI | MC1_AUDIO | MC1_I2C);
- /* Configure DEBI operating mode. */
- WR7146(P_DEBICFG, DEBI_CFG_SLAVE16 /* Local bus is 16 */
- /* bits wide. */
- | (DEBI_TOUT << DEBI_CFG_TOUT_BIT)
-
- /* Declare DEBI */
- /* transfer timeout */
- /* interval. */
- |DEBI_SWAP /* Set up byte lane */
- /* steering. */
- | DEBI_CFG_INTEL); /* Intel-compatible */
- /* local bus (DEBI */
- /* never times out). */
- DEBUG("s626_attach: %d debi init -- %d\n",
- DEBI_CFG_SLAVE16 | (DEBI_TOUT << DEBI_CFG_TOUT_BIT) |
- DEBI_SWAP | DEBI_CFG_INTEL,
- DEBI_CFG_INTEL | DEBI_CFG_TOQ | DEBI_CFG_INCQ |
- DEBI_CFG_16Q);
-
- /* DEBI INIT S626 WR7146( P_DEBICFG, DEBI_CFG_INTEL | DEBI_CFG_TOQ */
- /* | DEBI_CFG_INCQ| DEBI_CFG_16Q); //end */
-
- /* Paging is disabled. */
- WR7146(P_DEBIPAGE, DEBI_PAGE_DISABLE); /* Disable MMU paging. */
-
- /* Init GPIO so that ADC Start* is negated. */
- WR7146(P_GPIO, GPIO_BASE | GPIO1_HI);
-
- /* IsBoardRevA is a boolean that indicates whether the board is RevA.
- *
- * VERSION 2.01 CHANGE: REV A & B BOARDS NOW SUPPORTED BY DYNAMIC
- * EEPROM ADDRESS SELECTION. Initialize the I2C interface, which
- * is used to access the onboard serial EEPROM. The EEPROM's I2C
- * DeviceAddress is hardwired to a value that is dependent on the
- * 626 board revision. On all board revisions, the EEPROM stores
- * TrimDAC calibration constants for analog I/O. On RevB and
- * higher boards, the DeviceAddress is hardwired to 0 to enable
- * the EEPROM to also store the PCI SubVendorID and SubDeviceID;
- * this is the address at which the SAA7146 expects a
- * configuration EEPROM to reside. On RevA boards, the EEPROM
- * device address, which is hardwired to 4, prevents the SAA7146
- * from retrieving PCI sub-IDs, so the SAA7146 uses its built-in
- * default values, instead.
- */
-
- /* devpriv->I2Cards= IsBoardRevA ? 0xA8 : 0xA0; // Set I2C EEPROM */
- /* DeviceType (0xA0) */
- /* and DeviceAddress<<1. */
-
- devpriv->I2CAdrs = 0xA0; /* I2C device address for onboard */
- /* eeprom(revb) */
-
- /* Issue an I2C ABORT command to halt any I2C operation in */
- /* progress and reset BUSY flag. */
- WR7146(P_I2CSTAT, I2C_CLKSEL | I2C_ABORT);
- /* Write I2C control: abort any I2C activity. */
- MC_ENABLE(P_MC2, MC2_UPLD_IIC);
- /* Invoke command upload */
- while ((RR7146(P_MC2) & MC2_UPLD_IIC) == 0)
- ;
- /* and wait for upload to complete. */
-
- /* Per SAA7146 data sheet, write to STATUS reg twice to
- * reset all I2C error flags. */
- for (i = 0; i < 2; i++) {
- WR7146(P_I2CSTAT, I2C_CLKSEL);
- /* Write I2C control: reset error flags. */
- MC_ENABLE(P_MC2, MC2_UPLD_IIC); /* Invoke command upload */
- while (!MC_TEST(P_MC2, MC2_UPLD_IIC))
- ;
- /* and wait for upload to complete. */
- }
+/* TrimDac LogicalChan-to-EepromAdrs mapping table. */
+static uint8_t trimadrs[] = { 0x40, 0x41, 0x42, 0x50, 0x51, 0x52, 0x53, 0x60, 0x61, 0x62, 0x63 };
- /* Init audio interface functional attributes: set DAC/ADC
- * serial clock rates, invert DAC serial clock so that
- * DAC data setup times are satisfied, enable DAC serial
- * clock out.
- */
+/* Private helper function: Transmit serial data to DAC via Audio
+ * channel 2. Assumes: (1) TSL2 slot records initialized, and (2)
+ * Dacpol contains valid target image.
+ */
+static void SendDAC(struct comedi_device *dev, uint32_t val)
+{
- WR7146(P_ACON2, ACON2_INIT);
+ /* START THE SERIAL CLOCK RUNNING ------------- */
- /* Set up TSL1 slot list, which is used to control the
- * accumulation of ADC data: RSD1 = shift data in on SD1.
- * SIB_A1 = store data uint8_t at next available location in
- * FB BUFFER1 register. */
- WR7146(P_TSL1, RSD1 | SIB_A1);
- /* Fetch ADC high data uint8_t. */
- WR7146(P_TSL1 + 4, RSD1 | SIB_A1 | EOS);
- /* Fetch ADC low data uint8_t; end of TSL1. */
+ /* Assert DAC polarity control and enable gating of DAC serial clock
+ * and audio bit stream signals. At this point in time we must be
+ * assured of being in time slot 0. If we are not in slot 0, the
+ * serial clock and audio stream signals will be disabled; this is
+ * because the following DEBIwrite statement (which enables signals
+ * to be passed through the gate array) would execute before the
+ * trailing edge of WS1/WS3 (which turns off the signals), thus
+ * causing the signals to be inactive during the DAC write.
+ */
+ DEBIwrite(dev, LP_DACPOL, devpriv->Dacpol);
- /* enab TSL1 slot list so that it executes all the time. */
- WR7146(P_ACON1, ACON1_ADCSTART);
+ /* TRANSFER OUTPUT DWORD VALUE INTO A2'S OUTPUT FIFO ---------------- */
- /* Initialize RPS registers used for ADC. */
+ /* Copy DAC setpoint value to DAC's output DMA buffer. */
- /* Physical start of RPS program. */
- WR7146(P_RPSADDR1, (uint32_t) devpriv->RPSBuf.PhysicalBase);
+ /* WR7146( (uint32_t)devpriv->pDacWBuf, val ); */
+ *devpriv->pDacWBuf = val;
- WR7146(P_RPSPAGE1, 0);
- /* RPS program performs no explicit mem writes. */
- WR7146(P_RPS1_TOUT, 0); /* Disable RPS timeouts. */
+ /* enab the output DMA transfer. This will cause the DMAC to copy
+ * the DAC's data value to A2's output FIFO. The DMA transfer will
+ * then immediately terminate because the protection address is
+ * reached upon transfer of the first DWORD value.
+ */
+ MC_ENABLE(P_MC1, MC1_A2OUT);
- /* SAA7146 BUG WORKAROUND. Initialize SAA7146 ADC interface
- * to a known state by invoking ADCs until FB BUFFER 1
- * register shows that it is correctly receiving ADC data.
- * This is necessary because the SAA7146 ADC interface does
- * not start up in a defined state after a PCI reset.
- */
+ /* While the DMA transfer is executing ... */
-/* PollList = EOPL; // Create a simple polling */
-/* // list for analog input */
-/* // channel 0. */
-/* ResetADC( dev, &PollList ); */
+ /* Reset Audio2 output FIFO's underflow flag (along with any other
+ * FIFO underflow/overflow flags). When set, this flag will
+ * indicate that we have emerged from slot 0.
+ */
+ WR7146(P_ISR, ISR_AFOU);
-/* s626_ai_rinsn(dev,dev->subdevices,NULL,data); //( &AdcData ); // */
-/* //Get initial ADC */
-/* //value. */
+ /* Wait for the DMA transfer to finish so that there will be data
+ * available in the FIFO when time slot 1 tries to transfer a DWORD
+ * from the FIFO to the output buffer register. We test for DMA
+ * Done by polling the DMAC enable flag; this flag is automatically
+ * cleared when the transfer has finished.
+ */
+ while ((RR7146(P_MC1) & MC1_A2OUT) != 0)
+ ;
-/* StartVal = data[0]; */
+ /* START THE OUTPUT STREAM TO THE TARGET DAC -------------------- */
-/* // VERSION 2.01 CHANGE: TIMEOUT ADDED TO PREVENT HANGED EXECUTION. */
-/* // Invoke ADCs until the new ADC value differs from the initial */
-/* // value or a timeout occurs. The timeout protects against the */
-/* // possibility that the driver is restarting and the ADC data is a */
-/* // fixed value resulting from the applied ADC analog input being */
-/* // unusually quiet or at the rail. */
+ /* FIFO data is now available, so we enable execution of time slots
+ * 1 and higher by clearing the EOS flag in slot 0. Note that SD3
+ * will be shifted in and stored in FB_BUFFER2 for end-of-slot-list
+ * detection.
+ */
+ SETVECT(0, XSD2 | RSD3 | SIB_A2);
-/* for ( index = 0; index < 500; index++ ) */
-/* { */
-/* s626_ai_rinsn(dev,dev->subdevices,NULL,data); */
-/* AdcData = data[0]; //ReadADC( &AdcData ); */
-/* if ( AdcData != StartVal ) */
-/* break; */
-/* } */
+ /* Wait for slot 1 to execute to ensure that the Packet will be
+ * transmitted. This is detected by polling the Audio2 output FIFO
+ * underflow flag, which will be set when slot 1 execution has
+ * finished transferring the DAC's data DWORD from the output FIFO
+ * to the output buffer register.
+ */
+ while ((RR7146(P_SSR) & SSR_AF2_OUT) == 0)
+ ;
- /* end initADC */
+ /* Set up to trap execution at slot 0 when the TSL sequencer cycles
+ * back to slot 0 after executing the EOS in slot 5. Also,
+ * simultaneously shift out and in the 0x00 that is ALWAYS the value
+ * stored in the last byte to be shifted out of the FIFO's DWORD
+ * buffer register.
+ */
+ SETVECT(0, XSD2 | XFIFO_2 | RSD2 | SIB_A2 | EOS);
- /* init the DAC interface */
+ /* WAIT FOR THE TRANSACTION TO FINISH ----------------------- */
- /* Init Audio2's output DMAC attributes: burst length = 1
- * DWORD, threshold = 1 DWORD.
+ /* Wait for the TSL to finish executing all time slots before
+ * exiting this function. We must do this so that the next DAC
+ * write doesn't start, thereby enabling clock/chip select signals:
+ *
+ * 1. Before the TSL sequence cycles back to slot 0, which disables
+ * the clock/cs signal gating and traps slot // list execution.
+ * we have not yet finished slot 5 then the clock/cs signals are
+ * still gated and we have not finished transmitting the stream.
+ *
+ * 2. While slots 2-5 are executing due to a late slot 0 trap. In
+ * this case, the slot sequence is currently repeating, but with
+ * clock/cs signals disabled. We must wait for slot 0 to trap
+ * execution before setting up the next DAC setpoint DMA transfer
+ * and enabling the clock/cs signals. To detect the end of slot 5,
+ * we test for the FB_BUFFER2 MSB contents to be equal to 0xFF. If
+ * the TSL has not yet finished executing slot 5 ...
+ */
+ if ((RR7146(P_FB_BUFFER2) & 0xFF000000) != 0) {
+ /* The trap was set on time and we are still executing somewhere
+ * in slots 2-5, so we now wait for slot 0 to execute and trap
+ * TSL execution. This is detected when FB_BUFFER2 MSB changes
+ * from 0xFF to 0x00, which slot 0 causes to happen by shifting
+ * out/in on SD2 the 0x00 that is always referenced by slot 5.
*/
- WR7146(P_PCI_BT_A, 0);
+ while ((RR7146(P_FB_BUFFER2) & 0xFF000000) != 0)
+ ;
+ }
+ /* Either (1) we were too late setting the slot 0 trap; the TSL
+ * sequencer restarted slot 0 before we could set the EOS trap flag,
+ * or (2) we were not late and execution is now trapped at slot 0.
+ * In either case, we must now change slot 0 so that it will store
+ * value 0xFF (instead of 0x00) to FB_BUFFER2 next time it executes.
+ * In order to do this, we reprogram slot 0 so that it will shift in
+ * SD3, which is driven only by a pull-up resistor.
+ */
+ SETVECT(0, RSD3 | SIB_A2 | EOS);
- /* Init Audio2's output DMA physical addresses. The protection
- * address is set to 1 DWORD past the base address so that a
- * single DWORD will be transferred each time a DMA transfer is
- * enabled. */
+ /* Wait for slot 0 to execute, at which time the TSL is setup for
+ * the next DAC write. This is detected when FB_BUFFER2 MSB changes
+ * from 0x00 to 0xFF.
+ */
+ while ((RR7146(P_FB_BUFFER2) & 0xFF000000) == 0)
+ ;
+}
- pPhysBuf =
- devpriv->ANABuf.PhysicalBase +
- (DAC_WDMABUF_OS * sizeof(uint32_t));
+/* Private helper function: Write setpoint to an application DAC channel. */
+static void SetDAC(struct comedi_device *dev, uint16_t chan, short dacdata)
+{
+ register uint16_t signmask;
+ register uint32_t WSImage;
- WR7146(P_BASEA2_OUT, (uint32_t) pPhysBuf); /* Buffer base adrs. */
- WR7146(P_PROTA2_OUT, (uint32_t) (pPhysBuf + sizeof(uint32_t))); /* Protection address. */
+ /* Adjust DAC data polarity and set up Polarity Control Register */
+ /* image. */
+ signmask = 1 << chan;
+ if (dacdata < 0) {
+ dacdata = -dacdata;
+ devpriv->Dacpol |= signmask;
+ } else
+ devpriv->Dacpol &= ~signmask;
- /* Cache Audio2's output DMA buffer logical address. This is
- * where DAC data is buffered for A2 output DMA transfers. */
- devpriv->pDacWBuf =
- (uint32_t *) devpriv->ANABuf.LogicalBase + DAC_WDMABUF_OS;
+ /* Limit DAC setpoint value to valid range. */
+ if ((uint16_t) dacdata > 0x1FFF)
+ dacdata = 0x1FFF;
- /* Audio2's output channels does not use paging. The protection
- * violation handling bit is set so that the DMAC will
- * automatically halt and its PCI address pointer will be reset
- * when the protection address is reached. */
+ /* Set up TSL2 records (aka "vectors") for DAC update. Vectors V2
+ * and V3 transmit the setpoint to the target DAC. V4 and V5 send
+ * data to a non-existent TrimDac channel just to keep the clock
+ * running after sending data to the target DAC. This is necessary
+ * to eliminate the clock glitch that would otherwise occur at the
+ * end of the target DAC's serial data stream. When the sequence
+ * restarts at V0 (after executing V5), the gate array automatically
+ * disables gating for the DAC clock and all DAC chip selects.
+ */
- WR7146(P_PAGEA2_OUT, 8);
+ WSImage = (chan & 2) ? WS1 : WS2;
+ /* Choose DAC chip select to be asserted. */
+ SETVECT(2, XSD2 | XFIFO_1 | WSImage);
+ /* Slot 2: Transmit high data byte to target DAC. */
+ SETVECT(3, XSD2 | XFIFO_0 | WSImage);
+ /* Slot 3: Transmit low data byte to target DAC. */
+ SETVECT(4, XSD2 | XFIFO_3 | WS3);
+ /* Slot 4: Transmit to non-existent TrimDac channel to keep clock */
+ SETVECT(5, XSD2 | XFIFO_2 | WS3 | EOS);
+ /* Slot 5: running after writing target DAC's low data byte. */
- /* Initialize time slot list 2 (TSL2), which is used to control
- * the clock generation for and serialization of data to be sent
- * to the DAC devices. Slot 0 is a NOP that is used to trap TSL
- * execution; this permits other slots to be safely modified
- * without first turning off the TSL sequencer (which is
- * apparently impossible to do). Also, SD3 (which is driven by a
- * pull-up resistor) is shifted in and stored to the MSB of
- * FB_BUFFER2 to be used as evidence that the slot sequence has
- * not yet finished executing.
- */
+ /* Construct and transmit target DAC's serial packet:
+ * ( A10D DDDD ),( DDDD DDDD ),( 0x0F ),( 0x00 ) where A is chan<0>,
+ * and D<12:0> is the DAC setpoint. Append a WORD value (that writes
+ * to a non-existent TrimDac channel) that serves to keep the clock
+ * running after the packet has been sent to the target DAC.
+ */
+ SendDAC(dev, 0x0F000000
+ /* Continue clock after target DAC data (write to non-existent trimdac). */
+ | 0x00004000
+ /* Address the two main dual-DAC devices (TSL's chip select enables
+ * target device). */
+ | ((uint32_t) (chan & 1) << 15)
+ /* Address the DAC channel within the device. */
+ | (uint32_t) dacdata); /* Include DAC setpoint data. */
- SETVECT(0, XSD2 | RSD3 | SIB_A2 | EOS);
- /* Slot 0: Trap TSL execution, shift 0xFF into FB_BUFFER2. */
+}
- /* Initialize slot 1, which is constant. Slot 1 causes a
- * DWORD to be transferred from audio channel 2's output FIFO
- * to the FIFO's output buffer so that it can be serialized
- * and sent to the DAC during subsequent slots. All remaining
- * slots are dynamically populated as required by the target
- * DAC device.
- */
- SETVECT(1, LF_A2);
- /* Slot 1: Fetch DWORD from Audio2's output FIFO. */
+static void WriteTrimDAC(struct comedi_device *dev, uint8_t LogicalChan,
+ uint8_t DacData)
+{
+ uint32_t chan;
- /* Start DAC's audio interface (TSL2) running. */
- WR7146(P_ACON1, ACON1_DACSTART);
+ /* Save the new setpoint in case the application needs to read it back later. */
+ devpriv->TrimSetpoint[LogicalChan] = (uint8_t) DacData;
- /* end init DAC interface */
+ /* Map logical channel number to physical channel number. */
+ chan = (uint32_t) trimchan[LogicalChan];
- /* Init Trim DACs to calibrated values. Do it twice because the
- * SAA7146 audio channel does not always reset properly and
- * sometimes causes the first few TrimDAC writes to malfunction.
- */
+ /* Set up TSL2 records for TrimDac write operation. All slots shift
+ * 0xFF in from pulled-up SD3 so that the end of the slot sequence
+ * can be detected.
+ */
- LoadTrimDACs(dev);
- LoadTrimDACs(dev); /* Insurance. */
+ SETVECT(2, XSD2 | XFIFO_1 | WS3);
+ /* Slot 2: Send high uint8_t to target TrimDac. */
+ SETVECT(3, XSD2 | XFIFO_0 | WS3);
+ /* Slot 3: Send low uint8_t to target TrimDac. */
+ SETVECT(4, XSD2 | XFIFO_3 | WS1);
+ /* Slot 4: Send NOP high uint8_t to DAC0 to keep clock running. */
+ SETVECT(5, XSD2 | XFIFO_2 | WS1 | EOS);
+ /* Slot 5: Send NOP low uint8_t to DAC0. */
- /* Manually init all gate array hardware in case this is a soft
- * reset (we have no way of determining whether this is a warm
- * or cold start). This is necessary because the gate array will
- * reset only in response to a PCI hard reset; there is no soft
- * reset function. */
+ /* Construct and transmit target DAC's serial packet:
+ * ( 0000 AAAA ), ( DDDD DDDD ),( 0x00 ),( 0x00 ) where A<3:0> is the
+ * DAC channel's address, and D<7:0> is the DAC setpoint. Append a
+ * WORD value (that writes a channel 0 NOP command to a non-existent
+ * main DAC channel) that serves to keep the clock running after the
+ * packet has been sent to the target DAC.
+ */
- /* Init all DAC outputs to 0V and init all DAC setpoint and
- * polarity images.
- */
- for (chan = 0; chan < S626_DAC_CHANNELS; chan++)
- SetDAC(dev, chan, 0);
+ /* Address the DAC channel within the trimdac device. */
+ SendDAC(dev, ((uint32_t) chan << 8)
+ | (uint32_t) DacData); /* Include DAC setpoint data. */
+}
- /* Init image of WRMISC2 Battery Charger Enabled control bit.
- * This image is used when the state of the charger control bit,
- * which has no direct hardware readback mechanism, is queried.
- */
- devpriv->ChargeEnabled = 0;
+static void LoadTrimDACs(struct comedi_device *dev)
+{
+ register uint8_t i;
- /* Init image of watchdog timer interval in WRMISC2. This image
- * maintains the value of the control bits of MISC2 are
- * continuously reset to zero as long as the WD timer is disabled.
- */
- devpriv->WDInterval = 0;
+ /* Copy TrimDac setpoint values from EEPROM to TrimDacs. */
+ for (i = 0; i < ARRAY_SIZE(trimchan); i++)
+ WriteTrimDAC(dev, i, I2Cread(dev, trimadrs[i]));
+}
- /* Init Counter Interrupt enab mask for RDMISC2. This mask is
- * applied against MISC2 when testing to determine which timer
- * events are requesting interrupt service.
- */
- devpriv->CounterIntEnabs = 0;
+/* ****** COUNTER FUNCTIONS ******* */
+/* All counter functions address a specific counter by means of the
+ * "Counter" argument, which is a logical counter number. The Counter
+ * argument may have any of the following legal values: 0=0A, 1=1A,
+ * 2=2A, 3=0B, 4=1B, 5=2B.
+ */
- /* Init counters. */
- CountersInit(dev);
+/* Read a counter's output latch. */
+static uint32_t ReadLatch(struct comedi_device *dev, struct enc_private *k)
+{
+ register uint32_t value;
- /* Without modifying the state of the Battery Backup enab, disable
- * the watchdog timer, set DIO channels 0-5 to operate in the
- * standard DIO (vs. counter overflow) mode, disable the battery
- * charger, and reset the watchdog interval selector to zero.
- */
- WriteMISC2(dev, (uint16_t) (DEBIread(dev,
- LP_RDMISC2) &
- MISC2_BATT_ENABLE));
+ /* Latch counts and fetch LSW of latched counts value. */
+ value = (uint32_t) DEBIread(dev, k->MyLatchLsw);
- /* Initialize the digital I/O subsystem. */
- s626_dio_init(dev);
+ /* Fetch MSW of latched counts and combine with LSW. */
+ value |= ((uint32_t) DEBIread(dev, k->MyLatchLsw + 2) << 16);
- /* enable interrupt test */
- /* writel(IRQ_GPIO3 | IRQ_RPS1,devpriv->base_addr+P_IER); */
- }
+ /* Return latched counts. */
+ return value;
+}
- DEBUG("s626_attach: comedi%d s626 attached %04x\n", dev->minor,
- (uint32_t) devpriv->base_addr);
+/* Return/set a counter pair's latch trigger source. 0: On read
+ * access, 1: A index latches A, 2: B index latches B, 3: A overflow
+ * latches B.
+ */
+static void SetLatchSource(struct comedi_device *dev, struct enc_private *k,
+ uint16_t value)
+{
+ DEBIreplace(dev, k->MyCRB,
+ (uint16_t) (~(CRBMSK_INTCTRL | CRBMSK_LATCHSRC)),
+ (uint16_t) (value << CRBBIT_LATCHSRC));
+}
- return 1;
+/* Write value into counter preload register. */
+static void Preload(struct comedi_device *dev, struct enc_private *k,
+ uint32_t value)
+{
+ DEBIwrite(dev, (uint16_t) (k->MyLatchLsw), (uint16_t) value);
+ DEBIwrite(dev, (uint16_t) (k->MyLatchLsw + 2),
+ (uint16_t) (value >> 16));
}
static unsigned int s626_ai_reg_to_uint(int data)
/* return 0; */
/* } */
+static int s626_dio_set_irq(struct comedi_device *dev, unsigned int chan)
+{
+ unsigned int group;
+ unsigned int bitmask;
+ unsigned int status;
+
+ /* select dio bank */
+ group = chan / 16;
+ bitmask = 1 << (chan - (16 * group));
+
+ /* set channel to capture positive edge */
+ status = DEBIread(dev,
+ ((struct dio_private *)(dev->subdevices + 2 +
+ group)->private)->RDEdgSel);
+ DEBIwrite(dev,
+ ((struct dio_private *)(dev->subdevices + 2 +
+ group)->private)->WREdgSel,
+ bitmask | status);
+
+ /* enable interrupt on selected channel */
+ status = DEBIread(dev,
+ ((struct dio_private *)(dev->subdevices + 2 +
+ group)->private)->RDIntSel);
+ DEBIwrite(dev,
+ ((struct dio_private *)(dev->subdevices + 2 +
+ group)->private)->WRIntSel,
+ bitmask | status);
+
+ /* enable edge capture write command */
+ DEBIwrite(dev, LP_MISC1, MISC1_EDCAP);
+
+ /* enable edge capture on selected channel */
+ status = DEBIread(dev,
+ ((struct dio_private *)(dev->subdevices + 2 +
+ group)->private)->RDCapSel);
+ DEBIwrite(dev,
+ ((struct dio_private *)(dev->subdevices + 2 +
+ group)->private)->WRCapSel,
+ bitmask | status);
+
+ return 0;
+}
+
+static int s626_dio_reset_irq(struct comedi_device *dev, unsigned int group,
+ unsigned int mask)
+{
+ /* disable edge capture write command */
+ DEBIwrite(dev, LP_MISC1, MISC1_NOEDCAP);
+
+ /* enable edge capture on selected channel */
+ DEBIwrite(dev,
+ ((struct dio_private *)(dev->subdevices + 2 +
+ group)->private)->WRCapSel, mask);
+
+ return 0;
+}
+
+static int s626_dio_clear_irq(struct comedi_device *dev)
+{
+ unsigned int group;
+
+ /* disable edge capture write command */
+ DEBIwrite(dev, LP_MISC1, MISC1_NOEDCAP);
+
+ for (group = 0; group < S626_DIO_BANKS; group++) {
+ /* clear pending events and interrupt */
+ DEBIwrite(dev,
+ ((struct dio_private *)(dev->subdevices + 2 +
+ group)->private)->WRCapSel,
+ 0xffff);
+ }
+
+ return 0;
+}
+
static irqreturn_t s626_irq_handler(int irq, void *d)
{
struct comedi_device *dev = d;
uint8_t group;
uint16_t irqbit;
- DEBUG("s626_irq_handler: interrupt request received!!!\n");
-
if (dev->attached == 0)
return IRQ_NONE;
/* lock to avoid race with comedi_poll */
/* clear interrupt */
writel(irqtype, devpriv->base_addr + P_ISR);
- /* do somethings */
- DEBUG("s626_irq_handler: interrupt type %d\n", irqtype);
-
switch (irqtype) {
case IRQ_RPS1: /* end_of_scan occurs */
-
- DEBUG("s626_irq_handler: RPS1 irq detected\n");
-
/* manage ai subdevice */
s = dev->subdevices;
cmd = &(s->async->cmd);
if (cfc_write_to_buffer(s, tempdata) == 0)
printk
("s626_irq_handler: cfc_write_to_buffer error!\n");
-
- DEBUG("s626_irq_handler: ai channel %d acquired: %d\n",
- i, tempdata);
}
/* end of scan occurs */
irqstatus = 0;
}
- if (devpriv->ai_cmd_running && cmd->scan_begin_src == TRIG_EXT) {
- DEBUG
- ("s626_irq_handler: enable interrupt on dio channel %d\n",
- cmd->scan_begin_arg);
-
+ if (devpriv->ai_cmd_running && cmd->scan_begin_src == TRIG_EXT)
s626_dio_set_irq(dev, cmd->scan_begin_arg);
-
- DEBUG("s626_irq_handler: External trigger is set!!!\n");
- }
/* tell comedi that data is there */
- DEBUG("s626_irq_handler: events %d\n", s->async->events);
comedi_event(dev, s);
break;
case IRQ_GPIO3: /* check dio and conter interrupt */
-
- DEBUG("s626_irq_handler: GPIO3 irq detected\n");
-
/* manage ai subdevice */
s = dev->subdevices;
cmd = &(s->async->cmd);
/* check if interrupt is generated from dio channels */
if (irqbit) {
s626_dio_reset_irq(dev, group, irqbit);
- DEBUG
- ("s626_irq_handler: check interrupt on dio group %d %d\n",
- group, i);
if (devpriv->ai_cmd_running) {
/* check if interrupt is an ai acquisition start trigger */
if ((irqbit >> (cmd->start_arg -
(16 * group)))
== 1 && cmd->start_src == TRIG_EXT) {
- DEBUG
- ("s626_irq_handler: Edge capture interrupt received from channel %d\n",
- cmd->start_arg);
-
/* Start executing the RPS program. */
MC_ENABLE(P_MC1, MC1_ERPS1);
- DEBUG
- ("s626_irq_handler: acquisition start triggered!!!\n");
-
if (cmd->scan_begin_src ==
TRIG_EXT) {
- DEBUG
- ("s626_ai_cmd: enable interrupt on dio channel %d\n",
- cmd->
- scan_begin_arg);
-
s626_dio_set_irq(dev,
cmd->scan_begin_arg);
-
- DEBUG
- ("s626_irq_handler: External scan trigger is set!!!\n");
}
}
if ((irqbit >> (cmd->scan_begin_arg -
== 1
&& cmd->scan_begin_src ==
TRIG_EXT) {
- DEBUG
- ("s626_irq_handler: Edge capture interrupt received from channel %d\n",
- cmd->scan_begin_arg);
-
/* Trigger ADC scan loop start by setting RPS Signal 0. */
MC_ENABLE(P_MC2, MC2_ADC_RPS);
- DEBUG
- ("s626_irq_handler: scan triggered!!! %d\n",
- devpriv->ai_sample_count);
if (cmd->convert_src ==
TRIG_EXT) {
-
- DEBUG
- ("s626_ai_cmd: enable interrupt on dio channel %d group %d\n",
- cmd->convert_arg -
- (16 * group),
- group);
-
devpriv->ai_convert_count
= cmd->chanlist_len;
s626_dio_set_irq(dev,
cmd->convert_arg);
-
- DEBUG
- ("s626_irq_handler: External convert trigger is set!!!\n");
}
if (cmd->convert_src ==
(16 * group)))
== 1
&& cmd->convert_src == TRIG_EXT) {
- DEBUG
- ("s626_irq_handler: Edge capture interrupt received from channel %d\n",
- cmd->convert_arg);
-
/* Trigger ADC scan loop start by setting RPS Signal 0. */
MC_ENABLE(P_MC2, MC2_ADC_RPS);
- DEBUG
- ("s626_irq_handler: adc convert triggered!!!\n");
-
devpriv->ai_convert_count--;
if (devpriv->ai_convert_count >
0) {
-
- DEBUG
- ("s626_ai_cmd: enable interrupt on dio channel %d group %d\n",
- cmd->convert_arg -
- (16 * group),
- group);
-
s626_dio_set_irq(dev,
cmd->convert_arg);
-
- DEBUG
- ("s626_irq_handler: External trigger is set!!!\n");
}
}
}
irqbit = DEBIread(dev, LP_RDMISC2);
/* check interrupt on counters */
- DEBUG("s626_irq_handler: check counters interrupt %d\n",
- irqbit);
-
if (irqbit & IRQ_COINT1A) {
- DEBUG
- ("s626_irq_handler: interrupt on counter 1A overflow\n");
k = &encpriv[0];
/* clear interrupt capture flag */
k->ResetCapFlags(dev, k);
}
if (irqbit & IRQ_COINT2A) {
- DEBUG
- ("s626_irq_handler: interrupt on counter 2A overflow\n");
k = &encpriv[1];
/* clear interrupt capture flag */
k->ResetCapFlags(dev, k);
}
if (irqbit & IRQ_COINT3A) {
- DEBUG
- ("s626_irq_handler: interrupt on counter 3A overflow\n");
k = &encpriv[2];
/* clear interrupt capture flag */
k->ResetCapFlags(dev, k);
}
if (irqbit & IRQ_COINT1B) {
- DEBUG
- ("s626_irq_handler: interrupt on counter 1B overflow\n");
k = &encpriv[3];
/* clear interrupt capture flag */
k->ResetCapFlags(dev, k);
}
if (irqbit & IRQ_COINT2B) {
- DEBUG
- ("s626_irq_handler: interrupt on counter 2B overflow\n");
k = &encpriv[4];
/* clear interrupt capture flag */
k->SetEnable(dev, k, CLKENAB_INDEX);
if (cmd->convert_src == TRIG_TIMER) {
- DEBUG
- ("s626_irq_handler: conver timer trigger!!! %d\n",
- devpriv->ai_convert_count);
-
/* Trigger ADC scan loop start by setting RPS Signal 0. */
MC_ENABLE(P_MC2, MC2_ADC_RPS);
}
}
}
if (irqbit & IRQ_COINT3B) {
- DEBUG
- ("s626_irq_handler: interrupt on counter 3B overflow\n");
k = &encpriv[5];
/* clear interrupt capture flag */
k->ResetCapFlags(dev, k);
if (cmd->scan_begin_src == TRIG_TIMER) {
- DEBUG
- ("s626_irq_handler: scan timer trigger!!!\n");
-
/* Trigger ADC scan loop start by setting RPS Signal 0. */
MC_ENABLE(P_MC2, MC2_ADC_RPS);
}
if (cmd->convert_src == TRIG_TIMER) {
- DEBUG
- ("s626_irq_handler: convert timer trigger is set\n");
k = &encpriv[4];
devpriv->ai_convert_count = cmd->chanlist_len;
k->SetEnable(dev, k, CLKENAB_ALWAYS);
/* enable interrupt */
writel(irqstatus, devpriv->base_addr + P_IER);
- DEBUG("s626_irq_handler: exit interrupt service routine.\n");
-
spin_unlock_irqrestore(&dev->spinlock, flags);
return IRQ_HANDLED;
}
-static void s626_detach(struct comedi_device *dev)
-{
- if (devpriv) {
- /* stop ai_command */
- devpriv->ai_cmd_running = 0;
-
- if (devpriv->base_addr) {
- /* interrupt mask */
- WR7146(P_IER, 0); /* Disable master interrupt. */
- WR7146(P_ISR, IRQ_GPIO3 | IRQ_RPS1); /* Clear board's IRQ status flag. */
-
- /* Disable the watchdog timer and battery charger. */
- WriteMISC2(dev, 0);
-
- /* Close all interfaces on 7146 device. */
- WR7146(P_MC1, MC1_SHUTDOWN);
- WR7146(P_ACON1, ACON1_BASE);
-
- CloseDMAB(dev, &devpriv->RPSBuf, DMABUF_SIZE);
- CloseDMAB(dev, &devpriv->ANABuf, DMABUF_SIZE);
- }
-
- if (dev->irq)
- free_irq(dev->irq, dev);
- if (devpriv->base_addr)
- iounmap(devpriv->base_addr);
- if (devpriv->pdev) {
- if (devpriv->got_regions)
- comedi_pci_disable(devpriv->pdev);
- pci_dev_put(devpriv->pdev);
- }
- }
-}
-
/*
* this functions build the RPS program for hardware driven acquistion
*/
-void ResetADC(struct comedi_device *dev, uint8_t * ppl)
+static void ResetADC(struct comedi_device *dev, uint8_t *ppl)
{
register uint32_t *pRPS;
uint32_t JmpAdrs;
/* Construct RPS program in RPSBuf DMA buffer */
if (cmd != NULL && cmd->scan_begin_src != TRIG_FOLLOW) {
- DEBUG("ResetADC: scan_begin pause inserted\n");
/* Wait for Start trigger. */
*pRPS++ = RPS_PAUSE | RPS_SIGADC;
*pRPS++ = RPS_CLRSIGNAL | RPS_SIGADC;
}
if (cmd != NULL && cmd->convert_src != TRIG_NOW) {
- DEBUG("ResetADC: convert pause inserted\n");
/* Wait for Start trigger. */
*pRPS++ = RPS_PAUSE | RPS_SIGADC;
*pRPS++ = RPS_CLRSIGNAL | RPS_SIGADC;
break; /* Exit poll list processing loop. */
}
}
- DEBUG("ResetADC: ADC items %d\n", devpriv->AdcItems);
/* VERSION 2.01 CHANGE: DELAY CHANGED FROM 250NS to 2US. Allow the
* ADC to stabilize for 2 microseconds before starting the final
/* invoke interrupt */
if (devpriv->ai_cmd_running == 1) {
- DEBUG("ResetADC: insert irq in ADC RPS task\n");
*pRPS++ = RPS_IRQ;
}
/* Restart RPS program at its beginning. */
/* register uint8_t i; */
/* register int32_t *readaddr; */
-/* DEBUG("as626_ai_rinsn: ai_rinsn enter\n"); */
-
/* Trigger ADC scan loop start by setting RPS Signal 0. */
/* MC_ENABLE( P_MC2, MC2_ADC_RPS ); */
/* Convert ADC data to 16-bit integer values and copy to application buffer. */
/* for ( i = 0; i < devpriv->AdcItems; i++ ) { */
/* *data = s626_ai_reg_to_uint( *readaddr++ ); */
-/* DEBUG("s626_ai_rinsn: data %d\n",*data); */
/* data++; */
/* } */
-/* DEBUG("s626_ai_rinsn: ai_rinsn escape\n"); */
/* return i; */
/* } */
* corresponding interrupt to be generated if enabled
*/
- DEBUG("s626_ai_insn_read: entering\n");
-
/* Convert application's ADC specification into form
* appropriate for register programming.
*/
if (n != 0)
data[n - 1] = s626_ai_reg_to_uint(RR7146(P_FB_BUFFER1));
- DEBUG("s626_ai_insn_read: samples %d, data %d\n", n, data[n - 1]);
-
return n;
}
if (trignum != 0)
return -EINVAL;
- DEBUG("s626_ai_inttrig: trigger adc start...");
-
/* Start executing the RPS program. */
MC_ENABLE(P_MC1, MC1_ERPS1);
s->async->inttrig = NULL;
- DEBUG(" done\n");
-
return 1;
}
+/* This function doesn't require a particular form, this is just what
+ * happens to be used in some of the drivers. It should convert ns
+ * nanoseconds to a counter value suitable for programming the device.
+ * Also, it should adjust ns so that it cooresponds to the actual time
+ * that the device will use. */
+static int s626_ns_to_timer(int *nanosec, int round_mode)
+{
+ int divider, base;
+
+ base = 500; /* 2MHz internal clock */
+
+ switch (round_mode) {
+ case TRIG_ROUND_NEAREST:
+ default:
+ divider = (*nanosec + base / 2) / base;
+ break;
+ case TRIG_ROUND_DOWN:
+ divider = (*nanosec) / base;
+ break;
+ case TRIG_ROUND_UP:
+ divider = (*nanosec + base - 1) / base;
+ break;
+ }
+
+ *nanosec = base * divider;
+ return divider - 1;
+}
+
+static void s626_timer_load(struct comedi_device *dev, struct enc_private *k,
+ int tick)
+{
+ uint16_t Setup = (LOADSRC_INDX << BF_LOADSRC) | /* Preload upon */
+ /* index. */
+ (INDXSRC_SOFT << BF_INDXSRC) | /* Disable hardware index. */
+ (CLKSRC_TIMER << BF_CLKSRC) | /* Operating mode is Timer. */
+ (CLKPOL_POS << BF_CLKPOL) | /* Active high clock. */
+ (CNTDIR_DOWN << BF_CLKPOL) | /* Count direction is Down. */
+ (CLKMULT_1X << BF_CLKMULT) | /* Clock multiplier is 1x. */
+ (CLKENAB_INDEX << BF_CLKENAB);
+ uint16_t valueSrclatch = LATCHSRC_A_INDXA;
+ /* uint16_t enab=CLKENAB_ALWAYS; */
+
+ k->SetMode(dev, k, Setup, FALSE);
+
+ /* Set the preload register */
+ Preload(dev, k, tick);
+
+ /* Software index pulse forces the preload register to load */
+ /* into the counter */
+ k->SetLoadTrig(dev, k, 0);
+ k->PulseIndex(dev, k);
+
+ /* set reload on counter overflow */
+ k->SetLoadTrig(dev, k, 1);
+
+ /* set interrupt on overflow */
+ k->SetIntSrc(dev, k, INTSRC_OVER);
+
+ SetLatchSource(dev, k, valueSrclatch);
+ /* k->SetEnable(dev,k,(uint16_t)(enab != 0)); */
+}
+
/* TO COMPLETE */
static int s626_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
{
struct enc_private *k;
int tick;
- DEBUG("s626_ai_cmd: entering command function\n");
-
if (devpriv->ai_cmd_running) {
printk(KERN_ERR "s626_ai_cmd: Another ai_cmd is running %d\n",
dev->minor);
devpriv->ai_cmd_running = 0;
/* test if cmd is valid */
- if (cmd == NULL) {
- DEBUG("s626_ai_cmd: NULL command\n");
+ if (cmd == NULL)
return -EINVAL;
- } else {
- DEBUG("s626_ai_cmd: command received!!!\n");
- }
if (dev->irq == 0) {
comedi_error(dev,
/* load timer value and enable interrupt */
s626_timer_load(dev, k, tick);
k->SetEnable(dev, k, CLKENAB_ALWAYS);
-
- DEBUG("s626_ai_cmd: scan trigger timer is set with value %d\n",
- tick);
-
break;
case TRIG_EXT:
/* set the digital line and interrupt for scan trigger */
if (cmd->start_src != TRIG_EXT)
s626_dio_set_irq(dev, cmd->scan_begin_arg);
-
- DEBUG("s626_ai_cmd: External scan trigger is set!!!\n");
-
break;
}
/* load timer value and enable interrupt */
s626_timer_load(dev, k, tick);
k->SetEnable(dev, k, CLKENAB_INDEX);
-
- DEBUG
- ("s626_ai_cmd: convert trigger timer is set with value %d\n",
- tick);
break;
case TRIG_EXT:
/* set the digital line and interrupt for convert trigger */
if (cmd->scan_begin_src != TRIG_EXT
&& cmd->start_src == TRIG_EXT)
s626_dio_set_irq(dev, cmd->convert_arg);
-
- DEBUG("s626_ai_cmd: External convert trigger is set!!!\n");
-
break;
}
/* Start executing the RPS program. */
MC_ENABLE(P_MC1, MC1_ERPS1);
- DEBUG("s626_ai_cmd: ADC triggered\n");
s->async->inttrig = NULL;
break;
case TRIG_EXT:
/* configure DIO channel for acquisition trigger */
s626_dio_set_irq(dev, cmd->start_arg);
- DEBUG("s626_ai_cmd: External start trigger is set!!!\n");
-
s->async->inttrig = NULL;
break;
case TRIG_INT:
/* enable interrupt */
writel(IRQ_GPIO3 | IRQ_RPS1, devpriv->base_addr + P_IER);
- DEBUG("s626_ai_cmd: command function terminated\n");
-
return 0;
}
return 0;
}
-/* This function doesn't require a particular form, this is just what
- * happens to be used in some of the drivers. It should convert ns
- * nanoseconds to a counter value suitable for programming the device.
- * Also, it should adjust ns so that it cooresponds to the actual time
- * that the device will use. */
-static int s626_ns_to_timer(int *nanosec, int round_mode)
-{
- int divider, base;
-
- base = 500; /* 2MHz internal clock */
-
- switch (round_mode) {
- case TRIG_ROUND_NEAREST:
- default:
- divider = (*nanosec + base / 2) / base;
- break;
- case TRIG_ROUND_DOWN:
- divider = (*nanosec) / base;
- break;
- case TRIG_ROUND_UP:
- divider = (*nanosec + base - 1) / base;
- break;
- }
-
- *nanosec = base * divider;
- return divider - 1;
-}
-
static int s626_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
DEBIwrite(dev, diopriv->WRDOut, 0); /* Program all outputs */
/* to inactive state. */
}
- DEBUG("s626_dio_init: DIO initialized\n");
}
/* DIO devices are slightly special. Although it is possible to
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
-
- /* Length of data must be 2 (mask and new data, see below) */
- if (insn->n == 0)
- return 0;
-
- if (insn->n != 2) {
- printk
- ("comedi%d: s626: s626_dio_insn_bits(): Invalid instruction length\n",
- dev->minor);
- return -EINVAL;
- }
-
/*
* The insn data consists of a mask in data[0] and the new data in
* data[1]. The mask defines which bits we are concerning about.
}
data[1] = DEBIread(dev, diopriv->RDDIn);
- return 2;
+ return insn->n;
}
static int s626_dio_insn_config(struct comedi_device *dev,
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
-{
-
- switch (data[0]) {
- case INSN_CONFIG_DIO_QUERY:
- data[1] =
- (s->
- io_bits & (1 << CR_CHAN(insn->chanspec))) ? COMEDI_OUTPUT :
- COMEDI_INPUT;
- return insn->n;
- break;
- case COMEDI_INPUT:
- s->io_bits &= ~(1 << CR_CHAN(insn->chanspec));
- break;
- case COMEDI_OUTPUT:
- s->io_bits |= 1 << CR_CHAN(insn->chanspec);
- break;
- default:
- return -EINVAL;
- break;
- }
- DEBIwrite(dev, diopriv->WRDOut, s->io_bits);
-
- return 1;
-}
-
-static int s626_dio_set_irq(struct comedi_device *dev, unsigned int chan)
-{
- unsigned int group;
- unsigned int bitmask;
- unsigned int status;
-
- /* select dio bank */
- group = chan / 16;
- bitmask = 1 << (chan - (16 * group));
- DEBUG("s626_dio_set_irq: enable interrupt on dio channel %d group %d\n",
- chan - (16 * group), group);
-
- /* set channel to capture positive edge */
- status = DEBIread(dev,
- ((struct dio_private *)(dev->subdevices + 2 +
- group)->private)->RDEdgSel);
- DEBIwrite(dev,
- ((struct dio_private *)(dev->subdevices + 2 +
- group)->private)->WREdgSel,
- bitmask | status);
-
- /* enable interrupt on selected channel */
- status = DEBIread(dev,
- ((struct dio_private *)(dev->subdevices + 2 +
- group)->private)->RDIntSel);
- DEBIwrite(dev,
- ((struct dio_private *)(dev->subdevices + 2 +
- group)->private)->WRIntSel,
- bitmask | status);
-
- /* enable edge capture write command */
- DEBIwrite(dev, LP_MISC1, MISC1_EDCAP);
-
- /* enable edge capture on selected channel */
- status = DEBIread(dev,
- ((struct dio_private *)(dev->subdevices + 2 +
- group)->private)->RDCapSel);
- DEBIwrite(dev,
- ((struct dio_private *)(dev->subdevices + 2 +
- group)->private)->WRCapSel,
- bitmask | status);
-
- return 0;
-}
-
-static int s626_dio_reset_irq(struct comedi_device *dev, unsigned int group,
- unsigned int mask)
-{
- DEBUG
- ("s626_dio_reset_irq: disable interrupt on dio channel %d group %d\n",
- mask, group);
-
- /* disable edge capture write command */
- DEBIwrite(dev, LP_MISC1, MISC1_NOEDCAP);
-
- /* enable edge capture on selected channel */
- DEBIwrite(dev,
- ((struct dio_private *)(dev->subdevices + 2 +
- group)->private)->WRCapSel, mask);
-
- return 0;
-}
-
-static int s626_dio_clear_irq(struct comedi_device *dev)
-{
- unsigned int group;
-
- /* disable edge capture write command */
- DEBIwrite(dev, LP_MISC1, MISC1_NOEDCAP);
-
- for (group = 0; group < S626_DIO_BANKS; group++) {
- /* clear pending events and interrupt */
- DEBIwrite(dev,
- ((struct dio_private *)(dev->subdevices + 2 +
- group)->private)->WRCapSel,
- 0xffff);
+{
+
+ switch (data[0]) {
+ case INSN_CONFIG_DIO_QUERY:
+ data[1] =
+ (s->
+ io_bits & (1 << CR_CHAN(insn->chanspec))) ? COMEDI_OUTPUT :
+ COMEDI_INPUT;
+ return insn->n;
+ break;
+ case COMEDI_INPUT:
+ s->io_bits &= ~(1 << CR_CHAN(insn->chanspec));
+ break;
+ case COMEDI_OUTPUT:
+ s->io_bits |= 1 << CR_CHAN(insn->chanspec);
+ break;
+ default:
+ return -EINVAL;
+ break;
}
+ DEBIwrite(dev, diopriv->WRDOut, s->io_bits);
- return 0;
+ return 1;
}
/* Now this function initializes the value of the counter (data[0])
uint16_t enab = CLKENAB_ALWAYS;
struct enc_private *k = &encpriv[CR_CHAN(insn->chanspec)];
- DEBUG("s626_enc_insn_config: encoder config\n");
-
/* (data==NULL) ? (Preloadvalue=0) : (Preloadvalue=data[0]); */
k->SetMode(dev, k, Setup, TRUE);
int n;
struct enc_private *k = &encpriv[CR_CHAN(insn->chanspec)];
- DEBUG("s626_enc_insn_read: encoder read channel %d\n",
- CR_CHAN(insn->chanspec));
-
for (n = 0; n < insn->n; n++)
data[n] = ReadLatch(dev, k);
- DEBUG("s626_enc_insn_read: encoder sample %d\n", data[n]);
-
return n;
}
struct enc_private *k = &encpriv[CR_CHAN(insn->chanspec)];
- DEBUG("s626_enc_insn_write: encoder write channel %d\n",
- CR_CHAN(insn->chanspec));
-
/* Set the preload register */
Preload(dev, k, data[0]);
k->PulseIndex(dev, k);
k->SetLoadTrig(dev, k, 2);
- DEBUG("s626_enc_insn_write: End encoder write\n");
-
return 1;
}
-static void s626_timer_load(struct comedi_device *dev, struct enc_private *k,
- int tick)
+static void WriteMISC2(struct comedi_device *dev, uint16_t NewImage)
{
- uint16_t Setup = (LOADSRC_INDX << BF_LOADSRC) | /* Preload upon */
- /* index. */
- (INDXSRC_SOFT << BF_INDXSRC) | /* Disable hardware index. */
- (CLKSRC_TIMER << BF_CLKSRC) | /* Operating mode is Timer. */
- (CLKPOL_POS << BF_CLKPOL) | /* Active high clock. */
- (CNTDIR_DOWN << BF_CLKPOL) | /* Count direction is Down. */
- (CLKMULT_1X << BF_CLKMULT) | /* Clock multiplier is 1x. */
- (CLKENAB_INDEX << BF_CLKENAB);
- uint16_t valueSrclatch = LATCHSRC_A_INDXA;
- /* uint16_t enab=CLKENAB_ALWAYS; */
-
- k->SetMode(dev, k, Setup, FALSE);
-
- /* Set the preload register */
- Preload(dev, k, tick);
-
- /* Software index pulse forces the preload register to load */
- /* into the counter */
- k->SetLoadTrig(dev, k, 0);
- k->PulseIndex(dev, k);
+ DEBIwrite(dev, LP_MISC1, MISC1_WENABLE); /* enab writes to */
+ /* MISC2 register. */
+ DEBIwrite(dev, LP_WRMISC2, NewImage); /* Write new image to MISC2. */
+ DEBIwrite(dev, LP_MISC1, MISC1_WDISABLE); /* Disable writes to MISC2. */
+}
- /* set reload on counter overflow */
- k->SetLoadTrig(dev, k, 1);
+static void CloseDMAB(struct comedi_device *dev, struct bufferDMA *pdma,
+ size_t bsize)
+{
+ void *vbptr;
+ dma_addr_t vpptr;
- /* set interrupt on overflow */
- k->SetIntSrc(dev, k, INTSRC_OVER);
+ if (pdma == NULL)
+ return;
+ /* find the matching allocation from the board struct */
- SetLatchSource(dev, k, valueSrclatch);
- /* k->SetEnable(dev,k,(uint16_t)(enab != 0)); */
+ vbptr = pdma->LogicalBase;
+ vpptr = pdma->PhysicalBase;
+ if (vbptr) {
+ pci_free_consistent(devpriv->pdev, bsize, vbptr, vpptr);
+ pdma->LogicalBase = NULL;
+ pdma->PhysicalBase = 0;
+ }
}
-/* *********** DAC FUNCTIONS *********** */
-
-/* Slot 0 base settings. */
-#define VECT0 (XSD2 | RSD3 | SIB_A2)
-/* Slot 0 always shifts in 0xFF and store it to FB_BUFFER2. */
-
-/* TrimDac LogicalChan-to-PhysicalChan mapping table. */
-static uint8_t trimchan[] = { 10, 9, 8, 3, 2, 7, 6, 1, 0, 5, 4 };
+/* ****** PRIVATE COUNTER FUNCTIONS ****** */
-/* TrimDac LogicalChan-to-EepromAdrs mapping table. */
-static uint8_t trimadrs[] = { 0x40, 0x41, 0x42, 0x50, 0x51, 0x52, 0x53, 0x60, 0x61, 0x62, 0x63 };
+/* Reset a counter's index and overflow event capture flags. */
-static void LoadTrimDACs(struct comedi_device *dev)
+static void ResetCapFlags_A(struct comedi_device *dev, struct enc_private *k)
{
- register uint8_t i;
-
- /* Copy TrimDac setpoint values from EEPROM to TrimDacs. */
- for (i = 0; i < ARRAY_SIZE(trimchan); i++)
- WriteTrimDAC(dev, i, I2Cread(dev, trimadrs[i]));
+ DEBIreplace(dev, k->MyCRB, (uint16_t) (~CRBMSK_INTCTRL),
+ CRBMSK_INTRESETCMD | CRBMSK_INTRESET_A);
}
-static void WriteTrimDAC(struct comedi_device *dev, uint8_t LogicalChan,
- uint8_t DacData)
+static void ResetCapFlags_B(struct comedi_device *dev, struct enc_private *k)
{
- uint32_t chan;
-
- /* Save the new setpoint in case the application needs to read it back later. */
- devpriv->TrimSetpoint[LogicalChan] = (uint8_t) DacData;
-
- /* Map logical channel number to physical channel number. */
- chan = (uint32_t) trimchan[LogicalChan];
-
- /* Set up TSL2 records for TrimDac write operation. All slots shift
- * 0xFF in from pulled-up SD3 so that the end of the slot sequence
- * can be detected.
- */
-
- SETVECT(2, XSD2 | XFIFO_1 | WS3);
- /* Slot 2: Send high uint8_t to target TrimDac. */
- SETVECT(3, XSD2 | XFIFO_0 | WS3);
- /* Slot 3: Send low uint8_t to target TrimDac. */
- SETVECT(4, XSD2 | XFIFO_3 | WS1);
- /* Slot 4: Send NOP high uint8_t to DAC0 to keep clock running. */
- SETVECT(5, XSD2 | XFIFO_2 | WS1 | EOS);
- /* Slot 5: Send NOP low uint8_t to DAC0. */
-
- /* Construct and transmit target DAC's serial packet:
- * ( 0000 AAAA ), ( DDDD DDDD ),( 0x00 ),( 0x00 ) where A<3:0> is the
- * DAC channel's address, and D<7:0> is the DAC setpoint. Append a
- * WORD value (that writes a channel 0 NOP command to a non-existent
- * main DAC channel) that serves to keep the clock running after the
- * packet has been sent to the target DAC.
- */
-
- /* Address the DAC channel within the trimdac device. */
- SendDAC(dev, ((uint32_t) chan << 8)
- | (uint32_t) DacData); /* Include DAC setpoint data. */
+ DEBIreplace(dev, k->MyCRB, (uint16_t) (~CRBMSK_INTCTRL),
+ CRBMSK_INTRESETCMD | CRBMSK_INTRESET_B);
}
-/* ************** EEPROM ACCESS FUNCTIONS ************** */
-/* Read uint8_t from EEPROM. */
-
-static uint8_t I2Cread(struct comedi_device *dev, uint8_t addr)
-{
- uint8_t rtnval;
-
- /* Send EEPROM target address. */
- if (I2Chandshake(dev, I2C_B2(I2C_ATTRSTART, I2CW)
- /* Byte2 = I2C command: write to I2C EEPROM device. */
- | I2C_B1(I2C_ATTRSTOP, addr)
- /* Byte1 = EEPROM internal target address. */
- | I2C_B0(I2C_ATTRNOP, 0))) { /* Byte0 = Not sent. */
- /* Abort function and declare error if handshake failed. */
- DEBUG("I2Cread: error handshake I2Cread a\n");
- return 0;
- }
- /* Execute EEPROM read. */
- if (I2Chandshake(dev, I2C_B2(I2C_ATTRSTART, I2CR)
-
- /* Byte2 = I2C */
- /* command: read */
- /* from I2C EEPROM */
- /* device. */
- |I2C_B1(I2C_ATTRSTOP, 0)
-
- /* Byte1 receives */
- /* uint8_t from */
- /* EEPROM. */
- |I2C_B0(I2C_ATTRNOP, 0))) { /* Byte0 = Not sent. */
-
- /* Abort function and declare error if handshake failed. */
- DEBUG("I2Cread: error handshake I2Cread b\n");
- return 0;
- }
- /* Return copy of EEPROM value. */
- rtnval = (uint8_t) (RR7146(P_I2CCTRL) >> 16);
- return rtnval;
-}
+/* Return counter setup in a format (COUNTER_SETUP) that is consistent */
+/* for both A and B counters. */
-static uint32_t I2Chandshake(struct comedi_device *dev, uint32_t val)
+static uint16_t GetMode_A(struct comedi_device *dev, struct enc_private *k)
{
- /* Write I2C command to I2C Transfer Control shadow register. */
- WR7146(P_I2CCTRL, val);
+ register uint16_t cra;
+ register uint16_t crb;
+ register uint16_t setup;
- /* Upload I2C shadow registers into working registers and wait for */
- /* upload confirmation. */
+ /* Fetch CRA and CRB register images. */
+ cra = DEBIread(dev, k->MyCRA);
+ crb = DEBIread(dev, k->MyCRB);
- MC_ENABLE(P_MC2, MC2_UPLD_IIC);
- while (!MC_TEST(P_MC2, MC2_UPLD_IIC))
- ;
+ /* Populate the standardized counter setup bit fields. Note: */
+ /* IndexSrc is restricted to ENC_X or IndxPol. */
+ setup = ((cra & STDMSK_LOADSRC) /* LoadSrc = LoadSrcA. */
+ |((crb << (STDBIT_LATCHSRC - CRBBIT_LATCHSRC)) & STDMSK_LATCHSRC) /* LatchSrc = LatchSrcA. */
+ |((cra << (STDBIT_INTSRC - CRABIT_INTSRC_A)) & STDMSK_INTSRC) /* IntSrc = IntSrcA. */
+ |((cra << (STDBIT_INDXSRC - (CRABIT_INDXSRC_A + 1))) & STDMSK_INDXSRC) /* IndxSrc = IndxSrcA<1>. */
+ |((cra >> (CRABIT_INDXPOL_A - STDBIT_INDXPOL)) & STDMSK_INDXPOL) /* IndxPol = IndxPolA. */
+ |((crb >> (CRBBIT_CLKENAB_A - STDBIT_CLKENAB)) & STDMSK_CLKENAB)); /* ClkEnab = ClkEnabA. */
- /* Wait until I2C bus transfer is finished or an error occurs. */
- while ((RR7146(P_I2CCTRL) & (I2C_BUSY | I2C_ERR)) == I2C_BUSY)
- ;
+ /* Adjust mode-dependent parameters. */
+ if (cra & (2 << CRABIT_CLKSRC_A)) /* If Timer mode (ClkSrcA<1> == 1): */
+ setup |= ((CLKSRC_TIMER << STDBIT_CLKSRC) /* Indicate Timer mode. */
+ |((cra << (STDBIT_CLKPOL - CRABIT_CLKSRC_A)) & STDMSK_CLKPOL) /* Set ClkPol to indicate count direction (ClkSrcA<0>). */
+ |(MULT_X1 << STDBIT_CLKMULT)); /* ClkMult must be 1x in Timer mode. */
- /* Return non-zero if I2C error occurred. */
- return RR7146(P_I2CCTRL) & I2C_ERR;
+ else /* If Counter mode (ClkSrcA<1> == 0): */
+ setup |= ((CLKSRC_COUNTER << STDBIT_CLKSRC) /* Indicate Counter mode. */
+ |((cra >> (CRABIT_CLKPOL_A - STDBIT_CLKPOL)) & STDMSK_CLKPOL) /* Pass through ClkPol. */
+ |(((cra & CRAMSK_CLKMULT_A) == (MULT_X0 << CRABIT_CLKMULT_A)) ? /* Force ClkMult to 1x if not legal, else pass through. */
+ (MULT_X1 << STDBIT_CLKMULT) :
+ ((cra >> (CRABIT_CLKMULT_A -
+ STDBIT_CLKMULT)) & STDMSK_CLKMULT)));
+ /* Return adjusted counter setup. */
+ return setup;
}
-/* Private helper function: Write setpoint to an application DAC channel. */
-
-static void SetDAC(struct comedi_device *dev, uint16_t chan, short dacdata)
+static uint16_t GetMode_B(struct comedi_device *dev, struct enc_private *k)
{
- register uint16_t signmask;
- register uint32_t WSImage;
-
- /* Adjust DAC data polarity and set up Polarity Control Register */
- /* image. */
- signmask = 1 << chan;
- if (dacdata < 0) {
- dacdata = -dacdata;
- devpriv->Dacpol |= signmask;
- } else
- devpriv->Dacpol &= ~signmask;
+ register uint16_t cra;
+ register uint16_t crb;
+ register uint16_t setup;
- /* Limit DAC setpoint value to valid range. */
- if ((uint16_t) dacdata > 0x1FFF)
- dacdata = 0x1FFF;
+ /* Fetch CRA and CRB register images. */
+ cra = DEBIread(dev, k->MyCRA);
+ crb = DEBIread(dev, k->MyCRB);
- /* Set up TSL2 records (aka "vectors") for DAC update. Vectors V2
- * and V3 transmit the setpoint to the target DAC. V4 and V5 send
- * data to a non-existent TrimDac channel just to keep the clock
- * running after sending data to the target DAC. This is necessary
- * to eliminate the clock glitch that would otherwise occur at the
- * end of the target DAC's serial data stream. When the sequence
- * restarts at V0 (after executing V5), the gate array automatically
- * disables gating for the DAC clock and all DAC chip selects.
- */
+ /* Populate the standardized counter setup bit fields. Note: */
+ /* IndexSrc is restricted to ENC_X or IndxPol. */
+ setup = (((crb << (STDBIT_INTSRC - CRBBIT_INTSRC_B)) & STDMSK_INTSRC) /* IntSrc = IntSrcB. */
+ |((crb << (STDBIT_LATCHSRC - CRBBIT_LATCHSRC)) & STDMSK_LATCHSRC) /* LatchSrc = LatchSrcB. */
+ |((crb << (STDBIT_LOADSRC - CRBBIT_LOADSRC_B)) & STDMSK_LOADSRC) /* LoadSrc = LoadSrcB. */
+ |((crb << (STDBIT_INDXPOL - CRBBIT_INDXPOL_B)) & STDMSK_INDXPOL) /* IndxPol = IndxPolB. */
+ |((crb >> (CRBBIT_CLKENAB_B - STDBIT_CLKENAB)) & STDMSK_CLKENAB) /* ClkEnab = ClkEnabB. */
+ |((cra >> ((CRABIT_INDXSRC_B + 1) - STDBIT_INDXSRC)) & STDMSK_INDXSRC)); /* IndxSrc = IndxSrcB<1>. */
- WSImage = (chan & 2) ? WS1 : WS2;
- /* Choose DAC chip select to be asserted. */
- SETVECT(2, XSD2 | XFIFO_1 | WSImage);
- /* Slot 2: Transmit high data byte to target DAC. */
- SETVECT(3, XSD2 | XFIFO_0 | WSImage);
- /* Slot 3: Transmit low data byte to target DAC. */
- SETVECT(4, XSD2 | XFIFO_3 | WS3);
- /* Slot 4: Transmit to non-existent TrimDac channel to keep clock */
- SETVECT(5, XSD2 | XFIFO_2 | WS3 | EOS);
- /* Slot 5: running after writing target DAC's low data byte. */
+ /* Adjust mode-dependent parameters. */
+ if ((crb & CRBMSK_CLKMULT_B) == (MULT_X0 << CRBBIT_CLKMULT_B)) /* If Extender mode (ClkMultB == MULT_X0): */
+ setup |= ((CLKSRC_EXTENDER << STDBIT_CLKSRC) /* Indicate Extender mode. */
+ |(MULT_X1 << STDBIT_CLKMULT) /* Indicate multiplier is 1x. */
+ |((cra >> (CRABIT_CLKSRC_B - STDBIT_CLKPOL)) & STDMSK_CLKPOL)); /* Set ClkPol equal to Timer count direction (ClkSrcB<0>). */
- /* Construct and transmit target DAC's serial packet:
- * ( A10D DDDD ),( DDDD DDDD ),( 0x0F ),( 0x00 ) where A is chan<0>,
- * and D<12:0> is the DAC setpoint. Append a WORD value (that writes
- * to a non-existent TrimDac channel) that serves to keep the clock
- * running after the packet has been sent to the target DAC.
- */
- SendDAC(dev, 0x0F000000
- /* Continue clock after target DAC data (write to non-existent trimdac). */
- | 0x00004000
- /* Address the two main dual-DAC devices (TSL's chip select enables
- * target device). */
- | ((uint32_t) (chan & 1) << 15)
- /* Address the DAC channel within the device. */
- | (uint32_t) dacdata); /* Include DAC setpoint data. */
+ else if (cra & (2 << CRABIT_CLKSRC_B)) /* If Timer mode (ClkSrcB<1> == 1): */
+ setup |= ((CLKSRC_TIMER << STDBIT_CLKSRC) /* Indicate Timer mode. */
+ |(MULT_X1 << STDBIT_CLKMULT) /* Indicate multiplier is 1x. */
+ |((cra >> (CRABIT_CLKSRC_B - STDBIT_CLKPOL)) & STDMSK_CLKPOL)); /* Set ClkPol equal to Timer count direction (ClkSrcB<0>). */
+
+ else /* If Counter mode (ClkSrcB<1> == 0): */
+ setup |= ((CLKSRC_COUNTER << STDBIT_CLKSRC) /* Indicate Timer mode. */
+ |((crb >> (CRBBIT_CLKMULT_B - STDBIT_CLKMULT)) & STDMSK_CLKMULT) /* Clock multiplier is passed through. */
+ |((crb << (STDBIT_CLKPOL - CRBBIT_CLKPOL_B)) & STDMSK_CLKPOL)); /* Clock polarity is passed through. */
+ /* Return adjusted counter setup. */
+ return setup;
}
-/* Private helper function: Transmit serial data to DAC via Audio
- * channel 2. Assumes: (1) TSL2 slot records initialized, and (2)
- * Dacpol contains valid target image.
+/*
+ * Set the operating mode for the specified counter. The setup
+ * parameter is treated as a COUNTER_SETUP data type. The following
+ * parameters are programmable (all other parms are ignored): ClkMult,
+ * ClkPol, ClkEnab, IndexSrc, IndexPol, LoadSrc.
*/
-static void SendDAC(struct comedi_device *dev, uint32_t val)
+static void SetMode_A(struct comedi_device *dev, struct enc_private *k,
+ uint16_t Setup, uint16_t DisableIntSrc)
{
+ register uint16_t cra;
+ register uint16_t crb;
+ register uint16_t setup = Setup; /* Cache the Standard Setup. */
- /* START THE SERIAL CLOCK RUNNING ------------- */
+ /* Initialize CRA and CRB images. */
+ cra = ((setup & CRAMSK_LOADSRC_A) /* Preload trigger is passed through. */
+ |((setup & STDMSK_INDXSRC) >> (STDBIT_INDXSRC - (CRABIT_INDXSRC_A + 1)))); /* IndexSrc is restricted to ENC_X or IndxPol. */
- /* Assert DAC polarity control and enable gating of DAC serial clock
- * and audio bit stream signals. At this point in time we must be
- * assured of being in time slot 0. If we are not in slot 0, the
- * serial clock and audio stream signals will be disabled; this is
- * because the following DEBIwrite statement (which enables signals
- * to be passed through the gate array) would execute before the
- * trailing edge of WS1/WS3 (which turns off the signals), thus
- * causing the signals to be inactive during the DAC write.
- */
- DEBIwrite(dev, LP_DACPOL, devpriv->Dacpol);
+ crb = (CRBMSK_INTRESETCMD | CRBMSK_INTRESET_A /* Reset any pending CounterA event captures. */
+ | ((setup & STDMSK_CLKENAB) << (CRBBIT_CLKENAB_A - STDBIT_CLKENAB))); /* Clock enable is passed through. */
- /* TRANSFER OUTPUT DWORD VALUE INTO A2'S OUTPUT FIFO ---------------- */
+ /* Force IntSrc to Disabled if DisableIntSrc is asserted. */
+ if (!DisableIntSrc)
+ cra |= ((setup & STDMSK_INTSRC) >> (STDBIT_INTSRC -
+ CRABIT_INTSRC_A));
- /* Copy DAC setpoint value to DAC's output DMA buffer. */
+ /* Populate all mode-dependent attributes of CRA & CRB images. */
+ switch ((setup & STDMSK_CLKSRC) >> STDBIT_CLKSRC) {
+ case CLKSRC_EXTENDER: /* Extender Mode: Force to Timer mode */
+ /* (Extender valid only for B counters). */
- /* WR7146( (uint32_t)devpriv->pDacWBuf, val ); */
- *devpriv->pDacWBuf = val;
+ case CLKSRC_TIMER: /* Timer Mode: */
+ cra |= ((2 << CRABIT_CLKSRC_A) /* ClkSrcA<1> selects system clock */
+ |((setup & STDMSK_CLKPOL) >> (STDBIT_CLKPOL - CRABIT_CLKSRC_A)) /* with count direction (ClkSrcA<0>) obtained from ClkPol. */
+ |(1 << CRABIT_CLKPOL_A) /* ClkPolA behaves as always-on clock enable. */
+ |(MULT_X1 << CRABIT_CLKMULT_A)); /* ClkMult must be 1x. */
+ break;
- /* enab the output DMA transfer. This will cause the DMAC to copy
- * the DAC's data value to A2's output FIFO. The DMA transfer will
- * then immediately terminate because the protection address is
- * reached upon transfer of the first DWORD value.
- */
- MC_ENABLE(P_MC1, MC1_A2OUT);
+ default: /* Counter Mode: */
+ cra |= (CLKSRC_COUNTER /* Select ENC_C and ENC_D as clock/direction inputs. */
+ | ((setup & STDMSK_CLKPOL) << (CRABIT_CLKPOL_A - STDBIT_CLKPOL)) /* Clock polarity is passed through. */
+ |(((setup & STDMSK_CLKMULT) == (MULT_X0 << STDBIT_CLKMULT)) ? /* Force multiplier to x1 if not legal, otherwise pass through. */
+ (MULT_X1 << CRABIT_CLKMULT_A) :
+ ((setup & STDMSK_CLKMULT) << (CRABIT_CLKMULT_A -
+ STDBIT_CLKMULT))));
+ }
- /* While the DMA transfer is executing ... */
+ /* Force positive index polarity if IndxSrc is software-driven only, */
+ /* otherwise pass it through. */
+ if (~setup & STDMSK_INDXSRC)
+ cra |= ((setup & STDMSK_INDXPOL) << (CRABIT_INDXPOL_A -
+ STDBIT_INDXPOL));
- /* Reset Audio2 output FIFO's underflow flag (along with any other
- * FIFO underflow/overflow flags). When set, this flag will
- * indicate that we have emerged from slot 0.
- */
- WR7146(P_ISR, ISR_AFOU);
+ /* If IntSrc has been forced to Disabled, update the MISC2 interrupt */
+ /* enable mask to indicate the counter interrupt is disabled. */
+ if (DisableIntSrc)
+ devpriv->CounterIntEnabs &= ~k->MyEventBits[3];
- /* Wait for the DMA transfer to finish so that there will be data
- * available in the FIFO when time slot 1 tries to transfer a DWORD
- * from the FIFO to the output buffer register. We test for DMA
- * Done by polling the DMAC enable flag; this flag is automatically
- * cleared when the transfer has finished.
- */
- while ((RR7146(P_MC1) & MC1_A2OUT) != 0)
- ;
+ /* While retaining CounterB and LatchSrc configurations, program the */
+ /* new counter operating mode. */
+ DEBIreplace(dev, k->MyCRA, CRAMSK_INDXSRC_B | CRAMSK_CLKSRC_B, cra);
+ DEBIreplace(dev, k->MyCRB,
+ (uint16_t) (~(CRBMSK_INTCTRL | CRBMSK_CLKENAB_A)), crb);
+}
- /* START THE OUTPUT STREAM TO THE TARGET DAC -------------------- */
+static void SetMode_B(struct comedi_device *dev, struct enc_private *k,
+ uint16_t Setup, uint16_t DisableIntSrc)
+{
+ register uint16_t cra;
+ register uint16_t crb;
+ register uint16_t setup = Setup; /* Cache the Standard Setup. */
- /* FIFO data is now available, so we enable execution of time slots
- * 1 and higher by clearing the EOS flag in slot 0. Note that SD3
- * will be shifted in and stored in FB_BUFFER2 for end-of-slot-list
- * detection.
- */
- SETVECT(0, XSD2 | RSD3 | SIB_A2);
+ /* Initialize CRA and CRB images. */
+ cra = ((setup & STDMSK_INDXSRC) << ((CRABIT_INDXSRC_B + 1) - STDBIT_INDXSRC)); /* IndexSrc field is restricted to ENC_X or IndxPol. */
- /* Wait for slot 1 to execute to ensure that the Packet will be
- * transmitted. This is detected by polling the Audio2 output FIFO
- * underflow flag, which will be set when slot 1 execution has
- * finished transferring the DAC's data DWORD from the output FIFO
- * to the output buffer register.
- */
- while ((RR7146(P_SSR) & SSR_AF2_OUT) == 0)
- ;
+ crb = (CRBMSK_INTRESETCMD | CRBMSK_INTRESET_B /* Reset event captures and disable interrupts. */
+ | ((setup & STDMSK_CLKENAB) << (CRBBIT_CLKENAB_B - STDBIT_CLKENAB)) /* Clock enable is passed through. */
+ |((setup & STDMSK_LOADSRC) >> (STDBIT_LOADSRC - CRBBIT_LOADSRC_B))); /* Preload trigger source is passed through. */
- /* Set up to trap execution at slot 0 when the TSL sequencer cycles
- * back to slot 0 after executing the EOS in slot 5. Also,
- * simultaneously shift out and in the 0x00 that is ALWAYS the value
- * stored in the last byte to be shifted out of the FIFO's DWORD
- * buffer register.
- */
- SETVECT(0, XSD2 | XFIFO_2 | RSD2 | SIB_A2 | EOS);
+ /* Force IntSrc to Disabled if DisableIntSrc is asserted. */
+ if (!DisableIntSrc)
+ crb |= ((setup & STDMSK_INTSRC) >> (STDBIT_INTSRC -
+ CRBBIT_INTSRC_B));
- /* WAIT FOR THE TRANSACTION TO FINISH ----------------------- */
+ /* Populate all mode-dependent attributes of CRA & CRB images. */
+ switch ((setup & STDMSK_CLKSRC) >> STDBIT_CLKSRC) {
+ case CLKSRC_TIMER: /* Timer Mode: */
+ cra |= ((2 << CRABIT_CLKSRC_B) /* ClkSrcB<1> selects system clock */
+ |((setup & STDMSK_CLKPOL) << (CRABIT_CLKSRC_B - STDBIT_CLKPOL))); /* with direction (ClkSrcB<0>) obtained from ClkPol. */
+ crb |= ((1 << CRBBIT_CLKPOL_B) /* ClkPolB behaves as always-on clock enable. */
+ |(MULT_X1 << CRBBIT_CLKMULT_B)); /* ClkMultB must be 1x. */
+ break;
- /* Wait for the TSL to finish executing all time slots before
- * exiting this function. We must do this so that the next DAC
- * write doesn't start, thereby enabling clock/chip select signals:
- *
- * 1. Before the TSL sequence cycles back to slot 0, which disables
- * the clock/cs signal gating and traps slot // list execution.
- * we have not yet finished slot 5 then the clock/cs signals are
- * still gated and we have not finished transmitting the stream.
- *
- * 2. While slots 2-5 are executing due to a late slot 0 trap. In
- * this case, the slot sequence is currently repeating, but with
- * clock/cs signals disabled. We must wait for slot 0 to trap
- * execution before setting up the next DAC setpoint DMA transfer
- * and enabling the clock/cs signals. To detect the end of slot 5,
- * we test for the FB_BUFFER2 MSB contents to be equal to 0xFF. If
- * the TSL has not yet finished executing slot 5 ...
- */
- if ((RR7146(P_FB_BUFFER2) & 0xFF000000) != 0) {
- /* The trap was set on time and we are still executing somewhere
- * in slots 2-5, so we now wait for slot 0 to execute and trap
- * TSL execution. This is detected when FB_BUFFER2 MSB changes
- * from 0xFF to 0x00, which slot 0 causes to happen by shifting
- * out/in on SD2 the 0x00 that is always referenced by slot 5.
- */
- while ((RR7146(P_FB_BUFFER2) & 0xFF000000) != 0)
- ;
+ case CLKSRC_EXTENDER: /* Extender Mode: */
+ cra |= ((2 << CRABIT_CLKSRC_B) /* ClkSrcB source is OverflowA (same as "timer") */
+ |((setup & STDMSK_CLKPOL) << (CRABIT_CLKSRC_B - STDBIT_CLKPOL))); /* with direction obtained from ClkPol. */
+ crb |= ((1 << CRBBIT_CLKPOL_B) /* ClkPolB controls IndexB -- always set to active. */
+ |(MULT_X0 << CRBBIT_CLKMULT_B)); /* ClkMultB selects OverflowA as the clock source. */
+ break;
+
+ default: /* Counter Mode: */
+ cra |= (CLKSRC_COUNTER << CRABIT_CLKSRC_B); /* Select ENC_C and ENC_D as clock/direction inputs. */
+ crb |= (((setup & STDMSK_CLKPOL) >> (STDBIT_CLKPOL - CRBBIT_CLKPOL_B)) /* ClkPol is passed through. */
+ |(((setup & STDMSK_CLKMULT) == (MULT_X0 << STDBIT_CLKMULT)) ? /* Force ClkMult to x1 if not legal, otherwise pass through. */
+ (MULT_X1 << CRBBIT_CLKMULT_B) :
+ ((setup & STDMSK_CLKMULT) << (CRBBIT_CLKMULT_B -
+ STDBIT_CLKMULT))));
}
- /* Either (1) we were too late setting the slot 0 trap; the TSL
- * sequencer restarted slot 0 before we could set the EOS trap flag,
- * or (2) we were not late and execution is now trapped at slot 0.
- * In either case, we must now change slot 0 so that it will store
- * value 0xFF (instead of 0x00) to FB_BUFFER2 next time it executes.
- * In order to do this, we reprogram slot 0 so that it will shift in
- * SD3, which is driven only by a pull-up resistor.
- */
- SETVECT(0, RSD3 | SIB_A2 | EOS);
- /* Wait for slot 0 to execute, at which time the TSL is setup for
- * the next DAC write. This is detected when FB_BUFFER2 MSB changes
- * from 0x00 to 0xFF.
- */
- while ((RR7146(P_FB_BUFFER2) & 0xFF000000) == 0)
- ;
+ /* Force positive index polarity if IndxSrc is software-driven only, */
+ /* otherwise pass it through. */
+ if (~setup & STDMSK_INDXSRC)
+ crb |= ((setup & STDMSK_INDXPOL) >> (STDBIT_INDXPOL -
+ CRBBIT_INDXPOL_B));
+
+ /* If IntSrc has been forced to Disabled, update the MISC2 interrupt */
+ /* enable mask to indicate the counter interrupt is disabled. */
+ if (DisableIntSrc)
+ devpriv->CounterIntEnabs &= ~k->MyEventBits[3];
+
+ /* While retaining CounterA and LatchSrc configurations, program the */
+ /* new counter operating mode. */
+ DEBIreplace(dev, k->MyCRA,
+ (uint16_t) (~(CRAMSK_INDXSRC_B | CRAMSK_CLKSRC_B)), cra);
+ DEBIreplace(dev, k->MyCRB, CRBMSK_CLKENAB_A | CRBMSK_LATCHSRC, crb);
+}
+
+/* Return/set a counter's enable. enab: 0=always enabled, 1=enabled by index. */
+
+static void SetEnable_A(struct comedi_device *dev, struct enc_private *k,
+ uint16_t enab)
+{
+ DEBIreplace(dev, k->MyCRB,
+ (uint16_t) (~(CRBMSK_INTCTRL | CRBMSK_CLKENAB_A)),
+ (uint16_t) (enab << CRBBIT_CLKENAB_A));
}
-static void WriteMISC2(struct comedi_device *dev, uint16_t NewImage)
+static void SetEnable_B(struct comedi_device *dev, struct enc_private *k,
+ uint16_t enab)
{
- DEBIwrite(dev, LP_MISC1, MISC1_WENABLE); /* enab writes to */
- /* MISC2 register. */
- DEBIwrite(dev, LP_WRMISC2, NewImage); /* Write new image to MISC2. */
- DEBIwrite(dev, LP_MISC1, MISC1_WDISABLE); /* Disable writes to MISC2. */
+ DEBIreplace(dev, k->MyCRB,
+ (uint16_t) (~(CRBMSK_INTCTRL | CRBMSK_CLKENAB_B)),
+ (uint16_t) (enab << CRBBIT_CLKENAB_B));
}
-/* Initialize the DEBI interface for all transfers. */
-
-static uint16_t DEBIread(struct comedi_device *dev, uint16_t addr)
+static uint16_t GetEnable_A(struct comedi_device *dev, struct enc_private *k)
{
- uint16_t retval;
+ return (DEBIread(dev, k->MyCRB) >> CRBBIT_CLKENAB_A) & 1;
+}
- /* Set up DEBI control register value in shadow RAM. */
- WR7146(P_DEBICMD, DEBI_CMD_RDWORD | addr);
+static uint16_t GetEnable_B(struct comedi_device *dev, struct enc_private *k)
+{
+ return (DEBIread(dev, k->MyCRB) >> CRBBIT_CLKENAB_B) & 1;
+}
- /* Execute the DEBI transfer. */
- DEBItransfer(dev);
+/*
+ * static uint16_t GetLatchSource(struct comedi_device *dev, struct enc_private *k )
+ * {
+ * return ( DEBIread( dev, k->MyCRB) >> CRBBIT_LATCHSRC ) & 3;
+ * }
+ */
- /* Fetch target register value. */
- retval = (uint16_t) RR7146(P_DEBIAD);
+/*
+ * Return/set the event that will trigger transfer of the preload
+ * register into the counter. 0=ThisCntr_Index, 1=ThisCntr_Overflow,
+ * 2=OverflowA (B counters only), 3=disabled.
+ */
- /* Return register value. */
- return retval;
+static void SetLoadTrig_A(struct comedi_device *dev, struct enc_private *k,
+ uint16_t Trig)
+{
+ DEBIreplace(dev, k->MyCRA, (uint16_t) (~CRAMSK_LOADSRC_A),
+ (uint16_t) (Trig << CRABIT_LOADSRC_A));
}
-/* Execute a DEBI transfer. This must be called from within a */
-/* critical section. */
-static void DEBItransfer(struct comedi_device *dev)
+static void SetLoadTrig_B(struct comedi_device *dev, struct enc_private *k,
+ uint16_t Trig)
{
- /* Initiate upload of shadow RAM to DEBI control register. */
- MC_ENABLE(P_MC2, MC2_UPLD_DEBI);
+ DEBIreplace(dev, k->MyCRB,
+ (uint16_t) (~(CRBMSK_LOADSRC_B | CRBMSK_INTCTRL)),
+ (uint16_t) (Trig << CRBBIT_LOADSRC_B));
+}
- /* Wait for completion of upload from shadow RAM to DEBI control */
- /* register. */
- while (!MC_TEST(P_MC2, MC2_UPLD_DEBI))
- ;
+static uint16_t GetLoadTrig_A(struct comedi_device *dev, struct enc_private *k)
+{
+ return (DEBIread(dev, k->MyCRA) >> CRABIT_LOADSRC_A) & 3;
+}
- /* Wait until DEBI transfer is done. */
- while (RR7146(P_PSR) & PSR_DEBI_S)
- ;
+static uint16_t GetLoadTrig_B(struct comedi_device *dev, struct enc_private *k)
+{
+ return (DEBIread(dev, k->MyCRB) >> CRBBIT_LOADSRC_B) & 3;
}
-/* Write a value to a gate array register. */
-static void DEBIwrite(struct comedi_device *dev, uint16_t addr, uint16_t wdata)
+/* Return/set counter interrupt source and clear any captured
+ * index/overflow events. IntSource: 0=Disabled, 1=OverflowOnly,
+ * 2=IndexOnly, 3=IndexAndOverflow.
+ */
+
+static void SetIntSrc_A(struct comedi_device *dev, struct enc_private *k,
+ uint16_t IntSource)
{
+ /* Reset any pending counter overflow or index captures. */
+ DEBIreplace(dev, k->MyCRB, (uint16_t) (~CRBMSK_INTCTRL),
+ CRBMSK_INTRESETCMD | CRBMSK_INTRESET_A);
- /* Set up DEBI control register value in shadow RAM. */
- WR7146(P_DEBICMD, DEBI_CMD_WRWORD | addr);
- WR7146(P_DEBIAD, wdata);
+ /* Program counter interrupt source. */
+ DEBIreplace(dev, k->MyCRA, ~CRAMSK_INTSRC_A,
+ (uint16_t) (IntSource << CRABIT_INTSRC_A));
- /* Execute the DEBI transfer. */
- DEBItransfer(dev);
+ /* Update MISC2 interrupt enable mask. */
+ devpriv->CounterIntEnabs =
+ (devpriv->CounterIntEnabs & ~k->
+ MyEventBits[3]) | k->MyEventBits[IntSource];
}
-/* Replace the specified bits in a gate array register. Imports: mask
- * specifies bits that are to be preserved, wdata is new value to be
- * or'd with the masked original.
- */
-static void DEBIreplace(struct comedi_device *dev, uint16_t addr, uint16_t mask,
- uint16_t wdata)
+static void SetIntSrc_B(struct comedi_device *dev, struct enc_private *k,
+ uint16_t IntSource)
{
+ uint16_t crb;
- /* Copy target gate array register into P_DEBIAD register. */
- WR7146(P_DEBICMD, DEBI_CMD_RDWORD | addr);
- /* Set up DEBI control reg value in shadow RAM. */
- DEBItransfer(dev); /* Execute the DEBI Read transfer. */
+ /* Cache writeable CRB register image. */
+ crb = DEBIread(dev, k->MyCRB) & ~CRBMSK_INTCTRL;
- /* Write back the modified image. */
- WR7146(P_DEBICMD, DEBI_CMD_WRWORD | addr);
- /* Set up DEBI control reg value in shadow RAM. */
+ /* Reset any pending counter overflow or index captures. */
+ DEBIwrite(dev, k->MyCRB,
+ (uint16_t) (crb | CRBMSK_INTRESETCMD | CRBMSK_INTRESET_B));
- WR7146(P_DEBIAD, wdata | ((uint16_t) RR7146(P_DEBIAD) & mask));
- /* Modify the register image. */
- DEBItransfer(dev); /* Execute the DEBI Write transfer. */
+ /* Program counter interrupt source. */
+ DEBIwrite(dev, k->MyCRB,
+ (uint16_t) ((crb & ~CRBMSK_INTSRC_B) | (IntSource <<
+ CRBBIT_INTSRC_B)));
+
+ /* Update MISC2 interrupt enable mask. */
+ devpriv->CounterIntEnabs =
+ (devpriv->CounterIntEnabs & ~k->
+ MyEventBits[3]) | k->MyEventBits[IntSource];
}
-static void CloseDMAB(struct comedi_device *dev, struct bufferDMA *pdma,
- size_t bsize)
+static uint16_t GetIntSrc_A(struct comedi_device *dev, struct enc_private *k)
{
- void *vbptr;
- dma_addr_t vpptr;
+ return (DEBIread(dev, k->MyCRA) >> CRABIT_INTSRC_A) & 3;
+}
- DEBUG("CloseDMAB: Entering S626DRV_CloseDMAB():\n");
- if (pdma == NULL)
- return;
- /* find the matching allocation from the board struct */
+static uint16_t GetIntSrc_B(struct comedi_device *dev, struct enc_private *k)
+{
+ return (DEBIread(dev, k->MyCRB) >> CRBBIT_INTSRC_B) & 3;
+}
- vbptr = pdma->LogicalBase;
- vpptr = pdma->PhysicalBase;
- if (vbptr) {
- pci_free_consistent(devpriv->pdev, bsize, vbptr, vpptr);
- pdma->LogicalBase = 0;
- pdma->PhysicalBase = 0;
+/* Return/set the clock multiplier. */
- DEBUG("CloseDMAB(): Logical=%p, bsize=%d, Physical=0x%x\n",
- vbptr, bsize, (uint32_t) vpptr);
- }
+/* static void SetClkMult(struct comedi_device *dev, struct enc_private *k, uint16_t value ) */
+/* { */
+/* k->SetMode(dev, k, (uint16_t)( ( k->GetMode(dev, k ) & ~STDMSK_CLKMULT ) | ( value << STDBIT_CLKMULT ) ), FALSE ); */
+/* } */
+
+/* static uint16_t GetClkMult(struct comedi_device *dev, struct enc_private *k ) */
+/* { */
+/* return ( k->GetMode(dev, k ) >> STDBIT_CLKMULT ) & 3; */
+/* } */
+
+/* Return/set the clock polarity. */
+
+/* static void SetClkPol( struct comedi_device *dev,struct enc_private *k, uint16_t value ) */
+/* { */
+/* k->SetMode(dev, k, (uint16_t)( ( k->GetMode(dev, k ) & ~STDMSK_CLKPOL ) | ( value << STDBIT_CLKPOL ) ), FALSE ); */
+/* } */
+
+/* static uint16_t GetClkPol(struct comedi_device *dev, struct enc_private *k ) */
+/* { */
+/* return ( k->GetMode(dev, k ) >> STDBIT_CLKPOL ) & 1; */
+/* } */
+
+/* Return/set the clock source. */
+
+/* static void SetClkSrc( struct comedi_device *dev,struct enc_private *k, uint16_t value ) */
+/* { */
+/* k->SetMode(dev, k, (uint16_t)( ( k->GetMode(dev, k ) & ~STDMSK_CLKSRC ) | ( value << STDBIT_CLKSRC ) ), FALSE ); */
+/* } */
+
+/* static uint16_t GetClkSrc( struct comedi_device *dev,struct enc_private *k ) */
+/* { */
+/* return ( k->GetMode(dev, k ) >> STDBIT_CLKSRC ) & 3; */
+/* } */
+
+/* Return/set the index polarity. */
+
+/* static void SetIndexPol(struct comedi_device *dev, struct enc_private *k, uint16_t value ) */
+/* { */
+/* k->SetMode(dev, k, (uint16_t)( ( k->GetMode(dev, k ) & ~STDMSK_INDXPOL ) | ( (value != 0) << STDBIT_INDXPOL ) ), FALSE ); */
+/* } */
+
+/* static uint16_t GetIndexPol(struct comedi_device *dev, struct enc_private *k ) */
+/* { */
+/* return ( k->GetMode(dev, k ) >> STDBIT_INDXPOL ) & 1; */
+/* } */
+
+/* Return/set the index source. */
+
+/* static void SetIndexSrc(struct comedi_device *dev, struct enc_private *k, uint16_t value ) */
+/* { */
+/* k->SetMode(dev, k, (uint16_t)( ( k->GetMode(dev, k ) & ~STDMSK_INDXSRC ) | ( (value != 0) << STDBIT_INDXSRC ) ), FALSE ); */
+/* } */
+
+/* static uint16_t GetIndexSrc(struct comedi_device *dev, struct enc_private *k ) */
+/* { */
+/* return ( k->GetMode(dev, k ) >> STDBIT_INDXSRC ) & 1; */
+/* } */
+
+/* Generate an index pulse. */
+
+static void PulseIndex_A(struct comedi_device *dev, struct enc_private *k)
+{
+ register uint16_t cra;
+
+ cra = DEBIread(dev, k->MyCRA); /* Pulse index. */
+ DEBIwrite(dev, k->MyCRA, (uint16_t) (cra ^ CRAMSK_INDXPOL_A));
+ DEBIwrite(dev, k->MyCRA, cra);
}
-/* ****** COUNTER FUNCTIONS ******* */
-/* All counter functions address a specific counter by means of the
- * "Counter" argument, which is a logical counter number. The Counter
- * argument may have any of the following legal values: 0=0A, 1=1A,
- * 2=2A, 3=0B, 4=1B, 5=2B.
- */
+static void PulseIndex_B(struct comedi_device *dev, struct enc_private *k)
+{
+ register uint16_t crb;
-/* Forward declarations for functions that are common to both A and B counters: */
+ crb = DEBIread(dev, k->MyCRB) & ~CRBMSK_INTCTRL; /* Pulse index. */
+ DEBIwrite(dev, k->MyCRB, (uint16_t) (crb ^ CRBMSK_INDXPOL_B));
+ DEBIwrite(dev, k->MyCRB, crb);
+}
-/* ****** PRIVATE COUNTER FUNCTIONS ****** */
+static struct enc_private enc_private_data[] = {
+ {
+ .GetEnable = GetEnable_A,
+ .GetIntSrc = GetIntSrc_A,
+ .GetLoadTrig = GetLoadTrig_A,
+ .GetMode = GetMode_A,
+ .PulseIndex = PulseIndex_A,
+ .SetEnable = SetEnable_A,
+ .SetIntSrc = SetIntSrc_A,
+ .SetLoadTrig = SetLoadTrig_A,
+ .SetMode = SetMode_A,
+ .ResetCapFlags = ResetCapFlags_A,
+ .MyCRA = LP_CR0A,
+ .MyCRB = LP_CR0B,
+ .MyLatchLsw = LP_CNTR0ALSW,
+ .MyEventBits = EVBITS(0),
+ }, {
+ .GetEnable = GetEnable_A,
+ .GetIntSrc = GetIntSrc_A,
+ .GetLoadTrig = GetLoadTrig_A,
+ .GetMode = GetMode_A,
+ .PulseIndex = PulseIndex_A,
+ .SetEnable = SetEnable_A,
+ .SetIntSrc = SetIntSrc_A,
+ .SetLoadTrig = SetLoadTrig_A,
+ .SetMode = SetMode_A,
+ .ResetCapFlags = ResetCapFlags_A,
+ .MyCRA = LP_CR1A,
+ .MyCRB = LP_CR1B,
+ .MyLatchLsw = LP_CNTR1ALSW,
+ .MyEventBits = EVBITS(1),
+ }, {
+ .GetEnable = GetEnable_A,
+ .GetIntSrc = GetIntSrc_A,
+ .GetLoadTrig = GetLoadTrig_A,
+ .GetMode = GetMode_A,
+ .PulseIndex = PulseIndex_A,
+ .SetEnable = SetEnable_A,
+ .SetIntSrc = SetIntSrc_A,
+ .SetLoadTrig = SetLoadTrig_A,
+ .SetMode = SetMode_A,
+ .ResetCapFlags = ResetCapFlags_A,
+ .MyCRA = LP_CR2A,
+ .MyCRB = LP_CR2B,
+ .MyLatchLsw = LP_CNTR2ALSW,
+ .MyEventBits = EVBITS(2),
+ }, {
+ .GetEnable = GetEnable_B,
+ .GetIntSrc = GetIntSrc_B,
+ .GetLoadTrig = GetLoadTrig_B,
+ .GetMode = GetMode_B,
+ .PulseIndex = PulseIndex_B,
+ .SetEnable = SetEnable_B,
+ .SetIntSrc = SetIntSrc_B,
+ .SetLoadTrig = SetLoadTrig_B,
+ .SetMode = SetMode_B,
+ .ResetCapFlags = ResetCapFlags_B,
+ .MyCRA = LP_CR0A,
+ .MyCRB = LP_CR0B,
+ .MyLatchLsw = LP_CNTR0BLSW,
+ .MyEventBits = EVBITS(3),
+ }, {
+ .GetEnable = GetEnable_B,
+ .GetIntSrc = GetIntSrc_B,
+ .GetLoadTrig = GetLoadTrig_B,
+ .GetMode = GetMode_B,
+ .PulseIndex = PulseIndex_B,
+ .SetEnable = SetEnable_B,
+ .SetIntSrc = SetIntSrc_B,
+ .SetLoadTrig = SetLoadTrig_B,
+ .SetMode = SetMode_B,
+ .ResetCapFlags = ResetCapFlags_B,
+ .MyCRA = LP_CR1A,
+ .MyCRB = LP_CR1B,
+ .MyLatchLsw = LP_CNTR1BLSW,
+ .MyEventBits = EVBITS(4),
+ }, {
+ .GetEnable = GetEnable_B,
+ .GetIntSrc = GetIntSrc_B,
+ .GetLoadTrig = GetLoadTrig_B,
+ .GetMode = GetMode_B,
+ .PulseIndex = PulseIndex_B,
+ .SetEnable = SetEnable_B,
+ .SetIntSrc = SetIntSrc_B,
+ .SetLoadTrig = SetLoadTrig_B,
+ .SetMode = SetMode_B,
+ .ResetCapFlags = ResetCapFlags_B,
+ .MyCRA = LP_CR2A,
+ .MyCRB = LP_CR2B,
+ .MyLatchLsw = LP_CNTR2BLSW,
+ .MyEventBits = EVBITS(5),
+ },
+};
-/* Read a counter's output latch. */
+static void CountersInit(struct comedi_device *dev)
+{
+ int chan;
+ struct enc_private *k;
+ uint16_t Setup = (LOADSRC_INDX << BF_LOADSRC) | /* Preload upon */
+ /* index. */
+ (INDXSRC_SOFT << BF_INDXSRC) | /* Disable hardware index. */
+ (CLKSRC_COUNTER << BF_CLKSRC) | /* Operating mode is counter. */
+ (CLKPOL_POS << BF_CLKPOL) | /* Active high clock. */
+ (CNTDIR_UP << BF_CLKPOL) | /* Count direction is up. */
+ (CLKMULT_1X << BF_CLKMULT) | /* Clock multiplier is 1x. */
+ (CLKENAB_INDEX << BF_CLKENAB); /* Enabled by index */
+
+ /* Disable all counter interrupts and clear any captured counter events. */
+ for (chan = 0; chan < S626_ENCODER_CHANNELS; chan++) {
+ k = &encpriv[chan];
+ k->SetMode(dev, k, Setup, TRUE);
+ k->SetIntSrc(dev, k, 0);
+ k->ResetCapFlags(dev, k);
+ k->SetEnable(dev, k, CLKENAB_ALWAYS);
+ }
+}
-static uint32_t ReadLatch(struct comedi_device *dev, struct enc_private *k)
+static struct pci_dev *s626_find_pci(struct comedi_device *dev,
+ struct comedi_devconfig *it)
{
- register uint32_t value;
- /* DEBUG FIXME DEBUG("ReadLatch: Read Latch enter\n"); */
-
- /* Latch counts and fetch LSW of latched counts value. */
- value = (uint32_t) DEBIread(dev, k->MyLatchLsw);
-
- /* Fetch MSW of latched counts and combine with LSW. */
- value |= ((uint32_t) DEBIread(dev, k->MyLatchLsw + 2) << 16);
+ struct pci_dev *pcidev = NULL;
+ int bus = it->options[0];
+ int slot = it->options[1];
+ int i;
- /* DEBUG FIXME DEBUG("ReadLatch: Read Latch exit\n"); */
+ for (i = 0; i < ARRAY_SIZE(s626_boards) && !pcidev; i++) {
+ do {
+ pcidev = pci_get_subsys(s626_boards[i].vendor_id,
+ s626_boards[i].device_id,
+ s626_boards[i].subvendor_id,
+ s626_boards[i].subdevice_id,
+ pcidev);
- /* Return latched counts. */
- return value;
+ if ((bus || slot) && pcidev) {
+ /* matches requested bus/slot */
+ if (pcidev->bus->number == bus &&
+ PCI_SLOT(pcidev->devfn) == slot)
+ break;
+ } else {
+ break;
+ }
+ } while (1);
+ }
+ return pcidev;
}
-/* Reset a counter's index and overflow event capture flags. */
-
-static void ResetCapFlags_A(struct comedi_device *dev, struct enc_private *k)
+static int s626_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
- DEBIreplace(dev, k->MyCRB, (uint16_t) (~CRBMSK_INTCTRL),
- CRBMSK_INTRESETCMD | CRBMSK_INTRESET_A);
-}
+/* uint8_t PollList; */
+/* uint16_t AdcData; */
+/* uint16_t StartVal; */
+/* uint16_t index; */
+/* unsigned int data[16]; */
+ int result;
+ int i;
+ int ret;
+ resource_size_t resourceStart;
+ dma_addr_t appdma;
+ struct comedi_subdevice *s;
-static void ResetCapFlags_B(struct comedi_device *dev, struct enc_private *k)
-{
- DEBIreplace(dev, k->MyCRB, (uint16_t) (~CRBMSK_INTCTRL),
- CRBMSK_INTRESETCMD | CRBMSK_INTRESET_B);
-}
+ if (alloc_private(dev, sizeof(struct s626_private)) < 0)
+ return -ENOMEM;
-/* Return counter setup in a format (COUNTER_SETUP) that is consistent */
-/* for both A and B counters. */
+ devpriv->pdev = s626_find_pci(dev, it);
+ if (!devpriv->pdev) {
+ printk(KERN_ERR "s626_attach: Board not present!!!\n");
+ return -ENODEV;
+ }
-static uint16_t GetMode_A(struct comedi_device *dev, struct enc_private *k)
-{
- register uint16_t cra;
- register uint16_t crb;
- register uint16_t setup;
+ result = comedi_pci_enable(devpriv->pdev, "s626");
+ if (result < 0) {
+ printk(KERN_ERR "s626_attach: comedi_pci_enable fails\n");
+ return -ENODEV;
+ }
+ devpriv->got_regions = 1;
- /* Fetch CRA and CRB register images. */
- cra = DEBIread(dev, k->MyCRA);
- crb = DEBIread(dev, k->MyCRB);
+ resourceStart = pci_resource_start(devpriv->pdev, 0);
- /* Populate the standardized counter setup bit fields. Note: */
- /* IndexSrc is restricted to ENC_X or IndxPol. */
- setup = ((cra & STDMSK_LOADSRC) /* LoadSrc = LoadSrcA. */
- |((crb << (STDBIT_LATCHSRC - CRBBIT_LATCHSRC)) & STDMSK_LATCHSRC) /* LatchSrc = LatchSrcA. */
- |((cra << (STDBIT_INTSRC - CRABIT_INTSRC_A)) & STDMSK_INTSRC) /* IntSrc = IntSrcA. */
- |((cra << (STDBIT_INDXSRC - (CRABIT_INDXSRC_A + 1))) & STDMSK_INDXSRC) /* IndxSrc = IndxSrcA<1>. */
- |((cra >> (CRABIT_INDXPOL_A - STDBIT_INDXPOL)) & STDMSK_INDXPOL) /* IndxPol = IndxPolA. */
- |((crb >> (CRBBIT_CLKENAB_A - STDBIT_CLKENAB)) & STDMSK_CLKENAB)); /* ClkEnab = ClkEnabA. */
+ devpriv->base_addr = ioremap(resourceStart, SIZEOF_ADDRESS_SPACE);
+ if (devpriv->base_addr == NULL) {
+ printk(KERN_ERR "s626_attach: IOREMAP failed\n");
+ return -ENODEV;
+ }
- /* Adjust mode-dependent parameters. */
- if (cra & (2 << CRABIT_CLKSRC_A)) /* If Timer mode (ClkSrcA<1> == 1): */
- setup |= ((CLKSRC_TIMER << STDBIT_CLKSRC) /* Indicate Timer mode. */
- |((cra << (STDBIT_CLKPOL - CRABIT_CLKSRC_A)) & STDMSK_CLKPOL) /* Set ClkPol to indicate count direction (ClkSrcA<0>). */
- |(MULT_X1 << STDBIT_CLKMULT)); /* ClkMult must be 1x in Timer mode. */
+ if (devpriv->base_addr) {
+ /* disable master interrupt */
+ writel(0, devpriv->base_addr + P_IER);
- else /* If Counter mode (ClkSrcA<1> == 0): */
- setup |= ((CLKSRC_COUNTER << STDBIT_CLKSRC) /* Indicate Counter mode. */
- |((cra >> (CRABIT_CLKPOL_A - STDBIT_CLKPOL)) & STDMSK_CLKPOL) /* Pass through ClkPol. */
- |(((cra & CRAMSK_CLKMULT_A) == (MULT_X0 << CRABIT_CLKMULT_A)) ? /* Force ClkMult to 1x if not legal, else pass through. */
- (MULT_X1 << STDBIT_CLKMULT) :
- ((cra >> (CRABIT_CLKMULT_A -
- STDBIT_CLKMULT)) & STDMSK_CLKMULT)));
+ /* soft reset */
+ writel(MC1_SOFT_RESET, devpriv->base_addr + P_MC1);
- /* Return adjusted counter setup. */
- return setup;
-}
+ /* DMA FIXME DMA// */
-static uint16_t GetMode_B(struct comedi_device *dev, struct enc_private *k)
-{
- register uint16_t cra;
- register uint16_t crb;
- register uint16_t setup;
+ /* adc buffer allocation */
+ devpriv->allocatedBuf = 0;
- /* Fetch CRA and CRB register images. */
- cra = DEBIread(dev, k->MyCRA);
- crb = DEBIread(dev, k->MyCRB);
+ devpriv->ANABuf.LogicalBase =
+ pci_alloc_consistent(devpriv->pdev, DMABUF_SIZE, &appdma);
- /* Populate the standardized counter setup bit fields. Note: */
- /* IndexSrc is restricted to ENC_X or IndxPol. */
- setup = (((crb << (STDBIT_INTSRC - CRBBIT_INTSRC_B)) & STDMSK_INTSRC) /* IntSrc = IntSrcB. */
- |((crb << (STDBIT_LATCHSRC - CRBBIT_LATCHSRC)) & STDMSK_LATCHSRC) /* LatchSrc = LatchSrcB. */
- |((crb << (STDBIT_LOADSRC - CRBBIT_LOADSRC_B)) & STDMSK_LOADSRC) /* LoadSrc = LoadSrcB. */
- |((crb << (STDBIT_INDXPOL - CRBBIT_INDXPOL_B)) & STDMSK_INDXPOL) /* IndxPol = IndxPolB. */
- |((crb >> (CRBBIT_CLKENAB_B - STDBIT_CLKENAB)) & STDMSK_CLKENAB) /* ClkEnab = ClkEnabB. */
- |((cra >> ((CRABIT_INDXSRC_B + 1) - STDBIT_INDXSRC)) & STDMSK_INDXSRC)); /* IndxSrc = IndxSrcB<1>. */
+ if (devpriv->ANABuf.LogicalBase == NULL) {
+ printk(KERN_ERR "s626_attach: DMA Memory mapping error\n");
+ return -ENOMEM;
+ }
- /* Adjust mode-dependent parameters. */
- if ((crb & CRBMSK_CLKMULT_B) == (MULT_X0 << CRBBIT_CLKMULT_B)) /* If Extender mode (ClkMultB == MULT_X0): */
- setup |= ((CLKSRC_EXTENDER << STDBIT_CLKSRC) /* Indicate Extender mode. */
- |(MULT_X1 << STDBIT_CLKMULT) /* Indicate multiplier is 1x. */
- |((cra >> (CRABIT_CLKSRC_B - STDBIT_CLKPOL)) & STDMSK_CLKPOL)); /* Set ClkPol equal to Timer count direction (ClkSrcB<0>). */
+ devpriv->ANABuf.PhysicalBase = appdma;
- else if (cra & (2 << CRABIT_CLKSRC_B)) /* If Timer mode (ClkSrcB<1> == 1): */
- setup |= ((CLKSRC_TIMER << STDBIT_CLKSRC) /* Indicate Timer mode. */
- |(MULT_X1 << STDBIT_CLKMULT) /* Indicate multiplier is 1x. */
- |((cra >> (CRABIT_CLKSRC_B - STDBIT_CLKPOL)) & STDMSK_CLKPOL)); /* Set ClkPol equal to Timer count direction (ClkSrcB<0>). */
+ devpriv->allocatedBuf++;
- else /* If Counter mode (ClkSrcB<1> == 0): */
- setup |= ((CLKSRC_COUNTER << STDBIT_CLKSRC) /* Indicate Timer mode. */
- |((crb >> (CRBBIT_CLKMULT_B - STDBIT_CLKMULT)) & STDMSK_CLKMULT) /* Clock multiplier is passed through. */
- |((crb << (STDBIT_CLKPOL - CRBBIT_CLKPOL_B)) & STDMSK_CLKPOL)); /* Clock polarity is passed through. */
+ devpriv->RPSBuf.LogicalBase =
+ pci_alloc_consistent(devpriv->pdev, DMABUF_SIZE, &appdma);
- /* Return adjusted counter setup. */
- return setup;
-}
+ if (devpriv->RPSBuf.LogicalBase == NULL) {
+ printk(KERN_ERR "s626_attach: DMA Memory mapping error\n");
+ return -ENOMEM;
+ }
-/*
- * Set the operating mode for the specified counter. The setup
- * parameter is treated as a COUNTER_SETUP data type. The following
- * parameters are programmable (all other parms are ignored): ClkMult,
- * ClkPol, ClkEnab, IndexSrc, IndexPol, LoadSrc.
- */
+ devpriv->RPSBuf.PhysicalBase = appdma;
-static void SetMode_A(struct comedi_device *dev, struct enc_private *k,
- uint16_t Setup, uint16_t DisableIntSrc)
-{
- register uint16_t cra;
- register uint16_t crb;
- register uint16_t setup = Setup; /* Cache the Standard Setup. */
+ devpriv->allocatedBuf++;
- /* Initialize CRA and CRB images. */
- cra = ((setup & CRAMSK_LOADSRC_A) /* Preload trigger is passed through. */
- |((setup & STDMSK_INDXSRC) >> (STDBIT_INDXSRC - (CRABIT_INDXSRC_A + 1)))); /* IndexSrc is restricted to ENC_X or IndxPol. */
+ }
- crb = (CRBMSK_INTRESETCMD | CRBMSK_INTRESET_A /* Reset any pending CounterA event captures. */
- | ((setup & STDMSK_CLKENAB) << (CRBBIT_CLKENAB_A - STDBIT_CLKENAB))); /* Clock enable is passed through. */
+ dev->board_ptr = s626_boards;
+ dev->board_name = thisboard->name;
- /* Force IntSrc to Disabled if DisableIntSrc is asserted. */
- if (!DisableIntSrc)
- cra |= ((setup & STDMSK_INTSRC) >> (STDBIT_INTSRC -
- CRABIT_INTSRC_A));
+ ret = comedi_alloc_subdevices(dev, 6);
+ if (ret)
+ return ret;
- /* Populate all mode-dependent attributes of CRA & CRB images. */
- switch ((setup & STDMSK_CLKSRC) >> STDBIT_CLKSRC) {
- case CLKSRC_EXTENDER: /* Extender Mode: Force to Timer mode */
- /* (Extender valid only for B counters). */
+ dev->iobase = (unsigned long)devpriv->base_addr;
+ dev->irq = devpriv->pdev->irq;
- case CLKSRC_TIMER: /* Timer Mode: */
- cra |= ((2 << CRABIT_CLKSRC_A) /* ClkSrcA<1> selects system clock */
- |((setup & STDMSK_CLKPOL) >> (STDBIT_CLKPOL - CRABIT_CLKSRC_A)) /* with count direction (ClkSrcA<0>) obtained from ClkPol. */
- |(1 << CRABIT_CLKPOL_A) /* ClkPolA behaves as always-on clock enable. */
- |(MULT_X1 << CRABIT_CLKMULT_A)); /* ClkMult must be 1x. */
- break;
+ /* set up interrupt handler */
+ if (dev->irq == 0) {
+ printk(KERN_ERR " unknown irq (bad)\n");
+ } else {
+ ret = request_irq(dev->irq, s626_irq_handler, IRQF_SHARED,
+ "s626", dev);
- default: /* Counter Mode: */
- cra |= (CLKSRC_COUNTER /* Select ENC_C and ENC_D as clock/direction inputs. */
- | ((setup & STDMSK_CLKPOL) << (CRABIT_CLKPOL_A - STDBIT_CLKPOL)) /* Clock polarity is passed through. */
- |(((setup & STDMSK_CLKMULT) == (MULT_X0 << STDBIT_CLKMULT)) ? /* Force multiplier to x1 if not legal, otherwise pass through. */
- (MULT_X1 << CRABIT_CLKMULT_A) :
- ((setup & STDMSK_CLKMULT) << (CRABIT_CLKMULT_A -
- STDBIT_CLKMULT))));
+ if (ret < 0) {
+ printk(KERN_ERR " irq not available\n");
+ dev->irq = 0;
+ }
}
- /* Force positive index polarity if IndxSrc is software-driven only, */
- /* otherwise pass it through. */
- if (~setup & STDMSK_INDXSRC)
- cra |= ((setup & STDMSK_INDXPOL) << (CRABIT_INDXPOL_A -
- STDBIT_INDXPOL));
-
- /* If IntSrc has been forced to Disabled, update the MISC2 interrupt */
- /* enable mask to indicate the counter interrupt is disabled. */
- if (DisableIntSrc)
- devpriv->CounterIntEnabs &= ~k->MyEventBits[3];
+ s = dev->subdevices + 0;
+ /* analog input subdevice */
+ dev->read_subdev = s;
+ /* we support single-ended (ground) and differential */
+ s->type = COMEDI_SUBD_AI;
+ s->subdev_flags = SDF_READABLE | SDF_DIFF | SDF_CMD_READ;
+ s->n_chan = thisboard->ai_chans;
+ s->maxdata = (0xffff >> 2);
+ s->range_table = &s626_range_table;
+ s->len_chanlist = thisboard->ai_chans; /* This is the maximum chanlist
+ length that the board can
+ handle */
+ s->insn_config = s626_ai_insn_config;
+ s->insn_read = s626_ai_insn_read;
+ s->do_cmd = s626_ai_cmd;
+ s->do_cmdtest = s626_ai_cmdtest;
+ s->cancel = s626_ai_cancel;
- /* While retaining CounterB and LatchSrc configurations, program the */
- /* new counter operating mode. */
- DEBIreplace(dev, k->MyCRA, CRAMSK_INDXSRC_B | CRAMSK_CLKSRC_B, cra);
- DEBIreplace(dev, k->MyCRB,
- (uint16_t) (~(CRBMSK_INTCTRL | CRBMSK_CLKENAB_A)), crb);
-}
+ s = dev->subdevices + 1;
+ /* analog output subdevice */
+ s->type = COMEDI_SUBD_AO;
+ s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
+ s->n_chan = thisboard->ao_chans;
+ s->maxdata = (0x3fff);
+ s->range_table = &range_bipolar10;
+ s->insn_write = s626_ao_winsn;
+ s->insn_read = s626_ao_rinsn;
-static void SetMode_B(struct comedi_device *dev, struct enc_private *k,
- uint16_t Setup, uint16_t DisableIntSrc)
-{
- register uint16_t cra;
- register uint16_t crb;
- register uint16_t setup = Setup; /* Cache the Standard Setup. */
+ s = dev->subdevices + 2;
+ /* digital I/O subdevice */
+ s->type = COMEDI_SUBD_DIO;
+ s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
+ s->n_chan = S626_DIO_CHANNELS;
+ s->maxdata = 1;
+ s->io_bits = 0xffff;
+ s->private = &dio_private_A;
+ s->range_table = &range_digital;
+ s->insn_config = s626_dio_insn_config;
+ s->insn_bits = s626_dio_insn_bits;
- /* Initialize CRA and CRB images. */
- cra = ((setup & STDMSK_INDXSRC) << ((CRABIT_INDXSRC_B + 1) - STDBIT_INDXSRC)); /* IndexSrc field is restricted to ENC_X or IndxPol. */
+ s = dev->subdevices + 3;
+ /* digital I/O subdevice */
+ s->type = COMEDI_SUBD_DIO;
+ s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
+ s->n_chan = 16;
+ s->maxdata = 1;
+ s->io_bits = 0xffff;
+ s->private = &dio_private_B;
+ s->range_table = &range_digital;
+ s->insn_config = s626_dio_insn_config;
+ s->insn_bits = s626_dio_insn_bits;
- crb = (CRBMSK_INTRESETCMD | CRBMSK_INTRESET_B /* Reset event captures and disable interrupts. */
- | ((setup & STDMSK_CLKENAB) << (CRBBIT_CLKENAB_B - STDBIT_CLKENAB)) /* Clock enable is passed through. */
- |((setup & STDMSK_LOADSRC) >> (STDBIT_LOADSRC - CRBBIT_LOADSRC_B))); /* Preload trigger source is passed through. */
+ s = dev->subdevices + 4;
+ /* digital I/O subdevice */
+ s->type = COMEDI_SUBD_DIO;
+ s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
+ s->n_chan = 16;
+ s->maxdata = 1;
+ s->io_bits = 0xffff;
+ s->private = &dio_private_C;
+ s->range_table = &range_digital;
+ s->insn_config = s626_dio_insn_config;
+ s->insn_bits = s626_dio_insn_bits;
- /* Force IntSrc to Disabled if DisableIntSrc is asserted. */
- if (!DisableIntSrc)
- crb |= ((setup & STDMSK_INTSRC) >> (STDBIT_INTSRC -
- CRBBIT_INTSRC_B));
+ s = dev->subdevices + 5;
+ /* encoder (counter) subdevice */
+ s->type = COMEDI_SUBD_COUNTER;
+ s->subdev_flags = SDF_WRITABLE | SDF_READABLE | SDF_LSAMPL;
+ s->n_chan = thisboard->enc_chans;
+ s->private = enc_private_data;
+ s->insn_config = s626_enc_insn_config;
+ s->insn_read = s626_enc_insn_read;
+ s->insn_write = s626_enc_insn_write;
+ s->maxdata = 0xffffff;
+ s->range_table = &range_unknown;
- /* Populate all mode-dependent attributes of CRA & CRB images. */
- switch ((setup & STDMSK_CLKSRC) >> STDBIT_CLKSRC) {
- case CLKSRC_TIMER: /* Timer Mode: */
- cra |= ((2 << CRABIT_CLKSRC_B) /* ClkSrcB<1> selects system clock */
- |((setup & STDMSK_CLKPOL) << (CRABIT_CLKSRC_B - STDBIT_CLKPOL))); /* with direction (ClkSrcB<0>) obtained from ClkPol. */
- crb |= ((1 << CRBBIT_CLKPOL_B) /* ClkPolB behaves as always-on clock enable. */
- |(MULT_X1 << CRBBIT_CLKMULT_B)); /* ClkMultB must be 1x. */
- break;
+ /* stop ai_command */
+ devpriv->ai_cmd_running = 0;
- case CLKSRC_EXTENDER: /* Extender Mode: */
- cra |= ((2 << CRABIT_CLKSRC_B) /* ClkSrcB source is OverflowA (same as "timer") */
- |((setup & STDMSK_CLKPOL) << (CRABIT_CLKSRC_B - STDBIT_CLKPOL))); /* with direction obtained from ClkPol. */
- crb |= ((1 << CRBBIT_CLKPOL_B) /* ClkPolB controls IndexB -- always set to active. */
- |(MULT_X0 << CRBBIT_CLKMULT_B)); /* ClkMultB selects OverflowA as the clock source. */
- break;
+ if (devpriv->base_addr && (devpriv->allocatedBuf == 2)) {
+ dma_addr_t pPhysBuf;
+ uint16_t chan;
- default: /* Counter Mode: */
- cra |= (CLKSRC_COUNTER << CRABIT_CLKSRC_B); /* Select ENC_C and ENC_D as clock/direction inputs. */
- crb |= (((setup & STDMSK_CLKPOL) >> (STDBIT_CLKPOL - CRBBIT_CLKPOL_B)) /* ClkPol is passed through. */
- |(((setup & STDMSK_CLKMULT) == (MULT_X0 << STDBIT_CLKMULT)) ? /* Force ClkMult to x1 if not legal, otherwise pass through. */
- (MULT_X1 << CRBBIT_CLKMULT_B) :
- ((setup & STDMSK_CLKMULT) << (CRBBIT_CLKMULT_B -
- STDBIT_CLKMULT))));
- }
+ /* enab DEBI and audio pins, enable I2C interface. */
+ MC_ENABLE(P_MC1, MC1_DEBI | MC1_AUDIO | MC1_I2C);
+ /* Configure DEBI operating mode. */
+ WR7146(P_DEBICFG, DEBI_CFG_SLAVE16 /* Local bus is 16 */
+ /* bits wide. */
+ | (DEBI_TOUT << DEBI_CFG_TOUT_BIT)
- /* Force positive index polarity if IndxSrc is software-driven only, */
- /* otherwise pass it through. */
- if (~setup & STDMSK_INDXSRC)
- crb |= ((setup & STDMSK_INDXPOL) >> (STDBIT_INDXPOL -
- CRBBIT_INDXPOL_B));
+ /* Declare DEBI */
+ /* transfer timeout */
+ /* interval. */
+ |DEBI_SWAP /* Set up byte lane */
+ /* steering. */
+ | DEBI_CFG_INTEL); /* Intel-compatible */
+ /* local bus (DEBI */
+ /* never times out). */
- /* If IntSrc has been forced to Disabled, update the MISC2 interrupt */
- /* enable mask to indicate the counter interrupt is disabled. */
- if (DisableIntSrc)
- devpriv->CounterIntEnabs &= ~k->MyEventBits[3];
+ /* DEBI INIT S626 WR7146( P_DEBICFG, DEBI_CFG_INTEL | DEBI_CFG_TOQ */
+ /* | DEBI_CFG_INCQ| DEBI_CFG_16Q); //end */
- /* While retaining CounterA and LatchSrc configurations, program the */
- /* new counter operating mode. */
- DEBIreplace(dev, k->MyCRA,
- (uint16_t) (~(CRAMSK_INDXSRC_B | CRAMSK_CLKSRC_B)), cra);
- DEBIreplace(dev, k->MyCRB, CRBMSK_CLKENAB_A | CRBMSK_LATCHSRC, crb);
-}
+ /* Paging is disabled. */
+ WR7146(P_DEBIPAGE, DEBI_PAGE_DISABLE); /* Disable MMU paging. */
-/* Return/set a counter's enable. enab: 0=always enabled, 1=enabled by index. */
+ /* Init GPIO so that ADC Start* is negated. */
+ WR7146(P_GPIO, GPIO_BASE | GPIO1_HI);
-static void SetEnable_A(struct comedi_device *dev, struct enc_private *k,
- uint16_t enab)
-{
- DEBUG("SetEnable_A: SetEnable_A enter 3541\n");
- DEBIreplace(dev, k->MyCRB,
- (uint16_t) (~(CRBMSK_INTCTRL | CRBMSK_CLKENAB_A)),
- (uint16_t) (enab << CRBBIT_CLKENAB_A));
-}
+ /* IsBoardRevA is a boolean that indicates whether the board is RevA.
+ *
+ * VERSION 2.01 CHANGE: REV A & B BOARDS NOW SUPPORTED BY DYNAMIC
+ * EEPROM ADDRESS SELECTION. Initialize the I2C interface, which
+ * is used to access the onboard serial EEPROM. The EEPROM's I2C
+ * DeviceAddress is hardwired to a value that is dependent on the
+ * 626 board revision. On all board revisions, the EEPROM stores
+ * TrimDAC calibration constants for analog I/O. On RevB and
+ * higher boards, the DeviceAddress is hardwired to 0 to enable
+ * the EEPROM to also store the PCI SubVendorID and SubDeviceID;
+ * this is the address at which the SAA7146 expects a
+ * configuration EEPROM to reside. On RevA boards, the EEPROM
+ * device address, which is hardwired to 4, prevents the SAA7146
+ * from retrieving PCI sub-IDs, so the SAA7146 uses its built-in
+ * default values, instead.
+ */
-static void SetEnable_B(struct comedi_device *dev, struct enc_private *k,
- uint16_t enab)
-{
- DEBIreplace(dev, k->MyCRB,
- (uint16_t) (~(CRBMSK_INTCTRL | CRBMSK_CLKENAB_B)),
- (uint16_t) (enab << CRBBIT_CLKENAB_B));
-}
+ /* devpriv->I2Cards= IsBoardRevA ? 0xA8 : 0xA0; // Set I2C EEPROM */
+ /* DeviceType (0xA0) */
+ /* and DeviceAddress<<1. */
-static uint16_t GetEnable_A(struct comedi_device *dev, struct enc_private *k)
-{
- return (DEBIread(dev, k->MyCRB) >> CRBBIT_CLKENAB_A) & 1;
-}
+ devpriv->I2CAdrs = 0xA0; /* I2C device address for onboard */
+ /* eeprom(revb) */
-static uint16_t GetEnable_B(struct comedi_device *dev, struct enc_private *k)
-{
- return (DEBIread(dev, k->MyCRB) >> CRBBIT_CLKENAB_B) & 1;
-}
+ /* Issue an I2C ABORT command to halt any I2C operation in */
+ /* progress and reset BUSY flag. */
+ WR7146(P_I2CSTAT, I2C_CLKSEL | I2C_ABORT);
+ /* Write I2C control: abort any I2C activity. */
+ MC_ENABLE(P_MC2, MC2_UPLD_IIC);
+ /* Invoke command upload */
+ while ((RR7146(P_MC2) & MC2_UPLD_IIC) == 0)
+ ;
+ /* and wait for upload to complete. */
-/* Return/set a counter pair's latch trigger source. 0: On read
- * access, 1: A index latches A, 2: B index latches B, 3: A overflow
- * latches B.
- */
+ /* Per SAA7146 data sheet, write to STATUS reg twice to
+ * reset all I2C error flags. */
+ for (i = 0; i < 2; i++) {
+ WR7146(P_I2CSTAT, I2C_CLKSEL);
+ /* Write I2C control: reset error flags. */
+ MC_ENABLE(P_MC2, MC2_UPLD_IIC); /* Invoke command upload */
+ while (!MC_TEST(P_MC2, MC2_UPLD_IIC))
+ ;
+ /* and wait for upload to complete. */
+ }
-static void SetLatchSource(struct comedi_device *dev, struct enc_private *k,
- uint16_t value)
-{
- DEBUG("SetLatchSource: SetLatchSource enter 3550\n");
- DEBIreplace(dev, k->MyCRB,
- (uint16_t) (~(CRBMSK_INTCTRL | CRBMSK_LATCHSRC)),
- (uint16_t) (value << CRBBIT_LATCHSRC));
+ /* Init audio interface functional attributes: set DAC/ADC
+ * serial clock rates, invert DAC serial clock so that
+ * DAC data setup times are satisfied, enable DAC serial
+ * clock out.
+ */
- DEBUG("SetLatchSource: SetLatchSource exit\n");
-}
+ WR7146(P_ACON2, ACON2_INIT);
-/*
- * static uint16_t GetLatchSource(struct comedi_device *dev, struct enc_private *k )
- * {
- * return ( DEBIread( dev, k->MyCRB) >> CRBBIT_LATCHSRC ) & 3;
- * }
- */
+ /* Set up TSL1 slot list, which is used to control the
+ * accumulation of ADC data: RSD1 = shift data in on SD1.
+ * SIB_A1 = store data uint8_t at next available location in
+ * FB BUFFER1 register. */
+ WR7146(P_TSL1, RSD1 | SIB_A1);
+ /* Fetch ADC high data uint8_t. */
+ WR7146(P_TSL1 + 4, RSD1 | SIB_A1 | EOS);
+ /* Fetch ADC low data uint8_t; end of TSL1. */
-/*
- * Return/set the event that will trigger transfer of the preload
- * register into the counter. 0=ThisCntr_Index, 1=ThisCntr_Overflow,
- * 2=OverflowA (B counters only), 3=disabled.
- */
+ /* enab TSL1 slot list so that it executes all the time. */
+ WR7146(P_ACON1, ACON1_ADCSTART);
-static void SetLoadTrig_A(struct comedi_device *dev, struct enc_private *k,
- uint16_t Trig)
-{
- DEBIreplace(dev, k->MyCRA, (uint16_t) (~CRAMSK_LOADSRC_A),
- (uint16_t) (Trig << CRABIT_LOADSRC_A));
-}
+ /* Initialize RPS registers used for ADC. */
-static void SetLoadTrig_B(struct comedi_device *dev, struct enc_private *k,
- uint16_t Trig)
-{
- DEBIreplace(dev, k->MyCRB,
- (uint16_t) (~(CRBMSK_LOADSRC_B | CRBMSK_INTCTRL)),
- (uint16_t) (Trig << CRBBIT_LOADSRC_B));
-}
+ /* Physical start of RPS program. */
+ WR7146(P_RPSADDR1, (uint32_t) devpriv->RPSBuf.PhysicalBase);
-static uint16_t GetLoadTrig_A(struct comedi_device *dev, struct enc_private *k)
-{
- return (DEBIread(dev, k->MyCRA) >> CRABIT_LOADSRC_A) & 3;
-}
+ WR7146(P_RPSPAGE1, 0);
+ /* RPS program performs no explicit mem writes. */
+ WR7146(P_RPS1_TOUT, 0); /* Disable RPS timeouts. */
-static uint16_t GetLoadTrig_B(struct comedi_device *dev, struct enc_private *k)
-{
- return (DEBIread(dev, k->MyCRB) >> CRBBIT_LOADSRC_B) & 3;
-}
+ /* SAA7146 BUG WORKAROUND. Initialize SAA7146 ADC interface
+ * to a known state by invoking ADCs until FB BUFFER 1
+ * register shows that it is correctly receiving ADC data.
+ * This is necessary because the SAA7146 ADC interface does
+ * not start up in a defined state after a PCI reset.
+ */
-/* Return/set counter interrupt source and clear any captured
- * index/overflow events. IntSource: 0=Disabled, 1=OverflowOnly,
- * 2=IndexOnly, 3=IndexAndOverflow.
- */
+/* PollList = EOPL; // Create a simple polling */
+/* // list for analog input */
+/* // channel 0. */
+/* ResetADC( dev, &PollList ); */
-static void SetIntSrc_A(struct comedi_device *dev, struct enc_private *k,
- uint16_t IntSource)
-{
- /* Reset any pending counter overflow or index captures. */
- DEBIreplace(dev, k->MyCRB, (uint16_t) (~CRBMSK_INTCTRL),
- CRBMSK_INTRESETCMD | CRBMSK_INTRESET_A);
+/* s626_ai_rinsn(dev,dev->subdevices,NULL,data); //( &AdcData ); // */
+/* //Get initial ADC */
+/* //value. */
- /* Program counter interrupt source. */
- DEBIreplace(dev, k->MyCRA, ~CRAMSK_INTSRC_A,
- (uint16_t) (IntSource << CRABIT_INTSRC_A));
+/* StartVal = data[0]; */
- /* Update MISC2 interrupt enable mask. */
- devpriv->CounterIntEnabs =
- (devpriv->CounterIntEnabs & ~k->
- MyEventBits[3]) | k->MyEventBits[IntSource];
-}
+/* // VERSION 2.01 CHANGE: TIMEOUT ADDED TO PREVENT HANGED EXECUTION. */
+/* // Invoke ADCs until the new ADC value differs from the initial */
+/* // value or a timeout occurs. The timeout protects against the */
+/* // possibility that the driver is restarting and the ADC data is a */
+/* // fixed value resulting from the applied ADC analog input being */
+/* // unusually quiet or at the rail. */
-static void SetIntSrc_B(struct comedi_device *dev, struct enc_private *k,
- uint16_t IntSource)
-{
- uint16_t crb;
+/* for ( index = 0; index < 500; index++ ) */
+/* { */
+/* s626_ai_rinsn(dev,dev->subdevices,NULL,data); */
+/* AdcData = data[0]; //ReadADC( &AdcData ); */
+/* if ( AdcData != StartVal ) */
+/* break; */
+/* } */
- /* Cache writeable CRB register image. */
- crb = DEBIread(dev, k->MyCRB) & ~CRBMSK_INTCTRL;
+ /* end initADC */
- /* Reset any pending counter overflow or index captures. */
- DEBIwrite(dev, k->MyCRB,
- (uint16_t) (crb | CRBMSK_INTRESETCMD | CRBMSK_INTRESET_B));
+ /* init the DAC interface */
- /* Program counter interrupt source. */
- DEBIwrite(dev, k->MyCRB,
- (uint16_t) ((crb & ~CRBMSK_INTSRC_B) | (IntSource <<
- CRBBIT_INTSRC_B)));
+ /* Init Audio2's output DMAC attributes: burst length = 1
+ * DWORD, threshold = 1 DWORD.
+ */
+ WR7146(P_PCI_BT_A, 0);
- /* Update MISC2 interrupt enable mask. */
- devpriv->CounterIntEnabs =
- (devpriv->CounterIntEnabs & ~k->
- MyEventBits[3]) | k->MyEventBits[IntSource];
-}
+ /* Init Audio2's output DMA physical addresses. The protection
+ * address is set to 1 DWORD past the base address so that a
+ * single DWORD will be transferred each time a DMA transfer is
+ * enabled. */
-static uint16_t GetIntSrc_A(struct comedi_device *dev, struct enc_private *k)
-{
- return (DEBIread(dev, k->MyCRA) >> CRABIT_INTSRC_A) & 3;
-}
+ pPhysBuf =
+ devpriv->ANABuf.PhysicalBase +
+ (DAC_WDMABUF_OS * sizeof(uint32_t));
-static uint16_t GetIntSrc_B(struct comedi_device *dev, struct enc_private *k)
-{
- return (DEBIread(dev, k->MyCRB) >> CRBBIT_INTSRC_B) & 3;
-}
+ WR7146(P_BASEA2_OUT, (uint32_t) pPhysBuf); /* Buffer base adrs. */
+ WR7146(P_PROTA2_OUT, (uint32_t) (pPhysBuf + sizeof(uint32_t))); /* Protection address. */
-/* Return/set the clock multiplier. */
+ /* Cache Audio2's output DMA buffer logical address. This is
+ * where DAC data is buffered for A2 output DMA transfers. */
+ devpriv->pDacWBuf =
+ (uint32_t *) devpriv->ANABuf.LogicalBase + DAC_WDMABUF_OS;
-/* static void SetClkMult(struct comedi_device *dev, struct enc_private *k, uint16_t value ) */
-/* { */
-/* k->SetMode(dev, k, (uint16_t)( ( k->GetMode(dev, k ) & ~STDMSK_CLKMULT ) | ( value << STDBIT_CLKMULT ) ), FALSE ); */
-/* } */
+ /* Audio2's output channels does not use paging. The protection
+ * violation handling bit is set so that the DMAC will
+ * automatically halt and its PCI address pointer will be reset
+ * when the protection address is reached. */
-/* static uint16_t GetClkMult(struct comedi_device *dev, struct enc_private *k ) */
-/* { */
-/* return ( k->GetMode(dev, k ) >> STDBIT_CLKMULT ) & 3; */
-/* } */
+ WR7146(P_PAGEA2_OUT, 8);
-/* Return/set the clock polarity. */
+ /* Initialize time slot list 2 (TSL2), which is used to control
+ * the clock generation for and serialization of data to be sent
+ * to the DAC devices. Slot 0 is a NOP that is used to trap TSL
+ * execution; this permits other slots to be safely modified
+ * without first turning off the TSL sequencer (which is
+ * apparently impossible to do). Also, SD3 (which is driven by a
+ * pull-up resistor) is shifted in and stored to the MSB of
+ * FB_BUFFER2 to be used as evidence that the slot sequence has
+ * not yet finished executing.
+ */
-/* static void SetClkPol( struct comedi_device *dev,struct enc_private *k, uint16_t value ) */
-/* { */
-/* k->SetMode(dev, k, (uint16_t)( ( k->GetMode(dev, k ) & ~STDMSK_CLKPOL ) | ( value << STDBIT_CLKPOL ) ), FALSE ); */
-/* } */
+ SETVECT(0, XSD2 | RSD3 | SIB_A2 | EOS);
+ /* Slot 0: Trap TSL execution, shift 0xFF into FB_BUFFER2. */
-/* static uint16_t GetClkPol(struct comedi_device *dev, struct enc_private *k ) */
-/* { */
-/* return ( k->GetMode(dev, k ) >> STDBIT_CLKPOL ) & 1; */
-/* } */
+ /* Initialize slot 1, which is constant. Slot 1 causes a
+ * DWORD to be transferred from audio channel 2's output FIFO
+ * to the FIFO's output buffer so that it can be serialized
+ * and sent to the DAC during subsequent slots. All remaining
+ * slots are dynamically populated as required by the target
+ * DAC device.
+ */
+ SETVECT(1, LF_A2);
+ /* Slot 1: Fetch DWORD from Audio2's output FIFO. */
-/* Return/set the clock source. */
+ /* Start DAC's audio interface (TSL2) running. */
+ WR7146(P_ACON1, ACON1_DACSTART);
-/* static void SetClkSrc( struct comedi_device *dev,struct enc_private *k, uint16_t value ) */
-/* { */
-/* k->SetMode(dev, k, (uint16_t)( ( k->GetMode(dev, k ) & ~STDMSK_CLKSRC ) | ( value << STDBIT_CLKSRC ) ), FALSE ); */
-/* } */
+ /* end init DAC interface */
-/* static uint16_t GetClkSrc( struct comedi_device *dev,struct enc_private *k ) */
-/* { */
-/* return ( k->GetMode(dev, k ) >> STDBIT_CLKSRC ) & 3; */
-/* } */
+ /* Init Trim DACs to calibrated values. Do it twice because the
+ * SAA7146 audio channel does not always reset properly and
+ * sometimes causes the first few TrimDAC writes to malfunction.
+ */
-/* Return/set the index polarity. */
+ LoadTrimDACs(dev);
+ LoadTrimDACs(dev); /* Insurance. */
-/* static void SetIndexPol(struct comedi_device *dev, struct enc_private *k, uint16_t value ) */
-/* { */
-/* k->SetMode(dev, k, (uint16_t)( ( k->GetMode(dev, k ) & ~STDMSK_INDXPOL ) | ( (value != 0) << STDBIT_INDXPOL ) ), FALSE ); */
-/* } */
+ /* Manually init all gate array hardware in case this is a soft
+ * reset (we have no way of determining whether this is a warm
+ * or cold start). This is necessary because the gate array will
+ * reset only in response to a PCI hard reset; there is no soft
+ * reset function. */
-/* static uint16_t GetIndexPol(struct comedi_device *dev, struct enc_private *k ) */
-/* { */
-/* return ( k->GetMode(dev, k ) >> STDBIT_INDXPOL ) & 1; */
-/* } */
+ /* Init all DAC outputs to 0V and init all DAC setpoint and
+ * polarity images.
+ */
+ for (chan = 0; chan < S626_DAC_CHANNELS; chan++)
+ SetDAC(dev, chan, 0);
-/* Return/set the index source. */
+ /* Init image of WRMISC2 Battery Charger Enabled control bit.
+ * This image is used when the state of the charger control bit,
+ * which has no direct hardware readback mechanism, is queried.
+ */
+ devpriv->ChargeEnabled = 0;
-/* static void SetIndexSrc(struct comedi_device *dev, struct enc_private *k, uint16_t value ) */
-/* { */
-/* DEBUG("SetIndexSrc: set index src enter 3700\n"); */
-/* k->SetMode(dev, k, (uint16_t)( ( k->GetMode(dev, k ) & ~STDMSK_INDXSRC ) | ( (value != 0) << STDBIT_INDXSRC ) ), FALSE ); */
-/* } */
+ /* Init image of watchdog timer interval in WRMISC2. This image
+ * maintains the value of the control bits of MISC2 are
+ * continuously reset to zero as long as the WD timer is disabled.
+ */
+ devpriv->WDInterval = 0;
-/* static uint16_t GetIndexSrc(struct comedi_device *dev, struct enc_private *k ) */
-/* { */
-/* return ( k->GetMode(dev, k ) >> STDBIT_INDXSRC ) & 1; */
-/* } */
+ /* Init Counter Interrupt enab mask for RDMISC2. This mask is
+ * applied against MISC2 when testing to determine which timer
+ * events are requesting interrupt service.
+ */
+ devpriv->CounterIntEnabs = 0;
-/* Generate an index pulse. */
+ /* Init counters. */
+ CountersInit(dev);
-static void PulseIndex_A(struct comedi_device *dev, struct enc_private *k)
-{
- register uint16_t cra;
+ /* Without modifying the state of the Battery Backup enab, disable
+ * the watchdog timer, set DIO channels 0-5 to operate in the
+ * standard DIO (vs. counter overflow) mode, disable the battery
+ * charger, and reset the watchdog interval selector to zero.
+ */
+ WriteMISC2(dev, (uint16_t) (DEBIread(dev,
+ LP_RDMISC2) &
+ MISC2_BATT_ENABLE));
- DEBUG("PulseIndex_A: pulse index enter\n");
+ /* Initialize the digital I/O subsystem. */
+ s626_dio_init(dev);
- cra = DEBIread(dev, k->MyCRA); /* Pulse index. */
- DEBIwrite(dev, k->MyCRA, (uint16_t) (cra ^ CRAMSK_INDXPOL_A));
- DEBUG("PulseIndex_A: pulse index step1\n");
- DEBIwrite(dev, k->MyCRA, cra);
+ /* enable interrupt test */
+ /* writel(IRQ_GPIO3 | IRQ_RPS1,devpriv->base_addr+P_IER); */
+ }
+
+ return 1;
}
-static void PulseIndex_B(struct comedi_device *dev, struct enc_private *k)
+static void s626_detach(struct comedi_device *dev)
{
- register uint16_t crb;
+ if (devpriv) {
+ /* stop ai_command */
+ devpriv->ai_cmd_running = 0;
- crb = DEBIread(dev, k->MyCRB) & ~CRBMSK_INTCTRL; /* Pulse index. */
- DEBIwrite(dev, k->MyCRB, (uint16_t) (crb ^ CRBMSK_INDXPOL_B));
- DEBIwrite(dev, k->MyCRB, crb);
-}
+ if (devpriv->base_addr) {
+ /* interrupt mask */
+ WR7146(P_IER, 0); /* Disable master interrupt. */
+ WR7146(P_ISR, IRQ_GPIO3 | IRQ_RPS1); /* Clear board's IRQ status flag. */
-/* Write value into counter preload register. */
+ /* Disable the watchdog timer and battery charger. */
+ WriteMISC2(dev, 0);
-static void Preload(struct comedi_device *dev, struct enc_private *k,
- uint32_t value)
-{
- DEBUG("Preload: preload enter\n");
- DEBIwrite(dev, (uint16_t) (k->MyLatchLsw), (uint16_t) value); /* Write value to preload register. */
- DEBUG("Preload: preload step 1\n");
- DEBIwrite(dev, (uint16_t) (k->MyLatchLsw + 2),
- (uint16_t) (value >> 16));
-}
+ /* Close all interfaces on 7146 device. */
+ WR7146(P_MC1, MC1_SHUTDOWN);
+ WR7146(P_ACON1, ACON1_BASE);
-static void CountersInit(struct comedi_device *dev)
-{
- int chan;
- struct enc_private *k;
- uint16_t Setup = (LOADSRC_INDX << BF_LOADSRC) | /* Preload upon */
- /* index. */
- (INDXSRC_SOFT << BF_INDXSRC) | /* Disable hardware index. */
- (CLKSRC_COUNTER << BF_CLKSRC) | /* Operating mode is counter. */
- (CLKPOL_POS << BF_CLKPOL) | /* Active high clock. */
- (CNTDIR_UP << BF_CLKPOL) | /* Count direction is up. */
- (CLKMULT_1X << BF_CLKMULT) | /* Clock multiplier is 1x. */
- (CLKENAB_INDEX << BF_CLKENAB); /* Enabled by index */
+ CloseDMAB(dev, &devpriv->RPSBuf, DMABUF_SIZE);
+ CloseDMAB(dev, &devpriv->ANABuf, DMABUF_SIZE);
+ }
- /* Disable all counter interrupts and clear any captured counter events. */
- for (chan = 0; chan < S626_ENCODER_CHANNELS; chan++) {
- k = &encpriv[chan];
- k->SetMode(dev, k, Setup, TRUE);
- k->SetIntSrc(dev, k, 0);
- k->ResetCapFlags(dev, k);
- k->SetEnable(dev, k, CLKENAB_ALWAYS);
+ if (dev->irq)
+ free_irq(dev->irq, dev);
+ if (devpriv->base_addr)
+ iounmap(devpriv->base_addr);
+ if (devpriv->pdev) {
+ if (devpriv->got_regions)
+ comedi_pci_disable(devpriv->pdev);
+ pci_dev_put(devpriv->pdev);
+ }
}
- DEBUG("CountersInit: counters initialized\n");
-
}
static struct comedi_driver s626_driver = {
comedi_do_insn(cf,&insn); // executing configuration
*/
-#ifdef _DEBUG_
-#define DEBUG(...); printk(__VA_ARGS__);
-#else
-#define DEBUG(...)
-#endif
-
#if !defined(TRUE)
#define TRUE (1)
#endif
#define FALSE (0)
#endif
-#if !defined(INLINE)
-#define INLINE static __inline
-#endif
-
#include<linux/slab.h>
#define S626_SIZE 0x0200
const char *name;
};
-/*
- * Useful for shorthand access to the particular board structure
- */
-#define thisboard ((const struct serial2002_board *)dev->board_ptr)
-
struct serial2002_range_table_t {
/* HACK... */
if (result) {
if (devpriv->tty) {
- filp_close(devpriv->tty, 0);
+ filp_close(devpriv->tty, NULL);
devpriv->tty = NULL;
}
}
static void serial_2002_close(struct comedi_device *dev)
{
- if (!IS_ERR(devpriv->tty) && (devpriv->tty != 0))
- filp_close(devpriv->tty, 0);
+ if (!IS_ERR(devpriv->tty) && devpriv->tty)
+ filp_close(devpriv->tty, NULL);
}
static int serial2002_di_rinsn(struct comedi_device *dev,
static int serial2002_attach(struct comedi_device *dev,
struct comedi_devconfig *it)
{
+ const struct serial2002_board *board = comedi_board(dev);
struct comedi_subdevice *s;
+ int ret;
- dev_dbg(dev->hw_dev, "comedi%d: attached\n", dev->minor);
- dev->board_name = thisboard->name;
+ dev_dbg(dev->class_dev, "serial2002: attach\n");
+ dev->board_name = board->name;
if (alloc_private(dev, sizeof(struct serial2002_private)) < 0)
return -ENOMEM;
dev->open = serial_2002_open;
dev->close = serial_2002_close;
devpriv->port = it->options[0];
devpriv->speed = it->options[1];
- dev_dbg(dev->hw_dev, "/dev/ttyS%d @ %d\n", devpriv->port,
+ dev_dbg(dev->class_dev, "/dev/ttyS%d @ %d\n", devpriv->port,
devpriv->speed);
- if (alloc_subdevices(dev, 5) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 5);
+ if (ret)
+ return ret;
/* digital input subdevice */
s = dev->subdevices + 0;
s->subdev_flags = SDF_READABLE | SDF_GROUND;
s->n_chan = 0;
s->maxdata = 1;
- s->range_table = 0;
+ s->range_table = NULL;
s->insn_read = &serial2002_ai_rinsn;
/* analog output subdevice */
s->subdev_flags = SDF_WRITEABLE;
s->n_chan = 0;
s->maxdata = 1;
- s->range_table = 0;
+ s->range_table = NULL;
s->insn_write = &serial2002_ao_winsn;
s->insn_read = &serial2002_ao_rinsn;
s->subdev_flags = SDF_READABLE | SDF_LSAMPL;
s->n_chan = 0;
s->maxdata = 1;
- s->range_table = 0;
+ s->range_table = NULL;
s->insn_read = &serial2002_ei_rinsn;
return 1;
static int skel_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
struct comedi_subdevice *s;
+ int ret;
pr_info("comedi%d: skel: ", dev->minor);
if (alloc_private(dev, sizeof(struct skel_private)) < 0)
return -ENOMEM;
-/*
- * Allocate the subdevice structures. alloc_subdevice() is a
- * convenient macro defined in comedidev.h.
- */
- if (alloc_subdevices(dev, 3) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 3);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* dev->read_subdev=s; */
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
- if (insn->n != 2)
- return -EINVAL;
-
/* The insn data is a mask in data[0] and the new data
* in data[1], each channel cooresponding to a bit. */
if (data[0]) {
* it was a purely digital output subdevice */
/* data[1]=s->state; */
- return 2;
+ return insn->n;
}
static int skel_dio_insn_config(struct comedi_device *dev,
return insn->n;
}
-#ifdef CONFIG_COMEDI_PCI
+#ifdef CONFIG_COMEDI_PCI_DRIVERS
static int __devinit driver_skel_pci_probe(struct pci_dev *dev,
const struct pci_device_id *ent)
{
int have_dio;
};
-/* Useful for shorthand access to the particular board structure ----------- */
-#define thisboard ((const struct dnp_board *)dev->board_ptr)
-
-/* This structure is for data unique to the DNP driver --------------------- */
-struct dnp_private_data {
-
-};
-
-/* Shorthand macro for faster access to the private data ------------------- */
-#define devpriv ((dnp_private *)dev->private)
-
/* ------------------------------------------------------------------------- */
/* The insn_bits interface allows packed reading/writing of DIO channels. */
/* The comedi core can convert between insn_bits and insn_read/write, so you */
struct comedi_subdevice *s,
struct comedi_insn *insn, unsigned int *data)
{
-
- if (insn->n != 2)
- return -EINVAL; /* insn uses data[0] and data[1] */
-
/* The insn data is a mask in data[0] and the new data in data[1], */
/* each channel cooresponding to a bit. */
outb(PCDR, CSCIR);
data[0] += ((inb(CSCDR) & 0xF0) << 12);
- return 2;
+ return insn->n;
}
static int dnp_attach(struct comedi_device *dev, struct comedi_devconfig *it)
{
+ const struct dnp_board *board = comedi_board(dev);
struct comedi_subdevice *s;
+ int ret;
printk(KERN_INFO "comedi%d: dnp: ", dev->minor);
- /* Autoprobing: this should find out which board we have. Currently */
- /* only the 1486 board is supported and autoprobing is not */
- /* implemented :-) */
- /* dev->board_ptr = dnp_probe(dev); */
-
- /* Initialize the name of the board. */
- /* We can use the "thisboard" macro now. */
- dev->board_name = thisboard->name;
-
- /* Allocate the private structure area. alloc_private() is a */
- /* convenient macro defined in comedidev.h. */
- if (alloc_private(dev, sizeof(struct dnp_private_data)) < 0)
- return -ENOMEM;
-
- /* Allocate the subdevice structures. alloc_subdevice() is a */
- /* convenient macro defined in comedidev.h. */
+ dev->board_name = board->name;
- if (alloc_subdevices(dev, 1) < 0)
- return -ENOMEM;
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret)
+ return ret;
s = dev->subdevices + 0;
/* digital i/o subdevice */
{
int iobase, i, n_subd;
int id, num, ba;
+ int ret;
iobase = it->options[0];
return -1;
}
- if (alloc_subdevices(dev, n_subd) < 0) {
- printk(KERN_ERR "out of memory\n");
- return -ENOMEM;
- }
+ ret = comedi_alloc_subdevices(dev, n_subd);
+ if (ret)
+ return ret;
/* initializing each of for same subdevices */
for (i = 0; i < n_subd; i++, iobase += UNIOXX5_SUBDEV_ODDS) {
-#define DRIVER_VERSION "v2.4"
-#define DRIVER_AUTHOR "Bernd Porr, BerndPorr@f2s.com"
-#define DRIVER_DESC "Stirling/ITL USB-DUX -- Bernd.Porr@f2s.com"
/*
comedi/drivers/usbdux.c
Copyright (C) 2003-2007 Bernd Porr, Bernd.Porr@f2s.com
#include "../comedidev.h"
-#define BOARDNAME "usbdux"
-
/* timeout for the USB-transfer in ms*/
#define BULK_TIMEOUT 1000
static DEFINE_SEMAPHORE(start_stop_sem);
-static struct comedi_driver driver_usbdux; /* see below for initializer */
-
/*
* Stops the data acquision
* It should be safe to call this function from any context
if (!this_usbduxsub)
return -EFAULT;
- if (insn->n != 2)
- return -EINVAL;
-
down(&this_usbduxsub->sem);
if (!(this_usbduxsub->probed)) {
data[1] = le16_to_cpu(this_usbduxsub->insnBuffer[1]);
up(&this_usbduxsub->sem);
- return 2;
+ return insn->n;
}
/* reads the 4 counters, only two are used just now */
usbduxsub_tmp->pwm_cmd_running = 0;
}
+/* common part of attach and attach_usb */
+static int usbdux_attach_common(struct comedi_device *dev,
+ struct usbduxsub *udev,
+ void *aux_data, int aux_len)
+{
+ int ret;
+ struct comedi_subdevice *s = NULL;
+ int n_subdevs;
+
+ down(&udev->sem);
+ /* pointer back to the corresponding comedi device */
+ udev->comedidev = dev;
+
+ /* trying to upload the firmware into the chip */
+ if (aux_data)
+ firmwareUpload(udev, aux_data, aux_len);
+
+ dev->board_name = "usbdux";
+
+ /* set number of subdevices */
+ if (udev->high_speed) {
+ /* with pwm */
+ n_subdevs = 5;
+ } else {
+ /* without pwm */
+ n_subdevs = 4;
+ }
+
+ ret = comedi_alloc_subdevices(dev, n_subdevs);
+ if (ret) {
+ up(&udev->sem);
+ return ret;
+ }
+
+ /* private structure is also simply the usb-structure */
+ dev->private = udev;
+
+ /* the first subdevice is the A/D converter */
+ s = dev->subdevices + SUBDEV_AD;
+ /* the URBs get the comedi subdevice */
+ /* which is responsible for reading */
+ /* this is the subdevice which reads data */
+ dev->read_subdev = s;
+ /* the subdevice receives as private structure the */
+ /* usb-structure */
+ s->private = NULL;
+ /* analog input */
+ s->type = COMEDI_SUBD_AI;
+ /* readable and ref is to ground */
+ s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
+ /* 8 channels */
+ s->n_chan = 8;
+ /* length of the channellist */
+ s->len_chanlist = 8;
+ /* callback functions */
+ s->insn_read = usbdux_ai_insn_read;
+ s->do_cmdtest = usbdux_ai_cmdtest;
+ s->do_cmd = usbdux_ai_cmd;
+ s->cancel = usbdux_ai_cancel;
+ /* max value from the A/D converter (12bit) */
+ s->maxdata = 0xfff;
+ /* range table to convert to physical units */
+ s->range_table = (&range_usbdux_ai_range);
+
+ /* analog out */
+ s = dev->subdevices + SUBDEV_DA;
+ /* analog out */
+ s->type = COMEDI_SUBD_AO;
+ /* backward pointer */
+ dev->write_subdev = s;
+ /* the subdevice receives as private structure the */
+ /* usb-structure */
+ s->private = NULL;
+ /* are writable */
+ s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
+ /* 4 channels */
+ s->n_chan = 4;
+ /* length of the channellist */
+ s->len_chanlist = 4;
+ /* 12 bit resolution */
+ s->maxdata = 0x0fff;
+ /* bipolar range */
+ s->range_table = (&range_usbdux_ao_range);
+ /* callback */
+ s->do_cmdtest = usbdux_ao_cmdtest;
+ s->do_cmd = usbdux_ao_cmd;
+ s->cancel = usbdux_ao_cancel;
+ s->insn_read = usbdux_ao_insn_read;
+ s->insn_write = usbdux_ao_insn_write;
+
+ /* digital I/O */
+ s = dev->subdevices + SUBDEV_DIO;
+ s->type = COMEDI_SUBD_DIO;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ s->n_chan = 8;
+ s->maxdata = 1;
+ s->range_table = (&range_digital);
+ s->insn_bits = usbdux_dio_insn_bits;
+ s->insn_config = usbdux_dio_insn_config;
+ /* we don't use it */
+ s->private = NULL;
+
+ /* counter */
+ s = dev->subdevices + SUBDEV_COUNTER;
+ s->type = COMEDI_SUBD_COUNTER;
+ s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
+ s->n_chan = 4;
+ s->maxdata = 0xFFFF;
+ s->insn_read = usbdux_counter_read;
+ s->insn_write = usbdux_counter_write;
+ s->insn_config = usbdux_counter_config;
+
+ if (udev->high_speed) {
+ /* timer / pwm */
+ s = dev->subdevices + SUBDEV_PWM;
+ s->type = COMEDI_SUBD_PWM;
+ s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE;
+ s->n_chan = 8;
+ /* this defines the max duty cycle resolution */
+ s->maxdata = udev->sizePwmBuf;
+ s->insn_write = usbdux_pwm_write;
+ s->insn_read = usbdux_pwm_read;
+ s->insn_config = usbdux_pwm_config;
+ usbdux_pwm_period(dev, s, PWM_DEFAULT_PERIOD);
+ }
+ /* finally decide that it's attached */
+ udev->attached = 1;
+
+ up(&udev->sem);
+
+ dev_info(&udev->interface->dev, "comedi%d: attached to usbdux.\n",
+ dev->minor);
+
+ return 0;
+}
+
+/* is called when comedi-config is called */
+static int usbdux_attach(struct comedi_device *dev, struct comedi_devconfig *it)
+{
+ int ret;
+ int index;
+ int i;
+ void *aux_data;
+ int aux_len;
+
+ dev->private = NULL;
+
+ aux_data = comedi_aux_data(it->options, 0);
+ aux_len = it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH];
+ if (aux_data == NULL)
+ aux_len = 0;
+ else if (aux_len == 0)
+ aux_data = NULL;
+
+ down(&start_stop_sem);
+ /* find a valid device which has been detected by the probe function of
+ * the usb */
+ index = -1;
+ for (i = 0; i < NUMUSBDUX; i++) {
+ if ((usbduxsub[i].probed) && (!usbduxsub[i].attached)) {
+ index = i;
+ break;
+ }
+ }
+
+ if (index < 0) {
+ printk(KERN_ERR
+ "comedi%d: usbdux: error: attach failed, no usbdux devs connected to the usb bus.\n",
+ dev->minor);
+ ret = -ENODEV;
+ } else
+ ret = usbdux_attach_common(dev, &usbduxsub[index],
+ aux_data, aux_len);
+ up(&start_stop_sem);
+ return ret;
+}
+
+/* is called from comedi_usb_auto_config() */
+static int usbdux_attach_usb(struct comedi_device *dev,
+ struct usb_interface *uinterf)
+{
+ int ret;
+ struct usbduxsub *this_usbduxsub;
+
+ dev->private = NULL;
+
+ down(&start_stop_sem);
+ this_usbduxsub = usb_get_intfdata(uinterf);
+ if (!this_usbduxsub || !this_usbduxsub->probed) {
+ printk(KERN_ERR
+ "comedi%d: usbdux: error: attach_usb failed, not connected\n",
+ dev->minor);
+ ret = -ENODEV;
+ } else if (this_usbduxsub->attached) {
+ printk(KERN_ERR
+ "comedi%d: usbdux: error: attach_usb failed, already attached\n",
+ dev->minor);
+ ret = -ENODEV;
+ } else
+ ret = usbdux_attach_common(dev, this_usbduxsub, NULL, 0);
+ up(&start_stop_sem);
+ return ret;
+}
+
+static void usbdux_detach(struct comedi_device *dev)
+{
+ struct usbduxsub *usb = dev->private;
+
+ if (usb) {
+ down(&usb->sem);
+ dev->private = NULL;
+ usb->attached = 0;
+ usb->comedidev = NULL;
+ up(&usb->sem);
+ }
+}
+
+static struct comedi_driver usbdux_driver = {
+ .driver_name = "usbdux",
+ .module = THIS_MODULE,
+ .attach = usbdux_attach,
+ .detach = usbdux_detach,
+ .attach_usb = usbdux_attach_usb,
+};
+
static void usbdux_firmware_request_complete_handler(const struct firmware *fw,
void *context)
{
"Could not upload firmware (err=%d)\n", ret);
goto out;
}
- comedi_usb_auto_config(uinterf, &driver_usbdux);
+ comedi_usb_auto_config(uinterf, &usbdux_driver);
out:
release_firmware(fw);
}
-/* allocate memory for the urbs and initialise them */
-static int usbduxsub_probe(struct usb_interface *uinterf,
- const struct usb_device_id *id)
+static int usbdux_usb_probe(struct usb_interface *uinterf,
+ const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(uinterf);
struct device *dev = &uinterf->dev;
return 0;
}
-static void usbduxsub_disconnect(struct usb_interface *intf)
+static void usbdux_usb_disconnect(struct usb_interface *intf)
{
struct usbduxsub *usbduxsub_tmp = usb_get_intfdata(intf);
struct usb_device *udev = interface_to_usbdev(intf);
dev_dbg(&intf->dev, "comedi_: disconnected from the usb\n");
}
-/* common part of attach and attach_usb */
-static int usbdux_attach_common(struct comedi_device *dev,
- struct usbduxsub *udev,
- void *aux_data, int aux_len)
-{
- int ret;
- struct comedi_subdevice *s = NULL;
-
- down(&udev->sem);
- /* pointer back to the corresponding comedi device */
- udev->comedidev = dev;
-
- /* trying to upload the firmware into the chip */
- if (aux_data)
- firmwareUpload(udev, aux_data, aux_len);
-
- dev->board_name = BOARDNAME;
-
- /* set number of subdevices */
- if (udev->high_speed) {
- /* with pwm */
- dev->n_subdevices = 5;
- } else {
- /* without pwm */
- dev->n_subdevices = 4;
- }
-
- /* allocate space for the subdevices */
- ret = alloc_subdevices(dev, dev->n_subdevices);
- if (ret < 0) {
- dev_err(&udev->interface->dev,
- "comedi%d: error alloc space for subdev\n", dev->minor);
- up(&udev->sem);
- return ret;
- }
-
- /* private structure is also simply the usb-structure */
- dev->private = udev;
-
- /* the first subdevice is the A/D converter */
- s = dev->subdevices + SUBDEV_AD;
- /* the URBs get the comedi subdevice */
- /* which is responsible for reading */
- /* this is the subdevice which reads data */
- dev->read_subdev = s;
- /* the subdevice receives as private structure the */
- /* usb-structure */
- s->private = NULL;
- /* analog input */
- s->type = COMEDI_SUBD_AI;
- /* readable and ref is to ground */
- s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
- /* 8 channels */
- s->n_chan = 8;
- /* length of the channellist */
- s->len_chanlist = 8;
- /* callback functions */
- s->insn_read = usbdux_ai_insn_read;
- s->do_cmdtest = usbdux_ai_cmdtest;
- s->do_cmd = usbdux_ai_cmd;
- s->cancel = usbdux_ai_cancel;
- /* max value from the A/D converter (12bit) */
- s->maxdata = 0xfff;
- /* range table to convert to physical units */
- s->range_table = (&range_usbdux_ai_range);
-
- /* analog out */
- s = dev->subdevices + SUBDEV_DA;
- /* analog out */
- s->type = COMEDI_SUBD_AO;
- /* backward pointer */
- dev->write_subdev = s;
- /* the subdevice receives as private structure the */
- /* usb-structure */
- s->private = NULL;
- /* are writable */
- s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
- /* 4 channels */
- s->n_chan = 4;
- /* length of the channellist */
- s->len_chanlist = 4;
- /* 12 bit resolution */
- s->maxdata = 0x0fff;
- /* bipolar range */
- s->range_table = (&range_usbdux_ao_range);
- /* callback */
- s->do_cmdtest = usbdux_ao_cmdtest;
- s->do_cmd = usbdux_ao_cmd;
- s->cancel = usbdux_ao_cancel;
- s->insn_read = usbdux_ao_insn_read;
- s->insn_write = usbdux_ao_insn_write;
-
- /* digital I/O */
- s = dev->subdevices + SUBDEV_DIO;
- s->type = COMEDI_SUBD_DIO;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- s->n_chan = 8;
- s->maxdata = 1;
- s->range_table = (&range_digital);
- s->insn_bits = usbdux_dio_insn_bits;
- s->insn_config = usbdux_dio_insn_config;
- /* we don't use it */
- s->private = NULL;
-
- /* counter */
- s = dev->subdevices + SUBDEV_COUNTER;
- s->type = COMEDI_SUBD_COUNTER;
- s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
- s->n_chan = 4;
- s->maxdata = 0xFFFF;
- s->insn_read = usbdux_counter_read;
- s->insn_write = usbdux_counter_write;
- s->insn_config = usbdux_counter_config;
-
- if (udev->high_speed) {
- /* timer / pwm */
- s = dev->subdevices + SUBDEV_PWM;
- s->type = COMEDI_SUBD_PWM;
- s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE;
- s->n_chan = 8;
- /* this defines the max duty cycle resolution */
- s->maxdata = udev->sizePwmBuf;
- s->insn_write = usbdux_pwm_write;
- s->insn_read = usbdux_pwm_read;
- s->insn_config = usbdux_pwm_config;
- usbdux_pwm_period(dev, s, PWM_DEFAULT_PERIOD);
- }
- /* finally decide that it's attached */
- udev->attached = 1;
-
- up(&udev->sem);
-
- dev_info(&udev->interface->dev, "comedi%d: attached to usbdux.\n",
- dev->minor);
-
- return 0;
-}
-
-/* is called when comedi-config is called */
-static int usbdux_attach(struct comedi_device *dev, struct comedi_devconfig *it)
-{
- int ret;
- int index;
- int i;
- void *aux_data;
- int aux_len;
-
- dev->private = NULL;
-
- aux_data = comedi_aux_data(it->options, 0);
- aux_len = it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH];
- if (aux_data == NULL)
- aux_len = 0;
- else if (aux_len == 0)
- aux_data = NULL;
-
- down(&start_stop_sem);
- /* find a valid device which has been detected by the probe function of
- * the usb */
- index = -1;
- for (i = 0; i < NUMUSBDUX; i++) {
- if ((usbduxsub[i].probed) && (!usbduxsub[i].attached)) {
- index = i;
- break;
- }
- }
-
- if (index < 0) {
- printk(KERN_ERR
- "comedi%d: usbdux: error: attach failed, no usbdux devs connected to the usb bus.\n",
- dev->minor);
- ret = -ENODEV;
- } else
- ret = usbdux_attach_common(dev, &usbduxsub[index],
- aux_data, aux_len);
- up(&start_stop_sem);
- return ret;
-}
-
-/* is called from comedi_usb_auto_config() */
-static int usbdux_attach_usb(struct comedi_device *dev,
- struct usb_interface *uinterf)
-{
- int ret;
- struct usbduxsub *this_usbduxsub;
-
- dev->private = NULL;
-
- down(&start_stop_sem);
- this_usbduxsub = usb_get_intfdata(uinterf);
- if (!this_usbduxsub || !this_usbduxsub->probed) {
- printk(KERN_ERR
- "comedi%d: usbdux: error: attach_usb failed, not connected\n",
- dev->minor);
- ret = -ENODEV;
- } else if (this_usbduxsub->attached) {
- printk(KERN_ERR
- "comedi%d: usbdux: error: attach_usb failed, already attached\n",
- dev->minor);
- ret = -ENODEV;
- } else
- ret = usbdux_attach_common(dev, this_usbduxsub, NULL, 0);
- up(&start_stop_sem);
- return ret;
-}
-
-static void usbdux_detach(struct comedi_device *dev)
-{
- struct usbduxsub *usb = dev->private;
-
- if (usb) {
- down(&usb->sem);
- dev->private = NULL;
- usb->attached = 0;
- usb->comedidev = NULL;
- up(&usb->sem);
- }
-}
-
-/* main driver struct */
-static struct comedi_driver driver_usbdux = {
- .driver_name = "usbdux",
- .module = THIS_MODULE,
- .attach = usbdux_attach,
- .detach = usbdux_detach,
- .attach_usb = usbdux_attach_usb,
+static const struct usb_device_id usbdux_usb_table[] = {
+ { USB_DEVICE(0x13d8, 0x0001) },
+ { USB_DEVICE(0x13d8, 0x0002) },
+ { }
};
-/* Table with the USB-devices: just now only testing IDs */
-static const struct usb_device_id usbduxsub_table[] = {
- {USB_DEVICE(0x13d8, 0x0001)},
- {USB_DEVICE(0x13d8, 0x0002)},
- {} /* Terminating entry */
-};
+MODULE_DEVICE_TABLE(usb, usbdux_usb_table);
-MODULE_DEVICE_TABLE(usb, usbduxsub_table);
-
-/* The usbduxsub-driver */
-static struct usb_driver usbduxsub_driver = {
- .name = BOARDNAME,
- .probe = usbduxsub_probe,
- .disconnect = usbduxsub_disconnect,
- .id_table = usbduxsub_table,
+static struct usb_driver usbdux_usb_driver = {
+ .name = "usbdux",
+ .probe = usbdux_usb_probe,
+ .disconnect = usbdux_usb_disconnect,
+ .id_table = usbdux_usb_table,
};
+module_comedi_usb_driver(usbdux_driver, usbdux_usb_driver);
-/* Can't use the nice macro as I have also to initialise the USB */
-/* subsystem: */
-/* registering the usb-system _and_ the comedi-driver */
-static int __init init_usbdux(void)
-{
- printk(KERN_INFO KBUILD_MODNAME ": "
- DRIVER_VERSION ":" DRIVER_DESC "\n");
- usb_register(&usbduxsub_driver);
- comedi_driver_register(&driver_usbdux);
- return 0;
-}
-
-/* deregistering the comedi driver and the usb-subsystem */
-static void __exit exit_usbdux(void)
-{
- comedi_driver_unregister(&driver_usbdux);
- usb_deregister(&usbduxsub_driver);
-}
-
-module_init(init_usbdux);
-module_exit(exit_usbdux);
-
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
+MODULE_DESCRIPTION("Stirling/ITL USB-DUX -- Bernd.Porr@f2s.com");
MODULE_LICENSE("GPL");
#include "comedi_fc.h"
#include "../comedidev.h"
-#define DRIVER_VERSION "v1.0"
-#define DRIVER_AUTHOR "Bernd Porr, BerndPorr@f2s.com"
-#define DRIVER_DESC "USB-DUXfast, BerndPorr@f2s.com"
-#define BOARDNAME "usbduxfast"
-
/*
* timeout for the USB-transfer
*/
*/
#define NUMUSBDUXFAST 16
-/*
- * number of subdevices
- */
-#define N_SUBDEVICES 1
-
/*
* analogue in subdevice
*/
static DEFINE_SEMAPHORE(start_stop_sem);
-static struct comedi_driver driver_usbduxfast; /* see below for initializer */
-
/*
* bulk transfers to usbduxfast
*/
udfs->ai_cmd_running = 0;
}
+/* common part of attach and attach_usb */
+static int usbduxfast_attach_common(struct comedi_device *dev,
+ struct usbduxfastsub_s *udfs,
+ void *aux_data, int aux_len)
+{
+ int ret;
+ struct comedi_subdevice *s;
+
+ down(&udfs->sem);
+ /* pointer back to the corresponding comedi device */
+ udfs->comedidev = dev;
+ /* trying to upload the firmware into the chip */
+ if (aux_data)
+ firmwareUpload(udfs, aux_data, aux_len);
+ dev->board_name = "usbduxfast";
+ ret = comedi_alloc_subdevices(dev, 1);
+ if (ret) {
+ up(&udfs->sem);
+ return ret;
+ }
+ /* private structure is also simply the usb-structure */
+ dev->private = udfs;
+ /* the first subdevice is the A/D converter */
+ s = dev->subdevices + SUBDEV_AD;
+ /*
+ * the URBs get the comedi subdevice which is responsible for reading
+ * this is the subdevice which reads data
+ */
+ dev->read_subdev = s;
+ /* the subdevice receives as private structure the usb-structure */
+ s->private = NULL;
+ /* analog input */
+ s->type = COMEDI_SUBD_AI;
+ /* readable and ref is to ground */
+ s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
+ /* 16 channels */
+ s->n_chan = 16;
+ /* length of the channellist */
+ s->len_chanlist = 16;
+ /* callback functions */
+ s->insn_read = usbduxfast_ai_insn_read;
+ s->do_cmdtest = usbduxfast_ai_cmdtest;
+ s->do_cmd = usbduxfast_ai_cmd;
+ s->cancel = usbduxfast_ai_cancel;
+ /* max value from the A/D converter (12bit+1 bit for overflow) */
+ s->maxdata = 0x1000;
+ /* range table to convert to physical units */
+ s->range_table = &range_usbduxfast_ai_range;
+ /* finally decide that it's attached */
+ udfs->attached = 1;
+ up(&udfs->sem);
+ dev_info(dev->class_dev, "successfully attached to usbduxfast.\n");
+ return 0;
+}
+
+/* is called for COMEDI_DEVCONFIG ioctl (when comedi_config is run) */
+static int usbduxfast_attach(struct comedi_device *dev,
+ struct comedi_devconfig *it)
+{
+ int ret;
+ int index;
+ int i;
+ void *aux_data;
+ int aux_len;
+
+ dev->private = NULL;
+
+ aux_data = comedi_aux_data(it->options, 0);
+ aux_len = it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH];
+ if (aux_data == NULL)
+ aux_len = 0;
+ else if (aux_len == 0)
+ aux_data = NULL;
+ down(&start_stop_sem);
+ /*
+ * find a valid device which has been detected by the
+ * probe function of the usb
+ */
+ index = -1;
+ for (i = 0; i < NUMUSBDUXFAST; i++) {
+ if (usbduxfastsub[i].probed && !usbduxfastsub[i].attached) {
+ index = i;
+ break;
+ }
+ }
+ if (index < 0) {
+ dev_err(dev->class_dev,
+ "usbduxfast: error: attach failed, no usbduxfast devs connected to the usb bus.\n");
+ ret = -ENODEV;
+ } else
+ ret = usbduxfast_attach_common(dev, &usbduxfastsub[index],
+ aux_data, aux_len);
+ up(&start_stop_sem);
+ return ret;
+}
+
+/* is called from comedi_usb_auto_config() */
+static int usbduxfast_attach_usb(struct comedi_device *dev,
+ struct usb_interface *uinterf)
+{
+ int ret;
+ struct usbduxfastsub_s *udfs;
+
+ dev->private = NULL;
+ down(&start_stop_sem);
+ udfs = usb_get_intfdata(uinterf);
+ if (!udfs || !udfs->probed) {
+ dev_err(dev->class_dev,
+ "usbduxfast: error: attach_usb failed, not connected\n");
+ ret = -ENODEV;
+ } else if (udfs->attached) {
+ dev_err(dev->class_dev,
+ "usbduxfast: error: attach_usb failed, already attached\n");
+ ret = -ENODEV;
+ } else
+ ret = usbduxfast_attach_common(dev, udfs, NULL, 0);
+ up(&start_stop_sem);
+ return ret;
+}
+
+static void usbduxfast_detach(struct comedi_device *dev)
+{
+ struct usbduxfastsub_s *usb = dev->private;
+
+ if (usb) {
+ down(&usb->sem);
+ down(&start_stop_sem);
+ dev->private = NULL;
+ usb->attached = 0;
+ usb->comedidev = NULL;
+ up(&start_stop_sem);
+ up(&usb->sem);
+ }
+}
+
+static struct comedi_driver usbduxfast_driver = {
+ .driver_name = "usbduxfast",
+ .module = THIS_MODULE,
+ .attach = usbduxfast_attach,
+ .detach = usbduxfast_detach,
+ .attach_usb = usbduxfast_attach_usb,
+};
+
static void usbduxfast_firmware_request_complete_handler(const struct firmware
*fw, void *context)
{
goto out;
}
- comedi_usb_auto_config(uinterf, &driver_usbduxfast);
+ comedi_usb_auto_config(uinterf, &usbduxfast_driver);
out:
release_firmware(fw);
}
-/*
- * allocate memory for the urbs and initialise them
- */
-static int usbduxfastsub_probe(struct usb_interface *uinterf,
- const struct usb_device_id *id)
+static int usbduxfast_usb_probe(struct usb_interface *uinterf,
+ const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(uinterf);
int i;
return 0;
}
-static void usbduxfastsub_disconnect(struct usb_interface *intf)
+static void usbduxfast_usb_disconnect(struct usb_interface *intf)
{
struct usbduxfastsub_s *udfs = usb_get_intfdata(intf);
struct usb_device *udev = interface_to_usbdev(intf);
#endif
}
-/*
- * is called when comedi-config is called
- */
-static int usbduxfast_attach(struct comedi_device *dev,
- struct comedi_devconfig *it)
-{
- int ret;
- int index;
- int i;
- struct comedi_subdevice *s = NULL;
- dev->private = NULL;
-
- down(&start_stop_sem);
- /*
- * find a valid device which has been detected by the
- * probe function of the usb
- */
- index = -1;
- for (i = 0; i < NUMUSBDUXFAST; i++) {
- if (usbduxfastsub[i].probed && !usbduxfastsub[i].attached) {
- index = i;
- break;
- }
- }
-
- if (index < 0) {
- printk(KERN_ERR "comedi%d: usbduxfast: error: attach failed, "
- "no usbduxfast devs connected to the usb bus.\n",
- dev->minor);
- up(&start_stop_sem);
- return -ENODEV;
- }
-
- down(&(usbduxfastsub[index].sem));
- /* pointer back to the corresponding comedi device */
- usbduxfastsub[index].comedidev = dev;
-
- /* trying to upload the firmware into the chip */
- if (comedi_aux_data(it->options, 0) &&
- it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]) {
- firmwareUpload(&usbduxfastsub[index],
- comedi_aux_data(it->options, 0),
- it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]);
- }
-
- dev->board_name = BOARDNAME;
-
- /* set number of subdevices */
- dev->n_subdevices = N_SUBDEVICES;
-
- /* allocate space for the subdevices */
- ret = alloc_subdevices(dev, N_SUBDEVICES);
- if (ret < 0) {
- printk(KERN_ERR "comedi%d: usbduxfast: error alloc space for "
- "subdev\n", dev->minor);
- up(&(usbduxfastsub[index].sem));
- up(&start_stop_sem);
- return ret;
- }
-
- printk(KERN_INFO "comedi%d: usbduxfast: usb-device %d is attached to "
- "comedi.\n", dev->minor, index);
- /* private structure is also simply the usb-structure */
- dev->private = usbduxfastsub + index;
- /* the first subdevice is the A/D converter */
- s = dev->subdevices + SUBDEV_AD;
- /*
- * the URBs get the comedi subdevice which is responsible for reading
- * this is the subdevice which reads data
- */
- dev->read_subdev = s;
- /* the subdevice receives as private structure the usb-structure */
- s->private = NULL;
- /* analog input */
- s->type = COMEDI_SUBD_AI;
- /* readable and ref is to ground */
- s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
- /* 16 channels */
- s->n_chan = 16;
- /* length of the channellist */
- s->len_chanlist = 16;
- /* callback functions */
- s->insn_read = usbduxfast_ai_insn_read;
- s->do_cmdtest = usbduxfast_ai_cmdtest;
- s->do_cmd = usbduxfast_ai_cmd;
- s->cancel = usbduxfast_ai_cancel;
- /* max value from the A/D converter (12bit+1 bit for overflow) */
- s->maxdata = 0x1000;
- /* range table to convert to physical units */
- s->range_table = &range_usbduxfast_ai_range;
-
- /* finally decide that it's attached */
- usbduxfastsub[index].attached = 1;
-
- up(&(usbduxfastsub[index].sem));
- up(&start_stop_sem);
- printk(KERN_INFO "comedi%d: successfully attached to usbduxfast.\n",
- dev->minor);
-
- return 0;
-}
-
-static void usbduxfast_detach(struct comedi_device *dev)
-{
- struct usbduxfastsub_s *usb = dev->private;
-
- if (usb) {
- down(&usb->sem);
- down(&start_stop_sem);
- dev->private = NULL;
- usb->attached = 0;
- usb->comedidev = NULL;
- up(&start_stop_sem);
- up(&usb->sem);
- }
-}
-
-/*
- * main driver struct
- */
-static struct comedi_driver driver_usbduxfast = {
- .driver_name = "usbduxfast",
- .module = THIS_MODULE,
- .attach = usbduxfast_attach,
- .detach = usbduxfast_detach
-};
-
-/*
- * Table with the USB-devices: just now only testing IDs
- */
-static const struct usb_device_id usbduxfastsub_table[] = {
+static const struct usb_device_id usbduxfast_usb_table[] = {
/* { USB_DEVICE(0x4b4, 0x8613) }, testing */
- {USB_DEVICE(0x13d8, 0x0010)}, /* real ID */
- {USB_DEVICE(0x13d8, 0x0011)}, /* real ID */
- {} /* Terminating entry */
+ { USB_DEVICE(0x13d8, 0x0010) }, /* real ID */
+ { USB_DEVICE(0x13d8, 0x0011) }, /* real ID */
+ { }
};
+MODULE_DEVICE_TABLE(usb, usbduxfast_usb_table);
-MODULE_DEVICE_TABLE(usb, usbduxfastsub_table);
-
-/*
- * The usbduxfastsub-driver
- */
-static struct usb_driver usbduxfastsub_driver = {
+static struct usb_driver usbduxfast_usb_driver = {
#ifdef COMEDI_HAVE_USB_DRIVER_OWNER
- .owner = THIS_MODULE,
+ .owner = THIS_MODULE,
#endif
- .name = BOARDNAME,
- .probe = usbduxfastsub_probe,
- .disconnect = usbduxfastsub_disconnect,
- .id_table = usbduxfastsub_table
+ .name = "usbduxfast",
+ .probe = usbduxfast_usb_probe,
+ .disconnect = usbduxfast_usb_disconnect,
+ .id_table = usbduxfast_usb_table,
};
+module_comedi_usb_driver(usbduxfast_driver, usbduxfast_usb_driver);
-/*
- * Can't use the nice macro as I have also to initialise the USB subsystem:
- * registering the usb-system _and_ the comedi-driver
- */
-static int __init init_usbduxfast(void)
-{
- printk(KERN_INFO
- KBUILD_MODNAME ": " DRIVER_VERSION ":" DRIVER_DESC "\n");
- usb_register(&usbduxfastsub_driver);
- comedi_driver_register(&driver_usbduxfast);
- return 0;
-}
-
-/*
- * deregistering the comedi driver and the usb-subsystem
- */
-static void __exit exit_usbduxfast(void)
-{
- comedi_driver_unregister(&driver_usbduxfast);
- usb_deregister(&usbduxfastsub_driver);
-}
-
-module_init(init_usbduxfast);
-module_exit(exit_usbduxfast);
-
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
+MODULE_DESCRIPTION("USB-DUXfast, BerndPorr@f2s.com");
MODULE_LICENSE("GPL");
-#define DRIVER_VERSION "v0.6"
-#define DRIVER_AUTHOR "Bernd Porr, BerndPorr@f2s.com"
-#define DRIVER_DESC "Stirling/ITL USB-DUX SIGMA -- Bernd.Porr@f2s.com"
/*
comedi/drivers/usbdux.c
Copyright (C) 2011 Bernd Porr, Bernd.Porr@f2s.com
#include "comedi_fc.h"
#include "../comedidev.h"
-#define BOARDNAME "usbduxsigma"
-
/* timeout for the USB-transfer in ms*/
#define BULK_TIMEOUT 1000
static DEFINE_SEMAPHORE(start_stop_sem);
-static struct comedi_driver driver_usbduxsigma; /* see below for initializer */
-
/*
* Stops the data acquision
* It should be safe to call this function from any context
/* 32 bits big endian from the A/D converter */
one = be32_to_cpu(*((int32_t *)
((this_usbduxsub->insnBuffer)+1)));
- /* mask out the staus byte */
+ /* mask out the status byte */
one = one & 0x00ffffff;
/* turn it into an unsigned integer */
one = one ^ 0x00800000;
if (!this_usbduxsub)
return -EFAULT;
- if (insn->n != 2)
- return -EINVAL;
-
down(&this_usbduxsub->sem);
if (!(this_usbduxsub->probed)) {
s->state = data[1];
up(&this_usbduxsub->sem);
- return 2;
+ return insn->n;
}
/***********************************/
usbduxsub_tmp->pwm_cmd_running = 0;
}
+/* common part of attach and attach_usb */
+static int usbduxsigma_attach_common(struct comedi_device *dev,
+ struct usbduxsub *uds,
+ void *aux_data, int aux_len)
+{
+ int ret;
+ struct comedi_subdevice *s;
+ int n_subdevs;
+ int offset;
+
+ down(&uds->sem);
+ /* pointer back to the corresponding comedi device */
+ uds->comedidev = dev;
+ /* trying to upload the firmware into the FX2 */
+ if (aux_data)
+ firmwareUpload(uds, aux_data, aux_len);
+ dev->board_name = "usbduxsigma";
+ /* set number of subdevices */
+ if (uds->high_speed)
+ n_subdevs = 4; /* with pwm */
+ else
+ n_subdevs = 3; /* without pwm */
+ ret = comedi_alloc_subdevices(dev, n_subdevs);
+ if (ret) {
+ up(&uds->sem);
+ return ret;
+ }
+ /* private structure is also simply the usb-structure */
+ dev->private = uds;
+ /* the first subdevice is the A/D converter */
+ s = dev->subdevices + SUBDEV_AD;
+ /* the URBs get the comedi subdevice */
+ /* which is responsible for reading */
+ /* this is the subdevice which reads data */
+ dev->read_subdev = s;
+ /* the subdevice receives as private structure the */
+ /* usb-structure */
+ s->private = NULL;
+ /* analog input */
+ s->type = COMEDI_SUBD_AI;
+ /* readable and ref is to ground, 32 bit wide data! */
+ s->subdev_flags = SDF_READABLE | SDF_GROUND |
+ SDF_CMD_READ | SDF_LSAMPL;
+ /* 16 A/D channels */
+ s->n_chan = NUMCHANNELS;
+ /* length of the channellist */
+ s->len_chanlist = NUMCHANNELS;
+ /* callback functions */
+ s->insn_read = usbdux_ai_insn_read;
+ s->do_cmdtest = usbdux_ai_cmdtest;
+ s->do_cmd = usbdux_ai_cmd;
+ s->cancel = usbdux_ai_cancel;
+ /* max value from the A/D converter (24bit) */
+ s->maxdata = 0x00FFFFFF;
+ /* range table to convert to physical units */
+ s->range_table = (&range_usbdux_ai_range);
+ /* analog output subdevice */
+ s = dev->subdevices + SUBDEV_DA;
+ /* analog out */
+ s->type = COMEDI_SUBD_AO;
+ /* backward pointer */
+ dev->write_subdev = s;
+ /* the subdevice receives as private structure the */
+ /* usb-structure */
+ s->private = NULL;
+ /* are writable */
+ s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
+ /* 4 channels */
+ s->n_chan = 4;
+ /* length of the channellist */
+ s->len_chanlist = 4;
+ /* 8 bit resolution */
+ s->maxdata = 0x00ff;
+ /* unipolar range */
+ s->range_table = (&range_usbdux_ao_range);
+ /* callback */
+ s->do_cmdtest = usbdux_ao_cmdtest;
+ s->do_cmd = usbdux_ao_cmd;
+ s->cancel = usbdux_ao_cancel;
+ s->insn_read = usbdux_ao_insn_read;
+ s->insn_write = usbdux_ao_insn_write;
+ /* digital I/O subdevice */
+ s = dev->subdevices + SUBDEV_DIO;
+ s->type = COMEDI_SUBD_DIO;
+ s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
+ /* 8 external and 16 internal channels */
+ s->n_chan = 24;
+ s->maxdata = 1;
+ s->range_table = (&range_digital);
+ s->insn_bits = usbdux_dio_insn_bits;
+ s->insn_config = usbdux_dio_insn_config;
+ /* we don't use it */
+ s->private = NULL;
+ if (uds->high_speed) {
+ /* timer / pwm subdevice */
+ s = dev->subdevices + SUBDEV_PWM;
+ s->type = COMEDI_SUBD_PWM;
+ s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE;
+ s->n_chan = 8;
+ /* this defines the max duty cycle resolution */
+ s->maxdata = uds->sizePwmBuf;
+ s->insn_write = usbdux_pwm_write;
+ s->insn_read = usbdux_pwm_read;
+ s->insn_config = usbdux_pwm_config;
+ usbdux_pwm_period(dev, s, PWM_DEFAULT_PERIOD);
+ }
+ /* finally decide that it's attached */
+ uds->attached = 1;
+ up(&uds->sem);
+ offset = usbdux_getstatusinfo(dev, 0);
+ if (offset < 0)
+ dev_err(&uds->interface->dev,
+ "Communication to USBDUXSIGMA failed! Check firmware and cabling.");
+ dev_info(&uds->interface->dev,
+ "comedi%d: attached, ADC_zero = %x\n", dev->minor, offset);
+ return 0;
+}
+
+/* is called for COMEDI_DEVCONFIG ioctl (when comedi_config is run) */
+static int usbduxsigma_attach(struct comedi_device *dev,
+ struct comedi_devconfig *it)
+{
+ int ret;
+ int index;
+ int i;
+ void *aux_data;
+ int aux_len;
+
+ dev->private = NULL;
+
+ aux_data = comedi_aux_data(it->options, 0);
+ aux_len = it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH];
+ if (aux_data == NULL)
+ aux_len = 0;
+ else if (aux_len == 0)
+ aux_data = NULL;
+
+ down(&start_stop_sem);
+ /* find a valid device which has been detected by the probe function of
+ * the usb */
+ index = -1;
+ for (i = 0; i < NUMUSBDUX; i++) {
+ if ((usbduxsub[i].probed) && (!usbduxsub[i].attached)) {
+ index = i;
+ break;
+ }
+ }
+ if (index < 0) {
+ dev_err(dev->class_dev,
+ "usbduxsigma: error: attach failed, dev not connected to the usb bus.\n");
+ ret = -ENODEV;
+ } else
+ ret = usbduxsigma_attach_common(dev, &usbduxsub[index],
+ aux_data, aux_len);
+ up(&start_stop_sem);
+ return ret;
+}
+
+/* is called from comedi_usb_auto_config() */
+static int usbduxsigma_attach_usb(struct comedi_device *dev,
+ struct usb_interface *uinterf)
+{
+ int ret;
+ struct usbduxsub *uds;
+
+ dev->private = NULL;
+ down(&start_stop_sem);
+ uds = usb_get_intfdata(uinterf);
+ if (!uds || !uds->probed) {
+ dev_err(dev->class_dev,
+ "usbduxsigma: error: attach_usb failed, not connected\n");
+ ret = -ENODEV;
+ } else if (uds->attached) {
+ dev_err(dev->class_dev,
+ "usbduxsigma: error: attach_usb failed, already attached\n");
+ ret = -ENODEV;
+ } else
+ ret = usbduxsigma_attach_common(dev, uds, NULL, 0);
+ up(&start_stop_sem);
+ return ret;
+}
+
+static void usbduxsigma_detach(struct comedi_device *dev)
+{
+ struct usbduxsub *usb = dev->private;
+
+ if (usb) {
+ down(&usb->sem);
+ dev->private = NULL;
+ usb->attached = 0;
+ usb->comedidev = NULL;
+ up(&usb->sem);
+ }
+}
+
+static struct comedi_driver usbduxsigma_driver = {
+ .driver_name = "usbduxsigma",
+ .module = THIS_MODULE,
+ .attach = usbduxsigma_attach,
+ .detach = usbduxsigma_detach,
+ .attach_usb = usbduxsigma_attach_usb,
+};
+
static void usbdux_firmware_request_complete_handler(const struct firmware *fw,
void *context)
{
"Could not upload firmware (err=%d)\n", ret);
goto out;
}
- comedi_usb_auto_config(uinterf, &driver_usbduxsigma);
+ comedi_usb_auto_config(uinterf, &usbduxsigma_driver);
out:
release_firmware(fw);
}
-/* allocate memory for the urbs and initialise them */
-static int usbduxsigma_probe(struct usb_interface *uinterf,
- const struct usb_device_id *id)
+static int usbduxsigma_usb_probe(struct usb_interface *uinterf,
+ const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(uinterf);
struct device *dev = &uinterf->dev;
return 0;
}
-static void usbduxsigma_disconnect(struct usb_interface *intf)
+static void usbduxsigma_usb_disconnect(struct usb_interface *intf)
{
struct usbduxsub *usbduxsub_tmp = usb_get_intfdata(intf);
struct usb_device *udev = interface_to_usbdev(intf);
dev_info(&intf->dev, "comedi_: disconnected from the usb\n");
}
-/* is called when comedi-config is called */
-static int usbduxsigma_attach(struct comedi_device *dev,
- struct comedi_devconfig *it)
-{
- int ret;
- int index;
- int i;
- struct usbduxsub *udev;
-
- int offset;
-
- struct comedi_subdevice *s = NULL;
- dev->private = NULL;
-
- down(&start_stop_sem);
- /* find a valid device which has been detected by the probe function of
- * the usb */
- index = -1;
- for (i = 0; i < NUMUSBDUX; i++) {
- if ((usbduxsub[i].probed) && (!usbduxsub[i].attached)) {
- index = i;
- break;
- }
- }
-
- if (index < 0) {
- printk(KERN_ERR "comedi%d: usbduxsigma: error: attach failed,"
- "dev not connected to the usb bus.\n", dev->minor);
- up(&start_stop_sem);
- return -ENODEV;
- }
-
- udev = &usbduxsub[index];
- down(&udev->sem);
- /* pointer back to the corresponding comedi device */
- udev->comedidev = dev;
-
- /* trying to upload the firmware into the FX2 */
- if (comedi_aux_data(it->options, 0) &&
- it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]) {
- firmwareUpload(udev, comedi_aux_data(it->options, 0),
- it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]);
- }
-
- dev->board_name = BOARDNAME;
-
- /* set number of subdevices */
- if (udev->high_speed) {
- /* with pwm */
- dev->n_subdevices = 4;
- } else {
- /* without pwm */
- dev->n_subdevices = 3;
- }
-
- /* allocate space for the subdevices */
- ret = alloc_subdevices(dev, dev->n_subdevices);
- if (ret < 0) {
- dev_err(&udev->interface->dev,
- "comedi%d: no space for subdev\n", dev->minor);
- up(&udev->sem);
- up(&start_stop_sem);
- return ret;
- }
-
- /* private structure is also simply the usb-structure */
- dev->private = udev;
-
- /* the first subdevice is the A/D converter */
- s = dev->subdevices + SUBDEV_AD;
- /* the URBs get the comedi subdevice */
- /* which is responsible for reading */
- /* this is the subdevice which reads data */
- dev->read_subdev = s;
- /* the subdevice receives as private structure the */
- /* usb-structure */
- s->private = NULL;
- /* analog input */
- s->type = COMEDI_SUBD_AI;
- /* readable and ref is to ground, 32 bit wide data! */
- s->subdev_flags = SDF_READABLE | SDF_GROUND |
- SDF_CMD_READ | SDF_LSAMPL;
- /* 16 A/D channels */
- s->n_chan = NUMCHANNELS;
- /* length of the channellist */
- s->len_chanlist = NUMCHANNELS;
- /* callback functions */
- s->insn_read = usbdux_ai_insn_read;
- s->do_cmdtest = usbdux_ai_cmdtest;
- s->do_cmd = usbdux_ai_cmd;
- s->cancel = usbdux_ai_cancel;
- /* max value from the A/D converter (24bit) */
- s->maxdata = 0x00FFFFFF;
- /* range table to convert to physical units */
- s->range_table = (&range_usbdux_ai_range);
-
- /* analog out */
- s = dev->subdevices + SUBDEV_DA;
- /* analog out */
- s->type = COMEDI_SUBD_AO;
- /* backward pointer */
- dev->write_subdev = s;
- /* the subdevice receives as private structure the */
- /* usb-structure */
- s->private = NULL;
- /* are writable */
- s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
- /* 4 channels */
- s->n_chan = 4;
- /* length of the channellist */
- s->len_chanlist = 4;
- /* 8 bit resolution */
- s->maxdata = 0x00ff;
- /* unipolar range */
- s->range_table = (&range_usbdux_ao_range);
- /* callback */
- s->do_cmdtest = usbdux_ao_cmdtest;
- s->do_cmd = usbdux_ao_cmd;
- s->cancel = usbdux_ao_cancel;
- s->insn_read = usbdux_ao_insn_read;
- s->insn_write = usbdux_ao_insn_write;
-
- /* digital I/O */
- s = dev->subdevices + SUBDEV_DIO;
- s->type = COMEDI_SUBD_DIO;
- s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
- /* 8 external and 16 internal channels */
- s->n_chan = 24;
- s->maxdata = 1;
- s->range_table = (&range_digital);
- s->insn_bits = usbdux_dio_insn_bits;
- s->insn_config = usbdux_dio_insn_config;
- /* we don't use it */
- s->private = NULL;
-
- if (udev->high_speed) {
- /* timer / pwm */
- s = dev->subdevices + SUBDEV_PWM;
- s->type = COMEDI_SUBD_PWM;
- s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE;
- s->n_chan = 8;
- /* this defines the max duty cycle resolution */
- s->maxdata = udev->sizePwmBuf;
- s->insn_write = usbdux_pwm_write;
- s->insn_read = usbdux_pwm_read;
- s->insn_config = usbdux_pwm_config;
- usbdux_pwm_period(dev, s, PWM_DEFAULT_PERIOD);
- }
- /* finally decide that it's attached */
- udev->attached = 1;
-
- up(&udev->sem);
-
- up(&start_stop_sem);
-
- offset = usbdux_getstatusinfo(dev, 0);
- if (offset < 0)
- dev_err(&udev->interface->dev,
- "Communication to USBDUXSIGMA failed!"
- "Check firmware and cabling.");
-
- dev_info(&udev->interface->dev,
- "comedi%d: attached, ADC_zero = %x", dev->minor, offset);
-
- return 0;
-}
-
-static void usbduxsigma_detach(struct comedi_device *dev)
-{
- struct usbduxsub *usb = dev->private;
-
- if (usb) {
- down(&usb->sem);
- dev->private = NULL;
- usb->attached = 0;
- usb->comedidev = NULL;
- up(&usb->sem);
- }
-}
-
-/* main driver struct */
-static struct comedi_driver driver_usbduxsigma = {
- .driver_name = "usbduxsigma",
- .module = THIS_MODULE,
- .attach = usbduxsigma_attach,
- .detach = usbduxsigma_detach,
+static const struct usb_device_id usbduxsigma_usb_table[] = {
+ { USB_DEVICE(0x13d8, 0x0020) },
+ { USB_DEVICE(0x13d8, 0x0021) },
+ { USB_DEVICE(0x13d8, 0x0022) },
+ { }
};
+MODULE_DEVICE_TABLE(usb, usbduxsigma_usb_table);
-/* Table with the USB-devices */
-static const struct usb_device_id usbduxsigma_table[] = {
- {USB_DEVICE(0x13d8, 0x0020)},
- {USB_DEVICE(0x13d8, 0x0021)},
- {USB_DEVICE(0x13d8, 0x0022)},
- {} /* Terminating entry */
+static struct usb_driver usbduxsigma_usb_driver = {
+ .name = "usbduxsigma",
+ .probe = usbduxsigma_usb_probe,
+ .disconnect = usbduxsigma_usb_disconnect,
+ .id_table = usbduxsigma_usb_table,
};
+module_comedi_usb_driver(usbduxsigma_driver, usbduxsigma_usb_driver);
-MODULE_DEVICE_TABLE(usb, usbduxsigma_table);
-
-/* The usbduxsub-driver */
-static struct usb_driver usbduxsigma_driver = {
- .name = BOARDNAME,
- .probe = usbduxsigma_probe,
- .disconnect = usbduxsigma_disconnect,
- .id_table = usbduxsigma_table,
-};
-
-/* Can't use the nice macro as I have also to initialise the USB */
-/* subsystem: */
-/* registering the usb-system _and_ the comedi-driver */
-static int __init init_usbduxsigma(void)
-{
- printk(KERN_INFO KBUILD_MODNAME ": "
- DRIVER_VERSION ":" DRIVER_DESC "\n");
- usb_register(&usbduxsigma_driver);
- comedi_driver_register(&driver_usbduxsigma);
- return 0;
-}
-
-/* deregistering the comedi driver and the usb-subsystem */
-static void __exit exit_usbduxsigma(void)
-{
- comedi_driver_unregister(&driver_usbduxsigma);
- usb_deregister(&usbduxsigma_driver);
-}
-
-module_init(init_usbduxsigma);
-module_exit(exit_usbduxsigma);
-
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
+MODULE_DESCRIPTION("Stirling/ITL USB-DUX SIGMA -- Bernd.Porr@f2s.com");
MODULE_LICENSE("GPL");
#include "../comedidev.h"
-#define BOARDNAME "vmk80xx"
-
-MODULE_AUTHOR("Manuel Gebele <forensixs@gmx.de>");
-MODULE_DESCRIPTION("Velleman USB Board Low-Level Driver");
-MODULE_SUPPORTED_DEVICE("K8055/K8061 aka VM110/VM140");
-MODULE_VERSION("0.8.01");
-MODULE_LICENSE("GPL");
-
enum {
DEVICE_VMK8055,
DEVICE_VMK8061
};
-static const struct usb_device_id vmk80xx_id_table[] = {
- {USB_DEVICE(0x10cf, 0x5500), .driver_info = DEVICE_VMK8055},
- {USB_DEVICE(0x10cf, 0x5501), .driver_info = DEVICE_VMK8055},
- {USB_DEVICE(0x10cf, 0x5502), .driver_info = DEVICE_VMK8055},
- {USB_DEVICE(0x10cf, 0x5503), .driver_info = DEVICE_VMK8055},
- {USB_DEVICE(0x10cf, 0x8061), .driver_info = DEVICE_VMK8061},
- {USB_DEVICE(0x10cf, 0x8062), .driver_info = DEVICE_VMK8061},
- {USB_DEVICE(0x10cf, 0x8063), .driver_info = DEVICE_VMK8061},
- {USB_DEVICE(0x10cf, 0x8064), .driver_info = DEVICE_VMK8061},
- {USB_DEVICE(0x10cf, 0x8065), .driver_info = DEVICE_VMK8061},
- {USB_DEVICE(0x10cf, 0x8066), .driver_info = DEVICE_VMK8061},
- {USB_DEVICE(0x10cf, 0x8067), .driver_info = DEVICE_VMK8061},
- {USB_DEVICE(0x10cf, 0x8068), .driver_info = DEVICE_VMK8061},
- {} /* terminating entry */
-};
-
-MODULE_DEVICE_TABLE(usb, vmk80xx_id_table);
-
#define VMK8055_DI_REG 0x00
#define VMK8055_DO_REG 0x01
#define VMK8055_AO1_REG 0x02
static DEFINE_MUTEX(glb_mutex);
-static struct comedi_driver driver_vmk80xx; /* see below for initializer */
-
static void vmk80xx_tx_callback(struct urb *urb)
{
struct vmk80xx_usb *dev = urb->context;
return n;
}
-static int vmk80xx_attach(struct comedi_device *cdev,
- struct comedi_devconfig *it)
+static int vmk80xx_attach_common(struct comedi_device *cdev,
+ struct vmk80xx_usb *dev)
{
- int i;
- struct vmk80xx_usb *dev;
int n_subd;
struct comedi_subdevice *s;
- int minor;
-
- mutex_lock(&glb_mutex);
-
- for (i = 0; i < VMK80XX_MAX_BOARDS; i++)
- if (vmb[i].probed && !vmb[i].attached)
- break;
-
- if (i == VMK80XX_MAX_BOARDS) {
- mutex_unlock(&glb_mutex);
- return -ENODEV;
- }
-
- dev = &vmb[i];
+ int ret;
down(&dev->limit_sem);
-
cdev->board_name = dev->board.name;
cdev->private = dev;
-
if (dev->board.model == VMK8055_MODEL)
n_subd = 5;
else
n_subd = 6;
-
- if (alloc_subdevices(cdev, n_subd) < 0) {
+ ret = comedi_alloc_subdevices(cdev, n_subd);
+ if (ret) {
up(&dev->limit_sem);
- mutex_unlock(&glb_mutex);
- return -ENOMEM;
+ return ret;
}
-
/* Analog input subdevice */
s = cdev->subdevices + VMK80XX_SUBD_AI;
s->type = COMEDI_SUBD_AI;
s->maxdata = (1 << dev->board.ai_bits) - 1;
s->range_table = dev->board.range;
s->insn_read = vmk80xx_ai_rinsn;
-
/* Analog output subdevice */
s = cdev->subdevices + VMK80XX_SUBD_AO;
s->type = COMEDI_SUBD_AO;
s->maxdata = (1 << dev->board.ao_bits) - 1;
s->range_table = dev->board.range;
s->insn_write = vmk80xx_ao_winsn;
-
if (dev->board.model == VMK8061_MODEL) {
s->subdev_flags |= SDF_READABLE;
s->insn_read = vmk80xx_ao_rinsn;
}
-
/* Digital input subdevice */
s = cdev->subdevices + VMK80XX_SUBD_DI;
s->type = COMEDI_SUBD_DI;
s->maxdata = 1;
s->insn_read = vmk80xx_di_rinsn;
s->insn_bits = vmk80xx_di_bits;
-
/* Digital output subdevice */
s = cdev->subdevices + VMK80XX_SUBD_DO;
s->type = COMEDI_SUBD_DO;
s->maxdata = 1;
s->insn_write = vmk80xx_do_winsn;
s->insn_bits = vmk80xx_do_bits;
-
if (dev->board.model == VMK8061_MODEL) {
s->subdev_flags |= SDF_READABLE;
s->insn_read = vmk80xx_do_rinsn;
}
-
/* Counter subdevice */
s = cdev->subdevices + VMK80XX_SUBD_CNT;
s->type = COMEDI_SUBD_COUNTER;
s->n_chan = dev->board.cnt_chans;
s->insn_read = vmk80xx_cnt_rinsn;
s->insn_config = vmk80xx_cnt_cinsn;
-
if (dev->board.model == VMK8055_MODEL) {
s->subdev_flags |= SDF_WRITEABLE;
s->maxdata = (1 << dev->board.cnt_bits) - 1;
s->insn_write = vmk80xx_cnt_winsn;
}
-
/* PWM subdevice */
if (dev->board.model == VMK8061_MODEL) {
s = cdev->subdevices + VMK80XX_SUBD_PWM;
s->insn_read = vmk80xx_pwm_rinsn;
s->insn_write = vmk80xx_pwm_winsn;
}
-
dev->attached = 1;
+ dev_info(cdev->class_dev, "vmk80xx: board #%d [%s] attached\n",
+ dev->count, dev->board.name);
+ up(&dev->limit_sem);
+ return 0;
+}
- minor = cdev->minor;
-
- printk(KERN_INFO
- "comedi%d: vmk80xx: board #%d [%s] attached to comedi\n",
- minor, dev->count, dev->board.name);
+/* called for COMEDI_DEVCONFIG ioctl for board_name "vmk80xx" */
+static int vmk80xx_attach(struct comedi_device *cdev,
+ struct comedi_devconfig *it)
+{
+ int i;
+ int ret;
- up(&dev->limit_sem);
+ mutex_lock(&glb_mutex);
+ for (i = 0; i < VMK80XX_MAX_BOARDS; i++)
+ if (vmb[i].probed && !vmb[i].attached)
+ break;
+ if (i == VMK80XX_MAX_BOARDS)
+ ret = -ENODEV;
+ else
+ ret = vmk80xx_attach_common(cdev, &vmb[i]);
mutex_unlock(&glb_mutex);
+ return ret;
+}
- return 0;
+/* called via comedi_usb_auto_config() */
+static int vmk80xx_attach_usb(struct comedi_device *cdev,
+ struct usb_interface *intf)
+{
+ int i;
+ int ret;
+
+ mutex_lock(&glb_mutex);
+ for (i = 0; i < VMK80XX_MAX_BOARDS; i++)
+ if (vmb[i].probed && vmb[i].intf == intf)
+ break;
+ if (i == VMK80XX_MAX_BOARDS)
+ ret = -ENODEV;
+ else if (vmb[i].attached)
+ ret = -EBUSY;
+ else
+ ret = vmk80xx_attach_common(cdev, &vmb[i]);
+ mutex_unlock(&glb_mutex);
+ return ret;
}
static void vmk80xx_detach(struct comedi_device *dev)
}
}
-static int vmk80xx_probe(struct usb_interface *intf,
- const struct usb_device_id *id)
+static struct comedi_driver vmk80xx_driver = {
+ .module = THIS_MODULE,
+ .driver_name = "vmk80xx",
+ .attach = vmk80xx_attach,
+ .detach = vmk80xx_detach,
+ .attach_usb = vmk80xx_attach_usb,
+};
+
+static int vmk80xx_usb_probe(struct usb_interface *intf,
+ const struct usb_device_id *id)
{
int i;
struct vmk80xx_usb *dev;
mutex_unlock(&glb_mutex);
- comedi_usb_auto_config(intf, &driver_vmk80xx);
+ comedi_usb_auto_config(intf, &vmk80xx_driver);
return 0;
error:
return -ENODEV;
}
-static void vmk80xx_disconnect(struct usb_interface *intf)
+static void vmk80xx_usb_disconnect(struct usb_interface *intf)
{
struct vmk80xx_usb *dev = usb_get_intfdata(intf);
mutex_unlock(&glb_mutex);
}
-/* TODO: Add support for suspend, resume, pre_reset,
- * post_reset and flush */
-static struct usb_driver vmk80xx_driver = {
- .name = "vmk80xx",
- .probe = vmk80xx_probe,
- .disconnect = vmk80xx_disconnect,
- .id_table = vmk80xx_id_table
+static const struct usb_device_id vmk80xx_usb_id_table[] = {
+ { USB_DEVICE(0x10cf, 0x5500), .driver_info = DEVICE_VMK8055 },
+ { USB_DEVICE(0x10cf, 0x5501), .driver_info = DEVICE_VMK8055 },
+ { USB_DEVICE(0x10cf, 0x5502), .driver_info = DEVICE_VMK8055 },
+ { USB_DEVICE(0x10cf, 0x5503), .driver_info = DEVICE_VMK8055 },
+ { USB_DEVICE(0x10cf, 0x8061), .driver_info = DEVICE_VMK8061 },
+ { USB_DEVICE(0x10cf, 0x8062), .driver_info = DEVICE_VMK8061 },
+ { USB_DEVICE(0x10cf, 0x8063), .driver_info = DEVICE_VMK8061 },
+ { USB_DEVICE(0x10cf, 0x8064), .driver_info = DEVICE_VMK8061 },
+ { USB_DEVICE(0x10cf, 0x8065), .driver_info = DEVICE_VMK8061 },
+ { USB_DEVICE(0x10cf, 0x8066), .driver_info = DEVICE_VMK8061 },
+ { USB_DEVICE(0x10cf, 0x8067), .driver_info = DEVICE_VMK8061 },
+ { USB_DEVICE(0x10cf, 0x8068), .driver_info = DEVICE_VMK8061 },
+ { }
};
+MODULE_DEVICE_TABLE(usb, vmk80xx_usb_id_table);
-static struct comedi_driver driver_vmk80xx = {
- .module = THIS_MODULE,
- .driver_name = "vmk80xx",
- .attach = vmk80xx_attach,
- .detach = vmk80xx_detach
+/* TODO: Add support for suspend, resume, pre_reset,
+ * post_reset and flush */
+static struct usb_driver vmk80xx_usb_driver = {
+ .name = "vmk80xx",
+ .probe = vmk80xx_usb_probe,
+ .disconnect = vmk80xx_usb_disconnect,
+ .id_table = vmk80xx_usb_id_table,
};
+module_comedi_usb_driver(vmk80xx_driver, vmk80xx_usb_driver);
-static int __init vmk80xx_init(void)
-{
- int retval;
-
- printk(KERN_INFO "vmk80xx: version 0.8.01 "
- "Manuel Gebele <forensixs@gmx.de>\n");
-
- retval = comedi_driver_register(&driver_vmk80xx);
- if (retval < 0)
- return retval;
-
- return usb_register(&vmk80xx_driver);
-}
-
-static void __exit vmk80xx_exit(void)
-{
- comedi_driver_unregister(&driver_vmk80xx);
- usb_deregister(&vmk80xx_driver);
-}
-
-module_init(vmk80xx_init);
-module_exit(vmk80xx_exit);
+MODULE_AUTHOR("Manuel Gebele <forensixs@gmx.de>");
+MODULE_DESCRIPTION("Velleman USB Board Low-Level Driver");
+MODULE_SUPPORTED_DEVICE("K8055/K8061 aka VM110/VM140");
+MODULE_VERSION("0.8.01");
+MODULE_LICENSE("GPL");
+++ /dev/null
-/*
- * various internal comedi stuff
- */
-int do_rangeinfo_ioctl(struct comedi_device *dev,
- struct comedi_rangeinfo __user *arg);
-int insn_inval(struct comedi_device *dev, struct comedi_subdevice *s,
- struct comedi_insn *insn, unsigned int *data);
-int comedi_alloc_board_minor(struct device *hardware_device);
-void comedi_free_board_minor(unsigned minor);
-int comedi_find_board_minor(struct device *hardware_device);
-void comedi_reset_async_buf(struct comedi_async *async);
-int comedi_buf_alloc(struct comedi_device *dev, struct comedi_subdevice *s,
- unsigned long new_size);
-
-extern unsigned int comedi_default_buf_size_kb;
-extern unsigned int comedi_default_buf_maxsize_kb;
#define __NO_VERSION__
#include "comedidev.h"
-#include "comedi_fops.h"
+#include "comedi_internal.h"
#include <linux/proc_fs.h>
#include <linux/string.h>
#include <linux/uaccess.h>
#include "comedidev.h"
-#include "internal.h"
+#include "comedi_internal.h"
const struct comedi_lrange range_bipolar10 = { 1, {BIP_RANGE(10)} };
EXPORT_SYMBOL(range_bipolar10);
retval = gpio_to_irq(ts->gpio);
if (retval < 0) {
- dev_err(ts->dev, "cp_tm1217: GPIO to IRQ failedi,"
- " error %d\n", retval);
+ dev_err(ts->dev,
+ "cp_tm1217: GPIO to IRQ failed, error %d\n", retval);
gpio_free(ts->gpio);
}
dev_dbg(ts->dev,
--- /dev/null
+config CSR_WIFI
+ tristate "CSR wireless driver"
+ depends on PCI && MMC && CFG80211_WEXT
+ select WIRELESS_EXT
+ select WEXT_PRIV
+ help
+ Driver for the CSR wireless SDIO device.
+
+ If unsure, select N.
--- /dev/null
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+Except as contained in this notice, the names of above-listed
+copyright holders and the names of any contributors shall not be used
+in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+CONTRIBUTORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Alternatively, this software may be distributed under the terms of the
+GNU General Public License ("GPL") version 2 as published
+by the Free Software Foundation.
+
+As a special exception, if other files instantiate templates or use
+macros or inline functions from this file, or you compile this file
+and link it with other works to produce a work based on this file,
+this file does not by itself cause the resulting work to be covered by
+the GNU General Public License. However the source code for this file
+must still be made available in accordance with section (3) of the GNU
+General Public License.
+
+This exception does not invalidate any other reasons why a work based
+on this file might be covered by the GNU General Public License.
--- /dev/null
+obj-$(CONFIG_CSR_WIFI) += oska/
+
+ccflags-y := -DCSR_SME_USERSPACE -DCSR_SUPPORT_SME -DREMOTE_SYS_SAP -DCSR_WIFI_SECURITY_WAPI_ENABLE -DENABLE_SHUTDOWN -DUNIFI_DEBUG
+ccflags-y += -DSDIO_EXPORTS_STRUCT_DEVICE -DCSR_WIFI_SUPPORT_MMC_DRIVER -DCSR_WIFI_SINGLE_FUNCTION -DCSR_WIFI_SPLIT_PATCH
+ccflags-y += -DCSR_SUPPORT_WEXT -DREMOTE_SYS_SAP -DREMOTE_MGT_SAP -DCSR_WIFI_SECURITY_WAPI_ENABLE -DCSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND -DENABLE_SHUTDOWN -DCSR_WIFI_NME_ENABLE -DCSR_WIFI_AP_ENABLE -DCSR_SUPPORT_WEXT_AP -DCSR_WIFI_REQUEUE_PACKET_TO_HAL
+
+obj-$(CONFIG_CSR_WIFI) += csr_wifi.o
+obj-$(CONFIG_CSR_WIFI) += csr_helper.o
+
+csr_wifi-y := bh.o \
+ data_tx.o \
+ drv.o \
+ firmware.o \
+ indications.o \
+ inet.o \
+ init_hw.o \
+ io.o \
+ monitor.o \
+ netdev.o \
+ os.o \
+ putest.o \
+ sdio_events.o \
+ sdio_mmc.o \
+ sdio_stubs.o \
+ sme_blocking.o \
+ ul_int.o \
+ unifi_dbg.o \
+ unifi_event.o \
+ unifi_pdu_processing.o \
+ unifi_sme.o \
+ csr_formatted_io.o \
+ csr_wifi_hip_card_sdio.o \
+ csr_wifi_hip_card_sdio_intr.o \
+ csr_wifi_hip_card_sdio_mem.o \
+ csr_wifi_hip_chiphelper.o \
+ csr_wifi_hip_download.o \
+ csr_wifi_hip_dump.o \
+ csr_wifi_hip_packing.o \
+ csr_wifi_hip_send.o \
+ csr_wifi_hip_signals.o \
+ csr_wifi_hip_ta_sampling.o \
+ csr_wifi_hip_udi.o \
+ csr_wifi_hip_unifi_signal_names.o \
+ csr_wifi_hip_xbv.o \
+ csr_wifi_nme_ap_converter_init.o \
+ csr_wifi_nme_ap_free_downstream_contents.o \
+ csr_wifi_nme_ap_free_upstream_contents.o \
+ csr_wifi_nme_ap_serialize.o \
+ csr_wifi_nme_ap_sef.o \
+ csr_wifi_router_ctrl_sef.o \
+ csr_wifi_router_sef.o \
+ csr_wifi_router_transport.o \
+ csr_wifi_sme_sef.o \
+ csr_wifi_sme_converter_init.o \
+ csr_wifi_sme_free_downstream_contents.o \
+ csr_wifi_sme_free_upstream_contents.o \
+ csr_wifi_sme_serialize.o \
+ csr_wifi_router_ctrl_converter_init.o \
+ csr_wifi_router_ctrl_free_downstream_contents.o \
+ csr_wifi_router_ctrl_free_upstream_contents.o \
+ csr_wifi_router_ctrl_serialize.o \
+ csr_wifi_router_converter_init.o \
+ csr_wifi_router_free_downstream_contents.o \
+ csr_wifi_router_free_upstream_contents.o \
+ csr_wifi_router_serialize.o \
+ sme_mgt.o \
+ sme_sys.o \
+ sme_userspace.o \
+ sme_wext.o \
+ wext_events.o
+
+csr_helper-y := csr_time.o \
+ csr_util.o \
+ csr_framework_ext.o \
+ csr_pmem.o \
+ csr_wifi_serialize_primitive_types.o \
+ csr_serialize_primitive_types.o \
+ csr_utf16.o \
+ csr_msgconv.o \
+ csr_panic.o
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: bh.c
+ *
+ * PURPOSE:
+ * Provides an implementation for the driver bottom-half.
+ * It is part of the porting exercise in Linux.
+ *
+ * Copyright (C) 2005-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "unifi_priv.h"
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_start_thread
+ *
+ * Helper function to start a new thread.
+ *
+ * Arguments:
+ * priv Pointer to OS driver structure for the device.
+ * thread Pointer to the thread object
+ * func The thread function
+ *
+ * Returns:
+ * 0 on success or else a Linux error code.
+ * ---------------------------------------------------------------------------
+ */
+int
+uf_start_thread(unifi_priv_t *priv, struct uf_thread *thread, int (*func)(void *))
+{
+ if (thread->thread_task != NULL) {
+ unifi_error(priv, "%s thread already started\n", thread->name);
+ return 0;
+ }
+
+ /* Start the kernel thread that handles all h/w accesses. */
+ thread->thread_task = kthread_run(func, priv, "%s", thread->name);
+ if (IS_ERR(thread->thread_task)) {
+ return PTR_ERR(thread->thread_task);
+ }
+
+ /* Module parameter overides the thread priority */
+ if (bh_priority != -1) {
+ if (bh_priority >= 0 && bh_priority <= MAX_RT_PRIO) {
+ struct sched_param param;
+ priv->bh_thread.prio = bh_priority;
+ unifi_trace(priv, UDBG1, "%s thread (RT) priority = %d\n",
+ thread->name, bh_priority);
+ param.sched_priority = bh_priority;
+ sched_setscheduler(thread->thread_task, SCHED_FIFO, ¶m);
+ } else if (bh_priority > MAX_RT_PRIO && bh_priority <= MAX_PRIO) {
+ priv->bh_thread.prio = bh_priority;
+ unifi_trace(priv, UDBG1, "%s thread priority = %d\n",
+ thread->name, PRIO_TO_NICE(bh_priority));
+ set_user_nice(thread->thread_task, PRIO_TO_NICE(bh_priority));
+ } else {
+ priv->bh_thread.prio = DEFAULT_PRIO;
+ unifi_warning(priv, "%s thread unsupported (%d) priority\n",
+ thread->name, bh_priority);
+ }
+ } else {
+ priv->bh_thread.prio = DEFAULT_PRIO;
+ }
+ unifi_trace(priv, UDBG2, "Started %s thread\n", thread->name);
+
+ return 0;
+} /* uf_start_thread() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_stop_thread
+ *
+ * Helper function to stop a thread.
+ *
+ * Arguments:
+ * priv Pointer to OS driver structure for the device.
+ * thread Pointer to the thread object
+ *
+ * Returns:
+ *
+ * ---------------------------------------------------------------------------
+ */
+ void
+uf_stop_thread(unifi_priv_t *priv, struct uf_thread *thread)
+{
+ if (!thread->thread_task) {
+ unifi_notice(priv, "%s thread is already stopped\n", thread->name);
+ return;
+ }
+
+ unifi_trace(priv, UDBG2, "Stopping %s thread\n", thread->name);
+
+ kthread_stop(thread->thread_task);
+ thread->thread_task = NULL;
+
+} /* uf_stop_thread() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_wait_for_thread_to_stop
+ *
+ * Helper function to wait until a thread is stopped.
+ *
+ * Arguments:
+ * priv Pointer to OS driver structure for the device.
+ *
+ * Returns:
+ *
+ * ---------------------------------------------------------------------------
+ */
+ void
+uf_wait_for_thread_to_stop(unifi_priv_t *priv, struct uf_thread *thread)
+{
+ /*
+ * kthread_stop() cannot handle the thread exiting while
+ * kthread_should_stop() is false, so sleep until kthread_stop()
+ * wakes us up.
+ */
+ unifi_trace(priv, UDBG2, "%s waiting for the stop signal.\n", thread->name);
+ set_current_state(TASK_INTERRUPTIBLE);
+ if (!kthread_should_stop()) {
+ unifi_trace(priv, UDBG2, "%s schedule....\n", thread->name);
+ schedule();
+ }
+
+ thread->thread_task = NULL;
+ unifi_trace(priv, UDBG2, "%s exiting....\n", thread->name);
+} /* uf_wait_for_thread_to_stop() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * handle_bh_error
+ *
+ * This function reports an error returned from the HIP core bottom-half.
+ * Normally, implemented during the porting exercise, passing the error
+ * to the SME using unifi_sys_wifi_off_ind().
+ * The SME will try to reset the device and go through
+ * the initialisation of the UniFi.
+ *
+ * Arguments:
+ * priv Pointer to OS driver structure for the device.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+ static void
+handle_bh_error(unifi_priv_t *priv)
+{
+ u8 conf_param = CONFIG_IND_ERROR;
+ CsrUint8 interfaceTag = 0; /* used as a loop counter */
+
+
+ /* Block unifi_run_bh() until the error has been handled. */
+ priv->bh_thread.block_thread = 1;
+
+ /* Consider UniFi to be uninitialised */
+ priv->init_progress = UNIFI_INIT_NONE;
+
+ /* Stop the network traffic */
+ for( interfaceTag =0; interfaceTag <CSR_WIFI_NUM_INTERFACES;interfaceTag ++) {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ if (interfacePriv->netdev_registered == 1) {
+ netif_carrier_off(priv->netdev[interfaceTag]);
+ }
+ }
+
+#ifdef CSR_NATIVE_LINUX
+ /* Force any client waiting on an mlme_wait_for_reply() to abort. */
+ uf_abort_mlme(priv);
+
+ /* Cancel any pending workqueue tasks */
+ flush_workqueue(priv->unifi_workqueue);
+
+#endif /* CSR_NATIVE_LINUX */
+
+ unifi_error(priv, "handle_bh_error: fatal error is reported to the SME.\n");
+ /* Notify the clients (SME or unifi_manager) for the error. */
+ ul_log_config_ind(priv, &conf_param, sizeof(u8));
+
+} /* handle_bh_error() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * bh_thread_function
+ *
+ * All hardware access happens in this thread.
+ * This means there is no need for locks on the hardware and we don't need
+ * to worry about reentrancy with the SDIO library.
+ * Provides and example implementation on how to call unifi_bh(), which
+ * is part of the HIP core API.
+ *
+ * It processes the events generated by unifi_run_bh() to serialise calls
+ * to unifi_bh(). It also demonstrates how the timeout parameter passed in
+ * and returned from unifi_bh() needs to be handled.
+ *
+ * Arguments:
+ * arg Pointer to OS driver structure for the device.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * When the bottom half of the driver needs to process signals, events,
+ * or simply the host status (i.e sleep mode), it invokes unifi_run_bh().
+ * Since we need all SDIO transaction to be in a single thread, the
+ * unifi_run_bh() will wake up this thread to process it.
+ *
+ * ---------------------------------------------------------------------------
+ */
+static int
+bh_thread_function(void *arg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)arg;
+ CsrResult csrResult;
+ long ret;
+ CsrUint32 timeout, t;
+ struct uf_thread *this_thread;
+
+ unifi_trace(priv, UDBG2, "bh_thread_function starting\n");
+
+ this_thread = &priv->bh_thread;
+
+ t = timeout = 0;
+ while (!kthread_should_stop()) {
+ /* wait until an error occurs, or we need to process something. */
+ unifi_trace(priv, UDBG3, "bh_thread goes to sleep.\n");
+
+ if (timeout > 0) {
+ /* Convert t in ms to jiffies */
+ t = msecs_to_jiffies(timeout);
+ ret = wait_event_interruptible_timeout(this_thread->wakeup_q,
+ (this_thread->wakeup_flag && !this_thread->block_thread) ||
+ kthread_should_stop(),
+ t);
+ timeout = (ret > 0) ? jiffies_to_msecs(ret) : 0;
+ } else {
+ ret = wait_event_interruptible(this_thread->wakeup_q,
+ (this_thread->wakeup_flag && !this_thread->block_thread) ||
+ kthread_should_stop());
+ }
+
+ if (kthread_should_stop()) {
+ unifi_trace(priv, UDBG2, "bh_thread: signalled to exit\n");
+ break;
+ }
+
+ if (ret < 0) {
+ unifi_notice(priv,
+ "bh_thread: wait_event returned %d, thread will exit\n",
+ ret);
+ uf_wait_for_thread_to_stop(priv, this_thread);
+ break;
+ }
+
+ this_thread->wakeup_flag = 0;
+
+ unifi_trace(priv, UDBG3, "bh_thread calls unifi_bh().\n");
+
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_bh(priv->card, &timeout);
+ if(csrResult != CSR_RESULT_SUCCESS) {
+ if (csrResult == CSR_WIFI_HIP_RESULT_NO_DEVICE) {
+ CsrSdioRelease(priv->sdio);
+ uf_wait_for_thread_to_stop(priv, this_thread);
+ break;
+ }
+ /* Errors must be delivered to the error task */
+ handle_bh_error(priv);
+ }
+ CsrSdioRelease(priv->sdio);
+ }
+
+ /*
+ * I would normally try to call csr_sdio_remove_irq() here to make sure
+ * that we do not get any interrupts while this thread is not running.
+ * However, the MMC/SDIO driver tries to kill its' interrupt thread.
+ * The kernel threads implementation does not allow to kill threads
+ * from a signalled to stop thread.
+ * So, instead call csr_sdio_linux_remove_irq() always after calling
+ * uf_stop_thread() to kill this thread.
+ */
+
+ unifi_trace(priv, UDBG2, "bh_thread exiting....\n");
+ return 0;
+} /* bh_thread_function() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_init_bh
+ *
+ * Helper function to start the bottom half of the driver.
+ * All we need to do here is start the I/O bh thread.
+ *
+ * Arguments:
+ * priv Pointer to OS driver structure for the device.
+ *
+ * Returns:
+ * 0 on success or else a Linux error code.
+ * ---------------------------------------------------------------------------
+ */
+ int
+uf_init_bh(unifi_priv_t *priv)
+{
+ int r;
+
+ /* Enable mlme interface. */
+ priv->io_aborted = 0;
+
+
+ /* Start the BH thread */
+ r = uf_start_thread(priv, &priv->bh_thread, bh_thread_function);
+ if (r) {
+ unifi_error(priv,
+ "uf_init_bh: failed to start the BH thread.\n");
+ return r;
+ }
+
+ /* Allow interrupts */
+ r = csr_sdio_linux_install_irq(priv->sdio);
+ if (r) {
+ unifi_error(priv,
+ "uf_init_bh: failed to install the IRQ.\n");
+
+ uf_stop_thread(priv, &priv->bh_thread);
+ }
+
+ return r;
+} /* uf_init_bh() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_run_bh
+ *
+ * Part of the HIP core lib API, implemented in the porting exercise.
+ * The bottom half of the driver calls this function when
+ * it wants to process anything that requires access to unifi.
+ * We need to call unifi_bh() which in this implementation is done
+ * by waking up the I/O thread.
+ *
+ * Arguments:
+ * ospriv Pointer to OS driver structure for the device.
+ *
+ * Returns:
+ * 0 on success or else a Linux error code.
+ *
+ * Notes:
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_run_bh(void *ospriv)
+{
+ unifi_priv_t *priv = ospriv;
+
+ /*
+ * If an error has occured, we discard silently all messages from the bh
+ * until the error has been processed and the unifi has been reinitialised.
+ */
+ if (priv->bh_thread.block_thread == 1) {
+ unifi_trace(priv, UDBG3, "unifi_run_bh: discard message.\n");
+ /*
+ * Do not try to acknowledge a pending interrupt here.
+ * This function is called by unifi_send_signal() which in turn can be
+ * running in an atomic or 'disabled irq' level if a signal is sent
+ * from a workqueue task (i.e multicass addresses set).
+ * We can not hold the SDIO lock because it might sleep.
+ */
+ return CSR_RESULT_FAILURE;
+ }
+
+ priv->bh_thread.wakeup_flag = 1;
+ /* wake up I/O thread */
+ wake_up_interruptible(&priv->bh_thread.wakeup_q);
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_run_bh() */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+#include "csr_formatted_io.h"
+#include "csr_util.h"
+
+CsrInt32 CsrSnprintf(CsrCharString *dest, CsrSize n, const CsrCharString *fmt, ...)
+{
+ CsrInt32 r;
+ va_list args;
+ va_start(args, fmt);
+ r = CsrVsnprintf(dest, n, fmt, args);
+ va_end(args);
+
+ if (dest && (n > 0))
+ {
+ dest[n - 1] = '\0';
+ }
+
+ return r;
+}
--- /dev/null
+#ifndef CSR_FORMATTED_IO_H__
+#define CSR_FORMATTED_IO_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csr_types.h"
+
+CsrInt32 CsrSnprintf(CsrCharString *dest, CsrSize n, const CsrCharString *fmt, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/kthread.h>
+#include <linux/module.h>
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
+#include <linux/slab.h>
+#endif
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)
+#include <linux/freezer.h>
+#endif
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
+#include <asm/semaphore.h>
+#else
+#include <linux/semaphore.h>
+#endif
+
+#include <linux/bitops.h>
+
+#include "csr_types.h"
+#include "csr_framework_ext.h"
+#include "csr_panic.h"
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMutexCreate
+ *
+ * DESCRIPTION
+ * Create a mutex and return a handle to the created mutex.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_NO_MORE_MUTEXES in case of out of mutex resources
+ * CSR_FE_RESULT_INVALID_POINTER in case the mutexHandle pointer is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrMutexCreate(CsrMutexHandle *mutexHandle)
+{
+ if (mutexHandle == NULL)
+ {
+ return CSR_FE_RESULT_INVALID_POINTER;
+ }
+
+ sema_init(mutexHandle, 1);
+
+ return CSR_RESULT_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMutexDestroy
+ *
+ * DESCRIPTION
+ * Destroy the previously created mutex.
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+void CsrMutexDestroy(CsrMutexHandle *mutexHandle)
+{
+}
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMutexLock
+ *
+ * DESCRIPTION
+ * Lock the mutex refered to by the provided handle.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_INVALID_HANDLE in case the mutexHandle is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrMutexLock(CsrMutexHandle *mutexHandle)
+{
+ if (mutexHandle == NULL)
+ {
+ return CSR_FE_RESULT_INVALID_POINTER;
+ }
+
+ if (down_interruptible(mutexHandle))
+ {
+ CsrPanic(CSR_TECH_FW, CSR_PANIC_FW_UNEXPECTED_VALUE, "CsrMutexLock Failed");
+ return CSR_FE_RESULT_INVALID_POINTER;
+ }
+
+ return CSR_RESULT_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMutexUnlock
+ *
+ * DESCRIPTION
+ * Unlock the mutex refered to by the provided handle.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_INVALID_HANDLE in case the mutexHandle is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrMutexUnlock(CsrMutexHandle *mutexHandle)
+{
+ if (mutexHandle == NULL)
+ {
+ return CSR_FE_RESULT_INVALID_POINTER;
+ }
+
+ up(mutexHandle);
+
+ return CSR_RESULT_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrThreadSleep
+ *
+ * DESCRIPTION
+ * Sleep for a given period.
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+void CsrThreadSleep(CsrUint16 sleepTimeInMs)
+{
+ unsigned long t;
+
+ /* Convert t in ms to jiffies and round up */
+ t = ((sleepTimeInMs * HZ) + 999) / 1000;
+ schedule_timeout_uninterruptible(t);
+}
+EXPORT_SYMBOL_GPL(CsrThreadSleep);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMemCalloc
+ *
+ * DESCRIPTION
+ * Allocate dynamic memory of a given size calculated as the
+ * numberOfElements times the elementSize.
+ *
+ * RETURNS
+ * Pointer to allocated memory, or NULL in case of failure.
+ * Allocated memory is zero initialised.
+ *
+ *----------------------------------------------------------------------------*/
+void *CsrMemCalloc(CsrSize numberOfElements, CsrSize elementSize)
+{
+ void *buf;
+ size_t size;
+
+ size = numberOfElements * elementSize;
+
+ buf = kmalloc(size, GFP_KERNEL);
+ if (buf != NULL)
+ {
+ memset(buf, 0, size);
+ }
+
+ return buf;
+}
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMemAlloc
+ *
+ * DESCRIPTION
+ * Allocate dynamic memory of a given size.
+ *
+ * RETURNS
+ * Pointer to allocated memory, or NULL in case of failure.
+ * Allocated memory is not initialised.
+ *
+ *----------------------------------------------------------------------------*/
+void *CsrMemAlloc(CsrSize size)
+{
+ return kmalloc(size, GFP_KERNEL);
+}
+EXPORT_SYMBOL_GPL(CsrMemAlloc);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMemFree
+ *
+ * DESCRIPTION
+ * Free dynamic allocated memory.
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+void CsrMemFree(void *pointer)
+{
+ kfree(pointer);
+}
+EXPORT_SYMBOL_GPL(CsrMemFree);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMemAllocDma
+ *
+ * DESCRIPTION
+ * Allocate DMA capable dynamic memory of a given size.
+ *
+ * RETURNS
+ * Pointer to allocated memory, or NULL in case of failure.
+ * Allocated memory is not initialised.
+ *
+ *----------------------------------------------------------------------------*/
+void *CsrMemAllocDma(CsrSize size)
+{
+ return kmalloc(size, GFP_KERNEL | GFP_DMA);
+}
+EXPORT_SYMBOL_GPL(CsrMemAllocDma);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMemFreeDma
+ *
+ * DESCRIPTION
+ * Free DMA capable dynamic allocated memory.
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+void CsrMemFreeDma(void *pointer)
+{
+ kfree(pointer);
+}
+EXPORT_SYMBOL_GPL(CsrMemFreeDma);
--- /dev/null
+#ifndef CSR_FRAMEWORK_EXT_H__
+#define CSR_FRAMEWORK_EXT_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+#include "csr_result.h"
+#include "csr_framework_ext_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Result codes */
+#define CSR_FE_RESULT_NO_MORE_EVENTS ((CsrResult) 0x0001)
+#define CSR_FE_RESULT_INVALID_POINTER ((CsrResult) 0x0002)
+#define CSR_FE_RESULT_INVALID_HANDLE ((CsrResult) 0x0003)
+#define CSR_FE_RESULT_NO_MORE_MUTEXES ((CsrResult) 0x0004)
+#define CSR_FE_RESULT_TIMEOUT ((CsrResult) 0x0005)
+#define CSR_FE_RESULT_NO_MORE_THREADS ((CsrResult) 0x0006)
+
+/* Thread priorities */
+#define CSR_THREAD_PRIORITY_HIGHEST ((CsrUint16) 0)
+#define CSR_THREAD_PRIORITY_HIGH ((CsrUint16) 1)
+#define CSR_THREAD_PRIORITY_NORMAL ((CsrUint16) 2)
+#define CSR_THREAD_PRIORITY_LOW ((CsrUint16) 3)
+#define CSR_THREAD_PRIORITY_LOWEST ((CsrUint16) 4)
+
+#define CSR_EVENT_WAIT_INFINITE ((CsrUint16) 0xFFFF)
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrEventCreate
+ *
+ * DESCRIPTION
+ * Creates an event and returns a handle to the created event.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_NO_MORE_EVENTS in case of out of event resources
+ * CSR_FE_RESULT_INVALID_POINTER in case the eventHandle pointer is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrEventCreate(CsrEventHandle *eventHandle);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrEventWait
+ *
+ * DESCRIPTION
+ * Wait fore one or more of the event bits to be set.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_TIMEOUT in case of timeout
+ * CSR_FE_RESULT_INVALID_HANDLE in case the eventHandle is invalid
+ * CSR_FE_RESULT_INVALID_POINTER in case the eventBits pointer is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrEventWait(CsrEventHandle *eventHandle, CsrUint16 timeoutInMs, CsrUint32 *eventBits);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrEventSet
+ *
+ * DESCRIPTION
+ * Set an event.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_INVALID_HANDLE in case the eventHandle is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrEventSet(CsrEventHandle *eventHandle, CsrUint32 eventBits);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrEventDestroy
+ *
+ * DESCRIPTION
+ * Destroy the event associated.
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+void CsrEventDestroy(CsrEventHandle *eventHandle);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMutexCreate
+ *
+ * DESCRIPTION
+ * Create a mutex and return a handle to the created mutex.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_NO_MORE_MUTEXES in case of out of mutex resources
+ * CSR_FE_RESULT_INVALID_POINTER in case the mutexHandle pointer is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrMutexCreate(CsrMutexHandle *mutexHandle);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMutexLock
+ *
+ * DESCRIPTION
+ * Lock the mutex refered to by the provided handle.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_INVALID_HANDLE in case the mutexHandle is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrMutexLock(CsrMutexHandle *mutexHandle);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMutexUnlock
+ *
+ * DESCRIPTION
+ * Unlock the mutex refered to by the provided handle.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_INVALID_HANDLE in case the mutexHandle is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrMutexUnlock(CsrMutexHandle *mutexHandle);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMutexDestroy
+ *
+ * DESCRIPTION
+ * Destroy the previously created mutex.
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+void CsrMutexDestroy(CsrMutexHandle *mutexHandle);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrGlobalMutexLock
+ *
+ * DESCRIPTION
+ * Lock the global mutex. The global mutex is a single pre-initialised
+ * shared mutex, spinlock or similar that does not need to be created prior
+ * to use. The limitation is that there is only one single lock shared
+ * between all code. Consequently, it must only be used very briefly to
+ * either protect simple one-time initialisation or to protect the creation
+ * of a dedicated mutex by calling CsrMutexCreate.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrGlobalMutexLock(void);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrGlobalMutexUnlock
+ *
+ * DESCRIPTION
+ * Unlock the global mutex.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrGlobalMutexUnlock(void);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrThreadCreate
+ *
+ * DESCRIPTION
+ * Create thread function and return a handle to the created thread.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_NO_MORE_THREADS in case of out of thread resources
+ * CSR_FE_RESULT_INVALID_POINTER in case one of the supplied pointers is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrThreadCreate(void (*threadFunction)(void *pointer), void *pointer,
+ CsrUint32 stackSize, CsrUint16 priority,
+ const CsrCharString *threadName, CsrThreadHandle *threadHandle);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrThreadGetHandle
+ *
+ * DESCRIPTION
+ * Return thread handle of calling thread.
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case of success
+ * CSR_FE_RESULT_INVALID_POINTER in case the threadHandle pointer is invalid
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrThreadGetHandle(CsrThreadHandle *threadHandle);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrThreadEqual
+ *
+ * DESCRIPTION
+ * Compare thread handles
+ *
+ * RETURNS
+ * Possible values:
+ * CSR_RESULT_SUCCESS in case thread handles are identical
+ * CSR_FE_RESULT_INVALID_POINTER in case either threadHandle pointer is invalid
+ * CSR_RESULT_FAILURE otherwise
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrThreadEqual(CsrThreadHandle *threadHandle1, CsrThreadHandle *threadHandle2);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrThreadSleep
+ *
+ * DESCRIPTION
+ * Sleep for a given period.
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+void CsrThreadSleep(CsrUint16 sleepTimeInMs);
+
+#ifndef CSR_PMEM_DEBUG_ENABLE
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMemAlloc
+ *
+ * DESCRIPTION
+ * Allocate dynamic memory of a given size.
+ *
+ * RETURNS
+ * Pointer to allocated memory, or NULL in case of failure.
+ * Allocated memory is not initialised.
+ *
+ *----------------------------------------------------------------------------*/
+#ifdef CSR_MEM_DEBUG
+void *CsrMemAllocDebug(CsrSize size,
+ const CsrCharString *file, CsrUint32 line);
+#define CsrMemAlloc(sz) CsrMemAllocDebug((sz), __FILE__, __LINE__)
+#else
+void *CsrMemAlloc(CsrSize size);
+#endif
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMemCalloc
+ *
+ * DESCRIPTION
+ * Allocate dynamic memory of a given size calculated as the
+ * numberOfElements times the elementSize.
+ *
+ * RETURNS
+ * Pointer to allocated memory, or NULL in case of failure.
+ * Allocated memory is zero initialised.
+ *
+ *----------------------------------------------------------------------------*/
+#ifdef CSR_MEM_DEBUG
+void *CsrMemCallocDebug(CsrSize numberOfElements, CsrSize elementSize,
+ const CsrCharString *file, CsrUint32 line);
+#define CsrMemCalloc(cnt, sz) CsrMemAllocDebug((cnt), (sz), __FILE__, __LINE__)
+#else
+void *CsrMemCalloc(CsrSize numberOfElements, CsrSize elementSize);
+#endif
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMemFree
+ *
+ * DESCRIPTION
+ * Free dynamic allocated memory.
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+void CsrMemFree(void *pointer);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMemAllocDma
+ *
+ * DESCRIPTION
+ * Allocate dynamic memory suitable for DMA transfers.
+ *
+ * RETURNS
+ * Pointer to allocated memory, or NULL in case of failure.
+ * Allocated memory is not initialised.
+ *
+ *----------------------------------------------------------------------------*/
+#ifdef CSR_MEM_DEBUG
+void *CsrMemAllocDmaDebug(CsrSize size,
+ const CsrCharString *file, CsrUint32 line);
+#define CsrMemAllocDma(sz) CsrMemAllocDmaDebug((sz), __FILE__, __LINE__)
+#else
+void *CsrMemAllocDma(CsrSize size);
+#endif
+
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrMemFreeDma
+ *
+ * DESCRIPTION
+ * Free dynamic memory allocated by CsrMemAllocDma.
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+void CsrMemFreeDma(void *pointer);
+#else
+
+#include "csr_pmem.h"
+
+#define CsrMemAlloc(size) CsrPmemDebugAlloc(size, CSR_PMEM_DEBUG_TYPE_MEM_ALLOC, __FILE__, __LINE__)
+
+#define CsrMemCalloc(numberOfElements, elementSize) CsrPmemDebugAlloc((numberOfElements * elementSize), CSR_PMEM_DEBUG_TYPE_MEM_CALLOC, __FILE__, __LINE__)
+
+#define CsrMemFree(ptr) CsrPmemDebugFree(ptr,CSR_PMEM_DEBUG_TYPE_MEM_ALLOC, __FILE__, __LINE__)
+
+#define CsrMemAllocDma(size) CsrPmemDebugAlloc(size, CSR_PMEM_DEBUG_TYPE_MEM_ALLOC_DMA, __FILE__, __LINE__)
+
+#define CsrMemFreeDma(ptr) CsrPmemDebugFree(ptr, CSR_PMEM_DEBUG_TYPE_MEM_ALLOC_DMA, __FILE__, __LINE__)
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_FRAMEWORK_EXT_TYPES_H__
+#define CSR_FRAMEWORK_EXT_TYPES_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+
+#ifdef __KERNEL__
+#include <linux/kthread.h>
+#include <linux/semaphore.h>
+#else
+#include <pthread.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifdef __KERNEL__
+
+struct CsrThread
+{
+ struct task_struct *thread_task;
+ char name[16];
+};
+
+struct CsrEvent
+{
+ /* wait_queue for waking the kernel thread */
+ wait_queue_head_t wakeup_q;
+ unsigned int wakeup_flag;
+};
+
+typedef struct CsrEvent CsrEventHandle;
+typedef struct semaphore CsrMutexHandle;
+typedef struct CsrThread CsrThreadHandle;
+
+#else /* __KERNEL __ */
+
+struct CsrEvent
+{
+ pthread_cond_t event;
+ pthread_mutex_t mutex;
+ CsrUint32 eventBits;
+};
+
+typedef struct CsrEvent CsrEventHandle;
+typedef pthread_mutex_t CsrMutexHandle;
+typedef pthread_t CsrThreadHandle;
+
+#endif /* __KERNEL__ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_LIB_H__
+#define CSR_LIB_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+ CsrPrim type;
+} CsrEvent;
+
+/*----------------------------------------------------------------------------*
+ * CsrEvent_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrEvent
+ *
+ *----------------------------------------------------------------------------*/
+CsrEvent *CsrEvent_struct(CsrUint16 primtype, CsrUint16 msgtype);
+
+typedef struct
+{
+ CsrPrim type;
+ CsrUint8 value;
+} CsrEventCsrUint8;
+
+/*----------------------------------------------------------------------------*
+ * CsrEventCsrUint8_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrEventCsrUint8
+ *
+ *----------------------------------------------------------------------------*/
+CsrEventCsrUint8 *CsrEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint8 value);
+
+typedef struct
+{
+ CsrPrim type;
+ CsrUint16 value;
+} CsrEventCsrUint16;
+
+/*----------------------------------------------------------------------------*
+ * CsrEventCsrUint16_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrEventCsrUint16
+ *
+ *----------------------------------------------------------------------------*/
+CsrEventCsrUint16 *CsrEventCsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value);
+
+typedef struct
+{
+ CsrPrim type;
+ CsrUint16 value1;
+ CsrUint8 value2;
+} CsrEventCsrUint16CsrUint8;
+
+/*----------------------------------------------------------------------------*
+ * CsrEventCsrUint16CsrUint8_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrEventCsrUint16CsrUint8
+ *
+ *----------------------------------------------------------------------------*/
+CsrEventCsrUint16CsrUint8 *CsrEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrUint8 value2);
+
+typedef struct
+{
+ CsrPrim type;
+ CsrUint16 value1;
+ CsrUint16 value2;
+} CsrEventCsrUint16CsrUint16;
+
+/*----------------------------------------------------------------------------*
+ * CsrEventCsrUint16CsrUint16_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrEventCsrUint16CsrUint16
+ *
+ *----------------------------------------------------------------------------*/
+CsrEventCsrUint16CsrUint16 *CsrEventCsrUint16CsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrUint16 value2);
+
+typedef struct
+{
+ CsrPrim type;
+ CsrUint16 value1;
+ CsrUint32 value2;
+} CsrEventCsrUint16CsrUint32;
+
+/*----------------------------------------------------------------------------*
+ * CsrEventCsrUint16_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrEventCsrUint16
+ *
+ *----------------------------------------------------------------------------*/
+CsrEventCsrUint16CsrUint32 *CsrEventCsrUint16CsrUint32_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrUint32 value2);
+
+typedef struct
+{
+ CsrPrim type;
+ CsrUint16 value1;
+ CsrCharString *value2;
+} CsrEventCsrUint16CsrCharString;
+
+/*----------------------------------------------------------------------------*
+ * CsrEventCsrUint16CsrCharString_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrEventCsrUint16CsrCharString
+ *
+ *----------------------------------------------------------------------------*/
+CsrEventCsrUint16CsrCharString *CsrEventCsrUint16CsrCharString_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint16 value1, CsrCharString *value2);
+
+typedef struct
+{
+ CsrPrim type;
+ CsrUint32 value;
+} CsrEventCsrUint32;
+
+/*----------------------------------------------------------------------------*
+ * CsrEventCsrUint32_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrEventCsrUint32
+ *
+ *----------------------------------------------------------------------------*/
+CsrEventCsrUint32 *CsrEventCsrUint32_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint32 value);
+
+typedef struct
+{
+ CsrPrim type;
+ CsrUint32 value1;
+ CsrUint16 value2;
+} CsrEventCsrUint32CsrUint16;
+
+/*----------------------------------------------------------------------------*
+ * CsrEventCsrUint32CsrUint16_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrEventCsrUint32CsrUint16
+ *
+ *----------------------------------------------------------------------------*/
+CsrEventCsrUint32CsrUint16 *CsrEventCsrUint32CsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint32 value1, CsrUint32 value2);
+
+typedef struct
+{
+ CsrPrim type;
+ CsrUint32 value1;
+ CsrCharString *value2;
+} CsrEventCsrUint32CsrCharString;
+
+/*----------------------------------------------------------------------------*
+ * CsrEventCsrUint32CsrCharString_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrEventCsrUint32CsrCharString
+ *
+ *----------------------------------------------------------------------------*/
+CsrEventCsrUint32CsrCharString *CsrEventCsrUint32CsrCharString_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrUint32 value1, CsrCharString *value2);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_LIB_H__ */
--- /dev/null
+#ifndef CSR_LOG_H__
+#define CSR_LOG_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+#include "csr_sched.h"
+#include "csr_panic.h"
+#include "csr_prim_defs.h"
+#include "csr_msgconv.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Log filtering
+ */
+
+/*----------------------------------------------------*/
+/* Filtering on environment specific log levels */
+/*----------------------------------------------------*/
+typedef CsrUint32 CsrLogLevelEnvironment;
+#define CSR_LOG_LEVEL_ENVIRONMENT_OFF ((CsrLogLevelEnvironment) 0x00000000) /* No environment data/events are logged */
+#define CSR_LOG_LEVEL_ENVIRONMENT_BCI_ACL ((CsrLogLevelEnvironment) 0x00000001) /* BlueCore Channel Interface HCI Acl data are logged */
+#define CSR_LOG_LEVEL_ENVIRONMENT_BCI_HCI ((CsrLogLevelEnvironment) 0x00000002) /* BlueCore Channel Interface HCI Cmd/Evt data are logged */
+#define CSR_LOG_LEVEL_ENVIRONMENT_BCI_SCO ((CsrLogLevelEnvironment) 0x00000004) /* BlueCore Channel Interface HCI Sco data are logged */
+#define CSR_LOG_LEVEL_ENVIRONMENT_BCI_VENDOR ((CsrLogLevelEnvironment) 0x00000008) /* BlueCore Channel Interface HCI Vendor specific data are logged (This includes BCCMD, HQ, VM etc) */
+#define CSR_LOG_LEVEL_ENVIRONMENT_TRANSPORTS ((CsrLogLevelEnvironment) 0x00000010) /* Transport protocol data is logged (This includes transport protocols like BCSP, H4 etc.) */
+#define CSR_LOG_LEVEL_ENVIRONMENT_BGINT_REG ((CsrLogLevelEnvironment) 0x00000020) /* Background Interrupt registration events are logged */
+#define CSR_LOG_LEVEL_ENVIRONMENT_BGINT_UNREG ((CsrLogLevelEnvironment) 0x00000040) /* Background Interrupt unregistration events are logged */
+#define CSR_LOG_LEVEL_ENVIRONMENT_BGINT_SET ((CsrLogLevelEnvironment) 0x00000080) /* Background Interrupt set events are logged */
+#define CSR_LOG_LEVEL_ENVIRONMENT_BGINT_START ((CsrLogLevelEnvironment) 0x00000100) /* Background Interrupt start events are logged */
+#define CSR_LOG_LEVEL_ENVIRONMENT_BGINT_DONE ((CsrLogLevelEnvironment) 0x00000200) /* Background Interrupt done events are logged */
+#define CSR_LOG_LEVEL_ENVIRONMENT_PROTO ((CsrLogLevelEnvironment) 0x00000400) /* Transport protocol events are logged */
+#define CSR_LOG_LEVEL_ENVIRONMENT_PROTO_LOC ((CsrLogLevelEnvironment) 0x00000800) /* The Location where the transport protocol event occured are logged NB: This is a supplement to CSR_LOG_LEVEL_ENVIRONMENT_PROTO, it has no effect without it */
+/* The bit masks between here are reserved for future usage */
+#define CSR_LOG_LEVEL_ENVIRONMENT_ALL ((CsrLogLevelEnvironment) 0xFFFFFFFF) /* All possible environment data/events are logged WARNING: By using this define the application also accepts future possible environment data/events in the logs */
+
+/*----------------------------------------------------*/
+/* Filtering on task specific log levels */
+/*----------------------------------------------------*/
+typedef CsrUint32 CsrLogLevelTask;
+#define CSR_LOG_LEVEL_TASK_OFF ((CsrLogLevelTask) 0x00000000) /* No events are logged for this task */
+#define CSR_LOG_LEVEL_TASK_TEXT ((CsrLogLevelTask) 0x00000001) /* Text strings printed by a task are logged NB: This bit does not affect the CSR_LOG_TEXT_LEVEL interface. This has to be configured separately */
+#define CSR_LOG_LEVEL_TASK_TEXT_LOC ((CsrLogLevelTask) 0x00000002) /* The locaction where the text string call occured are logged. NB: This is a supplement to CSR_LOG_LEVEL_TASK_TEXT, it has no effect without it */
+#define CSR_LOG_LEVEL_TASK_STATE ((CsrLogLevelTask) 0x00000004) /* FSM state transitions in a task are logged */
+#define CSR_LOG_LEVEL_TASK_STATE_NAME ((CsrLogLevelTask) 0x00000008) /* The name of each state in a FSM state transition are logged. NB: This is a supplement to CSR_LOG_LEVEL_TASK_STATE, it has no effect without it */
+#define CSR_LOG_LEVEL_TASK_STATE_LOC ((CsrLogLevelTask) 0x00000010) /* The location where the FSM state transition occured are logged. NB: This is a supplement to CSR_LOG_LEVEL_TASK_STATE, it has no effect without it */
+#define CSR_LOG_LEVEL_TASK_TASK_SWITCH ((CsrLogLevelTask) 0x00000020) /* Activation and deactiation of a task are logged */
+#define CSR_LOG_LEVEL_TASK_MESSAGE_PUT ((CsrLogLevelTask) 0x00000080) /* Message put operations are logged */
+#define CSR_LOG_LEVEL_TASK_MESSAGE_PUT_LOC ((CsrLogLevelTask) 0x00000100) /* The location where a message was sent are logged. NB: This is a supplement to CSR_LOG_LEVEL_TASK_MESSAGE_PUT, it has no effect without it */
+#define CSR_LOG_LEVEL_TASK_MESSAGE_GET ((CsrLogLevelTask) 0x00000200) /* Message get operations are logged */
+#define CSR_LOG_LEVEL_TASK_MESSAGE_QUEUE_PUSH ((CsrLogLevelTask) 0x00000400) /* Message push operations are logged */
+#define CSR_LOG_LEVEL_TASK_MESSAGE_QUEUE_POP ((CsrLogLevelTask) 0x00000800) /* Message pop operations are logged */
+#define CSR_LOG_LEVEL_TASK_PRIM_ONLY_TYPE ((CsrLogLevelTask) 0x00001000) /* Only the type of primitives in messages are logged. By default the entire primitive is serialized and logged */
+#define CSR_LOG_LEVEL_TASK_PRIM_APPLY_LIMIT ((CsrLogLevelTask) 0x00002000) /* An upper limit (defined by CSR_LOG_PRIM_SIZE_UPPER_LIMIT) is applied to how much of a primitive in a message are logged. NB: This limit is only applied if CSR_LOG_LEVEL_TASK_PRIM_ONLY_TYPE is _not_ defined */
+#define CSR_LOG_LEVEL_TASK_TIMER_IN ((CsrLogLevelTask) 0x00004000) /* TimedEventIn events are logged */
+#define CSR_LOG_LEVEL_TASK_TIMER_IN_LOC ((CsrLogLevelTask) 0x00008000) /* The location where a timer was started are logged. NB: This is a supplement to CSR_LOG_LEVEL_TASK_TIMER_IN, it has no effect without it */
+#define CSR_LOG_LEVEL_TASK_TIMER_CANCEL ((CsrLogLevelTask) 0x00010000) /* TimedEventCancel events are logged */
+#define CSR_LOG_LEVEL_TASK_TIMER_CANCEL_LOC ((CsrLogLevelTask) 0x00020000) /* The location where a timer was cancelled are logged. NB: This is a supplement to CSR_LOG_LEVEL_TASK_TIMER_CANCEL, it has no effect without it */
+#define CSR_LOG_LEVEL_TASK_TIMER_FIRE ((CsrLogLevelTask) 0x00040000) /* TimedEventFire events are logged */
+#define CSR_LOG_LEVEL_TASK_TIMER_DONE ((CsrLogLevelTask) 0x00080000) /* TimedEventDone events are logged */
+/* The bit masks between here are reserved for future usage */
+#define CSR_LOG_LEVEL_TASK_ALL ((CsrLogLevelTask) 0xFFFFFFFF & ~(CSR_LOG_LEVEL_TASK_PRIM_ONLY_TYPE | CSR_LOG_LEVEL_TASK_PRIM_APPLY_LIMIT)) /* All info possible to log for a task are logged. WARNING: By using this define the application also accepts future possible task data/events in the logs */
+
+CsrBool CsrLogEnvironmentIsFiltered(CsrLogLevelEnvironment level);
+CsrLogLevelTask CsrLogTaskFilterGet(CsrSchedQid taskId);
+CsrBool CsrLogTaskIsFiltered(CsrSchedQid taskId, CsrLogLevelTask level);
+
+/*
+ * Logging stuff
+ */
+#define CSR_LOG_STRINGIFY_REAL(a) #a
+#define CSR_LOG_STRINGIFY(a) CSR_LOG_STRINGIFY_REAL(a)
+
+#ifdef CSR_LOG_ASSERT_ENABLE
+#define CSR_LOG_ASSERT(cond) \
+ do { \
+ if (!(cond)) \
+ { \
+ CsrCharString *panic_arg = "[" __FILE__ ":" CSR_LOG_STRINGIFY(__LINE__) "] - " CSR_LOG_STRINGIFY(cond); \
+ CsrPanic(CSR_TECH_FW, CSR_PANIC_FW_ASSERTION_FAIL, panic_arg); \
+ } \
+ } while (0)
+#else
+#define CSR_LOG_ASSERT(cond)
+#endif
+
+typedef struct
+{
+ CsrUint16 primitiveType;
+ const CsrCharString *primitiveName;
+ CsrMsgConvMsgEntry *messageConv; /* Private - do not use */
+} CsrLogPrimitiveInformation;
+
+typedef struct
+{
+ const CsrCharString *techVer;
+ CsrUint32 primitiveInfoCount;
+ CsrLogPrimitiveInformation *primitiveInfo;
+} CsrLogTechInformation;
+
+/*---------------------------------*/
+/* Tech logging */
+/*---------------------------------*/
+typedef CsrUint8 bitmask8_t;
+typedef CsrUint16 bitmask16_t;
+typedef CsrUint32 bitmask32_t;
+
+#ifdef CSR_LOG_ENABLE
+#ifdef CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER
+/* DEPRECATED - replaced by csr_log_text.h */
+#define CSR_LOG_TEXT(text) \
+ do { \
+ if (!CsrLogTaskIsFiltered(CsrSchedTaskQueueGet(), CSR_LOG_LEVEL_TASK_TEXT)) \
+ { \
+ CsrLogTaskText(text, __LINE__, __FILE__); \
+ } \
+ } while (0)
+#else
+/* DEPRECATED - replaced by csr_log_text.h */
+#define CSR_LOG_TEXT(text) \
+ do { \
+ if (!CsrLogTaskIsFiltered(CsrSchedTaskQueueGet(), CSR_LOG_LEVEL_TASK_TEXT)) \
+ { \
+ CsrLogTaskText(text, 0, NULL); \
+ } \
+ } while (0)
+#endif
+#else
+#define CSR_LOG_TEXT(text)
+#endif
+
+/* DEPRECATED - replaced by csr_log_text.h */
+void CsrLogTaskText(const CsrCharString *text,
+ CsrUint32 line,
+ const CsrCharString *file);
+
+#define CSR_LOG_STATE_TRANSITION_MASK_FSM_NAME (0x001)
+#define CSR_LOG_STATE_TRANSITION_MASK_NEXT_STATE (0x002)
+#define CSR_LOG_STATE_TRANSITION_MASK_NEXT_STATE_STR (0x004)
+#define CSR_LOG_STATE_TRANSITION_MASK_PREV_STATE (0x008)
+#define CSR_LOG_STATE_TRANSITION_MASK_PREV_STATE_STR (0x010)
+#define CSR_LOG_STATE_TRANSITION_MASK_EVENT (0x020)
+#define CSR_LOG_STATE_TRANSITION_MASK_EVENT_STR (0x040)
+
+/* DEPRECATED - replaced by csr_log_text.h */
+void CsrLogStateTransition(bitmask16_t mask,
+ CsrUint32 identifier,
+ const CsrCharString *fsm_name,
+ CsrUint32 prev_state,
+ const CsrCharString *prev_state_str,
+ CsrUint32 in_event,
+ const CsrCharString *in_event_str,
+ CsrUint32 next_state,
+ const CsrCharString *next_state_str,
+ CsrUint32 line,
+ const CsrCharString *file);
+
+/*---------------------------------*/
+/* BSP logging */
+/*---------------------------------*/
+void CsrLogSchedInit(CsrUint8 thread_id);
+void CsrLogSchedDeinit(CsrUint8 thread_id);
+
+void CsrLogSchedStart(CsrUint8 thread_id);
+void CsrLogSchedStop(CsrUint8 thread_id);
+
+void CsrLogInitTask(CsrUint8 thread_id, CsrSchedQid tskid, const CsrCharString *tskName);
+void CsrLogDeinitTask(CsrUint16 task_id);
+
+void CsrLogActivate(CsrSchedQid tskid);
+void CsrLogDeactivate(CsrSchedQid tskid);
+
+#define SYNERGY_SERIALIZER_TYPE_DUMP (0x000)
+#define SYNERGY_SERIALIZER_TYPE_SER (0x001)
+
+void CsrLogMessagePut(CsrUint32 line,
+ const CsrCharString *file,
+ CsrSchedQid src_task_id,
+ CsrSchedQid dst_taskid,
+ CsrSchedMsgId msg_id,
+ CsrUint16 prim_type,
+ const void *msg);
+
+void CsrLogMessageGet(CsrSchedQid src_task_id,
+ CsrSchedQid dst_taskid,
+ CsrBool get_res,
+ CsrSchedMsgId msg_id,
+ CsrUint16 prim_type,
+ const void *msg);
+
+void CsrLogTimedEventIn(CsrUint32 line,
+ const CsrCharString *file,
+ CsrSchedQid task_id,
+ CsrSchedTid tid,
+ CsrTime requested_delay,
+ CsrUint16 fniarg,
+ const void *fnvarg);
+
+void CsrLogTimedEventFire(CsrSchedQid task_id,
+ CsrSchedTid tid);
+
+void CsrLogTimedEventDone(CsrSchedQid task_id,
+ CsrSchedTid tid);
+
+void CsrLogTimedEventCancel(CsrUint32 line,
+ const CsrCharString *file,
+ CsrSchedQid task_id,
+ CsrSchedTid tid,
+ CsrBool cancel_res);
+
+void CsrLogBgintRegister(CsrUint8 thread_id,
+ CsrSchedBgint irq,
+ const CsrCharString *callback,
+ const void *ptr);
+void CsrLogBgintUnregister(CsrSchedBgint irq);
+void CsrLogBgintSet(CsrSchedBgint irq);
+void CsrLogBgintServiceStart(CsrSchedBgint irq);
+void CsrLogBgintServiceDone(CsrSchedBgint irq);
+
+void CsrLogExceptionStateEvent(CsrUint16 prim_type,
+ CsrPrim msg_type,
+ CsrUint16 state,
+ CsrUint32 line,
+ const CsrCharString *file);
+void CsrLogExceptionGeneral(CsrUint16 prim_type,
+ CsrUint16 state,
+ const CsrCharString *text,
+ CsrUint32 line,
+ const CsrCharString *file);
+void CsrLogExceptionWarning(CsrUint16 prim_type,
+ CsrUint16 state,
+ const CsrCharString *text,
+ CsrUint32 line,
+ const CsrCharString *file);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_LOG_CONFIGURE_H__
+#define CSR_LOG_CONFIGURE_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+#include "csr_log.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------*/
+/* Log init/deinit */
+/*---------------------------------*/
+void CsrLogInit(CsrUint8 size);
+void CsrLogDeinit(void);
+
+/*---------------------------------*/
+/* Log Framework Tech info */
+/*---------------------------------*/
+void CsrLogTechInfoRegister(void);
+
+/* Set the logging level for the environment outside the scheduler context */
+void CsrLogLevelEnvironmentSet(CsrLogLevelEnvironment environmentLogLevel);
+
+
+/* Set the logging level for all scheduler tasks */
+/* This function call takes precedence over all previous calls to CsrLogLevelTaskSetSpecific() */
+void CsrLogLevelTaskSetAll(CsrLogLevelTask tasksLogLevelMask);
+
+/* Set the logging level for a given Task */
+/* This function can be used as a complement to CsrLogLevelTaskSetAll() to add more _or_ less log from a given task than what is set
+generally with CsrLogLevelTaskSetAll(). */
+void CsrLogLevelTaskSetSpecific(CsrSchedQid taskId, CsrLogLevelTask taskLogLevelMask);
+
+
+/*--------------------------------------------*/
+/* Filtering on log text warning levels */
+/*--------------------------------------------*/
+typedef CsrUint32 CsrLogLevelText;
+#define CSR_LOG_LEVEL_TEXT_OFF ((CsrLogLevelText) 0x0000)
+
+#define CSR_LOG_LEVEL_TEXT_CRITICAL ((CsrLogLevelText) 0x0001)
+#define CSR_LOG_LEVEL_TEXT_ERROR ((CsrLogLevelText) 0x0002)
+#define CSR_LOG_LEVEL_TEXT_WARNING ((CsrLogLevelText) 0x0004)
+#define CSR_LOG_LEVEL_TEXT_INFO ((CsrLogLevelText) 0x0008)
+#define CSR_LOG_LEVEL_TEXT_DEBUG ((CsrLogLevelText) 0x0010)
+
+#define CSR_LOG_LEVEL_TEXT_ALL ((CsrLogLevelText) 0xFFFF)
+
+/* The log text interface is used by both scheduler tasks and components outside the scheduler context.
+ * Therefore a CsrLogTextTaskId is introduced. It is effectively considered as two CsrUint16's. The lower
+ * 16 bits corresponds one2one with the scheduler queueId's (CsrSchedQid) and as such these bits can not be used
+ * by components outside scheduler tasks. The upper 16 bits are allocated for use of components outside the
+ * scheduler like drivers etc. Components in this range is defined independently by each technology. To avoid
+ * clashes the technologies are only allowed to assign values within the same restrictive range as allies to
+ * primitive identifiers. eg. for the framework components outside the scheduler is only allowed to assign
+ * taskId's in the range 0x0600xxxx to 0x06FFxxxx. And so on for other technologies. */
+typedef CsrUint32 CsrLogTextTaskId;
+
+/* Set the text logging level for all Tasks */
+/* This function call takes precedence over all previous calls to CsrLogLevelTextSetTask() and CsrLogLevelTextSetTaskSubOrigin() */
+void CsrLogLevelTextSetAll(CsrLogLevelText warningLevelMask);
+
+/* Set the text logging level for a given Task */
+/* This function call takes precedence over all previous calls to CsrLogLevelTextSetTaskSubOrigin(), but it can be used as a complement to
+ * CsrLogLevelTextSetAll() to add more _or_ less log from a given task than what is set generally with CsrLogLevelTextSetAll(). */
+void CsrLogLevelTextSetTask(CsrLogTextTaskId taskId, CsrLogLevelText warningLevelMask);
+
+/* Set the text logging level for a given tasks subOrigin */
+/* This function can be used as a complement to CsrLogLevelTextSetAll() and CsrLogLevelTextSetTask() to add more _or_ less log from a given
+ * subOrigin within a task than what is set generally with CsrLogLevelTextSetAll() _or_ CsrLogLevelTextSetTask(). */
+void CsrLogLevelTextSetTaskSubOrigin(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrLogLevelText warningLevelMask);
+
+/*******************************************************************************
+
+ NAME
+ CsrLogLevelTextSet
+
+ DESCRIPTION
+ Set the text logging level for a given origin and optionally sub origin
+ by name. If either string is NULL or zero length, it is interpreted as
+ all origins and/or all sub origins respectively. If originName is NULL
+ or zero length, subOriginName is ignored.
+
+ Passing NULL or zero length strings in both originName and subOriginName
+ is equivalent to calling CsrLogLevelTextSetAll, and overrides all
+ previous filter configurations for all origins and sub origins.
+
+ Passing NULL or a zero length string in subOriginName overrides all
+ previous filter configurations for all sub origins of the specified
+ origin.
+
+ Note: the supplied strings may be accessed after the function returns
+ and must remain valid and constant until CsrLogDeinit is called.
+
+ Note: when specifying an origin (originName is not NULL and not zero
+ length), this function can only be used for origins that use the
+ csr_log_text_2.h interface for registration and logging. Filtering for
+ origins that use the legacy csr_log_text.h interface must be be
+ configured using the legacy filter configuration functions that accept
+ a CsrLogTextTaskId as origin specifier. However, when not specifying an
+ origin this function also affects origins that have been registered with
+ the legacy csr_log_text.h interface. Furthermore, using this function
+ and the legacy filter configuration functions on the same origin is not
+ allowed.
+
+ PARAMETERS
+ originName - a string containing the name of the origin. Can be NULL or
+ zero length to set the log level for all origins. In this case, the
+ subOriginName parameter will be ignored.
+ subOriginName - a string containing the name of the sub origin. Can be
+ NULL or zero length to set the log level for all sub origins of the
+ specified origin.
+ warningLevelMask - The desired log level for the specified origin(s) and
+ sub origin(s).
+
+*******************************************************************************/
+void CsrLogLevelTextSet(const CsrCharString *originName,
+ const CsrCharString *subOriginName,
+ CsrLogLevelText warningLevelMask);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_LOG_TEXT_H__
+#define CSR_LOG_TEXT_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+#include "csr_log_configure.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct CsrLogSubOrigin
+{
+ CsrUint16 subOriginNumber; /* Id of the given SubOrigin */
+ const CsrCharString *subOriginName; /* Prefix Text for this SubOrigin */
+} CsrLogSubOrigin;
+
+/* Register a task which is going to use the CSR_LOG_TEXT_XXX interface */
+#ifdef CSR_LOG_ENABLE
+void CsrLogTextRegister(CsrLogTextTaskId taskId, const CsrCharString *taskName, CsrUint16 subOriginsLength, const CsrLogSubOrigin *subOrigins);
+#else
+#define CsrLogTextRegister(taskId, taskName, subOriginsLength, subOrigins)
+#endif
+
+/* CRITICAL: Conditions that are threatening to the integrity/stability of the
+ system as a whole. */
+#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_CRITICAL_DISABLE)
+void CsrLogTextCritical(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferCritical(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+#define CSR_LOG_TEXT_CRITICAL(taskId_subOrigin_formatString_varargs) CsrLogTextCritical taskId_subOrigin_formatString_varargs
+#define CSR_LOG_TEXT_CONDITIONAL_CRITICAL(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_CRITICAL(logtextargs);}}
+#define CSR_LOG_TEXT_BUFFER_CRITICAL(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferCritical taskId_subOrigin_length_buffer_formatString_varargs
+#define CSR_LOG_TEXT_BUFFER_CONDITIONAL_CRITICAL(condition, logtextbufferargs) {if (condition) {CSR_LOG_TEXT_BUFFER_CRITICAL(logtextbufferargs);}}
+#else
+#define CSR_LOG_TEXT_CRITICAL(taskId_subOrigin_formatString_varargs)
+#define CSR_LOG_TEXT_CONDITIONAL_CRITICAL(condition, logtextargs)
+#define CSR_LOG_TEXT_BUFFER_CRITICAL(taskId_subOrigin_length_buffer_formatString_varargs)
+#define CSR_LOG_TEXT_BUFFER_CONDITIONAL_CRITICAL(condition, logtextbufferargs)
+#endif
+
+/* ERROR: Malfunction of a component rendering it unable to operate correctly,
+ causing lack of functionality but not loss of system integrity/stability. */
+#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_ERROR_DISABLE)
+void CsrLogTextError(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferError(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+#define CSR_LOG_TEXT_ERROR(taskId_subOrigin_formatString_varargs) CsrLogTextError taskId_subOrigin_formatString_varargs
+#define CSR_LOG_TEXT_CONDITIONAL_ERROR(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_ERROR(logtextargs);}}
+#define CSR_LOG_TEXT_BUFFER_ERROR(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferError taskId_subOrigin_length_buffer_formatString_varargs
+#define CSR_LOG_TEXT_BUFFER_CONDITIONAL_ERROR(condition, logtextbufferargs) {if (condition) {CSR_LOG_TEXT_BUFFER_ERROR(logtextbufferargs);}}
+#else
+#define CSR_LOG_TEXT_ERROR(taskId_subOrigin_formatString_varargs)
+#define CSR_LOG_TEXT_CONDITIONAL_ERROR(condition, logtextargs)
+#define CSR_LOG_TEXT_BUFFER_ERROR(taskId_subOrigin_length_buffer_formatString_varargs)
+#define CSR_LOG_TEXT_BUFFER_CONDITIONAL_ERROR(condition, logtextbufferargs)
+#endif
+
+/* WARNING: Conditions that are unexpected and indicative of possible problems
+ or violations of specifications, where the result of such deviations does not
+ lead to malfunction of the component. */
+#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_WARNING_DISABLE)
+void CsrLogTextWarning(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferWarning(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+#define CSR_LOG_TEXT_WARNING(taskId_subOrigin_formatString_varargs) CsrLogTextWarning taskId_subOrigin_formatString_varargs
+#define CSR_LOG_TEXT_CONDITIONAL_WARNING(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_WARNING(logtextargs);}}
+#define CSR_LOG_TEXT_BUFFER_WARNING(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferWarning taskId_subOrigin_length_buffer_formatString_varargs
+#define CSR_LOG_TEXT_BUFFER_CONDITIONAL_WARNING(condition, logtextbufferargs) {if (condition) {CSR_LOG_TEXT_BUFFER_WARNING(logtextbufferargs);}}
+#else
+#define CSR_LOG_TEXT_WARNING(taskId_subOrigin_formatString_varargs)
+#define CSR_LOG_TEXT_CONDITIONAL_WARNING(condition, logtextargs)
+#define CSR_LOG_TEXT_BUFFER_WARNING(taskId_subOrigin_length_buffer_formatString_varargs)
+#define CSR_LOG_TEXT_BUFFER_CONDITIONAL_WARNING(condition, logtextbufferargs)
+#endif
+
+/* INFO: Important events that may aid in determining the conditions under which
+ the more severe conditions are encountered. */
+#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_INFO_DISABLE)
+void CsrLogTextInfo(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferInfo(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+#define CSR_LOG_TEXT_INFO(taskId_subOrigin_formatString_varargs) CsrLogTextInfo taskId_subOrigin_formatString_varargs
+#define CSR_LOG_TEXT_CONDITIONAL_INFO(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_INFO(logtextargs);}}
+#define CSR_LOG_TEXT_BUFFER_INFO(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferInfo taskId_subOrigin_length_buffer_formatString_varargs
+#define CSR_LOG_TEXT_BUFFER_CONDITIONAL_INFO(condition, logtextbufferargs) {if (condition) {CSR_LOG_TEXT_BUFFER_INFO(logtextbufferargs);}}
+#else
+#define CSR_LOG_TEXT_INFO(taskId_subOrigin_formatString_varargs)
+#define CSR_LOG_TEXT_CONDITIONAL_INFO(condition, logtextargs)
+#define CSR_LOG_TEXT_BUFFER_INFO(taskId_subOrigin_length_buffer_formatString_varargs)
+#define CSR_LOG_TEXT_BUFFER_CONDITIONAL_INFO(condition, logtextbufferargs)
+#endif
+
+/* DEBUG: Similar to INFO, but dedicated to events that occur more frequently. */
+#if defined(CSR_LOG_ENABLE) && !defined(CSR_LOG_LEVEL_TEXT_DEBUG_DISABLE)
+void CsrLogTextDebug(CsrLogTextTaskId taskId, CsrUint16 subOrigin, const CsrCharString *formatString, ...);
+void CsrLogTextBufferDebug(CsrLogTextTaskId taskId, CsrUint16 subOrigin, CsrSize bufferLength, const void *buffer, const CsrCharString *formatString, ...);
+#define CSR_LOG_TEXT_DEBUG(taskId_subOrigin_formatString_varargs) CsrLogTextDebug taskId_subOrigin_formatString_varargs
+#define CSR_LOG_TEXT_CONDITIONAL_DEBUG(condition, logtextargs) {if (condition) {CSR_LOG_TEXT_DEBUG(logtextargs);}}
+#define CSR_LOG_TEXT_BUFFER_DEBUG(taskId_subOrigin_length_buffer_formatString_varargs) CsrLogTextBufferDebug taskId_subOrigin_length_buffer_formatString_varargs
+#define CSR_LOG_TEXT_BUFFER_CONDITIONAL_DEBUG(condition, logtextbufferargs) {if (condition) {CSR_LOG_TEXT_BUFFER_DEBUG(logtextbufferargs);}}
+#else
+#define CSR_LOG_TEXT_DEBUG(taskId_subOrigin_formatString_varargs)
+#define CSR_LOG_TEXT_CONDITIONAL_DEBUG(condition, logtextargs)
+#define CSR_LOG_TEXT_BUFFER_DEBUG(taskId_subOrigin_length_buffer_formatString_varargs)
+#define CSR_LOG_TEXT_BUFFER_CONDITIONAL_DEBUG(condition, logtextbufferargs)
+#endif
+
+/* CSR_LOG_TEXT_ASSERT (CRITICAL) */
+#ifdef CSR_LOG_ENABLE
+#define CSR_LOG_TEXT_ASSERT(origin, suborigin, condition) \
+ {if (!(condition)) {CSR_LOG_TEXT_CRITICAL((origin, suborigin, "Assertion \"%s\" failed at %s:%u", #condition, __FILE__, __LINE__));}}
+#else
+#define CSR_LOG_TEXT_ASSERT(origin, suborigin, condition)
+#endif
+
+/* CSR_LOG_TEXT_UNHANDLED_PRIM (CRITICAL) */
+#ifdef CSR_LOG_ENABLE
+#define CSR_LOG_TEXT_UNHANDLED_PRIMITIVE(origin, suborigin, primClass, primType) \
+ CSR_LOG_TEXT_CRITICAL((origin, suborigin, "Unhandled primitive 0x%04X:0x%04X at %s:%u", primClass, primType, __FILE__, __LINE__))
+#else
+#define CSR_LOG_TEXT_UNHANDLED_PRIMITIVE(origin, suborigin, primClass, primType)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_MACRO_H__
+#define CSR_MACRO_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*------------------------------------------------------------------*/
+/* Bits - intended to operate on CsrUint32 values */
+/*------------------------------------------------------------------*/
+#define CSR_MASK_IS_SET(val, mask) (((val) & (mask)) == (mask))
+#define CSR_MASK_IS_UNSET(val, mask) ((((val) & (mask)) ^ mask) == (mask))
+#define CSR_MASK_SET(val, mask) ((val) |= (mask))
+#define CSR_MASK_UNSET(val, mask) ((val) = ((val) ^ (mask)) & (val)) /* Unsets the bits in val that are set in mask */
+#define CSR_BIT_IS_SET(val, bit) ((CsrBool) ((((val) & (1UL << (bit))) != 0)))
+#define CSR_BIT_SET(val, bit) ((val) |= (1UL << (bit)))
+#define CSR_BIT_UNSET(val, bit) ((val) &= ~(1UL << (bit)))
+#define CSR_BIT_TOGGLE(val, bit) ((val) ^= (1UL << (bit)))
+
+/*------------------------------------------------------------------*/
+/* Endian conversion */
+/*------------------------------------------------------------------*/
+#define CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr) (((CsrUint16) ((CsrUint8 *) (ptr))[0]) | ((CsrUint16) ((CsrUint8 *) (ptr))[1]) << 8)
+#define CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr) (((CsrUint32) ((CsrUint8 *) (ptr))[0]) | ((CsrUint32) ((CsrUint8 *) (ptr))[1]) << 8 | \
+ ((CsrUint32) ((CsrUint8 *) (ptr))[2]) << 16 | ((CsrUint32) ((CsrUint8 *) (ptr))[3]) << 24)
+#define CSR_COPY_UINT16_TO_LITTLE_ENDIAN(uint, ptr) ((CsrUint8 *) (ptr))[0] = ((CsrUint8) ((uint) & 0x00FF)); \
+ ((CsrUint8 *) (ptr))[1] = ((CsrUint8) ((uint) >> 8))
+#define CSR_COPY_UINT32_TO_LITTLE_ENDIAN(uint, ptr) ((CsrUint8 *) (ptr))[0] = ((CsrUint8) ((uint) & 0x000000FF)); \
+ ((CsrUint8 *) (ptr))[1] = ((CsrUint8) (((uint) >> 8) & 0x000000FF)); \
+ ((CsrUint8 *) (ptr))[2] = ((CsrUint8) (((uint) >> 16) & 0x000000FF)); \
+ ((CsrUint8 *) (ptr))[3] = ((CsrUint8) (((uint) >> 24) & 0x000000FF))
+#define CSR_GET_UINT16_FROM_BIG_ENDIAN(ptr) (((CsrUint16) ((CsrUint8 *) (ptr))[1]) | ((CsrUint16) ((CsrUint8 *) (ptr))[0]) << 8)
+#define CSR_GET_UINT24_FROM_BIG_ENDIAN(ptr) (((CsrUint24) ((CsrUint8 *) (ptr))[2]) | \
+ ((CsrUint24) ((CsrUint8 *) (ptr))[1]) << 8 | ((CsrUint24) ((CsrUint8 *) (ptr))[0]) << 16)
+#define CSR_GET_UINT32_FROM_BIG_ENDIAN(ptr) (((CsrUint32) ((CsrUint8 *) (ptr))[3]) | ((CsrUint32) ((CsrUint8 *) (ptr))[2]) << 8 | \
+ ((CsrUint32) ((CsrUint8 *) (ptr))[1]) << 16 | ((CsrUint32) ((CsrUint8 *) (ptr))[0]) << 24)
+#define CSR_COPY_UINT16_TO_BIG_ENDIAN(uint, ptr) ((CsrUint8 *) (ptr))[1] = ((CsrUint8) ((uint) & 0x00FF)); \
+ ((CsrUint8 *) (ptr))[0] = ((CsrUint8) ((uint) >> 8))
+#define CSR_COPY_UINT24_TO_BIG_ENDIAN(uint, ptr) ((CsrUint8 *) (ptr))[2] = ((CsrUint8) ((uint) & 0x000000FF)); \
+ ((CsrUint8 *) (ptr))[1] = ((CsrUint8) (((uint) >> 8) & 0x000000FF)); \
+ ((CsrUint8 *) (ptr))[0] = ((CsrUint8) (((uint) >> 16) & 0x000000FF))
+#define CSR_COPY_UINT32_TO_BIG_ENDIAN(uint, ptr) ((CsrUint8 *) (ptr))[3] = ((CsrUint8) ((uint) & 0x000000FF)); \
+ ((CsrUint8 *) (ptr))[2] = ((CsrUint8) (((uint) >> 8) & 0x000000FF)); \
+ ((CsrUint8 *) (ptr))[1] = ((CsrUint8) (((uint) >> 16) & 0x000000FF)); \
+ ((CsrUint8 *) (ptr))[0] = ((CsrUint8) (((uint) >> 24) & 0x000000FF))
+
+/*------------------------------------------------------------------*/
+/* XAP conversion macros */
+/*------------------------------------------------------------------*/
+
+#define CSR_LSB16(a) ((CsrUint8) ((a) & 0x00ff))
+#define CSR_MSB16(b) ((CsrUint8) ((b) >> 8))
+
+#define CSR_CONVERT_8_FROM_XAP(output, input) \
+ (output) = ((CsrUint8) (input));(input) += 2
+
+#define CSR_CONVERT_16_FROM_XAP(output, input) \
+ (output) = (CsrUint16) ((((CsrUint16) (input)[1]) << 8) | \
+ ((CsrUint16) (input)[0]));(input) += 2
+
+#define CSR_CONVERT_32_FROM_XAP(output, input) \
+ (output) = (((CsrUint32) (input)[1]) << 24) | \
+ (((CsrUint32) (input)[0]) << 16) | \
+ (((CsrUint32) (input)[3]) << 8) | \
+ ((CsrUint32) (input)[2]);input += 4
+
+#define CSR_ADD_UINT8_TO_XAP(output, input) \
+ (output)[0] = (input); \
+ (output)[1] = 0;(output) += 2
+
+#define CSR_ADD_UINT16_TO_XAP(output, input) \
+ (output)[0] = ((CsrUint8) ((input) & 0x00FF)); \
+ (output)[1] = ((CsrUint8) ((input) >> 8));(output) += 2
+
+#define CSR_ADD_UINT32_TO_XAP(output, input) \
+ (output)[0] = ((CsrUint8) (((input) >> 16) & 0x00FF)); \
+ (output)[1] = ((CsrUint8) ((input) >> 24)); \
+ (output)[2] = ((CsrUint8) ((input) & 0x00FF)); \
+ (output)[3] = ((CsrUint8) (((input) >> 8) & 0x00FF));(output) += 4
+
+/*------------------------------------------------------------------*/
+/* Misc */
+/*------------------------------------------------------------------*/
+#define CSRMAX(a, b) (((a) > (b)) ? (a) : (b))
+#define CSRMIN(a, b) (((a) < (b)) ? (a) : (b))
+
+/* Use this macro on unused local variables that cannot be removed (such as
+ unused function parameters). This will quell warnings from certain compilers
+ and static code analysis tools like Lint and Valgrind. */
+#define CSR_UNUSED(x) ((void) (x))
+
+#define CSR_TOUPPER(character) (((character) >= 'a') && ((character) <= 'z') ? ((character) - 0x20) : (character))
+#define CSR_TOLOWER(character) (((character) >= 'A') && ((character) <= 'Z') ? ((character) + 0x20) : (character))
+#define CSR_ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_MSG_TRANSPORT_H__
+#define CSR_MSG_TRANSPORT_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CsrMsgTransport
+#define CsrMsgTransport CsrSchedMessagePut
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_MSG_TRANSPORT */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include <linux/module.h>
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_panic.h"
+#include "csr_sched.h"
+#include "csr_msgconv.h"
+#include "csr_util.h"
+
+static CsrMsgConvEntry *converter;
+
+CsrMsgConvPrimEntry *CsrMsgConvFind(CsrUint16 primType)
+{
+ CsrMsgConvPrimEntry *ptr = NULL;
+
+ if (converter)
+ {
+ ptr = converter->profile_converters;
+ while (ptr)
+ {
+ if (ptr->primType == primType)
+ {
+ break;
+ }
+ else
+ {
+ ptr = ptr->next;
+ }
+ }
+ }
+
+ return ptr;
+}
+
+static const CsrMsgConvMsgEntry *find_msg_converter(CsrMsgConvPrimEntry *ptr, CsrUint16 msgType)
+{
+ const CsrMsgConvMsgEntry *cv = ptr->conv;
+ if (ptr->lookupFunc)
+ {
+ return (const CsrMsgConvMsgEntry *) ptr->lookupFunc((CsrMsgConvMsgEntry *) cv, msgType);
+ }
+
+ while (cv)
+ {
+ if (cv->serFunc == NULL)
+ {
+ /* We've reached the end of the chain */
+ cv = NULL;
+ break;
+ }
+
+ if (cv->msgType == msgType)
+ {
+ break;
+ }
+ else
+ {
+ cv++;
+ }
+ }
+
+ return cv;
+}
+
+static void *deserialize_data(CsrUint16 primType,
+ CsrSize length,
+ CsrUint8 *data)
+{
+ CsrMsgConvPrimEntry *ptr;
+ CsrUint8 *ret;
+
+ ptr = CsrMsgConvFind(primType);
+
+ if (ptr)
+ {
+ const CsrMsgConvMsgEntry *cv;
+ CsrUint16 msgId = 0;
+ CsrSize offset = 0;
+ CsrUint16Des(&msgId, data, &offset);
+
+ cv = find_msg_converter(ptr, msgId);
+ if (cv)
+ {
+ ret = cv->deserFunc(data, length);
+ }
+ else
+ {
+ ret = NULL;
+ }
+ }
+ else
+ {
+ ret = NULL;
+ }
+
+ return ret;
+}
+
+static CsrSize sizeof_message(CsrUint16 primType, void *msg)
+{
+ CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
+ CsrSize ret;
+
+ if (ptr)
+ {
+ const CsrMsgConvMsgEntry *cv;
+ CsrUint16 msgId = *(CsrUint16 *) msg;
+
+ cv = find_msg_converter(ptr, msgId);
+ if (cv)
+ {
+ ret = cv->sizeofFunc(msg);
+ }
+ else
+ {
+ ret = 0;
+ }
+ }
+ else
+ {
+ ret = 0;
+ }
+
+ return ret;
+}
+
+static CsrBool free_message(CsrUint16 primType, CsrUint8 *data)
+{
+ CsrMsgConvPrimEntry *ptr;
+ CsrBool ret;
+
+ ptr = CsrMsgConvFind(primType);
+
+ if (ptr)
+ {
+ const CsrMsgConvMsgEntry *cv;
+ CsrUint16 msgId = *(CsrUint16 *) data;
+
+ cv = find_msg_converter(ptr, msgId);
+ if (cv)
+ {
+ cv->freeFunc(data);
+ ret = TRUE;
+ }
+ else
+ {
+ ret = FALSE;
+ }
+ }
+ else
+ {
+ ret = FALSE;
+ }
+
+ return ret;
+}
+
+static CsrUint8 *serialize_message(CsrUint16 primType,
+ void *msg,
+ CsrSize *length,
+ CsrUint8 *buffer)
+{
+ CsrMsgConvPrimEntry *ptr;
+ CsrUint8 *ret;
+
+ ptr = CsrMsgConvFind(primType);
+
+ *length = 0;
+
+ if (ptr)
+ {
+ const CsrMsgConvMsgEntry *cv;
+
+ cv = find_msg_converter(ptr, *(CsrUint16 *) msg);
+ if (cv)
+ {
+ ret = cv->serFunc(buffer, length, msg);
+ }
+ else
+ {
+ ret = NULL;
+ }
+ }
+ else
+ {
+ ret = NULL;
+ }
+
+ return ret;
+}
+
+CsrSize CsrMsgConvSizeof(CsrUint16 primType, void *msg)
+{
+ return sizeof_message(primType, msg);
+}
+
+CsrUint8 *CsrMsgConvSerialize(CsrUint8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg)
+{
+ if (converter)
+ {
+ CsrSize serializedLength;
+ CsrUint8 *bufSerialized;
+ CsrUint8 *bufOffset = &buffer[*offset];
+ bufSerialized = converter->serialize_message(primType, msg, &serializedLength, bufOffset);
+ *offset += serializedLength;
+ return bufSerialized;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+/* Insert profile converter at head of converter list. */
+void CsrMsgConvInsert(CsrUint16 primType, const CsrMsgConvMsgEntry *ce)
+{
+ CsrMsgConvPrimEntry *pc;
+ pc = CsrMsgConvFind(primType);
+
+ if (pc)
+ {
+ /* Already registered. Do nothing */
+ }
+ else
+ {
+ pc = CsrPmemAlloc(sizeof(*pc));
+ pc->primType = primType;
+ pc->conv = ce;
+ pc->lookupFunc = NULL;
+ pc->next = converter->profile_converters;
+ converter->profile_converters = pc;
+ }
+}
+EXPORT_SYMBOL_GPL(CsrMsgConvInsert);
+
+CsrMsgConvMsgEntry *CsrMsgConvFindEntry(CsrUint16 primType, CsrUint16 msgType)
+{
+ CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
+ if (ptr)
+ {
+ return (CsrMsgConvMsgEntry *) find_msg_converter(ptr, msgType);
+ }
+ return NULL;
+}
+EXPORT_SYMBOL_GPL(CsrMsgConvFindEntry);
+
+CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(CsrUint16 primType, const void *msg)
+{
+ CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
+ if (ptr && msg)
+ {
+ CsrUint16 msgType = *((CsrUint16 *) msg);
+ return (CsrMsgConvMsgEntry *) find_msg_converter(ptr, msgType);
+ }
+ return NULL;
+}
+
+void CsrMsgConvCustomLookupRegister(CsrUint16 primType, CsrMsgCustomLookupFunc *lookupFunc)
+{
+ CsrMsgConvPrimEntry *ptr = CsrMsgConvFind(primType);
+ if (ptr)
+ {
+ ptr->lookupFunc = lookupFunc;
+ }
+}
+EXPORT_SYMBOL_GPL(CsrMsgConvCustomLookupRegister);
+
+CsrMsgConvEntry *CsrMsgConvInit(void)
+{
+ if (!converter)
+ {
+ converter = (CsrMsgConvEntry *) CsrPmemAlloc(sizeof(CsrMsgConvEntry));
+
+ converter->profile_converters = NULL;
+ converter->free_message = free_message;
+ converter->sizeof_message = sizeof_message;
+ converter->serialize_message = serialize_message;
+ converter->deserialize_data = deserialize_data;
+ }
+
+ return converter;
+}
+EXPORT_SYMBOL_GPL(CsrMsgConvInit);
+
+CsrMsgConvEntry *CsrMsgConvGet(void)
+{
+ return converter;
+}
+
+#ifdef ENABLE_SHUTDOWN
+void CsrMsgConvDeinit(void)
+{
+ CsrMsgConvPrimEntry *s;
+
+ if (converter == NULL)
+ {
+ return;
+ }
+
+ /* Walk converter list and free elements. */
+ s = converter->profile_converters;
+ while (s)
+ {
+ CsrMsgConvPrimEntry *s_next;
+ s_next = s->next;
+ CsrPmemFree(s);
+ s = s_next;
+ }
+
+ CsrPmemFree(converter);
+ converter = NULL;
+}
+EXPORT_SYMBOL_GPL(CsrMsgConvDeinit);
+
+#endif /* ENABLE_SHUTDOWN */
--- /dev/null
+#ifndef CSR_MSGCONV_H__
+#define CSR_MSGCONV_H__
+
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+#include "csr_sched.h"
+#include "csr_unicode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef CsrSize (CsrMsgSizeofFunc)(void *msg);
+typedef CsrUint8 *(CsrMsgSerializeFunc)(CsrUint8 *buffer, CsrSize *length, void *msg);
+typedef void (CsrMsgFreeFunc)(void *msg);
+typedef void *(CsrMsgDeserializeFunc)(CsrUint8 *buffer, CsrSize length);
+
+/* Converter entry for one message type */
+typedef struct CsrMsgConvMsgEntry
+{
+ CsrUint16 msgType;
+ CsrMsgSizeofFunc *sizeofFunc;
+ CsrMsgSerializeFunc *serFunc;
+ CsrMsgDeserializeFunc *deserFunc;
+ CsrMsgFreeFunc *freeFunc;
+} CsrMsgConvMsgEntry;
+
+/* Optional lookup function */
+typedef CsrMsgConvMsgEntry *(CsrMsgCustomLookupFunc)(CsrMsgConvMsgEntry *ce, CsrUint16 msgType);
+
+/* All converter entries for one specific primitive */
+typedef struct CsrMsgConvPrimEntry
+{
+ CsrUint16 primType;
+ const CsrMsgConvMsgEntry *conv;
+ CsrMsgCustomLookupFunc *lookupFunc;
+ struct CsrMsgConvPrimEntry *next;
+} CsrMsgConvPrimEntry;
+
+typedef struct
+{
+ CsrMsgConvPrimEntry *profile_converters;
+ void *(*deserialize_data)(CsrUint16 primType, CsrSize length, CsrUint8 * data);
+ CsrBool (*free_message)(CsrUint16 primType, CsrUint8 *data);
+ CsrSize (*sizeof_message)(CsrUint16 primType, void *msg);
+ CsrUint8 *(*serialize_message)(CsrUint16 primType, void *msg,
+ CsrSize * length,
+ CsrUint8 * buffer);
+} CsrMsgConvEntry;
+
+CsrSize CsrMsgConvSizeof(CsrUint16 primType, void *msg);
+CsrUint8 *CsrMsgConvSerialize(CsrUint8 *buffer, CsrSize maxBufferOffset, CsrSize *offset, CsrUint16 primType, void *msg);
+void CsrMsgConvCustomLookupRegister(CsrUint16 primType, CsrMsgCustomLookupFunc *lookupFunc);
+void CsrMsgConvInsert(CsrUint16 primType, const CsrMsgConvMsgEntry *ce);
+CsrMsgConvPrimEntry *CsrMsgConvFind(CsrUint16 primType);
+CsrMsgConvMsgEntry *CsrMsgConvFindEntry(CsrUint16 primType, CsrUint16 msgType);
+CsrMsgConvMsgEntry *CsrMsgConvFindEntryByMsg(CsrUint16 primType, const void *msg);
+CsrMsgConvEntry *CsrMsgConvGet(void);
+CsrMsgConvEntry *CsrMsgConvInit(void);
+#ifdef ENABLE_SHUTDOWN
+void CsrMsgConvDeinit(void);
+#endif /* ENABLE_SHUTDOWN */
+
+/* SHOULD BE INTERNAL TO FRAMEWORK AKA DEPRECATED */
+
+CsrUint32 CsrCharStringSerLen(const CsrCharString *str);
+CsrUint32 CsrUtf8StringSerLen(const CsrUtf8String *str);
+CsrUint32 CsrUtf16StringSerLen(const CsrUtf16String *str);
+
+/* Prototypes for primitive type serializers */
+void CsrUint8Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint8 value);
+void CsrUint16Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint16 value);
+void CsrUint32Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint32 value);
+void CsrMemCpySer(CsrUint8 *buffer, CsrSize *offset, const void *value, CsrSize length);
+void CsrCharStringSer(CsrUint8 *buffer, CsrSize *offset, const CsrCharString *value);
+void CsrUtf8StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf8String *value);
+void CsrUtf16StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf16String *value);
+void CsrVoidPtrSer(CsrUint8 *buffer, CsrSize *offset, void *ptr);
+void CsrSizeSer(CsrUint8 *buffer, CsrSize *offset, CsrSize value);
+
+void CsrUint8Des(CsrUint8 *value, CsrUint8 *buffer, CsrSize *offset);
+void CsrUint16Des(CsrUint16 *value, CsrUint8 *buffer, CsrSize *offset);
+void CsrUint32Des(CsrUint32 *value, CsrUint8 *buffer, CsrSize *offset);
+void CsrMemCpyDes(void *value, CsrUint8 *buffer, CsrSize *offset, CsrSize length);
+void CsrCharStringDes(CsrCharString **value, CsrUint8 *buffer, CsrSize *offset);
+void CsrUtf8StringDes(CsrUtf8String **value, CsrUint8 *buffer, CsrSize *offset);
+void CsrUtf16StringDes(CsrUtf16String **value, CsrUint8 *buffer, CsrSize *offset);
+void CsrVoidPtrDes(void **value, CsrUint8 *buffer, CsrSize *offset);
+void CsrSizeDes(CsrSize *value, CsrUint8 *buffer, CsrSize *offset);
+
+CsrSize CsrEventSizeof(void *msg);
+CsrUint8 *CsrEventSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+void *CsrEventDes(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrEventCsrUint8Sizeof(void *msg);
+CsrUint8 *CsrEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint8Des(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrEventCsrUint16Sizeof(void *msg);
+CsrUint8 *CsrEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16Des(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrEventCsrUint32Sizeof(void *msg);
+CsrUint8 *CsrEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint32Des(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrEventCsrUint16CsrUint8Sizeof(void *msg);
+CsrUint8 *CsrEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrEventCsrUint16CsrUint16Sizeof(void *msg);
+CsrUint8 *CsrEventCsrUint16CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrUint16Des(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrEventCsrUint16CsrUint32Sizeof(void *msg);
+CsrUint8 *CsrEventCsrUint16CsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrUint32Des(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrEventCsrUint16CsrCharStringSizeof(void *msg);
+CsrUint8 *CsrEventCsrUint16CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint16CsrCharStringDes(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrEventCsrUint32CsrUint16Sizeof(void *msg);
+CsrUint8 *CsrEventCsrUint32CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint32CsrUint16Des(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrEventCsrUint32CsrCharStringSizeof(void *msg);
+CsrUint8 *CsrEventCsrUint32CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+void *CsrEventCsrUint32CsrCharStringDes(CsrUint8 *buffer, CsrSize length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/module.h>
+
+#include "csr_types.h"
+#include "csr_panic.h"
+
+void CsrPanic(CsrUint8 tech, CsrUint16 reason, const char *p)
+{
+ BUG_ON(1);
+}
+EXPORT_SYMBOL_GPL(CsrPanic);
--- /dev/null
+#ifndef CSR_PANIC_H__
+#define CSR_PANIC_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+#include "csr_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Synergy techonology ID definitions */
+#define CSR_TECH_FW 0
+#define CSR_TECH_BT 1
+#define CSR_TECH_WIFI 2
+#define CSR_TECH_GPS 3
+#define CSR_TECH_NFC 4
+
+/* Panic type ID definitions for technology type CSR_TECH_FW */
+#define CSR_PANIC_FW_UNEXPECTED_VALUE 0
+#define CSR_PANIC_FW_HEAP_EXHAUSTION 1
+#define CSR_PANIC_FW_INVALID_PFREE_POINTER 2
+#define CSR_PANIC_FW_EXCEPTION 3
+#define CSR_PANIC_FW_ASSERTION_FAIL 4
+#define CSR_PANIC_FW_NULL_TASK_HANDLER 5
+#define CSR_PANIC_FW_UNKNOWN_TASK 6
+#define CSR_PANIC_FW_QUEUE_ACCESS_VIOLATION 7
+#define CSR_PANIC_FW_TOO_MANY_MESSAGES 8
+#define CSR_PANIC_FW_TOO_MANY_TIMED_EVENTS 9
+#define CSR_PANIC_FW_ABCSP_SYNC_LOST 10
+#define CSR_PANIC_FW_OVERSIZE_ABCSP_PRIM 11
+#define CSR_PANIC_FW_H4_CORRUPTION 12
+#define CSR_PANIC_FW_H4_SYNC_LOST 13
+#define CSR_PANIC_FW_H4_RX_OVERRUN 14
+#define CSR_PANIC_FW_H4_TX_OVERRUN 15
+#define CSR_PANIC_FW_TM_BC_RESTART_FAIL 16
+#define CSR_PANIC_FW_TM_BC_START_FAIL 17
+#define CSR_PANIC_FW_TM_BC_BAD_STATE 18
+#define CSR_PANIC_FW_TM_BC_TRANSPORT_LOST 19
+
+/* Panic interface used by technologies */
+/* DEPRECATED - replaced by csr_log_text.h */
+void CsrPanic(CsrUint8 tech, CsrUint16 reason, const char *p);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_PANIC_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/module.h>
+
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
+#include <linux/autoconf.h>
+#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
+#include <linux/config.h>
+#endif
+
+#include <linux/slab.h>
+
+#include "csr_panic.h"
+#include "csr_pmem.h"
+
+void *CsrPmemAlloc(CsrSize size)
+{
+ void *ret;
+
+ ret = kmalloc(size, GFP_KERNEL);
+ if (!ret)
+ {
+ CsrPanic(CSR_TECH_FW, CSR_PANIC_FW_HEAP_EXHAUSTION,
+ "out of memory");
+ }
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(CsrPmemAlloc);
+
+void CsrPmemFree(void *ptr)
+{
+ if (ptr == NULL)
+ {
+ return;
+ }
+
+ kfree(ptr);
+}
+EXPORT_SYMBOL_GPL(CsrPmemFree);
--- /dev/null
+#ifndef CSR_PMEM_H__
+#define CSR_PMEM_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+#include "csr_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_PMEM_DEBUG_ENABLE
+/*****************************************************************************
+
+ NAME
+ CsrPmemAlloc
+
+ DESCRIPTION
+ This function will allocate a contiguous block of memory of at least
+ the specified size in bytes and return a pointer to the allocated
+ memory. This function is not allowed to return NULL. A size of 0 is a
+ valid request, and a unique and valid (not NULL) pointer must be
+ returned in this case.
+
+ PARAMETERS
+ size - Size of memory requested. Note that a size of 0 is valid.
+
+ RETURNS
+ Pointer to allocated memory.
+
+*****************************************************************************/
+#ifdef CSR_PMEM_DEBUG
+void *CsrPmemAllocDebug(CsrSize size,
+ const CsrCharString *file, CsrUint32 line);
+#define CsrPmemAlloc(sz) CsrPmemAllocDebug((sz), __FILE__, __LINE__)
+#else
+void *CsrPmemAlloc(CsrSize size);
+#endif
+
+
+/*****************************************************************************
+
+ NAME
+ CsrPmemFree
+
+ DESCRIPTION
+ This function will deallocate a previously allocated block of memory.
+
+ PARAMETERS
+ ptr - Pointer to allocated memory.
+
+*****************************************************************************/
+void CsrPmemFree(void *ptr);
+#endif
+
+/*****************************************************************************
+
+ NAME
+ CsrPmemZalloc
+
+ DESCRIPTION
+ This function is equivalent to CsrPmemAlloc, but the allocated memory
+ is initialised to zero.
+
+ PARAMETERS
+ size - Size of memory requested. Note that a size of 0 is valid.
+
+ RETURNS
+ Pointer to allocated memory.
+
+*****************************************************************************/
+#define CsrPmemZalloc(s) (CsrMemSet(CsrPmemAlloc(s), 0x00, (s)))
+
+
+/*****************************************************************************
+
+ NAME
+ pnew and zpnew
+
+ DESCRIPTIOM
+ Type-safe wrappers for CsrPmemAlloc and CsrPmemZalloc, for allocating
+ single instances of a specified and named type.
+
+ PARAMETERS
+ t - type to allocate.
+
+*****************************************************************************/
+#define pnew(t) ((t *) (CsrPmemAlloc(sizeof(t))))
+#define zpnew(t) ((t *) (CsrPmemZalloc(sizeof(t))))
+
+
+/*----------------------------------------------------------------------------*
+ * Csr Pmem Debug code. Allows custom callbacks on CsrPmemAlloc and CsrPmemFree
+ *----------------------------------------------------------------------------*/
+#ifdef CSR_PMEM_DEBUG_ENABLE
+
+typedef CsrUint8 CsrPmemDebugAllocType;
+#define CSR_PMEM_DEBUG_TYPE_PMEM_ALLOC 1
+#define CSR_PMEM_DEBUG_TYPE_MEM_ALLOC 2
+#define CSR_PMEM_DEBUG_TYPE_MEM_CALLOC 3
+#define CSR_PMEM_DEBUG_TYPE_MEM_ALLOC_DMA 4
+
+typedef void (CsrPmemDebugOnAlloc)(void *ptr, void *userptr, CsrSize size, CsrPmemDebugAllocType type, const CsrCharString* file, CsrUint32 line);
+typedef void (CsrPmemDebugOnFree)(void *ptr, void *userptr, CsrPmemDebugAllocType type, const CsrCharString* file, CsrUint32 line);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrPmemInstallHooks
+ *
+ * DESCRIPTION
+ * Install debug hooks for memory allocation
+ * Use NULL values to uninstall the hooks
+ * headSize = The number of extra bytes to allocate in the head of the Allocated buffer
+ * footSize = The number of extra bytes to allocate in the end of the Allocated buffer
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+void CsrPmemDebugInstallHooks(CsrUint8 headSize, CsrUint8 endSize, CsrPmemDebugOnAlloc *onAllocCallback, CsrPmemDebugOnFree *onFreeCallback);
+
+void *CsrPmemDebugAlloc(CsrSize size, CsrPmemDebugAllocType type, const CsrCharString* file, CsrUint32 line);
+#define CsrPmemAlloc(size) CsrPmemDebugAlloc(size, CSR_PMEM_DEBUG_TYPE_PMEM_ALLOC, __FILE__, __LINE__)
+
+void CsrPmemDebugFree(void *ptr, CsrPmemDebugAllocType type, const CsrCharString* file, CsrUint32 line);
+#define CsrPmemFree(ptr) CsrPmemDebugFree(ptr, CSR_PMEM_DEBUG_TYPE_PMEM_ALLOC, __FILE__, __LINE__)
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_PRIM_DEFS_H__
+#define CSR_PRIM_DEFS_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+#include "csr_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/************************************************************************************
+ * Segmentation of primitives in upstream and downstream segment
+ ************************************************************************************/
+typedef CsrUint16 CsrPrim;
+#define CSR_PRIM_UPSTREAM ((CsrPrim) (0x8000))
+
+/************************************************************************************
+ * Primitive definitions for Synergy framework
+ ************************************************************************************/
+#define CSR_SYNERGY_EVENT_CLASS_BASE ((CsrUint16) (0x0600))
+
+#define CSR_HCI_PRIM ((CsrUint16) (0x0000 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_BCCMD_PRIM ((CsrUint16) (0x0001 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_HQ_PRIM ((CsrUint16) (0x0002 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_VM_PRIM ((CsrUint16) (0x0003 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TM_BLUECORE_PRIM ((CsrUint16) (0x0004 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_FP_PRIM ((CsrUint16) (0x0005 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_SOCKET_PRIM ((CsrUint16) (0x0006 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_ETHER_PRIM ((CsrUint16) (0x0007 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_IFCONFIG_PRIM ((CsrUint16) (0x0008 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_IP_INTERNAL_PRIM ((CsrUint16) (0x0009 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_FSAL_PRIM ((CsrUint16) (0x000A | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_DATA_STORE_PRIM ((CsrUint16) (0x000B | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_AM_PRIM ((CsrUint16) (0x000C | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TLS_PRIM ((CsrUint16) (0x000D | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_DHCP_SERVER_PRIM ((CsrUint16) (0x000E | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TFTP_PRIM ((CsrUint16) (0x000F | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_DSPM_PRIM ((CsrUint16) (0x0010 | CSR_SYNERGY_EVENT_CLASS_BASE))
+#define CSR_TLS_INTERNAL_PRIM ((CsrUint16) (0x0011 | CSR_SYNERGY_EVENT_CLASS_BASE))
+
+#define NUMBER_OF_CSR_FW_EVENTS (CSR_DSPM_PRIM - CSR_SYNERGY_EVENT_CLASS_BASE + 1)
+
+#define CSR_SYNERGY_EVENT_CLASS_MISC_BASE ((CsrUint16) (0x06A0))
+
+#define CSR_UI_PRIM ((CsrUint16) (0x0000 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+#define CSR_APP_PRIM ((CsrUint16) (0x0001 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+#define CSR_SDIO_PROBE_PRIM ((CsrUint16) (0x0002 | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+
+#define NUMBER_OF_CSR_FW_MISC_EVENTS (CSR_SDIO_PROBE_PRIM - CSR_SYNERGY_EVENT_CLASS_MISC_BASE + 1)
+
+#define CSR_ENV_PRIM ((CsrUint16) (0x00FF | CSR_SYNERGY_EVENT_CLASS_MISC_BASE))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_PRIM_DEFS_H__ */
--- /dev/null
+#ifndef CSR_RESULT_H__
+#define CSR_RESULT_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef CsrUint16 CsrResult;
+#define CSR_RESULT_SUCCESS ((CsrResult) 0x0000)
+#define CSR_RESULT_FAILURE ((CsrResult) 0xFFFF)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_SCHED_H__
+#define CSR_SCHED_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+#include "csr_types.h"
+#include "csr_time.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* An identifier issued by the scheduler. */
+typedef CsrUint32 CsrSchedIdentifier;
+
+/* A task identifier */
+typedef CsrUint16 CsrSchedTaskId;
+
+/* A queue identifier */
+typedef CsrUint16 CsrSchedQid;
+#define CSR_SCHED_QID_INVALID ((CsrSchedQid) 0xFFFF)
+
+/* A message identifier */
+typedef CsrSchedIdentifier CsrSchedMsgId;
+
+/* A timer event identifier */
+typedef CsrSchedIdentifier CsrSchedTid;
+#define CSR_SCHED_TID_INVALID ((CsrSchedTid) 0)
+
+/* Scheduler entry functions share this structure */
+typedef void (*schedEntryFunction_t)(void **inst);
+
+/* Time constants. */
+#define CSR_SCHED_TIME_MAX ((CsrTime) 0xFFFFFFFF)
+#define CSR_SCHED_MILLISECOND ((CsrTime) (1000))
+#define CSR_SCHED_SECOND ((CsrTime) (1000 * CSR_SCHED_MILLISECOND))
+#define CSR_SCHED_MINUTE ((CsrTime) (60 * CSR_SCHED_SECOND))
+
+/* Queue and primitive that identifies the environment */
+#define CSR_SCHED_TASK_ID 0xFFFF
+#define CSR_SCHED_PRIM (CSR_SCHED_TASK_ID)
+#define CSR_SCHED_EXCLUDED_MODULE_QUEUE 0xFFFF
+
+/*
+ * Background interrupt definitions
+ */
+typedef CsrUint16 CsrSchedBgint;
+#define CSR_SCHED_BGINT_INVALID ((CsrSchedBgint) 0xFFFF)
+
+typedef void (*CsrSchedBgintHandler)(void *);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSchedBgintReg
+ *
+ * DESCRIPTION
+ * Register a background interrupt handler function with the scheduler.
+ * When CsrSchedBgint() is called from the foreground (e.g. an interrupt
+ * routine) the registered function is called.
+ *
+ * If "cb" is null then the interrupt is effectively disabled. If a
+ * no bgints are available, CSR_SCHED_BGINT_INVALID is returned, otherwise
+ * a CsrSchedBgint value is returned to be used in subsequent calls to
+ * CsrSchedBgint(). id is a possibly NULL identifier used for logging
+ * purposes only.
+ *
+ * RETURNS
+ * CsrSchedBgint -- CSR_SCHED_BGINT_INVALID denotes failure to obtain a CsrSchedBgintSet.
+ *
+ *----------------------------------------------------------------------------*/
+CsrSchedBgint CsrSchedBgintReg(CsrSchedBgintHandler cb,
+ void *context,
+ const CsrCharString *id);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSchedBgintUnreg
+ *
+ * DESCRIPTION
+ * Unregister a background interrupt handler function.
+ *
+ * ``irq'' is a background interrupt handle previously obtained
+ * from a call to CsrSchedBgintReg().
+ *
+ * RETURNS
+ * void.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSchedBgintUnreg(CsrSchedBgint bgint);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSchedBgintSet
+ *
+ * DESCRIPTION
+ * Set background interrupt.
+ *
+ * RETURNS
+ * void.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSchedBgintSet(CsrSchedBgint bgint);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSchedMessagePut
+ *
+ * DESCRIPTION
+ * Sends a message consisting of the integer "mi" and the void * pointer
+ * "mv" to the message queue "q".
+ *
+ * "mi" and "mv" are neither inspected nor changed by the scheduler - the
+ * task that owns "q" is expected to make sense of the values. "mv" may
+ * be null.
+ *
+ * NOTE
+ * If "mv" is not null then it will typically be a chunk of CsrPmemAlloc()ed
+ * memory, though there is no need for it to be so. Tasks should normally
+ * obey the convention that when a message built with CsrPmemAlloc()ed memory
+ * is given to CsrSchedMessagePut() then ownership of the memory is ceded to the
+ * scheduler - and eventually to the recipient task. I.e., the receiver of
+ * the message will be expected to CsrPmemFree() the message storage.
+ *
+ * RETURNS
+ * void.
+ *
+ *----------------------------------------------------------------------------*/
+#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
+void CsrSchedMessagePutStringLog(CsrSchedQid q,
+ CsrUint16 mi,
+ void *mv,
+ CsrUint32 line,
+ const CsrCharString *file);
+#define CsrSchedMessagePut(q, mi, mv) CsrSchedMessagePutStringLog((q), (mi), (mv), __LINE__, __FILE__)
+#else
+void CsrSchedMessagePut(CsrSchedQid q,
+ CsrUint16 mi,
+ void *mv);
+#endif
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSchedMessageBroadcast
+ *
+ * DESCRIPTION
+ * Sends a message to all tasks.
+ *
+ * The user must supply a "factory function" that is called once
+ * for every task that exists. The "factory function", msg_build_func,
+ * must allocate and initialise the message and set the msg_build_ptr
+ * to point to the message when done.
+ *
+ * NOTE
+ * N/A
+ *
+ * RETURNS
+ * void
+ *
+ *----------------------------------------------------------------------------*/
+#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
+void CsrSchedMessageBroadcastStringLog(CsrUint16 mi,
+ void *(*msg_build_func)(void *),
+ void *msg_build_ptr,
+ CsrUint32 line,
+ const CsrCharString *file);
+#define CsrSchedMessageBroadcast(mi, fn, ptr) CsrSchedMessageBroadcastStringLog((mi), (fn), (ptr), __LINE__, __FILE__)
+#else
+void CsrSchedMessageBroadcast(CsrUint16 mi,
+ void *(*msg_build_func)(void *),
+ void *msg_build_ptr);
+#endif
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSchedMessageGet
+ *
+ * DESCRIPTION
+ * Obtains a message from the message queue belonging to the calling task.
+ * The message consists of one or both of a CsrUint16 and a void *.
+ *
+ * RETURNS
+ * CsrBool - TRUE if a message has been obtained from the queue, else FALSE.
+ * If a message is taken from the queue, then "*pmi" and "*pmv" are set to
+ * the "mi" and "mv" passed to CsrSchedMessagePut() respectively.
+ *
+ * "pmi" and "pmv" can be null, in which case the corresponding value from
+ * them message is discarded.
+ *
+ *----------------------------------------------------------------------------*/
+CsrBool CsrSchedMessageGet(CsrUint16 *pmi, void **pmv);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSchedTimerSet
+ *
+ * DESCRIPTION
+ * Causes the void function "fn" to be called with the arguments
+ * "fniarg" and "fnvarg" after "delay" has elapsed.
+ *
+ * "delay" must be less than half the range of a CsrTime.
+ *
+ * CsrSchedTimerSet() does nothing with "fniarg" and "fnvarg" except
+ * deliver them via a call to "fn()". (Unless CsrSchedTimerCancel()
+ * is used to prevent delivery.)
+ *
+ * NOTE
+ * The function will be called at or after "delay"; the actual delay will
+ * depend on the timing behaviour of the scheduler's tasks.
+ *
+ * RETURNS
+ * CsrSchedTid - A timed event identifier, can be used in CsrSchedTimerCancel().
+ *
+ *----------------------------------------------------------------------------*/
+#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
+CsrSchedTid CsrSchedTimerSetStringLog(CsrTime delay,
+ void (*fn)(CsrUint16 mi, void *mv),
+ CsrUint16 fniarg,
+ void *fnvarg,
+ CsrUint32 line,
+ const CsrCharString *file);
+#define CsrSchedTimerSet(d, fn, fni, fnv) CsrSchedTimerSetStringLog((d), (fn), (fni), (fnv), __LINE__, __FILE__)
+#else
+CsrSchedTid CsrSchedTimerSet(CsrTime delay,
+ void (*fn)(CsrUint16 mi, void *mv),
+ CsrUint16 fniarg,
+ void *fnvarg);
+#endif
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSchedTimerCancel
+ *
+ * DESCRIPTION
+ * Attempts to prevent the timed event with identifier "eventid" from
+ * occurring.
+ *
+ * RETURNS
+ * CsrBool - TRUE if cancelled, FALSE if the event has already occurred.
+ *
+ *----------------------------------------------------------------------------*/
+#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
+CsrBool CsrSchedTimerCancelStringLog(CsrSchedTid eventid,
+ CsrUint16 *pmi,
+ void **pmv,
+ CsrUint32 line,
+ const CsrCharString *file);
+#define CsrSchedTimerCancel(e, pmi, pmv) CsrSchedTimerCancelStringLog((e), (pmi), (pmv), __LINE__, __FILE__)
+#else
+CsrBool CsrSchedTimerCancel(CsrSchedTid eventid,
+ CsrUint16 *pmi,
+ void **pmv);
+#endif
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSchedTaskQueueGet
+ *
+ * DESCRIPTION
+ * Return the queue identifier for the currently running queue
+ *
+ * RETURNS
+ * CsrSchedQid - The current task queue identifier, or 0xFFFF if not available.
+ *
+ *----------------------------------------------------------------------------*/
+CsrSchedQid CsrSchedTaskQueueGet(void);
+
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSchedTaskQueueGet
+ *
+ * DESCRIPTION
+ * Return the queue identifier for the currently running queue
+ *
+ * RETURNS
+ * CsrCharString - The current task queue identifier, or 0xFFFF if not available.
+ *
+ *----------------------------------------------------------------------------*/
+CsrCharString* CsrSchedTaskNameGet(CsrSchedQid );
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_SDIO_H__
+#define CSR_SDIO_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+#include "csr_result.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Result Codes */
+#define CSR_SDIO_RESULT_INVALID_VALUE ((CsrResult) 1) /* Invalid argument value */
+#define CSR_SDIO_RESULT_NO_DEVICE ((CsrResult) 2) /* The specified device is no longer present */
+#define CSR_SDIO_RESULT_CRC_ERROR ((CsrResult) 3) /* The transmitted/received data or command response contained a CRC error */
+#define CSR_SDIO_RESULT_TIMEOUT ((CsrResult) 4) /* No command response or data received from device, or function enable/disable did not succeed within timeout period */
+#define CSR_SDIO_RESULT_NOT_RESET ((CsrResult) 5) /* The device was not reset */
+
+/* Features (for use in features member of CsrSdioFunction) */
+#define CSR_SDIO_FEATURE_BYTE_MODE 0x00000001 /* Transfer sizes do not have to be a multiple of block size */
+#define CSR_SDIO_FEATURE_DMA_CAPABLE_MEM_REQUIRED 0x00000002 /* Bulk operations require DMA friendly memory */
+
+/* CsrSdioFunctionId wildcards (for use in CsrSdioFunctionId members) */
+#define CSR_SDIO_ANY_MANF_ID 0xFFFF
+#define CSR_SDIO_ANY_CARD_ID 0xFFFF
+#define CSR_SDIO_ANY_SDIO_FUNCTION 0xFF
+#define CSR_SDIO_ANY_SDIO_INTERFACE 0xFF
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionId
+ *
+ * DESCRIPTION
+ * This structure describes one or more functions of a device, based on
+ * four qualitative measures. The CsrSdioFunctionId wildcard defines can be
+ * used for making the CsrSdioFunctionId match more than one function.
+ *
+ * MEMBERS
+ * manfId - Vendor ID (or CSR_SDIO_ANY_MANF_ID).
+ * cardId - Device ID (or CSR_SDIO_ANY_CARD_ID).
+ * sdioFunction - SDIO Function number (or CSR_SDIO_ANY_SDIO_FUNCTION).
+ * sdioInterface - SDIO Standard Interface Code (or CSR_SDIO_ANY_SDIO_INTERFACE)
+ *
+ *----------------------------------------------------------------------------*/
+typedef struct
+{
+ CsrUint16 manfId; /* Vendor ID to match or CSR_SDIO_ANY_MANF_ID */
+ CsrUint16 cardId; /* Device ID to match or CSR_SDIO_ANY_CARD_ID */
+ CsrUint8 sdioFunction; /* SDIO Function number to match or CSR_SDIO_ANY_SDIO_FUNCTION */
+ CsrUint8 sdioInterface; /* SDIO Standard Interface Code to match or CSR_SDIO_ANY_SDIO_INTERFACE */
+} CsrSdioFunctionId;
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunction
+ *
+ * DESCRIPTION
+ * This structure represents a single function on a device.
+ *
+ * MEMBERS
+ * sdioId - A CsrSdioFunctionId describing this particular function. The
+ * subfield shall not contain any CsrSdioFunctionId wildcards. The
+ * subfields shall describe the specific single function
+ * represented by this structure.
+ * blockSize - Actual configured block size, or 0 if unconfigured.
+ * features - Bit mask with any of CSR_SDIO_FEATURE_* set.
+ * device - Handle of device containing the function. If two functions have
+ * the same device handle, they reside on the same device.
+ * driverData - For use by the Function Driver. The SDIO Driver shall not
+ * attempt to dereference the pointer.
+ * priv - For use by the SDIO Driver. The Function Driver shall not attempt
+ * to dereference the pointer.
+ *
+ *
+ *----------------------------------------------------------------------------*/
+typedef struct
+{
+ CsrSdioFunctionId sdioId;
+ CsrUint16 blockSize; /* Actual configured block size, or 0 if unconfigured */
+ CsrUint32 features; /* Bit mask with any of CSR_SDIO_FEATURE_* set */
+ void *device; /* Handle of device containing the function */
+ void *driverData; /* For use by the Function Driver */
+ void *priv; /* For use by the SDIO Driver */
+} CsrSdioFunction;
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioInsertedCallback, CsrSdioRemovedCallback
+ *
+ * DESCRIPTION
+ * CsrSdioInsertedCallback is called when a function becomes available to
+ * a registered Function Driver that supports the function.
+ * CsrSdioRemovedCallback is called when a function is no longer available
+ * to a Function Driver, either because the device has been removed, or the
+ * Function Driver has been unregistered.
+ *
+ * NOTE: These functions are implemented by the Function Driver, and are
+ * passed as function pointers in the CsrSdioFunctionDriver struct.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ *----------------------------------------------------------------------------*/
+typedef void (*CsrSdioInsertedCallback)(CsrSdioFunction *function);
+typedef void (*CsrSdioRemovedCallback)(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioInterruptDsrCallback, CsrSdioInterruptCallback
+ *
+ * DESCRIPTION
+ * CsrSdioInterruptCallback is called when an interrupt occurs on the
+ * the device associated with the specified function.
+ *
+ * NOTE: These functions are implemented by the Function Driver, and are
+ * passed as function pointers in the CsrSdioFunctionDriver struct.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ * RETURNS (only CsrSdioInterruptCallback)
+ * A pointer to a CsrSdioInterruptDsrCallback function.
+ *
+ *----------------------------------------------------------------------------*/
+typedef void (*CsrSdioInterruptDsrCallback)(CsrSdioFunction *function);
+typedef CsrSdioInterruptDsrCallback (*CsrSdioInterruptCallback)(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioSuspendCallback, CsrSdioResumeCallback
+ *
+ * DESCRIPTION
+ * CsrSdioSuspendCallback is called when the system is preparing to go
+ * into a suspended state. CsrSdioResumeCallback is called when the system
+ * has entered an active state again.
+ *
+ * NOTE: These functions are implemented by the Function Driver, and are
+ * passed as function pointers in the CsrSdioFunctionDriver struct.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ *----------------------------------------------------------------------------*/
+typedef void (*CsrSdioSuspendCallback)(CsrSdioFunction *function);
+typedef void (*CsrSdioResumeCallback)(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioAsyncCallback, CsrSdioAsyncDsrCallback
+ *
+ * DESCRIPTION
+ * CsrSdioAsyncCallback is called when an asynchronous operation completes.
+ *
+ * NOTE: These functions are implemented by the Function Driver, and are
+ * passed as function pointers in the function calls that initiate
+ * the operation.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * result - The result of the operation that completed. See the description
+ * of the initiating function for possible result values.
+ *
+ * RETURNS (only CsrSdioAsyncCallback)
+ * A pointer to a CsrSdioAsyncDsrCallback function.
+ *
+ *----------------------------------------------------------------------------*/
+typedef void (*CsrSdioAsyncDsrCallback)(CsrSdioFunction *function, CsrResult result);
+typedef CsrSdioAsyncDsrCallback (*CsrSdioAsyncCallback)(CsrSdioFunction *function, CsrResult result);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionDriver
+ *
+ * DESCRIPTION
+ * Structure representing a Function Driver.
+ *
+ * MEMBERS
+ * inserted - Callback, see description of CsrSdioInsertedCallback.
+ * removed - Callback, see description of CsrSdioRemovedCallback.
+ * intr - Callback, see description of CsrSdioInterruptCallback.
+ * suspend - Callback, see description of CsrSdioSuspendCallback.
+ * resume - Callback, see description of CsrSdioResumeCallback.
+ * ids - Array of CsrSdioFunctionId describing one or more functions that
+ * are supported by the Function Driver.
+ * idsCount - Length of the ids array.
+ * priv - For use by the SDIO Driver. The Function Driver may initialise
+ * it to NULL, but shall otherwise not access the pointer or attempt
+ * to dereference it.
+ *
+ *----------------------------------------------------------------------------*/
+typedef struct
+{
+ CsrSdioInsertedCallback inserted;
+ CsrSdioRemovedCallback removed;
+ CsrSdioInterruptCallback intr;
+ CsrSdioSuspendCallback suspend;
+ CsrSdioResumeCallback resume;
+ CsrSdioFunctionId *ids;
+ CsrUint8 idsCount;
+ void *priv; /* For use by the SDIO Driver */
+} CsrSdioFunctionDriver;
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionDriverRegister
+ *
+ * DESCRIPTION
+ * Register a Function Driver.
+ *
+ * PARAMETERS
+ * functionDriver - Pointer to struct describing the Function Driver.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The Function Driver was successfully
+ * registered.
+ * CSR_RESULT_FAILURE - Unable to register the function driver,
+ * because of an unspecified/unknown error. The
+ * Function Driver has not been registered.
+ * CSR_SDIO_RESULT_INVALID_VALUE - The specified Function Driver pointer
+ * does not point at a valid Function
+ * Driver structure, or some of the members
+ * contain invalid entries.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioFunctionDriverRegister(CsrSdioFunctionDriver *functionDriver);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionDriverUnregister
+ *
+ * DESCRIPTION
+ * Unregister a previously registered Function Driver.
+ *
+ * PARAMETERS
+ * functionDriver - pointer to struct describing the Function Driver.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSdioFunctionDriverUnregister(CsrSdioFunctionDriver *functionDriver);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionEnable, CsrSdioFunctionDisable
+ *
+ * DESCRIPTION
+ * Enable/disable the specified function by setting/clearing the
+ * corresponding bit in the I/O Enable register in function 0, and then
+ * periodically reading the related bit in the I/O Ready register until it
+ * is set/clear, limited by an implementation defined timeout.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The specified function was enabled/disabled.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. The state of the
+ * related bit in the I/O Enable register is
+ * undefined.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device, or the related
+ * bit in the I/O ready register was not
+ * set/cleared within the timeout period.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioFunctionEnable(CsrSdioFunction *function);
+CsrResult CsrSdioFunctionDisable(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioInterruptEnable, CsrSdioInterruptDisable
+ *
+ * DESCRIPTION
+ * Enable/disable the interrupt for the specified function by
+ * setting/clearing the corresponding bit in the INT Enable register in
+ * function 0.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The specified function was enabled/disabled.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. The state of the
+ * related bit in the INT Enable register is
+ * unchanged.
+ * CSR_SDIO_RESULT_INVALID_VALUE - The specified function cannot be
+ * enabled/disabled, because it either
+ * does not exist or it is not possible to
+ * individually enable/disable functions.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioInterruptEnable(CsrSdioFunction *function);
+CsrResult CsrSdioInterruptDisable(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioInterruptAcknowledge
+ *
+ * DESCRIPTION
+ * Acknowledge that a signalled interrupt has been handled. Shall only
+ * be called once, and exactly once for each signalled interrupt to the
+ * corresponding function.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function to which the
+ * event was signalled.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSdioInterruptAcknowledge(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioInsertedAcknowledge, CsrSdioRemovedAcknowledge
+ *
+ * DESCRIPTION
+ * Acknowledge that a signalled inserted/removed event has been handled.
+ * Shall only be called once, and exactly once for each signalled event to
+ * the corresponding function.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function to which the
+ * inserted was signalled.
+ * result (CsrSdioInsertedAcknowledge only)
+ * CSR_RESULT_SUCCESS - The Function Driver has accepted the
+ * function, and the function is attached to
+ * the Function Driver until the
+ * CsrSdioRemovedCallback is called and
+ * acknowledged.
+ * CSR_RESULT_FAILURE - Unable to accept the function. The
+ * function is not attached to the Function
+ * Driver, and it may be passed to another
+ * Function Driver which supports the
+ * function.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSdioInsertedAcknowledge(CsrSdioFunction *function, CsrResult result);
+void CsrSdioRemovedAcknowledge(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioSuspendAcknowledge, CsrSdioResumeAcknowledge
+ *
+ * DESCRIPTION
+ * Acknowledge that a signalled suspend event has been handled. Shall only
+ * be called once, and exactly once for each signalled event to the
+ * corresponding function.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function to which the
+ * event was signalled.
+ * result
+ * CSR_RESULT_SUCCESS - Successfully suspended/resumed.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSdioSuspendAcknowledge(CsrSdioFunction *function, CsrResult result);
+void CsrSdioResumeAcknowledge(CsrSdioFunction *function, CsrResult result);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioBlockSizeSet
+ *
+ * DESCRIPTION
+ * Set the block size to use for the function. The actual configured block
+ * size shall be the minimum of:
+ * 1) Maximum block size supported by the function.
+ * 2) Maximum block size supported by the host controller.
+ * 3) The block size specified by the blockSize argument.
+ *
+ * When this function returns, the actual configured block size is
+ * available in the blockSize member of the function struct.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * blockSize - Block size to use for the function. Valid range is 1 to
+ * 2048.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The block size register on the chip
+ * was updated.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. The configured block
+ * size is undefined.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and the FUNCTION_NUMBER
+ * bits is set, CSR_SDIO_RESULT_INVALID_VALUE shall be returned.
+ * If the ERROR bit is set (but not FUNCTION_NUMBER),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ * NOTE: Setting the block size requires two individual operations. The
+ * implementation shall ignore the OUT_OF_RANGE bit of the SDIO R5
+ * response for the first operation, as the partially configured
+ * block size may be out of range, even if the final block size
+ * (after the second operation) is in the valid range.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioBlockSizeSet(CsrSdioFunction *function, CsrUint16 blockSize);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioMaxBusClockFrequencySet
+ *
+ * DESCRIPTION
+ * Set the maximum clock frequency to use for the device associated with
+ * the specified function. The actual configured clock frequency for the
+ * device shall be the minimum of:
+ * 1) Maximum clock frequency supported by the device.
+ * 2) Maximum clock frequency supported by the host controller.
+ * 3) Maximum clock frequency specified for any function on the same
+ * device.
+ *
+ * If the clock frequency exceeds 25MHz, it is the responsibility of the
+ * SDIO driver to enable high speed mode on the device, using the standard
+ * defined procedure, before increasing the frequency beyond the limit.
+ *
+ * Note that the clock frequency configured affects all functions on the
+ * same device.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * maxFrequency - The maximum clock frequency for the function in Hertz.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The maximum clock frequency was succesfully
+ * set for the function.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ *
+ * NOTE: If the SDIO R5 response is available, and the FUNCTION_NUMBER
+ * bits is set, CSR_SDIO_RESULT_INVALID_VALUE shall be returned.
+ * If the ERROR bit is set (but not FUNCTION_NUMBER),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioMaxBusClockFrequencySet(CsrSdioFunction *function, CsrUint32 maxFrequency);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioRead8, CsrSdioWrite8, CsrSdioRead8Async, CsrSdioWrite8Async
+ *
+ * DESCRIPTION
+ * Read/write an 8bit value from/to the specified register address.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * address - Register address within the function.
+ * data - The data to read/write.
+ * callback - The function to call on operation completion.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The data was successfully read/written.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. No data read/written.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ * NOTE: The CsrSdioRead8Async and CsrSdioWrite8Async functions return
+ * immediately, and the supplied callback function is called when the
+ * operation is complete. The result value is given as an argument to
+ * the callback function.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data);
+CsrResult CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data);
+void CsrSdioRead8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data, CsrSdioAsyncCallback callback);
+void CsrSdioWrite8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data, CsrSdioAsyncCallback callback);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioRead16, CsrSdioWrite16, CsrSdioRead16Async, CsrSdioWrite16Async
+ *
+ * DESCRIPTION
+ * Read/write a 16bit value from/to the specified register address.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * address - Register address within the function.
+ * data - The data to read/write.
+ * callback - The function to call on operation completion.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The data was successfully read/written.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. Data may have been
+ * partially read/written.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ * NOTE: The CsrSdioRead16Async and CsrSdioWrite16Async functions return
+ * immediately, and the supplied callback function is called when the
+ * operation is complete. The result value is given as an argument to
+ * the callback function.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data);
+CsrResult CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data);
+void CsrSdioRead16Async(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data, CsrSdioAsyncCallback callback);
+void CsrSdioWrite16Async(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data, CsrSdioAsyncCallback callback);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioF0Read8, CsrSdioF0Write8, CsrSdioF0Read8Async,
+ * CsrSdioF0Write8Async
+ *
+ * DESCRIPTION
+ * Read/write an 8bit value from/to the specified register address in
+ * function 0.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * address - Register address within the function.
+ * data - The data to read/write.
+ * callback - The function to call on operation completion.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The data was successfully read/written.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. No data read/written.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ * NOTE: The CsrSdioF0Read8Async and CsrSdioF0Write8Async functions return
+ * immediately, and the supplied callback function is called when the
+ * operation is complete. The result value is given as an argument to
+ * the callback function.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data);
+CsrResult CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data);
+void CsrSdioF0Read8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data, CsrSdioAsyncCallback callback);
+void CsrSdioF0Write8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data, CsrSdioAsyncCallback callback);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioRead, CsrSdioWrite, CsrSdioReadAsync, CsrSdioWriteAsync
+ *
+ * DESCRIPTION
+ * Read/write a specified number of bytes from/to the specified register
+ * address.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * address - Register address within the function.
+ * data - The data to read/write.
+ * length - Number of byte to read/write.
+ * callback - The function to call on operation completion.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The data was successfully read/written.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. Data may have been
+ * partially read/written.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ * NOTE: The CsrSdioF0Read8Async and CsrSdioF0Write8Async functions return
+ * immediately, and the supplied callback function is called when the
+ * operation is complete. The result value is given as an argument to
+ * the callback function.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioRead(CsrSdioFunction *function, CsrUint32 address, void *data, CsrUint32 length);
+CsrResult CsrSdioWrite(CsrSdioFunction *function, CsrUint32 address, const void *data, CsrUint32 length);
+void CsrSdioReadAsync(CsrSdioFunction *function, CsrUint32 address, void *data, CsrUint32 length, CsrSdioAsyncCallback callback);
+void CsrSdioWriteAsync(CsrSdioFunction *function, CsrUint32 address, const void *data, CsrUint32 length, CsrSdioAsyncCallback callback);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioPowerOn, CsrSdioPowerOff
+ *
+ * DESCRIPTION
+ * Power on/off the device.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function that resides on
+ * the device to power on/off.
+ *
+ * RETURNS (only CsrSdioPowerOn)
+ * CSR_RESULT_SUCCESS - Power was succesfully reapplied and the device
+ * has been reinitialised.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured during reinitialisation.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device during
+ * reinitialisation.
+ * CSR_SDIO_RESULT_NOT_RESET - The power was not removed by the
+ * CsrSdioPowerOff call. The state of the
+ * device is unchanged.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioPowerOn(CsrSdioFunction *function);
+void CsrSdioPowerOff(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioHardReset
+ *
+ * DESCRIPTION
+ * Perform a hardware reset of the device.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function that resides on
+ * the device to hard reset.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - Reset was succesfully performed and the device
+ * has been reinitialised.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured during reinitialisation.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device during
+ * reinitialisation.
+ * CSR_SDIO_RESULT_NOT_RESET - The reset was not applied because it is not
+ * supported. The state of the device is
+ * unchanged.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioHardReset(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionActive, CsrSdioFunctionIdle
+ *
+ * DESCRIPTION
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSdioFunctionActive(CsrSdioFunction *function);
+void CsrSdioFunctionIdle(CsrSdioFunction *function);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include <linux/module.h>
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+#include "csr_msgconv.h"
+#include "csr_util.h"
+#include "csr_pmem.h"
+#include "csr_lib.h"
+
+void CsrUint8Des(CsrUint8 *value, CsrUint8 *buffer, CsrSize *offset)
+{
+ *value = buffer[*offset];
+ *offset += sizeof(*value);
+}
+EXPORT_SYMBOL_GPL(CsrUint8Des);
+
+void CsrUint16Des(CsrUint16 *value, CsrUint8 *buffer, CsrSize *offset)
+{
+ *value = (buffer[*offset + 0] << 0) |
+ (buffer[*offset + 1] << 8);
+ *offset += sizeof(*value);
+}
+EXPORT_SYMBOL_GPL(CsrUint16Des);
+
+void CsrUint32Des(CsrUint32 *value, CsrUint8 *buffer, CsrSize *offset)
+{
+ *value = (buffer[*offset + 0] << 0) |
+ (buffer[*offset + 1] << 8) |
+ (buffer[*offset + 2] << 16) |
+ (buffer[*offset + 3] << 24);
+ *offset += sizeof(*value);
+}
+EXPORT_SYMBOL_GPL(CsrUint32Des);
+
+void CsrMemCpyDes(void *value, CsrUint8 *buffer, CsrSize *offset, CsrSize length)
+{
+ CsrMemCpy(value, &buffer[*offset], length);
+ *offset += length;
+}
+EXPORT_SYMBOL_GPL(CsrMemCpyDes);
+
+void CsrCharStringDes(CsrCharString **value, CsrUint8 *buffer, CsrSize *offset)
+{
+ *value = CsrStrDup((CsrCharString *) &buffer[*offset]);
+ *offset += CsrStrLen(*value) + 1;
+}
+EXPORT_SYMBOL_GPL(CsrCharStringDes);
+
+void CsrUtf8StringDes(CsrUtf8String **value, CsrUint8 *buffer, CsrSize *offset)
+{
+ *value = (CsrUtf8String *) CsrStrDup((CsrCharString *) &buffer[*offset]);
+ *offset += CsrStrLen((CsrCharString *) *value) + 1;
+}
+
+void CsrUtf16StringDes(CsrUtf16String **value, CsrUint8 *buffer, CsrSize *offset)
+{
+ CsrUint32 length, i;
+
+ CsrUint32Des(&length, buffer, offset);
+
+ *value = CsrPmemAlloc(length * sizeof(**value));
+ for (i = 0; i < length; i++)
+ {
+ CsrUint16Des(&(*value)[i], buffer, offset);
+ }
+}
+
+void CsrSizeDes(CsrSize *value, CsrUint8 *buffer, CsrSize *offset)
+{
+ *value = (buffer[*offset + 0] << 0) |
+ (buffer[*offset + 1] << 8) |
+ (buffer[*offset + 2] << 16) |
+ (buffer[*offset + 3] << 24);
+ *offset += sizeof(*value);
+}
+
+void CsrVoidPtrDes(void **value, CsrUint8 *buffer, CsrSize *offset)
+{
+ CsrSizeDes((CsrSize *) value, buffer, offset);
+}
+
+void CsrUint8Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint8 value)
+{
+ buffer[*offset] = value;
+ *offset += sizeof(value);
+}
+EXPORT_SYMBOL_GPL(CsrUint8Ser);
+
+void CsrUint16Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint16 value)
+{
+ buffer[*offset + 0] = (CsrUint8) ((value >> 0) & 0xFF);
+ buffer[*offset + 1] = (CsrUint8) ((value >> 8) & 0xFF);
+ *offset += sizeof(value);
+}
+EXPORT_SYMBOL_GPL(CsrUint16Ser);
+
+void CsrUint32Ser(CsrUint8 *buffer, CsrSize *offset, CsrUint32 value)
+{
+ buffer[*offset + 0] = (CsrUint8) ((value >> 0) & 0xFF);
+ buffer[*offset + 1] = (CsrUint8) ((value >> 8) & 0xFF);
+ buffer[*offset + 2] = (CsrUint8) ((value >> 16) & 0xFF);
+ buffer[*offset + 3] = (CsrUint8) ((value >> 24) & 0xFF);
+ *offset += sizeof(value);
+}
+EXPORT_SYMBOL_GPL(CsrUint32Ser);
+
+void CsrMemCpySer(CsrUint8 *buffer, CsrSize *offset, const void *value, CsrSize length)
+{
+ CsrMemCpy(&buffer[*offset], value, length);
+ *offset += length;
+}
+EXPORT_SYMBOL_GPL(CsrMemCpySer);
+
+void CsrCharStringSer(CsrUint8 *buffer, CsrSize *offset, const CsrCharString *value)
+{
+ if (value)
+ {
+ CsrStrCpy(((CsrCharString *) &buffer[*offset]), value);
+ *offset += CsrStrLen(value) + 1;
+ }
+ else
+ {
+ CsrUint8Ser(buffer, offset, 0);
+ }
+}
+EXPORT_SYMBOL_GPL(CsrCharStringSer);
+
+void CsrUtf8StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf8String *value)
+{
+ CsrCharStringSer(buffer, offset, (CsrCharString *) value);
+}
+
+void CsrUtf16StringSer(CsrUint8 *buffer, CsrSize *offset, const CsrUtf16String *value)
+{
+ if (value)
+ {
+ CsrUint32 length = CsrUtf16StrLen(value) + 1;
+ CsrUint32 i;
+
+ CsrUint32Ser(buffer, offset, length);
+
+ for (i = 0; i < length; i++)
+ {
+ CsrUint16Ser(buffer, offset, (CsrUint16) value[i]);
+ }
+ }
+ else
+ {
+ CsrUint32Ser(buffer, offset, 0);
+ }
+}
+
+void CsrSizeSer(CsrUint8 *buffer, CsrSize *offset, CsrSize value)
+{
+ buffer[*offset + 0] = (CsrUint8) ((value >> 0) & 0xFF);
+ buffer[*offset + 1] = (CsrUint8) ((value >> 8) & 0xFF);
+ buffer[*offset + 2] = (CsrUint8) ((value >> 16) & 0xFF);
+ buffer[*offset + 3] = (CsrUint8) ((value >> 24) & 0xFF);
+ *offset += sizeof(value);
+}
+
+void CsrVoidPtrSer(CsrUint8 *buffer, CsrSize *offset, void *ptr)
+{
+ CsrSizeSer(buffer, offset, (CsrSize) ptr);
+}
+
+CsrUint32 CsrCharStringSerLen(const CsrCharString *str)
+{
+ if (str)
+ {
+ return (CsrUint32) (CsrStrLen(str) + sizeof(*str));
+ }
+ else
+ {
+ return sizeof(*str);
+ }
+}
+
+CsrUint32 CsrUtf8StringSerLen(const CsrUtf8String *str)
+{
+ if (str)
+ {
+ return (CsrUint32) (CsrStrLen((CsrCharString *) str) + sizeof(*str));
+ }
+ else
+ {
+ return sizeof(*str);
+ }
+}
+
+CsrUint32 CsrUtf16StringSerLen(const CsrUtf16String *str)
+{
+ if (str)
+ {
+ /* We always write down the length of the string */
+ return sizeof(CsrUint32) + (CsrUtf16StrLen(str) + 1) * sizeof(*str);
+ }
+ else
+ {
+ return sizeof(CsrUint32);
+ }
+}
+
+CsrSize CsrEventSizeof(void *msg)
+{
+ return 2;
+}
+
+CsrUint8 *CsrEventSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrEvent *primitive = (CsrEvent *) msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ return ptr;
+}
+
+void *CsrEventDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrEvent *primitive = (CsrEvent *) CsrPmemAlloc(sizeof(CsrEvent));
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+
+ return primitive;
+}
+
+CsrSize CsrEventCsrUint8Sizeof(void *msg)
+{
+ return 3;
+}
+
+CsrUint8 *CsrEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ CsrUint8Ser(ptr, len, primitive->value);
+ return ptr;
+}
+
+void *CsrEventCsrUint8Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrEventCsrUint8 *primitive = (CsrEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrEventCsrUint8));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+ CsrUint8Des(&primitive->value, buffer, &offset);
+
+ return primitive;
+}
+
+CsrSize CsrEventCsrUint16Sizeof(void *msg)
+{
+ return 4;
+}
+
+CsrUint8 *CsrEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ CsrUint16Ser(ptr, len, primitive->value);
+ return ptr;
+}
+
+void *CsrEventCsrUint16Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrEventCsrUint16 *primitive = (CsrEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+ CsrUint16Des(&primitive->value, buffer, &offset);
+
+ return primitive;
+}
+
+CsrSize CsrEventCsrUint32Sizeof(void *msg)
+{
+ return 6;
+}
+
+CsrUint8 *CsrEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ CsrUint32Ser(ptr, len, primitive->value);
+ return ptr;
+}
+
+void *CsrEventCsrUint32Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrEventCsrUint32 *primitive = (CsrEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrEventCsrUint32));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+ CsrUint32Des(&primitive->value, buffer, &offset);
+
+ return primitive;
+}
+
+CsrSize CsrEventCsrUint16CsrUint8Sizeof(void *msg)
+{
+ return 5;
+}
+
+CsrUint8 *CsrEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ CsrUint16Ser(ptr, len, primitive->value1);
+ CsrUint8Ser(ptr, len, primitive->value2);
+ return ptr;
+}
+
+void *CsrEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrEventCsrUint16CsrUint8 *primitive = (CsrEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint8));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+ CsrUint16Des(&primitive->value1, buffer, &offset);
+ CsrUint8Des(&primitive->value2, buffer, &offset);
+
+ return primitive;
+}
+
+CsrSize CsrEventCsrUint16CsrUint16Sizeof(void *msg)
+{
+ return 6;
+}
+
+CsrUint8 *CsrEventCsrUint16CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ CsrUint16Ser(ptr, len, primitive->value1);
+ CsrUint16Ser(ptr, len, primitive->value2);
+ return ptr;
+}
+
+void *CsrEventCsrUint16CsrUint16Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrEventCsrUint16CsrUint16 *primitive = (CsrEventCsrUint16CsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint16));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+ CsrUint16Des(&primitive->value1, buffer, &offset);
+ CsrUint16Des(&primitive->value2, buffer, &offset);
+
+ return primitive;
+}
+
+CsrSize CsrEventCsrUint16CsrUint32Sizeof(void *msg)
+{
+ return 8;
+}
+
+CsrUint8 *CsrEventCsrUint16CsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ CsrUint16Ser(ptr, len, primitive->value1);
+ CsrUint32Ser(ptr, len, primitive->value2);
+ return ptr;
+}
+
+void *CsrEventCsrUint16CsrUint32Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrEventCsrUint16CsrUint32 *primitive = (CsrEventCsrUint16CsrUint32 *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrUint32));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+ CsrUint16Des(&primitive->value1, buffer, &offset);
+ CsrUint32Des(&primitive->value2, buffer, &offset);
+
+ return primitive;
+}
+
+CsrSize CsrEventCsrUint16CsrCharStringSizeof(void *msg)
+{
+ CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
+ return 4 + CsrStrLen(primitive->value2) + 1;
+}
+
+CsrUint8 *CsrEventCsrUint16CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ CsrUint16Ser(ptr, len, primitive->value1);
+ CsrCharStringSer(ptr, len, primitive->value2);
+ return ptr;
+}
+
+void *CsrEventCsrUint16CsrCharStringDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrEventCsrUint16CsrCharString *primitive = (CsrEventCsrUint16CsrCharString *) CsrPmemAlloc(sizeof(CsrEventCsrUint16CsrCharString));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+ CsrUint16Des(&primitive->value1, buffer, &offset);
+ CsrCharStringDes(&primitive->value2, buffer, &offset);
+
+ return primitive;
+}
+
+CsrSize CsrEventCsrUint32CsrUint16Sizeof(void *msg)
+{
+ return 8;
+}
+
+CsrUint8 *CsrEventCsrUint32CsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ CsrUint32Ser(ptr, len, primitive->value1);
+ CsrUint16Ser(ptr, len, primitive->value2);
+ return ptr;
+}
+
+void *CsrEventCsrUint32CsrUint16Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrEventCsrUint32CsrUint16 *primitive = (CsrEventCsrUint32CsrUint16 *) CsrPmemAlloc(sizeof(CsrEventCsrUint32CsrUint16));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+ CsrUint32Des(&primitive->value1, buffer, &offset);
+ CsrUint16Des(&primitive->value2, buffer, &offset);
+
+ return primitive;
+}
+
+CsrSize CsrEventCsrUint32CsrCharStringSizeof(void *msg)
+{
+ CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
+ return 6 + CsrStrLen(primitive->value2) + 1;
+}
+
+CsrUint8 *CsrEventCsrUint32CsrCharStringSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ CsrUint32Ser(ptr, len, primitive->value1);
+ CsrCharStringSer(ptr, len, primitive->value2);
+ return ptr;
+}
+
+void *CsrEventCsrUint32CsrCharStringDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrEventCsrUint32CsrCharString *primitive = (CsrEventCsrUint32CsrCharString *) CsrPmemAlloc(sizeof(CsrEventCsrUint32CsrCharString));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+ CsrUint32Des(&primitive->value1, buffer, &offset);
+ CsrCharStringDes(&primitive->value2, buffer, &offset);
+
+ return primitive;
+}
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
+#elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
+#include <linux/autoconf.h>
+#include <linux/config.h>
+#endif
+
+#include <linux/time.h>
+#include <linux/module.h>
+
+#include "csr_types.h"
+#include "csr_time.h"
+
+CsrTime CsrTimeGet(CsrTime *high)
+{
+ struct timespec ts;
+ CsrUint64 time;
+ CsrTime low;
+
+ ts = current_kernel_time();
+ time = (CsrUint64) ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
+
+ if (high != NULL)
+ {
+ *high = (CsrTime) ((time >> 32) & 0xFFFFFFFF);
+ }
+
+ low = (CsrTime) (time & 0xFFFFFFFF);
+
+ return low;
+}
+EXPORT_SYMBOL_GPL(CsrTimeGet);
+
+void CsrTimeUtcGet(CsrTimeUtc *tod, CsrTime *low, CsrTime *high)
+{
+ struct timespec ts;
+ CsrUint64 time;
+
+ ts = current_kernel_time();
+ time = (CsrUint64) ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
+
+ if (high != NULL)
+ {
+ *high = (CsrTime) ((time >> 32) & 0xFFFFFFFF);
+ }
+
+ if (low != NULL)
+ {
+ *low = (CsrTime) (time & 0xFFFFFFFF);
+ }
+
+ if (tod != NULL)
+ {
+ struct timeval tv;
+ do_gettimeofday(&tv);
+ tod->sec = tv.tv_sec;
+ tod->msec = tv.tv_usec / 1000;
+ }
+}
--- /dev/null
+#ifndef CSR_TIME_H__
+#define CSR_TIME_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*******************************************************************************
+
+ NAME
+ CsrTime
+
+ DESCRIPTION
+ Type to hold a value describing the current system time, which is a
+ measure of time elapsed since some arbitrarily defined fixed time
+ reference, usually associated with system startup.
+
+*******************************************************************************/
+typedef CsrUint32 CsrTime;
+
+
+/*******************************************************************************
+
+ NAME
+ CsrTimeUtc
+
+ DESCRIPTION
+ Type to hold a value describing a UTC wallclock time expressed in
+ seconds and milliseconds elapsed since midnight January 1st 1970.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint32 sec;
+ CsrUint16 msec;
+} CsrTimeUtc;
+
+
+/*******************************************************************************
+
+ NAME
+ CsrTimeGet
+
+ DESCRIPTION
+ Returns the current system time in a low and a high part. The low part
+ is expressed in microseconds. The high part is incremented when the low
+ part wraps to provide an extended range.
+
+ The caller may provide a NULL pointer as the high parameter. In this case
+ the function just returns the low part and ignores the high parameter.
+
+ Although the time is expressed in microseconds the actual resolution is
+ platform dependent and can be less. It is recommended that the
+ resolution is at least 10 milliseconds.
+
+ PARAMETERS
+ high - Pointer to variable that will receive the high part of the
+ current system time. Passing NULL is valid.
+
+ RETURNS
+ Low part of current system time in microseconds.
+
+*******************************************************************************/
+CsrTime CsrTimeGet(CsrTime *high);
+
+
+/*******************************************************************************
+
+ NAME
+ CsrTimeUtcGet
+
+ DESCRIPTION
+ Get the current system wallclock time, and optionally the current system
+ time in a low and a high part as would have been returned by
+ CsrTimeGet.
+
+ Although CsrTimeUtc is expressed in seconds and milliseconds, the actual
+ resolution is platform dependent, and can be less. It is recommended
+ that the resolution is at least 1 second.
+
+ PARAMETERS
+ tod - Pointer to variable that will receive the current system
+ wallclock time.
+ low - The low part of the current system time in microseconds. Passing
+ NULL is valid.
+ high - The high part of the current system time in microseconds. Passing
+ NULL is valid.
+
+*******************************************************************************/
+void CsrTimeUtcGet(CsrTimeUtc *tod, CsrTime *low, CsrTime *high);
+
+
+/*------------------------------------------------------------------*/
+/* CsrTime Macros */
+/*------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrTimeAdd
+ *
+ * DESCRIPTION
+ * Add two time values. Adding the numbers can overflow the range of a
+ * CsrTime, so the user must be cautious.
+ *
+ * RETURNS
+ * CsrTime - the sum of "t1" and "t2".
+ *
+ *----------------------------------------------------------------------------*/
+#define CsrTimeAdd(t1, t2) ((t1) + (t2))
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrTimeSub
+ *
+ * DESCRIPTION
+ * Subtract two time values. Subtracting the numbers can provoke an
+ * underflow, so the user must be cautious.
+ *
+ * RETURNS
+ * CsrTime - "t1" - "t2".
+ *
+ *----------------------------------------------------------------------------*/
+#define CsrTimeSub(t1, t2) ((CsrInt32) (t1) - (CsrInt32) (t2))
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrTimeEq
+ *
+ * DESCRIPTION
+ * Compare two time values.
+ *
+ * RETURNS
+ * !0 if "t1" equal "t2", else 0.
+ *
+ *----------------------------------------------------------------------------*/
+#define CsrTimeEq(t1, t2) ((t1) == (t2))
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrTimeGt
+ *
+ * DESCRIPTION
+ * Compare two time values.
+ *
+ * RETURNS
+ * !0 if "t1" is greater than "t2", else 0.
+ *
+ *----------------------------------------------------------------------------*/
+#define CsrTimeGt(t1, t2) (CsrTimeSub((t1), (t2)) > 0)
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrTimeGe
+ *
+ * DESCRIPTION
+ * Compare two time values.
+ *
+ * RETURNS
+ * !0 if "t1" is greater than, or equal to "t2", else 0.
+ *
+ *----------------------------------------------------------------------------*/
+#define CsrTimeGe(t1, t2) (CsrTimeSub((t1), (t2)) >= 0)
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrTimeLt
+ *
+ * DESCRIPTION
+ * Compare two time values.
+ *
+ * RETURNS
+ * !0 if "t1" is less than "t2", else 0.
+ *
+ *----------------------------------------------------------------------------*/
+#define CsrTimeLt(t1, t2) (CsrTimeSub((t1), (t2)) < 0)
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrTimeLe
+ *
+ * DESCRIPTION
+ * Compare two time values.
+ *
+ * RETURNS
+ * !0 if "t1" is less than, or equal to "t2", else 0.
+ *
+ *----------------------------------------------------------------------------*/
+#define CsrTimeLe(t1, t2) (CsrTimeSub((t1), (t2)) <= 0)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_TYPES_H__
+#define CSR_TYPES_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifdef __KERNEL__
+#include <linux/stddef.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <asm/byteorder.h>
+#include <linux/string.h>
+#else
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+#include <stdarg.h>
+#include <string.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#undef FALSE
+#define FALSE (0)
+
+#undef TRUE
+#define TRUE (1)
+
+/* Basic types */
+typedef size_t CsrSize; /* Return type of sizeof (ISO/IEC 9899:1990 7.1.6) */
+typedef ptrdiff_t CsrPtrdiff; /* Type of the result of subtracting two pointers (ISO/IEC 9899:1990 7.1.6) */
+typedef uintptr_t CsrUintptr; /* Unsigned integer large enough to hold any pointer (ISO/IEC 9899:1999 7.18.1.4) */
+#ifdef __KERNEL__
+typedef ptrdiff_t CsrIntptr; /* intptr_t is not defined in kernel. Use the equivalent ptrdiff_t. */
+#else
+typedef intptr_t CsrIntptr; /* Signed integer large enough to hold any pointer (ISO/IEC 9899:1999 7.18.1.4) */
+#endif
+
+/* Unsigned fixed width types */
+typedef uint8_t CsrUint8;
+typedef uint16_t CsrUint16;
+typedef uint32_t CsrUint32;
+
+/* Signed fixed width types */
+typedef int8_t CsrInt8;
+typedef int16_t CsrInt16;
+typedef int32_t CsrInt32;
+
+/* Boolean */
+typedef CsrUint8 CsrBool;
+
+/* String types */
+typedef char CsrCharString;
+typedef CsrUint8 CsrUtf8String;
+typedef CsrUint16 CsrUtf16String; /* 16-bit UTF16 strings */
+typedef CsrUint32 CsrUint24;
+
+/*
+ * 64-bit integers
+ *
+ * Note: If a given compiler does not support 64-bit types, it is
+ * OK to omit these definitions; 32-bit versions of the code using
+ * these types may be available. Consult the relevant documentation
+ * or the customer support group for information on this.
+ */
+#define CSR_HAVE_64_BIT_INTEGERS
+typedef uint64_t CsrUint64;
+typedef int64_t CsrInt64;
+
+/*
+ * Floating point
+ *
+ * Note: If a given compiler does not support floating point, it is
+ * OK to omit these definitions; alternative versions of the code using
+ * these types may be available. Consult the relevant documentation
+ * or the customer support group for information on this.
+ */
+#define CSR_HAVE_FLOATING_POINT
+typedef float CsrFloat;
+typedef double CsrDouble;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef CSR_UNICODE_H__
+#define CSR_UNICODE_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+CsrUtf16String *CsrUint32ToUtf16String(CsrUint32 number);
+
+CsrUint32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString);
+CsrUint32 CsrUtf16StrLen(const CsrUtf16String *unicodeString);
+
+CsrUtf8String *CsrUtf16String2Utf8(const CsrUtf16String *source);
+
+CsrUtf16String *CsrUtf82Utf16String(const CsrUtf8String *utf8String);
+
+CsrUtf16String *CsrUtf16StrCpy(CsrUtf16String *target, const CsrUtf16String *source);
+CsrUtf16String *CsrUtf16StringDuplicate(const CsrUtf16String *source);
+
+CsrUint16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2);
+CsrUint16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count);
+
+CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, CsrUint32 count);
+CsrUtf16String *CsrUtf16ConcatenateTexts(const CsrUtf16String *inputText1, const CsrUtf16String *inputText2,
+ const CsrUtf16String *inputText3, const CsrUtf16String *inputText4);
+
+CsrUtf16String *CsrUtf16String2XML(CsrUtf16String *str);
+CsrUtf16String *CsrXML2Utf16String(CsrUtf16String *str);
+
+CsrInt32 CsrUtf8StrCmp(const CsrUtf8String *string1, const CsrUtf8String *string2);
+CsrInt32 CsrUtf8StrNCmp(const CsrUtf8String *string1, const CsrUtf8String *string2, CsrSize count);
+CsrUint32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string);
+
+/*******************************************************************************
+
+ NAME
+ CsrUtf8StrTruncate
+
+ DESCRIPTION
+ In-place truncate a string on a UTF-8 character boundary by writing a
+ null character somewhere in the range target[count - 3]:target[count].
+
+ Please note that memory passed must be at least of length count + 1, to
+ ensure space for a full length string that is terminated at
+ target[count], in the event that target[count - 1] is the final byte of
+ a UTF-8 character.
+
+ PARAMETERS
+ target - Target string to truncate.
+ count - The desired length, in bytes, of the resulting string. Depending
+ on the contents, the resulting string length will be between
+ count - 3 and count.
+
+ RETURNS
+ Returns target
+
+*******************************************************************************/
+CsrUtf8String *CsrUtf8StrTruncate(CsrUtf8String *target, CsrSize count);
+
+/*******************************************************************************
+
+ NAME
+ CsrUtf8StrCpy
+
+ DESCRIPTION
+ Copies the null terminated UTF-8 string pointed at by source into the
+ memory pointed at by target, including the terminating null character.
+
+ To avoid overflows, the size of the memory pointed at by target shall be
+ long enough to contain the same UTF-8 string as source (including the
+ terminating null character), and should not overlap in memory with
+ source.
+
+ PARAMETERS
+ target - Pointer to the target memory where the content is to be copied.
+ source - UTF-8 string to be copied.
+
+ RETURNS
+ Returns target
+
+*******************************************************************************/
+CsrUtf8String *CsrUtf8StrCpy(CsrUtf8String *target, const CsrUtf8String *source);
+
+/*******************************************************************************
+
+ NAME
+ CsrUtf8StrNCpy
+
+ DESCRIPTION
+ Copies the first count bytes of source to target. If the end of the
+ source UTF-8 string (which is signaled by a null-character) is found
+ before count bytes have been copied, target is padded with null
+ characters until a total of count bytes have been written to it.
+
+ No null-character is implicitly appended to the end of target, so target
+ will only be null-terminated if the length of the UTF-8 string in source
+ is less than count.
+
+ PARAMETERS
+ target - Pointer to the target memory where the content is to be copied.
+ source - UTF-8 string to be copied.
+ count - Maximum number of bytes to be written to target.
+
+ RETURNS
+ Returns target
+
+*******************************************************************************/
+CsrUtf8String *CsrUtf8StrNCpy(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count);
+
+/*******************************************************************************
+
+ NAME
+ CsrUtf8StrNCpyZero
+
+ DESCRIPTION
+ Equivalent to CsrUtf8StrNCpy, but if the length of source is equal to or
+ greater than count the target string is truncated on a UTF-8 character
+ boundary by writing a null character somewhere in the range
+ target[count - 4]:target[count - 1], leaving the target string
+ unconditionally null terminated in all cases.
+
+ Please note that if the length of source is shorter than count, no
+ truncation will be applied, and the target string will be a one to one
+ copy of source.
+
+ PARAMETERS
+ target - Pointer to the target memory where the content is to be copied.
+ source - UTF-8 string to be copied.
+ count - Maximum number of bytes to be written to target.
+
+ RETURNS
+ Returns target
+
+*******************************************************************************/
+CsrUtf8String *CsrUtf8StrNCpyZero(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count);
+
+/*******************************************************************************
+
+ NAME
+ CsrUtf8StrDup
+
+ DESCRIPTION
+ This function will allocate memory and copy the source string into the
+ allocated memory, which is then returned as a duplicate of the original
+ string. The memory returned must be freed by calling CsrPmemFree when
+ the duplicate is no longer needed.
+
+ PARAMETERS
+ source - UTF-8 string to be duplicated.
+
+ RETURNS
+ Returns a duplicate of source.
+
+*******************************************************************************/
+CsrUtf8String *CsrUtf8StrDup(const CsrUtf8String *source);
+
+CsrUtf8String *CsrUtf8StringConcatenateTexts(const CsrUtf8String *inputText1, const CsrUtf8String *inputText2, const CsrUtf8String *inputText3, const CsrUtf8String *inputText4);
+
+/*
+ * UCS2
+ *
+ * D-13157
+ */
+typedef CsrUint8 CsrUcs2String;
+
+CsrSize CsrUcs2ByteStrLen(const CsrUcs2String *ucs2String);
+CsrSize CsrConverterUcs2ByteStrLen(const CsrUcs2String *str);
+
+CsrUint8 *CsrUcs2ByteString2Utf8(const CsrUcs2String *ucs2String);
+CsrUcs2String *CsrUtf82Ucs2ByteString(const CsrUint8 *utf8String);
+
+CsrUint8 *CsrUtf16String2Ucs2ByteString(const CsrUtf16String *source);
+CsrUtf16String *CsrUcs2ByteString2Utf16String(const CsrUint8 *source);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+#include <linux/module.h>
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_unicode.h"
+#include "csr_util.h"
+
+#define UNI_SUR_HIGH_START ((CsrUint32) 0xD800)
+#define UNI_SUR_HIGH_END ((CsrUint32) 0xDBFF)
+#define UNI_SUR_LOW_START ((CsrUint32) 0xDC00)
+#define UNI_SUR_LOW_END ((CsrUint32) 0xDFFF)
+#define UNI_REPLACEMENT_CHAR ((CsrUint32) 0xFFFD)
+#define UNI_HALF_SHIFT ((CsrUint8) 10) /* used for shifting by 10 bits */
+#define UNI_HALF_BASE ((CsrUint32) 0x00010000)
+#define UNI_BYTEMASK ((CsrUint32) 0xBF)
+#define UNI_BYTEMARK ((CsrUint32) 0x80)
+
+#define CAPITAL(x) ((x >= 'a') && (x <= 'z') ? ((x) & 0x00DF) : (x))
+
+/*
+* Index into the table with the first byte to get the number of trailing bytes in a utf-8 character.
+* -1 if the byte has an invalid value.
+*
+* Legal sequences are:
+*
+* byte 1st 2nd 3rd 4th
+*
+* 00-7F
+* C2-DF 80-BF
+* E0 A0-BF 80-BF
+* E1-EC 80-BF 80-BF
+* ED 80-9F 80-BF
+* EE-EF 80-BF 80-BF
+* F0 90-BF 80-BF 80-BF
+* F1-F3 80-BF 80-BF 80-BF
+* F4 80-8F 80-BF 80-BF
+*/
+static const CsrInt8 trailingBytesForUtf8[256] =
+{
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 - 0x1F */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 - 0x3F */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 - 0x5F */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 - 0x7F */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x80 - 0x9F */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xA0 - 0xBF */
+ -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 0xC0 - 0xDF */
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0xE0 - 0xFF */
+};
+
+/* Values to be substracted from a CsrUint32 when converting from UTF8 to UTF16 */
+static const CsrUint32 offsetsFromUtf8[4] =
+{
+ 0x00000000, 0x00003080, 0x000E2080, 0x03C82080
+};
+
+/********************************************************************************
+*
+* Name: CsrUint32ToUtf16String
+*
+* Description: The function converts an 32 bit number to an UTF-16 string
+* that is allocated and 0-terminated.
+*
+* Input: 32 bit number.
+*
+* Output: A string of UTF-16 characters.
+*
+*********************************************************************************/
+CsrUtf16String *CsrUint32ToUtf16String(CsrUint32 number)
+{
+ CsrUint16 count, noOfDigits;
+ CsrUtf16String *output;
+ CsrUint32 tempNumber;
+
+ /* calculate the number of digits in the output */
+ tempNumber = number;
+ noOfDigits = 1;
+ while (tempNumber >= 10)
+ {
+ tempNumber = tempNumber / 10;
+ noOfDigits++;
+ }
+
+ output = (CsrUtf16String *) CsrPmemAlloc(sizeof(CsrUtf16String) * (noOfDigits + 1)); /*add space for 0-termination*/
+
+ tempNumber = number;
+ for (count = noOfDigits; count > 0; count--)
+ {
+ output[count - 1] = (CsrUtf16String) ((tempNumber % 10) + '0');
+ tempNumber = tempNumber / 10;
+ }
+ output[noOfDigits] = '\0';
+
+ return output;
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf16StringToUint32
+*
+* Description: The function converts an UTF-16 string that is
+* 0-terminated into a 32 bit number.
+*
+* Input: A string of UTF-16 characters containig a number.
+*
+* Output: 32 bit number.
+*
+*********************************************************************************/
+CsrUint32 CsrUtf16StringToUint32(const CsrUtf16String *unicodeString)
+{
+ CsrUint16 numLen, count;
+ CsrUint32 newNumber = 0;
+
+ numLen = (CsrUint16) CsrUtf16StrLen(unicodeString);
+
+ if ((numLen > 10) || (numLen == 0) || (unicodeString == NULL)) /*CSRMAX number is 4.294.967.295 */
+ {
+ return 0;
+ }
+
+ for (count = 0; count < numLen; count++)
+ {
+ CsrUtf16String input = unicodeString[count];
+ if ((input < 0x30) || (input > 0x39) || ((newNumber == 0x19999999) && (input > 0x35)) || (newNumber > 0x19999999)) /* chars are present or number is too large now causing number to get to large when *10 */
+ {
+ return 0;
+ }
+
+ newNumber = (newNumber * 10) + (input - 0x30);
+ }
+ return newNumber;
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf16MemCpy
+*
+* Description: The function copies count number of 16 bit data elements
+* from srv to dest.
+*
+* Input: A pointer to an unicoded string.
+*
+* Output: A pointer to an unicoded string.
+*
+*********************************************************************************/
+CsrUtf16String *CsrUtf16MemCpy(CsrUtf16String *dest, const CsrUtf16String *src, CsrUint32 count)
+{
+ return CsrMemCpy((CsrUint8 *) dest, (CsrUint8 *) src, count * sizeof(CsrUtf16String));
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf16ConcatenateTexts
+*
+* Description: The function merge the contents of 4 unicoded input pointers
+* into a new string.
+*
+* Input: 4 unicoded input strings (UTF-16).
+*
+* Output: A new unicoded string (UTF-16) containing the combined strings.
+*
+*********************************************************************************/
+CsrUtf16String *CsrUtf16ConcatenateTexts(const CsrUtf16String *inputText1, const CsrUtf16String *inputText2,
+ const CsrUtf16String *inputText3, const CsrUtf16String *inputText4)
+{
+ CsrUtf16String *outputText;
+ CsrUint32 textLen, textLen1, textLen2, textLen3, textLen4;
+
+ textLen1 = CsrUtf16StrLen(inputText1);
+ textLen2 = CsrUtf16StrLen(inputText2);
+ textLen3 = CsrUtf16StrLen(inputText3);
+ textLen4 = CsrUtf16StrLen(inputText4);
+
+ textLen = textLen1 + textLen2 + textLen3 + textLen4;
+
+ if (textLen == 0) /*stop here is all lengths are 0*/
+ {
+ return NULL;
+ }
+
+ outputText = (CsrUtf16String *) CsrPmemAlloc((textLen + 1) * sizeof(CsrUtf16String)); /* add space for 0-termination*/
+
+
+ if (inputText1 != NULL)
+ {
+ CsrUtf16MemCpy(outputText, inputText1, textLen1);
+ }
+
+ if (inputText2 != NULL)
+ {
+ CsrUtf16MemCpy(&(outputText[textLen1]), inputText2, textLen2);
+ }
+
+ if (inputText3 != NULL)
+ {
+ CsrUtf16MemCpy(&(outputText[textLen1 + textLen2]), inputText3, textLen3);
+ }
+
+ if (inputText4 != NULL)
+ {
+ CsrUtf16MemCpy(&(outputText[textLen1 + textLen2 + textLen3]), inputText4, textLen4);
+ }
+
+ outputText[textLen] = '\0';
+
+ return outputText;
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf16StrLen
+*
+* Description: The function returns the number of 16 bit elements present
+* in the 0-terminated string.
+*
+* Input: 0-terminated string of 16 bit unicoded characters.
+*
+* Output: The number of 16 bit elements in the string.
+*
+*********************************************************************************/
+CsrUint32 CsrUtf16StrLen(const CsrUtf16String *unicodeString)
+{
+ CsrUint32 length;
+
+ length = 0;
+ if (unicodeString != NULL)
+ {
+ while (*unicodeString)
+ {
+ length++;
+ unicodeString++;
+ }
+ }
+ return length;
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf16String2Utf8
+*
+* Description: The function decodes an UTF-16 string into an UTF8 byte
+* oriented string.
+*
+* Input: 0-terminated UTF-16 string characters.
+*
+* Output: 0-terminated string of byte oriented UTF8 coded characters.
+*
+*********************************************************************************/
+CsrUtf8String *CsrUtf16String2Utf8(const CsrUtf16String *source)
+{
+ CsrUtf8String *dest, *destStart = NULL;
+ CsrUint32 i;
+ CsrUint32 ch;
+ CsrUint32 length;
+ CsrUint32 sourceLength;
+ CsrUint8 bytes;
+ CsrBool appendNull = FALSE;
+
+ CsrUint8 firstByteMark[5] = {0x00, 0x00, 0xC0, 0xE0, 0xF0};
+
+ if (!source)
+ {
+ return NULL;
+ }
+
+ length = 0;
+ sourceLength = CsrUtf16StrLen(source) + 1;
+
+ for (i = 0; i < sourceLength; i++)
+ {
+ ch = source[i];
+ if ((ch >= UNI_SUR_HIGH_START) && (ch <= UNI_SUR_HIGH_END)) /* This is a high surrogate */
+ {
+ if (i + 1 < sourceLength) /* The low surrogate is in the source */
+ {
+ CsrUint32 ch2 = source[++i];
+ if ((ch2 >= UNI_SUR_LOW_START) && (ch2 <= UNI_SUR_LOW_END)) /* And it is a legal low surrogate */
+ {
+ length += 4;
+ }
+ else /* It is not a low surrogate, instead put a Unicode
+ 'REPLACEMENT CHARACTER' (U+FFFD) */
+ {
+ length += 3;
+ i--; /* Substract 1 again as the conversion must continue after the ill-formed code unit */
+ }
+ }
+ else /* The low surrogate does not exist, instead put a Unicode
+ 'REPLACEMENT CHARACTER' (U+FFFD), and the null terminated character */
+ {
+ length += 4;
+ }
+ }
+ else if ((ch >= UNI_SUR_LOW_START) && (ch <= UNI_SUR_LOW_END)) /* The value of UTF-16 is not allowed to be in this range, instead put
+ a Unicode 'REPLACEMENT CHARACTER' (U+FFFD) */
+ {
+ length += 3;
+ }
+ else /* Figure out how many bytes that are required */
+ {
+ if (ch < 0x0080)
+ {
+ length++;
+ }
+ else if (ch < 0x0800)
+ {
+ length += 2;
+ }
+ else
+ {
+ length += 3;
+ }
+ }
+ }
+
+ dest = CsrPmemAlloc(length);
+ destStart = dest;
+
+ for (i = 0; i < sourceLength; i++)
+ {
+ ch = source[i];
+ if ((ch >= UNI_SUR_HIGH_START) && (ch <= UNI_SUR_HIGH_END)) /* This is a high surrogate */
+ {
+ if (i + 1 < sourceLength) /* The low surrogate is in the source */
+ {
+ CsrUint32 ch2 = source[++i];
+ if ((ch2 >= UNI_SUR_LOW_START) && (ch2 <= UNI_SUR_LOW_END)) /* And it is a legal low surrogate, convert to UTF-32 */
+ {
+ ch = ((ch - UNI_SUR_HIGH_START) << UNI_HALF_SHIFT) + (ch2 - UNI_SUR_LOW_START) + UNI_HALF_BASE;
+ }
+ else /* It is not a low surrogate, instead put a Unicode
+ 'REPLACEMENT CHARACTER' (U+FFFD) */
+ {
+ ch = UNI_REPLACEMENT_CHAR;
+ i--; /* Substract 1 again as the conversion must continue after the ill-formed code unit */
+ }
+ }
+ else /* The low surrogate does not exist, instead put a Unicode
+ 'REPLACEMENT CHARACTER' (U+FFFD), and the null terminated character */
+ {
+ ch = UNI_REPLACEMENT_CHAR;
+ appendNull = TRUE;
+ }
+ }
+ else if ((ch >= UNI_SUR_LOW_START) && (ch <= UNI_SUR_LOW_END)) /* The value of UTF-16 is not allowed to be in this range, instead put
+ a Unicode 'REPLACEMENT CHARACTER' (U+FFFD) */
+ {
+ ch = UNI_REPLACEMENT_CHAR;
+ }
+
+ /* Figure out how many bytes that are required */
+ if (ch < (CsrUint32) 0x80)
+ {
+ bytes = 1;
+ }
+ else if (ch < (CsrUint32) 0x800)
+ {
+ bytes = 2;
+ }
+ else if (ch < (CsrUint32) 0x10000)
+ {
+ bytes = 3;
+ }
+ else if (ch < (CsrUint32) 0x110000)
+ {
+ bytes = 4;
+ }
+ else
+ {
+ bytes = 3;
+ ch = UNI_REPLACEMENT_CHAR;
+ }
+
+ dest += bytes;
+
+ switch (bytes) /* Convert character to UTF-8. Note: everything falls through. */
+ {
+ case 4:
+ {
+ *--dest = (CsrUint8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
+ ch >>= 6;
+ }
+ /* FALLTHROUGH */
+ case 3:
+ {
+ *--dest = (CsrUint8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
+ ch >>= 6;
+ }
+ /* FALLTHROUGH */
+ case 2:
+ {
+ *--dest = (CsrUint8) ((ch | UNI_BYTEMARK) & UNI_BYTEMASK);
+ ch >>= 6;
+ }
+ /* FALLTHROUGH */
+ case 1:
+ {
+ *--dest = (CsrUint8) (ch | firstByteMark[bytes]);
+ }
+ /* FALLTHROUGH */
+ default:
+ {
+ break;
+ }
+ }
+
+ dest += bytes;
+ }
+
+ if (appendNull) /* Append the \0 character */
+ {
+ *dest = '\0';
+ }
+
+ return destStart;
+}
+
+/*****************************************************************************
+
+ NAME
+ isLegalUtf8
+
+ DESCRIPTION
+ Returns TRUE if the given UFT-8 code unit is legal as defined by the
+ Unicode standard (see Chapter 3: Conformance, Section 3.9: Unicode
+ Encoding Forms, UTF-8).
+
+ This function assumes that the length parameter is unconditionally
+ correct and that the first byte is already validated by looking it up
+ in the trailingBytesForUtf8 array, which also reveals the number of
+ trailing bytes.
+
+ Legal code units are composed of one of the following byte sequences:
+
+ 1st 2nd 3rd 4th
+ --------------------------------
+ 00-7F
+ C2-DF 80-BF
+ E0 A0-BF 80-BF
+ E1-EC 80-BF 80-BF
+ ED 80-9F 80-BF
+ EE-EF 80-BF 80-BF
+ F0 90-BF 80-BF 80-BF
+ F1-F3 80-BF 80-BF 80-BF
+ F4 80-8F 80-BF 80-BF
+
+ Please note that this function only checks whether the 2nd, 3rd and
+ 4th bytes fall into the valid ranges.
+
+ PARAMETERS
+ codeUnit - pointer to the first byte of the byte sequence composing
+ the code unit to test.
+ length - the number of bytes in the code unit. Valid range is 1 to 4.
+
+ RETURNS
+ TRUE if the given code unit is legal.
+
+*****************************************************************************/
+static CsrBool isLegalUtf8(const CsrUtf8String *codeUnit, CsrUint32 length)
+{
+ const CsrUtf8String *srcPtr = codeUnit + length;
+ CsrUint8 byte;
+
+ switch (length) /* Everything falls through except case 1 */
+ {
+ case 4:
+ {
+ byte = *--srcPtr;
+ if ((byte < 0x80) || (byte > 0xBF))
+ {
+ return FALSE;
+ }
+ }
+ /* Fallthrough */
+ case 3:
+ {
+ byte = *--srcPtr;
+ if ((byte < 0x80) || (byte > 0xBF))
+ {
+ return FALSE;
+ }
+ }
+ /* Fallthrough */
+ case 2:
+ {
+ byte = *--srcPtr;
+ if (byte > 0xBF)
+ {
+ return FALSE;
+ }
+
+ switch (*codeUnit) /* No fallthrough */
+ {
+ case 0xE0:
+ {
+ if (byte < 0xA0)
+ {
+ return FALSE;
+ }
+ break;
+ }
+ case 0xED:
+ {
+ if ((byte < 0x80) || (byte > 0x9F))
+ {
+ return FALSE;
+ }
+ break;
+ }
+ case 0xF0:
+ {
+ if (byte < 0x90)
+ {
+ return FALSE;
+ }
+ break;
+ }
+ case 0xF4:
+ {
+ if ((byte < 0x80) || (byte > 0x8F))
+ {
+ return FALSE;
+ }
+ break;
+ }
+ default:
+ {
+ if (byte < 0x80)
+ {
+ return FALSE;
+ }
+ break;
+ }
+ }
+ }
+ /* Fallthrough */
+ case 1:
+ default:
+ /* The 1st byte and length are assumed correct */
+ break;
+ }
+
+ return TRUE;
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf82Utf16String
+*
+* Description: The function decodes an UTF8 byte oriented string into a
+* UTF-16string.
+*
+* Input: 0-terminated string of byte oriented UTF8 coded characters.
+*
+* Output: 0-terminated string of UTF-16 characters.
+*
+*********************************************************************************/
+CsrUtf16String *CsrUtf82Utf16String(const CsrUtf8String *utf8String)
+{
+ CsrSize i, length = 0;
+ CsrSize sourceLength;
+ CsrUtf16String *dest = NULL;
+ CsrUtf16String *destStart = NULL;
+ CsrInt8 extraBytes2Read;
+
+ if (!utf8String)
+ {
+ return NULL;
+ }
+ sourceLength = CsrStrLen((CsrCharString *) utf8String);
+
+ for (i = 0; i < sourceLength; i++)
+ {
+ extraBytes2Read = trailingBytesForUtf8[utf8String[i]];
+
+ if (extraBytes2Read == -1) /* Illegal byte value, instead put a Unicode 'REPLACEMENT CHARACTER' (U+FFFD) */
+ {
+ length += 1;
+ }
+ else if (i + extraBytes2Read > sourceLength) /* The extra bytes does not exist, instead put a Unicode 'REPLACEMENT
+ CHARACTER' (U+FFFD), and the null terminated character */
+ {
+ length += 2;
+ break;
+ }
+ else if (isLegalUtf8(&utf8String[i], extraBytes2Read + 1) == FALSE) /* It is not a legal utf-8 character, instead put a Unicode 'REPLACEMENT
+ CHARACTER' (U+FFFD) */
+ {
+ length += 1;
+ }
+ else
+ {
+ if (utf8String[i] > 0xEF) /* Needs a high and a low surrogate */
+ {
+ length += 2;
+ }
+ else
+ {
+ length += 1;
+ }
+ i += extraBytes2Read;
+ }
+ }
+
+ /* Create space for the null terminated character */
+ dest = (CsrUtf16String *) CsrPmemAlloc((1 + length) * sizeof(CsrUtf16String));
+ destStart = dest;
+
+ for (i = 0; i < sourceLength; i++)
+ {
+ extraBytes2Read = trailingBytesForUtf8[utf8String[i]];
+
+ if (extraBytes2Read == -1) /* Illegal byte value, instead put a Unicode 'REPLACEMENT CHARACTER' (U+FFFD) */
+ {
+ *dest++ = UNI_REPLACEMENT_CHAR;
+ }
+ else if (i + extraBytes2Read > sourceLength) /* The extra bytes does not exist, instead put a Unicode 'REPLACEMENT
+ CHARACTER' (U+FFFD), and the null terminated character */
+ {
+ *dest++ = UNI_REPLACEMENT_CHAR;
+ *dest++ = '\0';
+ break;
+ }
+ else if (isLegalUtf8(&utf8String[i], extraBytes2Read + 1) == FALSE) /* It is not a legal utf-8 character, instead put a Unicode 'REPLACEMENT
+ CHARACTER' (U+FFFD) */
+ {
+ *dest++ = UNI_REPLACEMENT_CHAR;
+ }
+ else /* It is legal, convert the character to an CsrUint32 */
+ {
+ CsrUint32 ch = 0;
+
+ switch (extraBytes2Read) /* Everything falls through */
+ {
+ case 3:
+ {
+ ch += utf8String[i];
+ ch <<= 6;
+ i++;
+ }
+ /* FALLTHROUGH */
+ case 2:
+ {
+ ch += utf8String[i];
+ ch <<= 6;
+ i++;
+ }
+ /* FALLTHROUGH */
+ case 1:
+ {
+ ch += utf8String[i];
+ ch <<= 6;
+ i++;
+ }
+ /* FALLTHROUGH */
+ case 0:
+ {
+ ch += utf8String[i];
+ }
+ /* FALLTHROUGH */
+ default:
+ {
+ break;
+ }
+ }
+
+ ch -= offsetsFromUtf8[extraBytes2Read];
+
+ if (ch <= 0xFFFF) /* Character can be encoded in one CsrUint16 */
+ {
+ *dest++ = (CsrUint16) ch;
+ }
+ else /* The character needs two CsrUint16 */
+ {
+ ch -= UNI_HALF_BASE;
+ *dest++ = (CsrUint16) ((ch >> UNI_HALF_SHIFT) | UNI_SUR_HIGH_START);
+ *dest++ = (CsrUint16) ((ch & 0x03FF) | UNI_SUR_LOW_START);
+ }
+ }
+ }
+
+ destStart[length] = 0x00;
+
+ return destStart;
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf16StrCpy
+*
+* Description: The function copies the contents from one UTF-16 string
+* to another UTF-16 string.
+*
+* Input: 0-terminated UTF-16 string.
+*
+* Output: 0-terminated UTF-16 string.
+*
+*********************************************************************************/
+CsrUtf16String *CsrUtf16StrCpy(CsrUtf16String *target, const CsrUtf16String *source)
+{
+ if (source) /* if source is not NULL*/
+ {
+ CsrMemCpy(target, source, (CsrUtf16StrLen(source) + 1) * sizeof(CsrUtf16String));
+ return target;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf16StringDuplicate
+*
+* Description: The function allocates a new pointer and copies the input to
+* the new pointer.
+*
+* Input: 0-terminated UTF-16 string.
+*
+* Output: Allocated variable0-terminated UTF-16 string.
+*
+*********************************************************************************/
+CsrUtf16String *CsrUtf16StringDuplicate(const CsrUtf16String *source)
+{
+ CsrUtf16String *target = NULL;
+ CsrUint32 length;
+
+ if (source) /* if source is not NULL*/
+ {
+ length = (CsrUtf16StrLen(source) + 1) * sizeof(CsrUtf16String);
+ target = (CsrUtf16String *) CsrPmemAlloc(length);
+ CsrMemCpy(target, source, length);
+ }
+ return target;
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf16StrICmp
+*
+* Description: The function compares two UTF-16 strings.
+*
+* Input: Two 0-terminated UTF-16 string.
+*
+* Output: 0: if the strings are identical.
+*
+*********************************************************************************/
+CsrUint16 CsrUtf16StrICmp(const CsrUtf16String *string1, const CsrUtf16String *string2)
+{
+ while (*string1 || *string2)
+ {
+ if (CAPITAL(*string1) != CAPITAL(*string2))
+ {
+ return *string1 - *string2;
+ }
+ string1++;
+ string2++;
+ }
+
+ return 0;
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf16StrNICmp
+*
+* Description: The function compares upto count number of elements in the
+* two UTF-16 string.
+*
+* Input: Two 0-terminated UTF-16 string and a maximum
+* number of elements to check.
+*
+* Output: 0: if the strings are identical.
+*
+*********************************************************************************/
+CsrUint16 CsrUtf16StrNICmp(const CsrUtf16String *string1, const CsrUtf16String *string2, CsrUint32 count)
+{
+ while ((*string1 || *string2) && count--)
+ {
+ if (CAPITAL(*string1) != CAPITAL(*string2))
+ {
+ return *string1 - *string2;
+ }
+ string1++;
+ string2++;
+ }
+
+ return 0;
+}
+
+/********************************************************************************
+*
+* Name: CsrUtf16String2XML
+*
+* Description: The function converts an unicoded string (UTF-16) into an unicoded XML
+* string where some special characters are encoded according to
+* the XML spec.
+*
+* Input: A unicoded string (UTF-16) which is freed.
+*
+* Output: A new unicoded string (UTF-16) containing the converted output.
+*
+*********************************************************************************/
+CsrUtf16String *CsrUtf16String2XML(CsrUtf16String *str)
+{
+ CsrUtf16String *scanString;
+ CsrUtf16String *outputString = NULL;
+ CsrUtf16String *resultString = str;
+ CsrUint32 stringLength = 0;
+ CsrBool encodeChars = FALSE;
+
+ scanString = str;
+ if (scanString)
+ {
+ while (*scanString)
+ {
+ if (*scanString == L'&')
+ {
+ stringLength += 5;
+ encodeChars = TRUE;
+ }
+ else if ((*scanString == L'<') || (*scanString == L'>'))
+ {
+ stringLength += 4;
+ encodeChars = TRUE;
+ }
+ else
+ {
+ stringLength++;
+ }
+
+ scanString++;
+ }
+
+ stringLength++;
+
+ if (encodeChars)
+ {
+ resultString = outputString = CsrPmemAlloc(stringLength * sizeof(CsrUtf16String));
+
+ scanString = str;
+
+ while (*scanString)
+ {
+ if (*scanString == L'&')
+ {
+ *outputString++ = '&';
+ *outputString++ = 'a';
+ *outputString++ = 'm';
+ *outputString++ = 'p';
+ *outputString++ = ';';
+ }
+ else if (*scanString == L'<')
+ {
+ *outputString++ = '&';
+ *outputString++ = 'l';
+ *outputString++ = 't';
+ *outputString++ = ';';
+ }
+ else if (*scanString == L'>')
+ {
+ *outputString++ = '&';
+ *outputString++ = 'g';
+ *outputString++ = 't';
+ *outputString++ = ';';
+ }
+ else
+ {
+ *outputString++ = *scanString;
+ }
+
+ scanString++;
+ }
+
+ *outputString++ = 0;
+
+ CsrPmemFree(str);
+ }
+ }
+
+ return resultString;
+}
+
+/********************************************************************************
+*
+* Name: CsrXML2Utf16String
+*
+* Description: The function converts an unicoded XML string into an unicoded
+* string (UTF-16) where some special XML characters are decoded according to
+* the XML spec.
+*
+* Input: A unicoded XML string which is freed.
+*
+* Output: A new unicoded pointer containing the decoded output.
+*
+*********************************************************************************/
+CsrUtf16String *CsrXML2Utf16String(CsrUtf16String *str)
+{
+ CsrUtf16String *scanString;
+ CsrUtf16String *outputString = NULL;
+ CsrUtf16String *resultString = str;
+ CsrUint32 stringLength = 0;
+ CsrBool encodeChars = FALSE;
+
+ scanString = str;
+ if (scanString)
+ {
+ while (*scanString)
+ {
+ if (*scanString == (CsrUtf16String) L'&')
+ {
+ scanString++;
+
+ if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"AMP;", 4))
+ {
+ scanString += 3;
+ encodeChars = TRUE;
+ }
+ else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"LT;", 3))
+ {
+ scanString += 2;
+ encodeChars = TRUE;
+ }
+ else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"GT;", 3))
+ {
+ scanString += 2;
+ encodeChars = TRUE;
+ }
+ if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"APOS;", 5))
+ {
+ scanString += 4;
+ encodeChars = TRUE;
+ }
+ if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"QUOT;", 5))
+ {
+ scanString += 4;
+ encodeChars = TRUE;
+ }
+ else
+ {
+ scanString--;
+ }
+ }
+
+ stringLength++;
+ scanString++;
+ }
+
+ stringLength++;
+
+ if (encodeChars)
+ {
+ resultString = outputString = CsrPmemAlloc(stringLength * sizeof(CsrUtf16String));
+
+ scanString = str;
+
+ while (*scanString)
+ {
+ if (*scanString == L'&')
+ {
+ scanString++;
+
+ if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"AMP;", 4))
+ {
+ *outputString++ = L'&';
+ scanString += 3;
+ }
+ else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"LT;", 3))
+ {
+ *outputString++ = L'<';
+ scanString += 2;
+ }
+ else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"GT;", 3))
+ {
+ *outputString++ = L'>';
+ scanString += 2;
+ }
+ else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"APOS;", 5))
+ {
+ *outputString++ = L'\'';
+ scanString += 4;
+ }
+ else if (!CsrUtf16StrNICmp(scanString, (CsrUtf16String *) L"QUOT;", 5))
+ {
+ *outputString++ = L'\"';
+ scanString += 4;
+ }
+ else
+ {
+ *outputString++ = L'&';
+ scanString--;
+ }
+ }
+ else
+ {
+ *outputString++ = *scanString;
+ }
+
+ scanString++;
+ }
+
+ *outputString++ = 0;
+
+ CsrPmemFree(str);
+ }
+ }
+
+ return resultString;
+}
+
+CsrInt32 CsrUtf8StrCmp(const CsrUtf8String *string1, const CsrUtf8String *string2)
+{
+ return CsrStrCmp((const CsrCharString *) string1, (const CsrCharString *) string2);
+}
+
+CsrInt32 CsrUtf8StrNCmp(const CsrUtf8String *string1, const CsrUtf8String *string2, CsrSize count)
+{
+ return CsrStrNCmp((const CsrCharString *) string1, (const CsrCharString *) string2, count);
+}
+
+CsrUint32 CsrUtf8StringLengthInBytes(const CsrUtf8String *string)
+{
+ CsrSize length = 0;
+ if (string)
+ {
+ length = CsrStrLen((const CsrCharString *) string);
+ }
+ return (CsrUint32) length;
+}
+
+CsrUtf8String *CsrUtf8StrCpy(CsrUtf8String *target, const CsrUtf8String *source)
+{
+ return (CsrUtf8String *) CsrStrCpy((CsrCharString *) target, (const CsrCharString *) source);
+}
+
+CsrUtf8String *CsrUtf8StrTruncate(CsrUtf8String *target, CsrSize count)
+{
+ CsrSize lastByte = count - 1;
+
+ target[count] = '\0';
+
+ if (count && (target[lastByte] & 0x80))
+ {
+ /* the last byte contains non-ascii char */
+ if (target[lastByte] & 0x40)
+ {
+ /* multi-byte char starting just before truncation */
+ target[lastByte] = '\0';
+ }
+ else if ((target[lastByte - 1] & 0xE0) == 0xE0)
+ {
+ /* 3-byte char starting 2 bytes before truncation */
+ target[lastByte - 1] = '\0';
+ }
+ else if ((target[lastByte - 2] & 0xF0) == 0xF0)
+ {
+ /* 4-byte char starting 3 bytes before truncation */
+ target[lastByte - 2] = '\0';
+ }
+ }
+
+ return target;
+}
+
+CsrUtf8String *CsrUtf8StrNCpy(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count)
+{
+ return (CsrUtf8String *) CsrStrNCpy((CsrCharString *) target, (const CsrCharString *) source, count);
+}
+
+CsrUtf8String *CsrUtf8StrNCpyZero(CsrUtf8String *target, const CsrUtf8String *source, CsrSize count)
+{
+ CsrStrNCpy((CsrCharString *) target, (const CsrCharString *) source, count);
+ if (target[count - 1] != '\0')
+ {
+ CsrUtf8StrTruncate(target, count - 1);
+ }
+ return target;
+}
+
+CsrUtf8String *CsrUtf8StrDup(const CsrUtf8String *source)
+{
+ return (CsrUtf8String *) CsrStrDup((const CsrCharString *) source);
+}
+
+CsrUtf8String *CsrUtf8StringConcatenateTexts(const CsrUtf8String *inputText1, const CsrUtf8String *inputText2, const CsrUtf8String *inputText3, const CsrUtf8String *inputText4)
+{
+ CsrUtf8String *outputText;
+ CsrUint32 textLen, textLen1, textLen2, textLen3, textLen4;
+
+ textLen1 = CsrUtf8StringLengthInBytes(inputText1);
+ textLen2 = CsrUtf8StringLengthInBytes(inputText2);
+ textLen3 = CsrUtf8StringLengthInBytes(inputText3);
+ textLen4 = CsrUtf8StringLengthInBytes(inputText4);
+
+ textLen = textLen1 + textLen2 + textLen3 + textLen4;
+
+ if (textLen == 0) /*stop here is all lengths are 0*/
+ {
+ return NULL;
+ }
+
+ outputText = (CsrUtf8String *) CsrPmemAlloc((textLen + 1) * sizeof(CsrUtf8String)); /* add space for 0-termination*/
+
+
+ if (inputText1 != NULL)
+ {
+ CsrUtf8StrNCpy(outputText, inputText1, textLen1);
+ }
+
+ if (inputText2 != NULL)
+ {
+ CsrUtf8StrNCpy(&(outputText[textLen1]), inputText2, textLen2);
+ }
+
+ if (inputText3 != NULL)
+ {
+ CsrUtf8StrNCpy(&(outputText[textLen1 + textLen2]), inputText3, textLen3);
+ }
+
+ if (inputText4 != NULL)
+ {
+ CsrUtf8StrNCpy(&(outputText[textLen1 + textLen2 + textLen3]), inputText4, textLen4);
+ }
+
+ outputText[textLen] = '\0';
+
+ return outputText;
+}
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <stdarg.h>
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_util.h"
+
+/*------------------------------------------------------------------*/
+/* Bits */
+/*------------------------------------------------------------------*/
+
+/* Time proportional with the number of 1's */
+CsrUint8 CsrBitCountSparse(CsrUint32 n)
+{
+ CsrUint8 count = 0;
+
+ while (n)
+ {
+ count++;
+ n &= (n - 1);
+ }
+
+ return count;
+}
+
+/* Time proportional with the number of 0's */
+CsrUint8 CsrBitCountDense(CsrUint32 n)
+{
+ CsrUint8 count = 8 * sizeof(CsrUint32);
+
+ n ^= (CsrUint32) (-1);
+
+ while (n)
+ {
+ count--;
+ n &= (n - 1);
+ }
+
+ return count;
+}
+
+/*------------------------------------------------------------------*/
+/* Base conversion */
+/*------------------------------------------------------------------*/
+CsrBool CsrHexStrToUint8(const CsrCharString *string, CsrUint8 *returnValue)
+{
+ CsrUint16 currentIndex = 0;
+ *returnValue = 0;
+ if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
+ {
+ string += 2;
+ }
+ if (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
+ {
+ while (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
+ {
+ *returnValue = (CsrUint8) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
+ currentIndex++;
+ if (currentIndex >= 2)
+ {
+ break;
+ }
+ }
+ return TRUE;
+ }
+ return FALSE;
+}
+
+CsrBool CsrHexStrToUint16(const CsrCharString *string, CsrUint16 *returnValue)
+{
+ CsrUint16 currentIndex = 0;
+ *returnValue = 0;
+ if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
+ {
+ string += 2;
+ }
+ if (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
+ {
+ while (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
+ {
+ *returnValue = (CsrUint16) (*returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10));
+ currentIndex++;
+ if (currentIndex >= 4)
+ {
+ break;
+ }
+ }
+ return TRUE;
+ }
+ return FALSE;
+}
+
+CsrBool CsrHexStrToUint32(const CsrCharString *string, CsrUint32 *returnValue)
+{
+ CsrUint16 currentIndex = 0;
+ *returnValue = 0;
+ if ((string[currentIndex] == '0') && (CSR_TOUPPER(string[currentIndex + 1]) == 'X'))
+ {
+ string += 2;
+ }
+ if (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
+ {
+ while (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) || ((CSR_TOUPPER(string[currentIndex]) >= 'A') && (CSR_TOUPPER(string[currentIndex]) <= 'F')))
+ {
+ *returnValue = *returnValue * 16 + (((string[currentIndex] >= '0') && (string[currentIndex] <= '9')) ? string[currentIndex] - '0' : CSR_TOUPPER(string[currentIndex]) - 'A' + 10);
+ currentIndex++;
+ if (currentIndex >= 8)
+ {
+ break;
+ }
+ }
+ return TRUE;
+ }
+ return FALSE;
+}
+
+CsrUint32 CsrPow(CsrUint32 base, CsrUint32 exponent)
+{
+ if (exponent == 0)
+ {
+ return 1;
+ }
+ else
+ {
+ CsrUint32 i, t = base;
+
+ for (i = 1; i < exponent; i++)
+ {
+ t = t * base;
+ }
+ return t;
+ }
+}
+
+/* Convert signed 32 bit (or less) integer to string */
+#define I2B10_MAX 12
+void CsrIntToBase10(CsrInt32 number, CsrCharString *str)
+{
+ CsrInt32 digit;
+ CsrUint8 index;
+ CsrCharString res[I2B10_MAX];
+ CsrBool foundDigit = FALSE;
+
+ for (digit = 0; digit < I2B10_MAX; digit++)
+ {
+ res[digit] = '\0';
+ }
+
+ /* Catch sign - and deal with positive numbers only afterwards */
+ index = 0;
+ if (number < 0)
+ {
+ res[index++] = '-';
+ number = -1 * number;
+ }
+
+ digit = 1000000000;
+ if (number > 0)
+ {
+ while ((index < I2B10_MAX - 1) && (digit > 0))
+ {
+ /* If the foundDigit flag is TRUE, this routine should be proceeded.
+ Otherwise the number which has '0' digit cannot be converted correctly */
+ if (((number / digit) > 0) || foundDigit)
+ {
+ foundDigit = TRUE; /* set foundDigit flag to TRUE*/
+ res[index++] = (char) ('0' + (number / digit));
+ number = number % digit;
+ }
+
+ digit = digit / 10;
+ }
+ }
+ else
+ {
+ res[index] = (char) '0';
+ }
+
+ CsrStrCpy(str, res);
+}
+
+void CsrUInt16ToHex(CsrUint16 number, CsrCharString *str)
+{
+ CsrUint16 index;
+ CsrUint16 currentValue;
+
+ for (index = 0; index < 4; index++)
+ {
+ currentValue = (CsrUint16) (number & 0x000F);
+ number >>= 4;
+ str[3 - index] = (char) (currentValue > 9 ? currentValue + 55 : currentValue + '0');
+ }
+ str[4] = '\0';
+}
+
+void CsrUInt32ToHex(CsrUint32 number, CsrCharString *str)
+{
+ CsrUint16 index;
+ CsrUint32 currentValue;
+
+ for (index = 0; index < 8; index++)
+ {
+ currentValue = (CsrUint32) (number & 0x0000000F);
+ number >>= 4;
+ str[7 - index] = (char) (currentValue > 9 ? currentValue + 55 : currentValue + '0');
+ }
+ str[8] = '\0';
+}
+
+/*------------------------------------------------------------------*/
+/* String */
+/*------------------------------------------------------------------*/
+#ifndef CSR_USE_STDC_LIB
+void *CsrMemCpy(void *dest, const void *src, CsrSize count)
+{
+ return memcpy(dest, src, count);
+}
+EXPORT_SYMBOL_GPL(CsrMemCpy);
+
+void *CsrMemSet(void *dest, CsrUint8 c, CsrSize count)
+{
+ return memset(dest, c, count);
+}
+EXPORT_SYMBOL_GPL(CsrMemSet);
+
+void *CsrMemMove(void *dest, const void *src, CsrSize count)
+{
+ return memmove(dest, src, count);
+}
+EXPORT_SYMBOL_GPL(CsrMemMove);
+
+CsrInt32 CsrMemCmp(const void *buf1, const void *buf2, CsrSize count)
+{
+ return memcmp(buf1, buf2, count);
+}
+EXPORT_SYMBOL_GPL(CsrMemCmp);
+
+void *CsrMemDup(const void *buf1, CsrSize count)
+{
+ void *buf2 = NULL;
+
+ if (buf1)
+ {
+ buf2 = CsrPmemAlloc(count);
+ CsrMemCpy(buf2, buf1, count);
+ }
+
+ return buf2;
+}
+#endif
+
+#ifndef CSR_USE_STDC_LIB
+CsrCharString *CsrStrCpy(CsrCharString *dest, const CsrCharString *src)
+{
+ return strcpy(dest, src);
+}
+
+CsrCharString *CsrStrNCpy(CsrCharString *dest, const CsrCharString *src, CsrSize count)
+{
+ return strncpy(dest, src, count);
+}
+
+CsrCharString *CsrStrCat(CsrCharString *dest, const CsrCharString *src)
+{
+ return strcat(dest, src);
+}
+
+CsrCharString *CsrStrNCat(CsrCharString *dest, const CsrCharString *src, CsrSize count)
+{
+ return strncat(dest, src, count);
+}
+
+CsrCharString *CsrStrStr(const CsrCharString *string1, const CsrCharString *string2)
+{
+ return strstr(string1, string2);
+}
+
+CsrSize CsrStrLen(const CsrCharString *string)
+{
+ return strlen(string);
+}
+EXPORT_SYMBOL_GPL(CsrStrLen);
+
+CsrInt32 CsrStrCmp(const CsrCharString *string1, const CsrCharString *string2)
+{
+ return strcmp(string1, string2);
+}
+
+CsrInt32 CsrStrNCmp(const CsrCharString *string1, const CsrCharString *string2, CsrSize count)
+{
+ return strncmp(string1, string2, count);
+}
+
+CsrCharString *CsrStrChr(const CsrCharString *string, CsrCharString c)
+{
+ return strchr(string, c);
+}
+#endif
+
+CsrInt32 CsrVsnprintf(CsrCharString *string, CsrSize count, const CsrCharString *format, va_list args)
+{
+ return vsnprintf(string, count, format, args);
+}
+EXPORT_SYMBOL_GPL(CsrVsnprintf);
+
+CsrCharString *CsrStrNCpyZero(CsrCharString *dest,
+ const CsrCharString *src,
+ CsrSize count)
+{
+ CsrStrNCpy(dest, src, count - 1);
+ dest[count - 1] = '\0';
+ return dest;
+}
+
+/* Convert string with base 10 to integer */
+CsrUint32 CsrStrToInt(const CsrCharString *str)
+{
+ CsrInt16 i;
+ CsrUint32 res;
+ CsrUint32 digit;
+
+ res = 0;
+ digit = 1;
+
+ /* Start from the string end */
+ for (i = (CsrUint16) (CsrStrLen(str) - 1); i >= 0; i--)
+ {
+ /* Only convert numbers */
+ if ((str[i] >= '0') && (str[i] <= '9'))
+ {
+ res += digit * (str[i] - '0');
+ digit = digit * 10;
+ }
+ }
+
+ return res;
+}
+
+CsrCharString *CsrStrDup(const CsrCharString *string)
+{
+ CsrCharString *copy;
+ CsrUint32 len;
+
+ copy = NULL;
+ if (string != NULL)
+ {
+ len = CsrStrLen(string) + 1;
+ copy = CsrPmemAlloc(len);
+ CsrMemCpy(copy, string, len);
+ }
+ return copy;
+}
+
+int CsrStrNICmp(const CsrCharString *string1,
+ const CsrCharString *string2,
+ CsrSize count)
+{
+ CsrUint32 index;
+ int returnValue = 0;
+
+ for (index = 0; index < count; index++)
+ {
+ if (CSR_TOUPPER(string1[index]) != CSR_TOUPPER(string2[index]))
+ {
+ if (CSR_TOUPPER(string1[index]) > CSR_TOUPPER(string2[index]))
+ {
+ returnValue = 1;
+ }
+ else
+ {
+ returnValue = -1;
+ }
+ break;
+ }
+ if (string1[index] == '\0')
+ {
+ break;
+ }
+ }
+ return returnValue;
+}
+
+const CsrCharString *CsrGetBaseName(const CsrCharString *file)
+{
+ const CsrCharString *pch;
+ static const CsrCharString dotDir[] = ".";
+
+ if (!file)
+ {
+ return NULL;
+ }
+
+ if (file[0] == '\0')
+ {
+ return dotDir;
+ }
+
+ pch = file + CsrStrLen(file) - 1;
+
+ while (*pch != '\\' && *pch != '/' && *pch != ':')
+ {
+ if (pch == file)
+ {
+ return pch;
+ }
+ --pch;
+ }
+
+ return ++pch;
+}
+
+/*------------------------------------------------------------------*/
+/* Misc */
+/*------------------------------------------------------------------*/
+CsrBool CsrIsSpace(CsrUint8 c)
+{
+ switch (c)
+ {
+ case '\t':
+ case '\n':
+ case '\f':
+ case '\r':
+ case ' ':
+ return TRUE;
+ default:
+ return FALSE;
+ }
+}
+
+MODULE_DESCRIPTION("CSR Operating System Kernel Abstraction");
+MODULE_AUTHOR("Cambridge Silicon Radio Ltd.");
+MODULE_LICENSE("GPL and additional rights");
--- /dev/null
+#ifndef CSR_UTIL_H__
+#define CSR_UTIL_H__
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csr_types.h"
+#include "csr_macro.h"
+
+/*------------------------------------------------------------------*/
+/* Bits - intended to operate on CsrUint32 values */
+/*------------------------------------------------------------------*/
+CsrUint8 CsrBitCountSparse(CsrUint32 n);
+CsrUint8 CsrBitCountDense(CsrUint32 n);
+
+/*------------------------------------------------------------------*/
+/* Base conversion */
+/*------------------------------------------------------------------*/
+CsrBool CsrHexStrToUint8(const CsrCharString *string, CsrUint8 *returnValue);
+CsrBool CsrHexStrToUint16(const CsrCharString *string, CsrUint16 *returnValue);
+CsrBool CsrHexStrToUint32(const CsrCharString *string, CsrUint32 *returnValue);
+CsrUint32 CsrPow(CsrUint32 base, CsrUint32 exponent);
+void CsrIntToBase10(CsrInt32 number, CsrCharString *str);
+void CsrUInt16ToHex(CsrUint16 number, CsrCharString *str);
+void CsrUInt32ToHex(CsrUint32 number, CsrCharString *str);
+
+/*------------------------------------------------------------------*/
+/* Standard C Library functions */
+/*------------------------------------------------------------------*/
+#ifdef CSR_USE_STDC_LIB
+#define CsrMemCpy memcpy
+#define CsrMemMove memmove
+#define CsrStrCpy strcpy
+#define CsrStrNCpy strncpy
+#define CsrStrCat strcat
+#define CsrStrNCat strncat
+#define CsrMemCmp(s1, s2, n) ((CsrInt32) memcmp((s1), (s2), (n)))
+#define CsrStrCmp(s1, s2) ((CsrInt32) strcmp((s1), (s2)))
+#define CsrStrNCmp(s1, s2, n) ((CsrInt32) strncmp((s1), (s2), (n)))
+/*#define CsrMemChr memchr*/
+#define CsrStrChr strchr
+/*#define CsrStrCSpn strcspn*/
+/*#define CsrStrPBrk strpbrk*/
+/*#define CsrStrRChr strrchr*/
+/*#define CsrStrSpn strspn*/
+#define CsrStrStr strstr
+/*#define CsrStrTok strtok*/
+#define CsrMemSet memset
+#define CsrStrLen strlen
+/*#define CsrVsnprintf(s, n, format, arg) ((CsrInt32) vsnprintf((s), (n), (format), (arg)))*/
+#else /* !CSR_USE_STDC_LIB */
+void *CsrMemCpy(void *dest, const void *src, CsrSize count);
+void *CsrMemMove(void *dest, const void *src, CsrSize count);
+CsrCharString *CsrStrCpy(CsrCharString *dest, const CsrCharString *src);
+CsrCharString *CsrStrNCpy(CsrCharString *dest, const CsrCharString *src, CsrSize count);
+CsrCharString *CsrStrCat(CsrCharString *dest, const CsrCharString *src);
+CsrCharString *CsrStrNCat(CsrCharString *dest, const CsrCharString *src, CsrSize count);
+CsrInt32 CsrMemCmp(const void *buf1, const void *buf2, CsrSize count);
+CsrInt32 CsrStrCmp(const CsrCharString *string1, const CsrCharString *string2);
+CsrInt32 CsrStrNCmp(const CsrCharString *string1, const CsrCharString *string2, CsrSize count);
+CsrCharString *CsrStrChr(const CsrCharString *string, CsrCharString c);
+CsrCharString *CsrStrStr(const CsrCharString *string1, const CsrCharString *string2);
+void *CsrMemSet(void *dest, CsrUint8 c, CsrSize count);
+CsrSize CsrStrLen(const CsrCharString *string);
+#endif /* !CSR_USE_STDC_LIB */
+CsrInt32 CsrVsnprintf(CsrCharString *string, CsrSize count, const CsrCharString *format, va_list args);
+
+/*------------------------------------------------------------------*/
+/* Non-standard utility functions */
+/*------------------------------------------------------------------*/
+void *CsrMemDup(const void *buf1, CsrSize count);
+int CsrStrNICmp(const CsrCharString *string1, const CsrCharString *string2, CsrSize count);
+CsrCharString *CsrStrDup(const CsrCharString *string);
+CsrUint32 CsrStrToInt(const CsrCharString *string);
+CsrCharString *CsrStrNCpyZero(CsrCharString *dest, const CsrCharString *src, CsrSize count);
+
+/*------------------------------------------------------------------*/
+/* Filename */
+/*------------------------------------------------------------------*/
+const CsrCharString *CsrGetBaseName(const CsrCharString *file);
+
+/*------------------------------------------------------------------*/
+/* Misc */
+/*------------------------------------------------------------------*/
+CsrBool CsrIsSpace(CsrUint8 c);
+#define CsrOffsetOf(st, m) ((CsrSize) & ((st *) 0)->m)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifndef CSR_WIFI_COMMON_H__
+#define CSR_WIFI_COMMON_H__
+
+#include "csr_types.h"
+#include "csr_result.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* MAC address */
+typedef struct
+{
+ CsrUint8 a[6];
+} CsrWifiMacAddress;
+
+/* IPv4 address */
+typedef struct
+{
+ CsrUint8 a[4];
+} CsrWifiIp4Address;
+
+/* IPv6 address */
+typedef struct
+{
+ CsrUint8 a[16];
+} CsrWifiIp6Address;
+
+typedef struct
+{
+ CsrUint8 ssid[32];
+ CsrUint8 length;
+} CsrWifiSsid;
+
+/*******************************************************************************
+
+ DESCRIPTION
+ Result values used on the Wifi Interfaces
+
+ VALUES
+ CSR_RESULT_SUCCESS
+ - The request/procedure succeeded
+ CSR_RESULT_FAILURE
+ - The request/procedure did not succeed because of an error
+ CSR_WIFI_RESULT_NOT_FOUND
+ - The request did not succeed because some resource was not
+ found.
+ CSR_WIFI_RESULT_TIMED_OUT
+ - The request/procedure did not succeed because of a time out
+ CSR_WIFI_RESULT_CANCELLED
+ - The request was canceled due to another conflicting
+ request that was issued before this one was completed
+ CSR_WIFI_RESULT_INVALID_PARAMETER
+ - The request/procedure did not succeed because it had an
+ invalid parameter
+ CSR_WIFI_RESULT_NO_ROOM
+ - The request did not succeed due to a lack of resources,
+ e.g. out of memory problem.
+ CSR_WIFI_RESULT_UNSUPPORTED
+ - The request/procedure did not succeed because the feature
+ is not supported yet
+ CSR_WIFI_RESULT_UNAVAILABLE
+ - The request cannot be processed at this time
+ CSR_WIFI_RESULT_WIFI_OFF
+ - The requested action is not available because Wi-Fi is
+ currently off
+ CSR_WIFI_RESULT_SECURITY_ERROR
+ - The request/procedure did not succeed because of a security
+ error
+ CSR_WIFI_RESULT_MIB_SET_FAILURE
+ - MIB Set Failure: either the MIB OID to be written to does
+ not exist or the MIB Value is invalid.
+ CSR_WIFI_RESULT_INVALID_INTERFACE_TAG
+ - The supplied Interface Tag is not valid.
+ CSR_WIFI_RESULT_P2P_NOA_CONFIG_CONFLICT
+ - The new NOA configuration conflicts with the existing NOA configuration
+ hence not accepted"
+*******************************************************************************/
+#define CSR_WIFI_RESULT_NOT_FOUND ((CsrResult) 0x0001)
+#define CSR_WIFI_RESULT_TIMED_OUT ((CsrResult) 0x0002)
+#define CSR_WIFI_RESULT_CANCELLED ((CsrResult) 0x0003)
+#define CSR_WIFI_RESULT_INVALID_PARAMETER ((CsrResult) 0x0004)
+#define CSR_WIFI_RESULT_NO_ROOM ((CsrResult) 0x0005)
+#define CSR_WIFI_RESULT_UNSUPPORTED ((CsrResult) 0x0006)
+#define CSR_WIFI_RESULT_UNAVAILABLE ((CsrResult) 0x0007)
+#define CSR_WIFI_RESULT_WIFI_OFF ((CsrResult) 0x0008)
+#define CSR_WIFI_RESULT_SECURITY_ERROR ((CsrResult) 0x0009)
+#define CSR_WIFI_RESULT_MIB_SET_FAILURE ((CsrResult) 0x000A)
+#define CSR_WIFI_RESULT_INVALID_INTERFACE_TAG ((CsrResult) 0x000B)
+#define CSR_WIFI_RESULT_P2P_NOA_CONFIG_CONFLICT ((CsrResult) 0x000C)
+
+#define CSR_WIFI_VERSION "5.1.0.0"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifndef CSR_WIFI_FSM_H
+#define CSR_WIFI_FSM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_prim_defs.h"
+#include "csr_log_text.h"
+#include "csr_wifi_fsm_event.h"
+
+/* including this file for CsrWifiInterfaceMode*/
+#include "csr_wifi_common.h"
+
+#define CSR_WIFI_FSM_ENV (0xFFFF)
+
+/**
+ * @brief
+ * Toplevel FSM context data
+ *
+ * @par Description
+ * Holds ALL FSM static and dynamic data for a FSM
+ */
+typedef struct CsrWifiFsmContext CsrWifiFsmContext;
+
+/**
+ * @brief
+ * FSM External Wakeup CallbackFunction Pointer
+ *
+ * @par Description
+ * Defines the external wakeup function for the FSM
+ * to call when an external event is injected into the systen
+ *
+ * @param[in] context : External context
+ *
+ * @return
+ * void
+ */
+typedef void (*CsrWifiFsmExternalWakupCallbackPtr)(void *context);
+
+/**
+ * @brief
+ * Initialises a top level FSM context
+ *
+ * @par Description
+ * Initialises the FSM Context to an initial state and allocates
+ * space for "maxProcesses" number of instances
+ *
+ * @param[in] osaContext : OSA context
+ * @param[in] applicationContext : Internal fsm application context
+ * @param[in] externalContext : External context
+ * @param[in] maxProcesses : Max processes to allocate room for
+ *
+ * @return
+ * CsrWifiFsmContext* fsm context
+ */
+extern CsrWifiFsmContext* CsrWifiFsmInit(void *applicationContext, void *externalContext, CsrUint16 maxProcesses, CsrLogTextTaskId loggingTaskId);
+
+/**
+ * @brief
+ * Resets the FSM's back to first conditions
+ *
+ * @par Description
+ * This function is used to free any dynamic resources allocated for the
+ * given context by CsrWifiFsmInit().
+ * The FSM's reset function is called to cleanup any fsm specific memory
+ * The reset funtion does NOT need to free the fsm data pointer as
+ * CsrWifiFsmShutdown() will do it.
+ * the FSM's init function is call again to reinitialise the FSM context.
+ * CsrWifiFsmReset() should NEVER be called when CsrWifiFsmExecute() is running.
+ *
+ * @param[in] context : FSM context
+ *
+ * @return
+ * void
+ */
+extern void CsrWifiFsmReset(CsrWifiFsmContext *context);
+
+/**
+ * @brief
+ * Frees resources allocated by CsrWifiFsmInit
+ *
+ * @par Description
+ * This function is used to free any dynamic resources allocated for the
+ * given context by CsrWifiFsmInit(), prior to complete termination of
+ * the program.
+ * The FSM's reset function is called to cleanup any fsm specific memory.
+ * The reset funtion does NOT need to free the fsm data pointer as
+ * CsrWifiFsmShutdown() will do it.
+ * CsrWifiFsmShutdown() should NEVER be called when CsrWifiFsmExecute() is running.
+ *
+ * @param[in] context : FSM context
+ *
+ * @return
+ * void
+ */
+extern void CsrWifiFsmShutdown(CsrWifiFsmContext *context);
+
+/**
+ * @brief
+ * Executes the fsm context
+ *
+ * @par Description
+ * Executes the FSM context and runs until ALL events in the context are processed.
+ * When no more events are left to process then CsrWifiFsmExecute() returns to a time
+ * specifying when to next call the CsrWifiFsmExecute()
+ * Scheduling, threading, blocking and external event notification are outside
+ * the scope of the FSM and CsrWifiFsmExecute().
+ *
+ * @param[in] context : FSM context
+ *
+ * @return
+ * CsrUint32 Time in ms until next timeout or 0xFFFFFFFF for no timer set
+ */
+extern CsrUint32 CsrWifiFsmExecute(CsrWifiFsmContext *context);
+
+/**
+ * @brief
+ * Adds an event to the FSM context's external event queue for processing
+ *
+ * @par Description
+ * Adds an event to the contexts external queue
+ * This is thread safe and adds an event to the fsm's external event queue.
+ *
+ * @param[in] context : FSM context
+ * @param[in] event : event to add to the event queue
+ * @param[in] source : source of the event (this can be a synergy task queue or an fsm instance id)
+ * @param[in] destination : destination of the event (This can be a fsm instance id or CSR_WIFI_FSM_ENV)
+ * @param[in] id : event id
+ *
+ * @return
+ * void
+ */
+extern void CsrWifiFsmSendEventExternal(CsrWifiFsmContext *context, CsrWifiFsmEvent *event, CsrUint16 source, CsrUint16 destination, CsrPrim primtype, CsrUint16 id);
+
+/**
+ * @brief
+ * Adds an Alien event to the FSM context's external event queue for processing
+ *
+ * @par Description
+ * Adds an event to the contexts external queue
+ * This is thread safe and adds an event to the fsm's external event queue.
+ *
+ * @param[in] context : FSM context
+ * @param[in] event : event to add to the event queue
+ * @param[in] source : source of the event (this can be a synergy task queue or an fsm instance id)
+ * @param[in] destination : destination of the event (This can be a fsm instance id or CSR_WIFI_FSM_ENV)
+ * @param[in] id : event id
+ */
+#define CsrWifiFsmSendAlienEventExternal(_context, _alienEvent, _source, _destination, _primtype, _id) \
+ { \
+ CsrWifiFsmAlienEvent *_evt = (CsrWifiFsmAlienEvent *)CsrPmemAlloc(sizeof(CsrWifiFsmAlienEvent)); \
+ _evt->alienEvent = _alienEvent; \
+ CsrWifiFsmSendEventExternal(_context, (CsrWifiFsmEvent *)_evt, _source, _destination, _primtype, _id); \
+ }
+
+
+/**
+ * @brief
+ * Current time of day in ms
+ *
+ * @param[in] context : FSM context
+ *
+ * @return
+ * CsrUint32 32 bit ms tick
+ */
+extern CsrUint32 CsrWifiFsmGetTimeOfDayMs(CsrWifiFsmContext *context);
+
+/**
+ * @brief
+ * Gets the time until the next FSM timer expiry
+ *
+ * @par Description
+ * Returns the next timeout time or 0 if no timers are set.
+ *
+ * @param[in] context : FSM context
+ *
+ * @return
+ * CsrUint32 Time in ms until next timeout or 0xFFFFFFFF for no timer set
+ */
+extern CsrUint32 CsrWifiFsmGetNextTimeout(CsrWifiFsmContext *context);
+
+/**
+ * @brief
+ * Fast forwards the fsm timers by ms Milliseconds
+ *
+ * @param[in] context : FSM context
+ * @param[in] ms : Milliseconds to fast forward by
+ *
+ * @return
+ * void
+ */
+extern void CsrWifiFsmFastForward(CsrWifiFsmContext *context, CsrUint16 ms);
+
+/**
+ * @brief
+ * shift the current time of day by ms amount
+ *
+ * @par Description
+ * usefull to speed up tests where time needs to pass
+ *
+ * @param[in] context : FSM context
+ * @param[in] ms : ms to adjust time by
+ *
+ * @return
+ * void
+ */
+extern void CsrWifiFsmTestAdvanceTime(CsrWifiFsmContext *context, CsrUint32 ms);
+
+/**
+ * @brief
+ * Check if the fsm has events to process
+ *
+ * @param[in] context : FSM context
+ *
+ * @return
+ * CsrBool returns TRUE if there are events for the FSM to process
+ */
+extern CsrBool CsrWifiFsmHasEvents(CsrWifiFsmContext *context);
+
+/**
+ * @brief
+ * function that installs the contexts wakeup function
+ *
+ * @param[in] context : FSM context
+ * @param[in] callback : Callback function pointer
+ *
+ * @return
+ * void
+ */
+extern void CsrWifiFsmInstallWakeupCallback(CsrWifiFsmContext *context, CsrWifiFsmExternalWakupCallbackPtr callback);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_FSM_H */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifndef CSR_WIFI_FSM_EVENT_H
+#define CSR_WIFI_FSM_EVENT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+#include "csr_sched.h"
+
+/**
+ * @brief
+ * FSM event header.
+ *
+ * @par Description
+ * All events MUST have this struct as the FIRST member.
+ * The next member is used internally for linked lists
+ */
+typedef struct CsrWifiFsmEvent
+{
+ CsrPrim type;
+ CsrUint16 primtype;
+ CsrSchedQid destination;
+ CsrSchedQid source;
+
+ /* Private pointer to allow an optimal Event list */
+ /* NOTE: Ignore this pointer.
+ * Do not waste code initializing OR freeing it.
+ * The pointer is used internally in the CsrWifiFsm code
+ * to avoid a second malloc when queuing events.
+ */
+ struct CsrWifiFsmEvent *next;
+} CsrWifiFsmEvent;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_FSM_EVENT_H */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifndef CSR_WIFI_FSM_TYPES_H
+#define CSR_WIFI_FSM_TYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csr_types.h"
+#include "csr_util.h"
+#include "csr_pmem.h"
+#include "csr_panic.h"
+#include "csr_sched.h"
+
+#ifdef CSR_WIFI_FSM_MUTEX_ENABLE
+#include "csr_framework_ext.h"
+#endif
+
+#include "csr_wifi_fsm.h"
+
+#define CSR_WIFI_FSM_MAX_TRANSITION_HISTORY 10
+
+/**
+ * @brief
+ * FSM event list header.
+ *
+ * @par Description
+ * Singly linked list of events.
+ */
+typedef struct CsrWifiFsmEventList
+{
+ CsrWifiFsmEvent *first;
+ CsrWifiFsmEvent *last;
+} CsrWifiFsmEventList;
+
+
+/**
+ * @brief
+ * FSM timer id.
+ *
+ * @par Description
+ * Composite Id made up of the type, dest and a unique id so
+ * CsrWifiFsmRemoveTimer knows where to look when removing the timer
+ */
+typedef struct CsrWifiFsmTimerId
+{
+ CsrPrim type;
+ CsrUint16 primtype;
+ CsrSchedQid destination;
+ CsrUint16 uniqueid;
+} CsrWifiFsmTimerId;
+
+/**
+ * @brief
+ * FSM timer header.
+ *
+ * @par Description
+ * All timer MUST have this struct as the FIRST member.
+ * The first members of the structure MUST remain compatable
+ * with the CsrWifiFsmEvent so that timers are just specialised events
+ */
+typedef struct CsrWifiFsmTimer
+{
+ CsrPrim type;
+ CsrUint16 primtype;
+ CsrSchedQid destination;
+ CsrSchedQid source;
+
+ /* Private pointer to allow an optimal Event list */
+ struct CsrWifiFsmTimer *next;
+
+ CsrWifiFsmTimerId timerid;
+ CsrUint32 timeoutTimeMs;
+} CsrWifiFsmTimer;
+
+
+/**
+ * @brief
+ * Fsm Alien Event
+ *
+ * @par Description
+ * Allows the wrapping of alien events that do not use CsrWifiFsmEvent
+ * as the first member of the Event struct
+ */
+typedef struct
+{
+ CsrWifiFsmEvent event;
+ void *alienEvent;
+} CsrWifiFsmAlienEvent;
+
+
+/**
+ * @brief
+ * FSM timer list header.
+ *
+ * @par Description
+ * Singly linked list of timers.
+ */
+typedef struct CsrWifiFsmTimerList
+{
+ CsrWifiFsmTimer *first;
+ CsrWifiFsmTimer *last;
+ CsrUint16 nexttimerid;
+} CsrWifiFsmTimerList;
+
+/**
+ * @brief
+ * Process Entry Function Pointer
+ *
+ * @par Description
+ * Defines the entry function for a processes.
+ * Called at process initialisation.
+ *
+ * @param[in] context : FSM context
+ *
+ * @return
+ * void
+ */
+typedef void (*CsrWifiFsmProcEntryFnPtr)(CsrWifiFsmContext *context);
+
+/**
+ * @brief
+ * Process Transition Function Pointer
+ *
+ * @par Description
+ * Defines a transition function for a processes.
+ * Called when an event causes a transition on a process
+ *
+ * @param[in] CsrWifiFsmContext* : FSM context
+ * @param[in] void* : FSM data (can be NULL)
+ * @param[in] const CsrWifiFsmEvent* : event to process
+ *
+ * @return
+ * void
+ */
+typedef void (*CsrWifiFsmTransitionFnPtr)(CsrWifiFsmContext *context, void *fsmData, const CsrWifiFsmEvent *event);
+
+/**
+ * @brief
+ * Process reset/shutdown Function Pointer
+ *
+ * @par Description
+ * Defines the reset/shutdown function for a processes.
+ * Called to reset or shutdown an fsm.
+ *
+ * @param[in] context : FSM context
+ *
+ * @return
+ * void
+ */
+typedef void (*CsrWifiFsmProcResetFnPtr)(CsrWifiFsmContext *context);
+
+/**
+ * @brief
+ * FSM Default Destination CallbackFunction Pointer
+ *
+ * @par Description
+ * Defines the default destination function for the FSM
+ * to call when an event does not have a valid destination.
+ * This
+ *
+ * @param[in] context : External context
+ *
+ * @return
+ * CsrUint16 a valid destination OR CSR_WIFI_FSM_ENV
+ */
+typedef CsrUint16 (*CsrWifiFsmDestLookupCallbackPtr)(void *context, const CsrWifiFsmEvent *event);
+
+
+#ifdef CSR_WIFI_FSM_DUMP_ENABLE
+/**
+ * @brief
+ * Trace Dump Function Pointer
+ *
+ * @par Description
+ * Called when we want to trace the FSM
+ *
+ * @param[in] context : FSM context
+ * @param[in] id : fsm id
+ *
+ * @return
+ * void
+ */
+typedef void (*CsrWifiFsmDumpFnPtr)(CsrWifiFsmContext *context, void *fsmData);
+#endif
+
+/**
+ * @brief
+ * Event ID to transition function entry
+ *
+ * @par Description
+ * Event ID to Transition Entry in a state table.
+ */
+typedef struct
+{
+ CsrUint32 eventid;
+ CsrWifiFsmTransitionFnPtr transition;
+#ifdef CSR_LOG_ENABLE
+ const CsrCharString *transitionName;
+#endif
+} CsrWifiFsmEventEntry;
+
+/**
+ * @brief
+ * Single State's Transition Table
+ *
+ * @par Description
+ * Stores Data for a single State's event to
+ * transition functions mapping
+ */
+typedef struct
+{
+ const CsrUint8 numEntries;
+ const CsrBool saveAll;
+ const CsrWifiFsmEventEntry *eventEntryArray; /* array of transition function pointers for state */
+#ifdef CSR_LOG_ENABLE
+ CsrUint16 stateNumber;
+ const CsrCharString *stateName;
+#endif
+} CsrWifiFsmTableEntry;
+
+/**
+ * @brief
+ * Process State Transtion table
+ *
+ * @par Description
+ * Stores Data for a processes State to transition table
+ */
+typedef struct
+{
+ CsrUint16 numStates; /* number of states */
+ const CsrWifiFsmTableEntry *aStateEventMatrix; /* state event matrix */
+} CsrWifiFsmTransitionFunctionTable;
+
+/**
+ * @brief
+ * Const Process definition
+ *
+ * @par Description
+ * Constant process specification.
+ * This is ALL the non dynamic data that defines
+ * a process.
+ */
+typedef struct
+{
+ const CsrCharString *processName;
+ const CsrUint32 processId;
+ const CsrWifiFsmTransitionFunctionTable transitionTable;
+ const CsrWifiFsmTableEntry unhandledTransitions;
+ const CsrWifiFsmTableEntry ignoreFunctions;
+ const CsrWifiFsmProcEntryFnPtr entryFn;
+ const CsrWifiFsmProcResetFnPtr resetFn;
+#ifdef CSR_WIFI_FSM_DUMP_ENABLE
+ const CsrWifiFsmDumpFnPtr dumpFn; /* Called to dump fsm specific trace if not NULL */
+#endif
+} CsrWifiFsmProcessStateMachine;
+
+#ifdef CSR_WIFI_FSM_DUMP_ENABLE
+/**
+ * @brief
+ * Storage for state transition info
+ */
+typedef struct
+{
+ CsrUint16 transitionNumber;
+ CsrWifiFsmEvent event;
+ CsrUint16 fromState;
+ CsrUint16 toState;
+ CsrWifiFsmTransitionFnPtr transitionFn;
+ CsrUint16 transitionCount; /* number consecutive of times this transition was seen */
+#ifdef CSR_LOG_ENABLE
+ const CsrCharString *transitionName;
+#endif
+} CsrWifiFsmTransitionRecord;
+
+/**
+ * @brief
+ * Storage for the last state X transitions
+ */
+typedef struct
+{
+ CsrUint16 numTransitions;
+ CsrWifiFsmTransitionRecord records[CSR_WIFI_FSM_MAX_TRANSITION_HISTORY];
+} CsrWifiFsmTransitionRecords;
+#endif
+
+/**
+ * @brief
+ * Dynamic Process data
+ *
+ * @par Description
+ * Dynamic process data that is used to keep track of the
+ * state and data for a process instance
+ */
+typedef struct
+{
+ const CsrWifiFsmProcessStateMachine *fsmInfo; /* state machine info that is constant regardless of context */
+ CsrUint16 instanceId; /* Runtime process id */
+ CsrUint16 state; /* Current state */
+ void *params; /* Instance user data */
+ CsrWifiFsmEventList savedEventQueue; /* The saved event queue */
+ struct CsrWifiFsmInstanceEntry *subFsm; /* Sub Fsm instance data */
+ struct CsrWifiFsmInstanceEntry *subFsmCaller; /* The Fsm instance that created the SubFsm and should be used for callbacks*/
+#ifdef CSR_WIFI_FSM_DUMP_ENABLE
+ CsrWifiFsmTransitionRecords transitionRecords; /* Last X transitions in the FSM */
+#endif
+} CsrWifiFsmInstanceEntry;
+
+/**
+ * @brief
+ * OnCreate Callback Function Pointer
+ *
+ * @par Description
+ * Called when an fsm is created.
+ *
+ * @param[in] extContext : External context
+ * @param[in] instance : FSM instance
+ *
+ * @return
+ * void
+ */
+typedef void (*CsrWifiFsmOnCreateFnPtr)(void *extContext, const CsrWifiFsmInstanceEntry *instance);
+
+/**
+ * @brief
+ * OnTransition Callback Function Pointer
+ *
+ * @par Description
+ * Called when an event is processed by a fsm
+ *
+ * @param[in] extContext : External context
+ * @param[in] eventEntryArray : Entry data
+ * @param[in] event : Event
+ *
+ * @return
+ * void
+ */
+typedef void (*CsrWifiFsmOnTransitionFnPtr)(void *extContext, const CsrWifiFsmEventEntry *eventEntryArray, const CsrWifiFsmEvent *event);
+
+/**
+ * @brief
+ * OnStateChange Callback Function Pointer
+ *
+ * @par Description
+ * Called when CsrWifiFsmNextState is called
+ *
+ * @param[in] extContext : External context
+ *
+ * @return
+ * void
+ */
+typedef void (*CsrWifiFsmOnStateChangeFnPtr)(void *extContext, CsrUint16 nextstate);
+
+/**
+ * @brief
+ * OnIgnore,OnError or OnInvalid Callback Function Pointer
+ *
+ * @par Description
+ * Called when an event is processed by a fsm
+ *
+ * @param[in] extContext : External context
+ * @param[in] event : Event
+ *
+ * @return
+ * void
+ */
+typedef void (*CsrWifiFsmOnEventFnPtr)(void *extContext, const CsrWifiFsmEvent *event);
+
+/**
+ * @brief
+ * Toplevel FSM context data
+ *
+ * @par Description
+ * Holds ALL FSM static and dynamic data for a FSM
+ */
+struct CsrWifiFsmContext
+{
+ CsrWifiFsmEventList eventQueue; /* The internal event queue */
+ CsrWifiFsmEventList externalEventQueue; /* The external event queue */
+#ifdef CSR_WIFI_FSM_MUTEX_ENABLE
+ CsrMutexHandle externalEventQueueLock; /* The external event queue mutex */
+#endif
+ CsrUint32 timeOffset; /* Amount to adjust the TimeOfDayMs by */
+ CsrWifiFsmTimerList timerQueue; /* The internal timer queue */
+ CsrBool useTempSaveList; /* Should the temp save list be used */
+ CsrWifiFsmEventList tempSaveList; /* The temp save event queue */
+ CsrWifiFsmEvent *eventForwardedOrSaved; /* The event that was forwarded or Saved */
+ CsrUint16 maxProcesses; /* Size of instanceArray */
+ CsrUint16 numProcesses; /* Current number allocated in instanceArray */
+ CsrWifiFsmInstanceEntry *instanceArray; /* Array of processes for this component */
+ CsrWifiFsmInstanceEntry *ownerInstance; /* The Process that owns currentInstance (SubFsm support) */
+ CsrWifiFsmInstanceEntry *currentInstance; /* Current Process that is executing */
+ CsrWifiFsmExternalWakupCallbackPtr externalEventFn; /* External event Callback */
+ CsrWifiFsmOnEventFnPtr appIgnoreCallback; /* Application Ignore event Callback */
+ CsrWifiFsmDestLookupCallbackPtr appEvtDstCallback; /* Application Lookup event Destination Function*/
+
+ void *applicationContext; /* Internal fsm application context */
+ void *externalContext; /* External context (set by the user of the fsm)*/
+ CsrLogTextTaskId loggingTaskId; /* Task Id to use in any logging output */
+
+#ifndef CSR_WIFI_FSM_SCHEDULER_DISABLED
+ CsrSchedTid schedTimerId; /* Scheduler TimerId for use in Scheduler Tasks */
+ CsrUint32 schedTimerNexttimeoutMs; /* Next timeout time for the current timer */
+#endif
+
+#ifdef CSR_WIFI_FSM_MUTEX_ENABLE
+#ifdef CSR_WIFI_FSM_TRANSITION_LOCK
+ CsrMutexHandle transitionLock; /* Lock when calling transition functions */
+#endif
+#endif
+
+#ifdef CSR_LOG_ENABLE
+ CsrWifiFsmOnCreateFnPtr onCreate; /* Debug Transition Callback */
+ CsrWifiFsmOnTransitionFnPtr onTransition; /* Debug Transition Callback */
+ CsrWifiFsmOnTransitionFnPtr onUnhandedCallback; /* Unhanded event Callback */
+ CsrWifiFsmOnStateChangeFnPtr onStateChange; /* Debug State Change Callback */
+ CsrWifiFsmOnEventFnPtr onIgnoreCallback; /* Ignore event Callback */
+ CsrWifiFsmOnEventFnPtr onSaveCallback; /* Save event Callback */
+ CsrWifiFsmOnEventFnPtr onErrorCallback; /* Error event Callback */
+ CsrWifiFsmOnEventFnPtr onInvalidCallback; /* Invalid event Callback */
+#endif
+#ifdef CSR_WIFI_FSM_DUMP_ENABLE
+ CsrUint16 masterTransitionNumber; /* Increments on every transition */
+#endif
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_FSM_TYPES_H */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ ******************************************************************************
+ * FILE : csr_wifi_hip_card.h
+ *
+ * PURPOSE : Defines abstract interface for hardware specific functions.
+ * Note, this is a different file from one of the same name in the
+ * Windows driver.
+ *
+ *****************************************************************************
+ */
+#ifndef __CARD_H__
+#define __CARD_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csr_wifi_hip_card_sdio.h"
+#include "csr_wifi_hip_signals.h"
+#include "csr_wifi_hip_unifi_udi.h"
+
+
+/*****************************************************************************
+ * CardEnableInt -
+ */
+CsrResult CardEnableInt(card_t *card);
+
+/*****************************************************************************
+ * CardGenInt -
+ */
+CsrResult CardGenInt(card_t *card);
+
+/*****************************************************************************
+ * CardPendingInt -
+ */
+CsrResult CardPendingInt(card_t *card, CsrBool *pintr);
+
+/*****************************************************************************
+ * CardDisableInt -
+ */
+CsrResult CardDisableInt(card_t *card);
+
+/*****************************************************************************
+ * CardClearInt -
+ */
+CsrResult CardClearInt(card_t *card);
+
+/*****************************************************************************
+ * CardDisable -
+ */
+void CardDisable(card_t *card);
+
+/*****************************************************************************
+ * CardIntEnabled -
+ */
+CsrResult CardIntEnabled(card_t *card, CsrBool *enabled);
+
+/*****************************************************************************
+ * CardGetDataSlotSize
+ */
+CsrUint16 CardGetDataSlotSize(card_t *card);
+
+/*****************************************************************************
+ * CardWriteBulkData -
+ */
+CsrResult CardWriteBulkData(card_t *card, card_signal_t *csptr, unifi_TrafficQueue queue);
+
+
+/*****************************************************************************
+ * CardClearFromHostDataSlot -
+ */
+void CardClearFromHostDataSlot(card_t *card, const CsrInt16 aSlotNum);
+
+#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
+/*****************************************************************************
+ * CardClearFromHostDataSlotWithoutFreeingBulkData - Clear the data stot
+ * without freeing the bulk data
+ */
+
+void CardClearFromHostDataSlotWithoutFreeingBulkData(card_t *card, const CsrInt16 aSlotNum);
+#endif
+
+/*****************************************************************************
+ * CardGetFreeFromHostDataSlots -
+ */
+CsrUint16 CardGetFreeFromHostDataSlots(card_t *card);
+
+CsrUint16 CardAreAllFromHostDataSlotsEmpty(card_t *card);
+
+CsrResult card_start_processor(card_t *card, enum unifi_dbg_processors_select which);
+
+CsrResult card_wait_for_firmware_to_start(card_t *card, CsrUint32 *paddr);
+
+CsrResult unifi_dl_firmware(card_t *card, void *arg);
+CsrResult unifi_dl_patch(card_t *card, void *arg, CsrUint32 boot_ctrl);
+CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, CsrUint8 opcode);
+void* unifi_dl_fw_read_start(card_t *card, CsrInt8 is_fw);
+
+CsrResult unifi_coredump_handle_request(card_t *card);
+
+CsrResult ConvertCsrSdioToCsrHipResult(card_t *card, CsrResult csrResult);
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+void unifi_debug_log_to_buf(const CsrCharString *fmt, ...);
+void unifi_debug_string_to_buf(const CsrCharString *str);
+void unifi_debug_hex_to_buf(const CsrCharString *buff, CsrUint16 length);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CARD_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_card_sdio.c
+ *
+ * PURPOSE: Implementation of the Card API for SDIO.
+ *
+ * NOTES:
+ * CardInit() is called from the SDIO probe callback when a card is
+ * inserted. This performs the basic SDIO initialisation, enabling i/o
+ * etc.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_conversions.h"
+#include "csr_wifi_hip_unifiversion.h"
+#include "csr_wifi_hip_card.h"
+#include "csr_wifi_hip_card_sdio.h"
+#include "csr_wifi_hip_chiphelper.h"
+
+
+/* Time to wait between attempts to read MAILBOX0 */
+#define MAILBOX1_TIMEOUT 10 /* in millisecs */
+#define MAILBOX1_ATTEMPTS 200 /* 2 seconds */
+
+#define MAILBOX2_TIMEOUT 5 /* in millisecs */
+#define MAILBOX2_ATTEMPTS 10 /* 50ms */
+
+#define MAILBOX2_RESET_ATTEMPTS 10
+#define MAILBOX2_RESET_TIMEOUT 5 /* in millisecs */
+
+#define RESET_SETTLE_DELAY 25 /* in millisecs */
+
+static CsrResult card_init_slots(card_t *card);
+static CsrResult card_hw_init(card_t *card);
+static CsrResult firmware_present_in_flash(card_t *card);
+static void bootstrap_chip_hw(card_t *card);
+static CsrResult unifi_reset_hardware(card_t *card);
+static CsrResult unifi_hip_init(card_t *card);
+static CsrResult card_access_panic(card_t *card);
+static CsrResult unifi_read_chip_version(card_t *card);
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_alloc_card
+ *
+ * Allocate and initialise the card context structure.
+ *
+ * Arguments:
+ * sdio Pointer to SDIO context pointer to pass to low
+ * level i/o functions.
+ * ospriv Pointer to O/S private struct to pass when calling
+ * callbacks to the higher level system.
+ *
+ * Returns:
+ * Pointer to card struct, which represents the driver context or
+ * NULL if the allocation failed.
+ * ---------------------------------------------------------------------------
+ */
+card_t* unifi_alloc_card(CsrSdioFunction *sdio, void *ospriv)
+{
+ card_t *card;
+ CsrUint32 i;
+
+ func_enter();
+
+
+ card = (card_t *)CsrMemAlloc(sizeof(card_t));
+ if (card == NULL)
+ {
+ return NULL;
+ }
+ CsrMemSet(card, 0, sizeof(card_t));
+
+
+ card->sdio_if = sdio;
+ card->ospriv = ospriv;
+
+ card->unifi_interrupt_seq = 1;
+
+ /* Make these invalid. */
+ card->proc_select = (CsrUint32)(-1);
+ card->dmem_page = (CsrUint32)(-1);
+ card->pmem_page = (CsrUint32)(-1);
+
+ card->bh_reason_host = 0;
+ card->bh_reason_unifi = 0;
+
+ for (i = 0; i < sizeof(card->tx_q_paused_flag) / sizeof(card->tx_q_paused_flag[0]); i++)
+ {
+ card->tx_q_paused_flag[i] = 0;
+ }
+ card->memory_resources_allocated = 0;
+
+ card->low_power_mode = UNIFI_LOW_POWER_DISABLED;
+ card->periodic_wake_mode = UNIFI_PERIODIC_WAKE_HOST_DISABLED;
+
+ card->host_state = UNIFI_HOST_STATE_AWAKE;
+ card->intmode = CSR_WIFI_INTMODE_DEFAULT;
+
+ /*
+ * Memory resources for buffers are allocated when the chip is initialised
+ * because we need configuration information from the firmware.
+ */
+
+ /*
+ * Initialise wait queues and lists
+ */
+ card->fh_command_queue.q_body = card->fh_command_q_body;
+ card->fh_command_queue.q_length = UNIFI_SOFT_COMMAND_Q_LENGTH;
+
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ card->fh_traffic_queue[i].q_body = card->fh_traffic_q_body[i];
+ card->fh_traffic_queue[i].q_length = UNIFI_SOFT_TRAFFIC_Q_LENGTH;
+ }
+
+
+ /* Initialise mini-coredump pointers in case no coredump buffers
+ * are requested by the OS layer.
+ */
+ card->request_coredump_on_reset = 0;
+ card->dump_next_write = NULL;
+ card->dump_cur_read = NULL;
+ card->dump_buf = NULL;
+
+#ifdef UNIFI_DEBUG
+ /* Determine offset of LSB in pointer for later alignment sanity check.
+ * Synergy integer types have specific widths, which cause compiler
+ * warnings when casting pointer types, e.g. on 64-bit systems.
+ */
+ {
+ CsrUint32 val = 0x01234567;
+
+ if (*((CsrUint8 *)&val) == 0x01)
+ {
+ card->lsb = sizeof(void *) - 1; /* BE */
+ }
+ else
+ {
+ card->lsb = 0; /* LE */
+ }
+ }
+#endif
+ func_exit();
+ return card;
+} /* unifi_alloc_card() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_init_card
+ *
+ * Reset the hardware and perform HIP initialization
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CsrResult code
+ * CSR_RESULT_SUCCESS if successful
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_init_card(card_t *card, CsrInt32 led_mask)
+{
+ CsrResult r;
+
+ func_enter();
+
+ if (card == NULL)
+ {
+ func_exit_r(CSR_WIFI_HIP_RESULT_INVALID_VALUE);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ r = unifi_init(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ func_exit_r(r);
+ return r;
+ }
+
+ r = unifi_hip_init(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ func_exit_r(r);
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to start host protocol.\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_init
+ *
+ * Init the hardware.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CsrResult code
+ * CSR_RESULT_SUCCESS if successful
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_init(card_t *card)
+{
+ CsrResult r;
+ CsrResult csrResult;
+
+ func_enter();
+
+ if (card == NULL)
+ {
+ func_exit_r(CSR_WIFI_HIP_RESULT_INVALID_VALUE);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ /*
+ * Disable the SDIO interrupts while initialising UniFi.
+ * Re-enable them when f/w is running.
+ */
+ csrResult = CsrSdioInterruptDisable(card->sdio_if);
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+
+ /*
+ * UniFi's PLL may start with a slow clock (~ 1 MHz) so initially
+ * set the SDIO bus clock to a similar value or SDIO accesses may
+ * fail.
+ */
+ csrResult = CsrSdioMaxBusClockFrequencySet(card->sdio_if, UNIFI_SDIO_CLOCK_SAFE_HZ);
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ func_exit_r(r);
+ return r;
+ }
+ card->sdio_clock_speed = UNIFI_SDIO_CLOCK_SAFE_HZ;
+
+ /*
+ * Reset UniFi. Note, this only resets the WLAN function part of the chip,
+ * the SDIO interface is not reset.
+ */
+ unifi_trace(card->ospriv, UDBG1, "Resetting UniFi\n");
+ r = unifi_reset_hardware(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to reset UniFi\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ /* Reset the power save mode, to be active until the MLME-reset is complete */
+ r = unifi_configure_low_power_mode(card,
+ UNIFI_LOW_POWER_DISABLED, UNIFI_PERIODIC_WAKE_HOST_DISABLED);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to set power save mode\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ /*
+ * Set initial value of page registers.
+ * The page registers will be maintained by unifi_read...() and
+ * unifi_write...().
+ */
+ card->proc_select = (CsrUint32)(-1);
+ card->dmem_page = (CsrUint32)(-1);
+ card->pmem_page = (CsrUint32)(-1);
+ r = unifi_write_direct16(card, ChipHelper_HOST_WINDOW3_PAGE(card->helper) * 2, 0);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write SHARED_DMEM_PAGE\n");
+ func_exit_r(r);
+ return r;
+ }
+ r = unifi_write_direct16(card, ChipHelper_HOST_WINDOW2_PAGE(card->helper) * 2, 0);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write PROG_MEM2_PAGE\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ /*
+ * If the driver has reset UniFi due to previous SDIO failure, this may
+ * have been due to a chip watchdog reset. In this case, the driver may
+ * have requested a mini-coredump which needs to be captured now the
+ * SDIO interface is alive.
+ */
+ (void)unifi_coredump_handle_request(card);
+
+ /*
+ * Probe to see if the UniFi has ROM/flash to boot from. CSR6xxx should do.
+ */
+ r = firmware_present_in_flash(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r == CSR_WIFI_HIP_RESULT_NOT_FOUND)
+ {
+ unifi_error(card->ospriv, "No firmware found\n");
+ }
+ else if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Probe for Flash failed\n");
+ }
+
+ func_exit_r(r);
+ return r;
+} /* unifi_init() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_download
+ *
+ * Load the firmware.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * led_mask Loader LED mask
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success
+ * CsrResult error code on failure.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_download(card_t *card, CsrInt32 led_mask)
+{
+ CsrResult r;
+ void *dlpriv;
+
+ func_enter();
+
+ if (card == NULL)
+ {
+ func_exit_r(CSR_WIFI_HIP_RESULT_INVALID_VALUE);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ /* Set the loader led mask */
+ card->loader_led_mask = led_mask;
+
+ /* Get the firmware file information */
+ unifi_trace(card->ospriv, UDBG1, "downloading firmware...\n");
+
+ dlpriv = unifi_dl_fw_read_start(card, UNIFI_FW_STA);
+ if (dlpriv == NULL)
+ {
+ func_exit_r(CSR_WIFI_HIP_RESULT_NOT_FOUND);
+ return CSR_WIFI_HIP_RESULT_NOT_FOUND;
+ }
+
+ /* Download the firmware. */
+ r = unifi_dl_firmware(card, dlpriv);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to download firmware\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ /* Free the firmware file information. */
+ unifi_fw_read_stop(card->ospriv, dlpriv);
+
+ func_exit();
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_download() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_hip_init
+ *
+ * This function performs the f/w initialisation sequence as described
+ * in the Unifi Host Interface Protocol Specification.
+ * It allocates memory for host-side slot data and signal queues.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success or else a CSR error code
+ *
+ * Notes:
+ * The firmware must have been downloaded.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult unifi_hip_init(card_t *card)
+{
+ CsrResult r;
+ CsrResult csrResult;
+
+ func_enter();
+
+ r = card_hw_init(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to establish communication with UniFi\n");
+ func_exit_r(r);
+ return r;
+ }
+#ifdef CSR_PRE_ALLOC_NET_DATA
+ /* if there is any preallocated netdata left from the prev session free it now */
+ prealloc_netdata_free(card);
+#endif
+ /*
+ * Allocate memory for host-side slot data and signal queues.
+ * We need the config info read from the firmware to know how much
+ * memory to allocate.
+ */
+ r = card_init_slots(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Init slots failed: %d\n", r);
+ func_exit_r(r);
+ return r;
+ }
+
+ unifi_trace(card->ospriv, UDBG2, "Sending first UniFi interrupt\n");
+
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ func_exit_r(r);
+ return r;
+ }
+
+ /* Enable the SDIO interrupts now that the f/w is running. */
+ csrResult = CsrSdioInterruptEnable(card->sdio_if);
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+
+ /* Signal the UniFi to start handling messages */
+ r = CardGenInt(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ func_exit_r(r);
+ return r;
+ }
+
+ func_exit();
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_hip_init() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * _build_sdio_config_data
+ *
+ * Unpack the SDIO configuration information from a buffer read from
+ * UniFi into a host structure.
+ * The data is byte-swapped for a big-endian host if necessary by the
+ * UNPACK... macros.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * cfg_data Destination structure to unpack into.
+ * cfg_data_buf Source buffer to read from. This should be the raw
+ * data read from UniFi.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void _build_sdio_config_data(sdio_config_data_t *cfg_data,
+ const CsrUint8 *cfg_data_buf)
+{
+ CsrInt16 offset = 0;
+
+ cfg_data->version = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->sdio_ctrl_offset = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->fromhost_sigbuf_handle = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->tohost_sigbuf_handle = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->num_fromhost_sig_frags = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->num_tohost_sig_frags = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->num_fromhost_data_slots = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->num_tohost_data_slots = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->data_slot_size = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->initialised = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->overlay_size = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT32;
+
+ cfg_data->data_slot_round = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->sig_frag_size = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+ offset += SIZEOF_UINT16;
+
+ cfg_data->tohost_signal_padding = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cfg_data_buf + offset);
+} /* _build_sdio_config_data() */
+
+
+/*
+ * - Function ----------------------------------------------------------------
+ * card_hw_init()
+ *
+ * Perform the initialisation procedure described in the UniFi Host
+ * Interface Protocol document (section 3.3.8) and read the run-time
+ * configuration information from the UniFi. This is stuff like number
+ * of bulk data slots etc.
+ *
+ * The card enumeration and SD initialisation has already been done by
+ * the SDIO library, see card_sdio_init().
+ *
+ * The initialisation is done when firmware is ready, i.e. this may need
+ * to be called after a f/w download operation.
+ *
+ * The initialisation procedure goes like this:
+ * - Wait for UniFi to start-up by polling SHARED_MAILBOX1
+ * - Find the symbol table and look up SLT_SDIO_SLOT_CONFIG
+ * - Read the config structure
+ * - Check the "SDIO initialised" flag, if not zero do a h/w reset and
+ * start again
+ * - Decide the number of bulk data slots to allocate, allocate them and
+ * set "SDIO initialised" flag (and generate an interrupt) to say so.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCEESS on success,
+ * a CSR error code on failure
+ *
+ * Notes:
+ * All data in the f/w is stored in a little endian format, without any
+ * padding bytes. Every read from this memory has to be transformed in
+ * host (cpu specific) format, before it is stored in driver's parameters
+ * or/and structures. Athough unifi_card_read16() and unifi_read32() do perform
+ * the convertion internally, unifi_readn() does not.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult card_hw_init(card_t *card)
+{
+ CsrUint32 slut_address;
+ CsrUint16 initialised;
+ CsrUint16 finger_print;
+ symbol_t slut;
+ sdio_config_data_t *cfg_data;
+ CsrUint8 cfg_data_buf[SDIO_CONFIG_DATA_SIZE];
+ CsrResult r;
+ void *dlpriv;
+ CsrInt16 major, minor;
+ CsrInt16 search_4slut_again;
+ CsrResult csrResult;
+
+ func_enter();
+
+ /*
+ * The device revision from the TPLMID_MANF and TPLMID_CARD fields
+ * of the CIS are available as
+ * card->sdio_if->pDevice->ManfID
+ * card->sdio_if->pDevice->AppID
+ */
+
+ /*
+ * Run in a loop so we can patch.
+ */
+ do
+ {
+ /* Reset these each time around the loop. */
+ search_4slut_again = 0;
+ cfg_data = NULL;
+
+ r = card_wait_for_firmware_to_start(card, &slut_address);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Firmware hasn't started\n");
+ func_exit_r(r);
+ return r;
+ }
+ unifi_trace(card->ospriv, UDBG4, "SLUT addr 0x%lX\n", slut_address);
+
+ /*
+ * Firmware has started, but doesn't know full clock configuration yet
+ * as some of the information may be in the MIB. Therefore we set an
+ * initial SDIO clock speed, faster than UNIFI_SDIO_CLOCK_SAFE_HZ, for
+ * the patch download and subsequent firmware initialisation, and
+ * full speed UNIFI_SDIO_CLOCK_MAX_HZ will be set once the f/w tells us
+ * that it is ready.
+ */
+ csrResult = CsrSdioMaxBusClockFrequencySet(card->sdio_if, UNIFI_SDIO_CLOCK_INIT_HZ);
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ func_exit_r(r);
+ return r;
+ }
+ card->sdio_clock_speed = UNIFI_SDIO_CLOCK_INIT_HZ;
+
+ /*
+ * Check the SLUT fingerprint.
+ * The slut_address is a generic pointer so we must use unifi_card_read16().
+ */
+ unifi_trace(card->ospriv, UDBG4, "Looking for SLUT finger print\n");
+ finger_print = 0;
+ r = unifi_card_read16(card, slut_address, &finger_print);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read SLUT finger print\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ if (finger_print != SLUT_FINGERPRINT)
+ {
+ unifi_error(card->ospriv, "Failed to find Symbol lookup table fingerprint\n");
+ func_exit_r(CSR_RESULT_FAILURE);
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Symbol table starts imedately after the fingerprint */
+ slut_address += 2;
+
+ /* Search the table until either the end marker is found, or the
+ * loading of patch firmware invalidates the current table.
+ */
+ while (!search_4slut_again)
+ {
+ CsrUint16 s;
+ CsrUint32 l;
+
+ r = unifi_card_read16(card, slut_address, &s);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ func_exit_r(r);
+ return r;
+ }
+ slut_address += 2;
+
+ if (s == CSR_SLT_END)
+ {
+ unifi_trace(card->ospriv, UDBG3, " found CSR_SLT_END\n");
+ break;
+ }
+
+ r = unifi_read32(card, slut_address, &l);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ func_exit_r(r);
+ return r;
+ }
+ slut_address += 4;
+
+ slut.id = s;
+ slut.obj = l;
+
+ unifi_trace(card->ospriv, UDBG3, " found SLUT id %02d.%08lx\n", slut.id, slut.obj);
+ switch (slut.id)
+ {
+ case CSR_SLT_SDIO_SLOT_CONFIG:
+ cfg_data = &card->config_data;
+ /*
+ * unifi_card_readn reads n bytes from the card, where data is stored
+ * in a little endian format, without any padding bytes. So, we
+ * can not just pass the cfg_data pointer or use the
+ * sizeof(sdio_config_data_t) since the structure in the host can
+ * be big endian formatted or have padding bytes for alignment.
+ * We use a char buffer to read the data from the card.
+ */
+ r = unifi_card_readn(card, slut.obj, cfg_data_buf, SDIO_CONFIG_DATA_SIZE);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read config data\n");
+ func_exit_r(r);
+ return r;
+ }
+ /* .. and then we copy the data to the host structure */
+ _build_sdio_config_data(cfg_data, cfg_data_buf);
+
+ /* Make sure the from host data slots are what we expect
+ we reserve 2 for commands and there should be at least
+ 1 left for each access category */
+ if ((cfg_data->num_fromhost_data_slots < UNIFI_RESERVED_COMMAND_SLOTS)
+ || (cfg_data->num_fromhost_data_slots - UNIFI_RESERVED_COMMAND_SLOTS) / UNIFI_NO_OF_TX_QS == 0)
+ {
+ unifi_error(card->ospriv, "From host data slots %d\n", cfg_data->num_fromhost_data_slots);
+ unifi_error(card->ospriv, "need to be (queues * x + 2) (UNIFI_RESERVED_COMMAND_SLOTS for commands)\n");
+ func_exit_r(CSR_RESULT_FAILURE);
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Configure SDIO to-block-size padding */
+ if (card->sdio_io_block_pad)
+ {
+ /*
+ * Firmware limits the maximum padding size via data_slot_round.
+ * Therefore when padding to whole block sizes, the block size
+ * must be configured correctly by adjusting CSR_WIFI_HIP_SDIO_BLOCK_SIZE.
+ */
+ if (cfg_data->data_slot_round < card->sdio_io_block_size)
+ {
+ unifi_error(card->ospriv,
+ "Configuration error: Block size of %d exceeds f/w data_slot_round of %d\n",
+ card->sdio_io_block_size, cfg_data->data_slot_round);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ /*
+ * To force the To-Host signals to be rounded up to the SDIO block
+ * size, we need to write the To-Host Signal Padding Fragments
+ * field of the SDIO configuration in UniFi.
+ */
+ if ((card->sdio_io_block_size % cfg_data->sig_frag_size) != 0)
+ {
+ unifi_error(card->ospriv, "Configuration error: Can not pad to-host signals.\n");
+ func_exit_r(CSR_WIFI_HIP_RESULT_INVALID_VALUE);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ cfg_data->tohost_signal_padding = (CsrUint16) (card->sdio_io_block_size / cfg_data->sig_frag_size);
+ unifi_info(card->ospriv, "SDIO block size %d requires %d padding chunks\n",
+ card->sdio_io_block_size, cfg_data->tohost_signal_padding);
+ r = unifi_card_write16(card, slut.obj + SDIO_TO_HOST_SIG_PADDING_OFFSET, cfg_data->tohost_signal_padding);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write To-Host Signal Padding Fragments\n");
+ func_exit_r(r);
+ return r;
+ }
+ }
+
+ /* Reconstruct the Generic Pointer address of the
+ * SDIO Control Data Struct.
+ */
+ card->sdio_ctrl_addr = cfg_data->sdio_ctrl_offset | (UNIFI_SH_DMEM << 24);
+ card->init_flag_addr = slut.obj + SDIO_INIT_FLAG_OFFSET;
+ break;
+
+ case CSR_SLT_BUILD_ID_NUMBER:
+ {
+ CsrUint32 n;
+ r = unifi_read32(card, slut.obj, &n);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read build id\n");
+ func_exit_r(r);
+ return r;
+ }
+ card->build_id = n;
+ }
+ break;
+
+ case CSR_SLT_BUILD_ID_STRING:
+ r = unifi_readnz(card, slut.obj, card->build_id_string,
+ sizeof(card->build_id_string));
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read build string\n");
+ func_exit_r(r);
+ return r;
+ }
+ break;
+
+ case CSR_SLT_PERSISTENT_STORE_DB:
+ break;
+
+ case CSR_SLT_BOOT_LOADER_CONTROL:
+
+ /* This command copies most of the station firmware
+ * image from ROM into program RAM. It also clears
+ * out the zerod data and sets up the initialised
+ * data. */
+ r = unifi_do_loader_op(card, slut.obj + 6, UNIFI_BOOT_LOADER_LOAD_STA);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write loader load image command\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ dlpriv = unifi_dl_fw_read_start(card, UNIFI_FW_STA);
+
+ /* dlpriv might be NULL, we still need to do the do_loader_op step. */
+ if (dlpriv != NULL)
+ {
+ /* Download the firmware. */
+ r = unifi_dl_patch(card, dlpriv, slut.obj);
+
+ /* Free the firmware file information. */
+ unifi_fw_read_stop(card->ospriv, dlpriv);
+
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to patch firmware\n");
+ func_exit_r(r);
+ return r;
+ }
+ }
+
+ /* This command starts the firmware image that we want (the
+ * station by default) with any patches required applied. */
+ r = unifi_do_loader_op(card, slut.obj + 6, UNIFI_BOOT_LOADER_RESTART);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write loader restart command\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ /* The now running patch f/w defines a new SLUT data structure -
+ * the current one is no longer valid. We must drop out of the
+ * processing loop and enumerate the new SLUT (which may appear
+ * at a different offset).
+ */
+ search_4slut_again = 1;
+ break;
+
+ case CSR_SLT_PANIC_DATA_PHY:
+ card->panic_data_phy_addr = slut.obj;
+ break;
+
+ case CSR_SLT_PANIC_DATA_MAC:
+ card->panic_data_mac_addr = slut.obj;
+ break;
+
+ default:
+ /* do nothing */
+ break;
+ }
+ } /* while */
+ } while (search_4slut_again);
+
+ /* Did we find the Config Data ? */
+ if (cfg_data == NULL)
+ {
+ unifi_error(card->ospriv, "Failed to find SDIO_SLOT_CONFIG Symbol\n");
+ func_exit_r(CSR_RESULT_FAILURE);
+ return CSR_RESULT_FAILURE;
+ }
+
+ /*
+ * Has ths card already been initialised?
+ * If so, return an error so we do a h/w reset and start again.
+ */
+ r = unifi_card_read16(card, card->init_flag_addr, &initialised);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read init flag at %08lx\n",
+ card->init_flag_addr);
+ func_exit_r(r);
+ return r;
+ }
+ if (initialised != 0)
+ {
+ func_exit_r(CSR_RESULT_FAILURE);
+ return CSR_RESULT_FAILURE;
+ }
+
+
+ /*
+ * Now check the UniFi firmware version
+ */
+ major = (cfg_data->version >> 8) & 0xFF;
+ minor = cfg_data->version & 0xFF;
+ unifi_info(card->ospriv, "UniFi f/w protocol version %d.%d (driver %d.%d)\n",
+ major, minor,
+ UNIFI_HIP_MAJOR_VERSION, UNIFI_HIP_MINOR_VERSION);
+
+ unifi_info(card->ospriv, "Firmware build %u: %s\n",
+ card->build_id, card->build_id_string);
+
+ if (major != UNIFI_HIP_MAJOR_VERSION)
+ {
+ unifi_error(card->ospriv, "UniFi f/w protocol major version (%d) is different from driver (v%d.%d)\n",
+ major, UNIFI_HIP_MAJOR_VERSION, UNIFI_HIP_MINOR_VERSION);
+#ifndef CSR_WIFI_DISABLE_HIP_VERSION_CHECK
+ func_exit_r(CSR_RESULT_FAILURE);
+ return CSR_RESULT_FAILURE;
+#endif
+ }
+ if (minor < UNIFI_HIP_MINOR_VERSION)
+ {
+ unifi_error(card->ospriv, "UniFi f/w protocol version (v%d.%d) is older than minimum required by driver (v%d.%d).\n",
+ major, minor,
+ UNIFI_HIP_MAJOR_VERSION, UNIFI_HIP_MINOR_VERSION);
+#ifndef CSR_WIFI_DISABLE_HIP_VERSION_CHECK
+ func_exit_r(CSR_RESULT_FAILURE);
+ return CSR_RESULT_FAILURE;
+#endif
+ }
+
+ /* Read panic codes from a previous firmware panic. If the firmware has
+ * not panicked since power was applied (e.g. power-off hard reset)
+ * the stored panic codes will not be updated.
+ */
+ unifi_read_panic(card);
+
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+} /* card_hw_init() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_wait_for_unifi_to_reset
+ *
+ * Waits for a reset to complete by polling the WLAN function enable
+ * bit (which is cleared on reset).
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error code on failure.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult card_wait_for_unifi_to_reset(card_t *card)
+{
+ CsrInt16 i;
+ CsrResult r;
+ CsrUint8 io_enable;
+ CsrResult csrResult;
+
+ func_enter();
+
+ r = CSR_RESULT_SUCCESS;
+ for (i = 0; i < MAILBOX2_ATTEMPTS; i++)
+ {
+ unifi_trace(card->ospriv, UDBG1, "waiting for reset to complete, attempt %d\n", i);
+ if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
+ {
+ /* It's quite likely that this read will timeout for the
+ * first few tries - especially if we have reset via
+ * DBG_RESET.
+ */
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_log_to_buf("m0@%02X=", SDIO_IO_READY);
+#endif
+ csrResult = CsrSdioF0Read8(card->sdio_if, SDIO_IO_READY, &io_enable);
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_debug_log_to_buf("error=%X\n", csrResult);
+ }
+ else
+ {
+ unifi_debug_log_to_buf("%X\n", io_enable);
+ }
+#endif
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+ r = CSR_RESULT_SUCCESS;
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ }
+ }
+ else
+ {
+ r = sdio_read_f0(card, SDIO_IO_ENABLE, &io_enable);
+ }
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r == CSR_RESULT_SUCCESS)
+ {
+ CsrUint16 mbox2;
+ CsrInt16 enabled = io_enable & (1 << card->function);
+
+ if (!enabled)
+ {
+ unifi_trace(card->ospriv, UDBG1,
+ "Reset complete (function %d is disabled) in ~ %u msecs\n",
+ card->function, i * MAILBOX2_TIMEOUT);
+
+ /* Enable WLAN function and verify MAILBOX2 is zero'd */
+ csrResult = CsrSdioFunctionEnable(card->sdio_if);
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ unifi_error(card->ospriv, "CsrSdioFunctionEnable failed %d\n", r);
+ break;
+ }
+ }
+
+ r = unifi_read_direct16(card, ChipHelper_SDIO_HIP_HANDSHAKE(card->helper) * 2, &mbox2);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "read HIP_HANDSHAKE failed %d\n", r);
+ break;
+ }
+ if (mbox2 != 0)
+ {
+ unifi_error(card->ospriv, "MAILBOX2 non-zero after reset (mbox2 = %04x)\n", mbox2);
+ r = CSR_RESULT_FAILURE;
+ }
+ break;
+ }
+ else
+ {
+ if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
+ {
+ /* We ignore read failures for the first few reads,
+ * they are probably benign. */
+ if (i > MAILBOX2_ATTEMPTS / 4)
+ {
+ unifi_trace(card->ospriv, UDBG1, "Failed to read CCCR IO Ready register while polling for reset\n");
+ }
+ }
+ else
+ {
+ unifi_trace(card->ospriv, UDBG1, "Failed to read CCCR IO Enable register while polling for reset\n");
+ }
+ }
+ CsrThreadSleep(MAILBOX2_TIMEOUT);
+ }
+
+ if (r == CSR_RESULT_SUCCESS && i == MAILBOX2_ATTEMPTS)
+ {
+ unifi_trace(card->ospriv, UDBG1, "Timeout waiting for UniFi to complete reset\n");
+ r = CSR_RESULT_FAILURE;
+ }
+
+ func_exit();
+ return r;
+} /* card_wait_for_unifi_to_reset() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_wait_for_unifi_to_disable
+ *
+ * Waits for the function to become disabled by polling the
+ * IO_READY bit.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error code on failure.
+ *
+ * Notes: This function can only be used with
+ * card->chip_id > SDIO_CARD_ID_UNIFI_2
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult card_wait_for_unifi_to_disable(card_t *card)
+{
+ CsrInt16 i;
+ CsrResult r;
+ CsrUint8 io_enable;
+ CsrResult csrResult;
+
+ func_enter();
+
+ if (card->chip_id <= SDIO_CARD_ID_UNIFI_2)
+ {
+ unifi_error(card->ospriv,
+ "Function reset method not supported for chip_id=%d\n",
+ card->chip_id);
+ func_exit();
+ return CSR_RESULT_FAILURE;
+ }
+
+ r = CSR_RESULT_SUCCESS;
+ for (i = 0; i < MAILBOX2_ATTEMPTS; i++)
+ {
+ unifi_trace(card->ospriv, UDBG1, "waiting for disable to complete, attempt %d\n", i);
+
+ /*
+ * It's quite likely that this read will timeout for the
+ * first few tries - especially if we have reset via
+ * DBG_RESET.
+ */
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_log_to_buf("r0@%02X=", SDIO_IO_READY);
+#endif
+ csrResult = CsrSdioF0Read8(card->sdio_if, SDIO_IO_READY, &io_enable);
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_debug_log_to_buf("error=%X\n", csrResult);
+ }
+ else
+ {
+ unifi_debug_log_to_buf("%X\n", io_enable);
+ }
+#endif
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+ if (csrResult == CSR_RESULT_SUCCESS)
+ {
+ CsrInt16 enabled = io_enable & (1 << card->function);
+ r = CSR_RESULT_SUCCESS;
+ if (!enabled)
+ {
+ unifi_trace(card->ospriv, UDBG1,
+ "Disable complete (function %d is disabled) in ~ %u msecs\n",
+ card->function, i * MAILBOX2_TIMEOUT);
+
+ break;
+ }
+ }
+ else
+ {
+ /*
+ * We ignore read failures for the first few reads,
+ * they are probably benign.
+ */
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ if (i > (MAILBOX2_ATTEMPTS / 4))
+ {
+ unifi_trace(card->ospriv, UDBG1,
+ "Failed to read CCCR IO Ready register while polling for disable\n");
+ }
+ }
+ CsrThreadSleep(MAILBOX2_TIMEOUT);
+ }
+
+ if ((r == CSR_RESULT_SUCCESS) && (i == MAILBOX2_ATTEMPTS))
+ {
+ unifi_trace(card->ospriv, UDBG1, "Timeout waiting for UniFi to complete disable\n");
+ r = CSR_RESULT_FAILURE;
+ }
+
+ func_exit();
+ return r;
+} /* card_wait_for_unifi_to_reset() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_wait_for_firmware_to_start
+ *
+ * Polls the MAILBOX1 register for a non-zero value.
+ * Then reads MAILBOX0 and forms the two values into a 32-bit address
+ * which is returned to the caller.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * paddr Pointer to receive the UniFi address formed
+ * by concatenating MAILBOX1 and MAILBOX0.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error code on failure.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult card_wait_for_firmware_to_start(card_t *card, CsrUint32 *paddr)
+{
+ CsrInt32 i;
+ CsrUint16 mbox0, mbox1;
+ CsrResult r;
+
+ func_enter();
+
+ /*
+ * Wait for UniFi to initialise its data structures by polling
+ * the SHARED_MAILBOX1 register.
+ * Experience shows this is typically 120ms.
+ */
+ CsrThreadSleep(MAILBOX1_TIMEOUT);
+
+ mbox1 = 0;
+ unifi_trace(card->ospriv, UDBG1, "waiting for MAILBOX1 to be non-zero...\n");
+ for (i = 0; i < MAILBOX1_ATTEMPTS; i++)
+ {
+ r = unifi_read_direct16(card, ChipHelper_MAILBOX1(card->helper) * 2, &mbox1);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ /* These reads can fail if UniFi isn't up yet, so try again */
+ unifi_warning(card->ospriv, "Failed to read UniFi Mailbox1 register\n");
+ }
+
+ if ((r == CSR_RESULT_SUCCESS) && (mbox1 != 0))
+ {
+ unifi_trace(card->ospriv, UDBG1, "MAILBOX1 ready (0x%04X) in %u millisecs\n",
+ mbox1, i * MAILBOX1_TIMEOUT);
+
+ /* Read the MAILBOX1 again in case we caught the value as it
+ * changed. */
+ r = unifi_read_direct16(card, ChipHelper_MAILBOX1(card->helper) * 2, &mbox1);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read UniFi Mailbox1 register for second time\n");
+ func_exit_r(r);
+ return r;
+ }
+ unifi_trace(card->ospriv, UDBG1, "MAILBOX1 value=0x%04X\n", mbox1);
+
+ break;
+ }
+
+ CsrThreadSleep(MAILBOX1_TIMEOUT);
+ if ((i % 100) == 99)
+ {
+ unifi_trace(card->ospriv, UDBG2, "MAILBOX1 not ready (0x%X), still trying...\n", mbox1);
+ }
+ }
+
+ if ((r == CSR_RESULT_SUCCESS) && (mbox1 == 0))
+ {
+ unifi_trace(card->ospriv, UDBG1, "Timeout waiting for firmware to start, Mailbox1 still 0 after %d ms\n",
+ MAILBOX1_ATTEMPTS * MAILBOX1_TIMEOUT);
+ func_exit_r(CSR_RESULT_FAILURE);
+ return CSR_RESULT_FAILURE;
+ }
+
+
+ /*
+ * Complete the reset handshake by setting MAILBOX2 to 0xFFFF
+ */
+ r = unifi_write_direct16(card, ChipHelper_SDIO_HIP_HANDSHAKE(card->helper) * 2, 0xFFFF);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write f/w startup handshake to MAILBOX2\n");
+ func_exit_r(r);
+ return r;
+ }
+
+
+ /*
+ * Read the Symbol Look Up Table (SLUT) offset.
+ * Top 16 bits are in mbox1, read the lower 16 bits from mbox0.
+ */
+ mbox0 = 0;
+ r = unifi_read_direct16(card, ChipHelper_MAILBOX0(card->helper) * 2, &mbox0);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read UniFi Mailbox0 register\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ *paddr = (((CsrUint32)mbox1 << 16) | mbox0);
+
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+} /* card_wait_for_firmware_to_start() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_capture_panic
+ *
+ * Attempt to capture panic codes from the firmware. This may involve
+ * warm reset of the chip to regain access following a watchdog reset.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS if panic codes were captured, or none available
+ * CSR_RESULT_FAILURE if the driver could not access function 1
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_capture_panic(card_t *card)
+{
+ func_enter();
+
+ /* The firmware must have previously initialised to read the panic addresses
+ * from the SLUT
+ */
+ if (!card->panic_data_phy_addr || !card->panic_data_mac_addr)
+ {
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+ }
+
+ /* Ensure we can access function 1 following a panic/watchdog reset */
+ if (card_access_panic(card) == CSR_RESULT_SUCCESS)
+ {
+ /* Read the panic codes */
+ unifi_read_panic(card);
+ }
+ else
+ {
+ unifi_info(card->ospriv, "Unable to read panic codes");
+ }
+
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_access_panic
+ * Attempt to read the WLAN SDIO function in order to read panic codes
+ * and perform various reset steps to regain access if the read fails.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS if panic codes can be read
+ * CSR error code if panic codes can not be read
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult card_access_panic(card_t *card)
+{
+ CsrUint16 data_u16 = 0;
+ CsrInt32 i;
+ CsrResult r, sr;
+
+ func_enter();
+
+ /* A chip version of zero means that the version never got succesfully read
+ * during reset. In this case give up because it will not be possible to
+ * verify the chip version.
+ */
+ if (!card->chip_version)
+ {
+ unifi_info(card->ospriv, "Unknown chip version\n");
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Ensure chip is awake or access to function 1 will fail */
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "unifi_set_host_state() failed %d\n", r);
+ return CSR_RESULT_FAILURE; /* Card is probably unpowered */
+ }
+ CsrThreadSleep(20);
+
+ for (i = 0; i < 3; i++)
+ {
+ sr = CsrSdioRead16(card->sdio_if, CHIP_HELPER_UNIFI_GBL_CHIP_VERSION * 2, &data_u16);
+ if (sr != CSR_RESULT_SUCCESS || data_u16 != card->chip_version)
+ {
+ unifi_info(card->ospriv, "Failed to read valid chip version sr=%d (0x%04x want 0x%04x) try %d\n",
+ sr, data_u16, card->chip_version, i);
+
+ /* Set clock speed low */
+ sr = CsrSdioMaxBusClockFrequencySet(card->sdio_if, UNIFI_SDIO_CLOCK_SAFE_HZ);
+ if (sr != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "CsrSdioMaxBusClockFrequencySet() failed1 %d\n", sr);
+ r = ConvertCsrSdioToCsrHipResult(card, sr);
+ }
+ card->sdio_clock_speed = UNIFI_SDIO_CLOCK_SAFE_HZ;
+
+ /* First try re-enabling function in case a f/w watchdog reset disabled it */
+ if (i == 0)
+ {
+ unifi_info(card->ospriv, "Try function enable\n");
+ sr = CsrSdioFunctionEnable(card->sdio_if);
+ if (sr != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, sr);
+ unifi_error(card->ospriv, "CsrSdioFunctionEnable failed %d (HIP %d)\n", sr, r);
+ }
+ continue;
+ }
+
+ /* Second try, set awake */
+ unifi_info(card->ospriv, "Try set awake\n");
+
+ /* Ensure chip is awake */
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "unifi_set_host_state() failed2 %d\n", r);
+ }
+
+ /* Set clock speed low in case setting the host state raised it, which
+ * would only happen if host state was previously TORPID
+ */
+ sr = CsrSdioMaxBusClockFrequencySet(card->sdio_if, UNIFI_SDIO_CLOCK_SAFE_HZ);
+ if (sr != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "CsrSdioMaxBusClockFrequencySet() failed2 %d\n", sr);
+ }
+ card->sdio_clock_speed = UNIFI_SDIO_CLOCK_SAFE_HZ;
+
+ if (i == 1)
+ {
+ continue;
+ }
+
+ /* Perform a s/w reset to preserve as much as the card state as possible,
+ * (mainly the preserve RAM). The context will be lost for coredump - but as we
+ * were unable to access the WLAN function for panic, the coredump would have
+ * also failed without a reset.
+ */
+ unifi_info(card->ospriv, "Try s/w reset\n");
+
+ r = unifi_card_hard_reset(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "unifi_card_hard_reset() failed %d\n", r);
+ }
+ }
+ else
+ {
+ if (i > 0)
+ {
+ unifi_info(card->ospriv, "Read chip version 0x%x after %d retries\n", data_u16, i);
+ }
+ break;
+ }
+ }
+
+ r = ConvertCsrSdioToCsrHipResult(card, sr);
+ func_exit_r(r);
+ return r;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_read_panic
+ * Reads, saves and prints panic codes stored by the firmware in UniFi's
+ * preserve RAM by the last panic that occurred since chip was powered.
+ * Nothing is saved if the panic codes are read as zero.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * ---------------------------------------------------------------------------
+ */
+void unifi_read_panic(card_t *card)
+{
+ CsrResult r;
+ CsrUint16 p_code, p_arg;
+
+ func_enter();
+
+ /* The firmware must have previously initialised to read the panic addresses
+ * from the SLUT
+ */
+ if (!card->panic_data_phy_addr || !card->panic_data_mac_addr)
+ {
+ return;
+ }
+
+ /* Get the panic data from PHY */
+ r = unifi_card_read16(card, card->panic_data_phy_addr, &p_code);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "capture_panic: unifi_read16 %08x failed %d\n", card->panic_data_phy_addr, r);
+ p_code = 0;
+ }
+ if (p_code)
+ {
+ r = unifi_card_read16(card, card->panic_data_phy_addr + 2, &p_arg);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "capture_panic: unifi_read16 %08x failed %d\n", card->panic_data_phy_addr + 2, r);
+ }
+ unifi_error(card->ospriv, "Last UniFi PHY PANIC %04x arg %04x\n", p_code, p_arg);
+ card->last_phy_panic_code = p_code;
+ card->last_phy_panic_arg = p_arg;
+ }
+
+ /* Get the panic data from MAC */
+ r = unifi_card_read16(card, card->panic_data_mac_addr, &p_code);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "capture_panic: unifi_read16 %08x failed %d\n", card->panic_data_mac_addr, r);
+ p_code = 0;
+ }
+ if (p_code)
+ {
+ r = unifi_card_read16(card, card->panic_data_mac_addr + 2, &p_arg);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "capture_panic: unifi_read16 %08x failed %d\n", card->panic_data_mac_addr + 2, r);
+ }
+ unifi_error(card->ospriv, "Last UniFi MAC PANIC %04x arg %04x\n", p_code, p_arg);
+ card->last_mac_panic_code = p_code;
+ card->last_mac_panic_arg = p_arg;
+ }
+
+ func_exit();
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_allocate_memory_resources
+ *
+ * Allocates memory for the from-host, to-host bulk data slots,
+ * soft queue buffers and bulk data buffers.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error code on failure.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult card_allocate_memory_resources(card_t *card)
+{
+ CsrInt16 n, i, k, r;
+ sdio_config_data_t *cfg_data;
+
+ func_enter();
+
+ /* Reset any state carried forward from a previous life */
+ card->fh_command_queue.q_rd_ptr = 0;
+ card->fh_command_queue.q_wr_ptr = 0;
+ (void)CsrSnprintf(card->fh_command_queue.name, UNIFI_QUEUE_NAME_MAX_LENGTH,
+ "fh_cmd_q");
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ card->fh_traffic_queue[i].q_rd_ptr = 0;
+ card->fh_traffic_queue[i].q_wr_ptr = 0;
+ (void)CsrSnprintf(card->fh_traffic_queue[i].name,
+ UNIFI_QUEUE_NAME_MAX_LENGTH, "fh_data_q%d", i);
+ }
+#ifndef CSR_WIFI_HIP_TA_DISABLE
+ unifi_ta_sampling_init(card);
+#endif
+ /* Convenience short-cut */
+ cfg_data = &card->config_data;
+
+ /*
+ * Allocate memory for the from-host and to-host signal buffers.
+ */
+ card->fh_buffer.buf = CsrMemAllocDma(UNIFI_FH_BUF_SIZE);
+ if (card->fh_buffer.buf == NULL)
+ {
+ unifi_error(card->ospriv, "Failed to allocate memory for F-H signals\n");
+ func_exit_r(CSR_WIFI_HIP_RESULT_NO_MEMORY);
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+ }
+ card->fh_buffer.bufsize = UNIFI_FH_BUF_SIZE;
+ card->fh_buffer.ptr = card->fh_buffer.buf;
+ card->fh_buffer.count = 0;
+
+ card->th_buffer.buf = CsrMemAllocDma(UNIFI_FH_BUF_SIZE);
+ if (card->th_buffer.buf == NULL)
+ {
+ unifi_error(card->ospriv, "Failed to allocate memory for T-H signals\n");
+ func_exit_r(CSR_WIFI_HIP_RESULT_NO_MEMORY);
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+ }
+ card->th_buffer.bufsize = UNIFI_FH_BUF_SIZE;
+ card->th_buffer.ptr = card->th_buffer.buf;
+ card->th_buffer.count = 0;
+
+
+ /*
+ * Allocate memory for the from-host and to-host bulk data slots.
+ * This is done as separate CsrPmemAllocs because lots of smaller
+ * allocations are more likely to succeed than one huge one.
+ */
+
+ /* Allocate memory for the array of pointers */
+ n = cfg_data->num_fromhost_data_slots;
+
+ unifi_trace(card->ospriv, UDBG3, "Alloc from-host resources, %d slots.\n", n);
+ card->from_host_data =
+ (slot_desc_t *)CsrMemAlloc(n * sizeof(slot_desc_t));
+ if (card->from_host_data == NULL)
+ {
+ unifi_error(card->ospriv, "Failed to allocate memory for F-H bulk data array\n");
+ func_exit_r(CSR_WIFI_HIP_RESULT_NO_MEMORY);
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+ }
+
+ /* Initialise from-host bulk data slots */
+ for (i = 0; i < n; i++)
+ {
+ UNIFI_INIT_BULK_DATA(&card->from_host_data[i].bd);
+ }
+
+ /* Allocate memory for the array used for slot host tag mapping */
+ card->fh_slot_host_tag_record =
+ (CsrUint32 *)CsrMemAlloc(n * sizeof(CsrUint32));
+
+ if (card->fh_slot_host_tag_record == NULL)
+ {
+ unifi_error(card->ospriv, "Failed to allocate memory for F-H slot host tag mapping array\n");
+ func_exit_r(CSR_WIFI_HIP_RESULT_NO_MEMORY);
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+ }
+
+ /* Initialise host tag entries for from-host bulk data slots */
+ for (i = 0; i < n; i++)
+ {
+ card->fh_slot_host_tag_record[i] = CSR_WIFI_HIP_RESERVED_HOST_TAG;
+ }
+
+
+ /* Allocate memory for the array of pointers */
+ n = cfg_data->num_tohost_data_slots;
+
+ unifi_trace(card->ospriv, UDBG3, "Alloc to-host resources, %d slots.\n", n);
+ card->to_host_data =
+ (bulk_data_desc_t *)CsrMemAlloc(n * sizeof(bulk_data_desc_t));
+ if (card->to_host_data == NULL)
+ {
+ unifi_error(card->ospriv, "Failed to allocate memory for T-H bulk data array\n");
+ func_exit_r(CSR_WIFI_HIP_RESULT_NO_MEMORY);
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+ }
+
+ /* Initialise to-host bulk data slots */
+ for (i = 0; i < n; i++)
+ {
+ UNIFI_INIT_BULK_DATA(&card->to_host_data[i]);
+ }
+
+ /*
+ * Initialise buffers for soft Q
+ */
+ for (i = 0; i < UNIFI_SOFT_COMMAND_Q_LENGTH; i++)
+ {
+ for (r = 0; r < UNIFI_MAX_DATA_REFERENCES; r++)
+ {
+ UNIFI_INIT_BULK_DATA(&card->fh_command_q_body[i].bulkdata[r]);
+ }
+ }
+
+ for (k = 0; k < UNIFI_NO_OF_TX_QS; k++)
+ {
+ for (i = 0; i < UNIFI_SOFT_TRAFFIC_Q_LENGTH; i++)
+ {
+ for (r = 0; r < UNIFI_MAX_DATA_REFERENCES; r++)
+ {
+ UNIFI_INIT_BULK_DATA(&card->fh_traffic_q_body[k][i].bulkdata[r]);
+ }
+ }
+ }
+
+ card->memory_resources_allocated = 1;
+
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+} /* card_allocate_memory_resources() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_free_bulk_data
+ *
+ * Free the data associated to a bulk data structure.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * bulk_data_slot Pointer to bulk data structure
+ *
+ * Returns:
+ * None.
+ *
+ * ---------------------------------------------------------------------------
+ */
+static void unifi_free_bulk_data(card_t *card, bulk_data_desc_t *bulk_data_slot)
+{
+ if (bulk_data_slot->data_length != 0)
+ {
+ unifi_net_data_free(card->ospriv, bulk_data_slot);
+ }
+} /* unifi_free_bulk_data() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_free_memory_resources
+ *
+ * Frees memory allocated for the from-host, to-host bulk data slots,
+ * soft queue buffers and bulk data buffers.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void card_free_memory_resources(card_t *card)
+{
+ func_enter();
+
+ unifi_trace(card->ospriv, UDBG1, "Freeing card memory resources.\n");
+
+ /* Clear our internal queues */
+ unifi_cancel_pending_signals(card);
+
+
+ if (card->to_host_data)
+ {
+ CsrMemFree(card->to_host_data);
+ card->to_host_data = NULL;
+ }
+
+ if (card->from_host_data)
+ {
+ CsrMemFree(card->from_host_data);
+ card->from_host_data = NULL;
+ }
+
+ /* free the memory for slot host tag mapping array */
+ if (card->fh_slot_host_tag_record)
+ {
+ CsrMemFree(card->fh_slot_host_tag_record);
+ card->fh_slot_host_tag_record = NULL;
+ }
+
+ if (card->fh_buffer.buf)
+ {
+ CsrMemFreeDma(card->fh_buffer.buf);
+ }
+ card->fh_buffer.ptr = card->fh_buffer.buf = NULL;
+ card->fh_buffer.bufsize = 0;
+ card->fh_buffer.count = 0;
+
+ if (card->th_buffer.buf)
+ {
+ CsrMemFreeDma(card->th_buffer.buf);
+ }
+ card->th_buffer.ptr = card->th_buffer.buf = NULL;
+ card->th_buffer.bufsize = 0;
+ card->th_buffer.count = 0;
+
+
+ card->memory_resources_allocated = 0;
+
+ func_exit();
+} /* card_free_memory_resources() */
+
+
+static void card_init_soft_queues(card_t *card)
+{
+ CsrInt16 i;
+
+ func_enter();
+
+ unifi_trace(card->ospriv, UDBG1, "Initialising internal signal queues.\n");
+ /* Reset any state carried forward from a previous life */
+ card->fh_command_queue.q_rd_ptr = 0;
+ card->fh_command_queue.q_wr_ptr = 0;
+ (void)CsrSnprintf(card->fh_command_queue.name, UNIFI_QUEUE_NAME_MAX_LENGTH,
+ "fh_cmd_q");
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ card->fh_traffic_queue[i].q_rd_ptr = 0;
+ card->fh_traffic_queue[i].q_wr_ptr = 0;
+ (void)CsrSnprintf(card->fh_traffic_queue[i].name,
+ UNIFI_QUEUE_NAME_MAX_LENGTH, "fh_data_q%d", i);
+ }
+#ifndef CSR_WIFI_HIP_TA_DISABLE
+ unifi_ta_sampling_init(card);
+#endif
+ func_exit();
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_cancel_pending_signals
+ *
+ * Free the signals and associated bulk data, pending in the core.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void unifi_cancel_pending_signals(card_t *card)
+{
+ CsrInt16 i, n, r;
+ func_enter();
+
+ unifi_trace(card->ospriv, UDBG1, "Canceling pending signals.\n");
+
+ if (card->to_host_data)
+ {
+ /*
+ * Free any bulk data buffers allocated for the t-h slots
+ * This will clear all buffers that did not make it to
+ * unifi_receive_event() before cancel was request.
+ */
+ n = card->config_data.num_tohost_data_slots;
+ unifi_trace(card->ospriv, UDBG3, "Freeing to-host resources, %d slots.\n", n);
+ for (i = 0; i < n; i++)
+ {
+ unifi_free_bulk_data(card, &card->to_host_data[i]);
+ }
+ }
+
+ /*
+ * If any of the from-host bulk data has reached the card->from_host_data
+ * but not UniFi, we need to free the buffers here.
+ */
+ if (card->from_host_data)
+ {
+ /* Free any bulk data buffers allocated for the f-h slots */
+ n = card->config_data.num_fromhost_data_slots;
+ unifi_trace(card->ospriv, UDBG3, "Freeing from-host resources, %d slots.\n", n);
+ for (i = 0; i < n; i++)
+ {
+ unifi_free_bulk_data(card, &card->from_host_data[i].bd);
+ }
+
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ card->dynamic_slot_data.from_host_used_slots[i] = 0;
+ card->dynamic_slot_data.from_host_max_slots[i] = 0;
+ card->dynamic_slot_data.from_host_reserved_slots[i] = 0;
+ }
+ }
+
+ /*
+ * Free any bulk data buffers allocated in the soft queues.
+ * This covers the case where a bulk data pointer has reached the soft queue
+ * but not the card->from_host_data.
+ */
+ unifi_trace(card->ospriv, UDBG3, "Freeing cmd q resources.\n");
+ for (i = 0; i < UNIFI_SOFT_COMMAND_Q_LENGTH; i++)
+ {
+ for (r = 0; r < UNIFI_MAX_DATA_REFERENCES; r++)
+ {
+ unifi_free_bulk_data(card, &card->fh_command_q_body[i].bulkdata[r]);
+ }
+ }
+
+ unifi_trace(card->ospriv, UDBG3, "Freeing traffic q resources.\n");
+ for (n = 0; n < UNIFI_NO_OF_TX_QS; n++)
+ {
+ for (i = 0; i < UNIFI_SOFT_TRAFFIC_Q_LENGTH; i++)
+ {
+ for (r = 0; r < UNIFI_MAX_DATA_REFERENCES; r++)
+ {
+ unifi_free_bulk_data(card, &card->fh_traffic_q_body[n][i].bulkdata[r]);
+ }
+ }
+ }
+
+ card_init_soft_queues(card);
+
+ func_exit();
+} /* unifi_cancel_pending_signals() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_free_card
+ *
+ * Free the memory allocated for the card structure and buffers.
+ *
+ * Notes:
+ * The porting layer is responsible for freeing any mini-coredump buffers
+ * allocated when it called unifi_coredump_init(), by calling
+ * unifi_coredump_free() before calling this function.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void unifi_free_card(card_t *card)
+{
+ func_enter();
+#ifdef CSR_PRE_ALLOC_NET_DATA
+ prealloc_netdata_free(card);
+#endif
+ /* Free any memory allocated. */
+ card_free_memory_resources(card);
+
+ /* Warn if caller didn't free coredump buffers */
+ if (card->dump_buf)
+ {
+ unifi_error(card->ospriv, "Caller should call unifi_coredump_free()\n");
+ unifi_coredump_free(card); /* free anyway to prevent memory leak */
+ }
+
+ CsrMemFree(card);
+
+ func_exit();
+} /* unifi_free_card() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_init_slots
+ *
+ * Allocate memory for host-side slot data and signal queues.
+ *
+ * Arguments:
+ * card Pointer to card object
+ *
+ * Returns:
+ * CSR error code.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult card_init_slots(card_t *card)
+{
+ CsrResult r;
+ CsrUint8 i;
+
+ func_enter();
+
+ /* Allocate the buffers we need, only once. */
+ if (card->memory_resources_allocated == 1)
+ {
+ card_free_memory_resources(card);
+ }
+ else
+ {
+ /* Initialise our internal command and traffic queues */
+ card_init_soft_queues(card);
+ }
+
+ r = card_allocate_memory_resources(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to allocate card memory resources.\n");
+ card_free_memory_resources(card);
+ func_exit_r(r);
+ return r;
+ }
+
+ if (card->sdio_ctrl_addr == 0)
+ {
+ unifi_error(card->ospriv, "Failed to find config struct!\n");
+ func_exit_r(CSR_WIFI_HIP_RESULT_INVALID_VALUE);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ /*
+ * Set initial counts.
+ */
+
+ card->from_host_data_head = 0;
+
+ /* Get initial signal counts from UniFi, in case it has not been reset. */
+ {
+ CsrUint16 s;
+
+ /* Get the from-host-signals-written count */
+ r = unifi_card_read16(card, card->sdio_ctrl_addr + 0, &s);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read from-host sig written count\n");
+ func_exit_r(r);
+ return r;
+ }
+ card->from_host_signals_w = (CsrInt16)s;
+
+ /* Get the to-host-signals-written count */
+ r = unifi_card_read16(card, card->sdio_ctrl_addr + 6, &s);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read to-host sig read count\n");
+ func_exit_r(r);
+ return r;
+ }
+ card->to_host_signals_r = (CsrInt16)s;
+ }
+
+ /* Set Initialised flag. */
+ r = unifi_card_write16(card, card->init_flag_addr, 0x0001);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write initialised flag\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ /* Dynamic queue reservation */
+ CsrMemSet(&card->dynamic_slot_data, 0, sizeof(card_dynamic_slot_t));
+
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ card->dynamic_slot_data.from_host_max_slots[i] = card->config_data.num_fromhost_data_slots -
+ UNIFI_RESERVED_COMMAND_SLOTS;
+ card->dynamic_slot_data.queue_stable[i] = FALSE;
+ }
+
+ card->dynamic_slot_data.packets_interval = UNIFI_PACKETS_INTERVAL;
+
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+} /* card_init_slots() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_set_udi_hook
+ *
+ * Registers the udi hook that reports the sent signals to the core.
+ *
+ * Arguments:
+ * card Pointer to the card context struct
+ * udi_fn Pointer to the callback function.
+ *
+ * Returns:
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE if the card pointer is invalid,
+ * CSR_RESULT_SUCCESS on success.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_set_udi_hook(card_t *card, udi_func_t udi_fn)
+{
+ if (card == NULL)
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ if (card->udi_hook == NULL)
+ {
+ card->udi_hook = udi_fn;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_set_udi_hook() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_remove_udi_hook
+ *
+ * Removes the udi hook that reports the sent signals from the core.
+ *
+ * Arguments:
+ * card Pointer to the card context struct
+ * udi_fn Pointer to the callback function.
+ *
+ * Returns:
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE if the card pointer is invalid,
+ * CSR_RESULT_SUCCESS on success.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_remove_udi_hook(card_t *card, udi_func_t udi_fn)
+{
+ if (card == NULL)
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ if (card->udi_hook == udi_fn)
+ {
+ card->udi_hook = NULL;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_remove_udi_hook() */
+
+
+static void CardReassignDynamicReservation(card_t *card)
+{
+ CsrUint8 i;
+
+ func_enter();
+
+ unifi_trace(card->ospriv, UDBG5, "Packets Txed %d %d %d %d\n",
+ card->dynamic_slot_data.packets_txed[0],
+ card->dynamic_slot_data.packets_txed[1],
+ card->dynamic_slot_data.packets_txed[2],
+ card->dynamic_slot_data.packets_txed[3]);
+
+ /* Clear reservation and recalculate max slots */
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ card->dynamic_slot_data.queue_stable[i] = FALSE;
+ card->dynamic_slot_data.from_host_reserved_slots[i] = 0;
+ card->dynamic_slot_data.from_host_max_slots[i] = card->config_data.num_fromhost_data_slots -
+ UNIFI_RESERVED_COMMAND_SLOTS;
+ card->dynamic_slot_data.packets_txed[i] = 0;
+
+ unifi_trace(card->ospriv, UDBG5, "CardReassignDynamicReservation: queue %d reserved %d Max %d\n", i,
+ card->dynamic_slot_data.from_host_reserved_slots[i],
+ card->dynamic_slot_data.from_host_max_slots[i]);
+ }
+
+ card->dynamic_slot_data.total_packets_txed = 0;
+ func_exit();
+}
+
+
+/* Algorithm to dynamically reserve slots. The logic is based mainly on the outstanding queue
+ * length. Slots are reserved for particular queues during an interval and cleared after the interval.
+ * Each queue has three associated variables.. a) used slots - the number of slots currently occupied
+ * by the queue b) reserved slots - number of slots reserved specifically for the queue c) max slots - total
+ * slots that this queue can actually use (may be higher than reserved slots and is dependent on reserved slots
+ * for other queues).
+ * This function is called when there are no slots available for a queue. It checks to see if there are enough
+ * unreserved slots sufficient for this request. If available these slots are reserved for the queue.
+ * If there are not enough unreserved slots, a fair share for each queue is calculated based on the total slots
+ * and the number of active queues (any queue with existing reservation is considered active). Queues needing
+ * less than their fair share are allowed to have the previously reserved slots. The remaining slots are
+ * distributed evenly among queues that need more than the fair share
+ *
+ * A better scheme would take current bandwidth per AC into consideration when reserving slots. An
+ * implementation scheme could consider the relative time/service period for slots in an AC. If the firmware
+ * services other ACs faster than a particular AC (packets wait in the slots longer) then it is fair to reserve
+ * less slots for the AC
+ */
+static void CardCheckDynamicReservation(card_t *card, unifi_TrafficQueue queue)
+{
+ CsrUint16 q_len, active_queues = 0, excess_queue_slots, div_extra_slots,
+ queue_fair_share, reserved_slots = 0, q, excess_need_queues = 0, unmovable_slots = 0;
+ CsrInt32 i;
+ q_t *sigq;
+ CsrUint16 num_data_slots = card->config_data.num_fromhost_data_slots - UNIFI_RESERVED_COMMAND_SLOTS;
+
+ func_enter();
+
+ /* Calculate the pending queue length */
+ sigq = &card->fh_traffic_queue[queue];
+ q_len = CSR_WIFI_HIP_Q_SLOTS_USED(sigq);
+
+ if (q_len <= card->dynamic_slot_data.from_host_reserved_slots[queue])
+ {
+ unifi_trace(card->ospriv, UDBG5, "queue %d q_len %d already has that many reserved slots, exiting\n", queue, q_len);
+ func_exit();
+ return;
+ }
+
+ /* Upper limit */
+ if (q_len > num_data_slots)
+ {
+ q_len = num_data_slots;
+ }
+
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ if (i != (CsrInt32)queue)
+ {
+ reserved_slots += card->dynamic_slot_data.from_host_reserved_slots[i];
+ }
+ if ((i == (CsrInt32)queue) || (card->dynamic_slot_data.from_host_reserved_slots[i] > 0))
+ {
+ active_queues++;
+ }
+ }
+
+ unifi_trace(card->ospriv, UDBG5, "CardCheckDynamicReservation: queue %d q_len %d\n", queue, q_len);
+ unifi_trace(card->ospriv, UDBG5, "Active queues %d reserved slots on other queues %d\n",
+ active_queues, reserved_slots);
+
+ if (reserved_slots + q_len <= num_data_slots)
+ {
+ card->dynamic_slot_data.from_host_reserved_slots[queue] = q_len;
+ if (q_len == num_data_slots)
+ {
+ /* This is the common case when just 1 stream is going */
+ card->dynamic_slot_data.queue_stable[queue] = TRUE;
+ }
+ }
+ else
+ {
+ queue_fair_share = num_data_slots / active_queues;
+ unifi_trace(card->ospriv, UDBG5, "queue fair share %d\n", queue_fair_share);
+
+ /* Evenly distribute slots among active queues */
+ /* Find out the queues that need excess of fair share. Also find slots allocated
+ * to queues less than their fair share, these slots cannot be reallocated (unmovable slots) */
+
+ card->dynamic_slot_data.from_host_reserved_slots[queue] = q_len;
+
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ if (card->dynamic_slot_data.from_host_reserved_slots[i] > queue_fair_share)
+ {
+ excess_need_queues++;
+ }
+ else
+ {
+ unmovable_slots += card->dynamic_slot_data.from_host_reserved_slots[i];
+ }
+ }
+
+ unifi_trace(card->ospriv, UDBG5, "Excess need queues %d\n", excess_need_queues);
+
+ /* Now find the slots per excess demand queue */
+ excess_queue_slots = (num_data_slots - unmovable_slots) / excess_need_queues;
+ div_extra_slots = (num_data_slots - unmovable_slots) - excess_queue_slots * excess_need_queues;
+ for (i = UNIFI_NO_OF_TX_QS - 1; i >= 0; i--)
+ {
+ if (card->dynamic_slot_data.from_host_reserved_slots[i] > excess_queue_slots)
+ {
+ card->dynamic_slot_data.from_host_reserved_slots[i] = excess_queue_slots;
+ if (div_extra_slots > 0)
+ {
+ card->dynamic_slot_data.from_host_reserved_slots[i]++;
+ div_extra_slots--;
+ }
+ /* No more slots will be allocated to this queue during the current interval */
+ card->dynamic_slot_data.queue_stable[i] = TRUE;
+ unifi_trace(card->ospriv, UDBG5, "queue stable %d\n", i);
+ }
+ }
+ }
+
+ /* Redistribute max slots */
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ reserved_slots = 0;
+ for (q = 0; q < UNIFI_NO_OF_TX_QS; q++)
+ {
+ if (i != q)
+ {
+ reserved_slots += card->dynamic_slot_data.from_host_reserved_slots[q];
+ }
+ }
+
+ card->dynamic_slot_data.from_host_max_slots[i] = num_data_slots - reserved_slots;
+ unifi_trace(card->ospriv, UDBG5, "queue %d reserved %d Max %d\n", i,
+ card->dynamic_slot_data.from_host_reserved_slots[i],
+ card->dynamic_slot_data.from_host_max_slots[i]);
+ }
+
+ func_exit();
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CardClearFromHostDataSlot
+ *
+ * Clear a the given data slot, making it available again.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ * slot Index of the signal slot to clear.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void CardClearFromHostDataSlot(card_t *card, const CsrInt16 slot)
+{
+ CsrUint8 queue = card->from_host_data[slot].queue;
+ const void *os_data_ptr = card->from_host_data[slot].bd.os_data_ptr;
+
+ func_enter();
+
+ if (card->from_host_data[slot].bd.data_length == 0)
+ {
+ unifi_warning(card->ospriv,
+ "Surprise: request to clear an already free FH data slot: %d\n",
+ slot);
+ func_exit();
+ return;
+ }
+
+ if (os_data_ptr == NULL)
+ {
+ unifi_warning(card->ospriv,
+ "Clearing FH data slot %d: has null payload, len=%d\n",
+ slot, card->from_host_data[slot].bd.data_length);
+ }
+
+ /* Free card->from_host_data[slot].bd.os_net_ptr here. */
+ /* Mark slot as free by setting length to 0. */
+ unifi_free_bulk_data(card, &card->from_host_data[slot].bd);
+ if (queue < UNIFI_NO_OF_TX_QS)
+ {
+ if (card->dynamic_slot_data.from_host_used_slots[queue] == 0)
+ {
+ unifi_error(card->ospriv, "Goofed up used slots q = %d used slots = %d\n",
+ queue,
+ card->dynamic_slot_data.from_host_used_slots[queue]);
+ }
+ else
+ {
+ card->dynamic_slot_data.from_host_used_slots[queue]--;
+ }
+ card->dynamic_slot_data.packets_txed[queue]++;
+ card->dynamic_slot_data.total_packets_txed++;
+ if (card->dynamic_slot_data.total_packets_txed >= card->dynamic_slot_data.packets_interval)
+ {
+ CardReassignDynamicReservation(card);
+ }
+ }
+
+ unifi_trace(card->ospriv, UDBG4, "CardClearFromHostDataSlot: slot %d recycled %p\n", slot, os_data_ptr);
+
+ func_exit();
+} /* CardClearFromHostDataSlot() */
+
+
+#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
+/*
+ * ---------------------------------------------------------------------------
+ * CardClearFromHostDataSlotWithoutFreeingBulkData
+ *
+ * Clear the given data slot with out freeing the bulk data.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ * slot Index of the signal slot to clear.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void CardClearFromHostDataSlotWithoutFreeingBulkData(card_t *card, const CsrInt16 slot)
+{
+ CsrUint8 queue = card->from_host_data[slot].queue;
+
+ /* Initialise the from_host data slot so it can be re-used,
+ * Set length field in from_host_data array to 0.
+ */
+ UNIFI_INIT_BULK_DATA(&card->from_host_data[slot].bd);
+
+ queue = card->from_host_data[slot].queue;
+
+ if (queue < UNIFI_NO_OF_TX_QS)
+ {
+ if (card->dynamic_slot_data.from_host_used_slots[queue] == 0)
+ {
+ unifi_error(card->ospriv, "Goofed up used slots q = %d used slots = %d\n",
+ queue,
+ card->dynamic_slot_data.from_host_used_slots[queue]);
+ }
+ else
+ {
+ card->dynamic_slot_data.from_host_used_slots[queue]--;
+ }
+ card->dynamic_slot_data.packets_txed[queue]++;
+ card->dynamic_slot_data.total_packets_txed++;
+ if (card->dynamic_slot_data.total_packets_txed >=
+ card->dynamic_slot_data.packets_interval)
+ {
+ CardReassignDynamicReservation(card);
+ }
+ }
+} /* CardClearFromHostDataSlotWithoutFreeingBulkData() */
+
+
+#endif
+
+CsrUint16 CardGetDataSlotSize(card_t *card)
+{
+ return card->config_data.data_slot_size;
+} /* CardGetDataSlotSize() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CardGetFreeFromHostDataSlots
+ *
+ * Retrieve the number of from-host bulk data slots available.
+ *
+ * Arguments:
+ * card Pointer to the card context struct
+ *
+ * Returns:
+ * Number of free from-host bulk data slots.
+ * ---------------------------------------------------------------------------
+ */
+CsrUint16 CardGetFreeFromHostDataSlots(card_t *card)
+{
+ CsrUint16 i, n = 0;
+
+ func_enter();
+
+ /* First two slots reserved for MLME */
+ for (i = 0; i < card->config_data.num_fromhost_data_slots; i++)
+ {
+ if (card->from_host_data[i].bd.data_length == 0)
+ {
+ /* Free slot */
+ n++;
+ }
+ }
+
+ func_exit();
+ return n;
+} /* CardGetFreeFromHostDataSlots() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CardAreAllFromHostDataSlotsEmpty
+ *
+ * Returns the state of from-host bulk data slots.
+ *
+ * Arguments:
+ * card Pointer to the card context struct
+ *
+ * Returns:
+ * 1 The from-host bulk data slots are all empty (available).
+ * 0 Some or all the from-host bulk data slots are in use.
+ * ---------------------------------------------------------------------------
+ */
+CsrUint16 CardAreAllFromHostDataSlotsEmpty(card_t *card)
+{
+ CsrUint16 i;
+
+ for (i = 0; i < card->config_data.num_fromhost_data_slots; i++)
+ {
+ if (card->from_host_data[i].bd.data_length != 0)
+ {
+ return 0;
+ }
+ }
+
+ return 1;
+} /* CardGetFreeFromHostDataSlots() */
+
+
+static CsrResult unifi_identify_hw(card_t *card)
+{
+ func_enter();
+
+ card->chip_id = card->sdio_if->sdioId.cardId;
+ card->function = card->sdio_if->sdioId.sdioFunction;
+ card->sdio_io_block_size = card->sdio_if->blockSize;
+
+ /* If SDIO controller doesn't support byte mode CMD53, pad transfers to block sizes */
+ card->sdio_io_block_pad = (card->sdio_if->features & CSR_SDIO_FEATURE_BYTE_MODE)?FALSE : TRUE;
+
+ /*
+ * Setup the chip helper so that we can access the registers (and
+ * also tell what sub-type of HIP we should use).
+ */
+ card->helper = ChipHelper_GetVersionSdio((CsrUint8)card->chip_id);
+ if (!card->helper)
+ {
+ unifi_error(card->ospriv, "Null ChipHelper\n");
+ }
+
+ unifi_info(card->ospriv, "Chip ID 0x%02X Function %u Block Size %u Name %s(%s)\n",
+ card->chip_id, card->function, card->sdio_io_block_size,
+ ChipHelper_MarketingName(card->helper),
+ ChipHelper_FriendlyName(card->helper));
+
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+} /* unifi_identify_hw() */
+
+
+static CsrResult unifi_prepare_hw(card_t *card)
+{
+ CsrResult r;
+ CsrResult csrResult;
+ enum unifi_host_state old_state = card->host_state;
+
+ func_enter();
+
+ r = unifi_identify_hw(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to identify hw\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ unifi_trace(card->ospriv, UDBG1,
+ "%s mode SDIO\n", card->sdio_io_block_pad?"Block" : "Byte");
+ /*
+ * Chip must be a awake or blocks that are asleep may not get
+ * reset. We can only do this after we have read the chip_id.
+ */
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+
+ if (old_state == UNIFI_HOST_STATE_TORPID)
+ {
+ /* Ensure the initial clock rate is set; if a reset occured when the chip was
+ * TORPID, unifi_set_host_state() may have raised it to MAX.
+ */
+ csrResult = CsrSdioMaxBusClockFrequencySet(card->sdio_if, UNIFI_SDIO_CLOCK_INIT_HZ);
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ func_exit_r(r);
+ return r;
+ }
+ card->sdio_clock_speed = UNIFI_SDIO_CLOCK_INIT_HZ;
+ }
+
+ /*
+ * The WLAN function must be enabled to access MAILBOX2 and DEBUG_RST
+ * registers.
+ */
+ csrResult = CsrSdioFunctionEnable(card->sdio_if);
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ /* Can't enable WLAN function. Try resetting the SDIO block. */
+ unifi_error(card->ospriv, "Failed to re-enable function %d.\n", card->function);
+ func_exit_r(r);
+ return r;
+ }
+
+ /*
+ * Poke some registers to make sure the PLL has started,
+ * otherwise memory accesses are likely to fail.
+ */
+ bootstrap_chip_hw(card);
+
+ /* Try to read the chip version from register. */
+ r = unifi_read_chip_version(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ func_exit_r(r);
+ return r;
+ }
+
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+} /* unifi_prepare_hw() */
+
+
+static CsrResult unifi_read_chip_version(card_t *card)
+{
+ CsrUint32 gbl_chip_version;
+ CsrResult r;
+ CsrUint16 ver;
+
+ func_enter();
+
+ gbl_chip_version = ChipHelper_GBL_CHIP_VERSION(card->helper);
+
+ /* Try to read the chip version from register. */
+ if (gbl_chip_version != 0)
+ {
+ r = unifi_read_direct16(card, gbl_chip_version * 2, &ver);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read GBL_CHIP_VERSION\n");
+ func_exit_r(r);
+ return r;
+ }
+ card->chip_version = ver;
+ }
+ else
+ {
+ unifi_info(card->ospriv, "Unknown Chip ID, cannot locate GBL_CHIP_VERSION\n");
+ r = CSR_RESULT_FAILURE;
+ }
+
+ unifi_info(card->ospriv, "Chip Version 0x%04X\n", card->chip_version);
+
+ func_exit_r(r);
+ return r;
+} /* unifi_read_chip_version() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_reset_hardware
+ *
+ * Execute the UniFi reset sequence.
+ *
+ * Note: This may fail if the chip is going TORPID so retry at
+ * least once.
+ *
+ * Arguments:
+ * card - pointer to card context structure
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error otherwise.
+ *
+ * Notes:
+ * Some platforms (e.g. Windows Vista) do not allow access to registers
+ * that are necessary for a software soft reset.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult unifi_reset_hardware(card_t *card)
+{
+ CsrResult r;
+ CsrUint16 new_block_size = UNIFI_IO_BLOCK_SIZE;
+ CsrResult csrResult;
+
+ func_enter();
+
+ /* Errors returned by unifi_prepare_hw() are not critical at this point */
+ r = unifi_prepare_hw(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+
+ /* First try SDIO controller reset, which may power cycle the UniFi, assert
+ * its reset line, or not be implemented depending on the platform.
+ */
+ unifi_info(card->ospriv, "Calling CsrSdioHardReset\n");
+ csrResult = CsrSdioHardReset(card->sdio_if);
+ if (csrResult == CSR_RESULT_SUCCESS)
+ {
+ unifi_info(card->ospriv, "CsrSdioHardReset succeeded on reseting UniFi\n");
+ r = unifi_prepare_hw(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "unifi_prepare_hw failed after hard reset\n");
+ func_exit_r(r);
+ return r;
+ }
+ }
+ else if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+ else
+ {
+ /* Falling back to software hard reset methods */
+ unifi_info(card->ospriv, "Falling back to software hard reset\n");
+ r = unifi_card_hard_reset(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "software hard reset failed\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ /* If we fell back to unifi_card_hard_reset() methods, chip version may
+ * not have been read. (Note in the unlikely event that it is zero,
+ * it will be harmlessly read again)
+ */
+ if (card->chip_version == 0)
+ {
+ r = unifi_read_chip_version(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ func_exit_r(r);
+ return r;
+ }
+ }
+ }
+
+#ifdef CSR_WIFI_HIP_SDIO_BLOCK_SIZE
+ new_block_size = CSR_WIFI_HIP_SDIO_BLOCK_SIZE;
+#endif
+
+ /* After hard reset, we need to restore the SDIO block size */
+ csrResult = CsrSdioBlockSizeSet(card->sdio_if, new_block_size);
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+
+ /* Warn if a different block size was achieved by the transport */
+ if (card->sdio_if->blockSize != new_block_size)
+ {
+ unifi_info(card->ospriv,
+ "Actually got block size %d\n", card->sdio_if->blockSize);
+ }
+
+ /* sdio_io_block_size always needs be updated from the achieved block size,
+ * as it is used by the OS layer to allocate memory in unifi_net_malloc().
+ * Controllers which don't support block mode (e.g. CSPI) will report a
+ * block size of zero.
+ */
+ if (card->sdio_if->blockSize == 0)
+ {
+ unifi_info(card->ospriv, "Block size 0, block mode not available\n");
+
+ /* Set sdio_io_block_size to 1 so that unifi_net_data_malloc() has a
+ * sensible rounding value. Elsewhere padding will already be
+ * disabled because the controller supports byte mode.
+ */
+ card->sdio_io_block_size = 1;
+
+ /* Controller features must declare support for byte mode */
+ if (!(card->sdio_if->features & CSR_SDIO_FEATURE_BYTE_MODE))
+ {
+ unifi_error(card->ospriv, "Requires byte mode\n");
+ r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ }
+ else
+ {
+ /* Padding will be enabled if CSR_SDIO_FEATURE_BYTE_MODE isn't set */
+ card->sdio_io_block_size = card->sdio_if->blockSize;
+ }
+
+
+ func_exit_r(r);
+ return r;
+} /* unifi_reset_hardware() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_reset_method_io_enable
+ *
+ * Issue a hard reset to the hw writing the IO_ENABLE.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ *
+ * Returns:
+ * 0 on success,
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred or if a response
+ * was not seen in the expected time
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult card_reset_method_io_enable(card_t *card)
+{
+ CsrResult r;
+ CsrResult csrResult;
+
+ func_enter();
+
+ /*
+ * This resets only function 1, so should be used in
+ * preference to the method below (CSR_FUNC_EN)
+ */
+ unifi_trace(card->ospriv, UDBG1, "Hard reset (IO_ENABLE)\n");
+
+ csrResult = CsrSdioFunctionDisable(card->sdio_if);
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ unifi_warning(card->ospriv, "SDIO error writing IO_ENABLE: %d\n", r);
+ }
+ else
+ {
+ /* Delay here to let the reset take affect. */
+ CsrThreadSleep(RESET_SETTLE_DELAY);
+
+ r = card_wait_for_unifi_to_disable(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+
+ if (r == CSR_RESULT_SUCCESS)
+ {
+ r = card_wait_for_unifi_to_reset(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ }
+ }
+
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_trace(card->ospriv, UDBG1, "Hard reset (CSR_FUNC_EN)\n");
+
+ r = sdio_write_f0(card, SDIO_CSR_FUNC_EN, 0);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_warning(card->ospriv, "SDIO error writing SDIO_CSR_FUNC_EN: %d\n", r);
+ func_exit_r(r);
+ return r;
+ }
+ else
+ {
+ /* Delay here to let the reset take affect. */
+ CsrThreadSleep(RESET_SETTLE_DELAY);
+
+ r = card_wait_for_unifi_to_reset(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ }
+ }
+
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_warning(card->ospriv, "card_reset_method_io_enable failed to reset UniFi\n");
+ }
+
+ func_exit();
+ return r;
+} /* card_reset_method_io_enable() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_reset_method_dbg_reset
+ *
+ * Issue a hard reset to the hw writing the DBG_RESET.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success,
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred or if a response
+ * was not seen in the expected time
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult card_reset_method_dbg_reset(card_t *card)
+{
+ CsrResult r;
+
+ func_enter();
+
+ /*
+ * Prepare UniFi for h/w reset
+ */
+ if (card->host_state == UNIFI_HOST_STATE_TORPID)
+ {
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_DROWSY);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to set UNIFI_HOST_STATE_DROWSY\n");
+ func_exit_r(r);
+ return r;
+ }
+ CsrThreadSleep(5);
+ }
+
+ r = unifi_card_stop_processor(card, UNIFI_PROC_BOTH);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Can't stop processors\n");
+ func_exit();
+ return r;
+ }
+
+ unifi_trace(card->ospriv, UDBG1, "Hard reset (DBG_RESET)\n");
+
+ /*
+ * This register write may fail. The debug reset resets
+ * parts of the Function 0 sections of the chip, and
+ * therefore the response cannot be sent back to the host.
+ */
+ r = unifi_write_direct_8_or_16(card, ChipHelper_DBG_RESET(card->helper) * 2, 1);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_warning(card->ospriv, "SDIO error writing DBG_RESET: %d\n", r);
+ func_exit_r(r);
+ return r;
+ }
+
+ /* Delay here to let the reset take affect. */
+ CsrThreadSleep(RESET_SETTLE_DELAY);
+
+ r = card_wait_for_unifi_to_reset(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_warning(card->ospriv, "card_reset_method_dbg_reset failed to reset UniFi\n");
+ }
+
+ func_exit();
+ return r;
+} /* card_reset_method_dbg_reset() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_card_hard_reset
+ *
+ * Issue reset to hardware, by writing to registers on the card.
+ * Power to the card is preserved.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success,
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred or if a response
+ * was not seen in the expected time
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_card_hard_reset(card_t *card)
+{
+ CsrResult r;
+ const struct chip_helper_reset_values *init_data;
+ CsrUint32 chunks;
+
+ func_enter();
+
+ /* Clear cache of page registers */
+ card->proc_select = (CsrUint32)(-1);
+ card->dmem_page = (CsrUint32)(-1);
+ card->pmem_page = (CsrUint32)(-1);
+
+ /*
+ * We need to have a valid card->helper before we use software hard reset.
+ * If unifi_identify_hw() fails to get the card ID, it probably means
+ * that there is no way to talk to the h/w.
+ */
+ r = unifi_identify_hw(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "unifi_card_hard_reset failed to identify h/w\n");
+ func_exit();
+ return r;
+ }
+
+ /* Search for some reset code. */
+ chunks = ChipHelper_HostResetSequence(card->helper, &init_data);
+ if (chunks != 0)
+ {
+ unifi_error(card->ospriv,
+ "Hard reset (Code download) is unsupported\n");
+
+ func_exit_r(CSR_RESULT_FAILURE);
+ return CSR_RESULT_FAILURE;
+ }
+
+ if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
+ {
+ /* The HIP spec considers this a bus-specific reset.
+ * This resets only function 1, so should be used in
+ * preference to the method below (CSR_FUNC_EN)
+ * If this method fails, it means that the f/w is probably
+ * not running. In this case, try the DBG_RESET method.
+ */
+ r = card_reset_method_io_enable(card);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r == CSR_RESULT_SUCCESS)
+ {
+ func_exit();
+ return r;
+ }
+ }
+
+ /* Software hard reset */
+ r = card_reset_method_dbg_reset(card);
+
+ func_exit_r(r);
+ return r;
+} /* unifi_card_hard_reset() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * CardGenInt
+ *
+ * Prod the card.
+ * This function causes an internal interrupt to be raised in the
+ * UniFi chip. It is used to signal the firmware that some action has
+ * been completed.
+ * The UniFi Host Interface asks that the value used increments for
+ * debugging purposes.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success,
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred or if a response
+ * was not seen in the expected time
+ * ---------------------------------------------------------------------------
+ */
+CsrResult CardGenInt(card_t *card)
+{
+ CsrResult r;
+
+ func_enter();
+
+ if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
+ {
+ r = sdio_write_f0(card, SDIO_CSR_FROM_HOST_SCRATCH0,
+ (CsrUint8)card->unifi_interrupt_seq);
+ }
+ else
+ {
+ r = unifi_write_direct_8_or_16(card,
+ ChipHelper_SHARED_IO_INTERRUPT(card->helper) * 2,
+ (CsrUint8)card->unifi_interrupt_seq);
+ }
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "SDIO error writing UNIFI_SHARED_IO_INTERRUPT: %d\n", r);
+ func_exit_r(r);
+ return r;
+ }
+
+ card->unifi_interrupt_seq++;
+
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+} /* CardGenInt() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CardEnableInt
+ *
+ * Enable the outgoing SDIO interrupt from UniFi to the host.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success,
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred,
+ * ---------------------------------------------------------------------------
+ */
+CsrResult CardEnableInt(card_t *card)
+{
+ CsrResult r;
+ CsrUint8 int_enable;
+
+ r = sdio_read_f0(card, SDIO_INT_ENABLE, &int_enable);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "SDIO error reading SDIO_INT_ENABLE\n");
+ return r;
+ }
+
+ int_enable |= (1 << card->function) | UNIFI_SD_INT_ENABLE_IENM;
+
+ r = sdio_write_f0(card, SDIO_INT_ENABLE, int_enable);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "SDIO error writing SDIO_INT_ENABLE\n");
+ return r;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CardEnableInt() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CardDisableInt
+ *
+ * Disable the outgoing SDIO interrupt from UniFi to the host.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success,
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred,
+ * ---------------------------------------------------------------------------
+ */
+CsrResult CardDisableInt(card_t *card)
+{
+ CsrResult r;
+ CsrUint8 int_enable;
+
+ r = sdio_read_f0(card, SDIO_INT_ENABLE, &int_enable);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "SDIO error reading SDIO_INT_ENABLE\n");
+ return r;
+ }
+
+ int_enable &= ~(1 << card->function);
+
+ r = sdio_write_f0(card, SDIO_INT_ENABLE, int_enable);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "SDIO error writing SDIO_INT_ENABLE\n");
+ return r;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CardDisableInt() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CardPendingInt
+ *
+ * Determine whether UniFi is currently asserting the SDIO interrupt
+ * request.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ * pintr Pointer to location to write interrupt status,
+ * TRUE if interrupt pending,
+ * FALSE if no interrupt pending.
+ * Returns:
+ * CSR_RESULT_SUCCESS interrupt status read successfully
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred,
+ * ---------------------------------------------------------------------------
+ */
+CsrResult CardPendingInt(card_t *card, CsrBool *pintr)
+{
+ CsrResult r;
+ CsrUint8 pending;
+
+ *pintr = FALSE;
+
+ r = sdio_read_f0(card, SDIO_INT_PENDING, &pending);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "SDIO error reading SDIO_INT_PENDING\n");
+ return r;
+ }
+
+ *pintr = (pending & (1 << card->function))?TRUE : FALSE;
+
+ return CSR_RESULT_SUCCESS;
+} /* CardPendingInt() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CardClearInt
+ *
+ * Clear the UniFi SDIO interrupt request.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS if pending interrupt was cleared, or no pending interrupt.
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred,
+ * ---------------------------------------------------------------------------
+ */
+CsrResult CardClearInt(card_t *card)
+{
+ CsrResult r;
+ CsrBool intr;
+
+ if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
+ {
+ /* CardPendingInt() sets intr, if there is a pending interrupt */
+ r = CardPendingInt(card, &intr);
+ if (intr == FALSE)
+ {
+ return r;
+ }
+
+ r = sdio_write_f0(card, SDIO_CSR_HOST_INT_CLEAR, 1);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "SDIO error writing SDIO_CSR_HOST_INT_CLEAR\n");
+ }
+ }
+ else
+ {
+ r = unifi_write_direct_8_or_16(card,
+ ChipHelper_SDIO_HOST_INT(card->helper) * 2,
+ 0);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "SDIO error writing UNIFI_SDIO_HOST_INT\n");
+ }
+ }
+
+ return r;
+} /* CardClearInt() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CardIntEnabled
+ *
+ * Determine whether UniFi is currently asserting the SDIO interrupt
+ * request.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ * enabled Pointer to location to write interrupt enable status,
+ * TRUE if interrupts enabled,
+ * FALSE if interupts disabled.
+ *
+ * Returns:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred,
+ * ---------------------------------------------------------------------------
+ */
+CsrResult CardIntEnabled(card_t *card, CsrBool *enabled)
+{
+ CsrResult r;
+ CsrUint8 int_enable;
+
+ r = sdio_read_f0(card, SDIO_INT_ENABLE, &int_enable);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "SDIO error reading SDIO_INT_ENABLE\n");
+ return r;
+ }
+
+ *enabled = (int_enable & (1 << card->function))?TRUE : FALSE;
+
+ return CSR_RESULT_SUCCESS;
+} /* CardIntEnabled() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CardWriteBulkData
+ * Allocate slot in the pending bulkdata arrays and assign it to a signal's
+ * bulkdata reference. The slot is then ready for UniFi's bulkdata commands
+ * to transfer the data to/from the host.
+ *
+ * Arguments:
+ * card Pointer to Card object
+ * csptr Pending signal pointer, including bulkdata ref
+ * queue Traffic queue that this signal is using
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS if a free slot was assigned
+ * CSR_RESULT_FAILURE if no slot was available
+ * ---------------------------------------------------------------------------
+ */
+CsrResult CardWriteBulkData(card_t *card, card_signal_t *csptr, unifi_TrafficQueue queue)
+{
+ CsrUint16 i, slots[UNIFI_MAX_DATA_REFERENCES], j = 0;
+ CsrUint8 *packed_sigptr, num_slots_required = 0;
+ bulk_data_desc_t *bulkdata = csptr->bulkdata;
+ CsrInt16 h, nslots;
+
+ func_enter();
+
+ /* Count the number of slots required */
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
+ {
+ if (bulkdata[i].data_length != 0)
+ {
+ num_slots_required++;
+ }
+ }
+
+ /* Get the slot numbers */
+ if (num_slots_required != 0)
+ {
+ /* Last 2 slots for MLME */
+ if (queue == UNIFI_TRAFFIC_Q_MLME)
+ {
+ h = card->config_data.num_fromhost_data_slots - UNIFI_RESERVED_COMMAND_SLOTS;
+ for (i = 0; i < card->config_data.num_fromhost_data_slots; i++)
+ {
+ if (card->from_host_data[h].bd.data_length == 0)
+ {
+ /* Free data slot, claim it */
+ slots[j++] = h;
+ if (j == num_slots_required)
+ {
+ break;
+ }
+ }
+
+ if (++h >= card->config_data.num_fromhost_data_slots)
+ {
+ h = 0;
+ }
+ }
+ }
+ else
+ {
+ if (card->dynamic_slot_data.from_host_used_slots[queue]
+ < card->dynamic_slot_data.from_host_max_slots[queue])
+ {
+ /* Data commands get a free slot only after a few checks */
+ nslots = card->config_data.num_fromhost_data_slots - UNIFI_RESERVED_COMMAND_SLOTS;
+
+ h = card->from_host_data_head;
+
+ for (i = 0; i < nslots; i++)
+ {
+ if (card->from_host_data[h].bd.data_length == 0)
+ {
+ /* Free data slot, claim it */
+ slots[j++] = h;
+ if (j == num_slots_required)
+ {
+ break;
+ }
+ }
+
+ if (++h >= nslots)
+ {
+ h = 0;
+ }
+ }
+ card->from_host_data_head = h;
+ }
+ }
+
+ /* Required number of slots are not available, bail out */
+ if (j != num_slots_required)
+ {
+ unifi_trace(card->ospriv, UDBG5, "CardWriteBulkData: didn't find free slot/s\n");
+
+ /* If we haven't already reached the stable state we can ask for reservation */
+ if ((queue != UNIFI_TRAFFIC_Q_MLME) && (card->dynamic_slot_data.queue_stable[queue] == FALSE))
+ {
+ CardCheckDynamicReservation(card, queue);
+ }
+
+ for (i = 0; i < card->config_data.num_fromhost_data_slots; i++)
+ {
+ unifi_trace(card->ospriv, UDBG5, "fh data slot %d: %d\n", i, card->from_host_data[i].bd.data_length);
+ }
+ func_exit();
+ return CSR_RESULT_FAILURE;
+ }
+ }
+
+ packed_sigptr = csptr->sigbuf;
+
+ /* Fill in the slots with data */
+ j = 0;
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
+ {
+ if (bulkdata[i].data_length == 0)
+ {
+ /* Zero-out the DATAREF in the signal */
+ SET_PACKED_DATAREF_SLOT(packed_sigptr, i, 0);
+ SET_PACKED_DATAREF_LEN(packed_sigptr, i, 0);
+ }
+ else
+ {
+ /*
+ * Fill in the slot number in the SIGNAL structure but
+ * preserve the offset already in there
+ */
+ SET_PACKED_DATAREF_SLOT(packed_sigptr, i, slots[j] | (((CsrUint16)packed_sigptr[SIZEOF_SIGNAL_HEADER + (i * SIZEOF_DATAREF) + 1]) << 8));
+ SET_PACKED_DATAREF_LEN(packed_sigptr, i, bulkdata[i].data_length);
+
+ /* Do not copy the data, just store the information to them */
+ card->from_host_data[slots[j]].bd.os_data_ptr = bulkdata[i].os_data_ptr;
+ card->from_host_data[slots[j]].bd.os_net_buf_ptr = bulkdata[i].os_net_buf_ptr;
+ card->from_host_data[slots[j]].bd.data_length = bulkdata[i].data_length;
+ card->from_host_data[slots[j]].bd.net_buf_length = bulkdata[i].net_buf_length;
+ card->from_host_data[slots[j]].queue = queue;
+
+ unifi_trace(card->ospriv, UDBG4, "CardWriteBulkData sig=0x%x, fh slot %d = %p\n",
+ GET_SIGNAL_ID(packed_sigptr), i, bulkdata[i].os_data_ptr);
+
+ /* Sanity-check that the bulk data desc being assigned to the slot
+ * actually has a payload.
+ */
+ if (!bulkdata[i].os_data_ptr)
+ {
+ unifi_error(card->ospriv, "Assign null os_data_ptr (len=%d) fh slot %d, i=%d, q=%d, sig=0x%x",
+ bulkdata[i].data_length, slots[j], i, queue, GET_SIGNAL_ID(packed_sigptr));
+ }
+
+ j++;
+ if (queue < UNIFI_NO_OF_TX_QS)
+ {
+ card->dynamic_slot_data.from_host_used_slots[queue]++;
+ }
+ }
+ }
+
+ func_exit();
+
+ return CSR_RESULT_SUCCESS;
+} /* CardWriteBulkData() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_find_data_slot
+ *
+ * Dereference references to bulk data slots into pointers to real data.
+ *
+ * Arguments:
+ * card Pointer to the card struct.
+ * slot Slot number from a signal structure
+ *
+ * Returns:
+ * Pointer to entry in bulk_data_slot array.
+ * ---------------------------------------------------------------------------
+ */
+bulk_data_desc_t* card_find_data_slot(card_t *card, CsrInt16 slot)
+{
+ CsrInt16 sn;
+ bulk_data_desc_t *bd;
+
+ sn = slot & 0x7FFF;
+
+ /* ?? check sanity of slot number ?? */
+
+ if (slot & SLOT_DIR_TO_HOST)
+ {
+ bd = &card->to_host_data[sn];
+ }
+ else
+ {
+ bd = &card->from_host_data[sn].bd;
+ }
+
+ return bd;
+} /* card_find_data_slot() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * firmware_present_in_flash
+ *
+ * Probe for external Flash that looks like it might contain firmware.
+ *
+ * If Flash is not present, reads always return 0x0008.
+ * If Flash is present, but empty, reads return 0xFFFF.
+ * Anything else is considered to be firmware.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS firmware is present in ROM or flash
+ * CSR_WIFI_HIP_RESULT_NOT_FOUND firmware is not present in ROM or flash
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult firmware_present_in_flash(card_t *card)
+{
+ CsrResult r;
+ CsrUint16 m1, m5;
+
+ if (ChipHelper_HasRom(card->helper))
+ {
+ return CSR_RESULT_SUCCESS;
+ }
+ if (!ChipHelper_HasFlash(card->helper))
+ {
+ return CSR_WIFI_HIP_RESULT_NOT_FOUND;
+ }
+
+ /*
+ * Examine the Flash locations that are the power-on default reset
+ * vectors of the XAP processors.
+ * These are words 1 and 5 in Flash.
+ */
+ r = unifi_card_read16(card, UNIFI_MAKE_GP(EXT_FLASH, 2), &m1);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ r = unifi_card_read16(card, UNIFI_MAKE_GP(EXT_FLASH, 10), &m5);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ /* Check for uninitialised/missing flash */
+ if ((m1 == 0x0008) || (m1 == 0xFFFF) ||
+ (m1 == 0x0004) || (m5 == 0x0004) ||
+ (m5 == 0x0008) || (m5 == 0xFFFF))
+ {
+ return CSR_WIFI_HIP_RESULT_NOT_FOUND;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* firmware_present_in_flash() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * bootstrap_chip_hw
+ *
+ * Perform chip specific magic to "Get It Working" TM. This will
+ * increase speed of PLLs in analogue and maybe enable some
+ * on-chip regulators.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void bootstrap_chip_hw(card_t *card)
+{
+ const struct chip_helper_init_values *vals;
+ CsrUint32 i, len;
+ void *sdio = card->sdio_if;
+ CsrResult csrResult;
+
+ len = ChipHelper_ClockStartupSequence(card->helper, &vals);
+ if (len != 0)
+ {
+ for (i = 0; i < len; i++)
+ {
+ csrResult = CsrSdioWrite16(sdio, vals[i].addr * 2, vals[i].value);
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_warning(card->ospriv, "Failed to write bootstrap value %d\n", i);
+ /* Might not be fatal */
+ }
+
+ CsrThreadSleep(1);
+ }
+ }
+} /* bootstrap_chip_hw() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_card_stop_processor
+ *
+ * Stop the UniFi XAP processors.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * which One of UNIFI_PROC_MAC, UNIFI_PROC_PHY, UNIFI_PROC_BOTH
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS if successful, or CSR error code
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_card_stop_processor(card_t *card, enum unifi_dbg_processors_select which)
+{
+ CsrResult r = CSR_RESULT_SUCCESS;
+ CsrUint8 status;
+ CsrInt16 retry = 100;
+
+ while (retry--)
+ {
+ /* Select both XAPs */
+ r = unifi_set_proc_select(card, which);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ break;
+ }
+
+ /* Stop processors */
+ r = unifi_write_direct16(card, ChipHelper_DBG_EMU_CMD(card->helper) * 2, 2);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ break;
+ }
+
+ /* Read status */
+ r = unifi_read_direct_8_or_16(card,
+ ChipHelper_DBG_HOST_STOP_STATUS(card->helper) * 2,
+ &status);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ break;
+ }
+
+ if ((status & 1) == 1)
+ {
+ /* Success! */
+ return CSR_RESULT_SUCCESS;
+ }
+
+ /* Processors didn't stop, try again */
+ }
+
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ /* An SDIO error occurred */
+ unifi_error(card->ospriv, "Failed to stop processors: SDIO error\n");
+ }
+ else
+ {
+ /* If we reach here, we didn't the status in time. */
+ unifi_error(card->ospriv, "Failed to stop processors: timeout waiting for stopped status\n");
+ r = CSR_RESULT_FAILURE;
+ }
+
+ return r;
+} /* unifi_card_stop_processor() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * card_start_processor
+ *
+ * Start the UniFi XAP processors.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * which One of UNIFI_PROC_MAC, UNIFI_PROC_PHY, UNIFI_PROC_BOTH
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS or CSR error code
+ * ---------------------------------------------------------------------------
+ */
+CsrResult card_start_processor(card_t *card, enum unifi_dbg_processors_select which)
+{
+ CsrResult r;
+
+ /* Select both XAPs */
+ r = unifi_set_proc_select(card, which);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "unifi_set_proc_select failed: %d.\n", r);
+ return r;
+ }
+
+
+ r = unifi_write_direct_8_or_16(card,
+ ChipHelper_DBG_EMU_CMD(card->helper) * 2, 8);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ r = unifi_write_direct_8_or_16(card,
+ ChipHelper_DBG_EMU_CMD(card->helper) * 2, 0);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* card_start_processor() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_set_interrupt_mode
+ *
+ * Configure the interrupt processing mode used by the HIP
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * mode Interrupt mode to apply
+ *
+ * Returns:
+ * None
+ * ---------------------------------------------------------------------------
+ */
+void unifi_set_interrupt_mode(card_t *card, CsrUint32 mode)
+{
+ if (mode == CSR_WIFI_INTMODE_RUN_BH_ONCE)
+ {
+ unifi_info(card->ospriv, "Scheduled interrupt mode");
+ }
+ card->intmode = mode;
+} /* unifi_set_interrupt_mode() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_start_processors
+ *
+ * Start all UniFi XAP processors.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error code on error
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_start_processors(card_t *card)
+{
+ return card_start_processor(card, UNIFI_PROC_BOTH);
+} /* unifi_start_processors() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_request_max_sdio_clock
+ *
+ * Requests that the maximum SDIO clock rate is set at the next suitable
+ * opportunity (e.g. when the BH next runs, so as not to interfere with
+ * any current operation).
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * None
+ * ---------------------------------------------------------------------------
+ */
+void unifi_request_max_sdio_clock(card_t *card)
+{
+ card->request_max_clock = 1;
+} /* unifi_request_max_sdio_clock() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_set_host_state
+ *
+ * Set the host deep-sleep state.
+ *
+ * If transitioning to TORPID, the SDIO driver will be notified
+ * that the SD bus will be unused (idle) and conversely, when
+ * transitioning from TORPID that the bus will be used (active).
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * state New deep-sleep state.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE if the card was ejected
+ * CSR_RESULT_FAILURE if an SDIO error occurred
+ *
+ * Notes:
+ * We need to reduce the SDIO clock speed before trying to wake up the
+ * chip. Actually, in the implementation below we reduce the clock speed
+ * not just before we try to wake up the chip, but when we put the chip to
+ * deep sleep. This means that if the f/w wakes up on its' own, we waste
+ * a reduce/increace cycle. However, trying to eliminate this overhead is
+ * proved difficult, as the current state machine in the HIP lib does at
+ * least a CMD52 to disable the interrupts before we configure the host
+ * state.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_set_host_state(card_t *card, enum unifi_host_state state)
+{
+ CsrResult r = CSR_RESULT_SUCCESS;
+ CsrResult csrResult;
+ static const CsrCharString *const states[] = {
+ "AWAKE", "DROWSY", "TORPID"
+ };
+ static const CsrUint8 state_csr_host_wakeup[] = {
+ 1, 3, 0
+ };
+ static const CsrUint8 state_io_abort[] = {
+ 0, 2, 3
+ };
+
+ unifi_trace(card->ospriv, UDBG4, "State %s to %s\n",
+ states[card->host_state], states[state]);
+
+ if (card->host_state == UNIFI_HOST_STATE_TORPID)
+ {
+ CsrSdioFunctionActive(card->sdio_if);
+ }
+
+ /* Write the new state to UniFi. */
+ if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
+ {
+ r = sdio_write_f0(card, SDIO_CSR_HOST_WAKEUP,
+ (CsrUint8)((card->function << 4) | state_csr_host_wakeup[state]));
+ }
+ else
+ {
+ r = sdio_write_f0(card, SDIO_IO_ABORT, state_io_abort[state]);
+ }
+
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write UniFi deep sleep state\n");
+ }
+ else
+ {
+ /*
+ * If the chip was in state TORPID then we can now increase
+ * the maximum bus clock speed.
+ */
+ if (card->host_state == UNIFI_HOST_STATE_TORPID)
+ {
+ csrResult = CsrSdioMaxBusClockFrequencySet(card->sdio_if,
+ UNIFI_SDIO_CLOCK_MAX_HZ);
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ /* Non-fatal error */
+ if (r != CSR_RESULT_SUCCESS && r != CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ unifi_warning(card->ospriv,
+ "Failed to increase the SDIO clock speed\n");
+ }
+ else
+ {
+ card->sdio_clock_speed = UNIFI_SDIO_CLOCK_MAX_HZ;
+ }
+ }
+
+ /*
+ * Cache the current state in the card structure to avoid
+ * unnecessary SDIO reads.
+ */
+ card->host_state = state;
+
+ if (state == UNIFI_HOST_STATE_TORPID)
+ {
+ /*
+ * If the chip is now in state TORPID then we must now decrease
+ * the maximum bus clock speed.
+ */
+ csrResult = CsrSdioMaxBusClockFrequencySet(card->sdio_if,
+ UNIFI_SDIO_CLOCK_SAFE_HZ);
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ if (r != CSR_RESULT_SUCCESS && r != CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ unifi_warning(card->ospriv,
+ "Failed to decrease the SDIO clock speed\n");
+ }
+ else
+ {
+ card->sdio_clock_speed = UNIFI_SDIO_CLOCK_SAFE_HZ;
+ }
+ CsrSdioFunctionIdle(card->sdio_if);
+ }
+ }
+
+ return r;
+} /* unifi_set_host_state() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_card_info
+ *
+ * Update the card information data structure
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * card_info Pointer to info structure to update
+ *
+ * Returns:
+ * None
+ * ---------------------------------------------------------------------------
+ */
+void unifi_card_info(card_t *card, card_info_t *card_info)
+{
+ card_info->chip_id = card->chip_id;
+ card_info->chip_version = card->chip_version;
+ card_info->fw_build = card->build_id;
+ card_info->fw_hip_version = card->config_data.version;
+ card_info->sdio_block_size = card->sdio_io_block_size;
+} /* unifi_card_info() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_check_io_status
+ *
+ * Check UniFi for spontaneous reset and pending interrupt.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * status Pointer to location to write chip status:
+ * 0 if UniFi is running, and no interrupt pending
+ * 1 if UniFi has spontaneously reset
+ * 2 if there is a pending interrupt
+ * Returns:
+ * CSR_RESULT_SUCCESS if OK, or CSR error
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_check_io_status(card_t *card, CsrInt32 *status)
+{
+ CsrUint8 io_en;
+ CsrResult r;
+ CsrBool pending;
+
+ *status = 0;
+
+ r = sdio_read_f0(card, SDIO_IO_ENABLE, &io_en);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read SDIO_IO_ENABLE to check for spontaneous reset\n");
+ return r;
+ }
+
+ if ((io_en & (1 << card->function)) == 0)
+ {
+ CsrInt32 fw_count;
+ *status = 1;
+ unifi_error(card->ospriv, "UniFi has spontaneously reset.\n");
+
+ /*
+ * These reads are very likely to fail. We want to know if the function is really
+ * disabled or the SDIO driver just returns rubbish.
+ */
+ fw_count = unifi_read_shared_count(card, card->sdio_ctrl_addr + 4);
+ if (fw_count < 0)
+ {
+ unifi_error(card->ospriv, "Failed to read to-host sig written count\n");
+ }
+ else
+ {
+ unifi_error(card->ospriv, "thsw: %u (driver thinks is %u)\n",
+ fw_count, card->to_host_signals_w);
+ }
+ fw_count = unifi_read_shared_count(card, card->sdio_ctrl_addr + 2);
+ if (fw_count < 0)
+ {
+ unifi_error(card->ospriv, "Failed to read from-host sig read count\n");
+ }
+ else
+ {
+ unifi_error(card->ospriv, "fhsr: %u (driver thinks is %u)\n",
+ fw_count, card->from_host_signals_r);
+ }
+
+ return r;
+ }
+
+ unifi_info(card->ospriv, "UniFi function %d is enabled.\n", card->function);
+
+ /* See if we missed an SDIO interrupt */
+ r = CardPendingInt(card, &pending);
+ if (pending)
+ {
+ unifi_error(card->ospriv, "There is an unhandled pending interrupt.\n");
+ *status = 2;
+ return r;
+ }
+
+ return r;
+} /* unifi_check_io_status() */
+
+
+void unifi_get_hip_qos_info(card_t *card, unifi_HipQosInfo *hipqosinfo)
+{
+ CsrInt32 count_fhr;
+ CsrInt16 t;
+ CsrUint32 occupied_fh;
+
+ q_t *sigq;
+ CsrUint16 nslots, i;
+
+ CsrMemSet(hipqosinfo, 0, sizeof(unifi_HipQosInfo));
+
+ nslots = card->config_data.num_fromhost_data_slots;
+
+ for (i = 0; i < nslots; i++)
+ {
+ if (card->from_host_data[i].bd.data_length == 0)
+ {
+ hipqosinfo->free_fh_bulkdata_slots++;
+ }
+ }
+
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ sigq = &card->fh_traffic_queue[i];
+ t = sigq->q_wr_ptr - sigq->q_rd_ptr;
+ if (t < 0)
+ {
+ t += sigq->q_length;
+ }
+ hipqosinfo->free_fh_sig_queue_slots[i] = (sigq->q_length - t) - 1;
+ }
+
+ count_fhr = unifi_read_shared_count(card, card->sdio_ctrl_addr + 2);
+ if (count_fhr < 0)
+ {
+ unifi_error(card->ospriv, "Failed to read from-host sig read count - %d\n", count_fhr);
+ hipqosinfo->free_fh_fw_slots = 0xfa;
+ return;
+ }
+
+ occupied_fh = (card->from_host_signals_w - count_fhr) % 128;
+
+ hipqosinfo->free_fh_fw_slots = (CsrUint16)(card->config_data.num_fromhost_sig_frags - occupied_fh);
+}
+
+
+
+CsrResult ConvertCsrSdioToCsrHipResult(card_t *card, CsrResult csrResult)
+{
+ CsrResult r = CSR_RESULT_FAILURE;
+
+ switch (csrResult)
+ {
+ case CSR_RESULT_SUCCESS:
+ r = CSR_RESULT_SUCCESS;
+ break;
+ /* Timeout errors */
+ case CSR_SDIO_RESULT_TIMEOUT:
+ /* Integrity errors */
+ case CSR_SDIO_RESULT_CRC_ERROR:
+ r = CSR_RESULT_FAILURE;
+ break;
+ case CSR_SDIO_RESULT_NO_DEVICE:
+ r = CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ break;
+ case CSR_SDIO_RESULT_INVALID_VALUE:
+ r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ break;
+ case CSR_RESULT_FAILURE:
+ r = CSR_RESULT_FAILURE;
+ break;
+ default:
+ unifi_warning(card->ospriv, "Unrecognised csrResult error code: %d\n", csrResult);
+ break;
+ }
+
+ return r;
+} /* ConvertCsrSdioToCsrHipResult() */
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * FILE: csr_wifi_hip_card_sdio.h
+ *
+ * PURPOSE:
+ * Internal header for Card API for SDIO.
+ * ---------------------------------------------------------------------------
+ */
+#ifndef __CARD_SDIO_H__
+#define __CARD_SDIO_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_unifi_udi.h"
+#include "csr_wifi_hip_unifihw.h"
+#include "csr_wifi_hip_unifiversion.h"
+#ifndef CSR_WIFI_HIP_TA_DISABLE
+#include "csr_wifi_hip_ta_sampling.h"
+#endif
+#include "csr_wifi_hip_xbv.h"
+#include "csr_wifi_hip_chiphelper.h"
+
+
+/*
+ *
+ * Configuration items.
+ * Which of these should go in a platform unifi_config.h file?
+ *
+ */
+
+/*
+ * When the traffic queues contain more signals than there is space for on
+ * UniFi, a limiting algorithm comes into play.
+ * If a traffic queue has enough slots free to buffer more traffic from the
+ * network stack, then the following check is applied. The number of free
+ * slots is RESUME_XMIT_THRESHOLD.
+ */
+#define RESUME_XMIT_THRESHOLD 4
+
+
+/*
+ * When reading signals from UniFi, the host processes pending all signals
+ * and then acknowledges them together in a single write to update the
+ * to-host-chunks-read location.
+ * When there is more than one bulk data transfer (e.g. one received data
+ * packet and a request for the payload data of a transmitted packet), the
+ * update can be delayed significantly. This ties up resources on chip.
+ *
+ * To remedy this problem, to-host-chunks-read is updated after processing
+ * a signal if TO_HOST_FLUSH_THRESHOLD bytes of bulk data have been
+ * transferred since the last update.
+ */
+#define TO_HOST_FLUSH_THRESHOLD (500 * 5)
+
+
+/* SDIO Card Common Control Registers */
+#define SDIO_CCCR_SDIO_REVISION (0x00)
+#define SDIO_SD_SPEC_REVISION (0x01)
+#define SDIO_IO_ENABLE (0x02)
+#define SDIO_IO_READY (0x03)
+#define SDIO_INT_ENABLE (0x04)
+#define SDIO_INT_PENDING (0x05)
+#define SDIO_IO_ABORT (0x06)
+#define SDIO_BUS_IFACE_CONTROL (0x07)
+#define SDIO_CARD_CAPABILOTY (0x08)
+#define SDIO_COMMON_CIS_POINTER (0x09)
+#define SDIO_BUS_SUSPEND (0x0C)
+#define SDIO_FUNCTION_SELECT (0x0D)
+#define SDIO_EXEC_FLAGS (0x0E)
+#define SDIO_READY_FLAGS (0x0F)
+#define SDIO_FN0_BLOCK_SIZE (0x10)
+#define SDIO_POWER_CONTROL (0x12)
+#define SDIO_VENDOR_START (0xF0)
+
+#define SDIO_CSR_HOST_WAKEUP (0xf0)
+#define SDIO_CSR_HOST_INT_CLEAR (0xf1)
+#define SDIO_CSR_FROM_HOST_SCRATCH0 (0xf2)
+#define SDIO_CSR_FROM_HOST_SCRATCH1 (0xf3)
+#define SDIO_CSR_TO_HOST_SCRATCH0 (0xf4)
+#define SDIO_CSR_TO_HOST_SCRATCH1 (0xf5)
+#define SDIO_CSR_FUNC_EN (0xf6)
+#define SDIO_CSR_CSPI_MODE (0xf7)
+#define SDIO_CSR_CSPI_STATUS (0xf8)
+#define SDIO_CSR_CSPI_PADDING (0xf9)
+
+
+#define UNIFI_SD_INT_ENABLE_IENM 0x0001 /* Master INT Enable */
+
+#ifdef CSR_PRE_ALLOC_NET_DATA
+#define BULK_DATA_PRE_ALLOC_NUM 16
+#endif
+
+/*
+ * Structure to hold configuration information read from UniFi.
+ */
+typedef struct
+{
+ /*
+ * The version of the SDIO signal queues and bulk data pools
+ * configuration structure. The MSB is the major version number, used to
+ * indicate incompatible changes. The LSB gives the minor revision number,
+ * used to indicate changes that maintain backwards compatibility.
+ */
+ CsrUint16 version;
+
+ /*
+ * offset from the start of the shared data memory to the SD IO
+ * control structure.
+ */
+ CsrUint16 sdio_ctrl_offset;
+
+ /* Buffer handle of the from-host signal queue */
+ CsrUint16 fromhost_sigbuf_handle;
+
+ /* Buffer handle of the to-host signal queue */
+ CsrUint16 tohost_sigbuf_handle;
+
+ /*
+ * Maximum number of signal primitive or bulk data command fragments that may be
+ * pending in the to-hw signal queue.
+ */
+ CsrUint16 num_fromhost_sig_frags;
+
+ /*
+ * Number of signal primitive or bulk data command fragments that must be pending
+ * in the to-host signal queue before the host will generate an interrupt
+ * to indicate that it has read a signal. This will usually be the total
+ * capacity of the to-host signal buffer less the size of the largest signal
+ * primitive divided by the signal primitive fragment size, but may be set
+ * to 1 to request interrupts every time that the host read a signal.
+ * Note that the hw may place more signals in the to-host signal queue
+ * than indicated by this field.
+ */
+ CsrUint16 num_tohost_sig_frags;
+
+ /*
+ * Number of to-hw bulk data slots. Slots are numbered from 0 (zero) to
+ * one less than the value in this field
+ */
+ CsrUint16 num_fromhost_data_slots;
+
+ /*
+ * Number of frm-hw bulk data slots. Slots are numbered from 0 (zero) to
+ * one less than the value in this field
+ */
+ CsrUint16 num_tohost_data_slots;
+
+ /*
+ * Size of the bulk data slots (2 octets)
+ * The size of the bulk data slots in octets. This will usually be
+ * the size of the largest MSDU. The value should always be even.
+ */
+ CsrUint16 data_slot_size;
+
+ /*
+ * Indicates that the host has finished the initialisation sequence.
+ * Initialised to 0x0000 by the firmware, and set to 0x0001 by us.
+ */
+ CsrUint16 initialised;
+
+ /* Added by protocol version 0x0001 */
+ CsrUint32 overlay_size;
+
+ /* Added by protocol version 0x0300 */
+ CsrUint16 data_slot_round;
+ CsrUint16 sig_frag_size;
+
+ /* Added by protocol version 0x0500 */
+ CsrUint16 tohost_signal_padding;
+} sdio_config_data_t;
+
+/*
+ * These values may change with versions of the Host Interface Protocol.
+ */
+/*
+ * Size of config info block pointed to by the CSR_SLT_SDIO_SLOT_CONFIG
+ * entry in the f/w symbol table
+ */
+#define SDIO_CONFIG_DATA_SIZE 30
+
+/* Offset of the INIT flag in the config info block. */
+#define SDIO_INIT_FLAG_OFFSET 0x12
+#define SDIO_TO_HOST_SIG_PADDING_OFFSET 0x1C
+
+
+/* Structure for a bulk data transfer command */
+typedef struct
+{
+ CsrUint16 cmd_and_len; /* bits 12-15 cmd, bits 0-11 len */
+ CsrUint16 data_slot; /* slot number, perhaps OR'd with SLOT_DIR_TO_HOST */
+ CsrUint16 offset;
+ CsrUint16 buffer_handle;
+} bulk_data_cmd_t;
+
+
+/* Bulk Data signal command values */
+#define SDIO_CMD_SIGNAL 0x00
+#define SDIO_CMD_TO_HOST_TRANSFER 0x01
+#define SDIO_CMD_TO_HOST_TRANSFER_ACK 0x02 /*deprecated*/
+#define SDIO_CMD_FROM_HOST_TRANSFER 0x03
+#define SDIO_CMD_FROM_HOST_TRANSFER_ACK 0x04 /*deprecated*/
+#define SDIO_CMD_CLEAR_SLOT 0x05
+#define SDIO_CMD_OVERLAY_TRANSFER 0x06
+#define SDIO_CMD_OVERLAY_TRANSFER_ACK 0x07 /*deprecated*/
+#define SDIO_CMD_FROM_HOST_AND_CLEAR 0x08
+#define SDIO_CMD_PADDING 0x0f
+
+#define SLOT_DIR_TO_HOST 0x8000
+
+
+/* Initialise bulkdata slot
+ * params:
+ * bulk_data_desc_t *bulk_data_slot
+ */
+#define UNIFI_INIT_BULK_DATA(bulk_data_slot) \
+ { \
+ (bulk_data_slot)->os_data_ptr = NULL; \
+ (bulk_data_slot)->data_length = 0; \
+ (bulk_data_slot)->os_net_buf_ptr = NULL; \
+ (bulk_data_slot)->net_buf_length = 0; \
+ }
+
+/*
+ * Structure to contain a SIGNAL datagram.
+ * This is used to build signal queues between the main driver and the
+ * i/o thread.
+ * The fields are:
+ * sigbuf Contains the HIP signal is wire-format (i.e. packed,
+ * little-endian)
+ * bulkdata Contains a copy of any associated bulk data
+ * signal_length The size of the signal in the sigbuf
+ */
+typedef struct card_signal
+{
+ CsrUint8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
+
+ /* Length of the SIGNAL inside sigbuf */
+ CsrUint16 signal_length;
+
+ bulk_data_desc_t bulkdata[UNIFI_MAX_DATA_REFERENCES];
+} card_signal_t;
+
+
+/*
+ * Control structure for a generic ring buffer.
+ */
+#define UNIFI_QUEUE_NAME_MAX_LENGTH 16
+typedef struct
+{
+ card_signal_t *q_body;
+
+ /* Num elements in queue (capacity is one less than this!) */
+ CsrUint16 q_length;
+
+ CsrUint16 q_wr_ptr;
+ CsrUint16 q_rd_ptr;
+
+ CsrCharString name[UNIFI_QUEUE_NAME_MAX_LENGTH];
+} q_t;
+
+
+#define UNIFI_RESERVED_COMMAND_SLOTS 2
+
+/* Considering approx 500 us per packet giving 0.5 secs */
+#define UNIFI_PACKETS_INTERVAL 1000
+
+/*
+ * Dynamic slot reservation for QoS
+ */
+typedef struct
+{
+ CsrUint16 from_host_used_slots[UNIFI_NO_OF_TX_QS];
+ CsrUint16 from_host_max_slots[UNIFI_NO_OF_TX_QS];
+ CsrUint16 from_host_reserved_slots[UNIFI_NO_OF_TX_QS];
+
+ /* Parameters to determine if a queue was active.
+ If number of packets sent is greater than the threshold
+ for the queue, the queue is considered active and no
+ re reservation is done, it is important not to keep this
+ value too low */
+ /* Packets sent during this interval */
+ CsrUint16 packets_txed[UNIFI_NO_OF_TX_QS];
+ CsrUint16 total_packets_txed;
+
+ /* Number of packets to see if slots need to be reassigned */
+ CsrUint16 packets_interval;
+
+ /* Once a queue reaches a stable state, avoid processing */
+ CsrBool queue_stable[UNIFI_NO_OF_TX_QS];
+} card_dynamic_slot_t;
+
+
+/* These are type-safe and don't write incorrect values to the
+ * structure. */
+
+/* Return queue slots used count
+ * params:
+ * const q_t *q
+ * returns:
+ * CsrUint16
+ */
+#define CSR_WIFI_HIP_Q_SLOTS_USED(q) \
+ (((q)->q_wr_ptr - (q)->q_rd_ptr < 0)? \
+ ((q)->q_wr_ptr - (q)->q_rd_ptr + (q)->q_length) : ((q)->q_wr_ptr - (q)->q_rd_ptr))
+
+/* Return queue slots free count
+ * params:
+ * const q_t *q
+ * returns:
+ * CsrUint16
+ */
+#define CSR_WIFI_HIP_Q_SLOTS_FREE(q) \
+ ((q)->q_length - CSR_WIFI_HIP_Q_SLOTS_USED((q)) - 1)
+
+/* Return slot signal data pointer
+ * params:
+ * const q_t *q
+ * CsrUint16 slot
+ * returns:
+ * card_signal_t *
+ */
+#define CSR_WIFI_HIP_Q_SLOT_DATA(q, slot) \
+ ((q)->q_body + slot)
+
+/* Return queue next read slot
+ * params:
+ * const q_t *q
+ * returns:
+ * CsrUint16 slot offset
+ */
+#define CSR_WIFI_HIP_Q_NEXT_R_SLOT(q) \
+ ((q)->q_rd_ptr)
+
+/* Return queue next write slot
+ * params:
+ * const q_t *q
+ * returns:
+ * CsrUint16 slot offset
+ */
+#define CSR_WIFI_HIP_Q_NEXT_W_SLOT(q) \
+ ((q)->q_wr_ptr)
+
+/* Return updated queue pointer wrapped around its length
+ * params:
+ * const q_t *q
+ * CsrUint16 x amount to add to queue pointer
+ * returns:
+ * CsrUint16 wrapped queue pointer
+ */
+#define CSR_WIFI_HIP_Q_WRAP(q, x) \
+ ((((x) >= (q)->q_length)?((x) % (q)->q_length) : (x)))
+
+/* Advance queue read pointer
+ * params:
+ * const q_t *q
+ */
+#define CSR_WIFI_HIP_Q_INC_R(q) \
+ ((q)->q_rd_ptr = CSR_WIFI_HIP_Q_WRAP((q), (q)->q_rd_ptr + 1))
+
+/* Advance queue write pointer
+ * params:
+ * const q_t *q
+ */
+#define CSR_WIFI_HIP_Q_INC_W(q) \
+ ((q)->q_wr_ptr = CSR_WIFI_HIP_Q_WRAP((q), (q)->q_wr_ptr + 1))
+
+enum unifi_host_state
+{
+ UNIFI_HOST_STATE_AWAKE = 0,
+ UNIFI_HOST_STATE_DROWSY = 1,
+ UNIFI_HOST_STATE_TORPID = 2
+};
+
+typedef struct
+{
+ bulk_data_desc_t bd;
+ unifi_TrafficQueue queue; /* Used for dynamic slot reservation */
+} slot_desc_t;
+
+/*
+ * Structure describing a UniFi SDIO card.
+ */
+struct card
+{
+ /*
+ * Back pointer for the higher level OS code. This is passed as
+ * an argument to callbacks (e.g. for received data and indications).
+ */
+ void *ospriv;
+
+ /*
+ * mapping of HIP slot to MA-PACKET.req host tag, the
+ * array is indexed by slot numbers and each index stores
+ * information of the last host tag it was used for
+ */
+ CsrUint32 *fh_slot_host_tag_record;
+
+
+ /* Info read from Symbol Table during probe */
+ CsrUint32 build_id;
+ CsrCharString build_id_string[128];
+
+ /* Retrieve from SDIO driver. */
+ CsrUint16 chip_id;
+
+ /* Read from GBL_CHIP_VERSION. */
+ CsrUint16 chip_version;
+
+ /* From the SDIO driver (probably 1) */
+ CsrUint8 function;
+
+ /* This is sused to get the register addresses and things. */
+ ChipDescript *helper;
+
+ /*
+ * Bit mask of PIOs for the loader to waggle during download.
+ * We assume these are connected to LEDs. The main firmware gets
+ * the mask from a MIB entry.
+ */
+ CsrInt32 loader_led_mask;
+
+ /*
+ * Support for flow control. When the from-host queue of signals
+ * is full, we ask the host upper layer to stop sending packets. When
+ * the queue drains we tell it that it can send packets again.
+ * We use this flag to remember the current state.
+ */
+#define card_is_tx_q_paused(card, q) (card->tx_q_paused_flag[q])
+#define card_tx_q_unpause(card, q) (card->tx_q_paused_flag[q] = 0)
+#define card_tx_q_pause(card, q) (card->tx_q_paused_flag[q] = 1)
+
+ CsrUint16 tx_q_paused_flag[UNIFI_TRAFFIC_Q_MAX + 1 + UNIFI_NO_OF_TX_QS]; /* defensive more than big enough */
+
+ /* UDI callback for logging UniFi interactions */
+ udi_func_t udi_hook;
+
+ CsrUint8 bh_reason_host;
+ CsrUint8 bh_reason_unifi;
+
+ /* SDIO clock speed request from OS layer */
+ CsrUint8 request_max_clock;
+
+ /* Last SDIO clock frequency set */
+ CsrUint32 sdio_clock_speed;
+
+ /*
+ * Current host state (copy of value in IOABORT register and
+ * spinlock to protect it.
+ */
+ enum unifi_host_state host_state;
+
+ enum unifi_low_power_mode low_power_mode;
+ enum unifi_periodic_wake_mode periodic_wake_mode;
+
+ /*
+ * Ring buffer of signal structs for a queue of data packets from
+ * the host.
+ * The queue is empty when fh_data_q_num_rd == fh_data_q_num_wr.
+ * To add a packet to the queue, copy it to index given by
+ * (fh_data_q_num_wr%UNIFI_SOFT_Q_LENGTH) and advance fh_data_q_num_wr.
+ * To take a packet from the queue, copy data from index given by
+ * (fh_data_q_num_rd%UNIFI_SOFT_Q_LENGTH) and advance fh_data_q_num_rd.
+ * fh_data_q_num_rd and fh_data_q_num_rd are both modulo 256.
+ */
+ card_signal_t fh_command_q_body[UNIFI_SOFT_COMMAND_Q_LENGTH];
+ q_t fh_command_queue;
+
+ card_signal_t fh_traffic_q_body[UNIFI_NO_OF_TX_QS][UNIFI_SOFT_TRAFFIC_Q_LENGTH];
+ q_t fh_traffic_queue[UNIFI_NO_OF_TX_QS];
+
+ /*
+ * Signal counts from UniFi SDIO Control Data Structure.
+ * These are cached and synchronised with the UniFi before and after
+ * a batch of operations.
+ *
+ * These are the modulo-256 count of signals written to or read from UniFi
+ * The value is incremented for every signal.
+ */
+ CsrInt32 from_host_signals_w;
+ CsrInt32 from_host_signals_r;
+ CsrInt32 to_host_signals_r;
+ CsrInt32 to_host_signals_w;
+
+
+ /* Should specify buffer size as a number of signals */
+ /*
+ * Enough for 10 th and 10 fh data slots:
+ * 1 * 10 * 8 = 80
+ * 2 * 10 * 8 = 160
+ */
+#define UNIFI_FH_BUF_SIZE 1024
+ struct sigbuf
+ {
+ CsrUint8 *buf; /* buffer area */
+ CsrUint8 *ptr; /* current pos */
+ CsrUint16 count; /* signal count */
+ CsrUint16 bufsize;
+ } fh_buffer;
+ struct sigbuf th_buffer;
+
+
+ /*
+ * Field to use for the incrementing value to write to the UniFi
+ * SHARED_IO_INTERRUPT register.
+ * Flag to say we need to generate an interrupt at end of processing.
+ */
+ CsrUint32 unifi_interrupt_seq;
+ CsrUint8 generate_interrupt;
+
+
+ /* Pointers to the bulk data slots */
+ slot_desc_t *from_host_data;
+ bulk_data_desc_t *to_host_data;
+
+
+ /*
+ * Index of the next (hopefully) free data slot.
+ * This is an optimisation that starts searching at a more likely point
+ * than the beginning.
+ */
+ CsrInt16 from_host_data_head;
+
+ /* Dynamic slot allocation for queues */
+ card_dynamic_slot_t dynamic_slot_data;
+
+ /*
+ * SDIO specific fields
+ */
+
+ /* Interface pointer for the SDIO library */
+ CsrSdioFunction *sdio_if;
+
+ /* Copy of config_data struct from the card */
+ sdio_config_data_t config_data;
+
+ /* SDIO address of the Initialised flag and Control Data struct */
+ CsrUint32 init_flag_addr;
+ CsrUint32 sdio_ctrl_addr;
+
+ /* The last value written to the Shared Data Memory Page register */
+ CsrUint32 proc_select;
+ CsrUint32 dmem_page;
+ CsrUint32 pmem_page;
+
+ /* SDIO traffic counters limited to 32 bits for Synergy compatibility */
+ CsrUint32 sdio_bytes_read;
+ CsrUint32 sdio_bytes_written;
+
+ CsrUint8 memory_resources_allocated;
+
+ /* UniFi SDIO I/O Block size. */
+ CsrUint16 sdio_io_block_size;
+
+ /* Pad transfer sizes to SDIO block boundaries */
+ CsrBool sdio_io_block_pad;
+
+ /* Read from the XBV */
+ struct FWOV fwov;
+
+#ifndef CSR_WIFI_HIP_TA_DISABLE
+ /* TA sampling */
+ ta_data_t ta_sampling;
+#endif
+
+ /* Auto-coredump */
+ CsrInt16 request_coredump_on_reset; /* request coredump on next reset */
+ struct coredump_buf *dump_buf; /* root node */
+ struct coredump_buf *dump_next_write; /* node to fill at next dump */
+ struct coredump_buf *dump_cur_read; /* valid node to read, or NULL */
+
+#ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
+ struct cmd_profile
+ {
+ CsrUint32 cmd52_count;
+ CsrUint32 cmd53_count;
+ CsrUint32 tx_count;
+ CsrUint32 tx_cfm_count;
+ CsrUint32 rx_count;
+ CsrUint32 bh_count;
+ CsrUint32 process_count;
+ CsrUint32 protocol_count;
+
+ CsrUint32 cmd52_f0_r_count;
+ CsrUint32 cmd52_f0_w_count;
+ CsrUint32 cmd52_r8or16_count;
+ CsrUint32 cmd52_w8or16_count;
+ CsrUint32 cmd52_r16_count;
+ CsrUint32 cmd52_w16_count;
+ CsrUint32 cmd52_r32_count;
+
+ CsrUint32 sdio_cmd_signal;
+ CsrUint32 sdio_cmd_clear_slot;
+ CsrUint32 sdio_cmd_to_host;
+ CsrUint32 sdio_cmd_from_host;
+ CsrUint32 sdio_cmd_from_host_and_clear;
+ } hip_prof;
+ struct cmd_profile cmd_prof;
+#endif
+
+ /* Interrupt processing mode flags */
+ CsrUint32 intmode;
+
+#ifdef UNIFI_DEBUG
+ CsrUint8 lsb;
+#endif
+
+ /* Historic firmware panic codes */
+ CsrUint32 panic_data_phy_addr;
+ CsrUint32 panic_data_mac_addr;
+ CsrUint16 last_phy_panic_code;
+ CsrUint16 last_phy_panic_arg;
+ CsrUint16 last_mac_panic_code;
+ CsrUint16 last_mac_panic_arg;
+#ifdef CSR_PRE_ALLOC_NET_DATA
+ bulk_data_desc_t bulk_data_desc_list[BULK_DATA_PRE_ALLOC_NUM];
+ CsrUint16 prealloc_netdata_r;
+ CsrUint16 prealloc_netdata_w;
+#endif
+}; /* struct card */
+
+
+/* Reset types */
+enum unifi_reset_type
+{
+ UNIFI_COLD_RESET = 1,
+ UNIFI_WARM_RESET = 2
+};
+
+/*
+ * unifi_set_host_state() implements signalling for waking UniFi from
+ * deep sleep. The host indicates to UniFi that it is in one of three states:
+ * Torpid - host has nothing to send, UniFi can go to sleep.
+ * Drowsy - host has data to send to UniFi. UniFi will respond with an
+ * SDIO interrupt. When hosts responds it moves to Awake.
+ * Awake - host has data to transfer, UniFi must stay awake.
+ * When host has finished, it moves to Torpid.
+ */
+CsrResult unifi_set_host_state(card_t *card, enum unifi_host_state state);
+
+
+CsrResult unifi_set_proc_select(card_t *card, enum unifi_dbg_processors_select select);
+CsrInt32 card_read_signal_counts(card_t *card);
+bulk_data_desc_t* card_find_data_slot(card_t *card, CsrInt16 slot);
+
+
+CsrResult unifi_read32(card_t *card, CsrUint32 unifi_addr, CsrUint32 *pdata);
+CsrResult unifi_readnz(card_t *card, CsrUint32 unifi_addr,
+ void *pdata, CsrUint16 len);
+CsrInt32 unifi_read_shared_count(card_t *card, CsrUint32 addr);
+
+CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len);
+
+CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle,
+ void *pdata, CsrUint32 len, CsrInt16 direction);
+CsrResult unifi_bulk_rw_noretry(card_t *card, CsrUint32 handle,
+ void *pdata, CsrUint32 len, CsrInt16 direction);
+#define UNIFI_SDIO_READ 0
+#define UNIFI_SDIO_WRITE 1
+
+CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 *pdata);
+CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 data);
+CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 *pdata);
+CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 data);
+
+CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, CsrUint16 *pdata);
+CsrResult unifi_read_direct32(card_t *card, CsrUint32 addr, CsrUint32 *pdata);
+CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len);
+
+CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, CsrUint16 data);
+CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len);
+
+CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, CsrUint8 *pdata);
+CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, CsrUint8 data);
+
+void unifi_read_panic(card_t *card);
+#ifdef CSR_PRE_ALLOC_NET_DATA
+void prealloc_netdata_free(card_t *card);
+CsrResult prealloc_netdata_alloc(card_t *card);
+#endif
+/* For diagnostic use */
+void dump(void *mem, CsrUint16 len);
+void dump16(void *mem, CsrUint16 len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CARD_SDIO_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_card_sdio_intr.c
+ *
+ * PURPOSE:
+ * Interrupt processing for the UniFi SDIO driver.
+ *
+ * We may need another signal queue of responses to UniFi to hold
+ * bulk data commands generated by read_to_host_signals().
+ *
+ * ---------------------------------------------------------------------------
+ */
+#undef CSR_WIFI_HIP_NOISY
+
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_conversions.h"
+#include "csr_wifi_hip_card.h"
+#include "csr_wifi_hip_xbv.h"
+
+
+/*
+ * If the SDIO link is idle for this time (in milliseconds),
+ * signal UniFi to go into Deep Sleep.
+ * Valid return value of unifi_bh().
+ */
+#define UNIFI_DEFAULT_HOST_IDLE_TIMEOUT 5
+/*
+ * If the UniFi has not woken up for this time (in milliseconds),
+ * signal the bottom half to take action.
+ * Valid return value of unifi_bh().
+ */
+#define UNIFI_DEFAULT_WAKE_TIMEOUT 1000
+
+
+static CsrResult process_bh(card_t *card);
+static CsrResult handle_host_protocol(card_t *card, CsrBool *processed_something);
+
+static CsrResult flush_fh_buffer(card_t *card);
+
+static CsrResult check_fh_sig_slots(card_t *card, CsrUint16 needed, CsrInt32 *space);
+
+static CsrResult read_to_host_signals(card_t *card, CsrInt32 *processed);
+static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed);
+
+static CsrResult process_bulk_data_command(card_t *card,
+ const CsrUint8 *cmdptr,
+ CsrInt16 cmd, CsrUint16 len);
+static CsrResult process_clear_slot_command(card_t *card,
+ const CsrUint8 *cmdptr);
+static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed);
+static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed);
+static void restart_packet_flow(card_t *card);
+static CsrResult process_clock_request(card_t *card);
+
+#ifdef CSR_WIFI_HIP_NOISY
+CsrInt16 dump_fh_buf = 0;
+#endif /* CSR_WIFI_HIP_NOISY */
+
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+
+/*
+ * The unifi_debug_output buffer can be used to debug the HIP behaviour offline
+ * i.e. without using the tracing functions that change the timing.
+ *
+ * Call unifi_debug_log_to_buf() with printf arguments to store a string into
+ * unifi_debug_output. When unifi_debug_buf_dump() is called, the contents of the
+ * buffer are dumped with dump_str() which has to be implemented in the
+ * OS layer, during the porting exercise. The offset printed, holds the
+ * offset where the last character is (always a zero).
+ *
+ */
+
+#define UNIFI_DEBUG_GBUFFER_SIZE 8192
+static CsrCharString unifi_debug_output[UNIFI_DEBUG_GBUFFER_SIZE];
+static CsrCharString *unifi_dbgbuf_ptr = unifi_debug_output;
+static CsrCharString *unifi_dbgbuf_start = unifi_debug_output;
+
+static void append_char(CsrCharString c)
+{
+ /* write char and advance pointer */
+ *unifi_dbgbuf_ptr++ = c;
+ /* wrap pointer at end of buffer */
+ if ((unifi_dbgbuf_ptr - unifi_debug_output) >= UNIFI_DEBUG_GBUFFER_SIZE)
+ {
+ unifi_dbgbuf_ptr = unifi_debug_output;
+ }
+} /* append_char() */
+
+
+void unifi_debug_string_to_buf(const CsrCharString *str)
+{
+ const CsrCharString *p = str;
+ while (*p)
+ {
+ append_char(*p);
+ p++;
+ }
+ /* Update start-of-buffer pointer */
+ unifi_dbgbuf_start = unifi_dbgbuf_ptr + 1;
+ if ((unifi_dbgbuf_start - unifi_debug_output) >= UNIFI_DEBUG_GBUFFER_SIZE)
+ {
+ unifi_dbgbuf_start = unifi_debug_output;
+ }
+}
+
+
+void unifi_debug_log_to_buf(const CsrCharString *fmt, ...)
+{
+#define DEBUG_BUFFER_SIZE 80
+ static CsrCharString s[DEBUG_BUFFER_SIZE];
+ va_list args;
+
+ va_start(args, fmt);
+ CsrVsnprintf(s, DEBUG_BUFFER_SIZE, fmt, args);
+ va_end(args);
+
+ unifi_debug_string_to_buf(s);
+} /* unifi_debug_log_to_buf() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_debug_hex_to_buf
+ *
+ * puts the contents of the passed buffer into the debug buffer as a hex string
+ *
+ * Arguments:
+ * buff buffer to print as hex
+ * length number of chars to print
+ *
+ * Returns:
+ * None.
+ *
+ * ---------------------------------------------------------------------------
+ */
+void unifi_debug_hex_to_buf(const CsrCharString *buff, CsrUint16 length)
+{
+ CsrCharString s[5];
+ CsrUint16 i;
+
+ for (i = 0; i < length; i = i + 2)
+ {
+ CsrUInt16ToHex(*((CsrUint16 *)(buff + i)), s);
+ unifi_debug_string_to_buf(s);
+ }
+}
+
+
+void unifi_debug_buf_dump(void)
+{
+ CsrInt32 offset = unifi_dbgbuf_ptr - unifi_debug_output;
+
+ unifi_error(NULL, "HIP debug buffer offset=%d\n", offset);
+ dump_str(unifi_debug_output + offset, UNIFI_DEBUG_GBUFFER_SIZE - offset);
+ dump_str(unifi_debug_output, offset);
+} /* unifi_debug_buf_dump() */
+
+
+#endif /* CSR_WIFI_HIP_DEBUG_OFFLINE */
+
+#ifdef CSR_PRE_ALLOC_NET_DATA
+#define NETDATA_PRE_ALLOC_BUF_SIZE 8000
+
+void prealloc_netdata_free(card_t *card)
+{
+ unifi_warning(card->ospriv, "prealloc_netdata_free: IN: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
+
+ while (card->bulk_data_desc_list[card->prealloc_netdata_r].data_length != 0)
+ {
+ unifi_warning(card->ospriv, "prealloc_netdata_free: r=%d\n", card->prealloc_netdata_r);
+
+ unifi_net_data_free(card->ospriv, &card->bulk_data_desc_list[card->prealloc_netdata_r]);
+ card->prealloc_netdata_r++;
+ card->prealloc_netdata_r %= BULK_DATA_PRE_ALLOC_NUM;
+ }
+ card->prealloc_netdata_r = card->prealloc_netdata_w = 0;
+
+ unifi_warning(card->ospriv, "prealloc_netdata_free: OUT: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
+}
+
+
+CsrResult prealloc_netdata_alloc(card_t *card)
+{
+ CsrResult r;
+
+ unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_alloc: IN: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
+
+ while (card->bulk_data_desc_list[card->prealloc_netdata_w].data_length == 0)
+ {
+ r = unifi_net_data_malloc(card->ospriv, &card->bulk_data_desc_list[card->prealloc_netdata_w], NETDATA_PRE_ALLOC_BUF_SIZE);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "prealloc_netdata_alloc: Failed to allocate t-h bulk data\n");
+ return CSR_RESULT_FAILURE;
+ }
+ card->prealloc_netdata_w++;
+ card->prealloc_netdata_w %= BULK_DATA_PRE_ALLOC_NUM;
+ }
+ unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_alloc: OUT: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
+
+ return CSR_RESULT_SUCCESS;
+}
+
+
+static CsrResult prealloc_netdata_get(card_t *card, bulk_data_desc_t *bulk_data_slot, CsrUint32 size)
+{
+ CsrResult r;
+
+ unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_get: IN: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
+
+ if (card->bulk_data_desc_list[card->prealloc_netdata_r].data_length == 0)
+ {
+ unifi_error(card->ospriv, "prealloc_netdata_get: data_length = 0\n");
+ }
+
+ if ((size > NETDATA_PRE_ALLOC_BUF_SIZE) || (card->bulk_data_desc_list[card->prealloc_netdata_r].data_length == 0))
+ {
+ unifi_warning(card->ospriv, "prealloc_netdata_get: Calling net_data_malloc\n");
+
+ r = unifi_net_data_malloc(card->ospriv, bulk_data_slot, size);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "prealloc_netdata_get: Failed to allocate t-h bulk data\n");
+ return CSR_RESULT_FAILURE;
+ }
+ return CSR_RESULT_SUCCESS;
+ }
+
+ *bulk_data_slot = card->bulk_data_desc_list[card->prealloc_netdata_r];
+ card->bulk_data_desc_list[card->prealloc_netdata_r].os_data_ptr = NULL;
+ card->bulk_data_desc_list[card->prealloc_netdata_r].os_net_buf_ptr = NULL;
+ card->bulk_data_desc_list[card->prealloc_netdata_r].net_buf_length = 0;
+ card->bulk_data_desc_list[card->prealloc_netdata_r].data_length = 0;
+
+ card->prealloc_netdata_r++;
+ card->prealloc_netdata_r %= BULK_DATA_PRE_ALLOC_NUM;
+
+ unifi_trace(card->ospriv, UDBG5, "prealloc_netdata_get: OUT: w=%d r=%d\n", card->prealloc_netdata_w, card->prealloc_netdata_r);
+
+ return CSR_RESULT_SUCCESS;
+}
+
+
+#endif
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_sdio_interrupt_handler
+ *
+ * This function should be called by the OS-dependent code to handle
+ * an SDIO interrupt from the UniFi.
+ *
+ * Arguments:
+ * card Pointer to card context structure.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes: This function may be called in DRS context. In this case,
+ * tracing with the unifi_trace(), etc, is not allowed.
+ * ---------------------------------------------------------------------------
+ */
+void unifi_sdio_interrupt_handler(card_t *card)
+{
+ /*
+ * Set the flag to say reason for waking was SDIO interrupt.
+ * Then ask the OS layer to run the unifi_bh to give attention to the UniFi.
+ */
+ card->bh_reason_unifi = 1;
+ (void)unifi_run_bh(card->ospriv);
+} /* sdio_interrupt_handler() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_configure_low_power_mode
+ *
+ * This function should be called by the OS-dependent when
+ * the deep sleep signaling needs to be enabled or disabled.
+ *
+ * Arguments:
+ * card Pointer to card context structure.
+ * low_power_mode Disable/Enable the deep sleep signaling
+ * periodic_wake_mode UniFi wakes host periodically.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success or a CSR error code.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_configure_low_power_mode(card_t *card,
+ enum unifi_low_power_mode low_power_mode,
+ enum unifi_periodic_wake_mode periodic_wake_mode)
+{
+ card->low_power_mode = low_power_mode;
+ card->periodic_wake_mode = periodic_wake_mode;
+
+ unifi_trace(card->ospriv, UDBG1,
+ "unifi_configure_low_power_mode: new mode = %s, wake_host = %s\n",
+ (low_power_mode == UNIFI_LOW_POWER_DISABLED)?"disabled" : "enabled",
+ (periodic_wake_mode == UNIFI_PERIODIC_WAKE_HOST_DISABLED)?"FALSE" : "TRUE");
+
+ (void)unifi_run_bh(card->ospriv);
+ return CSR_RESULT_SUCCESS;
+} /* unifi_configure_low_power_mode() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_force_low_power_mode
+ *
+ * This function should be called by the OS-dependent when
+ * UniFi needs to be set to the low power mode (e.g. on suspend)
+ *
+ * Arguments:
+ * card Pointer to card context structure.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success or a CSR error code.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_force_low_power_mode(card_t *card)
+{
+ if (card->low_power_mode == UNIFI_LOW_POWER_DISABLED)
+ {
+ unifi_error(card->ospriv, "Attempt to set mode to TORPID when lower power mode is disabled\n");
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ return unifi_set_host_state(card, UNIFI_HOST_STATE_TORPID);
+} /* unifi_force_low_power_mode() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_bh
+ *
+ * This function should be called by the OS-dependent code when
+ * host and/or UniFi has requested an exchange of messages.
+ *
+ * Arguments:
+ * card Pointer to card context structure.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success or a CSR error code.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_bh(card_t *card, CsrUint32 *remaining)
+{
+ CsrResult r;
+ CsrResult csrResult;
+ CsrBool pending;
+ CsrInt32 iostate, j;
+ const enum unifi_low_power_mode low_power_mode = card->low_power_mode;
+ CsrUint16 data_slots_used = 0;
+
+
+ /* Process request to raise the maximum SDIO clock */
+ r = process_clock_request(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Error setting maximum SDIO clock\n");
+ goto exit;
+ }
+
+ /*
+ * Why was the BH thread woken?
+ * If it was an SDIO interrupt, UniFi is awake and we need to process it.
+ * If it was a host process queueing data, then we need to awaken UniFi.
+ *
+ * Priority of flags is top down.
+ *
+ * ----------------------------------------------------------+
+ * \state| AWAKE | DROWSY | TORPID |
+ * flag\ | | | |
+ * ---------+--------------+----------------+----------------|
+ * | do the host | go to AWAKE and| go to AWAKE and|
+ * unifi | protocol | do the host | do the host |
+ * | | protocol | protocol |
+ * ---------+--------------+----------------+----------------|
+ * | do the host | | |
+ * host | protocol | do nothing | go to DROWSY |
+ * | | | |
+ * ---------+--------------+----------------+----------------|
+ * | | | should not |
+ * timeout | go to TORPID | error, unifi | occur |
+ * | | didn't wake up | do nothing |
+ * ----------------------------------------------------------+
+ *
+ * Note that if we end up in the AWAKE state we always do the host protocol.
+ */
+
+ do
+ {
+ /*
+ * When the host state is set to DROWSY, then we can not disable the
+ * interrupts as UniFi can generate an interrupt even when the INT_ENABLE
+ * register has the interrupts disabled. This interrupt will be lost.
+ */
+ if (card->host_state == UNIFI_HOST_STATE_DROWSY || card->host_state == UNIFI_HOST_STATE_TORPID)
+ {
+ CsrUint8 reason_unifi;
+
+ /*
+ * An interrupt may occur while or after we cache the reason.
+ * This interrupt will cause the unifi_bh() to be scheduled again.
+ * Any interrupt that has happened before the register is read
+ * and is considered spurious has to acknowledged.
+ */
+ reason_unifi = card->bh_reason_unifi;
+
+ /*
+ * If an interrupt is received, check if it was a real one,
+ * set the host state to AWAKE and run the BH.
+ */
+ r = CardPendingInt(card, &pending);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ goto exit;
+ }
+
+ if (pending)
+ {
+ unifi_trace(card->ospriv, UDBG5,
+ "UNIFI_HOST_STATE_%s: Set state to AWAKE.\n",
+ (card->host_state == UNIFI_HOST_STATE_TORPID)?"TORPID" : "DROWSY");
+
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE);
+ if (r == CSR_RESULT_SUCCESS)
+ {
+ (*remaining) = 0;
+ break;
+ }
+ }
+ else if (reason_unifi)
+ {
+ CsrSdioInterruptAcknowledge(card->sdio_if);
+ }
+
+ /*
+ * If an chip is in TORPID, and the host wants to wake it up,
+ * set the host state to DROWSY and wait for the wake-up interrupt.
+ */
+ if ((card->host_state == UNIFI_HOST_STATE_TORPID) && card->bh_reason_host)
+ {
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_DROWSY);
+ if (r == CSR_RESULT_SUCCESS)
+ {
+ /*
+ * set the timeout value to UNIFI_DEFAULT_WAKE_TIMEOUT
+ * to capture a wake error.
+ */
+ card->bh_reason_host = 0;
+ (*remaining) = UNIFI_DEFAULT_WAKE_TIMEOUT;
+ return CSR_RESULT_SUCCESS;
+ }
+
+ goto exit;
+ }
+
+ /*
+ * If the chip is in DROWSY, and the timeout expires,
+ * we need to reset the chip. This should never occur.
+ * (If it does, check that the calling thread set "remaining"
+ * according to the time remaining when unifi_bh() was called).
+ */
+ if ((card->host_state == UNIFI_HOST_STATE_DROWSY) && ((*remaining) == 0))
+ {
+ unifi_error(card->ospriv, "UniFi did not wake up on time...\n");
+
+ /*
+ * Check if Function1 has gone away or
+ * if we missed an SDIO interrupt.
+ */
+ r = unifi_check_io_status(card, &iostate);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ goto exit;
+ }
+ /* Need to reset and reboot */
+ return CSR_RESULT_FAILURE;
+ }
+ }
+ else
+ {
+ if (card->bh_reason_unifi || card->bh_reason_host)
+ {
+ break;
+ }
+
+ if (((*remaining) == 0) && (low_power_mode == UNIFI_LOW_POWER_ENABLED))
+ {
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_TORPID);
+ if (r == CSR_RESULT_SUCCESS)
+ {
+ (*remaining) = 0;
+ return CSR_RESULT_SUCCESS;
+ }
+
+ goto exit;
+ }
+ }
+
+ /* No need to run the host protocol */
+ return CSR_RESULT_SUCCESS;
+ } while (0);
+
+
+ /* Disable the SDIO interrupts while doing SDIO ops */
+ csrResult = CsrSdioInterruptDisable(card->sdio_if);
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ r = CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ goto exit;
+ }
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ unifi_error(card->ospriv, "Failed to disable SDIO interrupts. unifi_bh queues error.\n");
+ goto exit;
+ }
+
+ /* Now that the interrupts are disabled, ack the interrupt */
+ CsrSdioInterruptAcknowledge(card->sdio_if);
+
+ /* Run the HIP */
+ r = process_bh(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ goto exit;
+ }
+
+ /*
+ * If host is now idle, schedule a timer for the delay before we
+ * let UniFi go into deep sleep.
+ * If the timer goes off, we will move to TORPID state.
+ * If UniFi raises an interrupt in the meantime, we will cancel
+ * the timer and start a new one when we become idle.
+ */
+ for (j = 0; j < UNIFI_NO_OF_TX_QS; j++)
+ {
+ data_slots_used += CSR_WIFI_HIP_Q_SLOTS_USED(&card->fh_traffic_queue[j]);
+ }
+
+ if ((low_power_mode == UNIFI_LOW_POWER_ENABLED) && (data_slots_used == 0))
+ {
+#ifndef CSR_WIFI_HIP_TA_DISABLE
+ if (card->ta_sampling.traffic_type != CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_PERIODIC)
+ {
+#endif
+ /* return the UNIFI_DEFAULT_HOST_IDLE_TIMEOUT, so we can go to sleep. */
+ unifi_trace(card->ospriv, UDBG5,
+ "Traffic is not periodic, set timer for TORPID.\n");
+ (*remaining) = UNIFI_DEFAULT_HOST_IDLE_TIMEOUT;
+#ifndef CSR_WIFI_HIP_TA_DISABLE
+ }
+ else
+ {
+ unifi_trace(card->ospriv, UDBG5,
+ "Traffic is periodic, set unifi to TORPID immediately.\n");
+ if (CardAreAllFromHostDataSlotsEmpty(card) == 1)
+ {
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_TORPID);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ goto exit;
+ }
+ }
+ }
+#endif
+ }
+
+ csrResult = CsrSdioInterruptEnable(card->sdio_if);
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ r = CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ unifi_error(card->ospriv, "Failed to enable SDIO interrupt\n");
+ }
+
+exit:
+
+ unifi_trace(card->ospriv, UDBG4, "New state=%d\n", card->host_state);
+
+ if (r != CSR_RESULT_SUCCESS)
+ {
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_buf_dump();
+#endif
+ /* If an interrupt has been raised, ack it here */
+ if (card->bh_reason_unifi)
+ {
+ CsrSdioInterruptAcknowledge(card->sdio_if);
+ }
+
+ unifi_error(card->ospriv,
+ "unifi_bh: state=%d %c, clock=%dkHz, interrupt=%d host=%d, power_save=%s\n",
+ card->host_state,
+ (card->host_state == UNIFI_HOST_STATE_AWAKE)?'A' : (card->host_state == UNIFI_HOST_STATE_DROWSY)?'D' : 'T',
+ card->sdio_clock_speed / 1000,
+ card->bh_reason_unifi, card->bh_reason_host,
+ (low_power_mode == UNIFI_LOW_POWER_DISABLED)?"disabled" : "enabled");
+
+ /* Try to capture firmware panic codes */
+ (void)unifi_capture_panic(card);
+
+ /* Ask for a mini-coredump when the driver has reset UniFi */
+ (void)unifi_coredump_request_at_next_reset(card, 1);
+ }
+
+ return r;
+} /* unifi_bh() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * process_clock_request
+ *
+ * Handle request from the OS layer to increase the SDIO clock speed.
+ * The fast clock is limited until the firmware has indicated that it has
+ * completed initialisation to the OS layer.
+ *
+ * Arguments:
+ * card Pointer to card context structure.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success or CSR error code.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult process_clock_request(card_t *card)
+{
+ CsrResult r = CSR_RESULT_SUCCESS;
+ CsrResult csrResult;
+
+ if (!card->request_max_clock)
+ {
+ return CSR_RESULT_SUCCESS; /* No pending request */
+ }
+
+ /*
+ * The SDIO clock speed request from the OS layer is only acted upon if
+ * the UniFi is awake. If it was in any other state, the clock speed will
+ * transition through SAFE to MAX while the host wakes it up, and the
+ * final speed reached will be UNIFI_SDIO_CLOCK_MAX_HZ.
+ * This assumes that the SME never requests low power mode while the f/w
+ * initialisation takes place.
+ */
+ if (card->host_state == UNIFI_HOST_STATE_AWAKE)
+ {
+ unifi_trace(card->ospriv, UDBG1, "Set SDIO max clock\n");
+ csrResult = CsrSdioMaxBusClockFrequencySet(card->sdio_if, UNIFI_SDIO_CLOCK_MAX_HZ);
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ }
+ else
+ {
+ card->sdio_clock_speed = UNIFI_SDIO_CLOCK_MAX_HZ; /* log the new freq */
+ }
+ }
+ else
+ {
+ unifi_trace(card->ospriv, UDBG1, "Will set SDIO max clock after wakeup\n");
+ }
+
+ /* Cancel the request now that it has been acted upon, or is about to be
+ * by the wakeup mechanism
+ */
+ card->request_max_clock = 0;
+
+ return r;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * process_bh
+ *
+ * Exchange messages with UniFi
+ *
+ * Arguments:
+ * card Pointer to card context structure.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success or CSR error code.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult process_bh(card_t *card)
+{
+ CsrResult r;
+ CsrBool more;
+ more = FALSE;
+
+ /* Process the reasons (interrupt, signals) */
+ do
+ {
+ /*
+ * Run in a while loop, to save clearing the interrupts
+ * every time around the outside loop.
+ */
+ do
+ {
+ /* If configured to run the HIP just once, skip first loop */
+ if (card->intmode & CSR_WIFI_INTMODE_RUN_BH_ONCE)
+ {
+ break;
+ }
+
+ r = handle_host_protocol(card, &more);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ unifi_debug_log_to_buf("c52=%d c53=%d tx=%d txc=%d rx=%d s=%d t=%d fc=%d\n",
+ card->cmd_prof.cmd52_count,
+ card->cmd_prof.cmd53_count,
+ card->cmd_prof.tx_count,
+ card->cmd_prof.tx_cfm_count,
+ card->cmd_prof.rx_count,
+ card->cmd_prof.sdio_cmd_signal,
+ card->cmd_prof.sdio_cmd_to_host,
+ card->cmd_prof.sdio_cmd_from_host_and_clear
+ );
+
+ card->cmd_prof.cmd52_count = card->cmd_prof.cmd53_count = 0;
+ card->cmd_prof.tx_count = card->cmd_prof.tx_cfm_count = card->cmd_prof.rx_count = 0;
+
+ card->cmd_prof.cmd52_f0_r_count = 0;
+ card->cmd_prof.cmd52_f0_w_count = 0;
+ card->cmd_prof.cmd52_r8or16_count = 0;
+ card->cmd_prof.cmd52_w8or16_count = 0;
+ card->cmd_prof.cmd52_r16_count = 0;
+ card->cmd_prof.cmd52_w16_count = 0;
+ card->cmd_prof.cmd52_r32_count = 0;
+
+ card->cmd_prof.sdio_cmd_signal = 0;
+ card->cmd_prof.sdio_cmd_clear_slot = 0;
+ card->cmd_prof.sdio_cmd_to_host = 0;
+ card->cmd_prof.sdio_cmd_from_host = 0;
+ card->cmd_prof.sdio_cmd_from_host_and_clear = 0;
+#endif
+
+
+ } while (more || card->bh_reason_unifi || card->bh_reason_host);
+
+ /* Acknowledge the h/w interrupt */
+ r = CardClearInt(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to acknowledge interrupt.\n");
+ return r;
+ }
+
+ /*
+ * UniFi may have tried to generate an interrupt during the
+ * CardClearInt() was running. So, we need to run the host
+ * protocol again, to check if there are any pending requests.
+ */
+ r = handle_host_protocol(card, &more);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ unifi_debug_log_to_buf("c52=%d c53=%d tx=%d txc=%d rx=%d s=%d t=%d fc=%d\n",
+ card->cmd_prof.cmd52_count,
+ card->cmd_prof.cmd53_count,
+ card->cmd_prof.tx_count,
+ card->cmd_prof.tx_cfm_count,
+ card->cmd_prof.rx_count,
+ card->cmd_prof.sdio_cmd_signal,
+ card->cmd_prof.sdio_cmd_to_host,
+ card->cmd_prof.sdio_cmd_from_host_and_clear
+ );
+
+ card->cmd_prof.cmd52_count = card->cmd_prof.cmd53_count = 0;
+ card->cmd_prof.tx_count = card->cmd_prof.tx_cfm_count = card->cmd_prof.rx_count = 0;
+
+ card->cmd_prof.cmd52_f0_r_count = 0;
+ card->cmd_prof.cmd52_f0_w_count = 0;
+ card->cmd_prof.cmd52_r8or16_count = 0;
+ card->cmd_prof.cmd52_w8or16_count = 0;
+ card->cmd_prof.cmd52_r16_count = 0;
+ card->cmd_prof.cmd52_w16_count = 0;
+ card->cmd_prof.cmd52_r32_count = 0;
+
+ card->cmd_prof.sdio_cmd_signal = 0;
+ card->cmd_prof.sdio_cmd_clear_slot = 0;
+ card->cmd_prof.sdio_cmd_to_host = 0;
+ card->cmd_prof.sdio_cmd_from_host = 0;
+ card->cmd_prof.sdio_cmd_from_host_and_clear = 0;
+#endif
+ /* If configured to run the HIP just once, work is now done */
+ if (card->intmode & CSR_WIFI_INTMODE_RUN_BH_ONCE)
+ {
+ break;
+ }
+
+ } while (more || card->bh_reason_unifi || card->bh_reason_host);
+
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ if ((card->intmode & CSR_WIFI_INTMODE_RUN_BH_ONCE) == 0)
+ {
+ unifi_debug_log_to_buf("proc=%d\n",
+ card->cmd_prof.process_count);
+ }
+#endif
+
+ return CSR_RESULT_SUCCESS;
+} /* process_bh() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * handle_host_protocol
+ *
+ * This function implements the Host Interface Protocol (HIP) as
+ * described in the Host Interface Protocol Specification.
+ *
+ * Arguments:
+ * card Pointer to card context structure.
+ * processed_something Pointer to location to update processing status:
+ * TRUE when data was transferred
+ * FALSE when no data was transferred (queues empty)
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success or CSR error code.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult handle_host_protocol(card_t *card, CsrBool *processed_something)
+{
+ CsrResult r;
+ CsrInt32 done;
+
+ *processed_something = FALSE;
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, " ======================== \n");
+#endif /* CSR_WIFI_HIP_NOISY */
+
+#ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
+ card->cmd_prof.process_count++;
+#endif
+
+ card->bh_reason_unifi = card->bh_reason_host = 0;
+ card->generate_interrupt = 0;
+
+
+ /*
+ * (Re)fill the T-H signal buffer
+ */
+ r = read_to_host_signals(card, &done);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Error occured reading to-host signals\n");
+ return r;
+ }
+ if (done > 0)
+ {
+ *processed_something = TRUE;
+ }
+
+ /*
+ * Process any to-host signals.
+ * Perform any requested CMD53 transfers here, but just queue any
+ * bulk data command responses.
+ */
+ r = process_to_host_signals(card, &done);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Error occured processing to-host signals\n");
+ return r;
+ }
+
+ /* Now send any signals in the F-H queues */
+ /* Give precedence to the command queue */
+ r = process_fh_cmd_queue(card, &done);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Error occured processing from-host signals\n");
+ return r;
+ }
+ if (done > 0)
+ {
+ *processed_something = TRUE;
+ }
+
+ r = process_fh_traffic_queue(card, &done);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Error occured processing from-host data signals\n");
+ return r;
+ }
+ if (done > 0)
+ {
+ *processed_something = TRUE;
+ }
+
+ /* Flush out the batch of signals to the UniFi. */
+ r = flush_fh_buffer(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to copy from-host signals to UniFi\n");
+ return r;
+ }
+
+
+ /*
+ * Send the host interrupt to say the queues have been modified.
+ */
+ if (card->generate_interrupt)
+ {
+ r = CardGenInt(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to notify UniFi that queues have been modified.\n");
+ return r;
+ }
+ }
+
+#ifdef CSR_WIFI_RX_PATH_SPLIT
+#ifdef CSR_WIFI_RX_PATH_SPLIT_DONT_USE_WQ
+ unifi_rx_queue_flush(card->ospriv);
+#endif
+#endif
+
+ /* See if we can re-enable transmission now */
+ restart_packet_flow(card);
+
+#ifdef CSR_PRE_ALLOC_NET_DATA
+ r = prealloc_netdata_alloc(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "prealloc_netdata failed\n");
+ return r;
+ }
+#endif
+
+ /*
+ * Don't put the thread sleep if we just interacted with the chip,
+ * there might be more to do if we look again.
+ */
+ return r;
+} /* handle_host_protocol() */
+
+
+/*
+ * Rounds the given signal length in bytes to a whole number
+ * of sig_frag_size.
+ */
+#define GET_CHUNKS_FOR(SIG_FRAG_SIZE, LENGTH) (((LENGTH) + ((SIG_FRAG_SIZE)-1)) / (SIG_FRAG_SIZE))
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * read_to_host_signals
+ *
+ * Read everything pending in the UniFi TH signal buffer.
+ * Only do it if the local buffer is empty.
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ * processed Number of signals read:
+ * 0 if there were no signals pending,
+ * 1 if we read at least one signal
+ * Returns:
+ * CSR error code if an error occurred.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult read_to_host_signals(card_t *card, CsrInt32 *processed)
+{
+ CsrInt32 count_thw, count_thr;
+ CsrInt32 unread_chunks, unread_bytes;
+ CsrResult r;
+
+ *processed = 0;
+
+ /* Read any pending signals or bulk data commands */
+ count_thw = unifi_read_shared_count(card, card->sdio_ctrl_addr + 4);
+ if (count_thw < 0)
+ {
+ unifi_error(card->ospriv, "Failed to read to-host sig written count\n");
+ return CSR_RESULT_FAILURE;
+ }
+ card->to_host_signals_w = count_thw; /* diag */
+
+ count_thr = card->to_host_signals_r;
+
+ if (count_thw == count_thr)
+ {
+ return CSR_RESULT_SUCCESS;
+ }
+
+ unread_chunks =
+ (((count_thw - count_thr) + 128) % 128) - card->th_buffer.count;
+
+ if (unread_chunks == 0)
+ {
+ return CSR_RESULT_SUCCESS;
+ }
+
+ unread_bytes = card->config_data.sig_frag_size * unread_chunks;
+
+
+ r = unifi_bulk_rw(card,
+ card->config_data.tohost_sigbuf_handle,
+ card->th_buffer.ptr,
+ unread_bytes,
+ UNIFI_SDIO_READ);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read ToHost signal\n");
+ return r;
+ }
+
+ card->th_buffer.ptr += unread_bytes;
+ card->th_buffer.count += (CsrUint16)unread_chunks;
+
+ *processed = 1;
+
+ return CSR_RESULT_SUCCESS;
+} /* read_to_host_signals() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * update_to_host_signals_r
+ *
+ * Advance the shared-memory count of chunks read from the to-host
+ * signal buffer.
+ * Raise a UniFi internal interrupt to tell the firmware that the
+ * count has changed.
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ * pending Number of chunks remaining
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success or CSR error code
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult update_to_host_signals_r(card_t *card, CsrInt16 pending)
+{
+ CsrResult r;
+
+ card->to_host_signals_r =
+ (card->to_host_signals_r + (card->th_buffer.count - pending)) % 128;
+ card->th_buffer.count = pending;
+
+ /* Update the count of signals read */
+ r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 6,
+ (CsrUint8)card->to_host_signals_r);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to update to-host signals read\n");
+ return r;
+ }
+
+ r = CardGenInt(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to notify UniFi that we processed to-host signals.\n");
+ return r;
+ }
+
+ card->generate_interrupt = 0;
+
+ return CSR_RESULT_SUCCESS;
+} /* update_to_host_signals_r() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * read_unpack_cmd
+ *
+ * Converts a wire-formatted command to the host bulk_data_cmd_t structure.
+ *
+ * Arguments:
+ * ptr Pointer to the command
+ * bulk_data_cmd Pointer to the host structure
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void read_unpack_cmd(const CsrUint8 *ptr, bulk_data_cmd_t *bulk_data_cmd)
+{
+ CsrInt16 index = 0;
+ bulk_data_cmd->cmd_and_len = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ bulk_data_cmd->data_slot = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ bulk_data_cmd->offset = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ bulk_data_cmd->buffer_handle = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+} /* read_unpack_cmd */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * process_to_host_signals
+ *
+ * Read and dispatch signals from the UniFi
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ * processed Pointer to location to write processing result:
+ * 0 if there were no signals pending,
+ * 1 if we read at least one signal
+ *
+ * Returns:
+ * CSR error code if there was an error
+ *
+ * Notes:
+ * Since bulk data transfers can take a long time, if we wait until
+ * all are done before we acknowledge the signals, the UniFi runs out
+ * of buffer space. Therefore we keep a count of the bytes transferred
+ * in bulk data commands, and update the to-host-signals-read count
+ * if we've done a large transfer.
+ *
+ * All data in the f/w is stored in a little endian format, without any
+ * padding bytes. Every read from the memory has to be transformed in
+ * host (cpu specific) format, before we can process it. Therefore we
+ * use read_unpack_cmd() and read_unpack_signal() to convert the raw data
+ * contained in the card->th_buffer.buf to host structures.
+ * Important: UDI clients use wire-formatted structures, so we need to
+ * indicate all data, as we have read it from the device.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult process_to_host_signals(card_t *card, CsrInt32 *processed)
+{
+ CsrInt16 pending;
+ CsrInt16 remaining;
+ CsrUint8 *bufptr;
+ bulk_data_param_t data_ptrs;
+ CsrInt16 cmd;
+ CsrUint16 sig_len;
+ CsrInt16 i;
+ CsrUint16 chunks_in_buf;
+ CsrUint16 bytes_transferred = 0;
+ CsrResult r = CSR_RESULT_SUCCESS;
+
+ *processed = 0;
+
+ pending = card->th_buffer.count;
+
+ /* Are there new to-host signals? */
+ unifi_trace(card->ospriv, UDBG4, "handling %d to-host chunks\n", pending);
+
+ if (!pending)
+ {
+ return CSR_RESULT_SUCCESS;
+ }
+
+ /*
+ * This is a pointer to the raw data we have read from the f/w.
+ * Can be a signal or a command. Note that we need to convert
+ * it to a host structure before we process it.
+ */
+ bufptr = card->th_buffer.buf;
+
+ while (pending > 0)
+ {
+ CsrInt16 f_flush_count = 0;
+
+ /*
+ * Command and length are common to signal and bulk data msgs.
+ * If command == 0 (i.e. a signal), len is number of bytes
+ * *following* the 2-byte header.
+ */
+ cmd = bufptr[1] >> 4;
+ sig_len = bufptr[0] + ((bufptr[1] & 0x0F) << 8);
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "Received UniFi msg cmd=%d, len=%d\n",
+ cmd, sig_len);
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ if ((sig_len == 0) &&
+ ((cmd != SDIO_CMD_CLEAR_SLOT) && (cmd != SDIO_CMD_PADDING)))
+ {
+ unifi_error(card->ospriv, "incomplete signal or command: has size zero\n");
+ return CSR_RESULT_FAILURE;
+ }
+ /*
+ * Make sure the buffer contains a complete message.
+ * Signals may occupy multiple chunks, bulk-data commands occupy
+ * one chunk.
+ */
+ if (cmd == SDIO_CMD_SIGNAL)
+ {
+ chunks_in_buf = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(sig_len + 2));
+ }
+ else
+ {
+ chunks_in_buf = 1;
+ }
+
+ if (chunks_in_buf > (CsrUint16)pending)
+ {
+ unifi_error(card->ospriv, "incomplete signal (0x%x?): need %d chunks, got %d\n",
+ GET_SIGNAL_ID(bufptr + 2),
+ chunks_in_buf, pending);
+ unifi_error(card->ospriv, " thsw=%d, thsr=%d\n",
+ card->to_host_signals_w,
+ card->to_host_signals_r);
+ return CSR_RESULT_FAILURE;
+ }
+
+
+ switch (cmd)
+ {
+ case SDIO_CMD_SIGNAL:
+ /* This is a signal. Read the rest of it and then handle it. */
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ card->cmd_prof.sdio_cmd_signal++;
+#endif
+
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
+ {
+ /* Retrieve dataRefs[i].DataLength */
+ CsrUint16 data_len = GET_PACKED_DATAREF_LEN(bufptr + 2, i);
+
+ /*
+ * The bulk data length in the signal can not be greater than
+ * the maximun length allowed by the SDIO config structure.
+ */
+ if (data_len > card->config_data.data_slot_size)
+ {
+ unifi_error(card->ospriv,
+ "Bulk Data length (%d) exceeds Maximum Bulk Data length (%d)\n",
+ data_len, card->config_data.data_slot_size);
+ return CSR_RESULT_FAILURE;
+ }
+
+ /*
+ * Len here might not be the same as the length in the
+ * bulk data slot. The slot length will always be even,
+ * but len could be odd.
+ */
+ if (data_len != 0)
+ {
+ /* Retrieve dataRefs[i].SlotNumber */
+ CsrInt16 slot = GET_PACKED_DATAREF_SLOT(bufptr + 2, i);
+
+ if (slot >= card->config_data.num_tohost_data_slots)
+ {
+ unifi_error(card->ospriv, "!!!bad slot number in to-host signal: %d, sig 0x%X\n",
+ slot, cmd);
+ return CSR_RESULT_FAILURE;
+ }
+
+ data_ptrs.d[i].os_data_ptr = card->to_host_data[slot].os_data_ptr;
+ data_ptrs.d[i].os_net_buf_ptr = card->to_host_data[slot].os_net_buf_ptr;
+ data_ptrs.d[i].net_buf_length = card->to_host_data[slot].net_buf_length;
+ data_ptrs.d[i].data_length = data_len;
+ }
+ else
+ {
+ UNIFI_INIT_BULK_DATA(&data_ptrs.d[i]);
+ }
+ }
+
+ /*
+ * Log the signal to the UDI, before call unifi_receive_event() as
+ * it can modify the bulk data.
+ */
+ if (card->udi_hook)
+ {
+ (*card->udi_hook)(card->ospriv, bufptr + 2, sig_len,
+ &data_ptrs, UDI_LOG_TO_HOST);
+ }
+
+#ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
+ if (GET_SIGNAL_ID(bufptr + 2) == CSR_MA_PACKET_CONFIRM_ID)
+ {
+ card->cmd_prof.tx_cfm_count++;
+ }
+ else if (GET_SIGNAL_ID(bufptr + 2) == CSR_MA_PACKET_INDICATION_ID)
+ {
+ if (data_ptrs.d[0].os_data_ptr)
+ {
+ if ((*data_ptrs.d[0].os_data_ptr) & 0x08)
+ {
+ card->cmd_prof.rx_count++;
+ }
+ }
+ }
+#endif
+ /*
+ * Check if the signal is MA-PACKET.cfm and if so check the status.
+ * If the status is failure, search through the slot records to find
+ * if any slots are occupied for this host tag. This can happen if
+ * f/w has not downloaded the bulkdata and before that itself it has
+ * signalled the confirm with failure. If it finds a slot with that
+ * host tag then, it clears the corresponding slot
+ */
+
+ if (GET_SIGNAL_ID(bufptr + 2) == CSR_MA_PACKET_CONFIRM_ID)
+ {
+ /* Get host tag and transmission status */
+ CsrUint32 host_tag = GET_PACKED_MA_PACKET_CONFIRM_HOST_TAG(bufptr + 2);
+ CsrUint16 status = GET_PACKED_MA_PACKET_CONFIRM_TRANSMISSION_STATUS(bufptr + 2);
+
+ unifi_trace(card->ospriv, UDBG4, "process_to_host_signals signal ID=%x host Tag=%x status=%x\n",
+ GET_SIGNAL_ID(bufptr + 2), host_tag, status);
+
+ /* If transmission status is failure then search through the slot records
+ * and if for any slot records the clear slot is not done then do it now
+ */
+
+ if (status && (card->fh_slot_host_tag_record))
+ {
+ CsrUint16 num_fh_slots = card->config_data.num_fromhost_data_slots;
+
+ /* search through the list of slot records and match with host tag
+ * If a slot is not yet cleared then clear the slot from here
+ */
+ for (i = 0; i < num_fh_slots; i++)
+ {
+ if (card->fh_slot_host_tag_record[i] == host_tag)
+ {
+#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
+ /* Invoke the HAL module function to requeue it back to HAL Queues */
+ r = unifi_reque_ma_packet_request(card->ospriv, host_tag, status, &card->from_host_data[i].bd);
+ card->fh_slot_host_tag_record[i] = CSR_WIFI_HIP_RESERVED_HOST_TAG;
+ if (CSR_RESULT_SUCCESS != r)
+ {
+ unifi_trace(card->ospriv, UDBG5, "process_to_host_signals: Failed to requeue Packet(hTag:%x) back to HAL \n", host_tag);
+ CardClearFromHostDataSlot(card, i);
+ }
+ else
+ {
+ CardClearFromHostDataSlotWithoutFreeingBulkData(card, i);
+ }
+
+#else
+ unifi_trace(card->ospriv, UDBG4, "process_to_host_signals Clear slot=%x host tag=%x\n", i, host_tag);
+ card->fh_slot_host_tag_record[i] = CSR_WIFI_HIP_RESERVED_HOST_TAG;
+
+ /* Set length field in from_host_data array to 0 */
+ CardClearFromHostDataSlot(card, i);
+#endif
+ break;
+ }
+ }
+ }
+ }
+
+ /* Pass event to OS layer */
+ unifi_receive_event(card->ospriv, bufptr + 2, sig_len, &data_ptrs);
+
+ /* Initialise the to_host data, so it can be re-used. */
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
+ {
+ /* The slot is only valid if the length is non-zero. */
+ if (GET_PACKED_DATAREF_LEN(bufptr + 2, i) != 0)
+ {
+ CsrInt16 slot = GET_PACKED_DATAREF_SLOT(bufptr + 2, i);
+ if (slot < card->config_data.num_tohost_data_slots)
+ {
+ UNIFI_INIT_BULK_DATA(&card->to_host_data[slot]);
+ }
+ }
+ }
+
+#ifndef CSR_WIFI_DEFER_TH_FLUSH
+ /*
+ * If we have previously transferred a lot of data, ack
+ * the signals read so far, so f/w can reclaim the buffer
+ * memory sooner.
+ */
+ if (bytes_transferred >= TO_HOST_FLUSH_THRESHOLD)
+ {
+ f_flush_count = 1;
+ }
+#endif
+ break;
+
+
+ case SDIO_CMD_CLEAR_SLOT:
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ card->cmd_prof.sdio_cmd_clear_slot++;
+#endif
+ /* This is a clear slot command. */
+ if (sig_len != 0)
+ {
+ unifi_error(card->ospriv, "process_to_host_signals: clear slot, bad data len: 0x%X at offset %d\n",
+ sig_len, bufptr - card->th_buffer.buf);
+ return CSR_RESULT_FAILURE;
+ }
+
+ r = process_clear_slot_command(card, bufptr);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to process clear slot\n");
+ return r;
+ }
+ break;
+
+ case SDIO_CMD_TO_HOST_TRANSFER:
+ case SDIO_CMD_FROM_HOST_TRANSFER:
+ case SDIO_CMD_FROM_HOST_AND_CLEAR:
+ case SDIO_CMD_OVERLAY_TRANSFER:
+ /* This is a bulk data command. */
+ if (sig_len & 1)
+ {
+ unifi_error(card->ospriv, "process_to_host_signals: bulk data, bad data len: 0x%X at offset %d\n",
+ sig_len, bufptr - card->th_buffer.buf);
+ return CSR_RESULT_FAILURE;
+ }
+
+ r = process_bulk_data_command(card, bufptr, cmd, sig_len);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to process bulk cmd\n");
+ return r;
+ }
+ /* Count the bytes transferred */
+ bytes_transferred += sig_len;
+
+ if (cmd == SDIO_CMD_FROM_HOST_AND_CLEAR)
+ {
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ card->cmd_prof.sdio_cmd_from_host_and_clear++;
+#endif
+#ifndef CSR_WIFI_DEFER_TH_FLUSH
+ f_flush_count = 1;
+#endif
+ }
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ else if (cmd == SDIO_CMD_FROM_HOST_TRANSFER)
+ {
+ card->cmd_prof.sdio_cmd_from_host++;
+ }
+ else if (cmd == SDIO_CMD_TO_HOST_TRANSFER)
+ {
+ card->cmd_prof.sdio_cmd_to_host++;
+ }
+#endif
+ break;
+
+ case SDIO_CMD_PADDING:
+ break;
+
+ default:
+ unifi_error(card->ospriv, "Unrecognised to-host command: %d\n", cmd);
+ break;
+ }
+
+ bufptr += chunks_in_buf * card->config_data.sig_frag_size;
+ pending -= chunks_in_buf;
+
+ /*
+ * Write out the host signal count when a significant
+ * number of bytes of bulk data have been transferred or
+ * when we have performed a CopyFromHostAndClear.
+ */
+ if (f_flush_count)
+ {
+ r = update_to_host_signals_r(card, pending);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ bytes_transferred = 0;
+ }
+ }
+
+ if (pending)
+ {
+ unifi_warning(card->ospriv, "proc_th_sigs: %d unprocessed\n", pending);
+ }
+
+ /* If we processed any signals, write the updated count to UniFi */
+ if (card->th_buffer.count != pending)
+ {
+ r = update_to_host_signals_r(card, pending);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ }
+
+ /*
+ * Reset the buffer pointer, copying down any un-processed signals.
+ * This can happen if we enable the optimisation in read_to_host_signals()
+ * that limits the length to whole blocks.
+ */
+ remaining = card->th_buffer.ptr - bufptr;
+ if (remaining < 0)
+ {
+ unifi_error(card->ospriv, "Processing TH signals overran the buffer\n");
+ return CSR_RESULT_FAILURE;
+ }
+ if (remaining > 0)
+ {
+ /* Use a safe copy because source and destination may overlap */
+ CsrUint8 *d = card->th_buffer.buf;
+ CsrUint8 *s = bufptr;
+ CsrInt32 n = remaining;
+ while (n--)
+ {
+ *d++ = *s++;
+ }
+ }
+ card->th_buffer.ptr = card->th_buffer.buf + remaining;
+
+
+ /* If we reach here then we processed something */
+ *processed = 1;
+ return CSR_RESULT_SUCCESS;
+} /* process_to_host_signals() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * process_clear_slot_command
+ *
+ * Process a clear slot command fom the UniFi.
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ * bdcmd Pointer to bulk-data command msg from UniFi
+ *
+ * Returns:
+ * 0 on success, CSR error code on error
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult process_clear_slot_command(card_t *card, const CsrUint8 *cmdptr)
+{
+ CsrUint16 data_slot;
+ CsrInt16 slot;
+
+ data_slot = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(cmdptr + SIZEOF_UINT16);
+
+ unifi_trace(card->ospriv, UDBG4, "Processing clear slot cmd, slot=0x%X\n",
+ data_slot);
+
+ slot = data_slot & 0x7FFF;
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "CMD clear data slot 0x%04x\n", data_slot);
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ if (data_slot & SLOT_DIR_TO_HOST)
+ {
+ if (slot >= card->config_data.num_tohost_data_slots)
+ {
+ unifi_error(card->ospriv,
+ "Invalid to-host data slot in SDIO_CMD_CLEAR_SLOT: %d\n",
+ slot);
+ return CSR_RESULT_FAILURE;
+ }
+ /* clear to-host data slot */
+ unifi_warning(card->ospriv, "Unexpected clear to-host data slot cmd: 0x%04x\n",
+ data_slot);
+ }
+ else
+ {
+ if (slot >= card->config_data.num_fromhost_data_slots)
+ {
+ unifi_error(card->ospriv,
+ "Invalid from-host data slot in SDIO_CMD_CLEAR_SLOT: %d\n",
+ slot);
+ return CSR_RESULT_FAILURE;
+ }
+
+ /*
+ * The driver is the owner to clear all slots now
+ * Ref - comment in process_fh_traffic_queue
+ * so it will just ignore the clear slot command from firmware
+ * and return success
+ */
+ return CSR_RESULT_SUCCESS;
+
+ /* Set length field in from_host_data array to 0 */
+ /* CardClearFromHostDataSlot(card, slot); */
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* process_clear_slot_command() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * process_bulk_data_command
+ *
+ * Process a bulk data request from the UniFi.
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ * bdcmd Pointer to bulk-data command msg from UniFi
+ * cmd, len Decoded values of command and length from the msg header
+ * Cmd will only be one of:
+ * SDIO_CMD_TO_HOST_TRANSFER
+ * SDIO_CMD_FROM_HOST_TRANSFER
+ * SDIO_CMD_FROM_HOST_AND_CLEAR
+ * SDIO_CMD_OVERLAY_TRANSFER
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error code on error
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult process_bulk_data_command(card_t *card, const CsrUint8 *cmdptr,
+ CsrInt16 cmd, CsrUint16 len)
+{
+ bulk_data_desc_t *bdslot;
+#ifdef CSR_WIFI_ALIGNMENT_WORKAROUND
+ CsrUint8 *host_bulk_data_slot;
+#endif
+ bulk_data_cmd_t bdcmd;
+ CsrInt16 offset;
+ CsrInt16 slot;
+ CsrInt16 dir;
+ CsrResult r;
+
+ read_unpack_cmd(cmdptr, &bdcmd);
+
+ unifi_trace(card->ospriv, UDBG4, "Processing bulk data cmd %d %s, len=%d, slot=0x%X\n",
+ cmd, lookup_bulkcmd_name(cmd), len, bdcmd.data_slot);
+
+ /*
+ * Round up the transfer length if required.
+ * This is useful to force all transfers to be a multiple of the SDIO block
+ * size, so the SDIO driver won't try to use a byte-mode CMD53. These are
+ * broken on some hardware platforms.
+ */
+ if (card->sdio_io_block_pad)
+ {
+ len = (len + card->sdio_io_block_size - 1) & ~(card->sdio_io_block_size - 1);
+ unifi_trace(card->ospriv, UDBG4, "Rounded bulk data length up to %d\n", len);
+ }
+
+ slot = bdcmd.data_slot & 0x7FFF;
+
+ if (cmd == SDIO_CMD_OVERLAY_TRANSFER)
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE; /* Not used on CSR6xxx */
+ }
+ else
+ {
+ if (bdcmd.data_slot & SLOT_DIR_TO_HOST)
+ {
+ /* Request is for to-host bulk data */
+
+ /* Check sanity of slot number */
+ if (slot >= card->config_data.num_tohost_data_slots)
+ {
+ unifi_error(card->ospriv,
+ "Invalid to-host data slot in SDIO bulk xfr req: %d\n",
+ slot);
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Allocate memory for card->to_host_data[slot] bulk data here. */
+#ifdef CSR_PRE_ALLOC_NET_DATA
+ r = prealloc_netdata_get(card, &card->to_host_data[slot], len);
+#else
+ r = unifi_net_data_malloc(card->ospriv, &card->to_host_data[slot], len);
+#endif
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to allocate t-h bulk data\n");
+ return CSR_RESULT_FAILURE;
+ }
+
+ bdslot = &card->to_host_data[slot];
+
+ /* Make sure that the buffer is 4-bytes aligned */
+ r = unifi_net_dma_align(card->ospriv, bdslot);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to align t-h bulk data buffer for DMA\n");
+ return CSR_RESULT_FAILURE;
+ }
+ }
+ else
+ {
+ /* Request is for from-host bulk data */
+
+ if (slot >= card->config_data.num_fromhost_data_slots)
+ {
+ unifi_error(card->ospriv,
+ "Invalid from-host data slot in SDIO bulk xfr req: %d\n",
+ slot);
+ return CSR_RESULT_FAILURE;
+ }
+ bdslot = &card->from_host_data[slot].bd;
+ }
+ offset = bdcmd.offset;
+ }
+ /* Do the transfer */
+ dir = (cmd == SDIO_CMD_TO_HOST_TRANSFER)?
+ UNIFI_SDIO_READ : UNIFI_SDIO_WRITE;
+
+ unifi_trace(card->ospriv, UDBG4,
+ "Bulk %c %s len=%d, handle %d - slot=%d %p+(%d)\n",
+ (dir == UNIFI_SDIO_READ)?'R' : 'W',
+ lookup_bulkcmd_name(cmd),
+ len,
+ bdcmd.buffer_handle,
+ slot, bdslot->os_data_ptr, offset);
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "Bulk %s len=%d, handle %d - slot=%d %p+(%d)\n",
+ lookup_bulkcmd_name(cmd),
+ len,
+ bdcmd.buffer_handle,
+ slot, bdslot->os_data_ptr, offset);
+#endif /* CSR_WIFI_HIP_NOISY */
+
+
+ if (bdslot->os_data_ptr == NULL)
+ {
+ unifi_error(card->ospriv, "Null os_data_ptr - Bulk %s handle %d - slot=%d o=(%d)\n",
+ lookup_bulkcmd_name(cmd),
+ bdcmd.buffer_handle,
+ slot,
+ offset);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+#ifdef CSR_WIFI_ALIGNMENT_WORKAROUND
+ /* if os_data_ptr is not 4-byte aligned, then allocate a new buffer and copy data
+ to new buffer to ensure the address passed to unifi_bulk_rw is 4-byte aligned */
+
+ if (len != 0 && (dir == UNIFI_SDIO_WRITE) && (((CsrIntptr)bdslot->os_data_ptr + offset) & 3))
+ {
+ host_bulk_data_slot = CsrMemAllocDma(len);
+
+ if (!host_bulk_data_slot)
+ {
+ unifi_error(card->ospriv, " failed to allocate request_data before unifi_bulk_rw\n");
+ return -1;
+ }
+
+ CsrMemCpy((void *)host_bulk_data_slot,
+ (void *)(bdslot->os_data_ptr + offset), len);
+
+ r = unifi_bulk_rw(card,
+ bdcmd.buffer_handle,
+ (void *)host_bulk_data_slot,
+ len,
+ dir);
+ }
+ else
+#endif
+ {
+ r = unifi_bulk_rw(card,
+ bdcmd.buffer_handle,
+ (void *)(bdslot->os_data_ptr + offset),
+ len,
+ dir);
+ }
+
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv,
+ "Failed: %s hlen=%d, slen=%d, handle %d - slot=%d %p+0x%X\n",
+ lookup_bulkcmd_name(cmd),
+ len, /* Header length */
+ bdslot->data_length, /* Length stored in slot */
+ bdcmd.buffer_handle,
+ slot, bdslot->os_data_ptr, offset);
+ return r;
+ }
+
+ bdslot->data_length = len;
+
+ if (cmd == SDIO_CMD_FROM_HOST_AND_CLEAR)
+ {
+ if (slot >= card->config_data.num_fromhost_data_slots)
+ {
+ unifi_error(card->ospriv,
+ "Invalid from-host data slot in SDIO_CMD_FROM_HOST_AND_CLEAR: %d\n",
+ slot);
+ return CSR_RESULT_FAILURE;
+ }
+
+#ifdef CSR_WIFI_ALIGNMENT_WORKAROUND
+ /* moving this check before we clear host data slot */
+ if ((len != 0) && (dir == UNIFI_SDIO_WRITE) && (((CsrIntptr)bdslot->os_data_ptr + offset) & 3))
+ {
+ CsrMemFreeDma(host_bulk_data_slot);
+ }
+#endif
+
+ if (card->fh_slot_host_tag_record)
+ {
+ unifi_trace(card->ospriv, UDBG5, "CopyFromHostAndClearSlot Reset entry for slot=%d\n", slot);
+
+ /* reset the host tag entry for the corresponding slot */
+ card->fh_slot_host_tag_record[slot] = CSR_WIFI_HIP_RESERVED_HOST_TAG;
+ }
+
+
+ /* Set length field in from_host_data array to 0 */
+ CardClearFromHostDataSlot(card, slot);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* process_bulk_data_command() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * check_fh_sig_slots
+ *
+ * Check whether there are <n> free signal slots available on UniFi.
+ * This takes into account the signals already batched since the
+ * from_host_signal counts were last read.
+ * If the from_host_signal counts indicate not enough space, we read
+ * the latest count from UniFi to see if some more have been freed.
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS, otherwise CSR error code on error.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult check_fh_sig_slots(card_t *card, CsrUint16 needed, CsrInt32 *space_fh)
+{
+ CsrUint32 count_fhw;
+ CsrUint32 occupied_fh, slots_fh;
+ CsrInt32 count_fhr;
+
+ count_fhw = card->from_host_signals_w;
+ count_fhr = card->from_host_signals_r;
+ slots_fh = card->config_data.num_fromhost_sig_frags;
+
+ /* Only read the space in from-host queue if necessary */
+ occupied_fh = (count_fhw - count_fhr) % 128;
+
+ if (slots_fh < occupied_fh)
+ {
+ *space_fh = 0;
+ }
+ else
+ {
+ *space_fh = slots_fh - occupied_fh;
+ }
+
+ if ((occupied_fh != 0) && (*space_fh < needed))
+ {
+ count_fhr = unifi_read_shared_count(card, card->sdio_ctrl_addr + 2);
+ if (count_fhr < 0)
+ {
+ unifi_error(card->ospriv, "Failed to read from-host sig read count\n");
+ return CSR_RESULT_FAILURE;
+ }
+ card->from_host_signals_r = count_fhr; /* diag */
+
+ occupied_fh = (count_fhw - count_fhr) % 128;
+ *space_fh = slots_fh - occupied_fh;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* check_fh_sig_slots() */
+
+
+/*
+* If we are padding the From-Host signals to the SDIO block size,
+* we need to round up the needed_chunks to the SDIO block size.
+*/
+#define ROUND_UP_NEEDED_CHUNKS(_card, _needed_chunks) \
+ { \
+ CsrUint16 _chunks_per_block; \
+ CsrUint16 _chunks_in_last_block; \
+ \
+ if (_card->sdio_io_block_pad) \
+ { \
+ _chunks_per_block = _card->sdio_io_block_size / _card->config_data.sig_frag_size; \
+ _chunks_in_last_block = _needed_chunks % _chunks_per_block; \
+ if (_chunks_in_last_block != 0) \
+ { \
+ _needed_chunks = _needed_chunks + (_chunks_per_block - _chunks_in_last_block); \
+ } \
+ } \
+ }
+
+
+#define ROUND_UP_SPACE_CHUNKS(_card, _space_chunks) \
+ { \
+ CsrUint16 _chunks_per_block; \
+ \
+ if (_card->sdio_io_block_pad) \
+ { \
+ _chunks_per_block = _card->sdio_io_block_size / _card->config_data.sig_frag_size; \
+ _space_chunks = ((_space_chunks / _chunks_per_block) * _chunks_per_block); \
+ } \
+ }
+
+
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * process_fh_cmd_queue
+ *
+ * Take one signal off the from-host queue and copy it to the UniFi.
+ * Does nothing if the UniFi has no slots free.
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ * processed Location to write:
+ * 0 if there is nothing on the queue to process
+ * 1 if a signal was successfully processed
+ *
+ * Returns:
+ * CSR error code if an error occurred.
+ *
+ * Notes:
+ * The from-host queue contains signal requests from the network driver
+ * and any UDI clients interspersed. UDI clients' requests have been stored
+ * in the from-host queue using the wire-format structures, as they arrive.
+ * All other requests are stored in the from-host queue using the host
+ * (cpu specific) structures. We use the is_packed member of the card_signal_t
+ * structure that describes the queue to make the distiction.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult process_fh_cmd_queue(card_t *card, CsrInt32 *processed)
+{
+ q_t *sigq = &card->fh_command_queue;
+
+ CsrResult r;
+ CsrUint16 pending_sigs;
+ CsrUint16 pending_chunks;
+ CsrUint16 needed_chunks;
+ CsrInt32 space_chunks;
+ CsrUint16 q_index;
+
+ *processed = 0;
+
+ /* Get the number of pending signals. */
+ pending_sigs = CSR_WIFI_HIP_Q_SLOTS_USED(sigq);
+ unifi_trace(card->ospriv, UDBG5, "proc_fh: %d pending\n", pending_sigs);
+ if (pending_sigs == 0)
+ {
+ /* Nothing to do */
+ return CSR_RESULT_SUCCESS;
+ }
+
+ /* Work out how many chunks we have waiting to send */
+ for (pending_chunks = 0, q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(sigq);
+ q_index != CSR_WIFI_HIP_Q_NEXT_W_SLOT(sigq);
+ q_index = CSR_WIFI_HIP_Q_WRAP(sigq, q_index + 1))
+ {
+ card_signal_t *csptr = CSR_WIFI_HIP_Q_SLOT_DATA(sigq, q_index);
+
+ /*
+ * Note that GET_CHUNKS_FOR() needs the size of the packed
+ * (wire-formatted) structure
+ */
+ pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(csptr->signal_length + 2));
+ }
+
+ /*
+ * Check whether UniFi has space for all the buffered bulk-data
+ * commands and signals as well.
+ */
+ needed_chunks = pending_chunks + card->fh_buffer.count;
+
+ /* Round up to the block size if necessary */
+ ROUND_UP_NEEDED_CHUNKS(card, needed_chunks);
+
+ r = check_fh_sig_slots(card, needed_chunks, &space_chunks);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ /* Error */
+ unifi_error(card->ospriv, "Failed to read fh sig count\n");
+ return r;
+ }
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "proc_fh: %d chunks free, need %d\n",
+ space_chunks, needed_chunks);
+#endif /* CSR_WIFI_HIP_NOISY */
+
+
+ /*
+ * Coalesce as many from-host signals as possible
+ * into a single block and write using a single CMD53
+ */
+ if (needed_chunks > (CsrUint16)space_chunks)
+ {
+ /* Round up to the block size if necessary */
+ ROUND_UP_SPACE_CHUNKS(card, space_chunks);
+
+ /*
+ * If the f/w has less free chunks than those already pending
+ * return immediately.
+ */
+ if ((CsrUint16)space_chunks <= card->fh_buffer.count)
+ {
+ /*
+ * No room in UniFi for any signals after the buffered bulk
+ * data commands have been sent.
+ */
+ unifi_error(card->ospriv, "not enough room to send signals, need %d chunks, %d free\n",
+ card->fh_buffer.count, space_chunks);
+ card->generate_interrupt = 1;
+ return CSR_RESULT_SUCCESS;
+ }
+ pending_chunks = (CsrUint16)(space_chunks - card->fh_buffer.count);
+ }
+
+ while (pending_sigs-- && pending_chunks > 0)
+ {
+ card_signal_t *csptr;
+ CsrInt16 i;
+ CsrUint16 sig_chunks, total_length, free_chunks_in_fh_buffer;
+ bulk_data_param_t bulkdata;
+ CsrUint8 *packed_sigptr;
+ CsrUint16 signal_length = 0;
+
+ /* Retrieve the entry at the head of the queue */
+ q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(sigq);
+
+ /* Get a pointer to the containing card_signal_t struct */
+ csptr = CSR_WIFI_HIP_Q_SLOT_DATA(sigq, q_index);
+
+ /* Get the new length of the packed signal */
+ signal_length = csptr->signal_length;
+
+ if ((signal_length & 1) || (signal_length > UNIFI_PACKED_SIGBUF_SIZE))
+ {
+ unifi_error(card->ospriv, "process_fh_queue: Bad len: %d\n", signal_length);
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Need space for 2-byte SDIO protocol header + signal */
+ sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(signal_length + 2));
+
+ free_chunks_in_fh_buffer = GET_CHUNKS_FOR(card->config_data.sig_frag_size,
+ (CsrUint16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
+ if (free_chunks_in_fh_buffer < sig_chunks)
+ {
+ /* No more room */
+ unifi_notice(card->ospriv, "proc_fh_cmd_q: no room in fh buffer for 0x%.4X, deferring\n",
+ (CsrUint16)(GET_SIGNAL_ID(csptr->sigbuf)));
+ break;
+ }
+
+ packed_sigptr = csptr->sigbuf;
+
+ /* Claim and set up a from-host data slot */
+ if (CSR_RESULT_FAILURE == CardWriteBulkData(card, csptr, UNIFI_TRAFFIC_Q_MLME))
+ {
+ unifi_notice(card->ospriv, "proc_fh_cmd_q: no fh data slots for 0x%.4X, deferring\n",
+ (CsrUint16)(GET_SIGNAL_ID(csptr->sigbuf)));
+ break;
+ }
+
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
+ {
+ if (csptr->bulkdata[i].data_length == 0)
+ {
+ UNIFI_INIT_BULK_DATA(&bulkdata.d[i]);
+ }
+ else
+ {
+ bulkdata.d[i].os_data_ptr = csptr->bulkdata[i].os_data_ptr;
+ bulkdata.d[i].data_length = csptr->bulkdata[i].data_length;
+ }
+
+ /* Pass the free responsibility to the lower layer. */
+ UNIFI_INIT_BULK_DATA(&csptr->bulkdata[i]);
+ }
+
+ unifi_trace(card->ospriv, UDBG2, "Sending signal 0x%.4X\n",
+ GET_SIGNAL_ID(packed_sigptr));
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "Sending signal 0x%.4X\n",
+ GET_SIGNAL_ID(packed_sigptr));
+#endif /* CSR_WIFI_HIP_NOISY */
+
+
+ /* Append packed signal to F-H buffer */
+ total_length = sig_chunks * card->config_data.sig_frag_size;
+
+ card->fh_buffer.ptr[0] = (CsrUint8)(signal_length & 0xff);
+ card->fh_buffer.ptr[1] =
+ (CsrUint8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
+
+ CsrMemCpy(card->fh_buffer.ptr + 2, packed_sigptr, signal_length);
+ CsrMemSet(card->fh_buffer.ptr + 2 + signal_length, 0,
+ total_length - (2 + signal_length));
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "proc_fh: fh_buffer %d bytes \n",
+ signal_length + 2);
+ dump(card->fh_buffer.ptr, signal_length + 2);
+ unifi_trace(card->ospriv, UDBG1, " \n");
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ card->fh_buffer.ptr += total_length;
+ card->fh_buffer.count += sig_chunks;
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "Added %d to fh buf, len now %d, count %d\n",
+ signal_length,
+ card->fh_buffer.ptr - card->fh_buffer.buf,
+ card->fh_buffer.count);
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ (*processed)++;
+ pending_chunks -= sig_chunks;
+
+ /* Log the signal to the UDI. */
+ /* UDI will get the packed structure */
+ /* Can not log the unpacked signal, unless we reconstruct it! */
+ if (card->udi_hook)
+ {
+ (*card->udi_hook)(card->ospriv, packed_sigptr, signal_length,
+ &bulkdata, UDI_LOG_FROM_HOST);
+ }
+
+ /* Remove entry from q */
+ csptr->signal_length = 0;
+ CSR_WIFI_HIP_Q_INC_R(sigq);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* process_fh_cmd_queue() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * process_fh_traffic_queue
+ *
+ * Take signals off the from-host queue and copy them to the UniFi.
+ * Does nothing if the UniFi has no slots free.
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ * sigq Pointer to the traffic queue
+ * processed Pointer to location to write:
+ * 0 if there is nothing on the queue to process
+ * 1 if a signal was successfully processed
+ *
+ * Returns:
+ * CSR error code if an error occurred.
+ *
+ * Notes:
+ * The from-host queue contains signal requests from the network driver
+ * and any UDI clients interspersed.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult process_fh_traffic_queue(card_t *card, CsrInt32 *processed)
+{
+ q_t *sigq = card->fh_traffic_queue;
+
+ CsrResult r;
+ CsrInt16 n = 0;
+ CsrInt32 q_no;
+ CsrUint16 pending_sigs = 0;
+ CsrUint16 pending_chunks = 0;
+ CsrUint16 needed_chunks;
+ CsrInt32 space_chunks;
+ CsrUint16 q_index;
+ CsrUint32 host_tag = 0;
+ CsrUint16 slot_num = 0;
+
+ *processed = 0;
+
+ /* calculate how many signals are in queues and how many chunks are needed. */
+ for (n = UNIFI_NO_OF_TX_QS - 1; n >= 0; n--)
+ {
+ /* Get the number of pending signals. */
+ pending_sigs += CSR_WIFI_HIP_Q_SLOTS_USED(&sigq[n]);
+ unifi_trace(card->ospriv, UDBG5, "proc_fh%d: %d pending\n", n, pending_sigs);
+
+ /* Work out how many chunks we have waiting to send */
+ for (q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(&sigq[n]);
+ q_index != CSR_WIFI_HIP_Q_NEXT_W_SLOT(&sigq[n]);
+ q_index = CSR_WIFI_HIP_Q_WRAP(&sigq[n], q_index + 1))
+ {
+ card_signal_t *csptr = CSR_WIFI_HIP_Q_SLOT_DATA(&sigq[n], q_index);
+
+ /*
+ * Note that GET_CHUNKS_FOR() needs the size of the packed
+ * (wire-formatted) structure
+ */
+ pending_chunks += GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(csptr->signal_length + 2));
+ }
+ }
+
+ /* If there are no pending signals, just return */
+ if (pending_sigs == 0)
+ {
+ /* Nothing to do */
+ return CSR_RESULT_SUCCESS;
+ }
+
+ /*
+ * Check whether UniFi has space for all the buffered bulk-data
+ * commands and signals as well.
+ */
+ needed_chunks = pending_chunks + card->fh_buffer.count;
+
+ /* Round up to the block size if necessary */
+ ROUND_UP_NEEDED_CHUNKS(card, needed_chunks);
+
+ r = check_fh_sig_slots(card, needed_chunks, &space_chunks);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ /* Error */
+ unifi_error(card->ospriv, "Failed to read fh sig count\n");
+ return r;
+ }
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv,
+ "process_fh_traffic_queue: %d chunks free, need %d\n",
+ space_chunks, needed_chunks);
+ read_fhsr(card); /* debugging only */
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ /* Coalesce as many from-host signals as possible
+ into a single block and write using a single CMD53 */
+ if (needed_chunks > (CsrUint16)space_chunks)
+ {
+ /* Round up to the block size if necessary */
+ ROUND_UP_SPACE_CHUNKS(card, space_chunks);
+
+ if ((CsrUint16)space_chunks <= card->fh_buffer.count)
+ {
+ /*
+ * No room in UniFi for any signals after the buffered bulk
+ * data commands have been sent.
+ */
+ unifi_error(card->ospriv, "not enough room to send signals, need %d chunks, %d free\n",
+ card->fh_buffer.count, space_chunks);
+ card->generate_interrupt = 1;
+ return 0;
+ }
+
+ pending_chunks = (CsrUint16)space_chunks - card->fh_buffer.count;
+ }
+
+ q_no = UNIFI_NO_OF_TX_QS - 1;
+
+ /*
+ * pending_sigs will be exhausted if there are is no restriction to the pending
+ * signals per queue. pending_chunks may be exhausted if there is a restriction.
+ * q_no check will be exhausted if there is a restriction and our round-robin
+ * algorith fails to fill all chunks.
+ */
+ do
+ {
+ card_signal_t *csptr;
+ CsrUint16 sig_chunks, total_length, free_chunks_in_fh_buffer;
+ bulk_data_param_t bulkdata;
+ CsrUint8 *packed_sigptr;
+ CsrUint16 signal_length = 0;
+
+ /* if this queue is empty go to next one. */
+ if (CSR_WIFI_HIP_Q_SLOTS_USED(&sigq[q_no]) == 0)
+ {
+ q_no--;
+ continue;
+ }
+
+ /* Retrieve the entry at the head of the queue */
+ q_index = CSR_WIFI_HIP_Q_NEXT_R_SLOT(&sigq[q_no]);
+
+ /* Get a pointer to the containing card_signal_t struct */
+ csptr = CSR_WIFI_HIP_Q_SLOT_DATA(&sigq[q_no], q_index);
+
+ /* Get the new length of the packed signal */
+ signal_length = csptr->signal_length;
+
+ if ((signal_length & 1) || (signal_length > UNIFI_PACKED_SIGBUF_SIZE))
+ {
+ unifi_error(card->ospriv, "process_fh_traffic_queue: Bad len: %d\n", signal_length);
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Need space for 2-byte SDIO protocol header + signal */
+ sig_chunks = GET_CHUNKS_FOR(card->config_data.sig_frag_size, (CsrUint16)(signal_length + 2));
+ free_chunks_in_fh_buffer = GET_CHUNKS_FOR(card->config_data.sig_frag_size,
+ (CsrUint16)((card->fh_buffer.buf + UNIFI_FH_BUF_SIZE) - card->fh_buffer.ptr));
+ if (free_chunks_in_fh_buffer < sig_chunks)
+ {
+ /* No more room */
+ unifi_notice(card->ospriv, "process_fh_traffic_queue: no more chunks.\n");
+ break;
+ }
+
+ packed_sigptr = csptr->sigbuf;
+ /* Claim and set up a from-host data slot */
+ if (CSR_RESULT_FAILURE == CardWriteBulkData(card, csptr, (unifi_TrafficQueue)q_no))
+ {
+ q_no--;
+ continue;
+ }
+
+ /* Sanity check: MA-PACKET.req must have a valid bulk data */
+ if ((csptr->bulkdata[0].data_length == 0) || (csptr->bulkdata[0].os_data_ptr == NULL))
+ {
+ unifi_error(card->ospriv, "MA-PACKET.req with empty bulk data (%d bytes in %p)\n",
+ csptr->bulkdata[0].data_length, csptr->bulkdata[0].os_data_ptr);
+ dump(packed_sigptr, signal_length);
+ return CSR_RESULT_FAILURE;
+ }
+
+ bulkdata.d[0].os_data_ptr = csptr->bulkdata[0].os_data_ptr;
+ bulkdata.d[0].data_length = csptr->bulkdata[0].data_length;
+ bulkdata.d[0].os_net_buf_ptr = csptr->bulkdata[0].os_net_buf_ptr;
+ bulkdata.d[0].net_buf_length = csptr->bulkdata[0].net_buf_length;
+
+ /* The driver owns clearing of HIP slots for following scenario
+ * - driver has requested a MA-PACKET.req signal
+ * - The f/w after receiving the signal decides it can't send it out due to various reasons
+ * - So the f/w without downloading the bulk data decides to just send a confirmation with fail
+ * - and then sends a clear slot signal to HIP
+ *
+ * But in some cases the clear slot signal never comes and the slot remains --NOT-- freed for ever
+ *
+ * To handle this, HIP will keep the record of host tag for each occupied slot
+ * and then based on status of that Host tag and slot the driver will decide if the slot is
+ * cleared by f/w signal or the slot has to be freed by driver
+ */
+
+ if (card->fh_slot_host_tag_record)
+ {
+ /* Update the f-h slot record for the corresponding host tag */
+ host_tag = GET_PACKED_MA_PACKET_REQUEST_HOST_TAG(packed_sigptr);
+ slot_num = GET_PACKED_DATAREF_SLOT(packed_sigptr, 0) & 0x00FF;
+
+ unifi_trace(card->ospriv, UDBG5,
+ "process_fh_traffic_queue signal ID =%x fh slot=%x Host tag =%x\n",
+ GET_SIGNAL_ID(packed_sigptr), slot_num, host_tag);
+ card->fh_slot_host_tag_record[slot_num] = host_tag;
+ }
+ UNIFI_INIT_BULK_DATA(&bulkdata.d[1]);
+ UNIFI_INIT_BULK_DATA(&csptr->bulkdata[0]);
+ UNIFI_INIT_BULK_DATA(&csptr->bulkdata[1]);
+
+#ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
+ if (bulkdata.d[0].os_data_ptr)
+ {
+ if ((*bulkdata.d[0].os_data_ptr) & 0x08)
+ {
+ card->cmd_prof.tx_count++;
+ }
+ }
+#endif
+ unifi_trace(card->ospriv, UDBG3, "Sending signal 0x%.4X\n",
+ GET_SIGNAL_ID(packed_sigptr));
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "Sending signal 0x%.4X\n",
+ GET_SIGNAL_ID(packed_sigptr));
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ /* Append packed signal to F-H buffer */
+ total_length = sig_chunks * card->config_data.sig_frag_size;
+
+ card->fh_buffer.ptr[0] = (CsrUint8)(signal_length & 0xff);
+ card->fh_buffer.ptr[1] =
+ (CsrUint8)(((signal_length >> 8) & 0xf) | (SDIO_CMD_SIGNAL << 4));
+
+ CsrMemCpy(card->fh_buffer.ptr + 2, packed_sigptr, signal_length);
+ CsrMemSet(card->fh_buffer.ptr + 2 + signal_length, 0,
+ total_length - (2 + signal_length));
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "proc_fh: fh_buffer %d bytes \n",
+ signal_length + 2);
+ dump(card->fh_buffer.ptr, signal_length + 2);
+ unifi_trace(card->ospriv, UDBG1, " \n");
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ card->fh_buffer.ptr += total_length;
+ card->fh_buffer.count += sig_chunks;
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "Added %d to fh buf, len now %d, count %d\n",
+ signal_length,
+ card->fh_buffer.ptr - card->fh_buffer.buf,
+ card->fh_buffer.count);
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ (*processed)++;
+ pending_sigs--;
+ pending_chunks -= sig_chunks;
+
+ /* Log the signal to the UDI. */
+ /* UDI will get the packed structure */
+ /* Can not log the unpacked signal, unless we reconstruct it! */
+ if (card->udi_hook)
+ {
+ (*card->udi_hook)(card->ospriv, packed_sigptr, signal_length,
+ &bulkdata, UDI_LOG_FROM_HOST);
+ }
+
+ /* Remove entry from q */
+ csptr->signal_length = 0;
+ /* Note that the traffic queue has only one valid bulk data buffer. */
+ csptr->bulkdata[0].data_length = 0;
+
+ CSR_WIFI_HIP_Q_INC_R(&sigq[q_no]);
+ } while ((pending_sigs > 0) && (pending_chunks > 0) && (q_no >= 0));
+
+ return CSR_RESULT_SUCCESS;
+} /* process_fh_traffic_queue() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * flush_fh_buffer
+ *
+ * Write out the cache from-hosts signals to the UniFi.
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ *
+ * Returns:
+ * CSR error code if an SDIO error occurred.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult flush_fh_buffer(card_t *card)
+{
+ CsrResult r;
+ CsrUint16 len;
+ CsrUint16 sig_units;
+ CsrUint16 data_round;
+ CsrUint16 chunks_in_last_block;
+ CsrUint16 padding_chunks;
+ CsrUint16 i;
+
+ len = card->fh_buffer.ptr - card->fh_buffer.buf;
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "fh_buffer is at %p, ptr= %p\n",
+ card->fh_buffer.buf, card->fh_buffer.ptr);
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ if (len == 0)
+ {
+ return CSR_RESULT_SUCCESS;
+ }
+
+#ifdef CSR_WIFI_HIP_NOISY
+ if (dump_fh_buf)
+ {
+ dump(card->fh_buffer.buf, len);
+ dump_fh_buf = 0;
+ }
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ if (card->sdio_io_block_pad)
+ {
+ /* Both of these are powers of 2 */
+ sig_units = card->config_data.sig_frag_size;
+ data_round = card->sdio_io_block_size;
+
+ if (data_round > sig_units)
+ {
+ chunks_in_last_block = (len % data_round) / sig_units;
+
+ if (chunks_in_last_block != 0)
+ {
+ padding_chunks = (data_round / sig_units) - chunks_in_last_block;
+
+ CsrMemSet(card->fh_buffer.ptr, 0, padding_chunks * sig_units);
+ for (i = 0; i < padding_chunks; i++)
+ {
+ card->fh_buffer.ptr[1] = SDIO_CMD_PADDING << 4;
+ card->fh_buffer.ptr += sig_units;
+ }
+
+ card->fh_buffer.count += padding_chunks;
+ len += padding_chunks * sig_units;
+ }
+ }
+ }
+
+ r = unifi_bulk_rw(card,
+ card->config_data.fromhost_sigbuf_handle,
+ card->fh_buffer.buf,
+ len, UNIFI_SDIO_WRITE);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write fh signals: %u bytes, error %d\n", len, r);
+ return r;
+ }
+
+ /* Update from-host-signals-written signal count */
+ card->from_host_signals_w =
+ (card->from_host_signals_w + card->fh_buffer.count) % 128u;
+ r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 0,
+ (CsrUint8)card->from_host_signals_w);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write fh signal count %u with error %d\n",
+ card->from_host_signals_w, r);
+ return r;
+ }
+ card->generate_interrupt = 1;
+
+ /* Reset the fh buffer pointer */
+ card->fh_buffer.ptr = card->fh_buffer.buf;
+ card->fh_buffer.count = 0;
+
+#ifdef CSR_WIFI_HIP_NOISY
+ unifi_error(card->ospriv, "END flush: fh len %d, count %d\n",
+ card->fh_buffer.ptr - card->fh_buffer.buf,
+ card->fh_buffer.count);
+#endif /* CSR_WIFI_HIP_NOISY */
+
+ return CSR_RESULT_SUCCESS;
+} /* flush_fh_buffer() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * restart_packet_flow
+ *
+ * This function is called before the bottom-half thread sleeps.
+ * It checks whether both data and signal resources are available and
+ * then calls the OS-layer function to re-enable packet transmission.
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void restart_packet_flow(card_t *card)
+{
+ CsrUint8 q;
+
+ /*
+ * We only look at the fh_traffic_queue, because that is where packets from
+ * the network stack are placed.
+ */
+ for (q = 0; q <= UNIFI_TRAFFIC_Q_VO; q++)
+ {
+ if (card_is_tx_q_paused(card, q) &&
+ CSR_WIFI_HIP_Q_SLOTS_FREE(&card->fh_traffic_queue[q]) >= RESUME_XMIT_THRESHOLD)
+ {
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ unifi_debug_log_to_buf("U");
+#endif
+ card_tx_q_unpause(card, q);
+ unifi_restart_xmit(card->ospriv, (unifi_TrafficQueue)q);
+ }
+ }
+} /* restart_packet_flow() */
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_card_sdio_mem.c
+ *
+ * PURPOSE: Implementation of the Card API for SDIO.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_card.h"
+
+#define SDIO_RETRIES 3
+#define CSR_WIFI_HIP_SDIO_TRACE_DATA_LENGTH 16
+
+
+#define retryable_sdio_error(_csrResult) (((_csrResult) == CSR_SDIO_RESULT_CRC_ERROR) || ((_csrResult) == CSR_SDIO_RESULT_TIMEOUT))
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * retrying_read8
+ * retrying_write8
+ *
+ * These functions provide the first level of retry for SDIO operations.
+ * If an SDIO command fails for reason of a response timeout or CRC
+ * error, it is retried immediately. If three attempts fail we report a
+ * failure.
+ * If the command failed for any other reason, the failure is reported
+ * immediately.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * funcnum The SDIO function to access.
+ * Function 0 is the Card Configuration Register space,
+ * function 1/2 is the UniFi register space.
+ * addr Address to access
+ * pdata Pointer in which to return the value read.
+ * data Value to write.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult retrying_read8(card_t *card, CsrInt16 funcnum, CsrUint32 addr, CsrUint8 *pdata)
+{
+ CsrSdioFunction *sdio = card->sdio_if;
+ CsrResult r = CSR_RESULT_SUCCESS;
+ CsrInt16 retries;
+ CsrResult csrResult = CSR_RESULT_SUCCESS;
+
+ retries = 0;
+ while (retries++ < SDIO_RETRIES)
+ {
+ if (funcnum == 0)
+ {
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_log_to_buf("r0@%02X", addr);
+#endif
+ csrResult = CsrSdioF0Read8(sdio, addr, pdata);
+ }
+ else
+ {
+#ifdef CSR_WIFI_TRANSPORT_CSPI
+ unifi_error(card->ospriv,
+ "retrying_read_f0_8: F1 8-bit reads are not allowed.\n");
+ return CSR_RESULT_FAILURE;
+#else
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_log_to_buf("r@%02X", addr);
+#endif
+ csrResult = CsrSdioRead8(sdio, addr, pdata);
+#endif
+ }
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_debug_log_to_buf("error=%X\n", csrResult);
+ }
+ else
+ {
+ unifi_debug_log_to_buf("=%X\n", *pdata);
+ }
+#endif
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+ /*
+ * Try again for retryable (CRC or TIMEOUT) errors,
+ * break on success or fatal error
+ */
+ if (!retryable_sdio_error(csrResult))
+ {
+#ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
+ card->cmd_prof.cmd52_count++;
+#endif
+ break;
+ }
+ unifi_trace(card->ospriv, UDBG2, "retryable SDIO error reading F%d 0x%lX\n", funcnum, addr);
+ }
+
+ if ((csrResult == CSR_RESULT_SUCCESS) && (retries > 1))
+ {
+ unifi_warning(card->ospriv, "Read succeeded after %d attempts\n", retries);
+ }
+
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read from UniFi (addr 0x%lX) after %d tries\n",
+ addr, retries - 1);
+ /* Report any SDIO error as a general i/o error */
+ r = CSR_RESULT_FAILURE;
+ }
+
+ return r;
+} /* retrying_read8() */
+
+
+static CsrResult retrying_write8(card_t *card, CsrInt16 funcnum, CsrUint32 addr, CsrUint8 data)
+{
+ CsrSdioFunction *sdio = card->sdio_if;
+ CsrResult r = CSR_RESULT_SUCCESS;
+ CsrInt16 retries;
+ CsrResult csrResult = CSR_RESULT_SUCCESS;
+
+ retries = 0;
+ while (retries++ < SDIO_RETRIES)
+ {
+ if (funcnum == 0)
+ {
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_log_to_buf("w0@%02X=%X", addr, data);
+#endif
+ csrResult = CsrSdioF0Write8(sdio, addr, data);
+ }
+ else
+ {
+#ifdef CSR_WIFI_TRANSPORT_CSPI
+ unifi_error(card->ospriv,
+ "retrying_write_f0_8: F1 8-bit writes are not allowed.\n");
+ return CSR_RESULT_FAILURE;
+#else
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_log_to_buf("w@%02X=%X", addr, data);
+#endif
+ csrResult = CsrSdioWrite8(sdio, addr, data);
+#endif
+ }
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_debug_log_to_buf(",error=%X", csrResult);
+ }
+ unifi_debug_string_to_buf("\n");
+#endif
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+ /*
+ * Try again for retryable (CRC or TIMEOUT) errors,
+ * break on success or fatal error
+ */
+ if (!retryable_sdio_error(csrResult))
+ {
+#ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
+ card->cmd_prof.cmd52_count++;
+#endif
+ break;
+ }
+ unifi_trace(card->ospriv, UDBG2, "retryable SDIO error writing %02X to F%d 0x%lX\n",
+ data, funcnum, addr);
+ }
+
+ if ((csrResult == CSR_RESULT_SUCCESS) && (retries > 1))
+ {
+ unifi_warning(card->ospriv, "Write succeeded after %d attempts\n", retries);
+ }
+
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write to UniFi (addr 0x%lX) after %d tries\n",
+ addr, retries - 1);
+ /* Report any SDIO error as a general i/o error */
+ r = CSR_RESULT_FAILURE;
+ }
+
+ return r;
+} /* retrying_write8() */
+
+
+static CsrResult retrying_read16(card_t *card, CsrInt16 funcnum,
+ CsrUint32 addr, CsrUint16 *pdata)
+{
+ CsrSdioFunction *sdio = card->sdio_if;
+ CsrResult r = CSR_RESULT_SUCCESS;
+ CsrInt16 retries;
+ CsrResult csrResult = CSR_RESULT_SUCCESS;
+
+ retries = 0;
+ while (retries++ < SDIO_RETRIES)
+ {
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_log_to_buf("r@%02X", addr);
+#endif
+ csrResult = CsrSdioRead16(sdio, addr, pdata);
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_debug_log_to_buf("error=%X\n", csrResult);
+ }
+ else
+ {
+ unifi_debug_log_to_buf("=%X\n", *pdata);
+ }
+#endif
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+
+ /*
+ * Try again for retryable (CRC or TIMEOUT) errors,
+ * break on success or fatal error
+ */
+ if (!retryable_sdio_error(csrResult))
+ {
+#ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
+ card->cmd_prof.cmd52_count++;
+#endif
+ break;
+ }
+ unifi_trace(card->ospriv, UDBG2, "retryable SDIO error reading F%d 0x%lX\n", funcnum, addr);
+ }
+
+ if ((csrResult == CSR_RESULT_SUCCESS) && (retries > 1))
+ {
+ unifi_warning(card->ospriv, "Read succeeded after %d attempts\n", retries);
+ }
+
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read from UniFi (addr 0x%lX) after %d tries\n",
+ addr, retries - 1);
+ /* Report any SDIO error as a general i/o error */
+ r = CSR_RESULT_FAILURE;
+ }
+
+ return r;
+} /* retrying_read16() */
+
+
+static CsrResult retrying_write16(card_t *card, CsrInt16 funcnum,
+ CsrUint32 addr, CsrUint16 data)
+{
+ CsrSdioFunction *sdio = card->sdio_if;
+ CsrResult r = CSR_RESULT_SUCCESS;
+ CsrInt16 retries;
+ CsrResult csrResult = CSR_RESULT_SUCCESS;
+
+ retries = 0;
+ while (retries++ < SDIO_RETRIES)
+ {
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_log_to_buf("w@%02X=%X", addr, data);
+#endif
+ csrResult = CsrSdioWrite16(sdio, addr, data);
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_debug_log_to_buf(",error=%X", csrResult);
+ }
+ unifi_debug_string_to_buf("\n");
+#endif
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+
+ /*
+ * Try again for retryable (CRC or TIMEOUT) errors,
+ * break on success or fatal error
+ */
+ if (!retryable_sdio_error(csrResult))
+ {
+#ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
+ card->cmd_prof.cmd52_count++;
+#endif
+ break;
+ }
+ unifi_trace(card->ospriv, UDBG2, "retryable SDIO error writing %02X to F%d 0x%lX\n",
+ data, funcnum, addr);
+ }
+
+ if ((csrResult == CSR_RESULT_SUCCESS) && (retries > 1))
+ {
+ unifi_warning(card->ospriv, "Write succeeded after %d attempts\n", retries);
+ }
+
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write to UniFi (addr 0x%lX) after %d tries\n",
+ addr, retries - 1);
+ /* Report any SDIO error as a general i/o error */
+ r = CSR_RESULT_FAILURE;
+ }
+
+ return r;
+} /* retrying_write16() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * sdio_read_f0
+ *
+ * Reads a byte value from the CCCR (func 0) area of UniFi.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * addr Address to read from
+ * pdata Pointer in which to store the read value.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * ---------------------------------------------------------------------------
+ */
+CsrResult sdio_read_f0(card_t *card, CsrUint32 addr, CsrUint8 *pdata)
+{
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ card->cmd_prof.cmd52_f0_r_count++;
+#endif
+ return retrying_read8(card, 0, addr, pdata);
+} /* sdio_read_f0() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * sdio_write_f0
+ *
+ * Writes a byte value to the CCCR (func 0) area of UniFi.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * addr Address to read from
+ * data Data value to write.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * ---------------------------------------------------------------------------
+ */
+CsrResult sdio_write_f0(card_t *card, CsrUint32 addr, CsrUint8 data)
+{
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ card->cmd_prof.cmd52_f0_w_count++;
+#endif
+ return retrying_write8(card, 0, addr, data);
+} /* sdio_write_f0() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_read_direct_8_or_16
+ *
+ * Read a 8-bit value from the UniFi SDIO interface.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * addr Address to read from
+ * pdata Pointer in which to return data.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_read_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 *pdata)
+{
+#ifdef CSR_WIFI_TRANSPORT_CSPI
+ CsrUint16 w;
+ CsrResult r;
+
+ r = retrying_read16(card, card->function, addr, &w);
+ *pdata = (CsrUint8)(w & 0xFF);
+ return r;
+#else
+ return retrying_read8(card, card->function, addr, pdata);
+#endif
+} /* unifi_read_direct_8_or_16() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_write_direct_8_or_16
+ *
+ * Write a byte value to the UniFi SDIO interface.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * addr Address to write to
+ * data Value to write.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error
+ *
+ * Notes:
+ * If 8-bit write is used, the even address *must* be written second.
+ * This is because writes to odd bytes are cached and not committed
+ * to memory until the preceding even address is written.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_write_direct_8_or_16(card_t *card, CsrUint32 addr, CsrUint8 data)
+{
+ if (addr & 1)
+ {
+ unifi_warning(card->ospriv,
+ "Warning: Byte write to an odd address (0x%lX) is dangerous\n",
+ addr);
+ }
+
+#ifdef CSR_WIFI_TRANSPORT_CSPI
+ return retrying_write16(card, card->function, addr, (CsrUint16)data);
+#else
+ return retrying_write8(card, card->function, addr, data);
+#endif
+} /* unifi_write_direct_8_or_16() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_read_direct16
+ *
+ * Read a 16-bit value from the UniFi SDIO interface.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * addr Address to read from
+ * pdata Pointer in which to return data.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ *
+ * Notes:
+ * The even address *must* be read first. This is because reads from
+ * odd bytes are cached and read from memory when the preceding
+ * even address is read.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_read_direct16(card_t *card, CsrUint32 addr, CsrUint16 *pdata)
+{
+ return retrying_read16(card, card->function, addr, pdata);
+} /* unifi_read_direct16() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_write_direct16
+ *
+ * Write a 16-bit value to the UniFi SDIO interface.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * addr Address to write to
+ * data Value to write.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ *
+ * Notes:
+ * The even address *must* be written second. This is because writes to
+ * odd bytes are cached and not committed to memory until the preceding
+ * even address is written.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_write_direct16(card_t *card, CsrUint32 addr, CsrUint16 data)
+{
+ return retrying_write16(card, card->function, addr, data);
+} /* unifi_write_direct16() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_read_direct32
+ *
+ * Read a 32-bit value from the UniFi SDIO interface.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * addr Address to read from
+ * pdata Pointer in which to return data.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_read_direct32(card_t *card, CsrUint32 addr, CsrUint32 *pdata)
+{
+ CsrResult r;
+ CsrUint16 w0, w1;
+
+ r = retrying_read16(card, card->function, addr, &w0);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ r = retrying_read16(card, card->function, addr + 2, &w1);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ *pdata = ((CsrUint32)w1 << 16) | (CsrUint32)w0;
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_read_direct32() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_read_directn_match
+ *
+ * Read multiple 8-bit values from the UniFi SDIO interface,
+ * stopping when either we have read 'len' bytes or we have read
+ * a octet equal to 'match'. If 'match' is not a valid octet
+ * then this function is the same as 'unifi_read_directn'.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * addr Start address to read from.
+ * pdata Pointer to which to write data.
+ * len Maximum umber of bytes to read
+ * match The value to stop reading at.
+ * num Pointer to buffer to write number of bytes read
+ *
+ * Returns:
+ * number of octets read on success, negative error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ *
+ * Notes:
+ * The even address *must* be read first. This is because reads from
+ * odd bytes are cached and read from memory when the preceding
+ * even address is read.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult unifi_read_directn_match(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len, CsrInt8 m, CsrUint32 *num)
+{
+ CsrResult r;
+ CsrUint32 i;
+ CsrUint8 *cptr;
+ CsrUint16 w;
+
+ *num = 0;
+
+ cptr = (CsrUint8 *)pdata;
+ for (i = 0; i < len; i += 2)
+ {
+ r = retrying_read16(card, card->function, addr, &w);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ *cptr++ = ((CsrUint8)w & 0xFF);
+ if ((m >= 0) && (((CsrInt8)w & 0xFF) == m))
+ {
+ break;
+ }
+
+ if (i + 1 == len)
+ {
+ /* The len is odd. Ignore the last high byte */
+ break;
+ }
+
+ *cptr++ = ((CsrUint8)(w >> 8) & 0xFF);
+ if ((m >= 0) && (((CsrInt8)(w >> 8) & 0xFF) == m))
+ {
+ break;
+ }
+
+ addr += 2;
+ }
+
+ *num = (CsrInt32)(cptr - (CsrUint8 *)pdata);
+ return CSR_RESULT_SUCCESS;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_read_directn
+ *
+ * Read multiple 8-bit values from the UniFi SDIO interface.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * addr Start address to read from.
+ * pdata Pointer to which to write data.
+ * len Number of bytes to read
+ *
+ * Returns:
+ * 0 on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ *
+ * Notes:
+ * The even address *must* be read first. This is because reads from
+ * odd bytes are cached and read from memory when the preceding
+ * even address is read.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_read_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len)
+{
+ CsrUint32 num;
+
+ return unifi_read_directn_match(card, addr, pdata, len, -1, &num);
+} /* unifi_read_directn() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_write_directn
+ *
+ * Write multiple 8-bit values to the UniFi SDIO interface.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * addr Start address to write to.
+ * pdata Source data pointer.
+ * len Number of bytes to write, must be even.
+ *
+ * Returns:
+ * 0 on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ *
+ * Notes:
+ * The UniFi has a peculiar 16-bit bus architecture. Writes are only
+ * committed to memory when an even address is accessed. Writes to
+ * odd addresses are cached and only committed if the next write is
+ * to the preceding address.
+ * This means we must write data as pairs of bytes in reverse order.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_write_directn(card_t *card, CsrUint32 addr, void *pdata, CsrUint16 len)
+{
+ CsrResult r;
+ CsrUint8 *cptr;
+ CsrInt16 signed_len;
+
+ cptr = (CsrUint8 *)pdata;
+ signed_len = (CsrInt16)len;
+ while (signed_len > 0)
+ {
+ /* This is UniFi-1 specific code. CSPI not supported so 8-bit write allowed */
+ r = retrying_write16(card, card->function, addr, *cptr);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ cptr += 2;
+ addr += 2;
+ signed_len -= 2;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_write_directn() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * set_dmem_page
+ * set_pmem_page
+ *
+ * Set up the page register for the shared data memory window or program
+ * memory window.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * dmem_addr UniFi shared-data-memory address to access.
+ * pmem_addr UniFi program memory address to access. This includes
+ * External FLASH memory at 0x000000
+ * Processor program memory at 0x200000
+ * External SRAM at memory 0x400000
+ * paddr Location to write an SDIO address (24-bit) for
+ * use in a unifi_read_direct or unifi_write_direct call.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult set_dmem_page(card_t *card, CsrUint32 dmem_addr, CsrUint32 *paddr)
+{
+ CsrUint16 page, addr;
+ CsrUint32 len;
+ CsrResult r;
+
+ *paddr = 0;
+
+ if (!ChipHelper_DecodeWindow(card->helper,
+ CHIP_HELPER_WINDOW_3,
+ CHIP_HELPER_WT_SHARED,
+ dmem_addr / 2,
+ &page, &addr, &len))
+ {
+ unifi_error(card->ospriv, "Failed to decode SHARED_DMEM_PAGE %08lx\n", dmem_addr);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ if (page != card->dmem_page)
+ {
+ unifi_trace(card->ospriv, UDBG6, "setting dmem page=0x%X, addr=0x%lX\n", page, addr);
+
+ /* change page register */
+ r = unifi_write_direct16(card, ChipHelper_HOST_WINDOW3_PAGE(card->helper) * 2, page);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write SHARED_DMEM_PAGE\n");
+ return r;
+ }
+
+ card->dmem_page = page;
+ }
+
+ *paddr = ((CsrInt32)addr * 2) + (dmem_addr & 1);
+
+ return CSR_RESULT_SUCCESS;
+} /* set_dmem_page() */
+
+
+static CsrResult set_pmem_page(card_t *card, CsrUint32 pmem_addr,
+ enum chip_helper_window_type mem_type, CsrUint32 *paddr)
+{
+ CsrUint16 page, addr;
+ CsrUint32 len;
+ CsrResult r;
+
+ *paddr = 0;
+
+ if (!ChipHelper_DecodeWindow(card->helper,
+ CHIP_HELPER_WINDOW_2,
+ mem_type,
+ pmem_addr / 2,
+ &page, &addr, &len))
+ {
+ unifi_error(card->ospriv, "Failed to decode PROG MEM PAGE %08lx %d\n", pmem_addr, mem_type);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ if (page != card->pmem_page)
+ {
+ unifi_trace(card->ospriv, UDBG6, "setting pmem page=0x%X, addr=0x%lX\n", page, addr);
+
+ /* change page register */
+ r = unifi_write_direct16(card, ChipHelper_HOST_WINDOW2_PAGE(card->helper) * 2, page);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write PROG MEM PAGE\n");
+ return r;
+ }
+
+ card->pmem_page = page;
+ }
+
+ *paddr = ((CsrInt32)addr * 2) + (pmem_addr & 1);
+
+ return CSR_RESULT_SUCCESS;
+} /* set_pmem_page() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * set_page
+ *
+ * Sets up the appropriate page register to access the given address.
+ * Returns the sdio address at which the unifi address can be accessed.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * generic_addr UniFi internal address to access, in Generic Pointer
+ * format, i.e. top byte is space indicator.
+ * paddr Location to write page address
+ * SDIO address (24-bit) for use in a unifi_read_direct or
+ * unifi_write_direct call
+ *
+ * Returns:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE the address is invalid
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult set_page(card_t *card, CsrUint32 generic_addr, CsrUint32 *paddr)
+{
+ CsrInt32 space;
+ CsrUint32 addr;
+ CsrResult r = CSR_RESULT_SUCCESS;
+
+ if (!paddr)
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ *paddr = 0;
+ space = UNIFI_GP_SPACE(generic_addr);
+ addr = UNIFI_GP_OFFSET(generic_addr);
+ switch (space)
+ {
+ case UNIFI_SH_DMEM:
+ /* Shared Data Memory is accessed via the Shared Data Memory window */
+ r = set_dmem_page(card, addr, paddr);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ break;
+
+ case UNIFI_EXT_FLASH:
+ if (!ChipHelper_HasFlash(card->helper))
+ {
+ unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
+ generic_addr, card->helper);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ /* External FLASH is accessed via the Program Memory window */
+ r = set_pmem_page(card, addr, CHIP_HELPER_WT_FLASH, paddr);
+ break;
+
+ case UNIFI_EXT_SRAM:
+ if (!ChipHelper_HasExtSram(card->helper))
+ {
+ unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08l (helper=0x%x)\n",
+ generic_addr, card->helper);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ /* External SRAM is accessed via the Program Memory window */
+ r = set_pmem_page(card, addr, CHIP_HELPER_WT_EXT_SRAM, paddr);
+ break;
+
+ case UNIFI_REGISTERS:
+ /* Registers are accessed directly */
+ *paddr = addr;
+ break;
+
+ case UNIFI_PHY_DMEM:
+ r = unifi_set_proc_select(card, UNIFI_PROC_PHY);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ *paddr = ChipHelper_DATA_MEMORY_RAM_OFFSET(card->helper) * 2 + addr;
+ break;
+
+ case UNIFI_MAC_DMEM:
+ r = unifi_set_proc_select(card, UNIFI_PROC_MAC);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ *paddr = ChipHelper_DATA_MEMORY_RAM_OFFSET(card->helper) * 2 + addr;
+ break;
+
+ case UNIFI_BT_DMEM:
+ if (!ChipHelper_HasBt(card->helper))
+ {
+ unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
+ generic_addr, card->helper);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ r = unifi_set_proc_select(card, UNIFI_PROC_BT);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ *paddr = ChipHelper_DATA_MEMORY_RAM_OFFSET(card->helper) * 2 + addr;
+ break;
+
+ case UNIFI_PHY_PMEM:
+ r = unifi_set_proc_select(card, UNIFI_PROC_PHY);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ r = set_pmem_page(card, addr, CHIP_HELPER_WT_CODE_RAM, paddr);
+ break;
+
+ case UNIFI_MAC_PMEM:
+ r = unifi_set_proc_select(card, UNIFI_PROC_MAC);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ r = set_pmem_page(card, addr, CHIP_HELPER_WT_CODE_RAM, paddr);
+ break;
+
+ case UNIFI_BT_PMEM:
+ if (!ChipHelper_HasBt(card->helper))
+ {
+ unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
+ generic_addr, card->helper);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ r = unifi_set_proc_select(card, UNIFI_PROC_BT);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ r = set_pmem_page(card, addr, CHIP_HELPER_WT_CODE_RAM, paddr);
+ break;
+
+ case UNIFI_PHY_ROM:
+ if (!ChipHelper_HasRom(card->helper))
+ {
+ unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
+ generic_addr, card->helper);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ r = unifi_set_proc_select(card, UNIFI_PROC_PHY);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ r = set_pmem_page(card, addr, CHIP_HELPER_WT_ROM, paddr);
+ break;
+
+ case UNIFI_MAC_ROM:
+ if (!ChipHelper_HasRom(card->helper))
+ {
+ unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
+ generic_addr, card->helper);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ r = unifi_set_proc_select(card, UNIFI_PROC_MAC);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ r = set_pmem_page(card, addr, CHIP_HELPER_WT_ROM, paddr);
+ break;
+
+ case UNIFI_BT_ROM:
+ if (!ChipHelper_HasRom(card->helper) || !ChipHelper_HasBt(card->helper))
+ {
+ unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
+ generic_addr, card->helper);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ r = unifi_set_proc_select(card, UNIFI_PROC_BT);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+ r = set_pmem_page(card, addr, CHIP_HELPER_WT_ROM, paddr);
+ break;
+
+ default:
+ unifi_error(card->ospriv, "Bad address space %d in generic pointer 0x%08lX (helper=0x%x)\n",
+ space, generic_addr, card->helper);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ return r;
+} /* set_page() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_set_proc_select
+ *
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * select Which XAP core to select
+ *
+ * Returns:
+ * 0 on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_set_proc_select(card_t *card, enum unifi_dbg_processors_select select)
+{
+ CsrResult r;
+
+ /* Verify the the select value is allowed. */
+ switch (select)
+ {
+ case UNIFI_PROC_MAC:
+ case UNIFI_PROC_PHY:
+ case UNIFI_PROC_BOTH:
+ break;
+
+
+ default:
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ if (card->proc_select != (CsrUint32)select)
+ {
+ r = unifi_write_direct16(card,
+ ChipHelper_DBG_HOST_PROC_SELECT(card->helper) * 2,
+ (CsrUint8)select);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write to Proc Select register\n");
+ return r;
+ }
+
+ card->proc_select = (CsrUint32)select;
+ }
+
+ return CSR_RESULT_SUCCESS;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_read_8_or_16
+ *
+ * Performs a byte read of the given address in shared data memory.
+ * Set up the shared data memory page register as required.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * unifi_addr UniFi shared-data-memory address to access.
+ * pdata Pointer to a byte variable for the value read.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_read_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 *pdata)
+{
+ CsrUint32 sdio_addr;
+ CsrResult r;
+#ifdef CSR_WIFI_TRANSPORT_CSPI
+ CsrUint16 w;
+#endif
+
+ r = set_page(card, unifi_addr, &sdio_addr);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ card->cmd_prof.cmd52_r8or16_count++;
+#endif
+#ifdef CSR_WIFI_TRANSPORT_CSPI
+ r = retrying_read16(card, card->function, sdio_addr, &w);
+ *pdata = (CsrUint8)(w & 0xFF);
+ return r;
+#else
+ return retrying_read8(card, card->function, sdio_addr, pdata);
+#endif
+} /* unifi_read_8_or_16() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_write_8_or_16
+ *
+ * Performs a byte write of the given address in shared data memory.
+ * Set up the shared data memory page register as required.
+ *
+ * Arguments:
+ * card Pointer to card context struct.
+ * unifi_addr UniFi shared-data-memory address to access.
+ * data Value to write.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
+ *
+ * Notes:
+ * Beware using unifi_write8() because byte writes are not safe on UniFi.
+ * Writes to odd bytes are cached, writes to even bytes perform a 16-bit
+ * write with the previously cached odd byte.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_write_8_or_16(card_t *card, CsrUint32 unifi_addr, CsrUint8 data)
+{
+ CsrUint32 sdio_addr;
+ CsrResult r;
+#ifdef CSR_WIFI_TRANSPORT_CSPI
+ CsrUint16 w;
+#endif
+
+ r = set_page(card, unifi_addr, &sdio_addr);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ if (sdio_addr & 1)
+ {
+ unifi_warning(card->ospriv,
+ "Warning: Byte write to an odd address (0x%lX) is dangerous\n",
+ sdio_addr);
+ }
+
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ card->cmd_prof.cmd52_w8or16_count++;
+#endif
+#ifdef CSR_WIFI_TRANSPORT_CSPI
+ w = data;
+ return retrying_write16(card, card->function, sdio_addr, w);
+#else
+ return retrying_write8(card, card->function, sdio_addr, data);
+#endif
+} /* unifi_write_8_or_16() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_card_read16
+ *
+ * Performs a 16-bit read of the given address in shared data memory.
+ * Set up the shared data memory page register as required.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * unifi_addr UniFi shared-data-memory address to access.
+ * pdata Pointer to a 16-bit int variable for the value read.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, CsrUint16 *pdata)
+{
+ CsrUint32 sdio_addr;
+ CsrResult r;
+
+ r = set_page(card, unifi_addr, &sdio_addr);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ card->cmd_prof.cmd52_r16_count++;
+#endif
+ return unifi_read_direct16(card, sdio_addr, pdata);
+} /* unifi_card_read16() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_card_write16
+ *
+ * Performs a 16-bit write of the given address in shared data memory.
+ * Set up the shared data memory page register as required.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * unifi_addr UniFi shared-data-memory address to access.
+ * pdata Pointer to a byte variable for the value write.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, CsrUint16 data)
+{
+ CsrUint32 sdio_addr;
+ CsrResult r;
+
+ r = set_page(card, unifi_addr, &sdio_addr);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ card->cmd_prof.cmd52_w16_count++;
+#endif
+ return unifi_write_direct16(card, sdio_addr, data);
+} /* unifi_card_write16() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_read32
+ *
+ * Performs a 32-bit read of the given address in shared data memory.
+ * Set up the shared data memory page register as required.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * unifi_addr UniFi shared-data-memory address to access.
+ * pdata Pointer to a int variable for the value read.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_read32(card_t *card, CsrUint32 unifi_addr, CsrUint32 *pdata)
+{
+ CsrUint32 sdio_addr;
+ CsrResult r;
+
+ r = set_page(card, unifi_addr, &sdio_addr);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ card->cmd_prof.cmd52_r32_count++;
+#endif
+ return unifi_read_direct32(card, sdio_addr, pdata);
+} /* unifi_read32() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_card_readn
+ * unifi_readnz
+ *
+ * Read multiple 8-bit values from the UniFi SDIO interface.
+ * This function interprets the address as a GenericPointer as
+ * defined in the UniFi Host Interface Protocol Specification.
+ * The readnz version of this function will stop when it reads a
+ * zero octet.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * unifi_addr UniFi shared-data-memory address to access.
+ * pdata Pointer to which to write data.
+ * len Number of bytes to read
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_readn_match(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len, CsrInt8 match)
+{
+ CsrUint32 sdio_addr;
+ CsrResult r;
+ CsrUint32 num;
+
+ r = set_page(card, unifi_addr, &sdio_addr);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ r = unifi_read_directn_match(card, sdio_addr, pdata, len, match, &num);
+ return r;
+} /* unifi_readn_match() */
+
+
+CsrResult unifi_card_readn(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len)
+{
+ return unifi_readn_match(card, unifi_addr, pdata, len, -1);
+} /* unifi_card_readn() */
+
+
+CsrResult unifi_readnz(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len)
+{
+ return unifi_readn_match(card, unifi_addr, pdata, len, 0);
+} /* unifi_readnz() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_read_shared_count
+ *
+ * Read signal count locations, checking for an SDIO error. The
+ * signal count locations only contain a valid number if the
+ * highest bit isn't set.
+ *
+ * Arguments:
+ * card Pointer to card context structure.
+ * addr Shared-memory address to read.
+ *
+ * Returns:
+ * Value read from memory (0-127) or -1 on error
+ * ---------------------------------------------------------------------------
+ */
+CsrInt32 unifi_read_shared_count(card_t *card, CsrUint32 addr)
+{
+ CsrUint8 b;
+ /* I've increased this count, because I have seen cases where
+ * there were three reads in a row with the top bit set. I'm not
+ * sure why this might have happened, but I can't see a problem
+ * with increasing this limit. It's better to take a while to
+ * recover than to fail. */
+#define SHARED_READ_RETRY_LIMIT 10
+ CsrInt32 i;
+
+ /*
+ * Get the to-host-signals-written count.
+ * The top-bit will be set if the firmware was in the process of
+ * changing the value, in which case we read again.
+ */
+ /* Limit the number of repeats so we don't freeze */
+ for (i = 0; i < SHARED_READ_RETRY_LIMIT; i++)
+ {
+ CsrResult r;
+ r = unifi_read_8_or_16(card, addr, &b);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return -1;
+ }
+ if (!(b & 0x80))
+ {
+ /* There is a chance that the MSB may have contained invalid data
+ * (overflow) at the time it was read. Therefore mask off the MSB.
+ * This avoids a race between driver read and firmware write of the
+ * word, the value we need is in the lower 8 bits anway.
+ */
+ return (CsrInt32)(b & 0xff);
+ }
+ }
+
+ return -1; /* this function has changed in WMM mods */
+} /* unifi_read_shared_count() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_writen
+ *
+ * Write multiple 8-bit values to the UniFi SDIO interface using CMD52
+ * This function interprets the address as a GenericPointer as
+ * defined in the UniFi Host Interface Protocol Specification.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * unifi_addr UniFi shared-data-memory address to access.
+ * pdata Pointer to which to write data.
+ * len Number of bytes to write
+ *
+ * Returns:
+ * 0 on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE an odd length or length too big.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_writen(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len)
+{
+ CsrUint32 sdio_addr;
+ CsrResult r;
+
+ r = set_page(card, unifi_addr, &sdio_addr);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ return unifi_write_directn(card, sdio_addr, pdata, len);
+} /* unifi_writen() */
+
+
+static CsrResult csr_sdio_block_rw(card_t *card, CsrInt16 funcnum,
+ CsrUint32 addr, CsrUint8 *pdata,
+ CsrUint16 count, CsrInt16 dir_is_write)
+{
+ CsrResult csrResult;
+
+ if (dir_is_write == UNIFI_SDIO_READ)
+ {
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_log_to_buf("r@%02X#%X=", addr, count);
+#endif
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ unifi_debug_log_to_buf("R");
+#endif
+ csrResult = CsrSdioRead(card->sdio_if, addr, pdata, count);
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ unifi_debug_log_to_buf("<");
+#endif
+ }
+ else
+ {
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ unifi_debug_log_to_buf("w@%02X#%X=", addr, count);
+ unifi_debug_hex_to_buf(pdata, count > CSR_WIFI_HIP_SDIO_TRACE_DATA_LENGTH?CSR_WIFI_HIP_SDIO_TRACE_DATA_LENGTH : count);
+#endif
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ unifi_debug_log_to_buf("W");
+#endif
+ csrResult = CsrSdioWrite(card->sdio_if, addr, pdata, count);
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ unifi_debug_log_to_buf(">");
+#endif
+ }
+#ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
+ card->cmd_prof.cmd53_count++;
+#endif
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_debug_log_to_buf("error=%X", csrResult);
+ }
+ else if (dir_is_write == UNIFI_SDIO_READ)
+ {
+ unifi_debug_hex_to_buf(pdata, count > CSR_WIFI_HIP_SDIO_TRACE_DATA_LENGTH?CSR_WIFI_HIP_SDIO_TRACE_DATA_LENGTH : count);
+ }
+ unifi_debug_string_to_buf("\n");
+#endif
+ return csrResult; /* CSR SDIO (not HIP) error code */
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_bulk_rw
+ *
+ * Transfer bulk data to or from the UniFi SDIO interface.
+ * This function is used to read or write signals and bulk data.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * handle Value to put in the Register Address field of the CMD53 req.
+ * data Pointer to data to write.
+ * direction One of UNIFI_SDIO_READ or UNIFI_SDIO_WRITE
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ *
+ * Notes:
+ * This function uses SDIO CMD53, which is the block transfer mode.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_bulk_rw(card_t *card, CsrUint32 handle, void *pdata,
+ CsrUint32 len, CsrInt16 direction)
+{
+#define CMD53_RETRIES 3
+ /*
+ * Ideally instead of sleeping, we want to busy wait.
+ * Currently there is no framework API to do this. When it becomes available,
+ * we can use it to busy wait using usecs
+ */
+#define REWIND_RETRIES 15 /* when REWIND_DELAY==1msec, or 250 when REWIND_DELAY==50usecs */
+#define REWIND_POLLING_RETRIES 5
+#define REWIND_DELAY 1 /* msec or 50usecs */
+ CsrResult csrResult; /* SDIO error code */
+ CsrResult r = CSR_RESULT_SUCCESS; /* HIP error code */
+ CsrInt16 retries = CMD53_RETRIES;
+ CsrInt16 stat_retries;
+ CsrUint8 stat;
+ CsrInt16 dump_read;
+#ifdef UNIFI_DEBUG
+ CsrUint8 *pdata_lsb = ((CsrUint8 *)&pdata) + card->lsb;
+#endif
+#ifdef CSR_WIFI_MAKE_FAKE_CMD53_ERRORS
+ static CsrInt16 fake_error;
+#endif
+
+ dump_read = 0;
+#ifdef UNIFI_DEBUG
+ if (*pdata_lsb & 1)
+ {
+ unifi_notice(card->ospriv, "CD53 request on a unaligned buffer (addr: 0x%X) dir %s-Host\n",
+ pdata, (direction == UNIFI_SDIO_READ)?"To" : "From");
+ if (direction == UNIFI_SDIO_WRITE)
+ {
+ dump(pdata, (CsrUint16)len);
+ }
+ else
+ {
+ dump_read = 1;
+ }
+ }
+#endif
+
+ /* Defensive checks */
+ if (!pdata)
+ {
+ unifi_error(card->ospriv, "Null pdata for unifi_bulk_rw() len: %d\n", len);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ if ((len & 1) || (len > 0xffff))
+ {
+ unifi_error(card->ospriv, "Impossible CMD53 length requested: %d\n", len);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ while (1)
+ {
+ csrResult = csr_sdio_block_rw(card, card->function, handle,
+ (CsrUint8 *)pdata, (CsrUint16)len,
+ direction);
+ if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_DEVICE;
+ }
+#ifdef CSR_WIFI_MAKE_FAKE_CMD53_ERRORS
+ if (++fake_error > 100)
+ {
+ fake_error = 90;
+ unifi_warning(card->ospriv, "Faking a CMD53 error,\n");
+ if (csrResult == CSR_RESULT_SUCCESS)
+ {
+ csrResult = CSR_RESULT_FAILURE;
+ }
+ }
+#endif
+ if (csrResult == CSR_RESULT_SUCCESS)
+ {
+ if (dump_read)
+ {
+ dump(pdata, (CsrUint16)len);
+ }
+ break;
+ }
+
+ /*
+ * At this point the SDIO driver should have written the I/O Abort
+ * register to notify UniFi that the command has failed.
+ * UniFi-1 and UniFi-2 (not UF6xxx) use the same register to store the
+ * Deep Sleep State. This means we have to restore the Deep Sleep
+ * State (AWAKE in any case since we can not perform a CD53 in any other
+ * state) by rewriting the I/O Abort register to its previous value.
+ */
+ if (card->chip_id <= SDIO_CARD_ID_UNIFI_2)
+ {
+ (void)unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE);
+ }
+
+ /* If csr_sdio_block_rw() failed in a non-retryable way, or retries exhausted
+ * then stop retrying
+ */
+ if (!retryable_sdio_error(csrResult))
+ {
+ unifi_error(card->ospriv, "Fatal error in a CMD53 transfer\n");
+ break;
+ }
+
+ /*
+ * These happen from time to time, try again
+ */
+ if (--retries == 0)
+ {
+ break;
+ }
+
+ unifi_trace(card->ospriv, UDBG4,
+ "Error in a CMD53 transfer, retrying (h:%d,l:%u)...\n",
+ (CsrInt16)handle & 0xff, len);
+
+ /* The transfer failed, rewind and try again */
+ r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 8,
+ (CsrUint8)(handle & 0xff));
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ /*
+ * If we can't even do CMD52 (register read/write) then
+ * stop here.
+ */
+ unifi_error(card->ospriv, "Failed to write REWIND cmd\n");
+ return r;
+ }
+
+ /* Signal the UniFi to look for the rewind request. */
+ r = CardGenInt(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ /* Wait for UniFi to acknowledge the rewind */
+ stat_retries = REWIND_RETRIES;
+ while (1)
+ {
+ r = unifi_read_8_or_16(card, card->sdio_ctrl_addr + 8, &stat);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read REWIND status\n");
+ return CSR_RESULT_FAILURE;
+ }
+
+ if (stat == 0)
+ {
+ break;
+ }
+ if (--stat_retries == 0)
+ {
+ unifi_error(card->ospriv, "Timeout waiting for REWIND ready\n");
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Poll for the ack a few times */
+ if (stat_retries < REWIND_RETRIES - REWIND_POLLING_RETRIES)
+ {
+ CsrThreadSleep(REWIND_DELAY);
+ }
+ }
+ }
+
+ /* The call to csr_sdio_block_rw() still failed after retrying */
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Block %s failed after %d retries\n",
+ (direction == UNIFI_SDIO_READ)?"read" : "write",
+ CMD53_RETRIES - retries);
+ /* Report any SDIO error as a general i/o error */
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Collect some stats */
+ if (direction == UNIFI_SDIO_READ)
+ {
+ card->sdio_bytes_read += len;
+ }
+ else
+ {
+ card->sdio_bytes_written += len;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_bulk_rw() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_bulk_rw_noretry
+ *
+ * Transfer bulk data to or from the UniFi SDIO interface.
+ * This function is used to read or write signals and bulk data.
+ *
+ * Arguments:
+ * card Pointer to card structure.
+ * handle Value to put in the Register Address field of
+ * the CMD53 req.
+ * data Pointer to data to write.
+ * direction One of UNIFI_SDIO_READ or UNIFI_SDIO_WRITE
+ *
+ * Returns:
+ * 0 on success, non-zero error code on error:
+ * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
+ * CSR_RESULT_FAILURE an SDIO error occurred
+ *
+ * Notes:
+ * This function uses SDIO CMD53, which is the block transfer mode.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_bulk_rw_noretry(card_t *card, CsrUint32 handle, void *pdata,
+ CsrUint32 len, CsrInt16 direction)
+{
+ CsrResult csrResult;
+
+ csrResult = csr_sdio_block_rw(card, card->function, handle,
+ (CsrUint8 *)pdata, (CsrUint16)len, direction);
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Block %s failed\n",
+ (direction == UNIFI_SDIO_READ)?"read" : "write");
+ return csrResult;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_bulk_rw_noretry() */
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+
+#include "csr_wifi_hip_chiphelper_private.h"
+
+#ifndef nelem
+#define nelem(a) (sizeof(a) / sizeof(a[0]))
+#endif
+
+#define counted(foo) { nelem(foo), foo }
+#define null_counted() { 0, NULL }
+
+/* The init values are a set of register writes that we must
+ perform when we first connect to the chip to get it working.
+ They swicth on the correct clocks and possibly set the host
+ interface as a wkaeup source. They should not be used if
+ proper HIP opperation is required, but are useful before we
+ do a code download. */
+static const struct chip_helper_init_values init_vals_v1[] = {
+ { 0xFDBB, 0xFFFF },
+ { 0xFDB6, 0x03FF },
+ { 0xFDB1, 0x01E3 },
+ { 0xFDB3, 0x0FFF },
+ { 0xFEE3, 0x08F0 },
+ { 0xFEE7, 0x3C3F },
+ { 0xFEE6, 0x0050 },
+ { 0xFDBA, 0x0000 }
+};
+
+static const struct chip_helper_init_values init_vals_v2[] = {
+ { 0xFDB6, 0x0FFF },
+ { 0xF023, 0x3F3F },
+ { 0xFDB1, 0x01E3 },
+ { 0xFDB3, 0x0FFF },
+ { 0xF003, 0x08F0 },
+ { 0xF007, 0x3C3F },
+ { 0xF006, 0x0050 }
+};
+
+
+static const struct chip_helper_init_values init_vals_v22_v23[] = {
+ { 0xF81C, 0x00FF },
+ /*{ 0x????, 0x???? }, */
+ { 0xF80C, 0x1FFF },
+ { 0xFA25, 0x001F },
+ { 0xF804, 0x00FF },
+ { 0xF802, 0x0FFF },
+ /*{ 0x????, 0x???? },
+ { 0x????, 0x???? },
+ { 0x????, 0x???? }*/
+};
+
+static const CsrUint16 reset_program_a_v1_or_v2[] = {
+ 0x0000
+};
+static const CsrUint16 reset_program_b_v1_or_v2[] = {
+ 0x0010, 0xFE00, 0xA021, 0xFF00, 0x8111, 0x0009, 0x0CA4, 0x0114,
+ 0x0280, 0x04F8, 0xFE00, 0x6F25, 0x06E0, 0x0010, 0xFC00, 0x0121,
+ 0xFC00, 0x0225, 0xFE00, 0x7125, 0xFE00, 0x6D11, 0x03F0, 0xFE00,
+ 0x6E25, 0x0008, 0x00E0
+};
+
+static const struct chip_helper_reset_values reset_program_v1_or_v2[] =
+{
+ {
+ MAKE_GP(REGISTERS, 0x000C),
+ nelem(reset_program_a_v1_or_v2),
+ reset_program_a_v1_or_v2
+ },
+ {
+ MAKE_GP(MAC_PMEM, 0x000000),
+ nelem(reset_program_b_v1_or_v2),
+ reset_program_b_v1_or_v2
+ }
+};
+
+static const struct chip_map_address_t unifi_map_address_v1_v2[] =
+{
+ { 0xFE9F, 0xFE7B }, /* PM1_BANK_SELECT */
+ { 0xFE9E, 0xFE78 }, /* PM2_BANK_SELECT */
+ { 0xFE9D, 0xFE7E }, /* SHARED_DMEM_PAGE */
+ { 0xFE91, 0xFE90 }, /* PROC_SELECT */
+ { 0xFE8D, 0xFE8C }, /* STOP_STATUS */
+};
+
+static const struct chip_map_address_t unifi_map_address_v22_v23[] =
+{
+ { 0xF8F9, 0xF8AC }, /* GW1_CONFIG */
+ { 0xF8FA, 0xF8AD }, /* GW2_CONFIG */
+ { 0xF8FB, 0xF8AE }, /* GW3_CONFIG */
+ { 0xF830, 0xF81E }, /* PROC_SELECT */
+ { 0xF831, 0xF81F }, /* STOP_STATUS */
+ { 0xF8FC, 0xF8AF }, /* IO_LOG_ADDRESS */
+};
+
+static const struct chip_device_regs_t unifi_device_regs_null =
+{
+ 0xFE81, /* GBL_CHIP_VERSION */
+ 0x0000, /* GBL_MISC_ENABLES */
+ 0x0000, /* DBG_EMU_CMD */
+ {
+ 0x0000, /* HOST.DBG_PROC_SELECT */
+ 0x0000, /* HOST.DBG_STOP_STATUS */
+ 0x0000, /* HOST.WINDOW1_PAGE */
+ 0x0000, /* HOST.WINDOW2_PAGE */
+ 0x0000, /* HOST.WINDOW3_PAGE */
+ 0x0000 /* HOST.IO_LOG_ADDR */
+ },
+ {
+ 0x0000, /* SPI.DBG_PROC_SELECT */
+ 0x0000, /* SPI.DBG_STOP_STATUS */
+ 0x0000, /* SPI.WINDOW1_PAGE */
+ 0x0000, /* SPI.WINDOW2_PAGE */
+ 0x0000, /* SPI.WINDOW3_PAGE */
+ 0x0000 /* SPI.IO_LOG_ADDR */
+ },
+ 0x0000, /* DBG_RESET */
+ 0x0000, /* > DBG_RESET_VALUE */
+ 0x0000, /* DBG_RESET_WARN */
+ 0x0000, /* DBG_RESET_WARN_VALUE */
+ 0x0000, /* DBG_RESET_RESULT */
+ 0xFFE9, /* XAP_PCH */
+ 0xFFEA, /* XAP_PCL */
+ 0x0000, /* PROC_PC_SNOOP */
+ 0x0000, /* WATCHDOG_DISABLE */
+ 0x0000, /* MAILBOX0 */
+ 0x0000, /* MAILBOX1 */
+ 0x0000, /* MAILBOX2 */
+ 0x0000, /* MAILBOX3 */
+ 0x0000, /* SDIO_HOST_INT */
+ 0x0000, /* SHARED_IO_INTERRUPT */
+ 0x0000, /* SDIO HIP HANDSHAKE */
+ 0x0000 /* COEX_STATUS */
+};
+
+/* UF105x */
+static const struct chip_device_regs_t unifi_device_regs_v1 =
+{
+ 0xFE81, /* GBL_CHIP_VERSION */
+ 0xFE87, /* GBL_MISC_ENABLES */
+ 0xFE9C, /* DBG_EMU_CMD */
+ {
+ 0xFE90, /* HOST.DBG_PROC_SELECT */
+ 0xFE8C, /* HOST.DBG_STOP_STATUS */
+ 0xFE7B, /* HOST.WINDOW1_PAGE */
+ 0xFE78, /* HOST.WINDOW2_PAGE */
+ 0xFE7E, /* HOST.WINDOW3_PAGE */
+ 0x0000 /* HOST.IO_LOG_ADDR */
+ },
+ {
+ 0xFE91, /* SPI.DBG_PROC_SELECT */
+ 0xFE8D, /* SPI.DBG_STOP_STATUS */
+ 0xFE9F, /* SPI.WINDOW1_PAGE */
+ 0xFE9E, /* SPI.WINDOW2_PAGE */
+ 0xFE9D, /* SPI.WINDOW3_PAGE */
+ 0x0000 /* SPI.IO_LOG_ADDR */
+ },
+ 0xFE92, /* DBG_RESET */
+ 0x0001, /* > DBG_RESET_VALUE */
+ 0xFDA0, /* DBG_RESET_WARN (HOST_SELECT) */
+ 0x0000, /* DBG_RESET_WARN_VALUE */
+ 0xFE92, /* DBG_RESET_RESULT */
+ 0xFFE9, /* XAP_PCH */
+ 0xFFEA, /* XAP_PCL */
+ 0x0051, /* PROC_PC_SNOOP */
+ 0xFE70, /* WATCHDOG_DISABLE */
+ 0xFE6B, /* MAILBOX0 */
+ 0xFE6A, /* MAILBOX1 */
+ 0xFE69, /* MAILBOX2 */
+ 0xFE68, /* MAILBOX3 */
+ 0xFE67, /* SDIO_HOST_INT */
+ 0xFE65, /* SHARED_IO_INTERRUPT */
+ 0xFDE9, /* SDIO HIP HANDSHAKE */
+ 0x0000 /* COEX_STATUS */
+};
+
+/* UF2... */
+static const struct chip_device_regs_t unifi_device_regs_v2 =
+{
+ 0xFE81, /* GBL_CHIP_VERSION */
+ 0xFE87, /* GBL_MISC_ENABLES */
+ 0xFE9C, /* DBG_EMU_CMD */
+ {
+ 0xFE90, /* HOST.DBG_PROC_SELECT */
+ 0xFE8C, /* HOST.DBG_STOP_STATUS */
+ 0xFE7B, /* HOST.WINDOW1_PAGE */
+ 0xFE78, /* HOST.WINDOW2_PAGE */
+ 0xFE7E, /* HOST.WINDOW3_PAGE */
+ 0x0000 /* HOST.IO_LOG_ADDR */
+ },
+ {
+ 0xFE91, /* SPI.DBG_PROC_SELECT */
+ 0xFE8D, /* SPI.DBG_STOP_STATUS */
+ 0xFE9F, /* SPI.WINDOW1_PAGE */
+ 0xFE9E, /* SPI.WINDOW2_PAGE */
+ 0xFE9D, /* SPI.WINDOW3_PAGE */
+ 0x0000 /* SPI.IO_LOG_ADDR */
+ },
+ 0xFE92, /* DBG_RESET */
+ 0x0000, /* > DBG_RESET_VALUE */
+ 0xFDE9, /* DBG_RESET_WARN (TEST_FLASH_DATA - SHARED_MAILBOX2B) */
+ 0xFFFF, /* DBG_RESET_WARN_VALUE */
+ 0xFDE9, /* DBG_RESET_RESULT (TEST_FLASH_DATA) */
+ 0xFFE9, /* XAP_PCH */
+ 0xFFEA, /* XAP_PCL */
+ 0x0051, /* PROC_PC_SNOOP */
+ 0xFE70, /* WATCHDOG_DISABLE */
+ 0xFE6B, /* MAILBOX0 */
+ 0xFE6A, /* MAILBOX1 */
+ 0xFE69, /* MAILBOX2 */
+ 0xFE68, /* MAILBOX3 */
+ 0xFE67, /* SDIO_HOST_INT */
+ 0xFE65, /* SHARED_IO_INTERRUPT */
+ 0xFE69, /* SDIO HIP HANDSHAKE */
+ 0x0000 /* COEX_STATUS */
+};
+
+/* UF60xx */
+static const struct chip_device_regs_t unifi_device_regs_v22_v23 =
+{
+ 0xFE81, /* GBL_CHIP_VERSION */
+ 0xF84F, /* GBL_MISC_ENABLES */
+ 0xF81D, /* DBG_EMU_CMD */
+ {
+ 0xF81E, /* HOST.DBG_PROC_SELECT */
+ 0xF81F, /* HOST.DBG_STOP_STATUS */
+ 0xF8AC, /* HOST.WINDOW1_PAGE */
+ 0xF8AD, /* HOST.WINDOW2_PAGE */
+ 0xF8AE, /* HOST.WINDOW3_PAGE */
+ 0xF8AF /* HOST.IO_LOG_ADDR */
+ },
+ {
+ 0xF830, /* SPI.DBG_PROC_SELECT */
+ 0xF831, /* SPI.DBG_STOP_STATUS */
+ 0xF8F9, /* SPI.WINDOW1_PAGE */
+ 0xF8FA, /* SPI.WINDOW2_PAGE */
+ 0xF8FB, /* SPI.WINDOW3_PAGE */
+ 0xF8FC /* SPI.IO_LOG_ADDR */
+ },
+ 0xF82F, /* DBG_RESET */
+ 0x0001, /* > DBG_RESET_VALUE */
+ 0x0000, /* DBG_RESET_WARN */
+ 0x0000, /* DBG_RESET_WARN_VALUE */
+ 0xF82F, /* DBG_RESET_RESULT */
+ 0xFFE9, /* XAP_PCH */
+ 0xFFEA, /* XAP_PCL */
+ 0x001B, /* PROC_PC_SNOOP */
+ 0x0055, /* WATCHDOG_DISABLE */
+ 0xF84B, /* MAILBOX0 */
+ 0xF84C, /* MAILBOX1 */
+ 0xF84D, /* MAILBOX2 */
+ 0xF84E, /* MAILBOX3 */
+ 0xF92F, /* SDIO_HOST_INT */
+ 0xF92B, /* SDIO_FROMHOST_SCRTACH0 / SHARED_IO_INTERRUPT */
+ 0xF84D, /* SDIO HIP HANDSHAKE (MAILBOX2) */
+ 0xF9FB /* COEX_STATUS */
+};
+
+/* Program memory window on UF105x. */
+static const struct window_shift_info_t prog_window_array_unifi_v1_v2[CHIP_HELPER_WT_COUNT] =
+{
+ { TRUE, 11, 0x0200 }, /* CODE RAM */
+ { TRUE, 11, 0x0000 }, /* FLASH */
+ { TRUE, 11, 0x0400 }, /* External SRAM */
+ { FALSE, 0, 0 }, /* ROM */
+ { FALSE, 0, 0 } /* SHARED */
+};
+
+/* Shared memory window on UF105x. */
+static const struct window_shift_info_t shared_window_array_unifi_v1_v2[CHIP_HELPER_WT_COUNT] =
+{
+ { FALSE, 0, 0 }, /* CODE RAM */
+ { FALSE, 0, 0 }, /* FLASH */
+ { FALSE, 0, 0 }, /* External SRAM */
+ { FALSE, 0, 0 }, /* ROM */
+ { TRUE, 11, 0x0000 } /* SHARED */
+};
+
+/* One of the Generic Windows on UF60xx and later. */
+static const struct window_shift_info_t generic_window_array_unifi_v22_v23[CHIP_HELPER_WT_COUNT] =
+{
+ { TRUE, 11, 0x3800 }, /* CODE RAM */
+ { FALSE, 0, 0 }, /* FLASH */
+ { FALSE, 0, 0 }, /* External SRAM */
+ { TRUE, 11, 0x2000 }, /* ROM */
+ { TRUE, 11, 0x0000 } /* SHARED */
+};
+
+/* The three windows on UF105x. */
+static const struct window_info_t prog1_window_unifi_v1_v2 = { 0x0000, 0x2000, 0x0080, prog_window_array_unifi_v1_v2 };
+static const struct window_info_t prog2_window_unifi_v1_v2 = { 0x2000, 0x2000, 0x0000, prog_window_array_unifi_v1_v2 };
+static const struct window_info_t shared_window_unifi_v1_v2 = { 0x4000, 0x2000, 0x0000, shared_window_array_unifi_v1_v2 };
+
+/* The three windows on UF60xx and later. */
+static const struct window_info_t generic1_window_unifi_v22_v23 = { 0x0000, 0x2000, 0x0080, generic_window_array_unifi_v22_v23 };
+static const struct window_info_t generic2_window_unifi_v22_v23 = { 0x2000, 0x2000, 0x0000, generic_window_array_unifi_v22_v23 };
+static const struct window_info_t generic3_window_unifi_v22_v23 = { 0x4000, 0x2000, 0x0000, generic_window_array_unifi_v22_v23 };
+
+static const struct chip_device_desc_t chip_device_desc_null =
+{
+ { FALSE, 0x0000, 0x0000, 0x00 },
+ "",
+ "",
+ null_counted(), /* init */
+ null_counted(), /* reset_prog */
+ &unifi_device_regs_null, /* regs */
+ {
+ FALSE, /* has_flash */
+ FALSE, /* has_ext_sram */
+ FALSE, /* has_rom */
+ FALSE, /* has_bt */
+ FALSE, /* has_wlan */
+ },
+ null_counted(),
+ /* prog_offset */
+ {
+ 0x00000000,
+ 0x00000000,
+ 0x00000000,
+ 0x00000000
+ },
+ /* data_offset */
+ {
+ 0x0000 /* ram */
+ },
+ /* windows */
+ {
+ NULL,
+ NULL,
+ NULL
+ }
+};
+
+static const struct chip_device_desc_t unifi_device_desc_v1 =
+{
+ { FALSE, 0xf0ff, 0x1001, 0x01 }, /* UF105x R01 */
+ "UF105x",
+ "UniFi-1",
+ counted(init_vals_v1), /* init */
+ counted(reset_program_v1_or_v2), /* reset_prog */
+ &unifi_device_regs_v1, /* regs */
+ {
+ TRUE, /* has_flash */
+ TRUE, /* has_ext_sram */
+ FALSE, /* has_rom */
+ FALSE, /* has_bt */
+ TRUE, /* has_wlan */
+ },
+ counted(unifi_map_address_v1_v2), /* map */
+ /* prog_offset */
+ {
+ 0x00100000, /* ram */
+ 0x00000000, /* rom (invalid) */
+ 0x00000000, /* flash */
+ 0x00200000, /* ext_ram */
+ },
+ /* data_offset */
+ {
+ 0x8000 /* ram */
+ },
+ /* windows */
+ {
+ &prog1_window_unifi_v1_v2,
+ &prog2_window_unifi_v1_v2,
+ &shared_window_unifi_v1_v2
+ }
+};
+
+static const struct chip_device_desc_t unifi_device_desc_v2 =
+{
+ { FALSE, 0xf0ff, 0x2001, 0x02 }, /* UF2... R02 */
+ "UF2...",
+ "UniFi-2",
+ counted(init_vals_v2), /* init */
+ counted(reset_program_v1_or_v2), /* reset_prog */
+ &unifi_device_regs_v2, /* regs */
+ {
+ TRUE, /* has_flash */
+ TRUE, /* has_ext_sram */
+ FALSE, /* has_rom */
+ FALSE, /* has_bt */
+ TRUE, /* has_wlan */
+ },
+ counted(unifi_map_address_v1_v2), /* map */
+ /* prog_offset */
+ {
+ 0x00100000, /* ram */
+ 0x00000000, /* rom (invalid) */
+ 0x00000000, /* flash */
+ 0x00200000, /* ext_ram */
+ },
+ /* data_offset */
+ {
+ 0x8000 /* ram */
+ },
+ /* windows */
+ {
+ &prog1_window_unifi_v1_v2,
+ &prog2_window_unifi_v1_v2,
+ &shared_window_unifi_v1_v2
+ }
+};
+
+static const struct chip_device_desc_t unifi_device_desc_v3 =
+{
+ { FALSE, 0xf0ff, 0x3001, 0x02 }, /* UF2... R03 */
+ "UF2...",
+ "UniFi-3",
+ counted(init_vals_v2), /* init */
+ counted(reset_program_v1_or_v2), /* reset_prog */
+ &unifi_device_regs_v2, /* regs */
+ {
+ TRUE, /* has_flash */
+ TRUE, /* has_ext_sram */
+ FALSE, /* has_rom */
+ FALSE, /* has_bt */
+ TRUE, /* has_wlan */
+ },
+ counted(unifi_map_address_v1_v2), /* map */
+ /* prog_offset */
+ {
+ 0x00100000, /* ram */
+ 0x00000000, /* rom (invalid) */
+ 0x00000000, /* flash */
+ 0x00200000, /* ext_ram */
+ },
+ /* data_offset */
+ {
+ 0x8000 /* ram */
+ },
+ /* windows */
+ {
+ &prog1_window_unifi_v1_v2,
+ &prog2_window_unifi_v1_v2,
+ &shared_window_unifi_v1_v2
+ }
+};
+
+static const struct chip_device_desc_t unifi_device_desc_v22 =
+{
+ { FALSE, 0x00ff, 0x0022, 0x07 }, /* UF60xx */
+ "UF60xx",
+ "UniFi-4",
+ counted(init_vals_v22_v23), /* init */
+ null_counted(), /* reset_prog */
+ &unifi_device_regs_v22_v23, /* regs */
+ {
+ FALSE, /* has_flash */
+ FALSE, /* has_ext_sram */
+ TRUE, /* has_rom */
+ FALSE, /* has_bt */
+ TRUE, /* has_wlan */
+ },
+ counted(unifi_map_address_v22_v23), /* map */
+ /* prog_offset */
+ {
+ 0x00C00000, /* ram */
+ 0x00000000, /* rom */
+ 0x00000000, /* flash (invalid) */
+ 0x00000000, /* ext_ram (invalid) */
+ },
+ /* data_offset */
+ {
+ 0x8000 /* ram */
+ },
+ /* windows */
+ {
+ &generic1_window_unifi_v22_v23,
+ &generic2_window_unifi_v22_v23,
+ &generic3_window_unifi_v22_v23
+ }
+};
+
+static const struct chip_device_desc_t unifi_device_desc_v23 =
+{
+ { FALSE, 0x00ff, 0x0023, 0x08 }, /* UF.... */
+ "UF....",
+ "UF.... (5)",
+ counted(init_vals_v22_v23), /* init */
+ null_counted(), /* reset_prog */
+ &unifi_device_regs_v22_v23, /* regs */
+ {
+ FALSE, /* has_flash */
+ FALSE, /* has_ext_sram */
+ TRUE, /* has_rom */
+ TRUE, /* has_bt */
+ TRUE, /* has_wlan */
+ },
+ counted(unifi_map_address_v22_v23),
+ /* prog_offset */
+ {
+ 0x00C00000, /* ram */
+ 0x00000000, /* rom */
+ 0x00000000, /* flash (invalid) */
+ 0x00000000, /* ext_sram (invalid) */
+ },
+ /* data_offset */
+ {
+ 0x8000 /* ram */
+ },
+ /* windows */
+ {
+ &generic1_window_unifi_v22_v23,
+ &generic2_window_unifi_v22_v23,
+ &generic3_window_unifi_v22_v23
+ }
+};
+
+static const struct chip_device_desc_t hyd_wlan_subsys_desc_v1 =
+{
+ { FALSE, 0x00ff, 0x0044, 0x00 }, /* UF.... */
+ "HYD...",
+ "HYD... ",
+ counted(init_vals_v22_v23), /* init */
+ null_counted(), /* reset_prog */
+ &unifi_device_regs_v22_v23, /* regs */
+ {
+ FALSE, /* has_flash */
+ FALSE, /* has_ext_sram */
+ TRUE, /* has_rom */
+ FALSE, /* has_bt */
+ TRUE, /* has_wlan */
+ },
+ counted(unifi_map_address_v22_v23),
+ /* prog_offset */
+ {
+ 0x00C00000, /* ram */
+ 0x00000000, /* rom */
+ 0x00000000, /* flash (invalid) */
+ 0x00000000, /* ext_sram (invalid) */
+ },
+ /* data_offset */
+ {
+ 0x8000 /* ram */
+ },
+ /* windows */
+ {
+ &generic1_window_unifi_v22_v23,
+ &generic2_window_unifi_v22_v23,
+ &generic3_window_unifi_v22_v23
+ }
+};
+
+
+/* This is the list of all chips that we know about. I'm
+ assuming that the order here will be important - we
+ might have multiple entries witrh the same SDIO id for
+ instance. The first one in this list will be the one
+ that is returned if a search is done on only that id.
+ The client will then have to call GetVersionXXX again
+ but with more detailed info.
+
+ I don't know if we need to signal this up to the client
+ in some way?
+
+ (We get the SDIO id before we know anything else about
+ the chip. We might not be able to read any of the other
+ registers at first, but we still need to know about the
+ chip). */
+static const struct chip_device_desc_t *chip_ver_to_desc[] =
+{
+ &unifi_device_desc_v1, /* UF105x R01 */
+ &unifi_device_desc_v2, /* UF2... R02 */
+ &unifi_device_desc_v3, /* UF2... R03 */
+ &unifi_device_desc_v22, /* UF60xx */
+ &unifi_device_desc_v23, /* UF.... */
+ &hyd_wlan_subsys_desc_v1
+};
+
+ChipDescript* ChipHelper_GetVersionSdio(CsrUint8 sdio_ver)
+{
+ CsrUint32 i;
+
+ for (i = 0; i < nelem(chip_ver_to_desc); i++)
+ {
+ if (chip_ver_to_desc[i]->chip_version.sdio == sdio_ver)
+ {
+ return chip_ver_to_desc[i];
+ }
+ }
+
+ return &chip_device_desc_null;
+}
+
+
+ChipDescript* ChipHelper_GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81)
+{
+ CsrUint32 i;
+
+ if ((from_FF9A & 0xFF00) != 0)
+ {
+ for (i = 0; i < nelem(chip_ver_to_desc); i++)
+ {
+ if (chip_ver_to_desc[i]->chip_version.pre_bc7 &&
+ ((from_FF9A & chip_ver_to_desc[i]->chip_version.mask) ==
+ chip_ver_to_desc[i]->chip_version.result))
+ {
+ return chip_ver_to_desc[i];
+ }
+ }
+ }
+ else
+ {
+ for (i = 0; i < nelem(chip_ver_to_desc); i++)
+ {
+ if (!chip_ver_to_desc[i]->chip_version.pre_bc7 &&
+ ((from_FE81 & chip_ver_to_desc[i]->chip_version.mask) ==
+ chip_ver_to_desc[i]->chip_version.result))
+ {
+ return chip_ver_to_desc[i];
+ }
+ }
+ }
+
+ return &chip_device_desc_null;
+}
+
+
+ChipDescript* ChipHelper_GetVersionUniFi(CsrUint16 ver)
+{
+ return ChipHelper_GetVersionAny(0x0000, ver);
+}
+
+
+ChipDescript* ChipHelper_Null()
+{
+ return &chip_device_desc_null;
+}
+
+
+ChipDescript* ChipHelper_GetVersionBlueCore(enum chip_helper_bluecore_age bc_age, CsrUint16 version)
+{
+ if (bc_age == chip_helper_bluecore_pre_bc7)
+ {
+ return ChipHelper_GetVersionAny(version, 0x0000);
+ }
+ else
+ {
+ return ChipHelper_GetVersionAny(0x0000, version);
+ }
+}
+
+
+/* Expand the DEF0 functions into simple code to return the
+ correct thing. The DEF1 functions expand to nothing in
+ this X macro expansion. */
+#define CHIP_HELPER_DEF0_C_DEF(ret_type, name, info) \
+ ret_type ChipHelper_ ## name(ChipDescript * chip_help) \
+ { \
+ return chip_help->info; \
+ }
+#define CHIP_HELPER_DEF1_C_DEF(ret_type, name, type1, name1)
+
+CHIP_HELPER_LIST(C_DEF)
+
+/*
+ * Map register addresses between HOST and SPI access.
+ */
+CsrUint16 ChipHelper_MapAddress_SPI2HOST(ChipDescript *chip_help, CsrUint16 addr)
+{
+ CsrUint32 i;
+ for (i = 0; i < chip_help->map.len; i++)
+ {
+ if (chip_help->map.vals[i].spi == addr)
+ {
+ return chip_help->map.vals[i].host;
+ }
+ }
+ return addr;
+}
+
+
+CsrUint16 ChipHelper_MapAddress_HOST2SPI(ChipDescript *chip_help, CsrUint16 addr)
+{
+ CsrUint32 i;
+ for (i = 0; i < chip_help->map.len; i++)
+ {
+ if (chip_help->map.vals[i].host == addr)
+ {
+ return chip_help->map.vals[i].spi;
+ }
+ }
+ return addr;
+}
+
+
+/* The address returned by this function is the start of the
+ window in the address space, that is where we can start
+ accessing data from. If a section of the window at the
+ start is unusable because something else is cluttering up
+ the address map then that is taken into account and this
+ function returns that address justt past that. */
+CsrUint16 ChipHelper_WINDOW_ADDRESS(ChipDescript *chip_help,
+ enum chip_helper_window_index window)
+{
+ if (window < CHIP_HELPER_WINDOW_COUNT &&
+ chip_help->windows[window] != NULL)
+ {
+ return chip_help->windows[window]->address + chip_help->windows[window]->blocked;
+ }
+ return 0;
+}
+
+
+/* This returns the size of the window minus any blocked section */
+CsrUint16 ChipHelper_WINDOW_SIZE(ChipDescript *chip_help,
+ enum chip_helper_window_index window)
+{
+ if (window < CHIP_HELPER_WINDOW_COUNT &&
+ chip_help->windows[window] != NULL)
+ {
+ return chip_help->windows[window]->size - chip_help->windows[window]->blocked;
+ }
+ return 0;
+}
+
+
+/* Get the register writes we should do to make sure that
+ the chip is running with most clocks on. */
+CsrUint32 ChipHelper_ClockStartupSequence(ChipDescript *chip_help,
+ const struct chip_helper_init_values **val)
+{
+ *val = chip_help->init.vals;
+ return chip_help->init.len;
+}
+
+
+/* Get the set of values tat we should write to the chip to perform a reset. */
+CsrUint32 ChipHelper_HostResetSequence(ChipDescript *chip_help,
+ const struct chip_helper_reset_values **val)
+{
+ *val = chip_help->reset_prog.vals;
+ return chip_help->reset_prog.len;
+}
+
+
+/* Decode a windowed access to the chip. */
+CsrInt32 ChipHelper_DecodeWindow(ChipDescript *chip_help,
+ enum chip_helper_window_index window,
+ enum chip_helper_window_type type,
+ CsrUint32 offset,
+ CsrUint16 *page, CsrUint16 *addr, CsrUint32 *len)
+{
+ const struct window_info_t *win;
+ const struct window_shift_info_t *mode;
+ CsrUint16 of, pg;
+
+ if (window >= CHIP_HELPER_WINDOW_COUNT)
+ {
+ return FALSE;
+ }
+ if ((win = chip_help->windows[window]) == NULL)
+ {
+ return FALSE;
+ }
+ if (type >= CHIP_HELPER_WT_COUNT)
+ {
+ return FALSE;
+ }
+ if ((mode = &win->mode[type]) == NULL)
+ {
+ return FALSE;
+ }
+ if (!mode->allowed)
+ {
+ return FALSE;
+ }
+
+ pg = (CsrUint16)(offset >> mode->page_shift) + mode->page_offset;
+ of = (CsrUint16)(offset & ((1 << mode->page_shift) - 1));
+ /* If 'blocked' is zero this does nothing, else decrease
+ the page register and increase the offset until we aren't
+ in the blocked region of the window. */
+ while (of < win->blocked)
+ {
+ of += 1 << mode->page_shift;
+ pg--;
+ }
+ *page = pg;
+ *addr = win->address + of;
+ *len = win->size - of;
+ return TRUE;
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifndef CSR_WIFI_HIP_CHIPHELPER_H__
+#define CSR_WIFI_HIP_CHIPHELPER_H__
+
+
+#include "csr_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The age of the BlueCore chip. This is probably not useful, if
+ you know the age then you can probably work out the version directly. */
+enum chip_helper_bluecore_age
+{
+ chip_helper_bluecore_pre_bc7,
+ chip_helper_bluecore_bc7_or_later
+};
+
+/* We support up to three windowed regions at the moment.
+ Don't reorder these - they're used to index into an array. */
+enum chip_helper_window_index
+{
+ CHIP_HELPER_WINDOW_1 = 0,
+ CHIP_HELPER_WINDOW_2 = 1,
+ CHIP_HELPER_WINDOW_3 = 2,
+ CHIP_HELPER_WINDOW_COUNT = 3
+};
+
+/* These are the things that we can access through a window.
+ Don't reorder these - they're used to index into an array. */
+enum chip_helper_window_type
+{
+ CHIP_HELPER_WT_CODE_RAM = 0,
+ CHIP_HELPER_WT_FLASH = 1,
+ CHIP_HELPER_WT_EXT_SRAM = 2,
+ CHIP_HELPER_WT_ROM = 3,
+ CHIP_HELPER_WT_SHARED = 4,
+ CHIP_HELPER_WT_COUNT = 5
+};
+
+/* Commands to stop and start the XAP */
+enum chip_helper_dbg_emu_cmd_enum
+{
+ CHIP_HELPER_DBG_EMU_CMD_XAP_STEP_MASK = 0x0001,
+ CHIP_HELPER_DBG_EMU_CMD_XAP_RUN_B_MASK = 0x0002,
+ CHIP_HELPER_DBG_EMU_CMD_XAP_BRK_MASK = 0x0004,
+ CHIP_HELPER_DBG_EMU_CMD_XAP_WAKEUP_MASK = 0x0008
+};
+
+/* Bitmasks for Stop and sleep status: DBG_SPI_STOP_STATUS & DBG_HOST_STOP_STATUS */
+enum chip_helper_dbg_stop_status_enum
+{
+ CHIP_HELPER_DBG_STOP_STATUS_NONE_MASK = 0x0000,
+ CHIP_HELPER_DBG_STOP_STATUS_P0_MASK = 0x0001,
+ CHIP_HELPER_DBG_STOP_STATUS_P1_MASK = 0x0002,
+ CHIP_HELPER_DBG_STOP_STATUS_P2_MASK = 0x0004,
+ CHIP_HELPER_DBG_STOP_STATUS_SLEEP_STATUS_P0_MASK = 0x0008,
+ CHIP_HELPER_DBG_STOP_STATUS_SLEEP_STATUS_P1_MASK = 0x0010,
+ CHIP_HELPER_DBG_STOP_STATUS_SLEEP_STATUS_P2_MASK = 0x0020,
+ /* Legacy names/alias */
+ CHIP_HELPER_DBG_STOP_STATUS_MAC_MASK = 0x0001,
+ CHIP_HELPER_DBG_STOP_STATUS_PHY_MASK = 0x0002,
+ CHIP_HELPER_DBG_STOP_STATUS_BT_MASK = 0x0004,
+ CHIP_HELPER_DBG_STOP_STATUS_SLEEP_STATUS_MAC_MASK = 0x0008,
+ CHIP_HELPER_DBG_STOP_STATUS_SLEEP_STATUS_PHY_MASK = 0x0010,
+ CHIP_HELPER_DBG_STOP_STATUS_SLEEP_STATUS_BT_MASK = 0x0020
+};
+
+/* Codes to disable the watchdog */
+enum chip_helper_watchdog_disable_enum
+{
+ CHIP_HELPER_WATCHDOG_DISABLE_CODE1 = 0x6734,
+ CHIP_HELPER_WATCHDOG_DISABLE_CODE2 = 0xD6BF,
+ CHIP_HELPER_WATCHDOG_DISABLE_CODE3 = 0xC31E
+};
+
+/* Other bits have changed between versions */
+enum chip_helper_gbl_misc_enum
+{
+ CHIP_HELPER_GBL_MISC_SPI_STOP_OUT_EN_MASK = 0x0001,
+ CHIP_HELPER_GBL_MISC_MMU_INIT_DONE_MASK = 0x0004
+};
+
+/* Coex status register, contains interrupt status and reset pullup status.
+ * CHIP_HELPER_COEX_STATUS_RST_PULLS_MSB_MASK can be used to check
+ * for WAPI on R03 chips and later. */
+enum chip_helper_coex_status_mask_enum
+{
+ CHIP_HELPER_COEX_STATUS_RST_PULLS_LSB_MASK = 0x0001,
+ CHIP_HELPER_COEX_STATUS_RST_PULLS_MSB_MASK = 0x0008,
+ CHIP_HELPER_COEX_STATUS_WL_FEC_PINS_LSB_MASK = 0x0010,
+ CHIP_HELPER_COEX_STATUS_WL_FEC_PINS_MSB_MASK = 0x0080,
+ CHIP_HELPER_COEX_STATUS_INT_UART_MASK = 0x0100,
+ CHIP_HELPER_COEX_STATUS_INT_BT_LEG_MASK = 0x0200
+};
+
+/* How to select the different CPUs */
+enum chip_helper_dbg_proc_sel_enum
+{
+ CHIP_HELPER_DBG_PROC_SEL_MAC = 0,
+ CHIP_HELPER_DBG_PROC_SEL_PHY = 1,
+ CHIP_HELPER_DBG_PROC_SEL_BT = 2,
+ CHIP_HELPER_DBG_PROC_SEL_NONE = 2,
+ CHIP_HELPER_DBG_PROC_SEL_BOTH = 3
+};
+
+/* These are the only registers that we have to know the
+ address of before we know the chip version. */
+enum chip_helper_fixed_registers
+{
+ /* This is the address of GBL_CHIP_VERISON on BC7,
+ UF105x, UF60xx and
+ anything later than that. */
+ CHIP_HELPER_UNIFI_GBL_CHIP_VERSION = 0xFE81,
+
+ CHIP_HELPER_OLD_BLUECORE_GBL_CHIP_VERSION = 0xFF9A
+
+ /* This isn't used at the moment (but might be needed
+ to distinguish the BlueCore sub version?) */
+ /* CHIP_HELPER_OLD_BLUECORE_ANA_VERSION_ID = 0xFF7D */
+};
+
+/* Address-value pairs for defining initialisation values */
+struct chip_helper_init_values
+{
+ CsrUint16 addr;
+ CsrUint16 value;
+};
+
+/* A block of data that should be written to the device */
+struct chip_helper_reset_values
+{
+ CsrUint32 gp_address;
+ CsrUint32 len;
+ const CsrUint16 *data;
+};
+
+/*
+ * This is the C API.
+ */
+
+/* opaque type */
+typedef const struct chip_device_desc_t ChipDescript;
+
+/* Return a NULL descriptor */
+ChipDescript* ChipHelper_Null(void);
+
+/* This should get the correct version for any CSR chip.
+ The two parameters are what is read from addresses
+ 0xFF9A and 0xFE81 (OLD_BLUECORE_GBL_CHIP_VERSION and
+ UNIFI_GBL_CHIP_VERSION). These should give a unique identity
+ for most (all?) chips.
+
+ FF9A is the old GBL_CHIP_VERSION register. If the high
+ eight bits are zero then the chip is a new (BC7 +) one
+ and FE81 is the _new_ GBL_CHIP_VERSION register. */
+ChipDescript* ChipHelper_GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81);
+
+/* The chip is a UniFi, but we don't know which type
+ The parameter is the value of UNIFI_GBL_CHIP_VERSION (0xFE81) */
+ChipDescript* ChipHelper_GetVersionUniFi(CsrUint16 version);
+
+/* This gets the version from the SDIO device id. This only
+ gives quite a coarse grained version, so we should update once
+ we hav access to the function N registers. */
+ChipDescript* ChipHelper_GetVersionSdio(CsrUint8 sdio_version);
+
+/* The chip is some sort of BlueCore. If "age" is "pre_bc7" then
+ "version" is what was read from FF9A. If "age" is bc7_or_later
+ then "version" is read from FE81. If we don't know if we're pre
+ or post BC7 then we should use "GetVersionAny". */
+ChipDescript* ChipHelper_GetVersionBlueCore(enum chip_helper_bluecore_age age,
+ CsrUint16 version);
+
+/* The main functions of this class are built with an X macro. This
+ means we can generate the C and C++ versions from the same source
+ without the two diverging.
+
+ The DEF0 functions are simple and take no parameters. The first
+ parameter to the macro is the return type. The second parameter
+ is the function name and the third parameter is where to get the
+ info from (this is hidden from the user).
+
+ The DEF1 functions take one parameter. This time the third macro
+ parameter is the type of this parameter, and the fourth macro
+ parameter is the name of the parameter. The bodies of these
+ functions are hand written. */
+#define CHIP_HELPER_LIST(m) \
+ CHIP_HELPER_DEF0(m, (const CsrCharString *, FriendlyName, friendly_name)) \
+ CHIP_HELPER_DEF0(m, (const CsrCharString *, MarketingName, marketing_name)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DBG_EMU_CMD, regs->dbg_emu_cmd)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DBG_HOST_PROC_SELECT, regs->host.dbg_proc_select)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DBG_HOST_STOP_STATUS, regs->host.dbg_stop_status)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, HOST_WINDOW1_PAGE, regs->host.window1_page)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, HOST_WINDOW2_PAGE, regs->host.window2_page)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, HOST_WINDOW3_PAGE, regs->host.window3_page)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, HOST_IO_LOG_ADDR, regs->host.io_log_addr)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DBG_SPI_PROC_SELECT, regs->spi.dbg_proc_select)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DBG_SPI_STOP_STATUS, regs->spi.dbg_stop_status)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, SPI_WINDOW1_PAGE, regs->spi.window1_page)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, SPI_WINDOW2_PAGE, regs->spi.window2_page)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, SPI_WINDOW3_PAGE, regs->spi.window3_page)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, SPI_IO_LOG_ADDR, regs->spi.io_log_addr)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET, regs->dbg_reset)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_VALUE, regs->dbg_reset_value)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_WARN, regs->dbg_reset_warn)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_WARN_VALUE, regs->dbg_reset_warn_value)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DBG_RESET_RESULT, regs->dbg_reset_result)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, WATCHDOG_DISABLE, regs->watchdog_disable)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, PROC_PC_SNOOP, regs->proc_pc_snoop)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, GBL_CHIP_VERSION, regs->gbl_chip_version)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, GBL_MISC_ENABLES, regs->gbl_misc_enables)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, XAP_PCH, regs->xap_pch)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, XAP_PCL, regs->xap_pcl)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX0, regs->mailbox0)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX1, regs->mailbox1)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX2, regs->mailbox2)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, MAILBOX3, regs->mailbox3)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, SDIO_HIP_HANDSHAKE, regs->sdio_hip_handshake)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, SDIO_HOST_INT, regs->sdio_host_int)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, COEX_STATUS, regs->coex_status)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, SHARED_IO_INTERRUPT, regs->shared_io_interrupt)) \
+ CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_RAM_OFFSET, prog_offset.ram)) \
+ CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_ROM_OFFSET, prog_offset.rom)) \
+ CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_FLASH_OFFSET, prog_offset.flash)) \
+ CHIP_HELPER_DEF0(m, (CsrUint32, PROGRAM_MEMORY_EXT_SRAM_OFFSET, prog_offset.ext_sram)) \
+ CHIP_HELPER_DEF0(m, (CsrUint16, DATA_MEMORY_RAM_OFFSET, data_offset.ram)) \
+ CHIP_HELPER_DEF0(m, (CsrInt32, HasFlash, bools.has_flash)) \
+ CHIP_HELPER_DEF0(m, (CsrInt32, HasExtSram, bools.has_ext_sram)) \
+ CHIP_HELPER_DEF0(m, (CsrInt32, HasRom, bools.has_rom)) \
+ CHIP_HELPER_DEF0(m, (CsrInt32, HasBt, bools.has_bt)) \
+ CHIP_HELPER_DEF0(m, (CsrInt32, HasWLan, bools.has_wlan)) \
+ CHIP_HELPER_DEF1(m, (CsrUint16, WINDOW_ADDRESS, enum chip_helper_window_index, window)) \
+ CHIP_HELPER_DEF1(m, (CsrUint16, WINDOW_SIZE, enum chip_helper_window_index, window)) \
+ CHIP_HELPER_DEF1(m, (CsrUint16, MapAddress_SPI2HOST, CsrUint16, addr)) \
+ CHIP_HELPER_DEF1(m, (CsrUint16, MapAddress_HOST2SPI, CsrUint16, addr)) \
+ CHIP_HELPER_DEF1(m, (CsrUint32, ClockStartupSequence, const struct chip_helper_init_values **, val)) \
+ CHIP_HELPER_DEF1(m, (CsrUint32, HostResetSequence, const struct chip_helper_reset_values **, val))
+
+/* Some magic to help the expansion */
+#define CHIP_HELPER_DEF0(a, b) \
+ CHIP_HELPER_DEF0_ ## a b
+#define CHIP_HELPER_DEF1(a, b) \
+ CHIP_HELPER_DEF1_ ## a b
+
+/* Macros so that when we expand the list we get "C" function prototypes. */
+#define CHIP_HELPER_DEF0_C_DEC(ret_type, name, info) \
+ ret_type ChipHelper_ ## name(ChipDescript * chip_help);
+#define CHIP_HELPER_DEF1_C_DEC(ret_type, name, type1, name1) \
+ ret_type ChipHelper_ ## name(ChipDescript * chip_help, type1 name1);
+
+CHIP_HELPER_LIST(C_DEC)
+
+/* FriendlyName
+ MarketingName
+
+ These two functions return human readable strings that describe
+ the chip. FriendlyName returns something that a software engineer
+ at CSR might understand. MarketingName returns something more like
+ an external name for a CSR chip.
+*/
+/* DBG_EMU_CMD
+ WATCHDOG_DISABLE
+ PROC_PC_SNOOP
+ GBL_CHIP_VERSION
+ XAP_PCH
+ XAP_PCL
+
+ These registers are used to control the XAPs.
+*/
+/* DBG_HOST_PROC_SELECT DBG_HOST_STOP_STATUS
+ HOST_WINDOW1_PAGE HOST_WINDOW2_PAGE HOST_WINDOW3_PAGE
+ HOST_IO_LOG_ADDR
+ DBG_SPI_PROC_SELECT DBG_SPI_STOP_STATUS
+ SPI_WINDOW1_PAGE SPI_WINDOW2_PAGE SPI_WINDOW3_PAGE
+ SPI_IO_LOG_ADDR
+
+ These register are used to control the XAPs and the memory
+ windows, normally while debugging the code on chip. There
+ are two versons of these registers, one for access via SPI
+ and another for access via the host interface.
+*/
+/* DBG_RESET
+ DBG_RESET_VALUE
+ DBG_RESET_WARN
+ DBG_RESET_WARN_VALUE
+ DBG_RESET_RESULT
+
+ These registers are used to reset the XAP. This can be
+ quite complex for some chips. If DBG_RESET_WARN is non
+ zero the DBG_RESET_WARN_VALUE should be written to address
+ DBG_RESET_WARN before the reset is perfeormed. DBG_RESET_VALUE
+ should then be written to DBG_RESET to make the reset happen.
+ The DBG_RESET_RESULT register should contain 0 if the reset
+ was successful.
+*/
+/* GBL_MISC_ENABLES
+
+ This register controls some special chip features. It
+ should be used with care is it changes quite a lot between
+ chip versions.
+*/
+/* MAILBOX0
+ MAILBOX1
+ MAILBOX2
+ MAILBOX3
+
+ The mailbox registers are for communication between the host
+ and the firmware. There use is described in part by the host
+ interface protcol specifcation.
+*/
+/* SDIO_HIP_HANDSHAKE
+
+ This is one of the more important SDIO HIP registers. On some
+ chips it has the same value as one of the mailbox registers
+ and on other chips it is different.
+*/
+/* SDIO_HOST_INT
+ SHARED_IO_INTERRUPT
+
+ These registers are used by some versions of the host interface
+ protocol specification. Their names should probably be changed
+ to hide the registers and to expose the functions more.
+*/
+/* COEX_STATUS
+
+ Coex status register, contains interrupt status and reset
+ pullup status. The latter is used to detect WAPI.
+*/
+/* PROGRAM_MEMORY_RAM_OFFSET
+ PROGRAM_MEMORY_ROM_OFFSET
+ PROGRAM_MEMORY_FLASH_OFFSET
+ PROGRAM_MEMORY_EXT_SRAM_OFFSET
+ DATA_MEMORY_RAM_OFFSET
+
+ These are constants that describe the offset of the different
+ memory types in the two different address spaces.
+*/
+/* HasFlash HasExtSram HasRom
+ HasBt HasWLan
+
+ These are a set of bools describing the chip.
+*/
+/* WINDOW_ADDRESS WINDOW_SIZE
+
+ These two functions return the size and address of the windows.
+ The address is the address of the lowest value in the address
+ map that is part of the window and the size is the number of
+ visible words.
+
+ Some of the windows have thier lowest portion covered by
+ registers. For these windows address is the first address
+ after the registers and size is the siave excluding the part
+ covered by registers.
+*/
+/* MapAddress_SPI2HOST
+ MapAddress_HOST2SPI
+
+ The debugging interface is duplicated on UniFi and later chips
+ so that there are two versions - one over the SPI interaface and
+ the other over the SDIO interface. These functions map the
+ registers between these two interfaces.
+*/
+/* ClockStartupSequence
+
+ This function returns the list of register value pairs that
+ should be forced into UniFi to enable SPI communication. This
+ set of registers is not needed if the firmware is running, but
+ will be needed if the device is being booted from cold. These
+ register writes enable the clocks and setup the PLL to a basic
+ working state. SPI access might be unreliable until these writes
+ have occured (And they may take mulitple goes).
+*/
+/* HostResetSequence
+
+ This returns a number of chunks of data and generic pointers.
+ All of the XAPs should be stopped. The data should be written
+ to the generic pointers. The instruction pointer for the MAC
+ should then be set to the start of program memory and then the
+ MAC should be "go"d. This will reset the chip in a reliable
+ and orderly manner without resetting the SDIO interface. It
+ is therefore not needed if the chip is being accessed by the
+ SPI interface (the DBG_RESET_ mechanism can be used instead).
+*/
+
+/* The Decode Window function is more complex. For the window
+ 'window' it tries to return the address and page register
+ value needed to see offset 'offset' of memory type 'type'.
+
+ It return 1 on success and 0 on failure. 'page' is what
+ should be written to the page register. 'addr' is the
+ address in the XAPs 16 address map to read from. 'len'
+ is the length that we can read without having to change
+ the page registers. */
+CsrInt32 ChipHelper_DecodeWindow(ChipDescript *chip_help,
+ enum chip_helper_window_index window,
+ enum chip_helper_window_type type,
+ CsrUint32 offset,
+ CsrUint16 *page, CsrUint16 *addr, CsrUint32 *len);
+
+#ifdef __cplusplus
+/* Close the extern "C" */
+}
+
+/*
+ * This is the C++ API.
+ */
+
+class ChipHelper
+{
+public:
+ /* If this constructor is used then a GetVersionXXX function
+ should be called next. */
+ ChipHelper();
+
+ /* copy constructor */
+ ChipHelper(ChipDescript * desc);
+
+ /* The default constructor assume a BC7 / UF105x series chip
+ and that the number given is the value of UNIFI_GBL_CHIP_VERSION
+ (0xFE81) */
+ ChipHelper(CsrUint16 version);
+
+ /* This returns the C interface magic token from a C++ instance. */
+ ChipDescript* GetDescript() const
+ {
+ return m_desc;
+ }
+
+
+ /* Clear out theis class (set it to the null token). */
+ void ClearVersion();
+
+ /* Load this class with data for a specific chip. */
+ void GetVersionAny(CsrUint16 from_FF9A, CsrUint16 from_FE81);
+ void GetVersionUniFi(CsrUint16 version);
+ void GetVersionBlueCore(chip_helper_bluecore_age age, CsrUint16 version);
+ void GetVersionSdio(CsrUint8 sdio_version);
+
+ /* Helpers to build the definitions of the member functions. */
+#define CHIP_HELPER_DEF0_CPP_DEC(ret_type, name, info) \
+ ret_type name() const;
+#define CHIP_HELPER_DEF1_CPP_DEC(ret_type, name, type1, name1) \
+ ret_type name(type1 name1) const;
+
+ CHIP_HELPER_LIST(CPP_DEC)
+
+
+ /* The DecodeWindow function, see the description of the C version. */
+ CsrInt32 DecodeWindow(chip_helper_window_index window,
+ chip_helper_window_type type,
+ CsrUint32 offset,
+ CsrUint16 &page, CsrUint16 &addr, CsrUint32 &len) const;
+
+private:
+ ChipDescript *m_desc;
+};
+
+#endif /* __cplusplus */
+
+#endif
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifndef CSR_WIFI_HIP_CHIPHELPER_PRIVATE_H__
+#define CSR_WIFI_HIP_CHIPHELPER_PRIVATE_H__
+
+
+#include "csr_wifi_hip_chiphelper.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* This GP stuff should be somewhere else? */
+
+/* Memory spaces encoded in top byte of Generic Pointer type */
+#define UNIFI_SH_DMEM 0x01 /* Shared Data Memory */
+#define UNIFI_EXT_FLASH 0x02 /* External FLASH */
+#define UNIFI_EXT_SRAM 0x03 /* External SRAM */
+#define UNIFI_REGISTERS 0x04 /* Registers */
+#define UNIFI_PHY_DMEM 0x10 /* PHY Data Memory */
+#define UNIFI_PHY_PMEM 0x11 /* PHY Program Memory */
+#define UNIFI_PHY_ROM 0x12 /* PHY ROM */
+#define UNIFI_MAC_DMEM 0x20 /* MAC Data Memory */
+#define UNIFI_MAC_PMEM 0x21 /* MAC Program Memory */
+#define UNIFI_MAC_ROM 0x22 /* MAC ROM */
+#define UNIFI_BT_DMEM 0x30 /* BT Data Memory */
+#define UNIFI_BT_PMEM 0x31 /* BT Program Memory */
+#define UNIFI_BT_ROM 0x32 /* BT ROM */
+
+#define MAKE_GP(R, O) (((UNIFI_ ## R) << 24) | (O))
+#define GP_OFFSET(GP) ((GP) & 0xFFFFFF)
+#define GP_SPACE(GP) (((GP) >> 24) & 0xFF)
+
+
+/* Address value pairs */
+struct val_array_t
+{
+ CsrUint32 len;
+ const struct chip_helper_init_values *vals;
+};
+
+/* Just a (counted) CsrUint16 array */
+struct data_array_t
+{
+ CsrUint32 len;
+ const CsrUint16 *vals;
+};
+
+struct reset_prog_t
+{
+ CsrUint32 len;
+ const struct chip_helper_reset_values *vals;
+};
+
+/* The addresses of registers that are equivalent but on
+ different host transports. */
+struct chip_map_address_t
+{
+ CsrUint16 spi, host;
+};
+
+struct map_array_t
+{
+ CsrUint32 len;
+ const struct chip_map_address_t *vals;
+};
+
+struct chip_device_regs_per_transport_t
+{
+ CsrUint16 dbg_proc_select;
+ CsrUint16 dbg_stop_status;
+ CsrUint16 window1_page; /* PROG_PMEM1 or GW1 */
+ CsrUint16 window2_page; /* PROG_PMEM2 or GW2 */
+ CsrUint16 window3_page; /* SHARED or GW3 */
+ CsrUint16 io_log_addr;
+};
+
+struct chip_device_regs_t
+{
+ CsrUint16 gbl_chip_version;
+ CsrUint16 gbl_misc_enables;
+ CsrUint16 dbg_emu_cmd;
+ struct chip_device_regs_per_transport_t host;
+ struct chip_device_regs_per_transport_t spi;
+ CsrUint16 dbg_reset;
+ CsrUint16 dbg_reset_value;
+ CsrUint16 dbg_reset_warn;
+ CsrUint16 dbg_reset_warn_value;
+ CsrUint16 dbg_reset_result;
+ CsrUint16 xap_pch;
+ CsrUint16 xap_pcl;
+ CsrUint16 proc_pc_snoop;
+ CsrUint16 watchdog_disable;
+ CsrUint16 mailbox0;
+ CsrUint16 mailbox1;
+ CsrUint16 mailbox2;
+ CsrUint16 mailbox3;
+ CsrUint16 sdio_host_int;
+ CsrUint16 shared_io_interrupt;
+ CsrUint16 sdio_hip_handshake;
+ CsrUint16 coex_status; /* Allows WAPI detection */
+};
+
+/* If allowed is false then this window does not provide this
+ type of access.
+ This describes how addresses should be shifted to make the
+ "page" address. The address is shifted left by 'page_shift'
+ and then has 'page_offset' added. This value should then be
+ written to the page register. */
+struct window_shift_info_t
+{
+ CsrInt32 allowed;
+ CsrUint32 page_shift;
+ CsrUint16 page_offset;
+};
+
+/* Each window has an address and size. These are obvious. It then
+ has a description for each type of memory that might be accessed
+ through it. There might also be a start to the offset of the window.
+ This means that that number of addresses at the start of the window
+ are unusable. */
+struct window_info_t
+{
+ CsrUint16 address;
+ CsrUint16 size;
+ CsrUint16 blocked;
+ const struct window_shift_info_t *mode;
+};
+
+/* If GBL_CHIP_VERSION and'ed with 'mask' and is equal to 'result'
+ then this is the correct set of info. If pre_bc7 is true then the
+ address of GBL_CHIP_VERSION is FF9A, else its FE81. */
+struct chip_version_t
+{
+ CsrInt32 pre_bc7;
+ CsrUint16 mask;
+ CsrUint16 result;
+ CsrUint8 sdio;
+};
+
+struct chip_device_desc_t
+{
+ struct chip_version_t chip_version;
+
+ /* This is a text string that a human might find useful (BC02, UF105x) */
+ const CsrCharString *friendly_name;
+ /* This is what we show to customers */
+ const CsrCharString *marketing_name;
+
+ /* Initialisation values to write following a reset */
+ struct val_array_t init;
+
+ /* Binary sequence for hard reset */
+ struct reset_prog_t reset_prog;
+
+ /* The register map */
+ const struct chip_device_regs_t *regs;
+
+ /* Some misc. info on the chip */
+ struct
+ {
+ CsrUint32 has_flash : 1;
+ CsrUint32 has_ext_sram : 1;
+ CsrUint32 has_rom : 1;
+ CsrUint32 has_bt : 1;
+ CsrUint32 has_wlan : 1;
+ } bools;
+
+ /* This table is used to remap register addresses depending on what
+ host interface is used. On the BC7 and later chips there are
+ multiple sets of memory window registers, on for each host
+ interafce (SDIO / SPI). The correct one is needed. */
+ struct map_array_t map;
+
+ /* The offsets into the program address space of the different types of memory.
+ The RAM offset is probably the most useful. */
+ struct
+ {
+ CsrUint32 ram;
+ CsrUint32 rom;
+ CsrUint32 flash;
+ CsrUint32 ext_sram;
+ } prog_offset;
+
+ /* The offsets into the data address space of interesting things. */
+ struct
+ {
+ CsrUint16 ram;
+ /* maybe add shared / page tables? */
+ } data_offset;
+
+ /* Information on the different windows */
+ const struct window_info_t *windows[CHIP_HELPER_WINDOW_COUNT];
+};
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* CSR_WIFI_HIP_CHIPHELPER_PRIVATE_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * FILE: csr_wifi_hip_conversions.h
+ *
+ * PURPOSE:
+ * This header file provides the macros for converting to and from
+ * wire format.
+ * These macros *MUST* work for little-endian AND big-endian hosts.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#ifndef __CSR_WIFI_HIP_CONVERSIONS_H__
+#define __CSR_WIFI_HIP_CONVERSIONS_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SIZEOF_UINT16 2
+#define SIZEOF_UINT32 4
+#define SIZEOF_UINT64 8
+
+#define SIZEOF_SIGNAL_HEADER 6
+#define SIZEOF_DATAREF 4
+
+
+/*
+ * Macro to retrieve the signal ID from a wire-format signal.
+ */
+#define GET_SIGNAL_ID(_buf) CSR_GET_UINT16_FROM_LITTLE_ENDIAN((_buf))
+
+/*
+ * Macros to retrieve and set the DATAREF fields in a packed (i.e. wire-format)
+ * HIP signal.
+ */
+#define GET_PACKED_DATAREF_SLOT(_buf, _ref) \
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(((_buf) + SIZEOF_SIGNAL_HEADER + ((_ref) * SIZEOF_DATAREF) + 0))
+
+#define GET_PACKED_DATAREF_LEN(_buf, _ref) \
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(((_buf) + SIZEOF_SIGNAL_HEADER + ((_ref) * SIZEOF_DATAREF) + 2))
+
+#define SET_PACKED_DATAREF_SLOT(_buf, _ref, _slot) \
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN((_slot), ((_buf) + SIZEOF_SIGNAL_HEADER + ((_ref) * SIZEOF_DATAREF) + 0))
+
+#define SET_PACKED_DATAREF_LEN(_buf, _ref, _len) \
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN((_len), ((_buf) + SIZEOF_SIGNAL_HEADER + ((_ref) * SIZEOF_DATAREF) + 2))
+
+#define GET_PACKED_MA_PACKET_REQUEST_FRAME_PRIORITY(_buf) \
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(((_buf) + SIZEOF_SIGNAL_HEADER + UNIFI_MAX_DATA_REFERENCES * SIZEOF_DATAREF + 8))
+
+#define GET_PACKED_MA_PACKET_REQUEST_HOST_TAG(_buf) \
+ CSR_GET_UINT32_FROM_LITTLE_ENDIAN(((_buf) + SIZEOF_SIGNAL_HEADER + UNIFI_MAX_DATA_REFERENCES * SIZEOF_DATAREF + 4))
+
+#define GET_PACKED_MA_PACKET_CONFIRM_HOST_TAG(_buf) \
+ CSR_GET_UINT32_FROM_LITTLE_ENDIAN(((_buf) + SIZEOF_SIGNAL_HEADER + UNIFI_MAX_DATA_REFERENCES * SIZEOF_DATAREF + 8))
+
+#define GET_PACKED_MA_PACKET_CONFIRM_TRANSMISSION_STATUS(_buf) \
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(((_buf) + SIZEOF_SIGNAL_HEADER + UNIFI_MAX_DATA_REFERENCES * SIZEOF_DATAREF + 2))
+
+
+CsrInt32 get_packed_struct_size(const CsrUint8 *buf);
+CsrResult read_unpack_signal(const CsrUint8 *ptr, CSR_SIGNAL *sig);
+CsrResult write_pack(const CSR_SIGNAL *sig, CsrUint8 *ptr, CsrUint16 *sig_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CSR_WIFI_HIP_CONVERSIONS_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_download.c
+ *
+ * PURPOSE:
+ * Routines for downloading firmware to UniFi.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_unifiversion.h"
+#include "csr_wifi_hip_card.h"
+#include "csr_wifi_hip_xbv.h"
+
+#undef CSR_WIFI_IGNORE_PATCH_VERSION_MISMATCH
+
+static CsrResult do_patch_download(card_t *card, void *dlpriv,
+ xbv1_t *pfwinfo, CsrUint32 boot_ctrl_addr);
+
+static CsrResult do_patch_convert_download(card_t *card,
+ void *dlpriv, xbv1_t *pfwinfo);
+
+/*
+ * ---------------------------------------------------------------------------
+ * _find_in_slut
+ *
+ * Find the offset of the appropriate object in the SLUT of a card
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * psym Pointer to symbol object.
+ * id set up by caller
+ * obj will be set up by this function
+ * pslut Pointer to SLUT address, if 0xffffffff then it must be
+ * read from the chip.
+ * Returns:
+ * CSR_RESULT_SUCCESS on success
+ * Non-zero on error,
+ * CSR_WIFI_HIP_RESULT_NOT_FOUND if not found
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult _find_in_slut(card_t *card, symbol_t *psym, CsrUint32 *pslut)
+{
+ CsrUint32 slut_address;
+ CsrUint16 finger_print;
+ CsrResult r;
+ CsrResult csrResult;
+
+ /* Get SLUT address */
+ if (*pslut == 0xffffffff)
+ {
+ r = card_wait_for_firmware_to_start(card, &slut_address);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Firmware hasn't started\n");
+ func_exit_r(r);
+ return r;
+ }
+ *pslut = slut_address;
+
+ /*
+ * Firmware has started so set the SDIO bus clock to the initial speed,
+ * faster than UNIFI_SDIO_CLOCK_SAFE_HZ, to speed up the f/w download.
+ */
+ csrResult = CsrSdioMaxBusClockFrequencySet(card->sdio_if, UNIFI_SDIO_CLOCK_INIT_HZ);
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ r = ConvertCsrSdioToCsrHipResult(card, csrResult);
+ func_exit_r(r);
+ return r;
+ }
+ card->sdio_clock_speed = UNIFI_SDIO_CLOCK_INIT_HZ;
+ }
+ else
+ {
+ slut_address = *pslut; /* Use previously discovered address */
+ }
+ unifi_trace(card->ospriv, UDBG4, "SLUT addr: 0x%lX\n", slut_address);
+
+ /*
+ * Check the SLUT fingerprint.
+ * The slut_address is a generic pointer so we must use unifi_card_read16().
+ */
+ unifi_trace(card->ospriv, UDBG4, "Looking for SLUT finger print\n");
+ finger_print = 0;
+ r = unifi_card_read16(card, slut_address, &finger_print);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read SLUT finger print\n");
+ func_exit_r(r);
+ return r;
+ }
+
+ if (finger_print != SLUT_FINGERPRINT)
+ {
+ unifi_error(card->ospriv, "Failed to find SLUT fingerprint\n");
+ func_exit_r(CSR_RESULT_FAILURE);
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Symbol table starts imedately after the fingerprint */
+ slut_address += 2;
+
+ while (1)
+ {
+ CsrUint16 id;
+ CsrUint32 obj;
+
+ r = unifi_card_read16(card, slut_address, &id);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ func_exit_r(r);
+ return r;
+ }
+ slut_address += 2;
+
+ if (id == CSR_SLT_END)
+ {
+ /* End of table reached: not found */
+ r = CSR_WIFI_HIP_RESULT_RANGE;
+ break;
+ }
+
+ r = unifi_read32(card, slut_address, &obj);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ func_exit_r(r);
+ return r;
+ }
+ slut_address += 4;
+
+ unifi_trace(card->ospriv, UDBG3, " found SLUT id %02d.%08lx\n", id, obj);
+
+ r = CSR_WIFI_HIP_RESULT_NOT_FOUND;
+ /* Found search term? */
+ if (id == psym->id)
+ {
+ unifi_trace(card->ospriv, UDBG1, " matched SLUT id %02d.%08lx\n", id, obj);
+ psym->obj = obj;
+ r = CSR_RESULT_SUCCESS;
+ break;
+ }
+ }
+
+ func_exit_r(r);
+ return r;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * do_patch_convert_download
+ *
+ * Download the given firmware image to the UniFi, converting from FWDL
+ * to PTDL XBV format.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * dlpriv Pointer to source firmware image
+ * fwinfo Pointer to source firmware info struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error code on error
+ *
+ * Notes:
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult do_patch_convert_download(card_t *card, void *dlpriv, xbv1_t *pfwinfo)
+{
+ CsrResult r;
+ CsrUint32 slut_base = 0xffffffff;
+ void *pfw;
+ CsrUint32 psize;
+ symbol_t sym;
+
+ /* Reset the chip to guarantee that the ROM loader is running */
+ r = unifi_init(card);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv,
+ "do_patch_convert_download: failed to re-init UniFi\n");
+ return r;
+ }
+
+ /* If no unifi_helper is running, the firmware version must be read */
+ if (card->build_id == 0)
+ {
+ CsrUint32 ver = 0;
+ sym.id = CSR_SLT_BUILD_ID_NUMBER;
+ sym.obj = 0; /* To be updated by _find_in_slut() */
+
+ unifi_trace(card->ospriv, UDBG1, "Need f/w version\n");
+
+ /* Find chip build id entry in SLUT */
+ r = _find_in_slut(card, &sym, &slut_base);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to find CSR_SLT_BUILD_ID_NUMBER\n");
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Read running f/w version */
+ r = unifi_read32(card, sym.obj, &ver);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read f/w id\n");
+ return CSR_RESULT_FAILURE;
+ }
+ card->build_id = ver;
+ }
+
+ /* Convert the ptest firmware to a patch against the running firmware */
+ pfw = xbv_to_patch(card, unifi_fw_read, dlpriv, pfwinfo, &psize);
+ if (!pfw)
+ {
+ unifi_error(card->ospriv, "Failed to convert f/w to patch");
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+ }
+ else
+ {
+ void *desc;
+ sym.id = CSR_SLT_BOOT_LOADER_CONTROL;
+ sym.obj = 0; /* To be updated by _find_in_slut() */
+
+ /* Find boot loader control entry in SLUT */
+ r = _find_in_slut(card, &sym, &slut_base);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to find BOOT_LOADER_CONTROL\n");
+ return CSR_RESULT_FAILURE;
+ }
+
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to wake UniFi\n");
+ }
+
+ /* Get a dlpriv for the patch buffer so that unifi_fw_read() can
+ * access it.
+ */
+ desc = unifi_fw_open_buffer(card->ospriv, pfw, psize);
+ if (!desc)
+ {
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+ }
+
+ /* Download the patch */
+ unifi_info(card->ospriv, "Downloading converted f/w as patch\n");
+ r = unifi_dl_patch(card, desc, sym.obj);
+ CsrMemFree(pfw);
+ unifi_fw_close_buffer(card->ospriv, desc);
+
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Converted patch download failed\n");
+ func_exit_r(r);
+ return r;
+ }
+ else
+ {
+ unifi_trace(card->ospriv, UDBG1, "Converted patch downloaded\n");
+ }
+
+ /* This command starts the firmware */
+ r = unifi_do_loader_op(card, sym.obj + 6, UNIFI_BOOT_LOADER_RESTART);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write loader restart cmd\n");
+ }
+
+ func_exit_r(r);
+ return r;
+ }
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_dl_firmware
+ *
+ * Download the given firmware image to the UniFi.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * dlpriv A context pointer from the calling function to be
+ * passed when calling unifi_fw_read().
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success,
+ * CSR_WIFI_HIP_RESULT_NO_MEMORY memory allocation failed
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE error in XBV file
+ * CSR_RESULT_FAILURE SDIO error
+ *
+ * Notes:
+ * Stops and resets the chip, does the download and runs the new
+ * firmware.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_dl_firmware(card_t *card, void *dlpriv)
+{
+ xbv1_t *fwinfo;
+ CsrResult r;
+
+ func_enter();
+
+ fwinfo = CsrMemAlloc(sizeof(xbv1_t));
+ if (fwinfo == NULL)
+ {
+ unifi_error(card->ospriv, "Failed to allocate memory for firmware\n");
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+ }
+
+ /*
+ * Scan the firmware file to find the TLVs we are interested in.
+ * These are:
+ * - check we support the file format version in VERF
+ * - SLTP Symbol Lookup Table Pointer
+ * - FWDL firmware download segments
+ * - FWOV firmware overlay segment
+ * - VMEQ Register probe tests to verify matching h/w
+ */
+ r = xbv1_parse(card, unifi_fw_read, dlpriv, fwinfo);
+ if (r != CSR_RESULT_SUCCESS || fwinfo->mode != xbv_firmware)
+ {
+ unifi_error(card->ospriv, "File type is %s, expected firmware.\n",
+ fwinfo->mode == xbv_patch?"patch" : "unknown");
+ CsrMemFree(fwinfo);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ /* UF6xxx doesn't accept firmware, only patches. Therefore we convert
+ * the file to patch format with version numbers matching the current
+ * running firmware, and then download via the patch mechanism.
+ * The sole purpose of this is to support production test firmware across
+ * different ROM releases, the test firmware being provided in non-patch
+ * format.
+ */
+ if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
+ {
+ unifi_info(card->ospriv, "Must convert f/w to patch format\n");
+ r = do_patch_convert_download(card, dlpriv, fwinfo);
+ }
+ else
+ {
+ /* Older UniFi chips allowed firmware to be directly loaded onto the
+ * chip, which is no longer supported.
+ */
+ unifi_error(card->ospriv, "Only patch downloading supported\n");
+ r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ CsrMemFree(fwinfo);
+ func_exit_r(r);
+ return r;
+} /* unifi_dl_firmware() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_dl_patch
+ *
+ * Load the given patch set into UniFi.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * dlpriv The os specific handle to the firmware file.
+ * boot_ctrl The address of the boot loader control structure.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success,
+ * CSR_WIFI_HIP_RESULT_NO_MEMORY memory allocation failed
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE error in XBV file
+ * CSR_RESULT_FAILURE SDIO error
+ *
+ * Notes:
+ * This ends up telling UniFi to restart.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_dl_patch(card_t *card, void *dlpriv, CsrUint32 boot_ctrl)
+{
+ xbv1_t *fwinfo;
+ CsrResult r;
+
+ func_enter();
+
+ unifi_info(card->ospriv, "unifi_dl_patch %p %08x\n", dlpriv, boot_ctrl);
+
+ fwinfo = CsrMemAlloc(sizeof(xbv1_t));
+ if (fwinfo == NULL)
+ {
+ unifi_error(card->ospriv, "Failed to allocate memory for patches\n");
+ func_exit();
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+ }
+
+ /*
+ * Scan the firmware file to find the TLVs we are interested in.
+ * These are:
+ * - check we support the file format version in VERF
+ * - FWID The build ID of the ROM that we can patch
+ * - PTDL patch download segments
+ */
+ r = xbv1_parse(card, unifi_fw_read, dlpriv, fwinfo);
+ if (r != CSR_RESULT_SUCCESS || fwinfo->mode != xbv_patch)
+ {
+ CsrMemFree(fwinfo);
+ unifi_error(card->ospriv, "Failed to read in patch file\n");
+ func_exit();
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ /*
+ * We have to check the build id read from the SLUT against that
+ * for the patch file. They have to match exactly.
+ * "card->build_id" == XBV1.PTCH.FWID
+ */
+ if (card->build_id != fwinfo->build_id)
+ {
+ unifi_error(card->ospriv, "Wrong patch file for chip (chip = %lu, file = %lu)\n",
+ card->build_id, fwinfo->build_id);
+ CsrMemFree(fwinfo);
+#ifndef CSR_WIFI_IGNORE_PATCH_VERSION_MISMATCH
+ func_exit();
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+#else
+ fwinfo = NULL;
+ dlpriv = NULL;
+ return CSR_RESULT_SUCCESS;
+#endif
+ }
+
+ r = do_patch_download(card, dlpriv, fwinfo, boot_ctrl);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to patch image\n");
+ }
+
+ CsrMemFree(fwinfo);
+
+ func_exit_r(r);
+ return r;
+} /* unifi_dl_patch() */
+
+
+void* unifi_dl_fw_read_start(card_t *card, CsrInt8 is_fw)
+{
+ card_info_t card_info;
+
+ unifi_card_info(card, &card_info);
+ unifi_trace(card->ospriv, UDBG5,
+ "id=%d, ver=0x%x, fw_build=%u, fw_hip=0x%x, block_size=%d\n",
+ card_info.chip_id, card_info.chip_version,
+ card_info.fw_build, card_info.fw_hip_version,
+ card_info.sdio_block_size);
+
+ return unifi_fw_read_start(card->ospriv, is_fw, &card_info);
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * safe_read_shared_location
+ *
+ * Read a shared memory location repeatedly until we get two readings
+ * the same.
+ *
+ * Arguments:
+ * card Pointer to card context struct.
+ * unifi_addr UniFi shared-data-memory address to access.
+ * pdata Pointer to a byte variable for the value read.
+ *
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error code on failure
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult safe_read_shared_location(card_t *card, CsrUint32 address, CsrUint8 *pdata)
+{
+ CsrResult r;
+ CsrUint16 limit = 1000;
+ CsrUint8 b, b2;
+
+ *pdata = 0;
+
+ r = unifi_read_8_or_16(card, address, &b);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ while (limit--)
+ {
+ r = unifi_read_8_or_16(card, address, &b2);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ return r;
+ }
+
+ /* When we have a stable value, return it */
+ if (b == b2)
+ {
+ *pdata = b;
+ return CSR_RESULT_SUCCESS;
+ }
+
+ b = b2;
+ }
+
+ return CSR_RESULT_FAILURE;
+} /* safe_read_shared_location() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_do_loader_op
+ *
+ * Send a loader / boot_loader command to the UniFi and wait for
+ * it to complete.
+ *
+ * Arguments:
+ * card Pointer to card context struct.
+ * op_addr The address of the loader operation control word.
+ * opcode The operation to perform.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success
+ * CSR_RESULT_FAILURE SDIO error or SDIO/XAP timeout
+ * ---------------------------------------------------------------------------
+ */
+
+/*
+ * Ideally instead of sleeping, we want to busy wait.
+ * Currently there is no framework API to do this. When it becomes available,
+ * we can use it to busy wait using usecs
+ */
+#define OPERATION_TIMEOUT_LOOPS (100) /* when OPERATION_TIMEOUT_DELAY==1, (500) otherwise */
+#define OPERATION_TIMEOUT_DELAY 1 /* msec, or 200usecs */
+
+CsrResult unifi_do_loader_op(card_t *card, CsrUint32 op_addr, CsrUint8 opcode)
+{
+ CsrResult r;
+ CsrInt16 op_retries;
+
+ unifi_trace(card->ospriv, UDBG4, "Loader cmd 0x%0x -> 0x%08x\n", opcode, op_addr);
+
+ /* Set the Operation command byte to the opcode */
+ r = unifi_write_8_or_16(card, op_addr, opcode);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to write loader copy command\n");
+ return r;
+ }
+
+ /* Wait for Operation command byte to be Idle */
+ /* Typically takes ~100us */
+ op_retries = 0;
+ r = CSR_RESULT_SUCCESS;
+ while (1)
+ {
+ CsrUint8 op;
+
+ /*
+ * Read the memory location until two successive reads give
+ * the same value.
+ * Then handle it.
+ */
+ r = safe_read_shared_location(card, op_addr, &op);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to read loader status\n");
+ break;
+ }
+
+ if (op == UNIFI_LOADER_IDLE)
+ {
+ /* Success */
+ break;
+ }
+
+ if (op != opcode)
+ {
+ unifi_error(card->ospriv, "Error reported by loader: 0x%X\n", op);
+ r = CSR_RESULT_FAILURE;
+ break;
+ }
+
+ /* Allow 500us timeout */
+ if (++op_retries >= OPERATION_TIMEOUT_LOOPS)
+ {
+ unifi_error(card->ospriv, "Timeout waiting for loader to ack transfer\n");
+ /* Stop XAPs to aid post-mortem */
+ r = unifi_card_stop_processor(card, UNIFI_PROC_BOTH);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to stop UniFi processors\n");
+ }
+ else
+ {
+ r = CSR_RESULT_FAILURE;
+ }
+ break;
+ }
+ CsrThreadSleep(OPERATION_TIMEOUT_DELAY);
+ } /* Loop exits with r != CSR_RESULT_SUCCESS on error */
+
+ return r;
+} /* unifi_do_loader_op() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * send_ptdl_to_unifi
+ *
+ * Copy a patch block from userland to the UniFi.
+ * This function reads data, 2K at a time, from userland and writes
+ * it to the UniFi.
+ *
+ * Arguments:
+ * card A pointer to the card structure
+ * dlpriv The os specific handle for the firmware file
+ * ptdl A pointer ot the PTDL block
+ * handle The buffer handle to use for the xfer
+ * op_addr The address of the loader operation control word
+ *
+ * Returns:
+ * Number of bytes sent (Positive) or negative value indicating
+ * error code:
+ * CSR_WIFI_HIP_RESULT_NO_MEMORY memory allocation failed
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE error in XBV file
+ * CSR_RESULT_FAILURE SDIO error
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult send_ptdl_to_unifi(card_t *card, void *dlpriv,
+ const struct PTDL *ptdl, CsrUint32 handle,
+ CsrUint32 op_addr)
+{
+ CsrUint32 offset;
+ CsrUint8 *buf;
+ CsrInt32 data_len;
+ CsrUint32 write_len;
+ CsrResult r;
+ const CsrUint16 buf_size = 2 * 1024;
+
+ offset = ptdl->dl_offset;
+ data_len = ptdl->dl_size;
+
+ if (data_len > buf_size)
+ {
+ unifi_error(card->ospriv, "PTDL block is too large (%u)\n",
+ ptdl->dl_size);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ buf = CsrMemAllocDma(buf_size);
+ if (buf == NULL)
+ {
+ unifi_error(card->ospriv, "Failed to allocate transfer buffer for firmware download\n");
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+ }
+
+ r = CSR_RESULT_SUCCESS;
+
+ if (unifi_fw_read(card->ospriv, dlpriv, offset, buf, data_len) != data_len)
+ {
+ unifi_error(card->ospriv, "Failed to read from file\n");
+ }
+ else
+ {
+ /* We can always round these if the host wants to */
+ if (card->sdio_io_block_pad)
+ {
+ write_len = (data_len + (card->sdio_io_block_size - 1)) &
+ ~(card->sdio_io_block_size - 1);
+
+ /* Zero out the rest of the buffer (This isn't needed, but it
+ * makes debugging things later much easier). */
+ CsrMemSet(buf + data_len, 0, write_len - data_len);
+ }
+ else
+ {
+ write_len = data_len;
+ }
+
+ r = unifi_bulk_rw_noretry(card, handle, buf, write_len, UNIFI_SDIO_WRITE);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "CMD53 failed writing %d bytes to handle %ld\n",
+ data_len, handle);
+ }
+ else
+ {
+ /*
+ * Can change the order of things to overlap read from file
+ * with copy to unifi
+ */
+ r = unifi_do_loader_op(card, op_addr, UNIFI_BOOT_LOADER_PATCH);
+ }
+ }
+
+ CsrMemFreeDma(buf);
+
+ if (r != CSR_RESULT_SUCCESS && r != CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ unifi_error(card->ospriv, "Failed to copy block of %u bytes to UniFi\n",
+ ptdl->dl_size);
+ }
+
+ return r;
+} /* send_ptdl_to_unifi() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * do_patch_download
+ *
+ * This function downloads a set of patches to UniFi and then
+ * causes it to restart.
+ *
+ * Arguments:
+ * card Pointer to card struct.
+ * dlpriv A context pointer from the calling function to be
+ * used when reading the XBV file. This can be NULL
+ * in which case not patches are applied.
+ * pfwinfo Pointer to a fwinfo struct describing the f/w
+ * XBV file.
+ * boot_ctrl_addr The address of the boot loader control structure.
+ *
+ * Returns:
+ * 0 on success, or an error code
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE for a bad laoader version number
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult do_patch_download(card_t *card, void *dlpriv, xbv1_t *pfwinfo, CsrUint32 boot_ctrl_addr)
+{
+ CsrResult r;
+ CsrInt32 i;
+ CsrUint16 loader_version;
+ CsrUint16 handle;
+ CsrUint32 total_bytes;
+
+ /*
+ * Read info from the SDIO Loader Control Data Structure
+ */
+ /* Check the loader version */
+ r = unifi_card_read16(card, boot_ctrl_addr, &loader_version);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Patch download: Failed to read loader version\n");
+ return r;
+ }
+ unifi_trace(card->ospriv, UDBG2, "Patch download: boot loader version 0x%04X\n", loader_version);
+ switch (loader_version)
+ {
+ case 0x0000:
+ break;
+
+ default:
+ unifi_error(card->ospriv, "Patch loader version (0x%04X) is not supported by this driver\n",
+ loader_version);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ /* Retrieve the handle to use with CMD53 */
+ r = unifi_card_read16(card, boot_ctrl_addr + 4, &handle);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Patch download: Failed to read loader handle\n");
+ return r;
+ }
+
+ /* Set the mask of LEDs to flash */
+ if (card->loader_led_mask)
+ {
+ r = unifi_card_write16(card, boot_ctrl_addr + 2,
+ (CsrUint16)card->loader_led_mask);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Patch download: Failed to write LED mask\n");
+ return r;
+ }
+ }
+
+ total_bytes = 0;
+
+ /* Copy download data to UniFi memory */
+ for (i = 0; i < pfwinfo->num_ptdl; i++)
+ {
+ unifi_trace(card->ospriv, UDBG3, "Patch download: %d Downloading for %d from offset %d\n",
+ i,
+ pfwinfo->ptdl[i].dl_size,
+ pfwinfo->ptdl[i].dl_offset);
+
+ r = send_ptdl_to_unifi(card, dlpriv, &pfwinfo->ptdl[i],
+ handle, boot_ctrl_addr + 6);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ return r;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Patch failed after %u bytes\n",
+ total_bytes);
+ return r;
+ }
+ total_bytes += pfwinfo->ptdl[i].dl_size;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* do_patch_download() */
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_dump.c
+ *
+ * PURPOSE:
+ * Routines for retrieving and buffering core status from the UniFi
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_unifiversion.h"
+#include "csr_wifi_hip_card.h"
+
+/* Locations to capture in dump (XAP words) */
+#define HIP_CDUMP_FIRST_CPUREG (0xFFE0) /* First CPU register */
+#define HIP_CDUMP_FIRST_LO (0) /* Start of low address range */
+#define HIP_CDUMP_FIRST_HI_MAC (0x3C00) /* Start of MAC high area */
+#define HIP_CDUMP_FIRST_HI_PHY (0x1C00) /* Start of PHY high area */
+#define HIP_CDUMP_FIRST_SH (0) /* Start of shared memory area */
+
+#define HIP_CDUMP_NCPUREGS (10) /* No. of 16-bit XAP registers */
+#define HIP_CDUMP_NWORDS_LO (0x0100) /* Low area size in 16-bit words */
+#define HIP_CDUMP_NWORDS_HI (0x0400) /* High area size in 16-bit words */
+#define HIP_CDUMP_NWORDS_SH (0x0500) /* Shared memory area size, 16-bit words */
+
+#define HIP_CDUMP_NUM_ZONES 7 /* Number of UniFi memory areas to capture */
+
+/* Mini-coredump state */
+typedef struct coredump_buf
+{
+ CsrUint16 count; /* serial number of dump */
+ CsrTime timestamp; /* host's system time at capture */
+ CsrInt16 requestor; /* request: 0=auto dump, 1=manual */
+ CsrUint16 chip_ver;
+ CsrUint32 fw_ver;
+ CsrUint16 *zone[HIP_CDUMP_NUM_ZONES];
+
+ struct coredump_buf *next; /* circular list */
+ struct coredump_buf *prev; /* circular list */
+} coredump_buffer;
+
+/* Structure used to describe a zone of chip memory captured by mini-coredump */
+struct coredump_zone
+{
+ unifi_coredump_space_t space; /* XAP memory space this zone covers */
+ enum unifi_dbg_processors_select cpu; /* XAP CPU core selector */
+ CsrUint32 gp; /* Generic Pointer to memory zone on XAP */
+ CsrUint16 offset; /* 16-bit XAP word offset of zone in memory space */
+ CsrUint16 length; /* Length of zone in XAP words */
+};
+
+static CsrResult unifi_coredump_from_sdio(card_t *card, coredump_buffer *dump_buf);
+static CsrResult unifi_coredump_read_zones(card_t *card, coredump_buffer *dump_buf);
+static CsrResult unifi_coredump_read_zone(card_t *card, CsrUint16 *zone,
+ const struct coredump_zone *def);
+static CsrInt32 get_value_from_coredump(const coredump_buffer *dump,
+ const unifi_coredump_space_t space, const CsrUint16 offset);
+
+/* Table of chip memory zones we capture on mini-coredump */
+static const struct coredump_zone zonedef_table[HIP_CDUMP_NUM_ZONES] = {
+ { UNIFI_COREDUMP_MAC_REG, UNIFI_PROC_MAC, UNIFI_MAKE_GP(REGISTERS, HIP_CDUMP_FIRST_CPUREG * 2), HIP_CDUMP_FIRST_CPUREG, HIP_CDUMP_NCPUREGS },
+ { UNIFI_COREDUMP_PHY_REG, UNIFI_PROC_PHY, UNIFI_MAKE_GP(REGISTERS, HIP_CDUMP_FIRST_CPUREG * 2), HIP_CDUMP_FIRST_CPUREG, HIP_CDUMP_NCPUREGS },
+ { UNIFI_COREDUMP_SH_DMEM, UNIFI_PROC_INVALID, UNIFI_MAKE_GP(SH_DMEM, HIP_CDUMP_FIRST_SH * 2), HIP_CDUMP_FIRST_SH, HIP_CDUMP_NWORDS_SH },
+ { UNIFI_COREDUMP_MAC_DMEM, UNIFI_PROC_MAC, UNIFI_MAKE_GP(MAC_DMEM, HIP_CDUMP_FIRST_LO * 2), HIP_CDUMP_FIRST_LO, HIP_CDUMP_NWORDS_LO },
+ { UNIFI_COREDUMP_MAC_DMEM, UNIFI_PROC_MAC, UNIFI_MAKE_GP(MAC_DMEM, HIP_CDUMP_FIRST_HI_MAC * 2), HIP_CDUMP_FIRST_HI_MAC, HIP_CDUMP_NWORDS_HI },
+ { UNIFI_COREDUMP_PHY_DMEM, UNIFI_PROC_PHY, UNIFI_MAKE_GP(PHY_DMEM, HIP_CDUMP_FIRST_LO * 2), HIP_CDUMP_FIRST_LO, HIP_CDUMP_NWORDS_LO },
+ { UNIFI_COREDUMP_PHY_DMEM, UNIFI_PROC_PHY, UNIFI_MAKE_GP(PHY_DMEM, HIP_CDUMP_FIRST_HI_PHY * 2), HIP_CDUMP_FIRST_HI_PHY, HIP_CDUMP_NWORDS_HI },
+};
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_coredump_request_at_next_reset
+ *
+ * Request that a mini-coredump is performed when the driver has
+ * completed resetting the UniFi device.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * enable If non-zero, sets the request.
+ * If zero, cancels any pending request.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS or CSR HIP error code
+ *
+ * Notes:
+ * This function is typically called once the driver has detected that
+ * the UniFi device has become unresponsive due to crash, or internal
+ * watchdog reset. The driver must reset it to regain communication and,
+ * immediately after that, the mini-coredump can be captured.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_coredump_request_at_next_reset(card_t *card, CsrInt8 enable)
+{
+ CsrResult r;
+
+ func_enter();
+
+ if (enable)
+ {
+ unifi_trace(card->ospriv, UDBG2, "Mini-coredump requested after reset\n");
+ }
+
+ if (card == NULL)
+ {
+ r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ else
+ {
+ card->request_coredump_on_reset = enable?1 : 0;
+ r = CSR_RESULT_SUCCESS;
+ }
+
+ func_exit_r(r);
+ return r;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_coredump_handle_request
+ *
+ * Performs a coredump now, if one was requested, and clears the request.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS or CSR HIP error code
+ *
+ * Notes:
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_coredump_handle_request(card_t *card)
+{
+ CsrResult r = CSR_RESULT_SUCCESS;
+
+ func_enter();
+
+ if (card == NULL)
+ {
+ r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ else
+ {
+ if (card->request_coredump_on_reset == 1)
+ {
+ card->request_coredump_on_reset = 0;
+ r = unifi_coredump_capture(card, NULL);
+ }
+ }
+
+ func_exit_r(r);
+ return r;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_coredump_capture
+ *
+ * Capture the current status of the UniFi device.
+ * Various registers are buffered for future offline inspection.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * req Pointer to request struct, or NULL:
+ * A coredump requested manually by the user app
+ * will have a request struct pointer, an automatic
+ * coredump will have a NULL pointer.
+ * Returns:
+ * CSR_RESULT_SUCCESS on success,
+ * CSR_RESULT_FAILURE SDIO error
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE Initialisation not complete
+ *
+ * Notes:
+ * The result is a filled entry in the circular buffer of core dumps,
+ * values from which can be extracted to userland via an ioctl.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_coredump_capture(card_t *card, struct unifi_coredump_req *req)
+{
+ CsrResult r = CSR_RESULT_SUCCESS;
+ static CsrUint16 dump_seq_no = 1;
+ CsrTime time_of_capture;
+
+ func_enter();
+
+ if (card->dump_next_write == NULL)
+ {
+ r = CSR_RESULT_SUCCESS;
+ goto done;
+ }
+
+ /* Reject forced capture before initialisation has happened */
+ if (card->helper == NULL)
+ {
+ r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ goto done;
+ }
+
+
+ /*
+ * Force a mini-coredump capture right now
+ */
+ time_of_capture = CsrTimeGet(NULL);
+ unifi_info(card->ospriv, "Mini-coredump capture at t=%u\n", time_of_capture);
+
+ /* Wake up the processors so we can talk to them */
+ r = unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to wake UniFi\n");
+ goto done;
+ }
+ CsrThreadSleep(20);
+
+ /* Stop both XAPs */
+ unifi_trace(card->ospriv, UDBG4, "Stopping XAPs for coredump capture\n");
+ r = unifi_card_stop_processor(card, UNIFI_PROC_BOTH);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to stop UniFi XAPs\n");
+ goto done;
+ }
+
+ /* Dump core into the next available slot in the circular list */
+ r = unifi_coredump_from_sdio(card, card->dump_next_write);
+ if (r == CSR_RESULT_SUCCESS)
+ {
+ /* Record whether the dump was manual or automatic */
+ card->dump_next_write->requestor = (req?1 : 0);
+ card->dump_next_write->timestamp = time_of_capture;
+ /* Advance to the next buffer */
+ card->dump_next_write->count = dump_seq_no++;
+ card->dump_cur_read = card->dump_next_write;
+ card->dump_next_write = card->dump_next_write->next;
+
+ /* Sequence no. of zero indicates slot not in use, so handle wrap */
+ if (dump_seq_no == 0)
+ {
+ dump_seq_no = 1;
+ }
+
+ unifi_trace(card->ospriv, UDBG3,
+ "Coredump (%p), SeqNo=%d, cur_read=%p, next_write=%p\n",
+ req,
+ card->dump_cur_read->count,
+ card->dump_cur_read, card->dump_next_write);
+ }
+
+ /* Start both XAPs */
+ unifi_trace(card->ospriv, UDBG4, "Restart XAPs after coredump\n");
+ r = card_start_processor(card, UNIFI_PROC_BOTH);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Failed to start UniFi XAPs\n");
+ goto done;
+ }
+
+done:
+ func_exit_r(r);
+ return r;
+} /* unifi_coredump_capture() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * get_value_from_coredump
+ *
+ *
+ *
+ * Arguments:
+ * dump Pointer to buffered coredump data
+ * offset_in_space XAP memory space to retrieve from the buffer (there
+ * may be more than one zone covering the same memory
+ * space, but starting from different offsets).
+ * offset Offset within the XAP memory space to be retrieved
+ *
+ * Returns:
+ * >=0 Register value on success
+ * <0 Register out of range of any captured zones
+ *
+ * Notes:
+ * ---------------------------------------------------------------------------
+ */
+static CsrInt32 get_value_from_coredump(const coredump_buffer *coreDump,
+ const unifi_coredump_space_t space,
+ const CsrUint16 offset_in_space)
+{
+ CsrInt32 r = -1;
+ CsrUint16 offset_in_zone;
+ CsrUint32 zone_end_offset;
+ CsrInt32 i;
+ const struct coredump_zone *def = &zonedef_table[0];
+
+ /* Search zone def table for a match with the requested memory space */
+ for (i = 0; i < HIP_CDUMP_NUM_ZONES; i++, def++)
+ {
+ if (space == def->space)
+ {
+ zone_end_offset = def->offset + def->length;
+
+ /* Is the space offset contained in this zone? */
+ if (offset_in_space < zone_end_offset &&
+ offset_in_space >= def->offset)
+ {
+ /* Calculate the offset of data within the zone buffer */
+ offset_in_zone = offset_in_space - def->offset;
+ r = (CsrInt32) * (coreDump->zone[i] + offset_in_zone);
+
+ unifi_trace(NULL, UDBG6,
+ "sp %d, offs 0x%04x = 0x%04x (in z%d 0x%04x->0x%04x)\n",
+ space, offset_in_space, r,
+ i, def->offset, zone_end_offset - 1);
+ break;
+ }
+ }
+ }
+ return r;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_coredump_get_value
+ *
+ * Retrieve the value of a register buffered from a previous core dump,
+ * so that it may be reported back to application code.
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * req_reg Pointer to request parameter partially filled. This
+ * function puts in the values retrieved from the dump.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, or:
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE Null parameter error
+ * CSR_WIFI_HIP_RESULT_RANGE Register out of range
+ * CSR_WIFI_HIP_RESULT_NOT_FOUND Dump index not (yet) captured
+ *
+ * Notes:
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_coredump_get_value(card_t *card, struct unifi_coredump_req *req)
+{
+ CsrResult r;
+ CsrInt32 i = 0;
+ coredump_buffer *find_dump = NULL;
+
+ func_enter();
+
+ if (req == NULL || card == NULL)
+ {
+ r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ goto done;
+ }
+ req->value = -1;
+ if (card->dump_buf == NULL)
+ {
+ unifi_trace(card->ospriv, UDBG2, "No coredump buffers\n");
+ r = CSR_WIFI_HIP_RESULT_NOT_FOUND; /* Coredumping disabled */
+ goto done;
+ }
+ if (card->dump_cur_read == NULL)
+ {
+ unifi_trace(card->ospriv, UDBG4, "No coredumps captured\n");
+ r = CSR_WIFI_HIP_RESULT_NOT_FOUND; /* No coredump yet captured */
+ goto done;
+ }
+
+ /* Find the requested dump buffer */
+ switch (req->index)
+ {
+ case 0: /* Newest */
+ find_dump = card->dump_cur_read;
+ break;
+ case -1: /* Oldest: The next used slot forward */
+ for (find_dump = card->dump_cur_read->next;
+ (find_dump->count == 0) && (find_dump != card->dump_cur_read);
+ find_dump = card->dump_cur_read->next)
+ {
+ }
+ break;
+ default: /* Number of steps back from current read position */
+ for (i = 0, find_dump = card->dump_cur_read;
+ i < req->index;
+ i++, find_dump = find_dump->prev)
+ {
+ /* Walk the list for the index'th entry, but
+ * stop when about to wrap. */
+ unifi_trace(card->ospriv, UDBG6,
+ "%d: %d, @%p, p=%p, n=%p, cr=%p, h=%p\n",
+ i, find_dump->count, find_dump, find_dump->prev,
+ find_dump->next, card->dump_cur_read, card->dump_buf);
+ if (find_dump->prev == card->dump_cur_read)
+ {
+ /* Wrapped but still not found, index out of range */
+ if (i != req->index)
+ {
+ unifi_trace(card->ospriv, UDBG6,
+ "Dump index %d not found %d\n", req->index, i);
+ r = CSR_WIFI_HIP_RESULT_NOT_FOUND;
+ goto done;
+ }
+ break;
+ }
+ }
+ break;
+ }
+
+ /* Check if the slot is actually filled with a core dump */
+ if (find_dump->count == 0)
+ {
+ unifi_trace(card->ospriv, UDBG4, "Not captured %d\n", req->index);
+ r = CSR_WIFI_HIP_RESULT_NOT_FOUND;
+ goto done;
+ }
+
+ unifi_trace(card->ospriv, UDBG6, "Req index %d, found seq %d at step %d\n",
+ req->index, find_dump->count, i);
+
+ /* Find the appropriate entry in the buffer */
+ req->value = get_value_from_coredump(find_dump, req->space, (CsrUint16)req->offset);
+ if (req->value < 0)
+ {
+ r = CSR_WIFI_HIP_RESULT_RANGE; /* Un-captured register */
+ unifi_trace(card->ospriv, UDBG4,
+ "Can't read space %d, reg 0x%x from coredump buffer %d\n",
+ req->space, req->offset, req->index);
+ }
+ else
+ {
+ r = CSR_RESULT_SUCCESS;
+ }
+
+ /* Update the private request structure with the found values */
+ req->chip_ver = find_dump->chip_ver;
+ req->fw_ver = find_dump->fw_ver;
+ req->timestamp = find_dump->timestamp;
+ req->requestor = find_dump->requestor;
+ req->serial = find_dump->count;
+
+done:
+ func_exit_r(r);
+ return r;
+} /* unifi_coredump_get_value() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_coredump_read_zone
+ *
+ * Captures a UniFi memory zone into a buffer on the host
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * zonebuf Pointer to on-host buffer to dump the memory zone into
+ * def Pointer to description of the memory zone to read from UniFi.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, or:
+ * CSR_RESULT_FAILURE SDIO error
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE Parameter error
+ *
+ * Notes:
+ * It is assumed that the caller has already stopped the XAPs
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult unifi_coredump_read_zone(card_t *card, CsrUint16 *zonebuf, const struct coredump_zone *def)
+{
+ CsrResult r;
+
+ func_enter();
+
+ if (zonebuf == NULL || def == NULL)
+ {
+ r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ goto done;
+ }
+
+ /* Select XAP CPU if necessary */
+ if (def->cpu != UNIFI_PROC_INVALID)
+ {
+ if (def->cpu != UNIFI_PROC_MAC && def->cpu != UNIFI_PROC_PHY)
+ {
+ r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ goto done;
+ }
+ r = unifi_set_proc_select(card, def->cpu);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ goto done;
+ }
+ }
+
+ unifi_trace(card->ospriv, UDBG4,
+ "Dump sp %d, offs 0x%04x, 0x%04x words @GP=%08x CPU %d\n",
+ def->space, def->offset, def->length, def->gp, def->cpu);
+
+ /* Read on-chip RAM (byte-wise) */
+ r = unifi_card_readn(card, def->gp, zonebuf, (CsrUint16)(def->length * 2));
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ goto done;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Can't read UniFi shared data area\n");
+ goto done;
+ }
+
+done:
+ func_exit_r(r);
+ return r;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_coredump_read_zones
+ *
+ * Walks through the table of on-chip memory zones defined in zonedef_table,
+ * and reads each of them from the UniFi chip
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * dump_buf Buffer into which register values will be dumped
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, or:
+ * CSR_RESULT_FAILURE SDIO error
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE Parameter error
+ *
+ * Notes:
+ * It is assumed that the caller has already stopped the XAPs
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult unifi_coredump_read_zones(card_t *card, coredump_buffer *dump_buf)
+{
+ CsrResult r = CSR_RESULT_SUCCESS;
+ CsrInt32 i;
+
+ func_enter();
+
+ /* Walk the table of coredump zone definitions and read them from the chip */
+ for (i = 0;
+ (i < HIP_CDUMP_NUM_ZONES) && (r == 0);
+ i++)
+ {
+ r = unifi_coredump_read_zone(card, dump_buf->zone[i], &zonedef_table[i]);
+ }
+
+ func_exit_r(r);
+ return r;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_coredump_from_sdio
+ *
+ * Capture the status of the UniFi processors, over SDIO
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * reg_buffer Buffer into which register values will be dumped
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, or:
+ * CSR_RESULT_FAILURE SDIO error
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE Parameter error
+ *
+ * Notes:
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult unifi_coredump_from_sdio(card_t *card, coredump_buffer *dump_buf)
+{
+ CsrUint16 val;
+ CsrResult r;
+ CsrUint32 sdio_addr;
+
+ func_enter();
+
+ if (dump_buf == NULL)
+ {
+ r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ goto done;
+ }
+
+
+ /* Chip and firmware version */
+ unifi_trace(card->ospriv, UDBG4, "Get chip version\n");
+ sdio_addr = 2 * ChipHelper_GBL_CHIP_VERSION(card->helper);
+ if (sdio_addr != 0)
+ {
+ r = unifi_read_direct16(card, sdio_addr, &val);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ goto done;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Can't read GBL_CHIP_VERSION\n");
+ goto done;
+ }
+ }
+ dump_buf->chip_ver = val;
+ dump_buf->fw_ver = card->build_id;
+
+ unifi_trace(card->ospriv, UDBG4, "chip_ver 0x%04x, fw_ver %u\n",
+ dump_buf->chip_ver, dump_buf->fw_ver);
+
+ /* Capture the memory zones required from UniFi */
+ r = unifi_coredump_read_zones(card, dump_buf);
+ if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
+ {
+ goto done;
+ }
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "Can't read UniFi memory areas\n");
+ goto done;
+ }
+
+done:
+ func_exit_r(r);
+ return r;
+} /* unifi_coredump_from_sdio() */
+
+
+#ifndef UNIFI_DISABLE_COREDUMP
+/*
+ * ---------------------------------------------------------------------------
+ * new_coredump_node
+ *
+ * Allocates a coredump linked-list node, and links it to the previous.
+ *
+ * Arguments:
+ * ospriv OS context
+ * prevnode Previous node to link into
+ *
+ * Returns:
+ * Pointer to valid coredump_buffer on success
+ * NULL on memory allocation failure
+ *
+ * Notes:
+ * Allocates "all or nothing"
+ * ---------------------------------------------------------------------------
+ */
+static
+coredump_buffer* new_coredump_node(void *ospriv, coredump_buffer *prevnode)
+{
+ coredump_buffer *newnode = NULL;
+ CsrUint16 *newzone = NULL;
+ CsrInt32 i;
+ CsrUint32 zone_size;
+
+ /* Allocate node header */
+ newnode = (coredump_buffer *)CsrMemAlloc(sizeof(coredump_buffer));
+ if (newnode == NULL)
+ {
+ return NULL;
+ }
+ CsrMemSet(newnode, 0, sizeof(coredump_buffer));
+
+ /* Allocate chip memory zone capture buffers */
+ for (i = 0; i < HIP_CDUMP_NUM_ZONES; i++)
+ {
+ zone_size = sizeof(CsrUint16) * zonedef_table[i].length;
+ newzone = (CsrUint16 *)CsrMemAlloc(zone_size);
+ newnode->zone[i] = newzone;
+ if (newzone != NULL)
+ {
+ CsrMemSet(newzone, 0, zone_size);
+ }
+ else
+ {
+ unifi_error(ospriv, "Out of memory on coredump zone %d (%d words)\n",
+ i, zonedef_table[i].length);
+ break;
+ }
+ }
+
+ /* Clean up if any zone alloc failed */
+ if (newzone == NULL)
+ {
+ for (i = 0; newnode->zone[i] != NULL; i++)
+ {
+ CsrMemFree(newnode->zone[i]);
+ newnode->zone[i] = NULL;
+ }
+ }
+
+ /* Link to previous node */
+ newnode->prev = prevnode;
+ if (prevnode)
+ {
+ prevnode->next = newnode;
+ }
+ newnode->next = NULL;
+
+ return newnode;
+}
+
+
+#endif /* UNIFI_DISABLE_COREDUMP */
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_coredump_init
+ *
+ * Allocates buffers for the automatic SDIO core dump
+ *
+ * Arguments:
+ * card Pointer to card struct
+ * num_dump_buffers Number of buffers to reserve for coredumps
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, or:
+ * CSR_WIFI_HIP_RESULT_NO_MEMORY memory allocation failed
+ *
+ * Notes:
+ * Allocates space in advance, to be used for the last n coredump buffers
+ * the intention being that the size is sufficient for at least one dump,
+ * probably several.
+ * It's probably advisable to have at least 2 coredump buffers to allow
+ * one to be enquired with the unifi_coredump tool, while leaving another
+ * free for capturing.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_coredump_init(card_t *card, CsrUint16 num_dump_buffers)
+{
+#ifndef UNIFI_DISABLE_COREDUMP
+ void *ospriv = card->ospriv;
+ coredump_buffer *prev = NULL;
+ coredump_buffer *newnode = NULL;
+ CsrUint32 i = 0;
+#endif
+
+ func_enter();
+
+ card->request_coredump_on_reset = 0;
+ card->dump_next_write = NULL;
+ card->dump_cur_read = NULL;
+ card->dump_buf = NULL;
+
+#ifndef UNIFI_DISABLE_COREDUMP
+ unifi_trace(ospriv, UDBG1,
+ "Allocate buffers for %d core dumps\n", num_dump_buffers);
+ if (num_dump_buffers == 0)
+ {
+ goto done;
+ }
+
+ /* Root node */
+ card->dump_buf = new_coredump_node(ospriv, NULL);
+ if (card->dump_buf == NULL)
+ {
+ goto fail;
+ }
+ prev = card->dump_buf;
+ newnode = card->dump_buf;
+
+ /* Add each subsequent node at tail */
+ for (i = 1; i < num_dump_buffers; i++)
+ {
+ newnode = new_coredump_node(ospriv, prev);
+ if (newnode == NULL)
+ {
+ goto fail;
+ }
+ prev = newnode;
+ }
+
+ /* Link the first and last nodes to make the list circular */
+ card->dump_buf->prev = newnode;
+ newnode->next = card->dump_buf;
+
+ /* Set initial r/w access pointers */
+ card->dump_next_write = card->dump_buf;
+ card->dump_cur_read = NULL;
+
+ unifi_trace(ospriv, UDBG2, "Core dump configured (%d dumps max)\n", i);
+
+done:
+#endif
+ func_exit();
+ return CSR_RESULT_SUCCESS;
+
+#ifndef UNIFI_DISABLE_COREDUMP
+fail:
+ /* Unwind what we allocated so far */
+ unifi_error(ospriv, "Out of memory allocating core dump node %d\n", i);
+ unifi_coredump_free(card);
+ func_exit();
+ return CSR_WIFI_HIP_RESULT_NO_MEMORY;
+#endif
+} /* unifi_coreump_init() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_coredump_free
+ *
+ * Free all memory dynamically allocated for core dump
+ *
+ * Arguments:
+ * card Pointer to card struct
+ *
+ * Returns:
+ * None
+ *
+ * Notes:
+ * ---------------------------------------------------------------------------
+ */
+void unifi_coredump_free(card_t *card)
+{
+ void *ospriv = card->ospriv;
+ coredump_buffer *node, *del_node;
+ CsrInt16 i = 0;
+ CsrInt16 j;
+
+ func_enter();
+ unifi_trace(ospriv, UDBG2, "Core dump de-configured\n");
+
+ if (card->dump_buf == NULL)
+ {
+ return;
+ }
+
+ node = card->dump_buf;
+ do
+ {
+ /* Free payload zones */
+ for (j = 0; j < HIP_CDUMP_NUM_ZONES; j++)
+ {
+ if (node->zone[j] != NULL)
+ {
+ CsrMemFree(node->zone[j]);
+ node->zone[j] = NULL;
+ }
+ }
+
+ /* Detach */
+ del_node = node;
+ node = node->next;
+
+ /* Free header */
+ CsrMemFree(del_node);
+ i++;
+ } while ((node != NULL) && (node != card->dump_buf));
+
+ unifi_trace(ospriv, UDBG3, "Freed %d coredump buffers\n", i);
+
+ card->dump_buf = NULL;
+ card->dump_next_write = NULL;
+ card->dump_cur_read = NULL;
+
+ func_exit();
+} /* unifi_coredump_free() */
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_wifi_hip_signals.h"
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_conversions.h"
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * get_packed_struct_size
+ *
+ * Examine a buffer containing a UniFi signal in wire-format.
+ * The first two bytes contain the signal ID, decode the signal ID and
+ * return the size, in bytes, of the signal, not including any bulk
+ * data.
+ *
+ * WARNING: This function is auto-generated, DO NOT EDIT!
+ *
+ * Arguments:
+ * buf Pointer to buffer to decode.
+ *
+ * Returns:
+ * 0 if the signal ID is not recognised (i.e. zero length),
+ * otherwise the number of bytes occupied by the signal in the buffer.
+ * This is useful for stepping past the signal to the object in the buffer.
+ * ---------------------------------------------------------------------------
+ */
+CsrInt32 get_packed_struct_size(const CsrUint8 *buf)
+{
+ CsrInt32 size = 0;
+ CsrUint16 sig_id;
+
+ sig_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(buf);
+
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ switch (sig_id)
+ {
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_DEBUG_WORD16_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+ case CSR_DEBUG_GENERIC_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+ case CSR_MA_PACKET_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT64;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+ case CSR_MLME_SET_TIM_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECTED_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_TRIGGERED_GET_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT32;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ break;
+#endif
+ case CSR_DEBUG_GENERIC_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CANCEL_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT32;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MLME_SET_TIM_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_DEBUG_GENERIC_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+ case CSR_MA_PACKET_CANCEL_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT32;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_PACKET_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT32;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_VIF_AVAILABILITY_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLACKOUT_ENDED_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ break;
+#endif
+ case CSR_MA_VIF_AVAILABILITY_RESPONSE_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT32;
+ size += SIZEOF_UINT32;
+ size += SIZEOF_UINT32;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT32;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 32 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_PACKET_ERROR_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT32;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT32;
+ size += SIZEOF_UINT32;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_DEBUG_STRING_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLOCKACK_ERROR_INDICATION_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += 48 / 8;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_PACKET_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT32;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_CONFIRM_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_REQUEST_ID:
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ size += SIZEOF_UINT16;
+ break;
+#endif
+ default:
+ size = 0;
+ }
+ return size;
+} /* get_packed_struct_size() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * read_unpack_signal
+ *
+ * Unpack a wire-format signal into a host-native structure.
+ * This function handles any necessary conversions for endianness and
+ * places no restrictions on packing or alignment for the structure
+ * definition.
+ *
+ * WARNING: This function is auto-generated, DO NOT EDIT!
+ *
+ * Arguments:
+ * ptr Signal buffer to unpack.
+ * sig Pointer to destination structure to populate.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success,
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE if the ID of signal was not recognised.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult read_unpack_signal(const CsrUint8 *ptr, CSR_SIGNAL *sig)
+{
+ CsrInt32 index = 0;
+
+ sig->SignalPrimitiveHeader.SignalId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+
+ sig->SignalPrimitiveHeader.ReceiverProcessId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+
+ sig->SignalPrimitiveHeader.SenderProcessId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+
+ switch (sig->SignalPrimitiveHeader.SignalId)
+ {
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_CONFIRM_ID:
+ sig->u.MlmeSetPacketFilterConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_CONFIRM_ID:
+ sig->u.MlmeSetkeysConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_CONFIRM_ID:
+ sig->u.MlmeConfigQueueConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM_ID:
+ sig->u.MlmeAddAutonomousScanConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanConfirm.AutonomousScanId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_CONFIRM_ID:
+ sig->u.MlmeAddBlackoutConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutConfirm.BlackoutId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_REQUEST_ID:
+ sig->u.MlmeDelBlackoutRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutRequest.BlackoutId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_CONFIRM_ID:
+ sig->u.MlmeGetKeySequenceConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[0] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[1] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[2] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[3] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[4] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[5] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[6] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[7] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_CONFIRM_ID:
+ sig->u.MlmeSmStartConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_CONFIRM_ID:
+ sig->u.MlmeStopAggregationConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeStopAggregationConfirm.PeerQstaAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeStopAggregationConfirm.UserPriority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationConfirm.Direction = (CSR_DIRECTION) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_REQUEST_ID:
+ sig->u.MlmeDelTspecRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecRequest.UserPriority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecRequest.Direction = (CSR_DIRECTION) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_DEBUG_WORD16_INDICATION_ID:
+ sig->u.DebugWord16Indication.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[0] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[1] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[2] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[3] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[4] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[5] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[6] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[7] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[8] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[9] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[10] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[11] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[12] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[13] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[14] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugWord16Indication.DebugWords[15] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+ case CSR_DEBUG_GENERIC_CONFIRM_ID:
+ sig->u.DebugGenericConfirm.DebugVariable.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.DebugVariable.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.DebugWords[0] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.DebugWords[1] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.DebugWords[2] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.DebugWords[3] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.DebugWords[4] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.DebugWords[5] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.DebugWords[6] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericConfirm.DebugWords[7] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+ case CSR_MA_PACKET_INDICATION_ID:
+ sig->u.MaPacketIndication.Data.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketIndication.Data.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketIndication.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MaPacketIndication.LocalTime.x, &ptr[index], 64 / 8);
+ index += 64 / 8;
+ sig->u.MaPacketIndication.Ifindex = (CSR_IFINTERFACE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketIndication.Channel = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketIndication.ReceptionStatus = (CSR_RECEPTION_STATUS) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketIndication.Rssi = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketIndication.Snr = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketIndication.ReceivedRate = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+ case CSR_MLME_SET_TIM_REQUEST_ID:
+ sig->u.MlmeSetTimRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimRequest.AssociationId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimRequest.TimValue = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECTED_INDICATION_ID:
+ sig->u.MlmeConnectedIndication.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectedIndication.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectedIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectedIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectedIndication.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectedIndication.ConnectionStatus = (CSR_CONNECTION_STATUS) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeConnectedIndication.PeerMacAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_REQUEST_ID:
+ sig->u.MlmeDelRxTriggerRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerRequest.TriggerId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_TRIGGERED_GET_INDICATION_ID:
+ sig->u.MlmeTriggeredGetIndication.MibAttributeValue.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeTriggeredGetIndication.MibAttributeValue.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeTriggeredGetIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeTriggeredGetIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeTriggeredGetIndication.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeTriggeredGetIndication.Status = (CSR_MIB_STATUS) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeTriggeredGetIndication.ErrorIndex = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeTriggeredGetIndication.TriggeredId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_REQUEST_ID:
+ sig->u.MlmeScanRequest.ChannelList.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanRequest.ChannelList.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanRequest.InformationElements.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanRequest.InformationElements.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanRequest.Ifindex = (CSR_IFINTERFACE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanRequest.ScanType = (CSR_SCAN_TYPE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanRequest.ProbeDelay = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ sig->u.MlmeScanRequest.MinChannelTime = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanRequest.MaxChannelTime = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_CONFIRM_ID:
+ sig->u.MlmeDeletekeysConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_REQUEST_ID:
+ sig->u.MlmeGetNextRequest.MibAttribute.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetNextRequest.MibAttribute.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetNextRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetNextRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_CONFIRM_ID:
+ sig->u.MlmeSetChannelConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_REQUEST_ID:
+ sig->u.MlmeStartAggregationRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeStartAggregationRequest.PeerQstaAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeStartAggregationRequest.UserPriority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationRequest.Direction = (CSR_DIRECTION) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationRequest.StartingSequenceNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationRequest.BufferSize = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationRequest.BlockAckTimeout = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_REQUEST_ID:
+ sig->u.MlmeHlSyncRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeHlSyncRequest.GroupAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+ case CSR_DEBUG_GENERIC_REQUEST_ID:
+ sig->u.DebugGenericRequest.DebugVariable.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.DebugVariable.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.DebugWords[0] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.DebugWords[1] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.DebugWords[2] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.DebugWords[3] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.DebugWords[4] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.DebugWords[5] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.DebugWords[6] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericRequest.DebugWords[7] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_CONFIRM_ID:
+ sig->u.MlmeLeaveConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeLeaveConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeLeaveConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeLeaveConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeLeaveConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeLeaveConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_REQUEST_ID:
+ sig->u.MlmeDelTriggeredGetRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetRequest.TriggeredId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST_ID:
+ sig->u.MlmeAddMulticastAddressRequest.Data.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddMulticastAddressRequest.Data.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddMulticastAddressRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddMulticastAddressRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddMulticastAddressRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddMulticastAddressRequest.NumberOfMulticastGroupAddresses = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_REQUEST_ID:
+ sig->u.MlmeResetRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeResetRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeResetRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeResetRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeResetRequest.StaAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeResetRequest.SetDefaultMib = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CANCEL_REQUEST_ID:
+ sig->u.MlmeScanCancelRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanCancelRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanCancelRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanCancelRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanCancelRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_CONFIRM_ID:
+ sig->u.MlmeAddTriggeredGetConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetConfirm.TriggeredId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_REQUEST_ID:
+ sig->u.MlmeSetPacketFilterRequest.InformationElements.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterRequest.InformationElements.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterRequest.PacketFilterMode = (CSR_PACKET_FILTER_MODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetPacketFilterRequest.ArpFilterAddress = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_CONFIRM_ID:
+ sig->u.MlmeDelRxTriggerConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerConfirm.TriggerId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelRxTriggerConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_REQUEST_ID:
+ sig->u.MlmeConnectStatusRequest.InformationElements.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusRequest.InformationElements.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusRequest.ConnectionStatus = (CSR_CONNECTION_STATUS) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeConnectStatusRequest.StaAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeConnectStatusRequest.AssociationId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusRequest.AssociationCapabilityInformation = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_REQUEST_ID:
+ sig->u.MlmeLeaveRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeLeaveRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeLeaveRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeLeaveRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeLeaveRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_REQUEST_ID:
+ sig->u.MlmeConfigQueueRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueRequest.QueueIndex = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueRequest.Aifs = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueRequest.Cwmin = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueRequest.Cwmax = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConfigQueueRequest.TxopLimit = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_CONFIRM_ID:
+ sig->u.MlmeDelTspecConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecConfirm.UserPriority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTspecConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MLME_SET_TIM_CONFIRM_ID:
+ sig->u.MlmeSetTimConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetTimConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_INDICATION_ID:
+ sig->u.MlmeMeasureIndication.MeasurementReportSet.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureIndication.MeasurementReportSet.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureIndication.DialogToken = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_CONFIRM_ID:
+ sig->u.MlmeDelBlackoutConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutConfirm.BlackoutId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelBlackoutConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_CONFIRM_ID:
+ sig->u.MlmeDelTriggeredGetConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelTriggeredGetConfirm.TriggeredId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_DEBUG_GENERIC_INDICATION_ID:
+ sig->u.DebugGenericIndication.DebugVariable.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.DebugVariable.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.DebugWords[0] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.DebugWords[1] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.DebugWords[2] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.DebugWords[3] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.DebugWords[4] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.DebugWords[5] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.DebugWords[6] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugGenericIndication.DebugWords[7] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+ case CSR_MA_PACKET_CANCEL_REQUEST_ID:
+ sig->u.MaPacketCancelRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketCancelRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketCancelRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketCancelRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketCancelRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketCancelRequest.HostTag = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM_ID:
+ sig->u.MlmeModifyBssParameterConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM_ID:
+ sig->u.MlmePauseAutonomousScanConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanConfirm.AutonomousScanId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_PACKET_REQUEST_ID:
+ sig->u.MaPacketRequest.Data.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketRequest.Data.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketRequest.TransmitRate = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketRequest.HostTag = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ sig->u.MaPacketRequest.Priority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MaPacketRequest.Ra.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MaPacketRequest.TransmissionControl = (CSR_TRANSMISSION_CONTROL) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST_ID:
+ sig->u.MlmeModifyBssParameterRequest.Data.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterRequest.Data.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterRequest.BeaconPeriod = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterRequest.DtimPeriod = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeModifyBssParameterRequest.CapabilityInformation = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeModifyBssParameterRequest.Bssid.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeModifyBssParameterRequest.RtsThreshold = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_REQUEST_ID:
+ sig->u.MlmeAddRxTriggerRequest.InformationElements.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerRequest.InformationElements.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerRequest.TriggerId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerRequest.Priority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_VIF_AVAILABILITY_INDICATION_ID:
+ sig->u.MaVifAvailabilityIndication.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaVifAvailabilityIndication.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaVifAvailabilityIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaVifAvailabilityIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaVifAvailabilityIndication.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaVifAvailabilityIndication.Multicast = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_REQUEST_ID:
+ sig->u.MlmeHlSyncCancelRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncCancelRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncCancelRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncCancelRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeHlSyncCancelRequest.GroupAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST_ID:
+ sig->u.MlmeDelAutonomousScanRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanRequest.AutonomousScanId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLACKOUT_ENDED_INDICATION_ID:
+ sig->u.MlmeBlackoutEndedIndication.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeBlackoutEndedIndication.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeBlackoutEndedIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeBlackoutEndedIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeBlackoutEndedIndication.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeBlackoutEndedIndication.BlackoutId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION_ID:
+ sig->u.MlmeAutonomousScanDoneIndication.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAutonomousScanDoneIndication.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAutonomousScanDoneIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAutonomousScanDoneIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAutonomousScanDoneIndication.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAutonomousScanDoneIndication.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAutonomousScanDoneIndication.AutonomousScanId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_REQUEST_ID:
+ sig->u.MlmeGetKeySequenceRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceRequest.KeyId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetKeySequenceRequest.KeyType = (CSR_KEY_TYPE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeGetKeySequenceRequest.Address.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_REQUEST_ID:
+ sig->u.MlmeSetChannelRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelRequest.Ifindex = (CSR_IFINTERFACE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelRequest.Channel = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeSetChannelRequest.Address.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeSetChannelRequest.AvailabilityDuration = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetChannelRequest.AvailabilityInterval = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_CONFIRM_ID:
+ sig->u.MlmeMeasureConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureConfirm.DialogToken = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_REQUEST_ID:
+ sig->u.MlmeAddTriggeredGetRequest.MibAttribute.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetRequest.MibAttribute.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTriggeredGetRequest.TriggeredId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION_ID:
+ sig->u.MlmeAutonomousScanLossIndication.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAutonomousScanLossIndication.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAutonomousScanLossIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAutonomousScanLossIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAutonomousScanLossIndication.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeAutonomousScanLossIndication.Bssid.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+ case CSR_MA_VIF_AVAILABILITY_RESPONSE_ID:
+ sig->u.MaVifAvailabilityResponse.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaVifAvailabilityResponse.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaVifAvailabilityResponse.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaVifAvailabilityResponse.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaVifAvailabilityResponse.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaVifAvailabilityResponse.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_REQUEST_ID:
+ sig->u.MlmeAddTemplateRequest.Data1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateRequest.Data1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateRequest.Data2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateRequest.Data2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateRequest.FrameType = (CSR_FRAME_TYPE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateRequest.MinTransmitRate = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_CONFIRM_ID:
+ sig->u.MlmePowermgtConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_CONFIRM_ID:
+ sig->u.MlmeAddPeriodicConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicConfirm.PeriodicId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_CONFIRM_ID:
+ sig->u.MlmeGetConfirm.MibAttributeValue.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetConfirm.MibAttributeValue.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetConfirm.Status = (CSR_MIB_STATUS) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetConfirm.ErrorIndex = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_CONFIRM_ID:
+ sig->u.MlmeGetNextConfirm.MibAttributeValue.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetNextConfirm.MibAttributeValue.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetNextConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetNextConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetNextConfirm.Status = (CSR_MIB_STATUS) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetNextConfirm.ErrorIndex = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_REQUEST_ID:
+ sig->u.MlmeStopAggregationRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeStopAggregationRequest.PeerQstaAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeStopAggregationRequest.UserPriority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopAggregationRequest.Direction = (CSR_DIRECTION) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_CONFIRM_ID:
+ sig->u.MlmeAddRxTriggerConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerConfirm.TriggerId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddRxTriggerConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_REQUEST_ID:
+ sig->u.MlmeAddBlackoutRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutRequest.BlackoutId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutRequest.BlackoutType = (CSR_BLACKOUT_TYPE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutRequest.BlackoutSource = (CSR_BLACKOUT_SOURCE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddBlackoutRequest.BlackoutStartReference = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ sig->u.MlmeAddBlackoutRequest.BlackoutPeriod = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ sig->u.MlmeAddBlackoutRequest.BlackoutDuration = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ CsrMemCpy(sig->u.MlmeAddBlackoutRequest.PeerStaAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeAddBlackoutRequest.BlackoutCount = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_REQUEST_ID:
+ sig->u.MlmeDeletekeysRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysRequest.KeyId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDeletekeysRequest.KeyType = (CSR_KEY_TYPE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeDeletekeysRequest.Address.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_CONFIRM_ID:
+ sig->u.MlmeResetConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeResetConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeResetConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeResetConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeResetConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CONFIRM_ID:
+ sig->u.MlmeHlSyncConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeHlSyncConfirm.GroupAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeHlSyncConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST_ID:
+ sig->u.MlmeAddAutonomousScanRequest.ChannelList.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanRequest.ChannelList.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanRequest.InformationElements.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanRequest.InformationElements.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanRequest.AutonomousScanId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanRequest.Ifindex = (CSR_IFINTERFACE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanRequest.ChannelStartingFactor = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanRequest.ScanType = (CSR_SCAN_TYPE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanRequest.ProbeDelay = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ sig->u.MlmeAddAutonomousScanRequest.MinChannelTime = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddAutonomousScanRequest.MaxChannelTime = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_REQUEST_ID:
+ sig->u.MlmeSetRequest.MibAttributeValue.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetRequest.MibAttributeValue.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_REQUEST_ID:
+ sig->u.MlmeSmStartRequest.Beacon.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartRequest.Beacon.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartRequest.BssParameters.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartRequest.BssParameters.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartRequest.Ifindex = (CSR_IFINTERFACE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartRequest.Channel = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeSmStartRequest.InterfaceAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ CsrMemCpy(sig->u.MlmeSmStartRequest.Bssid.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeSmStartRequest.BeaconPeriod = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartRequest.DtimPeriod = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSmStartRequest.CapabilityInformation = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_CONFIRM_ID:
+ sig->u.MlmeConnectStatusConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeConnectStatusConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM_ID:
+ sig->u.MlmeDelAutonomousScanConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelAutonomousScanConfirm.AutonomousScanId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_REQUEST_ID:
+ sig->u.MlmeDelPeriodicRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicRequest.PeriodicId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_REQUEST_ID:
+ sig->u.MlmeSetkeysRequest.Key.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.Key.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.Length = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.KeyId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.KeyType = (CSR_KEY_TYPE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeSetkeysRequest.Address.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeSetkeysRequest.SequenceNumber[0] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.SequenceNumber[1] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.SequenceNumber[2] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.SequenceNumber[3] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.SequenceNumber[4] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.SequenceNumber[5] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.SequenceNumber[6] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetkeysRequest.SequenceNumber[7] = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(&sig->u.MlmeSetkeysRequest.CipherSuiteSelector, &ptr[index], 32 / 8);
+ index += 32 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST_ID:
+ sig->u.MlmePauseAutonomousScanRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanRequest.AutonomousScanId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePauseAutonomousScanRequest.Pause = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_REQUEST_ID:
+ sig->u.MlmeGetRequest.MibAttribute.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetRequest.MibAttribute.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeGetRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_REQUEST_ID:
+ sig->u.MlmePowermgtRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtRequest.PowerManagementMode = (CSR_POWER_MANAGEMENT_MODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtRequest.ReceiveDtims = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtRequest.ListenInterval = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmePowermgtRequest.TrafficWindow = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_PACKET_ERROR_INDICATION_ID:
+ sig->u.MaPacketErrorIndication.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketErrorIndication.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketErrorIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketErrorIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketErrorIndication.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MaPacketErrorIndication.PeerQstaAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MaPacketErrorIndication.UserPriority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketErrorIndication.SequenceNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_REQUEST_ID:
+ sig->u.MlmeAddPeriodicRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicRequest.PeriodicId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicRequest.MaximumLatency = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ sig->u.MlmeAddPeriodicRequest.PeriodicSchedulingMode = (CSR_PERIODIC_SCHEDULING_MODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicRequest.WakeHost = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddPeriodicRequest.UserPriority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_REQUEST_ID:
+ sig->u.MlmeAddTspecRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecRequest.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecRequest.UserPriority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecRequest.Direction = (CSR_DIRECTION) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecRequest.PsScheme = (CSR_PS_SCHEME) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecRequest.MediumTime = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecRequest.ServiceStartTime = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ sig->u.MlmeAddTspecRequest.ServiceInterval = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ sig->u.MlmeAddTspecRequest.MinimumDataRate = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM_ID:
+ sig->u.MlmeAddMulticastAddressConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddMulticastAddressConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddMulticastAddressConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddMulticastAddressConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddMulticastAddressConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddMulticastAddressConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_CONFIRM_ID:
+ sig->u.MlmeAddTspecConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecConfirm.UserPriority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTspecConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_CONFIRM_ID:
+ sig->u.MlmeHlSyncCancelConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncCancelConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncCancelConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncCancelConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeHlSyncCancelConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CONFIRM_ID:
+ sig->u.MlmeScanConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeScanConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_DEBUG_STRING_INDICATION_ID:
+ sig->u.DebugStringIndication.DebugMessage.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugStringIndication.DebugMessage.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugStringIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.DebugStringIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_CONFIRM_ID:
+ sig->u.MlmeAddTemplateConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateConfirm.FrameType = (CSR_FRAME_TYPE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeAddTemplateConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLOCKACK_ERROR_INDICATION_ID:
+ sig->u.MlmeBlockackErrorIndication.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeBlockackErrorIndication.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeBlockackErrorIndication.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeBlockackErrorIndication.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeBlockackErrorIndication.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeBlockackErrorIndication.ResultCode = (CSR_REASON_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeBlockackErrorIndication.PeerQstaAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CONFIRM_ID:
+ sig->u.MlmeSetConfirm.MibAttributeValue.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetConfirm.MibAttributeValue.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetConfirm.Status = (CSR_MIB_STATUS) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeSetConfirm.ErrorIndex = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_REQUEST_ID:
+ sig->u.MlmeMeasureRequest.MeasurementRequestSet.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureRequest.MeasurementRequestSet.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeMeasureRequest.DialogToken = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_CONFIRM_ID:
+ sig->u.MlmeStartAggregationConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(sig->u.MlmeStartAggregationConfirm.PeerQstaAddress.x, &ptr[index], 48 / 8);
+ index += 48 / 8;
+ sig->u.MlmeStartAggregationConfirm.UserPriority = (CSR_PRIORITY) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationConfirm.Direction = (CSR_DIRECTION) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStartAggregationConfirm.SequenceNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_CONFIRM_ID:
+ sig->u.MlmeStopMeasureConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopMeasureConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopMeasureConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopMeasureConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopMeasureConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopMeasureConfirm.DialogToken = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_PACKET_CONFIRM_ID:
+ sig->u.MaPacketConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketConfirm.TransmissionStatus = (CSR_TRANSMISSION_STATUS) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketConfirm.RetryCount = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketConfirm.Rate = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MaPacketConfirm.HostTag = CSR_GET_UINT32_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT32;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_CONFIRM_ID:
+ sig->u.MlmeDelPeriodicConfirm.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicConfirm.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicConfirm.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicConfirm.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicConfirm.VirtualInterfaceIdentifier = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicConfirm.PeriodicId = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeDelPeriodicConfirm.ResultCode = (CSR_RESULT_CODE) CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_REQUEST_ID:
+ sig->u.MlmeStopMeasureRequest.Dummydataref1.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopMeasureRequest.Dummydataref1.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopMeasureRequest.Dummydataref2.SlotNumber = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopMeasureRequest.Dummydataref2.DataLength = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ sig->u.MlmeStopMeasureRequest.DialogToken = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+
+ default:
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ return CSR_RESULT_SUCCESS;
+} /* read_unpack_signal() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * write_pack
+ *
+ * Convert a signal structure, in host-native format, to the
+ * little-endian wire format specified in the UniFi Host Interface
+ * Protocol Specification.
+ *
+ * WARNING: This function is auto-generated, DO NOT EDIT!
+ *
+ * Arguments:
+ * sig Pointer to signal structure to pack.
+ * ptr Destination buffer to pack into.
+ * sig_len Returns the length of the packed signal, i.e. the
+ * number of bytes written to ptr.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success,
+ * CSR_WIFI_HIP_RESULT_INVALID_VALUE if the ID of signal was not recognised.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult write_pack(const CSR_SIGNAL *sig, CsrUint8 *ptr, CsrUint16 *sig_len)
+{
+ CsrInt16 index = 0;
+
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->SignalPrimitiveHeader.SignalId, ptr + index);
+ index += SIZEOF_UINT16;
+
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->SignalPrimitiveHeader.ReceiverProcessId, ptr + index);
+ index += SIZEOF_UINT16;
+
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->SignalPrimitiveHeader.SenderProcessId, ptr + index);
+ index += SIZEOF_UINT16;
+
+ switch (sig->SignalPrimitiveHeader.SignalId)
+ {
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanConfirm.AutonomousScanId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutConfirm.BlackoutId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutRequest.BlackoutId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[0], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[1], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[2], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[3], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[4], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[5], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[6], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceConfirm.SequenceNumber[7], ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeStopAggregationConfirm.PeerQstaAddress.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationConfirm.UserPriority, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationConfirm.Direction, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecRequest.UserPriority, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecRequest.Direction, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_DEBUG_WORD16_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[0], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[1], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[2], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[3], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[4], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[5], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[6], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[7], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[8], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[9], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[10], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[11], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[12], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[13], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[14], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugWord16Indication.DebugWords[15], ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+ case CSR_DEBUG_GENERIC_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.DebugVariable.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.DebugVariable.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.DebugWords[0], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.DebugWords[1], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.DebugWords[2], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.DebugWords[3], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.DebugWords[4], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.DebugWords[5], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.DebugWords[6], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericConfirm.DebugWords[7], ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+ case CSR_MA_PACKET_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.Data.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.Data.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MaPacketIndication.LocalTime.x, 64 / 8);
+ index += 64 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.Ifindex, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.Channel, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.ReceptionStatus, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.Rssi, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.Snr, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketIndication.ReceivedRate, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+ case CSR_MLME_SET_TIM_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimRequest.AssociationId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimRequest.TimValue, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECTED_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectedIndication.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectedIndication.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectedIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectedIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectedIndication.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectedIndication.ConnectionStatus, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeConnectedIndication.PeerMacAddress.x, 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerRequest.TriggerId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_TRIGGERED_GET_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeTriggeredGetIndication.MibAttributeValue.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeTriggeredGetIndication.MibAttributeValue.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeTriggeredGetIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeTriggeredGetIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeTriggeredGetIndication.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeTriggeredGetIndication.Status, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeTriggeredGetIndication.ErrorIndex, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeTriggeredGetIndication.TriggeredId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanRequest.ChannelList.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanRequest.ChannelList.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanRequest.InformationElements.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanRequest.InformationElements.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanRequest.Ifindex, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanRequest.ScanType, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MlmeScanRequest.ProbeDelay, ptr + index);
+ index += SIZEOF_UINT32;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanRequest.MinChannelTime, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanRequest.MaxChannelTime, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetNextRequest.MibAttribute.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetNextRequest.MibAttribute.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetNextRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetNextRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeStartAggregationRequest.PeerQstaAddress.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationRequest.UserPriority, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationRequest.Direction, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationRequest.StartingSequenceNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationRequest.BufferSize, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationRequest.BlockAckTimeout, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeHlSyncRequest.GroupAddress.x, 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+ case CSR_DEBUG_GENERIC_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.DebugVariable.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.DebugVariable.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.DebugWords[0], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.DebugWords[1], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.DebugWords[2], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.DebugWords[3], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.DebugWords[4], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.DebugWords[5], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.DebugWords[6], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericRequest.DebugWords[7], ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetRequest.TriggeredId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressRequest.Data.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressRequest.Data.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressRequest.NumberOfMulticastGroupAddresses, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeResetRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeResetRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeResetRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeResetRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeResetRequest.StaAddress.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeResetRequest.SetDefaultMib, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CANCEL_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanCancelRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanCancelRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanCancelRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanCancelRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanCancelRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetConfirm.TriggeredId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterRequest.InformationElements.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterRequest.InformationElements.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterRequest.PacketFilterMode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MlmeSetPacketFilterRequest.ArpFilterAddress, ptr + index);
+ index += SIZEOF_UINT32;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerConfirm.TriggerId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelRxTriggerConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusRequest.InformationElements.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusRequest.InformationElements.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusRequest.ConnectionStatus, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeConnectStatusRequest.StaAddress.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusRequest.AssociationId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusRequest.AssociationCapabilityInformation, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeLeaveRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueRequest.QueueIndex, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueRequest.Aifs, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueRequest.Cwmin, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueRequest.Cwmax, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConfigQueueRequest.TxopLimit, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecConfirm.UserPriority, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTspecConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MLME_SET_TIM_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetTimConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureIndication.MeasurementReportSet.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureIndication.MeasurementReportSet.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureIndication.DialogToken, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutConfirm.BlackoutId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelBlackoutConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelTriggeredGetConfirm.TriggeredId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_DEBUG_GENERIC_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.DebugVariable.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.DebugVariable.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.DebugWords[0], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.DebugWords[1], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.DebugWords[2], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.DebugWords[3], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.DebugWords[4], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.DebugWords[5], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.DebugWords[6], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugGenericIndication.DebugWords[7], ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+ case CSR_MA_PACKET_CANCEL_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketCancelRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketCancelRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketCancelRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketCancelRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketCancelRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MaPacketCancelRequest.HostTag, ptr + index);
+ index += SIZEOF_UINT32;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanConfirm.AutonomousScanId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_PACKET_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketRequest.Data.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketRequest.Data.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketRequest.TransmitRate, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MaPacketRequest.HostTag, ptr + index);
+ index += SIZEOF_UINT32;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketRequest.Priority, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MaPacketRequest.Ra.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketRequest.TransmissionControl, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterRequest.Data.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterRequest.Data.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterRequest.BeaconPeriod, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterRequest.DtimPeriod, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterRequest.CapabilityInformation, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeModifyBssParameterRequest.Bssid.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeModifyBssParameterRequest.RtsThreshold, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerRequest.InformationElements.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerRequest.InformationElements.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerRequest.TriggerId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerRequest.Priority, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_VIF_AVAILABILITY_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityIndication.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityIndication.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityIndication.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityIndication.Multicast, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncCancelRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncCancelRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncCancelRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncCancelRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeHlSyncCancelRequest.GroupAddress.x, 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanRequest.AutonomousScanId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLACKOUT_ENDED_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlackoutEndedIndication.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlackoutEndedIndication.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlackoutEndedIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlackoutEndedIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlackoutEndedIndication.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlackoutEndedIndication.BlackoutId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanDoneIndication.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanDoneIndication.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanDoneIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanDoneIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanDoneIndication.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanDoneIndication.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanDoneIndication.AutonomousScanId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceRequest.KeyId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetKeySequenceRequest.KeyType, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeGetKeySequenceRequest.Address.x, 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelRequest.Ifindex, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelRequest.Channel, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeSetChannelRequest.Address.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelRequest.AvailabilityDuration, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetChannelRequest.AvailabilityInterval, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureConfirm.DialogToken, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetRequest.MibAttribute.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetRequest.MibAttribute.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTriggeredGetRequest.TriggeredId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanLossIndication.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanLossIndication.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanLossIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanLossIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAutonomousScanLossIndication.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeAutonomousScanLossIndication.Bssid.x, 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+ case CSR_MA_VIF_AVAILABILITY_RESPONSE_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityResponse.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityResponse.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityResponse.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityResponse.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityResponse.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaVifAvailabilityResponse.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateRequest.Data1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateRequest.Data1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateRequest.Data2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateRequest.Data2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateRequest.FrameType, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateRequest.MinTransmitRate, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicConfirm.PeriodicId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetConfirm.MibAttributeValue.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetConfirm.MibAttributeValue.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetConfirm.Status, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetConfirm.ErrorIndex, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetNextConfirm.MibAttributeValue.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetNextConfirm.MibAttributeValue.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetNextConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetNextConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetNextConfirm.Status, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetNextConfirm.ErrorIndex, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeStopAggregationRequest.PeerQstaAddress.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationRequest.UserPriority, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopAggregationRequest.Direction, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerConfirm.TriggerId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddRxTriggerConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.BlackoutId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.BlackoutType, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.BlackoutSource, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.BlackoutStartReference, ptr + index);
+ index += SIZEOF_UINT32;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.BlackoutPeriod, ptr + index);
+ index += SIZEOF_UINT32;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.BlackoutDuration, ptr + index);
+ index += SIZEOF_UINT32;
+ CsrMemCpy(ptr + index, sig->u.MlmeAddBlackoutRequest.PeerStaAddress.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddBlackoutRequest.BlackoutCount, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysRequest.KeyId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDeletekeysRequest.KeyType, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeDeletekeysRequest.Address.x, 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeResetConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeResetConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeResetConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeResetConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeResetConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeHlSyncConfirm.GroupAddress.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.ChannelList.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.ChannelList.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.InformationElements.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.InformationElements.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.AutonomousScanId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.Ifindex, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.ChannelStartingFactor, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.ScanType, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.ProbeDelay, ptr + index);
+ index += SIZEOF_UINT32;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.MinChannelTime, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddAutonomousScanRequest.MaxChannelTime, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetRequest.MibAttributeValue.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetRequest.MibAttributeValue.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartRequest.Beacon.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartRequest.Beacon.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartRequest.BssParameters.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartRequest.BssParameters.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartRequest.Ifindex, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartRequest.Channel, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeSmStartRequest.InterfaceAddress.x, 48 / 8);
+ index += 48 / 8;
+ CsrMemCpy(ptr + index, sig->u.MlmeSmStartRequest.Bssid.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartRequest.BeaconPeriod, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartRequest.DtimPeriod, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSmStartRequest.CapabilityInformation, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeConnectStatusConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelAutonomousScanConfirm.AutonomousScanId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicRequest.PeriodicId, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.Key.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.Key.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.Length, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.KeyId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.KeyType, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeSetkeysRequest.Address.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.SequenceNumber[0], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.SequenceNumber[1], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.SequenceNumber[2], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.SequenceNumber[3], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.SequenceNumber[4], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.SequenceNumber[5], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.SequenceNumber[6], ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetkeysRequest.SequenceNumber[7], ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, &sig->u.MlmeSetkeysRequest.CipherSuiteSelector, 32 / 8);
+ index += 32 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanRequest.AutonomousScanId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePauseAutonomousScanRequest.Pause, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetRequest.MibAttribute.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetRequest.MibAttribute.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeGetRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtRequest.PowerManagementMode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtRequest.ReceiveDtims, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtRequest.ListenInterval, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmePowermgtRequest.TrafficWindow, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_PACKET_ERROR_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketErrorIndication.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketErrorIndication.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketErrorIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketErrorIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketErrorIndication.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MaPacketErrorIndication.PeerQstaAddress.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketErrorIndication.UserPriority, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketErrorIndication.SequenceNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicRequest.PeriodicId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicRequest.MaximumLatency, ptr + index);
+ index += SIZEOF_UINT32;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicRequest.PeriodicSchedulingMode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicRequest.WakeHost, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddPeriodicRequest.UserPriority, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.UserPriority, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.Direction, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.PsScheme, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.MediumTime, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.ServiceStartTime, ptr + index);
+ index += SIZEOF_UINT32;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.ServiceInterval, ptr + index);
+ index += SIZEOF_UINT32;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecRequest.MinimumDataRate, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddMulticastAddressConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecConfirm.UserPriority, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTspecConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncCancelConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncCancelConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncCancelConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncCancelConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeHlSyncCancelConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeScanConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_DEBUG_STRING_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugStringIndication.DebugMessage.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugStringIndication.DebugMessage.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugStringIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.DebugStringIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateConfirm.FrameType, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeAddTemplateConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLOCKACK_ERROR_INDICATION_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlockackErrorIndication.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlockackErrorIndication.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlockackErrorIndication.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlockackErrorIndication.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlockackErrorIndication.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeBlockackErrorIndication.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeBlockackErrorIndication.PeerQstaAddress.x, 48 / 8);
+ index += 48 / 8;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetConfirm.MibAttributeValue.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetConfirm.MibAttributeValue.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetConfirm.Status, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeSetConfirm.ErrorIndex, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureRequest.MeasurementRequestSet.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureRequest.MeasurementRequestSet.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeMeasureRequest.DialogToken, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CsrMemCpy(ptr + index, sig->u.MlmeStartAggregationConfirm.PeerQstaAddress.x, 48 / 8);
+ index += 48 / 8;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationConfirm.UserPriority, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationConfirm.Direction, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStartAggregationConfirm.SequenceNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureConfirm.DialogToken, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+ case CSR_MA_PACKET_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketConfirm.TransmissionStatus, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketConfirm.RetryCount, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MaPacketConfirm.Rate, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT32_TO_LITTLE_ENDIAN(sig->u.MaPacketConfirm.HostTag, ptr + index);
+ index += SIZEOF_UINT32;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_CONFIRM_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicConfirm.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicConfirm.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicConfirm.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicConfirm.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicConfirm.VirtualInterfaceIdentifier, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicConfirm.PeriodicId, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeDelPeriodicConfirm.ResultCode, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_REQUEST_ID:
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureRequest.Dummydataref1.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureRequest.Dummydataref1.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureRequest.Dummydataref2.SlotNumber, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureRequest.Dummydataref2.DataLength, ptr + index);
+ index += SIZEOF_UINT16;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(sig->u.MlmeStopMeasureRequest.DialogToken, ptr + index);
+ index += SIZEOF_UINT16;
+ break;
+#endif
+
+ default:
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ *sig_len = index;
+
+ return CSR_RESULT_SUCCESS;
+} /* write_pack() */
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ***************************************************************************
+ *
+ * FILE: csr_wifi_hip_send.c
+ *
+ * PURPOSE:
+ * Code for adding a signal request to the from-host queue.
+ * When the driver bottom-half is run, it will take requests from the
+ * queue and pass them to the UniFi.
+ *
+ * ***************************************************************************
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_conversions.h"
+#include "csr_wifi_hip_sigs.h"
+#include "csr_wifi_hip_card.h"
+
+unifi_TrafficQueue unifi_frame_priority_to_queue(CSR_PRIORITY priority)
+{
+ switch (priority)
+ {
+ case CSR_QOS_UP0:
+ case CSR_QOS_UP3:
+ return UNIFI_TRAFFIC_Q_BE;
+ case CSR_QOS_UP1:
+ case CSR_QOS_UP2:
+ return UNIFI_TRAFFIC_Q_BK;
+ case CSR_QOS_UP4:
+ case CSR_QOS_UP5:
+ return UNIFI_TRAFFIC_Q_VI;
+ case CSR_QOS_UP6:
+ case CSR_QOS_UP7:
+ case CSR_MANAGEMENT:
+ return UNIFI_TRAFFIC_Q_VO;
+ default:
+ return UNIFI_TRAFFIC_Q_BE;
+ }
+}
+
+
+CSR_PRIORITY unifi_get_default_downgrade_priority(unifi_TrafficQueue queue)
+{
+ switch (queue)
+ {
+ case UNIFI_TRAFFIC_Q_BE:
+ return CSR_QOS_UP0;
+ case UNIFI_TRAFFIC_Q_BK:
+ return CSR_QOS_UP1;
+ case UNIFI_TRAFFIC_Q_VI:
+ return CSR_QOS_UP5;
+ case UNIFI_TRAFFIC_Q_VO:
+ return CSR_QOS_UP6;
+ default:
+ return CSR_QOS_UP0;
+ }
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * send_signal
+ *
+ * This function queues a signal for sending to UniFi. It first checks
+ * that there is space on the fh_signal_queue for another entry, then
+ * claims any bulk data slots required and copies data into them. Then
+ * increments the fh_signal_queue write count.
+ *
+ * The fh_signal_queue is later processed by the driver bottom half
+ * (in unifi_bh()).
+ *
+ * This function call unifi_pause_xmit() to pause the flow of data plane
+ * packets when:
+ * - the fh_signal_queue ring buffer is full
+ * - there are less than UNIFI_MAX_DATA_REFERENCES (2) bulk data
+ * slots available.
+ *
+ * Arguments:
+ * card Pointer to card context structure
+ * sigptr Pointer to the signal to write to UniFi.
+ * siglen Number of bytes pointer to by sigptr.
+ * bulkdata Array of pointers to an associated bulk data.
+ * sigq To which from-host queue to add the signal.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success
+ * CSR_WIFI_HIP_RESULT_NO_SPACE if there were insufficient data slots or
+ * no free signal queue entry
+ *
+ * Notes:
+ * Calls unifi_pause_xmit() when the last slots are used.
+ * ---------------------------------------------------------------------------
+ */
+static CsrResult send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 siglen,
+ const bulk_data_param_t *bulkdata,
+ q_t *sigq, CsrUint32 priority_q, CsrUint32 run_bh)
+{
+ CsrUint16 i, data_slot_size;
+ card_signal_t *csptr;
+ CsrInt16 qe;
+ CsrResult r;
+ CsrInt16 debug_print = 0;
+
+ data_slot_size = CardGetDataSlotSize(card);
+
+ /* Check that the fh_data_queue has a free slot */
+ if (!CSR_WIFI_HIP_Q_SLOTS_FREE(sigq))
+ {
+ unifi_trace(card->ospriv, UDBG3, "send_signal: %s full\n", sigq->name);
+
+ return CSR_WIFI_HIP_RESULT_NO_SPACE;
+ }
+
+ /*
+ * Now add the signal to the From Host signal queue
+ */
+ /* Get next slot on queue */
+ qe = CSR_WIFI_HIP_Q_NEXT_W_SLOT(sigq);
+ csptr = CSR_WIFI_HIP_Q_SLOT_DATA(sigq, qe);
+
+ /* Make up the card_signal struct */
+ csptr->signal_length = (CsrUint16)siglen;
+ CsrMemCpy((void *)csptr->sigbuf, (void *)sigptr, siglen);
+
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; ++i)
+ {
+ if ((bulkdata != NULL) && (bulkdata->d[i].data_length != 0))
+ {
+ CsrUint32 datalen = bulkdata->d[i].data_length;
+
+ /* Make sure data will fit in a bulk data slot */
+ if (bulkdata->d[i].os_data_ptr == NULL)
+ {
+ unifi_error(card->ospriv, "send_signal - NULL bulkdata[%d]\n", i);
+ debug_print++;
+ csptr->bulkdata[i].data_length = 0;
+ }
+ else
+ {
+ if (datalen > data_slot_size)
+ {
+ unifi_error(card->ospriv,
+ "send_signal - Invalid data length %u (@%p), "
+ "truncating\n",
+ datalen, bulkdata->d[i].os_data_ptr);
+ datalen = data_slot_size;
+ debug_print++;
+ }
+ /* Store the bulk data info in the soft queue. */
+ csptr->bulkdata[i].os_data_ptr = (CsrUint8 *)bulkdata->d[i].os_data_ptr;
+ csptr->bulkdata[i].os_net_buf_ptr = (CsrUint8 *)bulkdata->d[i].os_net_buf_ptr;
+ csptr->bulkdata[i].net_buf_length = bulkdata->d[i].net_buf_length;
+ csptr->bulkdata[i].data_length = datalen;
+ }
+ }
+ else
+ {
+ UNIFI_INIT_BULK_DATA(&csptr->bulkdata[i]);
+ }
+ }
+
+ if (debug_print)
+ {
+ const CsrUint8 *sig = sigptr;
+
+ unifi_error(card->ospriv, "Signal(%d): %02x %02x %02x %02x %02x %02x %02x %02x"
+ " %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ siglen,
+ sig[0], sig[1], sig[2], sig[3],
+ sig[4], sig[5], sig[6], sig[7],
+ sig[8], sig[9], sig[10], sig[11],
+ sig[12], sig[13], sig[14], sig[15]);
+ unifi_error(card->ospriv, "Bulkdata pointer %p(%d), %p(%d)\n",
+ bulkdata != NULL?bulkdata->d[0].os_data_ptr : NULL,
+ bulkdata != NULL?bulkdata->d[0].data_length : 0,
+ bulkdata != NULL?bulkdata->d[1].os_data_ptr : NULL,
+ bulkdata != NULL?bulkdata->d[1].data_length : 0);
+ }
+
+ /* Advance the written count to say there is a new entry */
+ CSR_WIFI_HIP_Q_INC_W(sigq);
+
+ /*
+ * Set the flag to say reason for waking was a host request.
+ * Then ask the OS layer to run the unifi_bh.
+ */
+ if (run_bh == 1)
+ {
+ card->bh_reason_host = 1;
+ r = unifi_run_bh(card->ospriv);
+ if (r != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(card->ospriv, "failed to run bh.\n");
+ card->bh_reason_host = 0;
+
+ /*
+ * The bulk data buffer will be freed by the caller.
+ * We need to invalidate the description of the bulk data in our
+ * soft queue, to prevent the core freeing the bulk data again later.
+ */
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; ++i)
+ {
+ if (csptr->bulkdata[i].data_length != 0)
+ {
+ csptr->bulkdata[i].os_data_ptr = csptr->bulkdata[i].os_net_buf_ptr = NULL;
+ csptr->bulkdata[i].net_buf_length = csptr->bulkdata[i].data_length = 0;
+ }
+ }
+ return r;
+ }
+ }
+ else
+ {
+ unifi_error(card->ospriv, "run_bh=%d, bh not called.\n", run_bh);
+ }
+
+ /*
+ * Have we used up all the fh signal list entries?
+ */
+ if (CSR_WIFI_HIP_Q_SLOTS_FREE(sigq) == 0)
+ {
+ /* We have filled the queue, so stop the upper layer. The command queue
+ * is an exception, as suspending due to that being full could delay
+ * resume/retry until new commands or data are received.
+ */
+ if (sigq != &card->fh_command_queue)
+ {
+ /*
+ * Must call unifi_pause_xmit() *before* setting the paused flag.
+ * (the unifi_pause_xmit call should not be after setting the flag because of the possibility of being interrupted
+ * by the bh thread between our setting the flag and the call to unifi_pause_xmit()
+ * If bh thread then cleared the flag, we would end up paused, but without the flag set)
+ * Instead, setting it afterwards means that if this thread is interrupted by the bh thread
+ * the pause flag is still guaranteed to end up set
+ * However the potential deadlock now is that if bh thread emptied the queue and cleared the flag before this thread's
+ * call to unifi_pause_xmit(), then bh thread may not run again because it will be waiting for
+ * a packet to appear in the queue but nothing ever will because xmit is paused.
+ * So we will end up with the queue paused, and the flag set to say it is paused, but bh never runs to unpause it.
+ * (Note even this bad situation would not persist long in practice, because something else (eg rx, or tx in different queue)
+ * is likely to wake bh thread quite soon)
+ * But to avoid this deadlock completely, after setting the flag we check that there is something left in the queue.
+ * If there is, we know that bh thread has not emptied the queue yet.
+ * Since bh thread checks to unpause the queue *after* taking packets from the queue, we know that it is still going to make at
+ * least one more check to see whether it needs to unpause the queue. So all is well.
+ * If there are no packets in the queue, then the deadlock described above might happen. To make sure it does not, we
+ * unpause the queue here. A possible side effect is that unifi_restart_xmit() may (rarely) be called for second time
+ * unnecessarily, which is harmless
+ */
+
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ unifi_debug_log_to_buf("P");
+#endif
+ unifi_pause_xmit(card->ospriv, (unifi_TrafficQueue)priority_q);
+ card_tx_q_pause(card, priority_q);
+ if (CSR_WIFI_HIP_Q_SLOTS_USED(sigq) == 0)
+ {
+ card_tx_q_unpause(card, priority_q);
+ unifi_restart_xmit(card->ospriv, (unifi_TrafficQueue) priority_q);
+ }
+ }
+ else
+ {
+ unifi_warning(card->ospriv,
+ "send_signal: fh_cmd_q full, not pausing (run_bh=%d)\n",
+ run_bh);
+ }
+ }
+
+ func_exit();
+
+ return CSR_RESULT_SUCCESS;
+} /* send_signal() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_send_signal
+ *
+ * Invokes send_signal() to queue a signal in the command or traffic queue
+ * If sigptr pointer is NULL, it pokes the bh to check if UniFi is responsive.
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ * sigptr Pointer to signal from card.
+ * siglen Size of the signal
+ * bulkdata Pointer to the bulk data of the signal
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success
+ * CSR_WIFI_HIP_RESULT_NO_SPACE if there were insufficient data slots or no free signal queue entry
+ *
+ * Notes:
+ * unifi_send_signal() is used to queue signals, created by the driver,
+ * to the device. Signals are constructed using the UniFi packed structures.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_send_signal(card_t *card, const CsrUint8 *sigptr, CsrUint32 siglen,
+ const bulk_data_param_t *bulkdata)
+{
+ q_t *sig_soft_q;
+ CsrUint16 signal_id;
+ CsrResult r;
+ CsrUint32 run_bh;
+ CsrUint32 priority_q;
+
+ /* A NULL signal pointer is a request to check if UniFi is responsive */
+ if (sigptr == NULL)
+ {
+ card->bh_reason_host = 1;
+ return unifi_run_bh(card->ospriv);
+ }
+
+ priority_q = 0;
+ run_bh = 1;
+ signal_id = GET_SIGNAL_ID(sigptr);
+ /*
+ * If the signal is a CSR_MA_PACKET_REQUEST ,
+ * we send it using the traffic soft queue. Else we use the command soft queue.
+ */
+ if (signal_id == CSR_MA_PACKET_REQUEST_ID)
+ {
+ CsrUint16 frame_priority;
+
+ if (card->periodic_wake_mode == UNIFI_PERIODIC_WAKE_HOST_ENABLED)
+ {
+ run_bh = 0;
+ }
+
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
+ unifi_debug_log_to_buf("D");
+#endif
+ /* Sanity check: MA-PACKET.req must have a valid bulk data */
+ if ((bulkdata->d[0].data_length == 0) || (bulkdata->d[0].os_data_ptr == NULL))
+ {
+ unifi_error(card->ospriv, "MA-PACKET.req with empty bulk data (%d bytes in %p)\n",
+ bulkdata->d[0].data_length, bulkdata->d[0].os_data_ptr);
+ dump((void *)sigptr, siglen);
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Map the frame priority to a traffic queue index. */
+ frame_priority = GET_PACKED_MA_PACKET_REQUEST_FRAME_PRIORITY(sigptr);
+ priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY)frame_priority);
+
+ sig_soft_q = &card->fh_traffic_queue[priority_q];
+ }
+ else
+ {
+ sig_soft_q = &card->fh_command_queue;
+ }
+
+ r = send_signal(card, sigptr, siglen, bulkdata, sig_soft_q, priority_q, run_bh);
+ /* On error, the caller must free or requeue bulkdata buffers */
+
+ return r;
+} /* unifi_send_signal() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_send_resources_available
+ *
+ * Examines whether there is available space to queue
+ * a signal in the command or traffic queue
+ *
+ * Arguments:
+ * card Pointer to card context struct
+ * sigptr Pointer to signal.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS if resources available
+ * CSR_WIFI_HIP_RESULT_NO_SPACE if there was no free signal queue entry
+ *
+ * Notes:
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_send_resources_available(card_t *card, const CsrUint8 *sigptr)
+{
+ q_t *sig_soft_q;
+ CsrUint16 signal_id = GET_SIGNAL_ID(sigptr);
+
+ /*
+ * If the signal is a CSR_MA_PACKET_REQUEST ,
+ * we send it using the traffic soft queue. Else we use the command soft queue.
+ */
+ if (signal_id == CSR_MA_PACKET_REQUEST_ID)
+ {
+ CsrUint16 frame_priority;
+ CsrUint32 priority_q;
+
+ /* Map the frame priority to a traffic queue index. */
+ frame_priority = GET_PACKED_MA_PACKET_REQUEST_FRAME_PRIORITY(sigptr);
+ priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY)frame_priority);
+
+ sig_soft_q = &card->fh_traffic_queue[priority_q];
+ }
+ else
+ {
+ sig_soft_q = &card->fh_command_queue;
+ }
+
+ /* Check that the fh_data_queue has a free slot */
+ if (!CSR_WIFI_HIP_Q_SLOTS_FREE(sig_soft_q))
+ {
+ unifi_notice(card->ospriv, "unifi_send_resources_available: %s full\n",
+ sig_soft_q->name);
+ return CSR_WIFI_HIP_RESULT_NO_SPACE;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_send_resources_available() */
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+
+/* Generated by hip_dd_l_c_gen.pl */
+
+#include "csr_wifi_hip_signals.h"
+
+#include "csr_wifi_hip_unifi.h"
+
+CsrInt32 SigGetSize(const CSR_SIGNAL *aSignal)
+{
+ switch (aSignal->SignalPrimitiveHeader.SignalId)
+ {
+ case CSR_MA_PACKET_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MA_PACKET_REQUEST);
+ case CSR_MA_PACKET_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MA_PACKET_CONFIRM);
+ case CSR_MA_PACKET_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MA_PACKET_INDICATION);
+ case CSR_MA_PACKET_CANCEL_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MA_PACKET_CANCEL_REQUEST);
+ case CSR_MA_VIF_AVAILABILITY_RESPONSE_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MA_VIF_AVAILABILITY_RESPONSE);
+ case CSR_MA_VIF_AVAILABILITY_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MA_VIF_AVAILABILITY_INDICATION);
+ case CSR_MA_PACKET_ERROR_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MA_PACKET_ERROR_INDICATION);
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_RESET_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_RESET_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_GET_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_GET_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SET_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SET_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_GET_NEXT_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_GET_NEXT_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_POWERMGT_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_POWERMGT_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SCAN_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SCAN_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_HL_SYNC_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_HL_SYNC_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_MEASURE_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_MEASURE_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_MEASURE_INDICATION);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SETKEYS_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SETKEYS_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DELETEKEYS_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DELETEKEYS_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECTED_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_CONNECTED_INDICATION);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CANCEL_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SCAN_CANCEL_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_HL_SYNC_CANCEL_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_HL_SYNC_CANCEL_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_PERIODIC_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_PERIODIC_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_PERIODIC_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_PERIODIC_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SET_PACKET_FILTER_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SET_PACKET_FILTER_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_STOP_MEASURE_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_STOP_MEASURE_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_TRIGGERED_GET_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_TRIGGERED_GET_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_TRIGGERED_GET_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_TRIGGERED_GET_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_TRIGGERED_GET_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_TRIGGERED_GET_INDICATION);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_BLACKOUT_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_BLACKOUT_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLACKOUT_ENDED_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_BLACKOUT_ENDED_INDICATION);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_BLACKOUT_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_BLACKOUT_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_RX_TRIGGER_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_RX_TRIGGER_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_RX_TRIGGER_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_RX_TRIGGER_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_CONNECT_STATUS_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_CONNECT_STATUS_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_TEMPLATE_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_TEMPLATE_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_CONFIG_QUEUE_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_CONFIG_QUEUE_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_TSPEC_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_TSPEC_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_TSPEC_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_DEL_TSPEC_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_START_AGGREGATION_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_START_AGGREGATION_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLOCKACK_ERROR_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_BLOCKACK_ERROR_INDICATION);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_STOP_AGGREGATION_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_STOP_AGGREGATION_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SM_START_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SM_START_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_LEAVE_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_LEAVE_CONFIRM);
+#endif
+ case CSR_MLME_SET_TIM_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SET_TIM_REQUEST);
+ case CSR_MLME_SET_TIM_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SET_TIM_CONFIRM);
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_GET_KEY_SEQUENCE_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_GET_KEY_SEQUENCE_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SET_CHANNEL_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_SET_CHANNEL_CONFIRM);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST);
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM);
+#endif
+ case CSR_DEBUG_STRING_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_DEBUG_STRING_INDICATION);
+ case CSR_DEBUG_WORD16_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_DEBUG_WORD16_INDICATION);
+ case CSR_DEBUG_GENERIC_REQUEST_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_DEBUG_GENERIC_REQUEST);
+ case CSR_DEBUG_GENERIC_CONFIRM_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_DEBUG_GENERIC_CONFIRM);
+ case CSR_DEBUG_GENERIC_INDICATION_ID:
+ return CsrOffsetOf(struct CSR_SIGNAL_PRIMITIVE, u) + sizeof(CSR_DEBUG_GENERIC_INDICATION);
+ default:
+ return 0;
+ }
+}
+
+
+CsrInt32 SigGetDataRefs(CSR_SIGNAL *aSignal, CSR_DATAREF **aDataRef)
+{
+ CsrInt32 numRefs = 0;
+
+ switch (aSignal->SignalPrimitiveHeader.SignalId)
+ {
+ case CSR_MA_PACKET_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MaPacketRequest.Data;
+ aDataRef[numRefs++] = &aSignal->u.MaPacketRequest.Dummydataref2;
+ break;
+ case CSR_MA_PACKET_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MaPacketConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MaPacketConfirm.Dummydataref2;
+ break;
+ case CSR_MA_PACKET_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.MaPacketIndication.Data;
+ aDataRef[numRefs++] = &aSignal->u.MaPacketIndication.Dummydataref2;
+ break;
+ case CSR_MA_PACKET_CANCEL_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MaPacketCancelRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MaPacketCancelRequest.Dummydataref2;
+ break;
+ case CSR_MA_VIF_AVAILABILITY_RESPONSE_ID:
+ aDataRef[numRefs++] = &aSignal->u.MaVifAvailabilityResponse.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MaVifAvailabilityResponse.Dummydataref2;
+ break;
+ case CSR_MA_VIF_AVAILABILITY_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.MaVifAvailabilityIndication.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MaVifAvailabilityIndication.Dummydataref2;
+ break;
+ case CSR_MA_PACKET_ERROR_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.MaPacketErrorIndication.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MaPacketErrorIndication.Dummydataref2;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeResetRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeResetRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeResetConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeResetConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetRequest.MibAttribute;
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetConfirm.MibAttributeValue;
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetRequest.MibAttributeValue;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetConfirm.MibAttributeValue;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetNextRequest.MibAttribute;
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetNextRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetNextConfirm.MibAttributeValue;
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetNextConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmePowermgtRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmePowermgtRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmePowermgtConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmePowermgtConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeScanRequest.ChannelList;
+ aDataRef[numRefs++] = &aSignal->u.MlmeScanRequest.InformationElements;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeScanConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeScanConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeHlSyncRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeHlSyncRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeHlSyncConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeHlSyncConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeMeasureRequest.MeasurementRequestSet;
+ aDataRef[numRefs++] = &aSignal->u.MlmeMeasureRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeMeasureConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeMeasureConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeMeasureIndication.MeasurementReportSet;
+ aDataRef[numRefs++] = &aSignal->u.MlmeMeasureIndication.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetkeysRequest.Key;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetkeysRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetkeysConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetkeysConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDeletekeysRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDeletekeysRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDeletekeysConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDeletekeysConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAutonomousScanLossIndication.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAutonomousScanLossIndication.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECTED_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeConnectedIndication.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeConnectedIndication.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CANCEL_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeScanCancelRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeScanCancelRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeHlSyncCancelRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeHlSyncCancelRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeHlSyncCancelConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeHlSyncCancelConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddPeriodicRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddPeriodicRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddPeriodicConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddPeriodicConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelPeriodicRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelPeriodicRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelPeriodicConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelPeriodicConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddAutonomousScanRequest.ChannelList;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddAutonomousScanRequest.InformationElements;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddAutonomousScanConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddAutonomousScanConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelAutonomousScanRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelAutonomousScanRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelAutonomousScanConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelAutonomousScanConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetPacketFilterRequest.InformationElements;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetPacketFilterRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetPacketFilterConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetPacketFilterConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeStopMeasureRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeStopMeasureRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeStopMeasureConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeStopMeasureConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmePauseAutonomousScanRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmePauseAutonomousScanRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmePauseAutonomousScanConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmePauseAutonomousScanConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAutonomousScanDoneIndication.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAutonomousScanDoneIndication.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTriggeredGetRequest.MibAttribute;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTriggeredGetRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTriggeredGetConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTriggeredGetConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelTriggeredGetRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelTriggeredGetRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelTriggeredGetConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelTriggeredGetConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_TRIGGERED_GET_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeTriggeredGetIndication.MibAttributeValue;
+ aDataRef[numRefs++] = &aSignal->u.MlmeTriggeredGetIndication.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddBlackoutRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddBlackoutRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddBlackoutConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddBlackoutConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLACKOUT_ENDED_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeBlackoutEndedIndication.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeBlackoutEndedIndication.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelBlackoutRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelBlackoutRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelBlackoutConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelBlackoutConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddRxTriggerRequest.InformationElements;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddRxTriggerRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddRxTriggerConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddRxTriggerConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelRxTriggerRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelRxTriggerRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelRxTriggerConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelRxTriggerConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeConnectStatusRequest.InformationElements;
+ aDataRef[numRefs++] = &aSignal->u.MlmeConnectStatusRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeConnectStatusConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeConnectStatusConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeModifyBssParameterRequest.Data;
+ aDataRef[numRefs++] = &aSignal->u.MlmeModifyBssParameterRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeModifyBssParameterConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeModifyBssParameterConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTemplateRequest.Data1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTemplateRequest.Data2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTemplateConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTemplateConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeConfigQueueRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeConfigQueueRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeConfigQueueConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeConfigQueueConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTspecRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTspecRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTspecConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddTspecConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelTspecRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelTspecRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelTspecConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeDelTspecConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeStartAggregationRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeStartAggregationRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeStartAggregationConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeStartAggregationConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLOCKACK_ERROR_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeBlockackErrorIndication.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeBlockackErrorIndication.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeStopAggregationRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeStopAggregationRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeStopAggregationConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeStopAggregationConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSmStartRequest.Beacon;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSmStartRequest.BssParameters;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSmStartConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSmStartConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeLeaveRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeLeaveRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeLeaveConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeLeaveConfirm.Dummydataref2;
+ break;
+#endif
+ case CSR_MLME_SET_TIM_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetTimRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetTimRequest.Dummydataref2;
+ break;
+ case CSR_MLME_SET_TIM_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetTimConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetTimConfirm.Dummydataref2;
+ break;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetKeySequenceRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetKeySequenceRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetKeySequenceConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeGetKeySequenceConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetChannelRequest.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetChannelRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetChannelConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeSetChannelConfirm.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddMulticastAddressRequest.Data;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddMulticastAddressRequest.Dummydataref2;
+ break;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddMulticastAddressConfirm.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.MlmeAddMulticastAddressConfirm.Dummydataref2;
+ break;
+#endif
+ case CSR_DEBUG_STRING_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.DebugStringIndication.DebugMessage;
+ aDataRef[numRefs++] = &aSignal->u.DebugStringIndication.Dummydataref2;
+ break;
+ case CSR_DEBUG_WORD16_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.DebugWord16Indication.Dummydataref1;
+ aDataRef[numRefs++] = &aSignal->u.DebugWord16Indication.Dummydataref2;
+ break;
+ case CSR_DEBUG_GENERIC_REQUEST_ID:
+ aDataRef[numRefs++] = &aSignal->u.DebugGenericRequest.DebugVariable;
+ aDataRef[numRefs++] = &aSignal->u.DebugGenericRequest.Dummydataref2;
+ break;
+ case CSR_DEBUG_GENERIC_CONFIRM_ID:
+ aDataRef[numRefs++] = &aSignal->u.DebugGenericConfirm.DebugVariable;
+ aDataRef[numRefs++] = &aSignal->u.DebugGenericConfirm.Dummydataref2;
+ break;
+ case CSR_DEBUG_GENERIC_INDICATION_ID:
+ aDataRef[numRefs++] = &aSignal->u.DebugGenericIndication.DebugVariable;
+ aDataRef[numRefs++] = &aSignal->u.DebugGenericIndication.Dummydataref2;
+ break;
+ default:
+ return 0;
+ }
+ return numRefs;
+}
+
+
+CsrUint32 SigGetFilterPos(CsrUint16 aSigID)
+{
+ switch (aSigID)
+ {
+ case CSR_MA_PACKET_REQUEST_ID:
+ return 0x00000001;
+ case CSR_MA_PACKET_CONFIRM_ID:
+ return 0x00000002;
+ case CSR_MA_PACKET_INDICATION_ID:
+ return 0x00000004;
+ case CSR_MA_PACKET_CANCEL_REQUEST_ID:
+ return 0x00000008;
+ case CSR_MA_VIF_AVAILABILITY_RESPONSE_ID:
+ return 0x00000010;
+ case CSR_MA_VIF_AVAILABILITY_INDICATION_ID:
+ return 0x00000020;
+ case CSR_MA_PACKET_ERROR_INDICATION_ID:
+ return 0x00000040;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_REQUEST_ID:
+ return 0x00000080;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_RESET_CONFIRM_ID:
+ return 0x00000100;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_REQUEST_ID:
+ return 0x00000200;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_CONFIRM_ID:
+ return 0x00000400;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_REQUEST_ID:
+ return 0x00000800;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CONFIRM_ID:
+ return 0x00001000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_REQUEST_ID:
+ return 0x00002000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_NEXT_CONFIRM_ID:
+ return 0x00004000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_REQUEST_ID:
+ return 0x00008000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_POWERMGT_CONFIRM_ID:
+ return 0x00010001;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_REQUEST_ID:
+ return 0x00010002;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CONFIRM_ID:
+ return 0x00010004;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_REQUEST_ID:
+ return 0x00010008;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CONFIRM_ID:
+ return 0x00010010;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_REQUEST_ID:
+ return 0x00010020;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_CONFIRM_ID:
+ return 0x00010040;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MEASURE_INDICATION_ID:
+ return 0x00010080;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_REQUEST_ID:
+ return 0x00010100;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SETKEYS_CONFIRM_ID:
+ return 0x00010200;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_REQUEST_ID:
+ return 0x00010400;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DELETEKEYS_CONFIRM_ID:
+ return 0x00010800;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION_ID:
+ return 0x00011000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECTED_INDICATION_ID:
+ return 0x00012000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SCAN_CANCEL_REQUEST_ID:
+ return 0x00014000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_REQUEST_ID:
+ return 0x00018000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_HL_SYNC_CANCEL_CONFIRM_ID:
+ return 0x00020001;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_REQUEST_ID:
+ return 0x00020002;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_PERIODIC_CONFIRM_ID:
+ return 0x00020004;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_REQUEST_ID:
+ return 0x00020008;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_PERIODIC_CONFIRM_ID:
+ return 0x00020010;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST_ID:
+ return 0x00020020;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM_ID:
+ return 0x00020040;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST_ID:
+ return 0x00020080;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM_ID:
+ return 0x00020100;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_REQUEST_ID:
+ return 0x00020200;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_PACKET_FILTER_CONFIRM_ID:
+ return 0x00020400;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_REQUEST_ID:
+ return 0x00020800;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_MEASURE_CONFIRM_ID:
+ return 0x00021000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST_ID:
+ return 0x00022000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM_ID:
+ return 0x00024000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION_ID:
+ return 0x00028000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_REQUEST_ID:
+ return 0x00030001;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TRIGGERED_GET_CONFIRM_ID:
+ return 0x00030002;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_REQUEST_ID:
+ return 0x00030004;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TRIGGERED_GET_CONFIRM_ID:
+ return 0x00030008;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_TRIGGERED_GET_INDICATION_ID:
+ return 0x00030010;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_REQUEST_ID:
+ return 0x00030020;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_BLACKOUT_CONFIRM_ID:
+ return 0x00030040;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLACKOUT_ENDED_INDICATION_ID:
+ return 0x00030080;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_REQUEST_ID:
+ return 0x00030100;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_BLACKOUT_CONFIRM_ID:
+ return 0x00030200;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_REQUEST_ID:
+ return 0x00030400;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_RX_TRIGGER_CONFIRM_ID:
+ return 0x00030800;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_REQUEST_ID:
+ return 0x00031000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_RX_TRIGGER_CONFIRM_ID:
+ return 0x00032000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_REQUEST_ID:
+ return 0x00034000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONNECT_STATUS_CONFIRM_ID:
+ return 0x00038000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST_ID:
+ return 0x00040001;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM_ID:
+ return 0x00040002;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_REQUEST_ID:
+ return 0x00040004;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TEMPLATE_CONFIRM_ID:
+ return 0x00040008;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_REQUEST_ID:
+ return 0x00040010;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_CONFIG_QUEUE_CONFIRM_ID:
+ return 0x00040020;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_REQUEST_ID:
+ return 0x00040040;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_TSPEC_CONFIRM_ID:
+ return 0x00040080;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_REQUEST_ID:
+ return 0x00040100;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_DEL_TSPEC_CONFIRM_ID:
+ return 0x00040200;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_REQUEST_ID:
+ return 0x00040400;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_START_AGGREGATION_CONFIRM_ID:
+ return 0x00040800;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_BLOCKACK_ERROR_INDICATION_ID:
+ return 0x00041000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_REQUEST_ID:
+ return 0x00042000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_STOP_AGGREGATION_CONFIRM_ID:
+ return 0x00044000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_REQUEST_ID:
+ return 0x00048000;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SM_START_CONFIRM_ID:
+ return 0x00050001;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_REQUEST_ID:
+ return 0x00050002;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_LEAVE_CONFIRM_ID:
+ return 0x00050004;
+#endif
+ case CSR_MLME_SET_TIM_REQUEST_ID:
+ return 0x00050008;
+ case CSR_MLME_SET_TIM_CONFIRM_ID:
+ return 0x00050010;
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_REQUEST_ID:
+ return 0x00050020;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_GET_KEY_SEQUENCE_CONFIRM_ID:
+ return 0x00050040;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_REQUEST_ID:
+ return 0x00050080;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_SET_CHANNEL_CONFIRM_ID:
+ return 0x00050100;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST_ID:
+ return 0x00050200;
+#endif
+#ifdef CSR_WIFI_HIP_FULL_SIGNAL_SET
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM_ID:
+ return 0x00050400;
+#endif
+ case CSR_DEBUG_STRING_INDICATION_ID:
+ return 0x00050800;
+ case CSR_DEBUG_WORD16_INDICATION_ID:
+ return 0x00051000;
+ case CSR_DEBUG_GENERIC_REQUEST_ID:
+ return 0x00052000;
+ case CSR_DEBUG_GENERIC_CONFIRM_ID:
+ return 0x00054000;
+ case CSR_DEBUG_GENERIC_INDICATION_ID:
+ return 0x00058000;
+ default:
+ break;
+ }
+ return 0xffffffff;
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ *****************************************************************************
+ *
+ * FILE: csr_wifi_hip_signals.h
+ *
+ * PURPOSE:
+ * Header file wrapping the auto-generated code in csr_wifi_hip_sigs.h
+ * and csr_wifi_hip_signals.c -
+ * csr_wifi_hip_sigs.h provides structures defining UniFi signals and
+ * csr_wifi_hip_signals.c provides SigGetSize() and SigGetDataRefs().
+ *
+ *****************************************************************************
+ */
+#ifndef __CSR_WIFI_HIP_SIGNALS_H__
+#define __CSR_WIFI_HIP_SIGNALS_H__
+
+#include "csr_types.h"
+#include "csr_wifi_hip_sigs.h"
+
+
+/****************************************************************************/
+/* INFORMATION ELEMENTS */
+/****************************************************************************/
+
+/* Information Element ID's - shouldn't be in here, but nowhere better yet */
+#define IE_SSID_ID 0
+#define IE_SUPPORTED_RATES_ID 1
+#define IE_FH_PARAM_SET_ID 2
+#define IE_DS_PARAM_SET_ID 3
+#define IE_CF_PARAM_SET_ID 4
+#define IE_TIM_ID 5
+#define IE_IBSS_PARAM_SET_ID 6
+#define IE_COUNTRY_ID 7
+#define IE_HOPPING_PATTERN_PARAMS_ID 8
+#define IE_HOPPING_PATTERN_TABLE_ID 9
+#define IE_REQUEST_ID 10
+#define IE_QBSS_LOAD_ID 11
+#define IE_EDCA_PARAM_SET_ID 12
+#define IE_TRAFFIC_SPEC_ID 13
+#define IE_TRAFFIC_CLASS_ID 14
+#define IE_SCHEDULE_ID 15
+#define IE_CHALLENGE_TEXT_ID 16
+#define IE_POWER_CONSTRAINT_ID 32
+#define IE_POWER_CAPABILITY_ID 33
+#define IE_TPC_REQUEST_ID 34
+#define IE_TPC_REPORT_ID 35
+#define IE_SUPPORTED_CHANNELS_ID 36
+#define IE_CHANNEL_SWITCH_ANNOUNCE_ID 37
+#define IE_MEASUREMENT_REQUEST_ID 38
+#define IE_MEASUREMENT_REPORT_ID 39
+#define IE_QUIET_ID 40
+#define IE_IBSS_DFS_ID 41
+#define IE_ERP_INFO_ID 42
+#define IE_TS_DELAY_ID 43
+#define IE_TCLAS_PROCESSING_ID 44
+#define IE_QOS_CAPABILITY_ID 46
+#define IE_RSN_ID 48
+#define IE_EXTENDED_SUPPORTED_RATES_ID 50
+#define IE_AP_CHANNEL_REPORT_ID 52
+#define IE_RCPI_ID 53
+#define IE_WPA_ID 221
+
+
+/* The maximum number of data references in a signal structure */
+#define UNIFI_MAX_DATA_REFERENCES 2
+
+/* The space to allow for a wire-format signal structure */
+#define UNIFI_PACKED_SIGBUF_SIZE 64
+
+
+/******************************************************************************/
+/* SIGNAL PARAMETER VALUES */
+/******************************************************************************/
+
+/* ifIndex */
+#define UNIFI_IF_2G4 1
+#define UNIFI_IF_5G 2
+
+/* SendProcessId */
+#define HOST_PROC_ID 0xc000
+
+#define SIG_CAP_ESS 0x0001
+#define SIG_CAP_IBSS 0x0002
+#define SIG_CAP_CF_POLLABLE 0x0004
+#define SIG_CAP_CF_POLL_REQUEST 0x0008
+#define SIG_CAP_PRIVACY 0x0010
+#define SIG_CAP_SHORT_PREAMBLE 0x0020
+#define SIG_CAP_DSSSOFDM 0x2000
+
+/******************************************************************************/
+/* FUNCTION DECLARATIONS */
+/******************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/******************************************************************************
+ * SigGetNumDataRefs - Retrieve pointers to data-refs from a signal.
+ *
+ * PARAMETERS:
+ * aSignal - Pointer to signal to retrieve the data refs of.
+ * aDataRef - Address of a pointer to the structure that the data refs
+ * pointers will be stored.
+ *
+ * RETURNS:
+ * The number of data-refs in the signal.
+ */
+CsrInt32 SigGetDataRefs(CSR_SIGNAL *aSignal, CSR_DATAREF **aDataRef);
+
+/******************************************************************************
+ * SigGetSize - Retrieve the size (in bytes) of a given signal.
+ *
+ * PARAMETERS:
+ * aSignal - Pointer to signal to retrieve size of.
+ *
+ * RETURNS:
+ * The size (in bytes) of the given signal.
+ */
+CsrInt32 SigGetSize(const CSR_SIGNAL *aSignal);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __CSR_WIFI_HIP_SIGNALS_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+
+/* Generated by hip_dd_l_h_gen.pl */
+
+#ifndef CSR_WIFI_HIP_SIGS_H
+#define CSR_WIFI_HIP_SIGS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef CsrInt16 csr_place_holding_type;
+
+typedef CsrUint16 CSR_ASSOCIATION_ID;
+
+typedef CsrUint16 CSR_AUTONOMOUS_SCAN_ID;
+
+typedef CsrUint16 CSR_BEACON_PERIODS;
+
+typedef CsrUint16 CSR_BLACKOUT_ID;
+
+typedef enum CSR_BLACKOUT_SOURCE
+{
+ CSR_DOT11_LOCAL = 0x0000,
+ CSR_DOT11_REMOTE = 0x0001,
+ CSR_OTHER_RADIO = 0x0002,
+ CSR_NOT_LINKED = 0x0004
+} CSR_BLACKOUT_SOURCE;
+
+typedef enum CSR_BLACKOUT_TYPE
+{
+ CSR_LOCAL_DEVICE_ONLY = 0x0001,
+ CSR_SPECIFIED_PEER = 0x0002,
+ CSR_CURRENT_CHANNEL = 0x0004,
+ CSR_P2P = 0x0008
+} CSR_BLACKOUT_TYPE;
+
+typedef enum CSR_BOOT_LOADER_OPERATION
+{
+ CSR_BOOT_LOADER_IDLE = 0x00,
+ CSR_BOOT_LOADER_RESTART = 0x01,
+ CSR_BOOT_LOADER_PATCH = 0x02,
+ CSR_BOOT_LOADER_IMAGE_0 = 0x10,
+ CSR_BOOT_LOADER_IMAGE_1 = 0x11,
+ CSR_BOOT_LOADER_IMAGE_2 = 0x12,
+ CSR_BOOT_LOADER_IMAGE_3 = 0x13
+} CSR_BOOT_LOADER_OPERATION;
+
+typedef CsrUint16 CSR_CAPABILITY_INFORMATION;
+
+typedef CsrUint16 CSR_CHANNEL_STARTING_FACTOR;
+
+typedef CsrUint32 CSR_CIPHER_SUITE_SELECTOR;
+
+typedef CsrUint32 CSR_CLIENT_TAG;
+
+typedef enum CSR_CONNECTION_STATUS
+{
+ CSR_DISCONNECTED = 0x0000,
+ CSR_CONNECTED_AWAKE = 0x0001
+} CSR_CONNECTION_STATUS;
+
+typedef CsrInt16 CSR_DECIBELS;
+
+typedef enum CSR_DIRECTION
+{
+ CSR_TRANSMIT = 0x0000,
+ CSR_RECEIVE = 0x0001,
+ CSR_BIDIRECTIONAL = 0x0003
+} CSR_DIRECTION;
+
+typedef enum CSR_FRAME_TYPE
+{
+ CSR_RESERVED = 0x0000,
+ CSR_BEACON = 0x0001,
+ CSR_PROBE_RESPONSE = 0x0002,
+ CSR_BEACON_AND_PROBE_RESPONSE = 0x0003,
+ CSR_PROBE_REQUEST = 0x0004
+} CSR_FRAME_TYPE;
+
+typedef CsrUint32 CSR_IPV4_ADDRESS;
+
+typedef enum CSR_IFINTERFACE
+{
+ CSR_INDEX_2G4 = 0x0001,
+ CSR_INDEX_5G = 0x0002
+} CSR_IFINTERFACE;
+
+typedef enum CSR_KEY_TYPE
+{
+ CSR_GROUP = 0x0000,
+ CSR_PAIRWISE = 0x0001,
+ CSR_PEER_KEY = 0x0002,
+ CSR_IGTK = 0x0003
+} CSR_KEY_TYPE;
+
+typedef enum CSR_LOADER_OPERATION
+{
+ CSR_LOADER_IDLE = 0x0000,
+ CSR_LOADER_COPY = 0x0001
+} CSR_LOADER_OPERATION;
+
+typedef struct CSR_MAC_ADDRESS
+{
+ CsrUint8 x[6];
+} CSR_MACADDRESS;
+
+typedef enum CSR_MIB_STATUS
+{
+ CSR_MIB_SUCCESSFUL = 0x0000,
+ CSR_MIB_INVALID_PARAMETERS = 0x0001,
+ CSR_MIB_WRITE_ONLY = 0x0002,
+ CSR_MIB_READ_ONLY = 0x0003
+} CSR_MIB_STATUS;
+
+typedef enum CSR_MEMORY_SPACE
+{
+ CSR_NONE = 0x00,
+ CSR_SHARED_DATA_MEMORY = 0x01,
+ CSR_EXTERNAL_FLASH_MEMORY = 0x02,
+ CSR_EXTERNAL_SRAM = 0x03,
+ CSR_REGISTERS = 0x04,
+ CSR_PHY_PROCESSOR_DATA_MEMORY = 0x10,
+ CSR_PHY_PROCESSOR_PROGRAM_MEMORY = 0x11,
+ CSR_PHY_PROCESSOR_ROM = 0x12,
+ CSR_MAC_PROCESSOR_DATA_MEMORY = 0x20,
+ CSR_MAC_PROCESSOR_PROGRAM_MEMORY = 0x21,
+ CSR_MAC_PROCESSOR_ROM = 0x22,
+ CSR_BT_PROCESSOR_DATA_MEMORY = 0x30,
+ CSR_BT_PROCESSOR_PROGRAM_MEMORY = 0x31,
+ CSR_BT_PROCESSOR_ROM = 0x32
+} CSR_MEMORY_SPACE;
+
+typedef CsrUint16 CSR_MICROSECONDS16;
+
+typedef CsrUint32 CSR_MICROSECONDS32;
+
+typedef CsrUint16 CSR_NATURAL16;
+
+typedef enum CSR_PS_SCHEME
+{
+ CSR_LEGACY_PS = 0x0001,
+ CSR_U_APSD = 0x0002,
+ CSR_S_APSD = 0x0004
+} CSR_PS_SCHEME;
+
+typedef enum CSR_PACKET_FILTER_MODE
+{
+ CSR_PFM_OPT_OUT = 0x0000,
+ CSR_PFM_OPT_IN = 0x0003
+} CSR_PACKET_FILTER_MODE;
+
+typedef CsrUint16 CSR_PERIODIC_ID;
+
+typedef enum CSR_PERIODIC_SCHEDULING_MODE
+{
+ CSR_PSM_PERIODIC_SCHEDULE_PS_POLL = 0x0001,
+ CSR_PSM_PERIODIC_SCHEDULE_PM_BIT = 0x0002,
+ CSR_PSM_PERIODIC_SCHEDULE_UAPSD = 0x0004,
+ CSR_PSM_PERIODIC_SCHEDULE_SAPSD = 0x0008
+} CSR_PERIODIC_SCHEDULING_MODE;
+
+typedef enum CSR_POWER_MANAGEMENT_MODE
+{
+ CSR_PMM_ACTIVE_MODE = 0x0000,
+ CSR_PMM_POWER_SAVE = 0x0001,
+ CSR_PMM_FAST_POWER_SAVE = 0x0002
+} CSR_POWER_MANAGEMENT_MODE;
+
+typedef enum CSR_PRIORITY
+{
+ CSR_QOS_UP0 = 0x0000,
+ CSR_QOS_UP1 = 0x0001,
+ CSR_QOS_UP2 = 0x0002,
+ CSR_QOS_UP3 = 0x0003,
+ CSR_QOS_UP4 = 0x0004,
+ CSR_QOS_UP5 = 0x0005,
+ CSR_QOS_UP6 = 0x0006,
+ CSR_QOS_UP7 = 0x0007,
+ CSR_CONTENTION = 0x8000,
+ CSR_MANAGEMENT = 0x8010
+} CSR_PRIORITY;
+
+typedef enum CSR_REASON_CODE
+{
+ CSR_UNSPECIFIED_REASON = 0x0001,
+ CSR_INVALID_INFORMATION_ELEMENT = 0x000d,
+ CSR_QOS_UNSPECIFIED_REASON = 0x0020,
+ CSR_QOS_EXCESSIVE_NOT_ACK = 0x0022,
+ CSR_QOS_TXOP_LIMIT_EXCEEDED = 0x0023,
+ CSR_QSTA_LEAVING = 0x0024,
+ CSR_UNKNOWN_BA = 0x0026,
+ CSR_UNKNOWN_TS = 0x0026,
+ CSR_TIMEOUT = 0x0027
+} CSR_REASON_CODE;
+
+typedef enum CSR_RECEPTION_STATUS
+{
+ CSR_RX_SUCCESS = 0x0000,
+ CSR_RX_FAILURE_UNSPECIFIED = 0x0001,
+ CSR_MICHAEL_MIC_ERROR = 0x0002,
+ CSR_DECRYPTION_ERROR = 0x0003,
+ CSR_NO_TEMPORAL_KEY_AVAILABLE = 0x0004,
+ CSR_UNSUPPORTED_MODULATION = 0x0011,
+ CSR_BAD_FCS = 0x0012,
+ CSR_BAD_SIGNAL = 0x0013
+} CSR_RECEPTION_STATUS;
+
+typedef enum CSR_RESULT_CODE
+{
+ CSR_RC_SUCCESS = 0x0000,
+ CSR_RC_UNSPECIFIED_FAILURE = 0x0001,
+ CSR_RC_REFUSED = 0x0003,
+ CSR_RC_INVALID_PARAMETERS = 0x0026,
+ CSR_RC_REJECTED_INVALID_IE = 0x0028,
+ CSR_RC_REJECTED_INVALID_GROUP_CIPHER = 0x0029,
+ CSR_RC_REJECTED_INVALID_PAIRWISE_CIPHER = 0x002a,
+ CSR_RC_TIMEOUT = 0x8000,
+ CSR_RC_TOO_MANY_SIMULTANEOUS_REQUESTS = 0x8001,
+ CSR_RC_BSS_ALREADY_STARTED_OR_JOINED = 0x8002,
+ CSR_RC_NOT_SUPPORTED = 0x8003,
+ CSR_RC_TRANSMISSION_FAILURE = 0x8004,
+ CSR_RC_RESET_REQUIRED_BEFORE_START = 0x8006,
+ CSR_RC_INSUFFICIENT_RESOURCE = 0x8007,
+ CSR_RC_NO_BUFFERED_BROADCAST_MULTICAST_FRAMES = 0x8008,
+ CSR_RC_INVALID_UNICAST_CIPHER = 0xf02f,
+ CSR_RC_INVALID_MULTICAST_CIPHER = 0xf030
+} CSR_RESULT_CODE;
+
+typedef enum CSR_SCAN_TYPE
+{
+ CSR_SC_ACTIVE_SCAN = 0x0000,
+ CSR_SC_PASSIVE_SCAN = 0x0001
+} CSR_SCAN_TYPE;
+
+typedef enum CSR_SIGNAL_ID
+{
+ CSR_MA_PACKET_REQUEST_ID = 0x0110,
+ CSR_MA_PACKET_CONFIRM_ID = 0x0111,
+ CSR_MA_PACKET_INDICATION_ID = 0x0113,
+ CSR_MA_PACKET_CANCEL_REQUEST_ID = 0x0114,
+ CSR_MA_VIF_AVAILABILITY_RESPONSE_ID = 0x0116,
+ CSR_MA_VIF_AVAILABILITY_INDICATION_ID = 0x0117,
+ CSR_MA_PACKET_ERROR_INDICATION_ID = 0x011b,
+ CSR_MLME_RESET_REQUEST_ID = 0x0200,
+ CSR_MLME_RESET_CONFIRM_ID = 0x0201,
+ CSR_MLME_GET_REQUEST_ID = 0x0204,
+ CSR_MLME_GET_CONFIRM_ID = 0x0205,
+ CSR_MLME_SET_REQUEST_ID = 0x0208,
+ CSR_MLME_SET_CONFIRM_ID = 0x0209,
+ CSR_MLME_GET_NEXT_REQUEST_ID = 0x020c,
+ CSR_MLME_GET_NEXT_CONFIRM_ID = 0x020d,
+ CSR_MLME_POWERMGT_REQUEST_ID = 0x0210,
+ CSR_MLME_POWERMGT_CONFIRM_ID = 0x0211,
+ CSR_MLME_SCAN_REQUEST_ID = 0x0214,
+ CSR_MLME_SCAN_CONFIRM_ID = 0x0215,
+ CSR_MLME_HL_SYNC_REQUEST_ID = 0x0244,
+ CSR_MLME_HL_SYNC_CONFIRM_ID = 0x0245,
+ CSR_MLME_MEASURE_REQUEST_ID = 0x0258,
+ CSR_MLME_MEASURE_CONFIRM_ID = 0x0259,
+ CSR_MLME_MEASURE_INDICATION_ID = 0x025b,
+ CSR_MLME_SETKEYS_REQUEST_ID = 0x0268,
+ CSR_MLME_SETKEYS_CONFIRM_ID = 0x0269,
+ CSR_MLME_DELETEKEYS_REQUEST_ID = 0x026c,
+ CSR_MLME_DELETEKEYS_CONFIRM_ID = 0x026d,
+ CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION_ID = 0x0287,
+ CSR_MLME_CONNECTED_INDICATION_ID = 0x028b,
+ CSR_MLME_SCAN_CANCEL_REQUEST_ID = 0x028c,
+ CSR_MLME_HL_SYNC_CANCEL_REQUEST_ID = 0x0298,
+ CSR_MLME_HL_SYNC_CANCEL_CONFIRM_ID = 0x0299,
+ CSR_MLME_ADD_PERIODIC_REQUEST_ID = 0x02a0,
+ CSR_MLME_ADD_PERIODIC_CONFIRM_ID = 0x02a1,
+ CSR_MLME_DEL_PERIODIC_REQUEST_ID = 0x02a4,
+ CSR_MLME_DEL_PERIODIC_CONFIRM_ID = 0x02a5,
+ CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST_ID = 0x02a8,
+ CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM_ID = 0x02a9,
+ CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST_ID = 0x02ac,
+ CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM_ID = 0x02ad,
+ CSR_MLME_SET_PACKET_FILTER_REQUEST_ID = 0x02b8,
+ CSR_MLME_SET_PACKET_FILTER_CONFIRM_ID = 0x02b9,
+ CSR_MLME_STOP_MEASURE_REQUEST_ID = 0x02bc,
+ CSR_MLME_STOP_MEASURE_CONFIRM_ID = 0x02bd,
+ CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST_ID = 0x02cc,
+ CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM_ID = 0x02cd,
+ CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION_ID = 0x02db,
+ CSR_MLME_ADD_TRIGGERED_GET_REQUEST_ID = 0x02dc,
+ CSR_MLME_ADD_TRIGGERED_GET_CONFIRM_ID = 0x02dd,
+ CSR_MLME_DEL_TRIGGERED_GET_REQUEST_ID = 0x02e0,
+ CSR_MLME_DEL_TRIGGERED_GET_CONFIRM_ID = 0x02e1,
+ CSR_MLME_TRIGGERED_GET_INDICATION_ID = 0x02e7,
+ CSR_MLME_ADD_BLACKOUT_REQUEST_ID = 0x02f8,
+ CSR_MLME_ADD_BLACKOUT_CONFIRM_ID = 0x02f9,
+ CSR_MLME_BLACKOUT_ENDED_INDICATION_ID = 0x02fb,
+ CSR_MLME_DEL_BLACKOUT_REQUEST_ID = 0x02fc,
+ CSR_MLME_DEL_BLACKOUT_CONFIRM_ID = 0x02fd,
+ CSR_MLME_ADD_RX_TRIGGER_REQUEST_ID = 0x0304,
+ CSR_MLME_ADD_RX_TRIGGER_CONFIRM_ID = 0x0305,
+ CSR_MLME_DEL_RX_TRIGGER_REQUEST_ID = 0x0308,
+ CSR_MLME_DEL_RX_TRIGGER_CONFIRM_ID = 0x0309,
+ CSR_MLME_CONNECT_STATUS_REQUEST_ID = 0x0310,
+ CSR_MLME_CONNECT_STATUS_CONFIRM_ID = 0x0311,
+ CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST_ID = 0x0314,
+ CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM_ID = 0x0315,
+ CSR_MLME_ADD_TEMPLATE_REQUEST_ID = 0x0318,
+ CSR_MLME_ADD_TEMPLATE_CONFIRM_ID = 0x0319,
+ CSR_MLME_CONFIG_QUEUE_REQUEST_ID = 0x031c,
+ CSR_MLME_CONFIG_QUEUE_CONFIRM_ID = 0x031d,
+ CSR_MLME_ADD_TSPEC_REQUEST_ID = 0x0320,
+ CSR_MLME_ADD_TSPEC_CONFIRM_ID = 0x0321,
+ CSR_MLME_DEL_TSPEC_REQUEST_ID = 0x0324,
+ CSR_MLME_DEL_TSPEC_CONFIRM_ID = 0x0325,
+ CSR_MLME_START_AGGREGATION_REQUEST_ID = 0x0328,
+ CSR_MLME_START_AGGREGATION_CONFIRM_ID = 0x0329,
+ CSR_MLME_BLOCKACK_ERROR_INDICATION_ID = 0x032b,
+ CSR_MLME_STOP_AGGREGATION_REQUEST_ID = 0x032c,
+ CSR_MLME_STOP_AGGREGATION_CONFIRM_ID = 0x032d,
+ CSR_MLME_SM_START_REQUEST_ID = 0x0334,
+ CSR_MLME_SM_START_CONFIRM_ID = 0x0335,
+ CSR_MLME_LEAVE_REQUEST_ID = 0x0338,
+ CSR_MLME_LEAVE_CONFIRM_ID = 0x0339,
+ CSR_MLME_SET_TIM_REQUEST_ID = 0x033c,
+ CSR_MLME_SET_TIM_CONFIRM_ID = 0x033d,
+ CSR_MLME_GET_KEY_SEQUENCE_REQUEST_ID = 0x0340,
+ CSR_MLME_GET_KEY_SEQUENCE_CONFIRM_ID = 0x0341,
+ CSR_MLME_SET_CHANNEL_REQUEST_ID = 0x034c,
+ CSR_MLME_SET_CHANNEL_CONFIRM_ID = 0x034d,
+ CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST_ID = 0x040c,
+ CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM_ID = 0x040d,
+ CSR_DEBUG_STRING_INDICATION_ID = 0x0803,
+ CSR_DEBUG_WORD16_INDICATION_ID = 0x0807,
+ CSR_DEBUG_GENERIC_REQUEST_ID = 0x0808,
+ CSR_DEBUG_GENERIC_CONFIRM_ID = 0x0809,
+ CSR_DEBUG_GENERIC_INDICATION_ID = 0x080b
+} CSR_SIGNAL_ID;
+
+typedef CsrUint16 CSR_SIMPLE_POINTER;
+
+typedef CsrUint16 CSR_STARTING_SEQUENCE_NUMBER;
+
+typedef enum CSR_SYMBOL_ID
+{
+ CSR_SLT_END = 0x0000,
+ CSR_SLT_PCI_SLOT_CONFIG = 0x0001,
+ CSR_SLT_SDIO_SLOT_CONFIG = 0x0002,
+ CSR_SLT_BUILD_ID_NUMBER = 0x0003,
+ CSR_SLT_BUILD_ID_STRING = 0x0004,
+ CSR_SLT_PERSISTENT_STORE_DB = 0x0005,
+ CSR_SLT_RESET_VECTOR_PHY = 0x0006,
+ CSR_SLT_RESET_VECTOR_MAC = 0x0007,
+ CSR_SLT_SDIO_LOADER_CONTROL = 0x0008,
+ CSR_SLT_TEST_CMD = 0x0009,
+ CSR_SLT_TEST_ALIVE_COUNTER = 0x000a,
+ CSR_SLT_TEST_PARAMETERS = 0x000b,
+ CSR_SLT_TEST_RESULTS = 0x000c,
+ CSR_SLT_TEST_VERSION = 0x000d,
+ CSR_SLT_MIB_PSID_RANGES = 0x000e,
+ CSR_SLT_KIP_TABLE = 0x000f,
+ CSR_SLT_PANIC_DATA_PHY = 0x0010,
+ CSR_SLT_PANIC_DATA_MAC = 0x0011,
+ CSR_SLT_BOOT_LOADER_CONTROL = 0x0012,
+ CSR_SLT_SOFT_MAC = 0x0013
+} CSR_SYMBOL_ID;
+
+typedef struct CSR_TSF_TIME
+{
+ CsrUint8 x[8];
+} CSR_TSF_TIME;
+
+typedef CsrUint16 CSR_TIME_UNITS;
+
+typedef enum CSR_TRANSMISSION_CONTROL
+{
+ CSR_TRIGGERED = 0x0001,
+ CSR_END_OF_SERVICE = 0x0002,
+ CSR_NO_CONFIRM_REQUIRED = 0x0004,
+ CSR_ALLOW_BA = 0x0008
+} CSR_TRANSMISSION_CONTROL;
+
+typedef enum CSR_TRANSMISSION_STATUS
+{
+ CSR_TX_SUCCESSFUL = 0x0000,
+ CSR_TX_RETRY_LIMIT = 0x0001,
+ CSR_TX_LIFETIME = 0x0002,
+ CSR_TX_NO_BSS = 0x0003,
+ CSR_TX_EXCESSIVE_DATA_LENGTH = 0x0004,
+ CSR_TX_UNSUPPORTED_PRIORITY = 0x0006,
+ CSR_TX_UNAVAILABLE_PRIORITY = 0x0007,
+ CSR_TX_UNAVAILABLE_KEY_MAPPING = 0x000a,
+ CSR_TX_EDCA_TIMEOUT = 0x000b,
+ CSR_TX_BLOCK_ACK_TIMEOUT = 0x000c,
+ CSR_TX_FAIL_TRANSMISSION_VIF_INTERRUPTED = 0x000d,
+ CSR_TX_REJECTED_PEER_STATION_SLEEPING = 0x000e,
+ CSR_TX_REJECTED_DTIM_ENDED = 0x000f,
+ CSR_TX_REJECTED_DTIM_STARTED = 0x0010
+} CSR_TRANSMISSION_STATUS;
+
+typedef CsrUint16 CSR_TRIGGER_ID;
+
+typedef CsrUint16 CSR_TRIGGERED_ID;
+
+typedef enum CSR_HIP_VERSIONS
+{
+ CSR_HIP_ENG_VERSION = 0x0001,
+ CSR_HIP_VERSION = 0x0900
+} CSR_HIP_VERSIONS;
+
+typedef CsrUint16 CSR_BUFFER_HANDLE;
+
+typedef CsrUint16 CSR_CHANNEL_NUMBER;
+
+typedef struct CSR_DATA_REFERENCE
+{
+ CsrUint16 SlotNumber;
+ CsrUint16 DataLength;
+} CSR_DATAREF;
+
+typedef CsrUint16 CSR_DIALOG_TOKEN;
+
+typedef struct CSR_GENERIC_POINTER
+{
+ CsrUint24 MemoryOffset;
+ CSR_MEMORY_SPACE MemorySpace;
+} CSR_GENERIC_POINTER;
+
+typedef struct CSR_MLME_CONFIG_QUEUE_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_CONFIG_QUEUE_CONFIRM;
+
+typedef struct CSR_MLME_CONFIG_QUEUE_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_NATURAL16 QueueIndex;
+ CSR_NATURAL16 Aifs;
+ CSR_NATURAL16 Cwmin;
+ CSR_NATURAL16 Cwmax;
+ CSR_NATURAL16 TxopLimit;
+} CSR_MLME_CONFIG_QUEUE_REQUEST;
+
+typedef struct CSR_MLME_GET_CONFIRM
+{
+ CSR_DATAREF MibAttributeValue;
+ CSR_DATAREF Dummydataref2;
+ CSR_MIB_STATUS Status;
+ CSR_NATURAL16 ErrorIndex;
+} CSR_MLME_GET_CONFIRM;
+
+typedef struct CSR_MLME_GET_REQUEST
+{
+ CSR_DATAREF MibAttribute;
+ CSR_DATAREF Dummydataref2;
+} CSR_MLME_GET_REQUEST;
+
+typedef struct CSR_MLME_GET_NEXT_CONFIRM
+{
+ CSR_DATAREF MibAttributeValue;
+ CSR_DATAREF Dummydataref2;
+ CSR_MIB_STATUS Status;
+ CSR_NATURAL16 ErrorIndex;
+} CSR_MLME_GET_NEXT_CONFIRM;
+
+typedef struct CSR_MLME_GET_NEXT_REQUEST
+{
+ CSR_DATAREF MibAttribute;
+ CSR_DATAREF Dummydataref2;
+} CSR_MLME_GET_NEXT_REQUEST;
+
+typedef struct CSR_MLME_HL_SYNC_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_MACADDRESS GroupAddress;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_HL_SYNC_CONFIRM;
+
+typedef struct CSR_MLME_HL_SYNC_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_MACADDRESS GroupAddress;
+} CSR_MLME_HL_SYNC_REQUEST;
+
+typedef struct CSR_MLME_HL_SYNC_CANCEL_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_HL_SYNC_CANCEL_CONFIRM;
+
+typedef struct CSR_MLME_HL_SYNC_CANCEL_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_MACADDRESS GroupAddress;
+} CSR_MLME_HL_SYNC_CANCEL_REQUEST;
+
+typedef struct CSR_MLME_MEASURE_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_RESULT_CODE ResultCode;
+ CSR_DIALOG_TOKEN DialogToken;
+} CSR_MLME_MEASURE_CONFIRM;
+
+typedef struct CSR_MLME_MEASURE_INDICATION
+{
+ CSR_DATAREF MeasurementReportSet;
+ CSR_DATAREF Dummydataref2;
+ CSR_DIALOG_TOKEN DialogToken;
+} CSR_MLME_MEASURE_INDICATION;
+
+typedef struct CSR_MLME_MEASURE_REQUEST
+{
+ CSR_DATAREF MeasurementRequestSet;
+ CSR_DATAREF Dummydataref2;
+ CSR_DIALOG_TOKEN DialogToken;
+} CSR_MLME_MEASURE_REQUEST;
+
+typedef struct CSR_MLME_RESET_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_RESET_CONFIRM;
+
+typedef struct CSR_MLME_RESET_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_MACADDRESS StaAddress;
+ CsrInt16 SetDefaultMib;
+} CSR_MLME_RESET_REQUEST;
+
+typedef struct CSR_MLME_SET_CONFIRM
+{
+ CSR_DATAREF MibAttributeValue;
+ CSR_DATAREF Dummydataref2;
+ CSR_MIB_STATUS Status;
+ CSR_NATURAL16 ErrorIndex;
+} CSR_MLME_SET_CONFIRM;
+
+typedef struct CSR_MLME_SET_REQUEST
+{
+ CSR_DATAREF MibAttributeValue;
+ CSR_DATAREF Dummydataref2;
+} CSR_MLME_SET_REQUEST;
+
+typedef struct CSR_MLME_STOP_MEASURE_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_RESULT_CODE ResultCode;
+ CSR_DIALOG_TOKEN DialogToken;
+} CSR_MLME_STOP_MEASURE_CONFIRM;
+
+typedef struct CSR_MLME_STOP_MEASURE_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_DIALOG_TOKEN DialogToken;
+} CSR_MLME_STOP_MEASURE_REQUEST;
+
+typedef CsrUint16 CSR_PROCESS_ID;
+
+typedef CsrUint16 CSR_RATE;
+
+typedef CsrUint16 CSR_SEQUENCE_NUMBER;
+
+typedef struct CSR_SIGNAL_PRIMITIVE_HEADER
+{
+ CsrInt16 SignalId;
+ CSR_PROCESS_ID ReceiverProcessId;
+ CSR_PROCESS_ID SenderProcessId;
+} CSR_SIGNAL_PRIMITIVE_HEADER;
+
+typedef CsrUint16 CSR_TRAFFIC_WINDOW;
+
+typedef CsrUint16 CSR_VIF_IDENTIFIER;
+
+typedef struct CSR_DEBUG_GENERIC_CONFIRM
+{
+ CSR_DATAREF DebugVariable;
+ CSR_DATAREF Dummydataref2;
+ CSR_NATURAL16 DebugWords[8];
+} CSR_DEBUG_GENERIC_CONFIRM;
+
+typedef struct CSR_DEBUG_GENERIC_INDICATION
+{
+ CSR_DATAREF DebugVariable;
+ CSR_DATAREF Dummydataref2;
+ CSR_NATURAL16 DebugWords[8];
+} CSR_DEBUG_GENERIC_INDICATION;
+
+typedef struct CSR_DEBUG_GENERIC_REQUEST
+{
+ CSR_DATAREF DebugVariable;
+ CSR_DATAREF Dummydataref2;
+ CSR_NATURAL16 DebugWords[8];
+} CSR_DEBUG_GENERIC_REQUEST;
+
+typedef struct CSR_DEBUG_STRING_INDICATION
+{
+ CSR_DATAREF DebugMessage;
+ CSR_DATAREF Dummydataref2;
+} CSR_DEBUG_STRING_INDICATION;
+
+typedef struct CSR_DEBUG_WORD16_INDICATION
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_NATURAL16 DebugWords[16];
+} CSR_DEBUG_WORD16_INDICATION;
+
+typedef struct CSR_MA_PACKET_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_TRANSMISSION_STATUS TransmissionStatus;
+ CSR_NATURAL16 RetryCount;
+ CSR_RATE Rate;
+ CSR_CLIENT_TAG HostTag;
+} CSR_MA_PACKET_CONFIRM;
+
+typedef struct CSR_MA_PACKET_INDICATION
+{
+ CSR_DATAREF Data;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_TSF_TIME LocalTime;
+ CSR_IFINTERFACE Ifindex;
+ CSR_CHANNEL_NUMBER Channel;
+ CSR_RECEPTION_STATUS ReceptionStatus;
+ CSR_DECIBELS Rssi;
+ CSR_DECIBELS Snr;
+ CSR_RATE ReceivedRate;
+} CSR_MA_PACKET_INDICATION;
+
+typedef struct CSR_MA_PACKET_REQUEST
+{
+ CSR_DATAREF Data;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RATE TransmitRate;
+ CSR_CLIENT_TAG HostTag;
+ CSR_PRIORITY Priority;
+ CSR_MACADDRESS Ra;
+ CSR_TRANSMISSION_CONTROL TransmissionControl;
+} CSR_MA_PACKET_REQUEST;
+
+typedef struct CSR_MA_PACKET_CANCEL_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_CLIENT_TAG HostTag;
+} CSR_MA_PACKET_CANCEL_REQUEST;
+
+typedef struct CSR_MA_PACKET_ERROR_INDICATION
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_MACADDRESS PeerQstaAddress;
+ CSR_PRIORITY UserPriority;
+ CSR_SEQUENCE_NUMBER SequenceNumber;
+} CSR_MA_PACKET_ERROR_INDICATION;
+
+typedef struct CSR_MA_VIF_AVAILABILITY_INDICATION
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CsrInt16 Multicast;
+} CSR_MA_VIF_AVAILABILITY_INDICATION;
+
+typedef struct CSR_MA_VIF_AVAILABILITY_RESPONSE
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MA_VIF_AVAILABILITY_RESPONSE;
+
+typedef struct CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+ CSR_AUTONOMOUS_SCAN_ID AutonomousScanId;
+} CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM;
+
+typedef struct CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST
+{
+ CSR_DATAREF ChannelList;
+ CSR_DATAREF InformationElements;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_AUTONOMOUS_SCAN_ID AutonomousScanId;
+ CSR_IFINTERFACE Ifindex;
+ CSR_CHANNEL_STARTING_FACTOR ChannelStartingFactor;
+ CSR_SCAN_TYPE ScanType;
+ CSR_MICROSECONDS32 ProbeDelay;
+ CSR_TIME_UNITS MinChannelTime;
+ CSR_TIME_UNITS MaxChannelTime;
+} CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST;
+
+typedef struct CSR_MLME_ADD_BLACKOUT_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_BLACKOUT_ID BlackoutId;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_ADD_BLACKOUT_CONFIRM;
+
+typedef struct CSR_MLME_ADD_BLACKOUT_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_BLACKOUT_ID BlackoutId;
+ CSR_BLACKOUT_TYPE BlackoutType;
+ CSR_BLACKOUT_SOURCE BlackoutSource;
+ CSR_MICROSECONDS32 BlackoutStartReference;
+ CSR_MICROSECONDS32 BlackoutPeriod;
+ CSR_MICROSECONDS32 BlackoutDuration;
+ CSR_MACADDRESS PeerStaAddress;
+ CSR_NATURAL16 BlackoutCount;
+} CSR_MLME_ADD_BLACKOUT_REQUEST;
+
+typedef struct CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM;
+
+typedef struct CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST
+{
+ CSR_DATAREF Data;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_NATURAL16 NumberOfMulticastGroupAddresses;
+} CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST;
+
+typedef struct CSR_MLME_ADD_PERIODIC_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_PERIODIC_ID PeriodicId;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_ADD_PERIODIC_CONFIRM;
+
+typedef struct CSR_MLME_ADD_PERIODIC_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_PERIODIC_ID PeriodicId;
+ CSR_MICROSECONDS32 MaximumLatency;
+ CSR_PERIODIC_SCHEDULING_MODE PeriodicSchedulingMode;
+ CsrInt16 WakeHost;
+ CSR_PRIORITY UserPriority;
+} CSR_MLME_ADD_PERIODIC_REQUEST;
+
+typedef struct CSR_MLME_ADD_RX_TRIGGER_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_TRIGGER_ID TriggerId;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_ADD_RX_TRIGGER_CONFIRM;
+
+typedef struct CSR_MLME_ADD_RX_TRIGGER_REQUEST
+{
+ CSR_DATAREF InformationElements;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_TRIGGER_ID TriggerId;
+ CSR_PRIORITY Priority;
+} CSR_MLME_ADD_RX_TRIGGER_REQUEST;
+
+typedef struct CSR_MLME_ADD_TEMPLATE_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_FRAME_TYPE FrameType;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_ADD_TEMPLATE_CONFIRM;
+
+typedef struct CSR_MLME_ADD_TEMPLATE_REQUEST
+{
+ CSR_DATAREF Data1;
+ CSR_DATAREF Data2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_FRAME_TYPE FrameType;
+ CSR_RATE MinTransmitRate;
+} CSR_MLME_ADD_TEMPLATE_REQUEST;
+
+typedef struct CSR_MLME_ADD_TRIGGERED_GET_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+ CSR_TRIGGERED_ID TriggeredId;
+} CSR_MLME_ADD_TRIGGERED_GET_CONFIRM;
+
+typedef struct CSR_MLME_ADD_TRIGGERED_GET_REQUEST
+{
+ CSR_DATAREF MibAttribute;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_TRIGGERED_ID TriggeredId;
+} CSR_MLME_ADD_TRIGGERED_GET_REQUEST;
+
+typedef struct CSR_MLME_ADD_TSPEC_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_PRIORITY UserPriority;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_ADD_TSPEC_CONFIRM;
+
+typedef struct CSR_MLME_ADD_TSPEC_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_PRIORITY UserPriority;
+ CSR_DIRECTION Direction;
+ CSR_PS_SCHEME PsScheme;
+ CSR_NATURAL16 MediumTime;
+ CSR_MICROSECONDS32 ServiceStartTime;
+ CSR_MICROSECONDS32 ServiceInterval;
+ CSR_RATE MinimumDataRate;
+} CSR_MLME_ADD_TSPEC_REQUEST;
+
+typedef struct CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+ CSR_AUTONOMOUS_SCAN_ID AutonomousScanId;
+} CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION;
+
+typedef struct CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_MACADDRESS Bssid;
+} CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION;
+
+typedef struct CSR_MLME_BLACKOUT_ENDED_INDICATION
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_BLACKOUT_ID BlackoutId;
+} CSR_MLME_BLACKOUT_ENDED_INDICATION;
+
+typedef struct CSR_MLME_BLOCKACK_ERROR_INDICATION
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_REASON_CODE ResultCode;
+ CSR_MACADDRESS PeerQstaAddress;
+} CSR_MLME_BLOCKACK_ERROR_INDICATION;
+
+typedef struct CSR_MLME_CONNECTED_INDICATION
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_CONNECTION_STATUS ConnectionStatus;
+ CSR_MACADDRESS PeerMacAddress;
+} CSR_MLME_CONNECTED_INDICATION;
+
+typedef struct CSR_MLME_CONNECT_STATUS_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_CONNECT_STATUS_CONFIRM;
+
+typedef struct CSR_MLME_CONNECT_STATUS_REQUEST
+{
+ CSR_DATAREF InformationElements;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_CONNECTION_STATUS ConnectionStatus;
+ CSR_MACADDRESS StaAddress;
+ CSR_ASSOCIATION_ID AssociationId;
+ CSR_CAPABILITY_INFORMATION AssociationCapabilityInformation;
+} CSR_MLME_CONNECT_STATUS_REQUEST;
+
+typedef struct CSR_MLME_DELETEKEYS_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_DELETEKEYS_CONFIRM;
+
+typedef struct CSR_MLME_DELETEKEYS_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_NATURAL16 KeyId;
+ CSR_KEY_TYPE KeyType;
+ CSR_MACADDRESS Address;
+} CSR_MLME_DELETEKEYS_REQUEST;
+
+typedef struct CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+ CSR_AUTONOMOUS_SCAN_ID AutonomousScanId;
+} CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM;
+
+typedef struct CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_AUTONOMOUS_SCAN_ID AutonomousScanId;
+} CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST;
+
+typedef struct CSR_MLME_DEL_BLACKOUT_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_BLACKOUT_ID BlackoutId;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_DEL_BLACKOUT_CONFIRM;
+
+typedef struct CSR_MLME_DEL_BLACKOUT_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_BLACKOUT_ID BlackoutId;
+} CSR_MLME_DEL_BLACKOUT_REQUEST;
+
+typedef struct CSR_MLME_DEL_PERIODIC_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_PERIODIC_ID PeriodicId;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_DEL_PERIODIC_CONFIRM;
+
+typedef struct CSR_MLME_DEL_PERIODIC_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_PERIODIC_ID PeriodicId;
+} CSR_MLME_DEL_PERIODIC_REQUEST;
+
+typedef struct CSR_MLME_DEL_RX_TRIGGER_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_TRIGGER_ID TriggerId;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_DEL_RX_TRIGGER_CONFIRM;
+
+typedef struct CSR_MLME_DEL_RX_TRIGGER_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_TRIGGER_ID TriggerId;
+} CSR_MLME_DEL_RX_TRIGGER_REQUEST;
+
+typedef struct CSR_MLME_DEL_TRIGGERED_GET_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+ CSR_TRIGGERED_ID TriggeredId;
+} CSR_MLME_DEL_TRIGGERED_GET_CONFIRM;
+
+typedef struct CSR_MLME_DEL_TRIGGERED_GET_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_TRIGGERED_ID TriggeredId;
+} CSR_MLME_DEL_TRIGGERED_GET_REQUEST;
+
+typedef struct CSR_MLME_DEL_TSPEC_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_PRIORITY UserPriority;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_DEL_TSPEC_CONFIRM;
+
+typedef struct CSR_MLME_DEL_TSPEC_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_PRIORITY UserPriority;
+ CSR_DIRECTION Direction;
+} CSR_MLME_DEL_TSPEC_REQUEST;
+
+typedef struct CSR_MLME_GET_KEY_SEQUENCE_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+ CSR_NATURAL16 SequenceNumber[8];
+} CSR_MLME_GET_KEY_SEQUENCE_CONFIRM;
+
+typedef struct CSR_MLME_GET_KEY_SEQUENCE_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_NATURAL16 KeyId;
+ CSR_KEY_TYPE KeyType;
+ CSR_MACADDRESS Address;
+} CSR_MLME_GET_KEY_SEQUENCE_REQUEST;
+
+typedef struct CSR_MLME_LEAVE_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_LEAVE_CONFIRM;
+
+typedef struct CSR_MLME_LEAVE_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+} CSR_MLME_LEAVE_REQUEST;
+
+typedef struct CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM;
+
+typedef struct CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST
+{
+ CSR_DATAREF Data;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_TIME_UNITS BeaconPeriod;
+ CSR_BEACON_PERIODS DtimPeriod;
+ CSR_CAPABILITY_INFORMATION CapabilityInformation;
+ CSR_MACADDRESS Bssid;
+ CSR_NATURAL16 RtsThreshold;
+} CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST;
+
+typedef struct CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+ CSR_AUTONOMOUS_SCAN_ID AutonomousScanId;
+} CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM;
+
+typedef struct CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_AUTONOMOUS_SCAN_ID AutonomousScanId;
+ CsrInt16 Pause;
+} CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST;
+
+typedef struct CSR_MLME_POWERMGT_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_POWERMGT_CONFIRM;
+
+typedef struct CSR_MLME_POWERMGT_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_POWER_MANAGEMENT_MODE PowerManagementMode;
+ CsrInt16 ReceiveDtims;
+ CSR_BEACON_PERIODS ListenInterval;
+ CSR_TRAFFIC_WINDOW TrafficWindow;
+} CSR_MLME_POWERMGT_REQUEST;
+
+typedef struct CSR_MLME_SCAN_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_SCAN_CONFIRM;
+
+typedef struct CSR_MLME_SCAN_REQUEST
+{
+ CSR_DATAREF ChannelList;
+ CSR_DATAREF InformationElements;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_IFINTERFACE Ifindex;
+ CSR_SCAN_TYPE ScanType;
+ CSR_MICROSECONDS32 ProbeDelay;
+ CSR_TIME_UNITS MinChannelTime;
+ CSR_TIME_UNITS MaxChannelTime;
+} CSR_MLME_SCAN_REQUEST;
+
+typedef struct CSR_MLME_SCAN_CANCEL_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+} CSR_MLME_SCAN_CANCEL_REQUEST;
+
+typedef struct CSR_MLME_SETKEYS_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_SETKEYS_CONFIRM;
+
+typedef struct CSR_MLME_SETKEYS_REQUEST
+{
+ CSR_DATAREF Key;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_NATURAL16 Length;
+ CSR_NATURAL16 KeyId;
+ CSR_KEY_TYPE KeyType;
+ CSR_MACADDRESS Address;
+ CSR_NATURAL16 SequenceNumber[8];
+ CSR_CIPHER_SUITE_SELECTOR CipherSuiteSelector;
+} CSR_MLME_SETKEYS_REQUEST;
+
+typedef struct CSR_MLME_SET_CHANNEL_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_SET_CHANNEL_CONFIRM;
+
+typedef struct CSR_MLME_SET_CHANNEL_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_IFINTERFACE Ifindex;
+ CSR_CHANNEL_NUMBER Channel;
+ CSR_MACADDRESS Address;
+ CSR_TIME_UNITS AvailabilityDuration;
+ CSR_TIME_UNITS AvailabilityInterval;
+} CSR_MLME_SET_CHANNEL_REQUEST;
+
+typedef struct CSR_MLME_SET_PACKET_FILTER_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_SET_PACKET_FILTER_CONFIRM;
+
+typedef struct CSR_MLME_SET_PACKET_FILTER_REQUEST
+{
+ CSR_DATAREF InformationElements;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_PACKET_FILTER_MODE PacketFilterMode;
+ CSR_IPV4_ADDRESS ArpFilterAddress;
+} CSR_MLME_SET_PACKET_FILTER_REQUEST;
+
+typedef struct CSR_MLME_SET_TIM_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_SET_TIM_CONFIRM;
+
+typedef struct CSR_MLME_SET_TIM_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_ASSOCIATION_ID AssociationId;
+ CsrInt16 TimValue;
+} CSR_MLME_SET_TIM_REQUEST;
+
+typedef struct CSR_MLME_SM_START_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_SM_START_CONFIRM;
+
+typedef struct CSR_MLME_SM_START_REQUEST
+{
+ CSR_DATAREF Beacon;
+ CSR_DATAREF BssParameters;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_IFINTERFACE Ifindex;
+ CSR_CHANNEL_NUMBER Channel;
+ CSR_MACADDRESS InterfaceAddress;
+ CSR_MACADDRESS Bssid;
+ CSR_TIME_UNITS BeaconPeriod;
+ CSR_BEACON_PERIODS DtimPeriod;
+ CSR_CAPABILITY_INFORMATION CapabilityInformation;
+} CSR_MLME_SM_START_REQUEST;
+
+typedef struct CSR_MLME_START_AGGREGATION_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_MACADDRESS PeerQstaAddress;
+ CSR_PRIORITY UserPriority;
+ CSR_DIRECTION Direction;
+ CSR_RESULT_CODE ResultCode;
+ CSR_SEQUENCE_NUMBER SequenceNumber;
+} CSR_MLME_START_AGGREGATION_CONFIRM;
+
+typedef struct CSR_MLME_START_AGGREGATION_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_MACADDRESS PeerQstaAddress;
+ CSR_PRIORITY UserPriority;
+ CSR_DIRECTION Direction;
+ CSR_STARTING_SEQUENCE_NUMBER StartingSequenceNumber;
+ CSR_NATURAL16 BufferSize;
+ CSR_TIME_UNITS BlockAckTimeout;
+} CSR_MLME_START_AGGREGATION_REQUEST;
+
+typedef struct CSR_MLME_STOP_AGGREGATION_CONFIRM
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_MACADDRESS PeerQstaAddress;
+ CSR_PRIORITY UserPriority;
+ CSR_DIRECTION Direction;
+ CSR_RESULT_CODE ResultCode;
+} CSR_MLME_STOP_AGGREGATION_CONFIRM;
+
+typedef struct CSR_MLME_STOP_AGGREGATION_REQUEST
+{
+ CSR_DATAREF Dummydataref1;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_MACADDRESS PeerQstaAddress;
+ CSR_PRIORITY UserPriority;
+ CSR_DIRECTION Direction;
+} CSR_MLME_STOP_AGGREGATION_REQUEST;
+
+typedef struct CSR_MLME_TRIGGERED_GET_INDICATION
+{
+ CSR_DATAREF MibAttributeValue;
+ CSR_DATAREF Dummydataref2;
+ CSR_VIF_IDENTIFIER VirtualInterfaceIdentifier;
+ CSR_MIB_STATUS Status;
+ CSR_NATURAL16 ErrorIndex;
+ CSR_TRIGGERED_ID TriggeredId;
+} CSR_MLME_TRIGGERED_GET_INDICATION;
+
+typedef struct CSR_SIGNAL_PRIMITIVE
+{
+ CSR_SIGNAL_PRIMITIVE_HEADER SignalPrimitiveHeader;
+ union
+ {
+ CSR_MA_PACKET_REQUEST MaPacketRequest;
+ CSR_MA_PACKET_CONFIRM MaPacketConfirm;
+ CSR_MA_PACKET_INDICATION MaPacketIndication;
+ CSR_MA_PACKET_CANCEL_REQUEST MaPacketCancelRequest;
+ CSR_MA_VIF_AVAILABILITY_RESPONSE MaVifAvailabilityResponse;
+ CSR_MA_VIF_AVAILABILITY_INDICATION MaVifAvailabilityIndication;
+ CSR_MA_PACKET_ERROR_INDICATION MaPacketErrorIndication;
+ CSR_MLME_RESET_REQUEST MlmeResetRequest;
+ CSR_MLME_RESET_CONFIRM MlmeResetConfirm;
+ CSR_MLME_GET_REQUEST MlmeGetRequest;
+ CSR_MLME_GET_CONFIRM MlmeGetConfirm;
+ CSR_MLME_SET_REQUEST MlmeSetRequest;
+ CSR_MLME_SET_CONFIRM MlmeSetConfirm;
+ CSR_MLME_GET_NEXT_REQUEST MlmeGetNextRequest;
+ CSR_MLME_GET_NEXT_CONFIRM MlmeGetNextConfirm;
+ CSR_MLME_POWERMGT_REQUEST MlmePowermgtRequest;
+ CSR_MLME_POWERMGT_CONFIRM MlmePowermgtConfirm;
+ CSR_MLME_SCAN_REQUEST MlmeScanRequest;
+ CSR_MLME_SCAN_CONFIRM MlmeScanConfirm;
+ CSR_MLME_HL_SYNC_REQUEST MlmeHlSyncRequest;
+ CSR_MLME_HL_SYNC_CONFIRM MlmeHlSyncConfirm;
+ CSR_MLME_MEASURE_REQUEST MlmeMeasureRequest;
+ CSR_MLME_MEASURE_CONFIRM MlmeMeasureConfirm;
+ CSR_MLME_MEASURE_INDICATION MlmeMeasureIndication;
+ CSR_MLME_SETKEYS_REQUEST MlmeSetkeysRequest;
+ CSR_MLME_SETKEYS_CONFIRM MlmeSetkeysConfirm;
+ CSR_MLME_DELETEKEYS_REQUEST MlmeDeletekeysRequest;
+ CSR_MLME_DELETEKEYS_CONFIRM MlmeDeletekeysConfirm;
+ CSR_MLME_AUTONOMOUS_SCAN_LOSS_INDICATION MlmeAutonomousScanLossIndication;
+ CSR_MLME_CONNECTED_INDICATION MlmeConnectedIndication;
+ CSR_MLME_SCAN_CANCEL_REQUEST MlmeScanCancelRequest;
+ CSR_MLME_HL_SYNC_CANCEL_REQUEST MlmeHlSyncCancelRequest;
+ CSR_MLME_HL_SYNC_CANCEL_CONFIRM MlmeHlSyncCancelConfirm;
+ CSR_MLME_ADD_PERIODIC_REQUEST MlmeAddPeriodicRequest;
+ CSR_MLME_ADD_PERIODIC_CONFIRM MlmeAddPeriodicConfirm;
+ CSR_MLME_DEL_PERIODIC_REQUEST MlmeDelPeriodicRequest;
+ CSR_MLME_DEL_PERIODIC_CONFIRM MlmeDelPeriodicConfirm;
+ CSR_MLME_ADD_AUTONOMOUS_SCAN_REQUEST MlmeAddAutonomousScanRequest;
+ CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM MlmeAddAutonomousScanConfirm;
+ CSR_MLME_DEL_AUTONOMOUS_SCAN_REQUEST MlmeDelAutonomousScanRequest;
+ CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM MlmeDelAutonomousScanConfirm;
+ CSR_MLME_SET_PACKET_FILTER_REQUEST MlmeSetPacketFilterRequest;
+ CSR_MLME_SET_PACKET_FILTER_CONFIRM MlmeSetPacketFilterConfirm;
+ CSR_MLME_STOP_MEASURE_REQUEST MlmeStopMeasureRequest;
+ CSR_MLME_STOP_MEASURE_CONFIRM MlmeStopMeasureConfirm;
+ CSR_MLME_PAUSE_AUTONOMOUS_SCAN_REQUEST MlmePauseAutonomousScanRequest;
+ CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM MlmePauseAutonomousScanConfirm;
+ CSR_MLME_AUTONOMOUS_SCAN_DONE_INDICATION MlmeAutonomousScanDoneIndication;
+ CSR_MLME_ADD_TRIGGERED_GET_REQUEST MlmeAddTriggeredGetRequest;
+ CSR_MLME_ADD_TRIGGERED_GET_CONFIRM MlmeAddTriggeredGetConfirm;
+ CSR_MLME_DEL_TRIGGERED_GET_REQUEST MlmeDelTriggeredGetRequest;
+ CSR_MLME_DEL_TRIGGERED_GET_CONFIRM MlmeDelTriggeredGetConfirm;
+ CSR_MLME_TRIGGERED_GET_INDICATION MlmeTriggeredGetIndication;
+ CSR_MLME_ADD_BLACKOUT_REQUEST MlmeAddBlackoutRequest;
+ CSR_MLME_ADD_BLACKOUT_CONFIRM MlmeAddBlackoutConfirm;
+ CSR_MLME_BLACKOUT_ENDED_INDICATION MlmeBlackoutEndedIndication;
+ CSR_MLME_DEL_BLACKOUT_REQUEST MlmeDelBlackoutRequest;
+ CSR_MLME_DEL_BLACKOUT_CONFIRM MlmeDelBlackoutConfirm;
+ CSR_MLME_ADD_RX_TRIGGER_REQUEST MlmeAddRxTriggerRequest;
+ CSR_MLME_ADD_RX_TRIGGER_CONFIRM MlmeAddRxTriggerConfirm;
+ CSR_MLME_DEL_RX_TRIGGER_REQUEST MlmeDelRxTriggerRequest;
+ CSR_MLME_DEL_RX_TRIGGER_CONFIRM MlmeDelRxTriggerConfirm;
+ CSR_MLME_CONNECT_STATUS_REQUEST MlmeConnectStatusRequest;
+ CSR_MLME_CONNECT_STATUS_CONFIRM MlmeConnectStatusConfirm;
+ CSR_MLME_MODIFY_BSS_PARAMETER_REQUEST MlmeModifyBssParameterRequest;
+ CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM MlmeModifyBssParameterConfirm;
+ CSR_MLME_ADD_TEMPLATE_REQUEST MlmeAddTemplateRequest;
+ CSR_MLME_ADD_TEMPLATE_CONFIRM MlmeAddTemplateConfirm;
+ CSR_MLME_CONFIG_QUEUE_REQUEST MlmeConfigQueueRequest;
+ CSR_MLME_CONFIG_QUEUE_CONFIRM MlmeConfigQueueConfirm;
+ CSR_MLME_ADD_TSPEC_REQUEST MlmeAddTspecRequest;
+ CSR_MLME_ADD_TSPEC_CONFIRM MlmeAddTspecConfirm;
+ CSR_MLME_DEL_TSPEC_REQUEST MlmeDelTspecRequest;
+ CSR_MLME_DEL_TSPEC_CONFIRM MlmeDelTspecConfirm;
+ CSR_MLME_START_AGGREGATION_REQUEST MlmeStartAggregationRequest;
+ CSR_MLME_START_AGGREGATION_CONFIRM MlmeStartAggregationConfirm;
+ CSR_MLME_BLOCKACK_ERROR_INDICATION MlmeBlockackErrorIndication;
+ CSR_MLME_STOP_AGGREGATION_REQUEST MlmeStopAggregationRequest;
+ CSR_MLME_STOP_AGGREGATION_CONFIRM MlmeStopAggregationConfirm;
+ CSR_MLME_SM_START_REQUEST MlmeSmStartRequest;
+ CSR_MLME_SM_START_CONFIRM MlmeSmStartConfirm;
+ CSR_MLME_LEAVE_REQUEST MlmeLeaveRequest;
+ CSR_MLME_LEAVE_CONFIRM MlmeLeaveConfirm;
+ CSR_MLME_SET_TIM_REQUEST MlmeSetTimRequest;
+ CSR_MLME_SET_TIM_CONFIRM MlmeSetTimConfirm;
+ CSR_MLME_GET_KEY_SEQUENCE_REQUEST MlmeGetKeySequenceRequest;
+ CSR_MLME_GET_KEY_SEQUENCE_CONFIRM MlmeGetKeySequenceConfirm;
+ CSR_MLME_SET_CHANNEL_REQUEST MlmeSetChannelRequest;
+ CSR_MLME_SET_CHANNEL_CONFIRM MlmeSetChannelConfirm;
+ CSR_MLME_ADD_MULTICAST_ADDRESS_REQUEST MlmeAddMulticastAddressRequest;
+ CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM MlmeAddMulticastAddressConfirm;
+ CSR_DEBUG_STRING_INDICATION DebugStringIndication;
+ CSR_DEBUG_WORD16_INDICATION DebugWord16Indication;
+ CSR_DEBUG_GENERIC_REQUEST DebugGenericRequest;
+ CSR_DEBUG_GENERIC_CONFIRM DebugGenericConfirm;
+ CSR_DEBUG_GENERIC_INDICATION DebugGenericIndication;
+ } u;
+} CSR_SIGNAL;
+
+#define SIG_FILTER_SIZE 6
+
+CsrUint32 SigGetFilterPos(CsrUint16 aSigID);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_ta_sampling.c
+ *
+ * PURPOSE:
+ * The traffic analysis sampling module.
+ * This gathers data which is sent to the SME and used to analyse
+ * the traffic behaviour.
+ *
+ * Provides:
+ * unifi_ta_sampling_init - Initialise the internal state
+ * unifi_ta_sample - Sampling function, call this for every data packet
+ *
+ * Calls these external functions which must be provided:
+ * unifi_ta_indicate_sampling - Pass sample data to the SME.
+ * unifi_ta_indicate_protocol - Report certain data packet types to the SME.
+ * ---------------------------------------------------------------------------
+ */
+
+#include "csr_wifi_hip_card_sdio.h"
+
+/* Maximum number of Tx frames we store each CYCLE_1, for detecting period */
+#define TA_MAX_INTERVALS_IN_C1 100
+
+/* Number of intervals in CYCLE_1 (one second), for detecting periodic */
+/* Must match size of unifi_TrafficStats.intervals - 1 */
+#define TA_INTERVALS_NUM 10
+
+/* Step (in msecs) between intervals, for detecting periodic */
+/* We are only interested in periods up to 100ms, i.e. between beacons */
+/* This is correct for TA_INTERVALS_NUM=10 */
+#define TA_INTERVALS_STEP 10
+
+
+enum ta_frame_identity
+{
+ TA_FRAME_UNKNOWN,
+ TA_FRAME_ETHERNET_UNINTERESTING,
+ TA_FRAME_ETHERNET_INTERESTING
+};
+
+
+#define TA_ETHERNET_TYPE_OFFSET 6
+#define TA_LLC_HEADER_SIZE 8
+#define TA_IP_TYPE_OFFSET 17
+#define TA_UDP_SOURCE_PORT_OFFSET 28
+#define TA_UDP_DEST_PORT_OFFSET (TA_UDP_SOURCE_PORT_OFFSET + 2)
+#define TA_BOOTP_CLIENT_MAC_ADDR_OFFSET 64
+#define TA_DHCP_MESSAGE_TYPE_OFFSET 278
+#define TA_DHCP_MESSAGE_TYPE_ACK 0x05
+#define TA_PROTO_TYPE_IP 0x0800
+#define TA_PROTO_TYPE_EAP 0x888E
+#define TA_PROTO_TYPE_WAI 0x8864
+#define TA_PROTO_TYPE_ARP 0x0806
+#define TA_IP_TYPE_TCP 0x06
+#define TA_IP_TYPE_UDP 0x11
+#define TA_UDP_PORT_BOOTPC 0x0044
+#define TA_UDP_PORT_BOOTPS 0x0043
+#define TA_EAPOL_TYPE_OFFSET 9
+#define TA_EAPOL_TYPE_START 0x01
+
+#define snap_802_2 0xAAAA0300
+#define oui_rfc1042 0x00000000
+#define oui_8021h 0x0000f800
+static const CsrUint8 aironet_snap[5] = { 0x00, 0x40, 0x96, 0x00, 0x00 };
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * ta_detect_protocol
+ *
+ * Internal only.
+ * Detects a specific protocol in a frame and indicates a TA event.
+ *
+ * Arguments:
+ * ta The pointer to the TA module.
+ * direction The direction of the frame (tx or rx).
+ * data Pointer to the structure that contains the data.
+ *
+ * Returns:
+ * None
+ * ---------------------------------------------------------------------------
+ */
+static enum ta_frame_identity ta_detect_protocol(card_t *card, CsrWifiRouterCtrlProtocolDirection direction,
+ const bulk_data_desc_t *data,
+ const CsrUint8 *saddr,
+ const CsrUint8 *sta_macaddr)
+{
+ ta_data_t *tad = &card->ta_sampling;
+ CsrUint16 proto;
+ CsrUint16 source_port, dest_port;
+ CsrWifiMacAddress srcAddress;
+ CsrUint32 snap_hdr, oui_hdr;
+
+ if (data->data_length < TA_LLC_HEADER_SIZE)
+ {
+ return TA_FRAME_UNKNOWN;
+ }
+
+ snap_hdr = (((CsrUint32)data->os_data_ptr[0]) << 24) |
+ (((CsrUint32)data->os_data_ptr[1]) << 16) |
+ (((CsrUint32)data->os_data_ptr[2]) << 8);
+ if (snap_hdr != snap_802_2)
+ {
+ return TA_FRAME_UNKNOWN;
+ }
+
+ if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
+ {
+ /*
+ * Here we would use the custom filter to detect interesting frames.
+ */
+ }
+
+ oui_hdr = (((CsrUint32)data->os_data_ptr[3]) << 24) |
+ (((CsrUint32)data->os_data_ptr[4]) << 16) |
+ (((CsrUint32)data->os_data_ptr[5]) << 8);
+ if ((oui_hdr == oui_rfc1042) || (oui_hdr == oui_8021h))
+ {
+ proto = (data->os_data_ptr[TA_ETHERNET_TYPE_OFFSET] * 256) +
+ data->os_data_ptr[TA_ETHERNET_TYPE_OFFSET + 1];
+
+ /* The only interesting IP frames are the DHCP */
+ if (proto == TA_PROTO_TYPE_IP)
+ {
+ if (data->data_length > TA_IP_TYPE_OFFSET)
+ {
+ if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
+ {
+ ta_l4stats_t *ta_l4stats = &tad->ta_l4stats;
+ CsrUint8 l4proto = data->os_data_ptr[TA_IP_TYPE_OFFSET];
+
+ if (l4proto == TA_IP_TYPE_TCP)
+ {
+ if (direction == CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX)
+ {
+ ta_l4stats->txTcpBytesCount += data->data_length;
+ }
+ else
+ {
+ ta_l4stats->rxTcpBytesCount += data->data_length;
+ }
+ }
+ else if (l4proto == TA_IP_TYPE_UDP)
+ {
+ if (direction == CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX)
+ {
+ ta_l4stats->txUdpBytesCount += data->data_length;
+ }
+ else
+ {
+ ta_l4stats->rxUdpBytesCount += data->data_length;
+ }
+ }
+ }
+
+ /* detect DHCP frames */
+ if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP)
+ {
+ /* DHCP frames are UDP frames with BOOTP ports */
+ if (data->os_data_ptr[TA_IP_TYPE_OFFSET] == TA_IP_TYPE_UDP)
+ {
+ if (data->data_length > TA_UDP_DEST_PORT_OFFSET)
+ {
+ source_port = (data->os_data_ptr[TA_UDP_SOURCE_PORT_OFFSET] * 256) +
+ data->os_data_ptr[TA_UDP_SOURCE_PORT_OFFSET + 1];
+ dest_port = (data->os_data_ptr[TA_UDP_DEST_PORT_OFFSET] * 256) +
+ data->os_data_ptr[TA_UDP_DEST_PORT_OFFSET + 1];
+
+ if (((source_port == TA_UDP_PORT_BOOTPC) && (dest_port == TA_UDP_PORT_BOOTPS)) ||
+ ((source_port == TA_UDP_PORT_BOOTPS) && (dest_port == TA_UDP_PORT_BOOTPC)))
+ {
+ /* The DHCP should have at least a message type (request, ack, nack, etc) */
+ if (data->data_length > TA_DHCP_MESSAGE_TYPE_OFFSET + 6)
+ {
+ UNIFI_MAC_ADDRESS_COPY(srcAddress.a, saddr);
+
+ if (direction == CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX)
+ {
+ unifi_ta_indicate_protocol(card->ospriv,
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP,
+ direction,
+ &srcAddress);
+ return TA_FRAME_ETHERNET_UNINTERESTING;
+ }
+
+ /* DHCPACK is a special indication */
+ if (UNIFI_MAC_ADDRESS_CMP(data->os_data_ptr + TA_BOOTP_CLIENT_MAC_ADDR_OFFSET, sta_macaddr) == TRUE)
+ {
+ if (data->os_data_ptr[TA_DHCP_MESSAGE_TYPE_OFFSET] == TA_DHCP_MESSAGE_TYPE_ACK)
+ {
+ unifi_ta_indicate_protocol(card->ospriv,
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP_ACK,
+ direction,
+ &srcAddress);
+ }
+ else
+ {
+ unifi_ta_indicate_protocol(card->ospriv,
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP,
+ direction,
+ &srcAddress);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return TA_FRAME_ETHERNET_INTERESTING;
+ }
+
+ /* detect protocol type EAPOL or WAI (treated as equivalent here) */
+ if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_EAPOL)
+ {
+ if (TA_PROTO_TYPE_EAP == proto || TA_PROTO_TYPE_WAI == proto)
+ {
+ if ((TA_PROTO_TYPE_WAI == proto) || (direction != CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX) ||
+ (data->os_data_ptr[TA_EAPOL_TYPE_OFFSET] == TA_EAPOL_TYPE_START))
+ {
+ UNIFI_MAC_ADDRESS_COPY(srcAddress.a, saddr);
+ unifi_ta_indicate_protocol(card->ospriv,
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_EAPOL,
+ direction, &srcAddress);
+ }
+ return TA_FRAME_ETHERNET_UNINTERESTING;
+ }
+ }
+
+ /* detect protocol type 0x0806 (ARP) */
+ if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_ARP)
+ {
+ if (proto == TA_PROTO_TYPE_ARP)
+ {
+ UNIFI_MAC_ADDRESS_COPY(srcAddress.a, saddr);
+ unifi_ta_indicate_protocol(card->ospriv,
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_ARP,
+ direction, &srcAddress);
+ return TA_FRAME_ETHERNET_UNINTERESTING;
+ }
+ }
+
+ return TA_FRAME_ETHERNET_INTERESTING;
+ }
+ else if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_AIRONET)
+ {
+ /* detect Aironet frames */
+ if (!CsrMemCmp(data->os_data_ptr + 3, aironet_snap, 5))
+ {
+ UNIFI_MAC_ADDRESS_COPY(srcAddress.a, saddr);
+ unifi_ta_indicate_protocol(card->ospriv, CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_AIRONET,
+ direction, &srcAddress);
+ }
+ }
+
+ return TA_FRAME_ETHERNET_UNINTERESTING;
+} /* ta_detect_protocol() */
+
+
+static void tas_reset_data(ta_data_t *tad)
+{
+ CsrInt16 i;
+
+ for (i = 0; i < (TA_INTERVALS_NUM + 1); i++)
+ {
+ tad->stats.intervals[i] = 0;
+ }
+
+ tad->stats.rxFramesNum = 0;
+ tad->stats.txFramesNum = 0;
+ tad->stats.rxBytesCount = 0;
+ tad->stats.txBytesCount = 0;
+ tad->stats.rxMeanRate = 0;
+
+ tad->rx_sum_rate = 0;
+
+ tad->ta_l4stats.rxTcpBytesCount = 0;
+ tad->ta_l4stats.txTcpBytesCount = 0;
+ tad->ta_l4stats.rxUdpBytesCount = 0;
+ tad->ta_l4stats.txUdpBytesCount = 0;
+} /* tas_reset_data() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * API.
+ * unifi_ta_sampling_init
+ *
+ * (Re)Initialise the Traffic Analysis sampling module.
+ * Resets the counters and timestamps.
+ *
+ * Arguments:
+ * tad Pointer to a ta_data_t structure containing the
+ * context for this device instance.
+ * drv_priv An opaque pointer that the TA sampling module will
+ * pass in call-outs.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void unifi_ta_sampling_init(card_t *card)
+{
+ (void)unifi_ta_configure(card, CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_RESET, NULL);
+
+ card->ta_sampling.packet_filter = CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_NONE;
+ card->ta_sampling.traffic_type = CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_OCCASIONAL;
+} /* unifi_ta_sampling_init() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * API.
+ * unifi_ta_sample
+ *
+ * Sample a data frame for the TA module.
+ * This function stores all the useful information it can extract from
+ * the frame and detects any specific protocols.
+ *
+ * Arguments:
+ * tad The pointer to the TA sampling context struct.
+ * direction The direction of the frame (rx, tx)
+ * data Pointer to the frame data
+ * saddr Source MAC address of frame.
+ * timestamp Time (in msecs) that the frame was received.
+ * rate Reported data rate for the rx frame (0 for tx frames)
+ *
+ * Returns:
+ * None
+ * ---------------------------------------------------------------------------
+ */
+void unifi_ta_sample(card_t *card,
+ CsrWifiRouterCtrlProtocolDirection direction,
+ const bulk_data_desc_t *data,
+ const CsrUint8 *saddr,
+ const CsrUint8 *sta_macaddr,
+ CsrUint32 timestamp,
+ CsrUint16 rate)
+{
+ ta_data_t *tad = &card->ta_sampling;
+ enum ta_frame_identity identity;
+ CsrUint32 time_delta;
+
+
+
+ /* Step1: Check for specific frames */
+ if (tad->packet_filter != CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_NONE)
+ {
+ identity = ta_detect_protocol(card, direction, data, saddr, sta_macaddr);
+ }
+ else
+ {
+ identity = TA_FRAME_ETHERNET_INTERESTING;
+ }
+
+
+ /* Step2: Update the information in the current record */
+ if (direction == CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_RX)
+ {
+ /* Update the Rx packet count and the throughput count */
+ tad->stats.rxFramesNum++;
+ tad->stats.rxBytesCount += data->data_length;
+
+ /* Accumulate packet Rx rates for later averaging */
+ tad->rx_sum_rate += rate;
+ }
+ else
+ {
+ if (identity == TA_FRAME_ETHERNET_INTERESTING)
+ {
+ /*
+ * Store the period between the last and the current frame.
+ * There is not point storing more than TA_MAX_INTERVALS_IN_C1 periods,
+ * the traffic will be bursty or continuous.
+ */
+ if (tad->stats.txFramesNum < TA_MAX_INTERVALS_IN_C1)
+ {
+ CsrUint32 interval;
+ CsrUint32 index_in_intervals;
+
+ interval = timestamp - tad->tx_last_ts;
+ tad->tx_last_ts = timestamp;
+ index_in_intervals = (interval + TA_INTERVALS_STEP / 2 - 1) / TA_INTERVALS_STEP;
+
+ /* If the interval is interesting, update the t1_intervals count */
+ if (index_in_intervals <= TA_INTERVALS_NUM)
+ {
+ unifi_trace(card->ospriv, UDBG5,
+ "unifi_ta_sample: TX interval=%d index=%d\n",
+ interval, index_in_intervals);
+ tad->stats.intervals[index_in_intervals]++;
+ }
+ }
+ }
+
+ /* Update the Tx packet count... */
+ tad->stats.txFramesNum++;
+ /* ... and the number of bytes for throughput. */
+ tad->stats.txBytesCount += data->data_length;
+ }
+
+ /*
+ * If more than one second has elapsed since the last report, send
+ * another one.
+ */
+ /* Unsigned subtraction handles wrap-around from 0xFFFFFFFF to 0 */
+ time_delta = timestamp - tad->last_indication_time;
+ if (time_delta >= 1000)
+ {
+ /*
+ * rxFramesNum can be flashed in tas_reset_data() by another thread.
+ * Use a temp to avoid division by zero.
+ */
+ CsrUint32 temp_rxFramesNum;
+ temp_rxFramesNum = tad->stats.rxFramesNum;
+
+ /* Calculate this interval's mean frame Rx rate from the sum */
+ if (temp_rxFramesNum)
+ {
+ tad->stats.rxMeanRate = tad->rx_sum_rate / temp_rxFramesNum;
+ }
+ unifi_trace(card->ospriv, UDBG5,
+ "unifi_ta_sample: RX fr=%lu, r=%u, sum=%lu, av=%lu\n",
+ tad->stats.rxFramesNum, rate,
+ tad->rx_sum_rate, tad->stats.rxMeanRate);
+
+ /*
+ * Send the information collected in the stats struct
+ * to the SME and reset the counters.
+ */
+ if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
+ {
+ CsrUint32 rxTcpThroughput = tad->ta_l4stats.rxTcpBytesCount / time_delta;
+ CsrUint32 txTcpThroughput = tad->ta_l4stats.txTcpBytesCount / time_delta;
+ CsrUint32 rxUdpThroughput = tad->ta_l4stats.rxUdpBytesCount / time_delta;
+ CsrUint32 txUdpThroughput = tad->ta_l4stats.txUdpBytesCount / time_delta;
+
+ unifi_ta_indicate_l4stats(card->ospriv,
+ rxTcpThroughput,
+ txTcpThroughput,
+ rxUdpThroughput,
+ txUdpThroughput
+ );
+ }
+ unifi_ta_indicate_sampling(card->ospriv, &tad->stats);
+ tas_reset_data(tad);
+ tad->last_indication_time = timestamp;
+ }
+} /* unifi_ta_sample() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * External API.
+ * unifi_ta_configure
+ *
+ * Configures the TA module parameters.
+ *
+ * Arguments:
+ * ta The pointer to the TA module.
+ * config_type The type of the configuration request
+ * config Pointer to the configuration parameters.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error code otherwise
+ * ---------------------------------------------------------------------------
+ */
+CsrResult unifi_ta_configure(card_t *card,
+ CsrWifiRouterCtrlTrafficConfigType config_type,
+ const CsrWifiRouterCtrlTrafficConfig *config)
+{
+ ta_data_t *tad = &card->ta_sampling;
+
+ /* Reinitialise our data when we are reset */
+ if (config_type == CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_RESET)
+ {
+ /* Reset the stats to zero */
+ tas_reset_data(tad);
+
+ /* Reset the timer variables */
+ tad->tx_last_ts = 0;
+ tad->last_indication_time = 0;
+
+ return CSR_RESULT_SUCCESS;
+ }
+
+ if (config_type == CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_FILTER)
+ {
+ tad->packet_filter = config->packetFilter;
+
+ if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
+ {
+ tad->custom_filter = config->customFilter;
+ }
+
+ return CSR_RESULT_SUCCESS;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_ta_configure() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * External API.
+ * unifi_ta_classification
+ *
+ * Configures the current TA classification.
+ *
+ * Arguments:
+ * ta The pointer to the TA module.
+ * traffic_type The classification type
+ * period The traffic period if the type is periodic
+ *
+ * Returns:
+ * None
+ * ---------------------------------------------------------------------------
+ */
+void unifi_ta_classification(card_t *card,
+ CsrWifiRouterCtrlTrafficType traffic_type,
+ CsrUint16 period)
+{
+ unifi_trace(card->ospriv, UDBG3,
+ "Changed current ta classification to: %d\n", traffic_type);
+
+ card->ta_sampling.traffic_type = traffic_type;
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_ta_sampling.h
+ *
+ * PURPOSE:
+ * This file contains Traffic Analysis definitions common to the
+ * sampling and analysis modules.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#ifndef __TA_SAMPLING_H__
+#define __TA_SAMPLING_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csr_wifi_hip_unifi.h"
+
+typedef struct ta_l4stats
+{
+ CsrUint32 rxTcpBytesCount;
+ CsrUint32 txTcpBytesCount;
+ CsrUint32 rxUdpBytesCount;
+ CsrUint32 txUdpBytesCount;
+} ta_l4stats_t;
+
+/*
+ * Context structure to preserve state between calls.
+ */
+
+typedef struct ta_data
+{
+ /* Current packet filter configuration */
+ CsrUint16 packet_filter;
+
+ /* Current packet custom filter configuration */
+ CsrWifiRouterCtrlTrafficFilter custom_filter;
+
+ /* The timestamp of the last tx packet processed. */
+ CsrUint32 tx_last_ts;
+
+ /* The timestamp of the last packet processed. */
+ CsrUint32 last_indication_time;
+
+ /* Statistics */
+ CsrWifiRouterCtrlTrafficStats stats;
+
+ /* Current traffic classification */
+ CsrWifiRouterCtrlTrafficType traffic_type;
+
+ /* Sum of packet rx rates for this interval used to calculate mean */
+ CsrUint32 rx_sum_rate;
+ ta_l4stats_t ta_l4stats;
+} ta_data_t;
+
+
+void unifi_ta_sampling_init(card_t *card);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TA_SAMPLING_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_card_udi.c
+ *
+ * PURPOSE:
+ * Maintain a list of callbacks to log UniFi exchanges to one or more
+ * debug/monitoring client applications.
+ *
+ * NOTES:
+ * Just call the UDI driver log fn directly for now.
+ * When done properly, each open() on the UDI device will install
+ * a log function. We will call all log fns whenever a signal is written
+ * to or read form the UniFi.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_card.h"
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_print_status
+ *
+ * Print status info to given character buffer.
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+CsrInt32 unifi_print_status(card_t *card, CsrCharString *str, CsrInt32 *remain)
+{
+ CsrCharString *p = str;
+ sdio_config_data_t *cfg;
+ CsrUint16 i, n;
+ CsrInt32 remaining = *remain;
+ CsrInt32 written;
+#ifdef CSR_UNSAFE_SDIO_ACCESS
+ CsrInt32 iostate;
+ CsrResult r;
+ static const CsrCharString *const states[] = {
+ "AWAKE", "DROWSY", "TORPID"
+ };
+ #define SHARED_READ_RETRY_LIMIT 10
+ CsrUint8 b;
+#endif
+
+ if (remaining <= 0)
+ {
+ return 0;
+ }
+
+ i = n = 0;
+ written = CsrSnprintf(p, remaining, "Chip ID %u\n",
+ (CsrUint16)card->chip_id);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "Chip Version %04X\n",
+ card->chip_version);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "HIP v%u.%u\n",
+ (card->config_data.version >> 8) & 0xFF,
+ card->config_data.version & 0xFF);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "Build %lu: %s\n",
+ card->build_id, card->build_id_string);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ cfg = &card->config_data;
+
+ written = CsrSnprintf(p, remaining, "sdio ctrl offset %u\n",
+ cfg->sdio_ctrl_offset);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "fromhost sigbuf handle %u\n",
+ cfg->fromhost_sigbuf_handle);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "tohost_sigbuf_handle %u\n",
+ cfg->tohost_sigbuf_handle);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "num_fromhost_sig_frags %u\n",
+ cfg->num_fromhost_sig_frags);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "num_tohost_sig_frags %u\n",
+ cfg->num_tohost_sig_frags);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "num_fromhost_data_slots %u\n",
+ cfg->num_fromhost_data_slots);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "num_tohost_data_slots %u\n",
+ cfg->num_tohost_data_slots);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "data_slot_size %u\n",
+ cfg->data_slot_size);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ /* Added by protocol version 0x0001 */
+ written = CsrSnprintf(p, remaining, "overlay_size %u\n",
+ (CsrUint16)cfg->overlay_size);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ /* Added by protocol version 0x0300 */
+ written = CsrSnprintf(p, remaining, "data_slot_round %u\n",
+ cfg->data_slot_round);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "sig_frag_size %u\n",
+ cfg->sig_frag_size);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ /* Added by protocol version 0x0300 */
+ written = CsrSnprintf(p, remaining, "tohost_sig_pad %u\n",
+ cfg->tohost_signal_padding);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ written = CsrSnprintf(p, remaining, "\nInternal state:\n");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ written = CsrSnprintf(p, remaining, "Last PHY PANIC: %04x:%04x\n",
+ card->last_phy_panic_code, card->last_phy_panic_arg);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "Last MAC PANIC: %04x:%04x\n",
+ card->last_mac_panic_code, card->last_mac_panic_arg);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ written = CsrSnprintf(p, remaining, "fhsr: %u\n",
+ (CsrUint16)card->from_host_signals_r);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "fhsw: %u\n",
+ (CsrUint16)card->from_host_signals_w);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "thsr: %u\n",
+ (CsrUint16)card->to_host_signals_r);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "thsw: %u\n",
+ (CsrUint16)card->to_host_signals_w);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining,
+ "fh buffer contains: %u signals, %u bytes\n",
+ card->fh_buffer.count,
+ card->fh_buffer.ptr - card->fh_buffer.buf);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ written = CsrSnprintf(p, remaining, "paused: ");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ for (i = 0; i < sizeof(card->tx_q_paused_flag) / sizeof(card->tx_q_paused_flag[0]); i++)
+ {
+ written = CsrSnprintf(p, remaining, card->tx_q_paused_flag[i]?"1" : "0");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ }
+ written = CsrSnprintf(p, remaining, "\n");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ written = CsrSnprintf(p, remaining,
+ "fh command q: %u waiting, %u free of %u:\n",
+ CSR_WIFI_HIP_Q_SLOTS_USED(&card->fh_command_queue),
+ CSR_WIFI_HIP_Q_SLOTS_FREE(&card->fh_command_queue),
+ UNIFI_SOFT_COMMAND_Q_LENGTH);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)
+ {
+ written = CsrSnprintf(p, remaining,
+ "fh traffic q[%u]: %u waiting, %u free of %u:\n",
+ i,
+ CSR_WIFI_HIP_Q_SLOTS_USED(&card->fh_traffic_queue[i]),
+ CSR_WIFI_HIP_Q_SLOTS_FREE(&card->fh_traffic_queue[i]),
+ UNIFI_SOFT_TRAFFIC_Q_LENGTH);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ }
+
+ written = CsrSnprintf(p, remaining, "fh data slots free: %u\n",
+ card->from_host_data?CardGetFreeFromHostDataSlots(card) : 0);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+
+ written = CsrSnprintf(p, remaining, "From host data slots:");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ n = card->config_data.num_fromhost_data_slots;
+ for (i = 0; i < n && card->from_host_data; i++)
+ {
+ written = CsrSnprintf(p, remaining, " %u",
+ (CsrUint16)card->from_host_data[i].bd.data_length);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ }
+ written = CsrSnprintf(p, remaining, "\n");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ written = CsrSnprintf(p, remaining, "To host data slots:");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ n = card->config_data.num_tohost_data_slots;
+ for (i = 0; i < n && card->to_host_data; i++)
+ {
+ written = CsrSnprintf(p, remaining, " %u",
+ (CsrUint16)card->to_host_data[i].data_length);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ }
+
+ written = CsrSnprintf(p, remaining, "\n");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+#ifdef CSR_UNSAFE_SDIO_ACCESS
+ written = CsrSnprintf(p, remaining, "Host State: %s\n", states[card->host_state]);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ r = unifi_check_io_status(card, &iostate);
+ if (iostate == 1)
+ {
+ written = CsrSnprintf(p, remaining, "I/O Check: F1 disabled\n");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ }
+ else
+ {
+ if (iostate == 1)
+ {
+ written = CsrSnprintf(p, remaining, "I/O Check: pending interrupt\n");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ }
+
+ written = CsrSnprintf(p, remaining, "BH reason interrupt = %d\n",
+ card->bh_reason_unifi);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "BH reason host = %d\n",
+ card->bh_reason_host);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ for (i = 0; i < SHARED_READ_RETRY_LIMIT; i++)
+ {
+ r = unifi_read_8_or_16(card, card->sdio_ctrl_addr + 2, &b);
+ if ((r == CSR_RESULT_SUCCESS) && (!(b & 0x80)))
+ {
+ written = CsrSnprintf(p, remaining, "fhsr: %u (driver thinks is %u)\n",
+ b, card->from_host_signals_r);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ break;
+ }
+ }
+ iostate = unifi_read_shared_count(card, card->sdio_ctrl_addr + 4);
+ written = CsrSnprintf(p, remaining, "thsw: %u (driver thinks is %u)\n",
+ iostate, card->to_host_signals_w);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ }
+#endif
+
+ written = CsrSnprintf(p, remaining, "\nStats:\n");
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "Total SDIO bytes: R=%lu W=%lu\n",
+ card->sdio_bytes_read, card->sdio_bytes_written);
+
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+ written = CsrSnprintf(p, remaining, "Interrupts generated on card: %lu\n",
+ card->unifi_interrupt_seq);
+ UNIFI_SNPRINTF_RET(p, remaining, written);
+
+ *remain = remaining;
+ return (p - str);
+} /* unifi_print_status() */
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * FILE : csr_wifi_hip_unifi.h
+ *
+ * PURPOSE : Public API for the UniFi HIP core library.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#ifndef __CSR_WIFI_HIP_UNIFI_H__
+#define __CSR_WIFI_HIP_UNIFI_H__ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_HIP_TA_DISABLE
+#include "csr_wifi_router_ctrl_prim.h"
+#include "csr_wifi_router_prim.h"
+#else
+#include "csr_time.h"
+#endif
+
+/* SDIO chip ID numbers */
+
+/* Manufacturer id */
+#define SDIO_MANF_ID_CSR 0x032a
+
+/* Device id */
+#define SDIO_CARD_ID_UNIFI_1 0x0001
+#define SDIO_CARD_ID_UNIFI_2 0x0002
+#define SDIO_CARD_ID_UNIFI_3 0x0007
+#define SDIO_CARD_ID_UNIFI_4 0x0008
+
+/* Function number for WLAN */
+#define SDIO_WLAN_FUNC_ID_UNIFI_1 0x0001
+#define SDIO_WLAN_FUNC_ID_UNIFI_2 0x0001
+#define SDIO_WLAN_FUNC_ID_UNIFI_3 0x0001
+#define SDIO_WLAN_FUNC_ID_UNIFI_4 0x0002
+
+/* Maximum SDIO bus clock supported. */
+#define UNIFI_SDIO_CLOCK_MAX_HZ 50000000 /* Hz */
+
+/*
+ * Initialisation SDIO bus clock.
+ *
+ * The initialisation clock speed should be used from when the chip has been
+ * reset until the first MLME-reset has been received (i.e. during firmware
+ * initialisation), unless UNIFI_SDIO_CLOCK_SAFE_HZ applies.
+ */
+#define UNIFI_SDIO_CLOCK_INIT_HZ 12500000 /* Hz */
+
+/*
+ * Safe SDIO bus clock.
+ *
+ * The safe speed should be used when the chip is in deep sleep or
+ * it's state is unknown (just after reset / power on).
+ */
+#define UNIFI_SDIO_CLOCK_SAFE_HZ 1000000 /* Hz */
+
+/* I/O default block size to use for UniFi. */
+#define UNIFI_IO_BLOCK_SIZE 64
+
+#define UNIFI_WOL_OFF 0
+#define UNIFI_WOL_SDIO 1
+#define UNIFI_WOL_PIO 2
+
+/* The number of Tx traffic queues */
+#define UNIFI_NO_OF_TX_QS 4
+
+#define CSR_WIFI_HIP_RESERVED_HOST_TAG 0xFFFFFFFF
+
+/*
+ * The number of slots in the from-host queues.
+ *
+ * UNIFI_SOFT_TRAFFIC_Q_LENGTH is the number of slots in the traffic queues
+ * and there will be UNIFI_NO_OF_TX_QS of them.
+ * Traffic queues are used for data packets.
+ *
+ * UNIFI_SOFT_COMMAND_Q_LENGTH is the number of slots in the command queue.
+ * The command queue is used for MLME management requests.
+ *
+ * Queues are ring buffers and so must always have 1 unused slot.
+ */
+#define UNIFI_SOFT_TRAFFIC_Q_LENGTH (20 + 1)
+#define UNIFI_SOFT_COMMAND_Q_LENGTH (16 + 1)
+
+#include "csr_types.h" /* from the synergy porting folder */
+#include "csr_framework_ext.h" /* from the synergy porting folder */
+#include "csr_sdio.h" /* from the synergy porting folder */
+#include "csr_pmem.h" /* from the synergy porting folder */
+#include "csr_util.h" /* from the synergy porting folder */
+#include "csr_formatted_io.h" /* from the synergy gsp folder */
+#include "csr_wifi_result.h"
+
+/* Utility MACROS. Note that UNIFI_MAC_ADDRESS_CMP returns TRUE on success */
+#define UNIFI_MAC_ADDRESS_COPY(dst, src) \
+ do { (dst)[0] = (src)[0]; (dst)[1] = (src)[1]; \
+ (dst)[2] = (src)[2]; (dst)[3] = (src)[3]; \
+ (dst)[4] = (src)[4]; (dst)[5] = (src)[5]; \
+ } while (0)
+
+#define UNIFI_MAC_ADDRESS_CMP(addr1, addr2) \
+ (((addr1)[0] == (addr2)[0]) && ((addr1)[1] == (addr2)[1]) && \
+ ((addr1)[2] == (addr2)[2]) && ((addr1)[3] == (addr2)[3]) && \
+ ((addr1)[4] == (addr2)[4]) && ((addr1)[5] == (addr2)[5]))
+
+/* Traffic queue ordered according to priority
+ * EAPOL/Uncontrolled port Queue should be the last
+ */
+typedef enum
+{
+ UNIFI_TRAFFIC_Q_BK = 0,
+ UNIFI_TRAFFIC_Q_BE,
+ UNIFI_TRAFFIC_Q_VI,
+ UNIFI_TRAFFIC_Q_VO,
+ UNIFI_TRAFFIC_Q_EAPOL, /* Non existant in HIP */
+ UNIFI_TRAFFIC_Q_MAX, /* Non existant */
+ UNIFI_TRAFFIC_Q_MLME /* Non existant */
+} unifi_TrafficQueue;
+
+/*
+ * Structure describing a bulk data slot.
+ * This structure is shared between the HIP core library and the OS
+ * layer. See the definition of unifi_net_data_malloc() for more details.
+ *
+ * The data_length field is used to indicate empty/occupied state.
+ * Needs to be defined before #include "unifi_os.h".
+ */
+typedef struct _bulk_data_desc
+{
+ const CsrUint8 *os_data_ptr;
+ CsrUint32 data_length;
+ const void *os_net_buf_ptr;
+ CsrUint32 net_buf_length;
+} bulk_data_desc_t;
+
+/* Structure of an entry in the Symbol Look Up Table (SLUT). */
+typedef struct _symbol
+{
+ CsrUint16 id;
+ CsrUint32 obj;
+} symbol_t;
+
+/*
+ * Header files need to be included from the current directory,
+ * the SME library, the synergy framework and the OS layer.
+ * A thin OS layer needs to be implemented in the porting exercise.
+ *
+ * Note that unifi_os.h should be included only in unifi.h
+ */
+
+#include "unifi_os.h"
+
+/*
+ * Contains the HIP core definitions selected in the porting exercise, such as
+ * UNIFI_PAD_BULK_DATA_TO_BLOCK_SIZE and UNIFI_PAD_SIGNALS_TO_BLOCK_SIZE.
+ * Implemented in the OS layer, as part of the porting exersice.
+ */
+#include "unifi_config.h"
+
+#include "csr_wifi_hip_signals.h" /* from this dir */
+
+/*
+ * The card structure is an opaque pointer that is used to pass context
+ * to the upper-edge API functions.
+ */
+typedef struct card card_t;
+
+
+/*
+ * This structure describes all of the bulk data that 'might' be
+ * associated with a signal.
+ */
+typedef struct _bulk_data_param
+{
+ bulk_data_desc_t d[UNIFI_MAX_DATA_REFERENCES];
+} bulk_data_param_t;
+
+
+/*
+ * This structure describes the chip and HIP core lib
+ * information that exposed to the OS layer.
+ */
+typedef struct _card_info
+{
+ CsrUint16 chip_id;
+ CsrUint16 chip_version;
+ CsrUint32 fw_build;
+ CsrUint16 fw_hip_version;
+ CsrUint32 sdio_block_size;
+} card_info_t;
+
+
+/*
+ * Mini-coredump definitions
+ */
+/* Definition of XAP memory ranges used by the mini-coredump system.
+ * Note that, these values are NOT the same as UNIFI_REGISTERS, etc
+ * in unifihw.h which don't allow selection of register areas for each XAP.
+ */
+typedef enum unifi_coredump_space
+{
+ UNIFI_COREDUMP_MAC_REG,
+ UNIFI_COREDUMP_PHY_REG,
+ UNIFI_COREDUMP_SH_DMEM,
+ UNIFI_COREDUMP_MAC_DMEM,
+ UNIFI_COREDUMP_PHY_DMEM,
+ UNIFI_COREDUMP_TRIGGER_MAGIC = 0xFEED
+} unifi_coredump_space_t;
+
+/* Structure used to request a register value from a mini-coredump buffer */
+typedef struct unifi_coredump_req
+{
+ /* From user */
+ CsrInt32 index; /* 0=newest, -1=oldest */
+ unifi_coredump_space_t space; /* memory space */
+ CsrUint32 offset; /* register offset in space */
+ /* From driver */
+ CsrUint32 drv_build; /* Driver build id */
+ CsrUint32 chip_ver; /* Chip version */
+ CsrUint32 fw_ver; /* Firmware version */
+ CsrInt32 requestor; /* Requestor: 0=auto dump, 1=manual */
+ CsrTime timestamp; /* time of capture by driver */
+ CsrUint32 serial; /* capture serial number */
+ CsrInt32 value; /* register value */
+} unifi_coredump_req_t; /* mini-coredumped reg value request */
+
+
+/**
+ * @defgroup upperedge Upper edge API
+ *
+ * The following functions are implemented in the HIP core lib.
+ */
+
+/**
+ *
+ * Initialise the HIP core lib.
+ * Note that the OS layer must initialise the SDIO glue layer and obtain
+ * an SDIO function context, prior to this call.
+ *
+ * @param sdiopriv the SDIO function context.
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @return \p card_t the HIP core lib API context.
+ *
+ * @ingroup upperedge
+ */
+card_t* unifi_alloc_card(CsrSdioFunction *sdiopriv, void *ospriv);
+
+
+/**
+ *
+ * Initialise the UniFi chip.
+ *
+ * @param card the HIP core lib API context.
+ *
+ * @param led_mask the led mask to apply to UniFi.
+ *
+ * @return \b 0 if UniFi is initialized.
+ *
+ * @return \b -CSR_EIO if an I/O error occured while initializing UniFi
+ *
+ * @return \b -CSR_ENODEV if the card is no longer present.
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_init_card(card_t *card, CsrInt32 led_mask);
+
+/**
+ *
+ * De-Initialise the HIP core lib.
+ *
+ * @param card the HIP core lib API context.
+ *
+ * @ingroup upperedge
+ */
+void unifi_free_card(card_t *card);
+
+/**
+ *
+ * Cancel all the signals pending in the HIP core lib.
+ * Normally used during a system suspend when the power is retained on UniFi.
+ *
+ * @param card the HIP core lib API context.
+ *
+ * @ingroup upperedge
+ */
+void unifi_cancel_pending_signals(card_t *card);
+
+/**
+ *
+ * Send a signal to UniFi.
+ * Normally it is called from unifi_sys_hip_req() and the OS layer
+ * Tx data plane.
+ *
+ * Note that the bulkdata buffers ownership is passed to the HIP core lib.
+ * These buffers must be allocated using unifi_net_data_malloc().
+ *
+ * @param card the HIP core lib API context.
+ *
+ * @param sigptr pointer to the signal.
+ *
+ * @param siglen size of the signal.
+ *
+ * @param bulkdata pointer to the bulk data associated with the signal.
+ *
+ * @return \b 0 signal is sent.
+ *
+ * @return \b -CSR_EIO if an error occured while sending the signal
+ *
+ * @return \b -CSR_ENODEV if the card is no longer present.
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_send_signal(card_t *card, const CsrUint8 *sigptr,
+ CsrUint32 siglen,
+ const bulk_data_param_t *bulkdata);
+
+/**
+ *
+ * Check if the HIP core lib has resources to send a signal.
+ * Normally there no need to use this function.
+ *
+ * @param card the HIP core lib API context.
+ *
+ * @param sigptr pointer to the signal.
+ *
+ * @return \b 0 if there are resources for the signal.
+ *
+ * @return \b -CSR_ENOSPC if there are not enough resources
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_send_resources_available(card_t *card, const CsrUint8 *sigptr);
+
+/**
+ *
+ * Read the UniFi chip and the HIP core lib information.
+ *
+ * @param card the HIP core lib API context.
+ *
+ * @param card_info pointer to save the information.
+ *
+ * @ingroup upperedge
+ */
+void unifi_card_info(card_t *card, card_info_t *card_info);
+
+/**
+ *
+ * Print the UniFi I/O and Interrupt status.
+ * Normally it is used for debug purposes only.
+ *
+ * @param card the HIP core lib API context.
+
+ * @param status buffer for the chip status
+ *
+ * @return \b 0 if the check was performed.
+ *
+ * @return \b -CSR_EIO if an error occured while checking the status.
+ *
+ * @return \b -CSR_ENODEV if the card is no longer present.
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_check_io_status(card_t *card, CsrInt32 *status);
+
+
+/**
+ *
+ * Run the HIP core lib Botton-Half.
+ * Whenever the HIP core lib want this function to be called
+ * by the OS layer, it calls unifi_run_bh().
+ *
+ * @param card the HIP core lib API context.
+ *
+ * @param remaining pointer to return the time (in msecs) that this function
+ * should be re-scheduled. A return value of 0 means that no re-scheduling
+ * is required. If unifi_bh() is called before the timeout expires,
+ * the caller must pass in the remaining time.
+ *
+ * @return \b 0 if no error occured.
+ *
+ * @return \b -CSR_ENODEV if the card is no longer present.
+ *
+ * @return \b -CSR_E* if an error occured while running the bottom half.
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_bh(card_t *card, CsrUint32 *remaining);
+
+
+/**
+ * UniFi Low Power Mode (Deep Sleep Signaling)
+ *
+ * unifi_low_power_mode defines the UniFi Deep Sleep Signaling status.
+ * Use with unifi_configure_low_power_mode() to enable/disable
+ * the Deep Sleep Signaling.
+ */
+enum unifi_low_power_mode
+{
+ UNIFI_LOW_POWER_DISABLED,
+ UNIFI_LOW_POWER_ENABLED
+};
+
+/**
+ * Periodic Wake Host Mode
+ *
+ * unifi_periodic_wake_mode defines the Periodic Wake Host Mode.
+ * It can only be set to UNIFI_PERIODIC_WAKE_HOST_ENABLED if
+ * low_power_mode == UNIFI_LOW_POWER_ENABLED.
+ */
+enum unifi_periodic_wake_mode
+{
+ UNIFI_PERIODIC_WAKE_HOST_DISABLED,
+ UNIFI_PERIODIC_WAKE_HOST_ENABLED
+};
+
+/**
+ *
+ * Run the HIP core lib Botton-Half.
+ * Whenever the HIP core lib want this function to be called
+ * by the OS layer, it calls unifi_run_bh().
+ *
+ * Typically, the SME is responsible for configuring these parameters,
+ * so unifi_sys_configure_power_mode_req() is usually implemented
+ * as a direct call to unifi_configure_low_power_mode().
+ *
+ * Note: When polling mode is used instead of interrupts,
+ * low_power_mode must never be set to UNIFI_LOW_POWER_ENABLED.
+ *
+ * @param card the HIP core lib API context.
+ *
+ * @param low_power_mode the Low Power Mode.
+ *
+ * @param periodic_wake_mode the Periodic Wake Mode.
+ *
+ * @return \b 0 if no error occured.
+ *
+ * @return \b -CSR_E* if the request failed.
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_configure_low_power_mode(card_t *card,
+ enum unifi_low_power_mode low_power_mode,
+ enum unifi_periodic_wake_mode periodic_wake_mode);
+
+/**
+ *
+ * Forces the UniFi chip to enter a Deep Sleep state.
+ * This is normally called by the OS layer when the platform suspends.
+ *
+ * Note that if the UniFi Low Power Mode is disabled this call fails.
+ *
+ * @param card the HIP core lib API context.
+ *
+ * @return \b 0 if no error occured.
+ *
+ * @return \b -CSR_ENODEV if the card is no longer present.
+ *
+ * @return \b -CSR_E* if the request failed.
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_force_low_power_mode(card_t *card);
+
+#ifndef CSR_WIFI_HIP_TA_DISABLE
+/**
+ * Configure the Traffic Analysis sampling
+ *
+ * Enable or disable statistics gathering.
+ * Enable or disable particular packet detection.
+ *
+ * @param card the HIP core context
+ * @param config_type the item to configure
+ * @param config pointer to struct containing config info
+ *
+ * @return \b 0 if configuration was successful
+ *
+ * @return \b -CSR_EINVAL if a parameter had an invalid value
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_ta_configure(card_t *card,
+ CsrWifiRouterCtrlTrafficConfigType config_type,
+ const CsrWifiRouterCtrlTrafficConfig *config);
+
+/**
+ * Pass a packet for Traffic Analysis sampling
+ *
+ * @param card the HIP core context
+ * @param direction the direction (Rx or Tx) of the frame.
+ * @param data pointer to bulkdata struct containing the packet
+ * @param saddr the source address of the packet
+ * @param sta_macaddr the MAC address of the UniFi chip
+ * @param timestamp the current time in msecs
+ *
+ * @ingroup upperedge
+ */
+void unifi_ta_sample(card_t *card,
+ CsrWifiRouterCtrlProtocolDirection direction,
+ const bulk_data_desc_t *data,
+ const CsrUint8 *saddr,
+ const CsrUint8 *sta_macaddr,
+ CsrUint32 timestamp,
+ CsrUint16 rate);
+
+/**
+ * Notify the HIP core lib for a detected Traffic Classification.
+ * Typically, the SME is responsible for configuring these parameters,
+ * so unifi_sys_traffic_classification_req() is usually implemented
+ * as a direct call to unifi_ta_classification().
+ *
+ * @param card the HIP core context.
+ * @param traffic_type the detected traffic type.
+ * @param period The detected period of the traffic.
+ *
+ * @ingroup upperedge
+ */
+void unifi_ta_classification(card_t *card,
+ CsrWifiRouterCtrlTrafficType traffic_type,
+ CsrUint16 period);
+
+#endif
+/**
+ * Use software to hard reset the chip.
+ * This is a subset of the unifi_init_card() functionality and should
+ * only be used only to reset a paniced chip before a coredump is taken.
+ *
+ * @param card the HIP core context.
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_card_hard_reset(card_t *card);
+
+
+CsrResult unifi_card_readn(card_t *card, CsrUint32 unifi_addr, void *pdata, CsrUint16 len);
+CsrResult unifi_card_read16(card_t *card, CsrUint32 unifi_addr, CsrUint16 *pdata);
+CsrResult unifi_card_write16(card_t *card, CsrUint32 unifi_addr, CsrUint16 data);
+
+
+enum unifi_dbg_processors_select
+{
+ UNIFI_PROC_MAC,
+ UNIFI_PROC_PHY,
+ UNIFI_PROC_BT,
+ UNIFI_PROC_BOTH,
+ UNIFI_PROC_INVALID
+};
+
+CsrResult unifi_card_stop_processor(card_t *card, enum unifi_dbg_processors_select which);
+
+/**
+ * Call-outs from the HIP core lib to the OS layer.
+ * The following functions need to be implemented during the porting exercise.
+ */
+
+/**
+ * Selects appropriate queue according to priority
+ * Helps maintain uniformity in queue selection between the HIP
+ * and the OS layers.
+ *
+ * @param priority priority of the packet
+ *
+ * @return \b Traffic queue to which a packet of this priority belongs
+ *
+ * @ingroup upperedge
+ */
+unifi_TrafficQueue
+unifi_frame_priority_to_queue(CSR_PRIORITY priority);
+
+/**
+ * Returns the priority corresponding to a particular Queue when that is used
+ * when downgrading a packet to a lower AC.
+ * Helps maintain uniformity in queue - priority mapping between the HIP
+ * and the OS layers.
+ *
+ * @param queue
+ *
+ * @return \b Highest priority corresponding to this queue
+ *
+ * @ingroup upperedge
+ */
+CSR_PRIORITY unifi_get_default_downgrade_priority(unifi_TrafficQueue queue);
+
+/**
+ *
+ * Flow control callbacks.
+ * unifi_pause_xmit() is called when the HIP core lib does not have any
+ * resources to store data packets. The OS layer needs to pause
+ * the Tx data plane until unifi_restart_xmit() is called.
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @ingroup upperedge
+ */
+void unifi_pause_xmit(void *ospriv, unifi_TrafficQueue queue);
+void unifi_restart_xmit(void *ospriv, unifi_TrafficQueue queue);
+
+/**
+ *
+ * Request to run the Bottom-Half.
+ * The HIP core lib calls this function to request that unifi_bh()
+ * needs to be run by the OS layer. It can be called anytime, i.e.
+ * when the unifi_bh() is running.
+ * Since unifi_bh() is not re-entrant, usually unifi_run_bh() sets
+ * an event to a thread that schedules a call to unifi_bh().
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_run_bh(void *ospriv);
+
+/**
+ *
+ * Delivers a signal received from UniFi to the OS layer.
+ * Normally, the data signals should be delivered to the data plane
+ * and all the rest to the SME (unifi_sys_hip_ind()).
+ *
+ * Note that the OS layer is responsible for freeing the bulkdata
+ * buffers, using unifi_net_data_free().
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @param sigptr pointer to the signal.
+ *
+ * @param siglen size of the signal.
+ *
+ * @param bulkdata pointer to the bulk data associated with the signal.
+ *
+ * @ingroup upperedge
+ */
+void unifi_receive_event(void *ospriv,
+ CsrUint8 *sigdata, CsrUint32 siglen,
+ const bulk_data_param_t *bulkdata);
+
+#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
+/**
+ *
+ * Used to reque the failed ma packet request back to hal queues
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @param host_tag host tag for the packet to requeue.
+ *
+ * @param bulkDataDesc pointer to the bulk data.
+ *
+ * @ingroup upperedge
+ */
+CsrResult unifi_reque_ma_packet_request(void *ospriv, CsrUint32 host_tag,
+ CsrUint16 status,
+ bulk_data_desc_t *bulkDataDesc);
+
+#endif
+typedef struct
+{
+ CsrUint16 free_fh_sig_queue_slots[UNIFI_NO_OF_TX_QS];
+ CsrUint16 free_fh_bulkdata_slots;
+ CsrUint16 free_fh_fw_slots;
+} unifi_HipQosInfo;
+
+void unifi_get_hip_qos_info(card_t *card, unifi_HipQosInfo *hipqosinfo);
+
+
+/**
+ * Functions that read a portion of a firmware file.
+ *
+ * Note: If the UniFi chip runs the f/w from ROM, the HIP core may never
+ * call these functions. Also, the HIP core may call these functions even if
+ * a f/w file is not available. In this case, it is safe to fail the request.
+ */
+#define UNIFI_FW_STA 1 /* Identify STA firmware file */
+
+/**
+ *
+ * Ask the OS layer to initialise a read from a f/w file.
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @param is_fw if 0 the request if for the loader file, if 1 the request
+ * is for a f/w file.
+ *
+ * @param info a card_info_t structure containing versions information.
+ * Note that some members of the structure may not be initialised.
+ *
+ * @return \p NULL if the file is not available, or a pointer which contains
+ * OS specific information for the file (typically the contents of the file)
+ * that the HIP core uses when calling unifi_fw_read() and unifi_fw_read_stop()
+ *
+ * @ingroup upperedge
+ */
+void* unifi_fw_read_start(void *ospriv, CsrInt8 is_fw, const card_info_t *info);
+
+/**
+ *
+ * Ask the OS layer to return a portion from a f/w file.
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @param arg the OS pointer returned by unifi_fw_read_start().
+ *
+ * @param offset the offset in the f/w file to read the read from.
+ *
+ * @param buf the buffer to store the returned data.
+ *
+ * @param len the size in bytes of the requested read.
+ *
+ * @ingroup upperedge
+ */
+CsrInt32 unifi_fw_read(void *ospriv, void *arg, CsrUint32 offset, void *buf, CsrUint32 len);
+
+/**
+ *
+ * Ask the OS layer to finish reading from a f/w file.
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @param dlpriv the OS pointer returned by unifi_fw_read_start().
+ *
+ * @ingroup upperedge
+ */
+void unifi_fw_read_stop(void *ospriv, void *dlpriv);
+
+/**
+ *
+ * Ask OS layer for a handle to a dynamically allocated firmware buffer
+ * (primarily intended for production test images which may need conversion)
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @param fwbuf pointer to dynamically allocated buffer
+ *
+ * @param len length of provided buffer in bytes
+ *
+ * @ingroup upperedge
+ */
+void* unifi_fw_open_buffer(void *ospriv, void *fwbuf, CsrUint32 len);
+
+/**
+ *
+ * Release a handle to a dynamically allocated firmware buffer
+ * (primarily intended for production test images which may need conversion)
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @param fwbuf pointer to dynamically allocated buffer
+ *
+ * @ingroup upperedge
+ */
+void unifi_fw_close_buffer(void *ospriv, void *fwbuf);
+
+#ifndef CSR_WIFI_HIP_TA_DISABLE
+/*
+ * Driver must provide these.
+ *
+ * A simple implementation will just call
+ * unifi_sys_traffic_protocol_ind() or unifi_sys_traffic_classification_ind()
+ * respectively. See sme_csr_userspace/sme_userspace.c.
+ */
+/**
+ *
+ * Indicates a detected packet of type packet_type.
+ * Typically, this information is processed by the SME so
+ * unifi_ta_indicate_protocol() needs to schedule a call to
+ * unifi_sys_traffic_protocol_ind().
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @param packet_type the detected packet type.
+ *
+ * @param direction the direction of the packet (Rx, Tx).
+ *
+ * @param src_addr the source address of the packet.
+ *
+ * @ingroup upperedge
+ */
+void unifi_ta_indicate_protocol(void *ospriv,
+ CsrWifiRouterCtrlTrafficPacketType packet_type,
+ CsrWifiRouterCtrlProtocolDirection direction,
+ const CsrWifiMacAddress *src_addr);
+
+/**
+ *
+ * Indicates statistics for the sample data over a period.
+ * Typically, this information is processed by the SME so
+ * unifi_ta_indicate_sampling() needs to schedule a call to
+ * unifi_sys_traffic_sample_ind().
+ *
+ * @param ospriv the OS layer context.
+ *
+ * @param stats the pointer to the structure that contains the statistics.
+ *
+ * @ingroup upperedge
+ */
+void unifi_ta_indicate_sampling(void *ospriv, CsrWifiRouterCtrlTrafficStats *stats);
+void unifi_ta_indicate_l4stats(void *ospriv,
+ CsrUint32 rxTcpThroughput,
+ CsrUint32 txTcpThroughput,
+ CsrUint32 rxUdpThroughput,
+ CsrUint32 txUdpThroughput);
+#endif
+
+void unifi_rx_queue_flush(void *ospriv);
+
+/**
+ * Call-out from the SDIO glue layer.
+ *
+ * The glue layer needs to call unifi_sdio_interrupt_handler() every time
+ * an interrupts occurs.
+ *
+ * @param card the HIP core context.
+ *
+ * @ingroup bottomedge
+ */
+void unifi_sdio_interrupt_handler(card_t *card);
+
+
+/* HELPER FUNCTIONS */
+
+/*
+ * unifi_init() and unifi_download() implement a subset of unifi_init_card functionality
+ * that excludes HIP initialization.
+ */
+CsrResult unifi_init(card_t *card);
+CsrResult unifi_download(card_t *card, CsrInt32 led_mask);
+
+/*
+ * unifi_start_processors() ensures both on-chip processors are running
+ */
+CsrResult unifi_start_processors(card_t *card);
+
+CsrResult unifi_capture_panic(card_t *card);
+
+/*
+ * Configure HIP interrupt processing mode
+ */
+#define CSR_WIFI_INTMODE_DEFAULT 0
+#define CSR_WIFI_INTMODE_RUN_BH_ONCE 1 /* Run BH once per interrupt */
+
+void unifi_set_interrupt_mode(card_t *card, CsrUint32 mode);
+
+/*
+ * unifi_request_max_clock() requests that max SDIO clock speed is set at the
+ * next suitable opportunity.
+ */
+void unifi_request_max_sdio_clock(card_t *card);
+
+
+/* Functions to lookup bulk data command names. */
+const CsrCharString* lookup_bulkcmd_name(CsrUint16 id);
+
+/* Function to log HIP's global debug buffer */
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+void unifi_debug_buf_dump(void);
+void unifi_debug_log_to_buf(const CsrCharString *fmt, ...);
+void unifi_debug_hex_to_buf(const CsrCharString *buff, CsrUint16 length);
+#endif
+
+/* Mini-coredump utility functions */
+CsrResult unifi_coredump_get_value(card_t *card, struct unifi_coredump_req *req);
+CsrResult unifi_coredump_capture(card_t *card, struct unifi_coredump_req *req);
+CsrResult unifi_coredump_request_at_next_reset(card_t *card, CsrInt8 enable);
+CsrResult unifi_coredump_init(card_t *card, CsrUint16 num_dump_buffers);
+void unifi_coredump_free(card_t *card);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CSR_WIFI_HIP_UNIFI_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include "csr_wifi_hip_unifi.h"
+
+struct sig_name
+{
+ CsrInt16 id;
+ const CsrCharString *name;
+};
+
+static const struct sig_name Unifi_bulkcmd_names[] = {
+ { 0, "SignalCmd" },
+ { 1, "CopyToHost" },
+ { 2, "CopyToHostAck" },
+ { 3, "CopyFromHost" },
+ { 4, "CopyFromHostAck" },
+ { 5, "ClearSlot" },
+ { 6, "CopyOverlay" },
+ { 7, "CopyOverlayAck" },
+ { 8, "CopyFromHostAndClearSlot" },
+ { 15, "Padding" }
+};
+
+const CsrCharString* lookup_bulkcmd_name(CsrUint16 id)
+{
+ if (id < 9)
+ {
+ return Unifi_bulkcmd_names[id].name;
+ }
+ if (id == 15)
+ {
+ return "Padding";
+ }
+
+ return "UNKNOWN";
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_unifi_udi.h
+ *
+ * PURPOSE:
+ * Declarations and definitions for the UniFi Debug Interface.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#ifndef __CSR_WIFI_HIP_UNIFI_UDI_H__
+#define __CSR_WIFI_HIP_UNIFI_UDI_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_signals.h"
+
+
+/*
+ * Support for tracing the wire protocol.
+ */
+enum udi_log_direction
+{
+ UDI_LOG_FROM_HOST = 0x0000,
+ UDI_LOG_TO_HOST = 0x0001
+};
+
+typedef void (*udi_func_t)(void *ospriv, CsrUint8 *sigdata,
+ CsrUint32 signal_len,
+ const bulk_data_param_t *bulkdata,
+ enum udi_log_direction dir);
+
+CsrResult unifi_set_udi_hook(card_t *card, udi_func_t udi_fn);
+CsrResult unifi_remove_udi_hook(card_t *card, udi_func_t udi_fn);
+
+
+/*
+ * Function to print current status info to a string.
+ * This is used in the linux /proc interface and might be useful
+ * in other systems.
+ */
+CsrInt32 unifi_print_status(card_t *card, CsrCharString *str, CsrInt32 *remain);
+
+#define UNIFI_SNPRINTF_RET(buf_p, remain, written) \
+ do { \
+ if (written >= remain) { \
+ if (remain >= 2) { \
+ buf_p[remain - 2] = '\n'; \
+ buf_p[remain - 1] = 0; \
+ } \
+ buf_p += remain; \
+ remain = 0; \
+ } else if (written > 0) { \
+ buf_p += written; \
+ remain -= written; \
+ } \
+ } while (0)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CSR_WIFI_HIP_UNIFI_UDI_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * File: csr_wifi_hip_unifihw.h
+ *
+ * Definitions of various chip registers, addresses, values etc.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#ifndef __UNIFIHW_H__
+#define __UNIFIHW_H__ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Symbol Look Up Table fingerprint. IDs are in sigs.h */
+#define SLUT_FINGERPRINT 0xD397
+
+
+/* Values of LoaderOperation */
+#define UNIFI_LOADER_IDLE 0x00
+#define UNIFI_LOADER_COPY 0x01
+#define UNIFI_LOADER_ERROR_MASK 0xF0
+
+/* Values of BootLoaderOperation */
+#define UNIFI_BOOT_LOADER_IDLE 0x00
+#define UNIFI_BOOT_LOADER_RESTART 0x01
+#define UNIFI_BOOT_LOADER_PATCH 0x02
+#define UNIFI_BOOT_LOADER_LOAD_STA 0x10
+#define UNIFI_BOOT_LOADER_LOAD_PTEST 0x11
+
+
+/* Memory spaces encoded in top byte of Generic Pointer type */
+#define UNIFI_SH_DMEM 0x01 /* Shared Data Memory */
+#define UNIFI_EXT_FLASH 0x02 /* External FLASH */
+#define UNIFI_EXT_SRAM 0x03 /* External SRAM */
+#define UNIFI_REGISTERS 0x04 /* Registers */
+#define UNIFI_PHY_DMEM 0x10 /* PHY Data Memory */
+#define UNIFI_PHY_PMEM 0x11 /* PHY Program Memory */
+#define UNIFI_PHY_ROM 0x12 /* PHY ROM */
+#define UNIFI_MAC_DMEM 0x20 /* MAC Data Memory */
+#define UNIFI_MAC_PMEM 0x21 /* MAC Program Memory */
+#define UNIFI_MAC_ROM 0x22 /* MAC ROM */
+#define UNIFI_BT_DMEM 0x30 /* BT Data Memory */
+#define UNIFI_BT_PMEM 0x31 /* BT Program Memory */
+#define UNIFI_BT_ROM 0x32 /* BT ROM */
+
+#define UNIFI_MAKE_GP(R, O) (((UNIFI_ ## R) << 24) | (O))
+#define UNIFI_GP_OFFSET(GP) ((GP) & 0xFFFFFF)
+#define UNIFI_GP_SPACE(GP) (((GP) >> 24) & 0xFF)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __UNIFIHW_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: unifiversion.h
+ *
+ * PURPOSE:
+ * Version information for the portable UniFi driver.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+#ifndef __UNIFIVERSION_H__
+#define __UNIFIVERSION_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The minimum version of Host Interface Protocol required by the driver.
+ */
+#define UNIFI_HIP_MAJOR_VERSION 9
+#define UNIFI_HIP_MINOR_VERSION 1
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __UNIFIVERSION_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_xbv.c
+ *
+ * PURPOSE:
+ * Routines for downloading firmware to UniFi.
+ *
+ * UniFi firmware files use a nested TLV (Tag-Length-Value) format.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+#ifdef CSR_WIFI_XBV_TEST
+/* Standalone test harness */
+#include "unifi_xbv.h"
+#include "csr_wifi_hip_unifihw.h"
+#else
+/* Normal driver build */
+#include "csr_wifi_hip_unifiversion.h"
+#include "csr_wifi_hip_card.h"
+#define DBG_TAG(t)
+#endif
+
+#include "csr_wifi_hip_xbv.h"
+
+#define STREAM_CHECKSUM 0x6d34 /* Sum of uint16s in each patch stream */
+
+/* XBV sizes used in patch conversion
+ */
+#define PTDL_MAX_SIZE 2048 /* Max bytes allowed per PTDL */
+#define PTDL_HDR_SIZE (4 + 2 + 6 + 2) /* sizeof(fw_id, sec_len, patch_cmd, csum) */
+
+/* Struct to represent a buffer for reading firmware file */
+
+typedef struct
+{
+ void *dlpriv;
+ CsrInt32 ioffset;
+ fwreadfn_t iread;
+} ct_t;
+
+/* Struct to represent a TLV field */
+typedef struct
+{
+ CsrCharString t_name[4];
+ CsrUint32 t_len;
+} tag_t;
+
+
+#define TAG_EQ(i, v) (((i)[0] == (v)[0]) && \
+ ((i)[1] == (v)[1]) && \
+ ((i)[2] == (v)[2]) && \
+ ((i)[3] == (v)[3]))
+
+/* We create a small stack on the stack that contains an enum
+ * indicating the containing list segments, and the offset at which
+ * those lists end. This enables a lot more error checking. */
+typedef enum
+{
+ xbv_xbv1,
+ /*xbv_info,*/
+ xbv_fw,
+ xbv_vers,
+ xbv_vand,
+ xbv_ptch,
+ xbv_other
+} xbv_container;
+
+#define XBV_STACK_SIZE 6
+#define XBV_MAX_OFFS 0x7fffffff
+
+typedef struct
+{
+ struct
+ {
+ xbv_container container;
+ CsrInt32 ioffset_end;
+ } s[XBV_STACK_SIZE];
+ CsrUint32 ptr;
+} xbv_stack_t;
+
+static CsrInt32 read_tag(card_t *card, ct_t *ct, tag_t *tag);
+static CsrInt32 read_bytes(card_t *card, ct_t *ct, void *buf, CsrUint32 len);
+static CsrInt32 read_uint(card_t *card, ct_t *ct, CsrUint32 *u, CsrUint32 len);
+static CsrInt32 xbv_check(xbv1_t *fwinfo, const xbv_stack_t *stack,
+ xbv_mode new_mode, xbv_container old_cont);
+static CsrInt32 xbv_push(xbv1_t *fwinfo, xbv_stack_t *stack,
+ xbv_mode new_mode, xbv_container old_cont,
+ xbv_container new_cont, CsrUint32 ioff);
+
+static CsrUint32 write_uint16(void *buf, const CsrUint32 offset,
+ const CsrUint16 val);
+static CsrUint32 write_uint32(void *buf, const CsrUint32 offset,
+ const CsrUint32 val);
+static CsrUint32 write_bytes(void *buf, const CsrUint32 offset,
+ const CsrUint8 *data, const CsrUint32 len);
+static CsrUint32 write_tag(void *buf, const CsrUint32 offset,
+ const CsrCharString *tag_str);
+static CsrUint32 write_chunk(void *buf, const CsrUint32 offset,
+ const CsrCharString *tag_str,
+ const CsrUint32 payload_len);
+static CsrUint16 calc_checksum(void *buf, const CsrUint32 offset,
+ const CsrUint32 bytes_len);
+static CsrUint32 calc_patch_size(const xbv1_t *fwinfo);
+
+static CsrUint32 write_xbv_header(void *buf, const CsrUint32 offset,
+ const CsrUint32 file_payload_length);
+static CsrUint32 write_ptch_header(void *buf, const CsrUint32 offset,
+ const CsrUint32 fw_id);
+static CsrUint32 write_patchcmd(void *buf, const CsrUint32 offset,
+ const CsrUint32 dst_genaddr, const CsrUint16 len);
+static CsrUint32 write_reset_ptdl(void *buf, const CsrUint32 offset,
+ const xbv1_t *fwinfo, CsrUint32 fw_id);
+static CsrUint32 write_fwdl_to_ptdl(void *buf, const CsrUint32 offset,
+ fwreadfn_t readfn, const struct FWDL *fwdl,
+ const void *fw_buf, const CsrUint32 fw_id,
+ void *rdbuf);
+
+/*
+ * ---------------------------------------------------------------------------
+ * parse_xbv1
+ *
+ * Scan the firmware file to find the TLVs we are interested in.
+ * Actions performed:
+ * - check we support the file format version in VERF
+ * Store these TLVs if we have a firmware image:
+ * - SLTP Symbol Lookup Table Pointer
+ * - FWDL firmware download segments
+ * - FWOL firmware overlay segment
+ * - VMEQ Register probe tests to verify matching h/w
+ * Store these TLVs if we have a patch file:
+ * - FWID the firmware build ID that this file patches
+ * - PTDL The actual patches
+ *
+ * The structure pointed to by fwinfo is cleared and
+ * 'fwinfo->mode' is set to 'unknown'. The 'fwinfo->mode'
+ * variable is set to 'firmware' or 'patch' once we know which
+ * sort of XBV file we have.
+ *
+ * Arguments:
+ * readfn Pointer to function to call to read from the file.
+ * dlpriv Opaque pointer arg to pass to readfn.
+ * fwinfo Pointer to fwinfo struct to fill in.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR error code on failure
+ * ---------------------------------------------------------------------------
+ */
+CsrResult xbv1_parse(card_t *card, fwreadfn_t readfn, void *dlpriv, xbv1_t *fwinfo)
+{
+ ct_t ct;
+ tag_t tag;
+ xbv_stack_t stack;
+
+ ct.dlpriv = dlpriv;
+ ct.ioffset = 0;
+ ct.iread = readfn;
+
+ CsrMemSet(fwinfo, 0, sizeof(xbv1_t));
+ fwinfo->mode = xbv_unknown;
+
+ /* File must start with XBV1 triplet */
+ if (read_tag(card, &ct, &tag) <= 0)
+ {
+ unifi_error(NULL, "File is not UniFi firmware\n");
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ DBG_TAG(tag.t_name);
+
+ if (!TAG_EQ(tag.t_name, "XBV1"))
+ {
+ unifi_error(NULL, "File is not UniFi firmware (%s)\n", tag.t_name);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ stack.ptr = 0;
+ stack.s[stack.ptr].container = xbv_xbv1;
+ stack.s[stack.ptr].ioffset_end = XBV_MAX_OFFS;
+
+ /* Now scan the file */
+ while (1)
+ {
+ CsrInt32 n;
+
+ n = read_tag(card, &ct, &tag);
+ if (n < 0)
+ {
+ unifi_error(NULL, "No tag\n");
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ if (n == 0)
+ {
+ /* End of file */
+ break;
+ }
+
+ DBG_TAG(tag.t_name);
+
+ /* File format version */
+ if (TAG_EQ(tag.t_name, "VERF"))
+ {
+ CsrUint32 version;
+
+ if (xbv_check(fwinfo, &stack, xbv_unknown, xbv_xbv1) ||
+ (tag.t_len != 2) ||
+ read_uint(card, &ct, &version, 2))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ if (version != 0)
+ {
+ unifi_error(NULL, "Unsupported firmware file version: %d.%d\n",
+ version >> 8, version & 0xFF);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ }
+ else if (TAG_EQ(tag.t_name, "LIST"))
+ {
+ CsrCharString name[4];
+ CsrUint32 list_end;
+
+ list_end = ct.ioffset + tag.t_len;
+
+ if (read_bytes(card, &ct, name, 4))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ DBG_TAG(name);
+ if (TAG_EQ(name, "FW "))
+ {
+ if (xbv_push(fwinfo, &stack, xbv_firmware, xbv_xbv1, xbv_fw, list_end))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ }
+ else if (TAG_EQ(name, "VERS"))
+ {
+ if (xbv_push(fwinfo, &stack, xbv_firmware, xbv_fw, xbv_vers, list_end) ||
+ (fwinfo->vers.num_vand != 0))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ }
+ else if (TAG_EQ(name, "VAND"))
+ {
+ struct VAND *vand;
+
+ if (xbv_push(fwinfo, &stack, xbv_firmware, xbv_vers, xbv_vand, list_end) ||
+ (fwinfo->vers.num_vand >= MAX_VAND))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ /* Get a new VAND */
+ vand = fwinfo->vand + fwinfo->vers.num_vand++;
+
+ /* Fill it in */
+ vand->first = fwinfo->num_vmeq;
+ vand->count = 0;
+ }
+ else if (TAG_EQ(name, "PTCH"))
+ {
+ if (xbv_push(fwinfo, &stack, xbv_patch, xbv_xbv1, xbv_ptch, list_end))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ }
+ else
+ {
+ /* Skip over any other lists. We dont bother to push
+ * the new list type now as we would only pop it at
+ * the end of the outer loop. */
+ ct.ioffset += tag.t_len - 4;
+ }
+ }
+ else if (TAG_EQ(tag.t_name, "SLTP"))
+ {
+ CsrUint32 addr;
+
+ if (xbv_check(fwinfo, &stack, xbv_firmware, xbv_fw) ||
+ (tag.t_len != 4) ||
+ (fwinfo->slut_addr != 0) ||
+ read_uint(card, &ct, &addr, 4))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ fwinfo->slut_addr = addr;
+ }
+ else if (TAG_EQ(tag.t_name, "FWDL"))
+ {
+ CsrUint32 addr;
+ struct FWDL *fwdl;
+
+ if (xbv_check(fwinfo, &stack, xbv_firmware, xbv_fw) ||
+ (fwinfo->num_fwdl >= MAX_FWDL) ||
+ (read_uint(card, &ct, &addr, 4)))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ fwdl = fwinfo->fwdl + fwinfo->num_fwdl++;
+
+ fwdl->dl_size = tag.t_len - 4;
+ fwdl->dl_addr = addr;
+ fwdl->dl_offset = ct.ioffset;
+
+ ct.ioffset += tag.t_len - 4;
+ }
+ else if (TAG_EQ(tag.t_name, "FWOV"))
+ {
+ if (xbv_check(fwinfo, &stack, xbv_firmware, xbv_fw) ||
+ (fwinfo->fwov.dl_size != 0) ||
+ (fwinfo->fwov.dl_offset != 0))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ fwinfo->fwov.dl_size = tag.t_len;
+ fwinfo->fwov.dl_offset = ct.ioffset;
+
+ ct.ioffset += tag.t_len;
+ }
+ else if (TAG_EQ(tag.t_name, "VMEQ"))
+ {
+ CsrUint32 temp[3];
+ struct VAND *vand;
+ struct VMEQ *vmeq;
+
+ if (xbv_check(fwinfo, &stack, xbv_firmware, xbv_vand) ||
+ (fwinfo->num_vmeq >= MAX_VMEQ) ||
+ (fwinfo->vers.num_vand == 0) ||
+ (tag.t_len != 8) ||
+ read_uint(card, &ct, &temp[0], 4) ||
+ read_uint(card, &ct, &temp[1], 2) ||
+ read_uint(card, &ct, &temp[2], 2))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ /* Get the last VAND */
+ vand = fwinfo->vand + (fwinfo->vers.num_vand - 1);
+
+ /* Get a new VMEQ */
+ vmeq = fwinfo->vmeq + fwinfo->num_vmeq++;
+
+ /* Note that this VAND contains another VMEQ */
+ vand->count++;
+
+ /* Fill in the VMEQ */
+ vmeq->addr = temp[0];
+ vmeq->mask = (CsrUint16)temp[1];
+ vmeq->value = (CsrUint16)temp[2];
+ }
+ else if (TAG_EQ(tag.t_name, "FWID"))
+ {
+ CsrUint32 build_id;
+
+ if (xbv_check(fwinfo, &stack, xbv_patch, xbv_ptch) ||
+ (tag.t_len != 4) ||
+ (fwinfo->build_id != 0) ||
+ read_uint(card, &ct, &build_id, 4))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ fwinfo->build_id = build_id;
+ }
+ else if (TAG_EQ(tag.t_name, "PTDL"))
+ {
+ struct PTDL *ptdl;
+
+ if (xbv_check(fwinfo, &stack, xbv_patch, xbv_ptch) ||
+ (fwinfo->num_ptdl >= MAX_PTDL))
+ {
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ /* Allocate a new PTDL */
+ ptdl = fwinfo->ptdl + fwinfo->num_ptdl++;
+
+ ptdl->dl_size = tag.t_len;
+ ptdl->dl_offset = ct.ioffset;
+
+ ct.ioffset += tag.t_len;
+ }
+ else
+ {
+ /*
+ * If we get here it is a tag we are not interested in,
+ * just skip over it.
+ */
+ ct.ioffset += tag.t_len;
+ }
+
+ /* Check to see if we are at the end of the currently stacked
+ * segment. We could finish more than one list at a time. */
+ while (ct.ioffset >= stack.s[stack.ptr].ioffset_end)
+ {
+ if (ct.ioffset > stack.s[stack.ptr].ioffset_end)
+ {
+ unifi_error(NULL,
+ "XBV file has overrun stack'd segment %d (%d > %d)\n",
+ stack.ptr, ct.ioffset, stack.s[stack.ptr].ioffset_end);
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ if (stack.ptr <= 0)
+ {
+ unifi_error(NULL, "XBV file has underrun stack pointer\n");
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+ stack.ptr--;
+ }
+ }
+
+ if (stack.ptr != 0)
+ {
+ unifi_error(NULL, "Last list of XBV is not complete.\n");
+ return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* xbv1_parse() */
+
+
+/* Check the the XBV file is of a consistant sort (either firmware or
+ * patch) and that we are in the correct containing list type. */
+static CsrInt32 xbv_check(xbv1_t *fwinfo, const xbv_stack_t *stack,
+ xbv_mode new_mode, xbv_container old_cont)
+{
+ /* If the new file mode is unknown the current packet could be in
+ * either (any) type of XBV file, and we cant make a decission at
+ * this time. */
+ if (new_mode != xbv_unknown)
+ {
+ if (fwinfo->mode == xbv_unknown)
+ {
+ fwinfo->mode = new_mode;
+ }
+ else if (fwinfo->mode != new_mode)
+ {
+ return -1;
+ }
+ }
+ /* If the current stack top doesn't match what we expect then the
+ * file is corrupt. */
+ if (stack->s[stack->ptr].container != old_cont)
+ {
+ return -1;
+ }
+ return 0;
+}
+
+
+/* Make checks as above and then enter a new list */
+static CsrInt32 xbv_push(xbv1_t *fwinfo, xbv_stack_t *stack,
+ xbv_mode new_mode, xbv_container old_cont,
+ xbv_container new_cont, CsrUint32 new_ioff)
+{
+ if (xbv_check(fwinfo, stack, new_mode, old_cont))
+ {
+ return -1;
+ }
+
+ /* Check that our stack won't overflow. */
+ if (stack->ptr >= (XBV_STACK_SIZE - 1))
+ {
+ return -1;
+ }
+
+ /* Add the new list element to the top of the stack. */
+ stack->ptr++;
+ stack->s[stack->ptr].container = new_cont;
+ stack->s[stack->ptr].ioffset_end = new_ioff;
+
+ return 0;
+}
+
+
+static CsrUint32 xbv2uint(CsrUint8 *ptr, CsrInt32 len)
+{
+ CsrUint32 u = 0;
+ CsrInt16 i;
+
+ for (i = 0; i < len; i++)
+ {
+ CsrUint32 b;
+ b = ptr[i];
+ u += b << (i * 8);
+ }
+ return u;
+}
+
+
+static CsrInt32 read_tag(card_t *card, ct_t *ct, tag_t *tag)
+{
+ CsrUint8 buf[8];
+ CsrInt32 n;
+
+ n = (*ct->iread)(card->ospriv, ct->dlpriv, ct->ioffset, buf, 8);
+ if (n <= 0)
+ {
+ return n;
+ }
+
+ /* read the tag and length */
+ if (n != 8)
+ {
+ return -1;
+ }
+
+ /* get section tag */
+ CsrMemCpy(tag->t_name, buf, 4);
+
+ /* get section length */
+ tag->t_len = xbv2uint(buf + 4, 4);
+
+ ct->ioffset += 8;
+
+ return 8;
+} /* read_tag() */
+
+
+static CsrInt32 read_bytes(card_t *card, ct_t *ct, void *buf, CsrUint32 len)
+{
+ /* read the tag value */
+ if ((*ct->iread)(card->ospriv, ct->dlpriv, ct->ioffset, buf, len) != (CsrInt32)len)
+ {
+ return -1;
+ }
+
+ ct->ioffset += len;
+
+ return 0;
+} /* read_bytes() */
+
+
+static CsrInt32 read_uint(card_t *card, ct_t *ct, CsrUint32 *u, CsrUint32 len)
+{
+ CsrUint8 buf[4];
+
+ /* Integer cannot be more than 4 bytes */
+ if (len > 4)
+ {
+ return -1;
+ }
+
+ if (read_bytes(card, ct, buf, len))
+ {
+ return -1;
+ }
+
+ *u = xbv2uint(buf, len);
+
+ return 0;
+} /* read_uint() */
+
+
+static CsrUint32 write_uint16(void *buf, const CsrUint32 offset, const CsrUint16 val)
+{
+ CsrUint8 *dst = (CsrUint8 *)buf + offset;
+ *dst++ = (CsrUint8)(val & 0xff); /* LSB first */
+ *dst = (CsrUint8)(val >> 8);
+ return sizeof(CsrUint16);
+}
+
+
+static CsrUint32 write_uint32(void *buf, const CsrUint32 offset, const CsrUint32 val)
+{
+ (void)write_uint16(buf, offset + 0, (CsrUint16)(val & 0xffff));
+ (void)write_uint16(buf, offset + 2, (CsrUint16)(val >> 16));
+ return sizeof(CsrUint32);
+}
+
+
+static CsrUint32 write_bytes(void *buf, const CsrUint32 offset, const CsrUint8 *data, const CsrUint32 len)
+{
+ CsrUint32 i;
+ CsrUint8 *dst = (CsrUint8 *)buf + offset;
+
+ for (i = 0; i < len; i++)
+ {
+ *dst++ = *((CsrUint8 *)data + i);
+ }
+ return len;
+}
+
+
+static CsrUint32 write_tag(void *buf, const CsrUint32 offset, const CsrCharString *tag_str)
+{
+ CsrUint8 *dst = (CsrUint8 *)buf + offset;
+ CsrMemCpy(dst, tag_str, 4);
+ return 4;
+}
+
+
+static CsrUint32 write_chunk(void *buf, const CsrUint32 offset, const CsrCharString *tag_str, const CsrUint32 payload_len)
+{
+ CsrUint32 written = 0;
+ written += write_tag(buf, offset, tag_str);
+ written += write_uint32(buf, written + offset, (CsrUint32)payload_len);
+
+ return written;
+}
+
+
+static CsrUint16 calc_checksum(void *buf, const CsrUint32 offset, const CsrUint32 bytes_len)
+{
+ CsrUint32 i;
+ CsrUint8 *src = (CsrUint8 *)buf + offset;
+ CsrUint16 sum = 0;
+ CsrUint16 val;
+
+ for (i = 0; i < bytes_len / 2; i++)
+ {
+ /* Contents copied to file is LE, host might not be */
+ val = (CsrUint16) * src++; /* LSB */
+ val += (CsrUint16)(*src++) << 8; /* MSB */
+ sum += val;
+ }
+
+ /* Total of uint16s in the stream plus the stored check value
+ * should equal STREAM_CHECKSUM when decoded.
+ */
+ return (STREAM_CHECKSUM - sum);
+}
+
+
+#define PTDL_RESET_DATA_SIZE 20 /* Size of reset vectors PTDL */
+
+static CsrUint32 calc_patch_size(const xbv1_t *fwinfo)
+{
+ CsrInt16 i;
+ CsrUint32 size = 0;
+
+ /*
+ * Work out how big an equivalent patch format file must be for this image.
+ * This only needs to be approximate, so long as it's large enough.
+ */
+ if (fwinfo->mode != xbv_firmware)
+ {
+ return 0;
+ }
+
+ /* Payload (which will get put into a series of PTDLs) */
+ for (i = 0; i < fwinfo->num_fwdl; i++)
+ {
+ size += fwinfo->fwdl[i].dl_size;
+ }
+
+ /* Another PTDL at the end containing reset vectors */
+ size += PTDL_RESET_DATA_SIZE;
+
+ /* PTDL headers. Add one for remainder, one for reset vectors */
+ size += ((fwinfo->num_fwdl / PTDL_MAX_SIZE) + 2) * PTDL_HDR_SIZE;
+
+ /* Another 1K sufficient to cover miscellaneous headers */
+ size += 1024;
+
+ return size;
+}
+
+
+static CsrUint32 write_xbv_header(void *buf, const CsrUint32 offset, const CsrUint32 file_payload_length)
+{
+ CsrUint32 written = 0;
+
+ /* The length value given to the XBV chunk is the length of all subsequent
+ * contents of the file, excluding the 8 byte size of the XBV1 header itself
+ * (The added 6 bytes thus accounts for the size of the VERF)
+ */
+ written += write_chunk(buf, offset + written, (CsrCharString *)"XBV1", file_payload_length + 6);
+
+ written += write_chunk(buf, offset + written, (CsrCharString *)"VERF", 2);
+ written += write_uint16(buf, offset + written, 0); /* File version */
+
+ return written;
+}
+
+
+static CsrUint32 write_ptch_header(void *buf, const CsrUint32 offset, const CsrUint32 fw_id)
+{
+ CsrUint32 written = 0;
+
+ /* LIST is written with a zero length, to be updated later */
+ written += write_chunk(buf, offset + written, (CsrCharString *)"LIST", 0);
+ written += write_tag(buf, offset + written, (CsrCharString *)"PTCH"); /* List type */
+
+ written += write_chunk(buf, offset + written, (CsrCharString *)"FWID", 4);
+ written += write_uint32(buf, offset + written, fw_id);
+
+
+ return written;
+}
+
+
+#define UF_REGION_PHY 1
+#define UF_REGION_MAC 2
+#define UF_MEMPUT_MAC 0x0000
+#define UF_MEMPUT_PHY 0x1000
+
+static CsrUint32 write_patchcmd(void *buf, const CsrUint32 offset, const CsrUint32 dst_genaddr, const CsrUint16 len)
+{
+ CsrUint32 written = 0;
+ CsrUint32 region = (dst_genaddr >> 28);
+ CsrUint16 cmd_and_len = UF_MEMPUT_MAC;
+
+ if (region == UF_REGION_PHY)
+ {
+ cmd_and_len = UF_MEMPUT_PHY;
+ }
+ else if (region != UF_REGION_MAC)
+ {
+ return 0; /* invalid */
+ }
+
+ /* Write the command and data length */
+ cmd_and_len |= len;
+ written += write_uint16(buf, offset + written, cmd_and_len);
+
+ /* Write the destination generic address */
+ written += write_uint16(buf, offset + written, (CsrUint16)(dst_genaddr >> 16));
+ written += write_uint16(buf, offset + written, (CsrUint16)(dst_genaddr & 0xffff));
+
+ /* The data payload should be appended to the command */
+ return written;
+}
+
+
+static CsrUint32 write_fwdl_to_ptdl(void *buf, const CsrUint32 offset, fwreadfn_t readfn,
+ const struct FWDL *fwdl, const void *dlpriv,
+ const CsrUint32 fw_id, void *fw_buf)
+{
+ CsrUint32 written = 0;
+ CsrInt16 chunks = 0;
+ CsrUint32 left = fwdl->dl_size; /* Bytes left in this fwdl */
+ CsrUint32 dl_addr = fwdl->dl_addr; /* Target address of fwdl image on XAP */
+ CsrUint32 dl_offs = fwdl->dl_offset; /* Offset of fwdl image data in source */
+ CsrUint16 csum;
+ CsrUint32 csum_start_offs; /* first offset to include in checksum */
+ CsrUint32 sec_data_len; /* section data byte count */
+ CsrUint32 sec_len; /* section data + header byte count */
+
+ /* FWDL maps to one or more PTDLs, as max size for a PTDL is 1K words */
+ while (left)
+ {
+ /* Calculate amount to be transferred */
+ sec_data_len = CSRMIN(left, PTDL_MAX_SIZE - PTDL_HDR_SIZE);
+ sec_len = sec_data_len + PTDL_HDR_SIZE;
+
+ /* Write PTDL header + entire PTDL size */
+ written += write_chunk(buf, offset + written, (CsrCharString *)"PTDL", sec_len);
+ /* bug digest implies 4 bytes of padding here, but that seems wrong */
+
+ /* Checksum starts here */
+ csum_start_offs = offset + written;
+
+ /* Patch-chunk header: fw_id. Note that this is in XAP word order */
+ written += write_uint16(buf, offset + written, (CsrUint16)(fw_id >> 16));
+ written += write_uint16(buf, offset + written, (CsrUint16)(fw_id & 0xffff));
+
+ /* Patch-chunk header: section length in uint16s */
+ written += write_uint16(buf, offset + written, (CsrUint16)(sec_len / 2));
+
+
+ /* Write the appropriate patch command for the data's destination ptr */
+ written += write_patchcmd(buf, offset + written, dl_addr, (CsrUint16)(sec_data_len / 2));
+
+ /* Write the data itself (limited to the max chunk length) */
+ if (readfn(NULL, (void *)dlpriv, dl_offs, fw_buf, sec_data_len) < 0)
+ {
+ return 0;
+ }
+
+ written += write_bytes(buf,
+ offset + written,
+ fw_buf,
+ sec_data_len);
+
+ /* CsrUint16 checksum calculated over data written */
+ csum = calc_checksum(buf, csum_start_offs, written - (csum_start_offs - offset));
+ written += write_uint16(buf, offset + written, csum);
+
+ left -= sec_data_len;
+ dl_addr += sec_data_len;
+ dl_offs += sec_data_len;
+ chunks++;
+ }
+
+ return written;
+}
+
+
+#define SEC_CMD_LEN ((4 + 2) * 2) /* sizeof(cmd, vector) per XAP */
+#define PTDL_VEC_HDR_SIZE (4 + 2 + 2) /* sizeof(fw_id, sec_len, csum) */
+#define UF_MAC_START_VEC 0x00c00000 /* Start address of image on MAC */
+#define UF_PHY_START_VEC 0x00c00000 /* Start address of image on PHY */
+#define UF_MAC_START_CMD 0x6000 /* MAC "Set start address" command */
+#define UF_PHY_START_CMD 0x7000 /* PHY "Set start address" command */
+
+static CsrUint32 write_reset_ptdl(void *buf, const CsrUint32 offset, const xbv1_t *fwinfo, CsrUint32 fw_id)
+{
+ CsrUint32 written = 0;
+ CsrUint16 csum;
+ CsrUint32 csum_start_offs; /* first offset to include in checksum */
+ CsrUint32 sec_len; /* section data + header byte count */
+
+ sec_len = SEC_CMD_LEN + PTDL_VEC_HDR_SIZE; /* Total section byte length */
+
+ /* Write PTDL header + entire PTDL size */
+ written += write_chunk(buf, offset + written, (CsrCharString *)"PTDL", sec_len);
+
+ /* Checksum starts here */
+ csum_start_offs = offset + written;
+
+ /* Patch-chunk header: fw_id. Note that this is in XAP word order */
+ written += write_uint16(buf, offset + written, (CsrUint16)(fw_id >> 16));
+ written += write_uint16(buf, offset + written, (CsrUint16)(fw_id & 0xffff));
+
+ /* Patch-chunk header: section length in uint16s */
+ written += write_uint16(buf, offset + written, (CsrUint16)(sec_len / 2));
+
+ /*
+ * Restart addresses to be executed on subsequent loader restart command.
+ */
+
+ /* Setup the MAC start address, note word ordering */
+ written += write_uint16(buf, offset + written, UF_MAC_START_CMD);
+ written += write_uint16(buf, offset + written, (UF_MAC_START_VEC >> 16));
+ written += write_uint16(buf, offset + written, (UF_MAC_START_VEC & 0xffff));
+
+ /* Setup the PHY start address, note word ordering */
+ written += write_uint16(buf, offset + written, UF_PHY_START_CMD);
+ written += write_uint16(buf, offset + written, (UF_PHY_START_VEC >> 16));
+ written += write_uint16(buf, offset + written, (UF_PHY_START_VEC & 0xffff));
+
+ /* CsrUint16 checksum calculated over data written */
+ csum = calc_checksum(buf, csum_start_offs, written - (csum_start_offs - offset));
+ written += write_uint16(buf, offset + written, csum);
+
+ return written;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * read_slut
+ *
+ * desc
+ *
+ * Arguments:
+ * readfn Pointer to function to call to read from the file.
+ * dlpriv Opaque pointer arg to pass to readfn.
+ * addr Offset into firmware image of SLUT.
+ * fwinfo Pointer to fwinfo struct to fill in.
+ *
+ * Returns:
+ * Number of SLUT entries in the f/w, or -1 if the image was corrupt.
+ * ---------------------------------------------------------------------------
+ */
+CsrInt32 xbv1_read_slut(card_t *card, fwreadfn_t readfn, void *dlpriv, xbv1_t *fwinfo,
+ symbol_t *slut, CsrUint32 slut_len)
+{
+ CsrInt16 i;
+ CsrInt32 offset;
+ CsrUint32 magic;
+ CsrUint32 count = 0;
+ ct_t ct;
+
+ if (fwinfo->mode != xbv_firmware)
+ {
+ return -1;
+ }
+
+ /* Find the d/l segment containing the SLUT */
+ /* This relies on the SLUT being entirely contained in one segment */
+ offset = -1;
+ for (i = 0; i < fwinfo->num_fwdl; i++)
+ {
+ if ((fwinfo->slut_addr >= fwinfo->fwdl[i].dl_addr) &&
+ (fwinfo->slut_addr < (fwinfo->fwdl[i].dl_addr + fwinfo->fwdl[i].dl_size)))
+ {
+ offset = fwinfo->fwdl[i].dl_offset +
+ (fwinfo->slut_addr - fwinfo->fwdl[i].dl_addr);
+ }
+ }
+ if (offset < 0)
+ {
+ return -1;
+ }
+
+ ct.dlpriv = dlpriv;
+ ct.ioffset = offset;
+ ct.iread = readfn;
+
+ if (read_uint(card, &ct, &magic, 2))
+ {
+ return -1;
+ }
+ if (magic != SLUT_FINGERPRINT)
+ {
+ return -1;
+ }
+
+ while (count < slut_len)
+ {
+ CsrUint32 id, obj;
+
+ /* Read Symbol Id */
+ if (read_uint(card, &ct, &id, 2))
+ {
+ return -1;
+ }
+
+ /* Check for end of table marker */
+ if (id == CSR_SLT_END)
+ {
+ break;
+ }
+
+ /* Read Symbol Value */
+ if (read_uint(card, &ct, &obj, 4))
+ {
+ return -1;
+ }
+
+ slut[count].id = (CsrUint16)id;
+ slut[count].obj = obj;
+ count++;
+ }
+
+ return count;
+} /* read_slut() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * xbv_to_patch
+ *
+ * Convert (the relevant parts of) a firmware xbv file into a patch xbv
+ *
+ * Arguments:
+ * card
+ * fw_buf - pointer to xbv firmware image
+ * fwinfo - structure describing the firmware image
+ * size - pointer to location into which size of f/w is written.
+ *
+ * Returns:
+ * Pointer to firmware image, or NULL on error. Caller must free this
+ * buffer via CsrMemFree() once it's finished with.
+ *
+ * Notes:
+ * The input fw_buf should have been checked via xbv1_parse prior to
+ * calling this function, so the input image is assumed valid.
+ * ---------------------------------------------------------------------------
+ */
+#define PTCH_LIST_SIZE 16 /* sizeof PTCH+FWID chunk in LIST header */
+
+void* xbv_to_patch(card_t *card, fwreadfn_t readfn,
+ const void *fw_buf, const xbv1_t *fwinfo, CsrUint32 *size)
+{
+ void *patch_buf = NULL;
+ CsrUint32 patch_buf_size;
+ CsrUint32 payload_offs = 0; /* Start of XBV payload */
+ CsrInt16 i;
+ CsrUint32 patch_offs = 0;
+ CsrUint32 list_len_offs = 0; /* Offset of PTDL LIST length parameter */
+ CsrUint32 ptdl_start_offs = 0; /* Offset of first PTDL chunk */
+ CsrUint32 fw_id;
+ void *rdbuf;
+
+ if (!fw_buf || !fwinfo || !card)
+ {
+ return NULL;
+ }
+
+ if (fwinfo->mode != xbv_firmware)
+ {
+ unifi_error(NULL, "Not a firmware file\n");
+ return NULL;
+ }
+
+ /* Pre-allocate read buffer for chunk conversion */
+ rdbuf = CsrMemAlloc(PTDL_MAX_SIZE);
+ if (!rdbuf)
+ {
+ unifi_error(card, "Couldn't alloc conversion buffer\n");
+ return NULL;
+ }
+
+ /* Loader requires patch file's build ID to match the running firmware's */
+ fw_id = card->build_id;
+
+ /* Firmware XBV1 contains VERF, optional INFO, SLUT(s), FWDL(s) */
+ /* Other chunks should get skipped. */
+ /* VERF should be sanity-checked against chip version */
+
+ /* Patch XBV1 contains VERF, optional INFO, PTCH */
+ /* PTCH contains FWID, optional INFO, PTDL(s), PTDL(start_vec) */
+ /* Each FWDL is split into PTDLs (each is 1024 XAP words max) */
+ /* Each PTDL contains running ROM f/w version, and checksum */
+ /* MAC/PHY reset addresses (known) are added into a final PTDL */
+
+ /* The input image has already been parsed, and loaded into fwinfo, so we
+ * can use that to build the output image
+ */
+ patch_buf_size = calc_patch_size(fwinfo);
+
+ patch_buf = (void *)CsrMemAlloc(patch_buf_size);
+ if (!patch_buf)
+ {
+ CsrMemFree(rdbuf);
+ unifi_error(NULL, "Can't malloc buffer for patch conversion\n");
+ return NULL;
+ }
+
+ CsrMemSet(patch_buf, 0xdd, patch_buf_size);
+
+ /* Write XBV + VERF headers */
+ patch_offs += write_xbv_header(patch_buf, patch_offs, 0);
+ payload_offs = patch_offs;
+
+ /* Write patch (LIST) header */
+ list_len_offs = patch_offs + 4; /* Save LIST.length offset for later update */
+ patch_offs += write_ptch_header(patch_buf, patch_offs, fw_id);
+
+ /* Save start offset of the PTDL chunks */
+ ptdl_start_offs = patch_offs;
+
+ /* Write LIST of firmware PTDL blocks */
+ for (i = 0; i < fwinfo->num_fwdl; i++)
+ {
+ patch_offs += write_fwdl_to_ptdl(patch_buf,
+ patch_offs,
+ readfn,
+ &fwinfo->fwdl[i],
+ fw_buf,
+ fw_id,
+ rdbuf);
+ }
+
+ /* Write restart-vector PTDL last */
+ patch_offs += write_reset_ptdl(patch_buf, patch_offs, fwinfo, fw_id);
+
+ /* Now the length is known, update the LIST.length */
+ (void)write_uint32(patch_buf, list_len_offs,
+ (patch_offs - ptdl_start_offs) + PTCH_LIST_SIZE);
+
+ /* Re write XBV headers just to fill in the correct file size */
+ (void)write_xbv_header(patch_buf, 0, (patch_offs - payload_offs));
+
+ unifi_trace(card->ospriv, UDBG1, "XBV:PTCH size %u, fw_id %u\n",
+ patch_offs, fw_id);
+ if (size)
+ {
+ *size = patch_offs;
+ }
+ CsrMemFree(rdbuf);
+
+ return patch_buf;
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: csr_wifi_hip_xbv.h
+ *
+ * PURPOSE:
+ * Definitions and declarations for code to read XBV files - the UniFi
+ * firmware download file format.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#ifndef __XBV_H__
+#define __XBV_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_XBV_TEST
+/* Driver includes */
+#include "csr_wifi_hip_unifi.h"
+#endif
+
+
+struct VMEQ
+{
+ CsrUint32 addr;
+ CsrUint16 mask;
+ CsrUint16 value;
+};
+
+struct VAND
+{
+ CsrUint32 first;
+ CsrUint32 count;
+};
+
+struct VERS
+{
+ CsrUint32 num_vand;
+};
+
+struct FWDL
+{
+ CsrUint32 dl_addr;
+ CsrUint32 dl_size;
+ CsrUint32 dl_offset;
+};
+
+struct FWOV
+{
+ CsrUint32 dl_size;
+ CsrUint32 dl_offset;
+};
+
+struct PTDL
+{
+ CsrUint32 dl_size;
+ CsrUint32 dl_offset;
+};
+
+#define MAX_VMEQ 64
+#define MAX_VAND 64
+#define MAX_FWDL 256
+#define MAX_PTDL 256
+
+/* An XBV1 file can either contain firmware or patches (at the
+ * moment). The 'mode' member of the xbv1_t structure tells us which
+ * one is the case. */
+typedef enum
+{
+ xbv_unknown,
+ xbv_firmware,
+ xbv_patch
+} xbv_mode;
+
+typedef struct
+{
+ xbv_mode mode;
+
+ /* Parts of a Firmware XBV1 */
+
+ struct VMEQ vmeq[MAX_VMEQ];
+ CsrUint32 num_vmeq;
+ struct VAND vand[MAX_VAND];
+ struct VERS vers;
+
+ CsrUint32 slut_addr;
+
+ /* F/W download image, possibly more than one part */
+ struct FWDL fwdl[MAX_FWDL];
+ CsrInt16 num_fwdl;
+
+ /* F/W overlay image, add r not used */
+ struct FWOV fwov;
+
+ /* Parts of a Patch XBV1 */
+
+ CsrUint32 build_id;
+
+ struct PTDL ptdl[MAX_PTDL];
+ CsrInt16 num_ptdl;
+} xbv1_t;
+
+
+typedef CsrInt32 (*fwreadfn_t)(void *ospriv, void *dlpriv, CsrUint32 offset, void *buf, CsrUint32 len);
+
+CsrResult xbv1_parse(card_t *card, fwreadfn_t readfn, void *dlpriv, xbv1_t *fwinfo);
+CsrInt32 xbv1_read_slut(card_t *card, fwreadfn_t readfn, void *dlpriv, xbv1_t *fwinfo,
+ symbol_t *slut, CsrUint32 slut_len);
+void* xbv_to_patch(card_t *card, fwreadfn_t readfn, const void *fw_buf, const xbv1_t *fwinfo,
+ CsrUint32 *size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __XBV_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+
+#ifndef CSR_WIFI_HOSTIO_H
+#define CSR_WIFI_HOSTIO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define CSR_WIFI_HOSTIO_PRIM 0x0453
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_HOSTIO_H */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+#ifndef CSR_WIFI_LIB_H__
+#define CSR_WIFI_LIB_H__
+
+#include "csr_types.h"
+#include "csr_wifi_fsm_event.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiFsmEventInit
+ *
+ * DESCRIPTION
+ * Macro to initialise the members of a CsrWifiFsmEvent.
+ *----------------------------------------------------------------------------*/
+#define CsrWifiFsmEventInit(evt, p_primtype, p_msgtype, p_dst, p_src) \
+ (evt)->primtype = p_primtype; \
+ (evt)->type = p_msgtype; \
+ (evt)->destination = p_dst; \
+ (evt)->source = p_src
+
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiEvent_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrWifiEvent
+ *
+ *----------------------------------------------------------------------------*/
+CsrWifiFsmEvent* CsrWifiEvent_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src);
+
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint8 value;
+} CsrWifiEventCsrUint8;
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiEventCsrUint8_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrWifiEventCsrUint8
+ *
+ *----------------------------------------------------------------------------*/
+CsrWifiEventCsrUint8* CsrWifiEventCsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint8 value);
+
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 value;
+} CsrWifiEventCsrUint16;
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiEventCsrUint16_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrWifiEventCsrUint16
+ *
+ *----------------------------------------------------------------------------*/
+CsrWifiEventCsrUint16* CsrWifiEventCsrUint16_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint16 value);
+
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint32 value;
+} CsrWifiEventCsrUint32;
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiEventCsrUint32_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrWifiEventCsrUint32
+ *
+ *----------------------------------------------------------------------------*/
+CsrWifiEventCsrUint32* CsrWifiEventCsrUint32_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint32 value);
+
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 value16;
+ CsrUint8 value8;
+} CsrWifiEventCsrUint16CsrUint8;
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiEventCsrUint16CsrUint8_struct
+ *
+ * DESCRIPTION
+ * Generic message creator.
+ * Allocates and fills in a message with the signature CsrWifiEventCsrUint16CsrUint8
+ *
+ *----------------------------------------------------------------------------*/
+CsrWifiEventCsrUint16CsrUint8* CsrWifiEventCsrUint16CsrUint8_struct(CsrUint16 primtype, CsrUint16 msgtype, CsrSchedQid dst, CsrSchedQid src, CsrUint16 value16, CsrUint8 value8);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_LIB_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifndef CSR_WIFI_MSGCONV_H__
+#define CSR_WIFI_MSGCONV_H__
+
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+#include "csr_sched.h"
+#include "csr_unicode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+void CsrUint16SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint16 v);
+void CsrUint24SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v);
+void CsrUint32SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v);
+
+void CsrUint16DesBigEndian(CsrUint16 *v, CsrUint8 *buffer, CsrSize *offset);
+void CsrUint24DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset);
+void CsrUint32DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset);
+
+void CsrUint24Ser(CsrUint8 *ptr, CsrSize *len, CsrUint32 v);
+void CsrUint24Des(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset);
+
+
+CsrSize CsrWifiEventSizeof(void *msg);
+CsrUint8* CsrWifiEventSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventDes(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrWifiEventCsrUint8Sizeof(void *msg);
+CsrUint8* CsrWifiEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint8Des(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrWifiEventCsrUint16Sizeof(void *msg);
+CsrUint8* CsrWifiEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint16Des(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrWifiEventCsrUint32Sizeof(void *msg);
+CsrUint8* CsrWifiEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint32Des(CsrUint8 *buffer, CsrSize length);
+
+CsrSize CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg);
+CsrUint8* CsrWifiEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg);
+void* CsrWifiEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_MSGCONV_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_msgconv.h"
+#include "csr_pmem.h"
+#include "csr_util.h"
+
+#ifdef CSR_WIFI_NME_ENABLE
+#ifdef CSR_WIFI_AP_ENABLE
+
+#ifdef CSR_LOG_ENABLE
+#include "csr_log.h"
+#endif
+
+#ifndef EXCLUDE_CSR_WIFI_NME_AP_MODULE
+#include "csr_wifi_nme_ap_serialize.h"
+#include "csr_wifi_nme_ap_prim.h"
+
+static CsrMsgConvMsgEntry csrwifinmeap_conv_lut[] = {
+ { CSR_WIFI_NME_AP_CONFIG_SET_REQ, CsrWifiNmeApConfigSetReqSizeof, CsrWifiNmeApConfigSetReqSer, CsrWifiNmeApConfigSetReqDes, CsrWifiNmeApConfigSetReqSerFree },
+ { CSR_WIFI_NME_AP_WPS_REGISTER_REQ, CsrWifiNmeApWpsRegisterReqSizeof, CsrWifiNmeApWpsRegisterReqSer, CsrWifiNmeApWpsRegisterReqDes, CsrWifiNmeApWpsRegisterReqSerFree },
+ { CSR_WIFI_NME_AP_START_REQ, CsrWifiNmeApStartReqSizeof, CsrWifiNmeApStartReqSer, CsrWifiNmeApStartReqDes, CsrWifiNmeApStartReqSerFree },
+ { CSR_WIFI_NME_AP_STOP_REQ, CsrWifiNmeApStopReqSizeof, CsrWifiNmeApStopReqSer, CsrWifiNmeApStopReqDes, CsrWifiNmeApStopReqSerFree },
+ { CSR_WIFI_NME_AP_WMM_PARAM_UPDATE_REQ, CsrWifiNmeApWmmParamUpdateReqSizeof, CsrWifiNmeApWmmParamUpdateReqSer, CsrWifiNmeApWmmParamUpdateReqDes, CsrWifiNmeApWmmParamUpdateReqSerFree },
+ { CSR_WIFI_NME_AP_STA_REMOVE_REQ, CsrWifiNmeApStaRemoveReqSizeof, CsrWifiNmeApStaRemoveReqSer, CsrWifiNmeApStaRemoveReqDes, CsrWifiNmeApStaRemoveReqSerFree },
+ { CSR_WIFI_NME_AP_CONFIG_SET_CFM, CsrWifiNmeApConfigSetCfmSizeof, CsrWifiNmeApConfigSetCfmSer, CsrWifiNmeApConfigSetCfmDes, CsrWifiNmeApConfigSetCfmSerFree },
+ { CSR_WIFI_NME_AP_WPS_REGISTER_CFM, CsrWifiNmeApWpsRegisterCfmSizeof, CsrWifiNmeApWpsRegisterCfmSer, CsrWifiNmeApWpsRegisterCfmDes, CsrWifiNmeApWpsRegisterCfmSerFree },
+ { CSR_WIFI_NME_AP_START_CFM, CsrWifiNmeApStartCfmSizeof, CsrWifiNmeApStartCfmSer, CsrWifiNmeApStartCfmDes, CsrWifiNmeApStartCfmSerFree },
+ { CSR_WIFI_NME_AP_STOP_CFM, CsrWifiNmeApStopCfmSizeof, CsrWifiNmeApStopCfmSer, CsrWifiNmeApStopCfmDes, CsrWifiNmeApStopCfmSerFree },
+ { CSR_WIFI_NME_AP_STOP_IND, CsrWifiNmeApStopIndSizeof, CsrWifiNmeApStopIndSer, CsrWifiNmeApStopIndDes, CsrWifiNmeApStopIndSerFree },
+ { CSR_WIFI_NME_AP_WMM_PARAM_UPDATE_CFM, CsrWifiNmeApWmmParamUpdateCfmSizeof, CsrWifiNmeApWmmParamUpdateCfmSer, CsrWifiNmeApWmmParamUpdateCfmDes, CsrWifiNmeApWmmParamUpdateCfmSerFree },
+ { CSR_WIFI_NME_AP_STATION_IND, CsrWifiNmeApStationIndSizeof, CsrWifiNmeApStationIndSer, CsrWifiNmeApStationIndDes, CsrWifiNmeApStationIndSerFree },
+
+ { 0, NULL, NULL, NULL, NULL },
+};
+
+CsrMsgConvMsgEntry* CsrWifiNmeApConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+{
+ if (msgType & CSR_PRIM_UPSTREAM)
+ {
+ CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT;
+ if (idx < (CSR_WIFI_NME_AP_PRIM_UPSTREAM_COUNT + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT) &&
+ csrwifinmeap_conv_lut[idx].msgType == msgType)
+ {
+ return &csrwifinmeap_conv_lut[idx];
+ }
+ }
+ else
+ {
+ if (msgType < CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT &&
+ csrwifinmeap_conv_lut[msgType].msgType == msgType)
+ {
+ return &csrwifinmeap_conv_lut[msgType];
+ }
+ }
+ return NULL;
+}
+
+
+void CsrWifiNmeApConverterInit(void)
+{
+ CsrMsgConvInsert(CSR_WIFI_NME_AP_PRIM, csrwifinmeap_conv_lut);
+ CsrMsgConvCustomLookupRegister(CSR_WIFI_NME_AP_PRIM, CsrWifiNmeApConverterLookup);
+}
+
+
+#ifdef CSR_LOG_ENABLE
+static const CsrLogPrimitiveInformation csrwifinmeap_conv_info = {
+ CSR_WIFI_NME_AP_PRIM,
+ (CsrCharString *)"CSR_WIFI_NME_AP_PRIM",
+ csrwifinmeap_conv_lut
+};
+const CsrLogPrimitiveInformation* CsrWifiNmeApTechInfoGet(void)
+{
+ return &csrwifinmeap_conv_info;
+}
+
+
+#endif /* CSR_LOG_ENABLE */
+#endif /* EXCLUDE_CSR_WIFI_NME_AP_MODULE */
+#endif /* CSR_WIFI_NME_ENABLE */
+#endif /* CSR_WIFI_AP_ENABLE */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_NME_AP_CONVERTER_INIT_H__
+#define CSR_WIFI_NME_AP_CONVERTER_INIT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_NME_ENABLE
+#error CSR_WIFI_NME_ENABLE MUST be defined inorder to use csr_wifi_nme_ap_converter_init.h
+#endif
+#ifndef CSR_WIFI_AP_ENABLE
+#error CSR_WIFI_AP_ENABLE MUST be defined inorder to use csr_wifi_nme_ap_converter_init.h
+#endif
+
+#ifndef EXCLUDE_CSR_WIFI_NME_AP_MODULE
+
+#include "csr_msgconv.h"
+
+#ifdef CSR_LOG_ENABLE
+#include "csr_log.h"
+
+extern const CsrLogPrimitiveInformation* CsrWifiNmeApTechInfoGet(void);
+#endif /* CSR_LOG_ENABLE */
+
+extern void CsrWifiNmeApConverterInit(void);
+
+#else /* EXCLUDE_CSR_WIFI_NME_AP_MODULE */
+
+#define CsrWifiNmeApConverterInit()
+
+#endif /* EXCLUDE_CSR_WIFI_NME_AP_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_NME_AP_CONVERTER_INIT_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_wifi_nme_ap_prim.h"
+#include "csr_wifi_nme_ap_lib.h"
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrWifiNmeApFreeDownstreamMessageContents
+ *
+ * DESCRIPTION
+ *
+ *
+ * PARAMETERS
+ * eventClass: only the value CSR_WIFI_NME_AP_PRIM will be handled
+ * message: the message to free
+ *----------------------------------------------------------------------------*/
+void CsrWifiNmeApFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+{
+ if (eventClass != CSR_WIFI_NME_AP_PRIM)
+ {
+ return;
+ }
+ if (NULL == message)
+ {
+ return;
+ }
+
+ switch (*((CsrWifiNmeApPrim *) message))
+ {
+ case CSR_WIFI_NME_AP_CONFIG_SET_REQ:
+ {
+ CsrWifiNmeApConfigSetReq *p = (CsrWifiNmeApConfigSetReq *)message;
+ CsrPmemFree(p->apMacConfig.macAddressList);
+ p->apMacConfig.macAddressList = NULL;
+ break;
+ }
+ case CSR_WIFI_NME_AP_START_REQ:
+ {
+ CsrWifiNmeApStartReq *p = (CsrWifiNmeApStartReq *)message;
+ switch (p->apCredentials.authType)
+ {
+ case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
+ switch (p->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
+ {
+ case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
+ CsrPmemFree(p->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase);
+ p->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase = NULL;
+ break;
+ default:
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+ {
+ CsrUint16 i3;
+ for (i3 = 0; i3 < p->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
+ {
+ CsrPmemFree(p->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel);
+ p->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel = NULL;
+ }
+ }
+ CsrPmemFree(p->p2pGoParam.operatingChanList.channelEntryList);
+ p->p2pGoParam.operatingChanList.channelEntryList = NULL;
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_wifi_nme_ap_prim.h"
+#include "csr_wifi_nme_ap_lib.h"
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrWifiNmeApFreeUpstreamMessageContents
+ *
+ * DESCRIPTION
+ *
+ *
+ * PARAMETERS
+ * eventClass: only the value CSR_WIFI_NME_AP_PRIM will be handled
+ * message: the message to free
+ *----------------------------------------------------------------------------*/
+void CsrWifiNmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+{
+ if (eventClass != CSR_WIFI_NME_AP_PRIM)
+ {
+ return;
+ }
+ if (NULL == message)
+ {
+ return;
+ }
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_NME_AP_LIB_H__
+#define CSR_WIFI_NME_AP_LIB_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_sched.h"
+#include "csr_util.h"
+#include "csr_msg_transport.h"
+
+#include "csr_wifi_lib.h"
+
+#include "csr_wifi_nme_ap_prim.h"
+#include "csr_wifi_nme_task.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_NME_ENABLE
+#error CSR_WIFI_NME_ENABLE MUST be defined inorder to use csr_wifi_nme_ap_lib.h
+#endif
+#ifndef CSR_WIFI_AP_ENABLE
+#error CSR_WIFI_AP_ENABLE MUST be defined inorder to use csr_wifi_nme_ap_lib.h
+#endif
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiNmeApFreeUpstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_NME_AP upstream message. Does not
+ * free the message itself, and can only be used for upstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_NME_AP upstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiNmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiNmeApFreeDownstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_NME_AP downstream message. Does not
+ * free the message itself, and can only be used for downstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_NME_AP downstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiNmeApFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * Enum to string functions
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiNmeApPersCredentialTypeToString(CsrWifiNmeApPersCredentialType value);
+
+
+/*----------------------------------------------------------------------------*
+ * CsrPrim Type toString function.
+ * Converts a message type to the String name of the Message
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiNmeApPrimTypeToString(CsrPrim msgType);
+
+/*----------------------------------------------------------------------------*
+ * Lookup arrays for PrimType name Strings
+ *----------------------------------------------------------------------------*/
+extern const CsrCharString *CsrWifiNmeApUpstreamPrimNames[CSR_WIFI_NME_AP_PRIM_UPSTREAM_COUNT];
+extern const CsrCharString *CsrWifiNmeApDownstreamPrimNames[CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT];
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApConfigSetReqSend
+
+ DESCRIPTION
+ This primitive passes AP configuration info for NME. This can be sent at
+ any time but will be acted upon when the AP is started again. This
+ information is common to both P2P GO and AP
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ apConfig - AP configuration for the NME.
+ apMacConfig - MAC configuration to be acted on when
+ CSR_WIFI_NME_AP_START.request is sent.
+
+*******************************************************************************/
+#define CsrWifiNmeApConfigSetReqCreate(msg__, dst__, src__, apConfig__, apMacConfig__) \
+ msg__ = (CsrWifiNmeApConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_CONFIG_SET_REQ, dst__, src__); \
+ msg__->apConfig = (apConfig__); \
+ msg__->apMacConfig = (apMacConfig__);
+
+#define CsrWifiNmeApConfigSetReqSendTo(dst__, src__, apConfig__, apMacConfig__) \
+ { \
+ CsrWifiNmeApConfigSetReq *msg__; \
+ CsrWifiNmeApConfigSetReqCreate(msg__, dst__, src__, apConfig__, apMacConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApConfigSetReqSend(src__, apConfig__, apMacConfig__) \
+ CsrWifiNmeApConfigSetReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, apConfig__, apMacConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApConfigSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Status of the request.
+
+*******************************************************************************/
+#define CsrWifiNmeApConfigSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiNmeApConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_CONFIG_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeApConfigSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiNmeApConfigSetCfm *msg__; \
+ CsrWifiNmeApConfigSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApConfigSetCfmSend(dst__, status__) \
+ CsrWifiNmeApConfigSetCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStaRemoveReqSend
+
+ DESCRIPTION
+ This primitive disconnects a connected station. If keepBlocking is set to
+ TRUE, the station with the specified MAC address is not allowed to
+ connect. If the requested station is not already connected,it may be
+ blocked based on keepBlocking parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ staMacAddress - Mac Address of the station to be disconnected or blocked
+ keepBlocking - If TRUE, the station is blocked. If FALSE and the station is
+ connected, disconnect the station. If FALSE and the station
+ is not connected, no action is taken.
+
+*******************************************************************************/
+#define CsrWifiNmeApStaRemoveReqCreate(msg__, dst__, src__, interfaceTag__, staMacAddress__, keepBlocking__) \
+ msg__ = (CsrWifiNmeApStaRemoveReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStaRemoveReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_STA_REMOVE_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->staMacAddress = (staMacAddress__); \
+ msg__->keepBlocking = (keepBlocking__);
+
+#define CsrWifiNmeApStaRemoveReqSendTo(dst__, src__, interfaceTag__, staMacAddress__, keepBlocking__) \
+ { \
+ CsrWifiNmeApStaRemoveReq *msg__; \
+ CsrWifiNmeApStaRemoveReqCreate(msg__, dst__, src__, interfaceTag__, staMacAddress__, keepBlocking__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApStaRemoveReqSend(src__, interfaceTag__, staMacAddress__, keepBlocking__) \
+ CsrWifiNmeApStaRemoveReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, interfaceTag__, staMacAddress__, keepBlocking__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStartReqSend
+
+ DESCRIPTION
+ This primitive requests NME to started the AP operation.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface identifier; unique identifier of an interface
+ apType - AP Type specifies the Legacy AP or P2P GO operation
+ cloakSsid - Indicates whether the SSID should be cloaked (hidden and
+ not broadcast in beacon) or not
+ ssid - Service Set Identifier
+ ifIndex - Radio interface
+ channel - Channel number of the channel to use
+ apCredentials - Security credential configuration.
+ maxConnections - Maximum number of stations/P2P clients allowed
+ p2pGoParam - P2P specific GO parameters.
+ wpsEnabled - Indicates whether WPS should be enabled or not
+
+*******************************************************************************/
+#define CsrWifiNmeApStartReqCreate(msg__, dst__, src__, interfaceTag__, apType__, cloakSsid__, ssid__, ifIndex__, channel__, apCredentials__, maxConnections__, p2pGoParam__, wpsEnabled__) \
+ msg__ = (CsrWifiNmeApStartReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_START_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->apType = (apType__); \
+ msg__->cloakSsid = (cloakSsid__); \
+ msg__->ssid = (ssid__); \
+ msg__->ifIndex = (ifIndex__); \
+ msg__->channel = (channel__); \
+ msg__->apCredentials = (apCredentials__); \
+ msg__->maxConnections = (maxConnections__); \
+ msg__->p2pGoParam = (p2pGoParam__); \
+ msg__->wpsEnabled = (wpsEnabled__);
+
+#define CsrWifiNmeApStartReqSendTo(dst__, src__, interfaceTag__, apType__, cloakSsid__, ssid__, ifIndex__, channel__, apCredentials__, maxConnections__, p2pGoParam__, wpsEnabled__) \
+ { \
+ CsrWifiNmeApStartReq *msg__; \
+ CsrWifiNmeApStartReqCreate(msg__, dst__, src__, interfaceTag__, apType__, cloakSsid__, ssid__, ifIndex__, channel__, apCredentials__, maxConnections__, p2pGoParam__, wpsEnabled__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApStartReqSend(src__, interfaceTag__, apType__, cloakSsid__, ssid__, ifIndex__, channel__, apCredentials__, maxConnections__, p2pGoParam__, wpsEnabled__) \
+ CsrWifiNmeApStartReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, interfaceTag__, apType__, cloakSsid__, ssid__, ifIndex__, channel__, apCredentials__, maxConnections__, p2pGoParam__, wpsEnabled__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStartCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of CSR_WIFI_NME_AP_START.request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface identifier; unique identifier of an interface
+ status - Status of the request.
+ ssid - Service Set Identifier
+
+*******************************************************************************/
+#define CsrWifiNmeApStartCfmCreate(msg__, dst__, src__, interfaceTag__, status__, ssid__) \
+ msg__ = (CsrWifiNmeApStartCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_START_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->ssid = (ssid__);
+
+#define CsrWifiNmeApStartCfmSendTo(dst__, src__, interfaceTag__, status__, ssid__) \
+ { \
+ CsrWifiNmeApStartCfm *msg__; \
+ CsrWifiNmeApStartCfmCreate(msg__, dst__, src__, interfaceTag__, status__, ssid__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApStartCfmSend(dst__, interfaceTag__, status__, ssid__) \
+ CsrWifiNmeApStartCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, status__, ssid__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStationIndSend
+
+ DESCRIPTION
+ This primitive indicates that a station has joined or a previously joined
+ station has left the BSS/group
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ mediaStatus - Indicates whether the station is connected or
+ disconnected
+ peerMacAddress - MAC address of the station
+ peerDeviceAddress - P2P Device Address
+
+*******************************************************************************/
+#define CsrWifiNmeApStationIndCreate(msg__, dst__, src__, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__) \
+ msg__ = (CsrWifiNmeApStationInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStationInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_STATION_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->mediaStatus = (mediaStatus__); \
+ msg__->peerMacAddress = (peerMacAddress__); \
+ msg__->peerDeviceAddress = (peerDeviceAddress__);
+
+#define CsrWifiNmeApStationIndSendTo(dst__, src__, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__) \
+ { \
+ CsrWifiNmeApStationInd *msg__; \
+ CsrWifiNmeApStationIndCreate(msg__, dst__, src__, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApStationIndSend(dst__, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__) \
+ CsrWifiNmeApStationIndSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStopReqSend
+
+ DESCRIPTION
+ This primitive requests NME to stop the AP operation.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiNmeApStopReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiNmeApStopReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_STOP_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiNmeApStopReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiNmeApStopReq *msg__; \
+ CsrWifiNmeApStopReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApStopReqSend(src__, interfaceTag__) \
+ CsrWifiNmeApStopReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStopIndSend
+
+ DESCRIPTION
+ Indicates that AP operation had stopped because of some unrecoverable
+ error after AP operation was started successfully. NME sends this signal
+ after failing to restart the AP operation internally following an error
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ apType - Reports AP Type (P2PGO or AP)
+ status - Error Status
+
+*******************************************************************************/
+#define CsrWifiNmeApStopIndCreate(msg__, dst__, src__, interfaceTag__, apType__, status__) \
+ msg__ = (CsrWifiNmeApStopInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_STOP_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->apType = (apType__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeApStopIndSendTo(dst__, src__, interfaceTag__, apType__, status__) \
+ { \
+ CsrWifiNmeApStopInd *msg__; \
+ CsrWifiNmeApStopIndCreate(msg__, dst__, src__, interfaceTag__, apType__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApStopIndSend(dst__, interfaceTag__, apType__, status__) \
+ CsrWifiNmeApStopIndSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, apType__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStopCfmSend
+
+ DESCRIPTION
+ This primitive confirms that the AP operation is stopped. NME shall send
+ this primitive in response to the request even if AP operation has
+ already been stopped
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface identifier; unique identifier of an interface
+ status - Status of the request.
+
+*******************************************************************************/
+#define CsrWifiNmeApStopCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiNmeApStopCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_STOP_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeApStopCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiNmeApStopCfm *msg__; \
+ CsrWifiNmeApStopCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApStopCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiNmeApStopCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApWmmParamUpdateReqSend
+
+ DESCRIPTION
+ Application uses this primitive to update the WMM parameters
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ wmmApParams - WMM Access point parameters per access category. The array
+ index corresponds to the ACI
+ wmmApBcParams - WMM station parameters per access category to be advertised
+ in the beacons and probe response The array index
+ corresponds to the ACI
+
+*******************************************************************************/
+#define CsrWifiNmeApWmmParamUpdateReqCreate(msg__, dst__, src__, wmmApParams__, wmmApBcParams__) \
+ msg__ = (CsrWifiNmeApWmmParamUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWmmParamUpdateReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_WMM_PARAM_UPDATE_REQ, dst__, src__); \
+ CsrMemCpy(msg__->wmmApParams, (wmmApParams__), sizeof(CsrWifiSmeWmmAcParams) * 4); \
+ CsrMemCpy(msg__->wmmApBcParams, (wmmApBcParams__), sizeof(CsrWifiSmeWmmAcParams) * 4);
+
+#define CsrWifiNmeApWmmParamUpdateReqSendTo(dst__, src__, wmmApParams__, wmmApBcParams__) \
+ { \
+ CsrWifiNmeApWmmParamUpdateReq *msg__; \
+ CsrWifiNmeApWmmParamUpdateReqCreate(msg__, dst__, src__, wmmApParams__, wmmApBcParams__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApWmmParamUpdateReqSend(src__, wmmApParams__, wmmApBcParams__) \
+ CsrWifiNmeApWmmParamUpdateReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, wmmApParams__, wmmApBcParams__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApWmmParamUpdateCfmSend
+
+ DESCRIPTION
+ A confirm for for the WMM parameters update
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Status of the request.
+
+*******************************************************************************/
+#define CsrWifiNmeApWmmParamUpdateCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiNmeApWmmParamUpdateCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApWmmParamUpdateCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_WMM_PARAM_UPDATE_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeApWmmParamUpdateCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiNmeApWmmParamUpdateCfm *msg__; \
+ CsrWifiNmeApWmmParamUpdateCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApWmmParamUpdateCfmSend(dst__, status__) \
+ CsrWifiNmeApWmmParamUpdateCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApWpsRegisterReqSend
+
+ DESCRIPTION
+ This primitive allows the NME to accept the WPS registration from an
+ enrollee. Such registration procedure can be cancelled by sending
+ CSR_WIFI_NME_WPS_CANCEL.request.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an
+ interface
+ selectedDevicePasswordId - Selected password type
+ selectedConfigMethod - Selected WPS configuration method type
+ pin - PIN value.
+ Relevant if selected device password ID is PIN.4
+ digit pin is passed by sending the pin digits in
+ pin[0]..pin[3] and rest of the contents filled
+ with '-'.
+
+*******************************************************************************/
+#define CsrWifiNmeApWpsRegisterReqCreate(msg__, dst__, src__, interfaceTag__, selectedDevicePasswordId__, selectedConfigMethod__, pin__) \
+ msg__ = (CsrWifiNmeApWpsRegisterReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_WPS_REGISTER_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->selectedDevicePasswordId = (selectedDevicePasswordId__); \
+ msg__->selectedConfigMethod = (selectedConfigMethod__); \
+ CsrMemCpy(msg__->pin, (pin__), sizeof(CsrUint8) * 8);
+
+#define CsrWifiNmeApWpsRegisterReqSendTo(dst__, src__, interfaceTag__, selectedDevicePasswordId__, selectedConfigMethod__, pin__) \
+ { \
+ CsrWifiNmeApWpsRegisterReq *msg__; \
+ CsrWifiNmeApWpsRegisterReqCreate(msg__, dst__, src__, interfaceTag__, selectedDevicePasswordId__, selectedConfigMethod__, pin__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApWpsRegisterReqSend(src__, interfaceTag__, selectedDevicePasswordId__, selectedConfigMethod__, pin__) \
+ CsrWifiNmeApWpsRegisterReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, interfaceTag__, selectedDevicePasswordId__, selectedConfigMethod__, pin__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApWpsRegisterCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of WPS procedure.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface identifier; unique identifier of an interface
+ status - Status of the request.
+
+*******************************************************************************/
+#define CsrWifiNmeApWpsRegisterCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiNmeApWpsRegisterCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_AP_PRIM, CSR_WIFI_NME_AP_WPS_REGISTER_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeApWpsRegisterCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiNmeApWpsRegisterCfm *msg__; \
+ CsrWifiNmeApWpsRegisterCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeApWpsRegisterCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiNmeApWpsRegisterCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, status__)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_NME_AP_LIB_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_NME_AP_PRIM_H__
+#define CSR_WIFI_NME_AP_PRIM_H__
+
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+#include "csr_sched.h"
+#include "csr_wifi_common.h"
+#include "csr_result.h"
+#include "csr_wifi_fsm_event.h"
+#include "csr_wifi_sme_ap_prim.h"
+#include "csr_wifi_nme_prim.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_NME_ENABLE
+#error CSR_WIFI_NME_ENABLE MUST be defined inorder to use csr_wifi_nme_ap_prim.h
+#endif
+#ifndef CSR_WIFI_AP_ENABLE
+#error CSR_WIFI_AP_ENABLE MUST be defined inorder to use csr_wifi_nme_ap_prim.h
+#endif
+
+#define CSR_WIFI_NME_AP_PRIM (0x0426)
+
+typedef CsrPrim CsrWifiNmeApPrim;
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApPersCredentialType
+
+ DESCRIPTION
+ NME Credential Types
+
+ VALUES
+ CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK
+ - Use PSK as credential.
+ CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE
+ - Use the specified passphrase as credential
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiNmeApPersCredentialType;
+#define CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK ((CsrWifiNmeApPersCredentialType) 0x00)
+#define CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE ((CsrWifiNmeApPersCredentialType) 0x01)
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApConfig
+
+ DESCRIPTION
+ Structure holding AP config data.
+
+ MEMBERS
+ apGroupkeyTimeout - Access point group key timeout.
+ apStrictGtkRekey - Access point strict GTK rekey flag. If set TRUE, the AP
+ shall rekey GTK every time a connected STA leaves BSS.
+ apGmkTimeout - Access point GMK timeout
+ apResponseTimeout - Response timeout
+ apRetransLimit - Max allowed retransmissions
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint16 apGroupkeyTimeout;
+ CsrBool apStrictGtkRekey;
+ CsrUint16 apGmkTimeout;
+ CsrUint16 apResponseTimeout;
+ CsrUint8 apRetransLimit;
+} CsrWifiNmeApConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApAuthPers
+
+ DESCRIPTION
+
+ MEMBERS
+ authSupport - Credential type value (as defined in the
+ enumeration type).
+ rsnCapabilities - RSN capabilities mask
+ wapiCapabilities - WAPI capabilities mask
+ pskOrPassphrase - Credential type value (as defined in the
+ enumeration type).
+ authPers_credentials - Union containing credentials which depends
+ on credentialType parameter.
+ authPers_credentialspsk -
+ authPers_credentialspassphrase -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeApAuthSupportMask authSupport;
+ CsrWifiSmeApRsnCapabilitiesMask rsnCapabilities;
+ CsrWifiSmeApWapiCapabilitiesMask wapiCapabilities;
+ CsrWifiNmeApPersCredentialType pskOrPassphrase;
+ union {
+ CsrWifiNmePsk psk;
+ CsrWifiNmePassphrase passphrase;
+ } authPers_credentials;
+} CsrWifiNmeApAuthPers;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApCredentials
+
+ DESCRIPTION
+ Structure containing the Credentials data.
+
+ MEMBERS
+ authType - Authentication type
+ nmeAuthType - Authentication parameters
+ nmeAuthTypeopenSystemEmpty -
+ nmeAuthTypeauthwep -
+ nmeAuthTypeauthTypePersonal -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeApAuthType authType;
+ union {
+ CsrWifiSmeEmpty openSystemEmpty;
+ CsrWifiSmeWepAuth authwep;
+ CsrWifiNmeApAuthPers authTypePersonal;
+ } nmeAuthType;
+} CsrWifiNmeApCredentials;
+
+
+/* Downstream */
+#define CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_LOWEST (0x0000)
+
+#define CSR_WIFI_NME_AP_CONFIG_SET_REQ ((CsrWifiNmeApPrim) (0x0000 + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_WPS_REGISTER_REQ ((CsrWifiNmeApPrim) (0x0001 + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_START_REQ ((CsrWifiNmeApPrim) (0x0002 + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_STOP_REQ ((CsrWifiNmeApPrim) (0x0003 + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_WMM_PARAM_UPDATE_REQ ((CsrWifiNmeApPrim) (0x0004 + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_STA_REMOVE_REQ ((CsrWifiNmeApPrim) (0x0005 + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_LOWEST))
+
+
+#define CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_HIGHEST (0x0005 + CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_LOWEST)
+
+/* Upstream */
+#define CSR_WIFI_NME_AP_PRIM_UPSTREAM_LOWEST (0x0000 + CSR_PRIM_UPSTREAM)
+
+#define CSR_WIFI_NME_AP_CONFIG_SET_CFM ((CsrWifiNmeApPrim)(0x0000 + CSR_WIFI_NME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_WPS_REGISTER_CFM ((CsrWifiNmeApPrim)(0x0001 + CSR_WIFI_NME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_START_CFM ((CsrWifiNmeApPrim)(0x0002 + CSR_WIFI_NME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_STOP_CFM ((CsrWifiNmeApPrim)(0x0003 + CSR_WIFI_NME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_STOP_IND ((CsrWifiNmeApPrim)(0x0004 + CSR_WIFI_NME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_WMM_PARAM_UPDATE_CFM ((CsrWifiNmeApPrim)(0x0005 + CSR_WIFI_NME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_AP_STATION_IND ((CsrWifiNmeApPrim)(0x0006 + CSR_WIFI_NME_AP_PRIM_UPSTREAM_LOWEST))
+
+#define CSR_WIFI_NME_AP_PRIM_UPSTREAM_HIGHEST (0x0006 + CSR_WIFI_NME_AP_PRIM_UPSTREAM_LOWEST)
+
+#define CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_COUNT (CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_HIGHEST + 1 - CSR_WIFI_NME_AP_PRIM_DOWNSTREAM_LOWEST)
+#define CSR_WIFI_NME_AP_PRIM_UPSTREAM_COUNT (CSR_WIFI_NME_AP_PRIM_UPSTREAM_HIGHEST + 1 - CSR_WIFI_NME_AP_PRIM_UPSTREAM_LOWEST)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApConfigSetReq
+
+ DESCRIPTION
+ This primitive passes AP configuration info for NME. This can be sent at
+ any time but will be acted upon when the AP is started again. This
+ information is common to both P2P GO and AP
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ apConfig - AP configuration for the NME.
+ apMacConfig - MAC configuration to be acted on when
+ CSR_WIFI_NME_AP_START.request is sent.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiNmeApConfig apConfig;
+ CsrWifiSmeApMacConfig apMacConfig;
+} CsrWifiNmeApConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApWpsRegisterReq
+
+ DESCRIPTION
+ This primitive allows the NME to accept the WPS registration from an
+ enrollee. Such registration procedure can be cancelled by sending
+ CSR_WIFI_NME_WPS_CANCEL.request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an
+ interface
+ selectedDevicePasswordId - Selected password type
+ selectedConfigMethod - Selected WPS configuration method type
+ pin - PIN value.
+ Relevant if selected device password ID is PIN.4
+ digit pin is passed by sending the pin digits in
+ pin[0]..pin[3] and rest of the contents filled
+ with '-'.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeWpsDpid selectedDevicePasswordId;
+ CsrWifiSmeWpsConfigType selectedConfigMethod;
+ CsrUint8 pin[8];
+} CsrWifiNmeApWpsRegisterReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStartReq
+
+ DESCRIPTION
+ This primitive requests NME to started the AP operation.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface identifier; unique identifier of an interface
+ apType - AP Type specifies the Legacy AP or P2P GO operation
+ cloakSsid - Indicates whether the SSID should be cloaked (hidden and
+ not broadcast in beacon) or not
+ ssid - Service Set Identifier
+ ifIndex - Radio interface
+ channel - Channel number of the channel to use
+ apCredentials - Security credential configuration.
+ maxConnections - Maximum number of stations/P2P clients allowed
+ p2pGoParam - P2P specific GO parameters.
+ wpsEnabled - Indicates whether WPS should be enabled or not
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeApType apType;
+ CsrBool cloakSsid;
+ CsrWifiSsid ssid;
+ CsrWifiSmeRadioIF ifIndex;
+ CsrUint8 channel;
+ CsrWifiNmeApCredentials apCredentials;
+ CsrUint8 maxConnections;
+ CsrWifiSmeApP2pGoConfig p2pGoParam;
+ CsrBool wpsEnabled;
+} CsrWifiNmeApStartReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStopReq
+
+ DESCRIPTION
+ This primitive requests NME to stop the AP operation.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiNmeApStopReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApWmmParamUpdateReq
+
+ DESCRIPTION
+ Application uses this primitive to update the WMM parameters
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ wmmApParams - WMM Access point parameters per access category. The array
+ index corresponds to the ACI
+ wmmApBcParams - WMM station parameters per access category to be advertised
+ in the beacons and probe response The array index
+ corresponds to the ACI
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeWmmAcParams wmmApParams[4];
+ CsrWifiSmeWmmAcParams wmmApBcParams[4];
+} CsrWifiNmeApWmmParamUpdateReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStaRemoveReq
+
+ DESCRIPTION
+ This primitive disconnects a connected station. If keepBlocking is set to
+ TRUE, the station with the specified MAC address is not allowed to
+ connect. If the requested station is not already connected,it may be
+ blocked based on keepBlocking parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ staMacAddress - Mac Address of the station to be disconnected or blocked
+ keepBlocking - If TRUE, the station is blocked. If FALSE and the station is
+ connected, disconnect the station. If FALSE and the station
+ is not connected, no action is taken.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress staMacAddress;
+ CsrBool keepBlocking;
+} CsrWifiNmeApStaRemoveReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApConfigSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Status of the request.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiNmeApConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApWpsRegisterCfm
+
+ DESCRIPTION
+ This primitive reports the result of WPS procedure.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface identifier; unique identifier of an interface
+ status - Status of the request.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiNmeApWpsRegisterCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStartCfm
+
+ DESCRIPTION
+ This primitive reports the result of CSR_WIFI_NME_AP_START.request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface identifier; unique identifier of an interface
+ status - Status of the request.
+ ssid - Service Set Identifier
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSsid ssid;
+} CsrWifiNmeApStartCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStopCfm
+
+ DESCRIPTION
+ This primitive confirms that the AP operation is stopped. NME shall send
+ this primitive in response to the request even if AP operation has
+ already been stopped
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface identifier; unique identifier of an interface
+ status - Status of the request.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiNmeApStopCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStopInd
+
+ DESCRIPTION
+ Indicates that AP operation had stopped because of some unrecoverable
+ error after AP operation was started successfully. NME sends this signal
+ after failing to restart the AP operation internally following an error
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ apType - Reports AP Type (P2PGO or AP)
+ status - Error Status
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeApType apType;
+ CsrResult status;
+} CsrWifiNmeApStopInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApWmmParamUpdateCfm
+
+ DESCRIPTION
+ A confirm for for the WMM parameters update
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Status of the request.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiNmeApWmmParamUpdateCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeApStationInd
+
+ DESCRIPTION
+ This primitive indicates that a station has joined or a previously joined
+ station has left the BSS/group
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ mediaStatus - Indicates whether the station is connected or
+ disconnected
+ peerMacAddress - MAC address of the station
+ peerDeviceAddress - P2P Device Address
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeMediaStatus mediaStatus;
+ CsrWifiMacAddress peerMacAddress;
+ CsrWifiMacAddress peerDeviceAddress;
+} CsrWifiNmeApStationInd;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_NME_AP_PRIM_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ FILE: csr_wifi_nme_sef.c
+
+ (c) Cambridge Silicon Radio Limited 2010
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+ *****************************************************************************/
+#include "csr_wifi_nme_ap_sef.h"
+#include "unifi_priv.h"
+
+void CsrWifiNmeApUpstreamStateHandlers(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ switch(msg->type) {
+ case CSR_WIFI_NME_AP_START_CFM:
+ CsrWifiNmeApStartCfmHandler(drvpriv, msg);
+ break;
+ case CSR_WIFI_NME_AP_STOP_CFM:
+ CsrWifiNmeApStopCfmHandler(drvpriv, msg);
+ break;
+ case CSR_WIFI_NME_AP_CONFIG_SET_CFM:
+ CsrWifiNmeApConfigSetCfmHandler(drvpriv,msg);
+ break;
+ default:
+ unifi_error(drvpriv, "CsrWifiNmeApUpstreamStateHandlers: unhandled NME_AP message type 0x%.4X\n",msg->type);
+ break;
+ }
+}
--- /dev/null
+/*****************************************************************************
+ FILE: csr_wifi_nme_sef.h
+ (c) Cambridge Silicon Radio Limited 2010
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+#ifndef CSR_WIFI_ROUTER_SEF_CSR_WIFI_NME_H__
+#define CSR_WIFI_ROUTER_SEF_CSR_WIFI_NME_H__
+
+#include "csr_wifi_nme_prim.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void CsrWifiNmeApUpstreamStateHandlers(void* drvpriv, CsrWifiFsmEvent* msg);
+
+
+extern void CsrWifiNmeApConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiNmeApStartCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiNmeApStopCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_SEF_CSR_WIFI_NME_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_msgconv.h"
+#include "csr_unicode.h"
+
+#ifdef CSR_WIFI_NME_ENABLE
+#ifdef CSR_WIFI_AP_ENABLE
+
+#include "csr_wifi_nme_ap_prim.h"
+#include "csr_wifi_nme_ap_serialize.h"
+
+void CsrWifiNmeApPfree(void *ptr)
+{
+ CsrPmemFree(ptr);
+}
+
+
+CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg)
+{
+ CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 104) */
+ bufferSize += 2; /* CsrUint16 primitive->apConfig.apGroupkeyTimeout */
+ bufferSize += 1; /* CsrBool primitive->apConfig.apStrictGtkRekey */
+ bufferSize += 2; /* CsrUint16 primitive->apConfig.apGmkTimeout */
+ bufferSize += 2; /* CsrUint16 primitive->apConfig.apResponseTimeout */
+ bufferSize += 1; /* CsrUint8 primitive->apConfig.apRetransLimit */
+ bufferSize += 1; /* CsrWifiSmeApPhySupportMask primitive->apMacConfig.phySupportedBitmap */
+ bufferSize += 2; /* CsrUint16 primitive->apMacConfig.beaconInterval */
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.dtimPeriod */
+ bufferSize += 2; /* CsrUint16 primitive->apMacConfig.maxListenInterval */
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.supportedRatesCount */
+ bufferSize += 20; /* CsrUint8 primitive->apMacConfig.supportedRates[20] */
+ bufferSize += 1; /* CsrWifiSmePreambleType primitive->apMacConfig.preamble */
+ bufferSize += 1; /* CsrBool primitive->apMacConfig.shortSlotTimeEnabled */
+ bufferSize += 1; /* CsrWifiSmeCtsProtectionType primitive->apMacConfig.ctsProtectionType */
+ bufferSize += 1; /* CsrBool primitive->apMacConfig.wmmEnabled */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApParams[i2].cwMin */
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApParams[i2].cwMax */
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApParams[i2].aifs */
+ bufferSize += 2; /* CsrUint16 primitive->apMacConfig.wmmApParams[i2].txopLimit */
+ bufferSize += 1; /* CsrBool primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory */
+ }
+ }
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApBcParams[i2].cwMin */
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApBcParams[i2].cwMax */
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.wmmApBcParams[i2].aifs */
+ bufferSize += 2; /* CsrUint16 primitive->apMacConfig.wmmApBcParams[i2].txopLimit */
+ bufferSize += 1; /* CsrBool primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory */
+ }
+ }
+ bufferSize += 1; /* CsrWifiSmeApAccessType primitive->apMacConfig.accessType */
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.macAddressListCount */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->apMacConfig.macAddressList[i2].a[6] */
+ }
+ }
+ bufferSize += 1; /* CsrBool primitive->apMacConfig.apHtParams.greenfieldSupported */
+ bufferSize += 1; /* CsrBool primitive->apMacConfig.apHtParams.shortGi20MHz */
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.apHtParams.rxStbc */
+ bufferSize += 1; /* CsrBool primitive->apMacConfig.apHtParams.rifsModeAllowed */
+ bufferSize += 1; /* CsrUint8 primitive->apMacConfig.apHtParams.htProtection */
+ bufferSize += 1; /* CsrBool primitive->apMacConfig.apHtParams.dualCtsProtection */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiNmeApConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apGroupkeyTimeout);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apConfig.apStrictGtkRekey);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apGmkTimeout);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apConfig.apResponseTimeout);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apConfig.apRetransLimit);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.phySupportedBitmap);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.beaconInterval);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.dtimPeriod);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.maxListenInterval);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.supportedRatesCount);
+ CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.supportedRates, ((CsrUint16) (20)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.preamble);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.shortSlotTimeEnabled);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.ctsProtectionType);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmEnabled);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].cwMin);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].cwMax);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].aifs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.wmmApParams[i2].txopLimit);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory);
+ }
+ }
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].cwMin);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].cwMax);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].aifs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apMacConfig.wmmApBcParams[i2].txopLimit);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory);
+ }
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.accessType);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.macAddressListCount);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->apMacConfig.macAddressList[i2].a, ((CsrUint16) (6)));
+ }
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.greenfieldSupported);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.shortGi20MHz);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.rxStbc);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.rifsModeAllowed);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.htProtection);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apMacConfig.apHtParams.dualCtsProtection);
+ return(ptr);
+}
+
+
+void* CsrWifiNmeApConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->apConfig.apGroupkeyTimeout, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apConfig.apStrictGtkRekey, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->apConfig.apGmkTimeout, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->apConfig.apResponseTimeout, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apConfig.apRetransLimit, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.phySupportedBitmap, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.beaconInterval, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.dtimPeriod, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.maxListenInterval, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.supportedRatesCount, buffer, &offset);
+ CsrMemCpyDes(primitive->apMacConfig.supportedRates, buffer, &offset, ((CsrUint16) (20)));
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.preamble, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.shortSlotTimeEnabled, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.ctsProtectionType, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmEnabled, buffer, &offset);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].cwMin, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].cwMax, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].aifs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.wmmApParams[i2].txopLimit, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApParams[i2].admissionControlMandatory, buffer, &offset);
+ }
+ }
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMin, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].cwMax, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].aifs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->apMacConfig.wmmApBcParams[i2].txopLimit, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.wmmApBcParams[i2].admissionControlMandatory, buffer, &offset);
+ }
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.accessType, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.macAddressListCount, buffer, &offset);
+ primitive->apMacConfig.macAddressList = NULL;
+ if (primitive->apMacConfig.macAddressListCount)
+ {
+ primitive->apMacConfig.macAddressList = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->apMacConfig.macAddressListCount);
+ }
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->apMacConfig.macAddressListCount; i2++)
+ {
+ CsrMemCpyDes(primitive->apMacConfig.macAddressList[i2].a, buffer, &offset, ((CsrUint16) (6)));
+ }
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.greenfieldSupported, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.shortGi20MHz, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.rxStbc, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.rifsModeAllowed, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.htProtection, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apMacConfig.apHtParams.dualCtsProtection, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiNmeApConfigSetReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiNmeApConfigSetReq *primitive = (CsrWifiNmeApConfigSetReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->apMacConfig.macAddressList);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiSmeWpsDpid primitive->selectedDevicePasswordId */
+ bufferSize += 2; /* CsrWifiSmeWpsConfigType primitive->selectedConfigMethod */
+ bufferSize += 8; /* CsrUint8 primitive->pin[8] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiNmeApWpsRegisterReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->selectedDevicePasswordId);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->selectedConfigMethod);
+ CsrMemCpySer(ptr, len, (const void *) primitive->pin, ((CsrUint16) (8)));
+ return(ptr);
+}
+
+
+void* CsrWifiNmeApWpsRegisterReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiNmeApWpsRegisterReq *primitive = (CsrWifiNmeApWpsRegisterReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->selectedDevicePasswordId, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->selectedConfigMethod, buffer, &offset);
+ CsrMemCpyDes(primitive->pin, buffer, &offset, ((CsrUint16) (8)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiNmeApStartReqSizeof(void *msg)
+{
+ CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 112) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeApType primitive->apType */
+ bufferSize += 1; /* CsrBool primitive->cloakSsid */
+ bufferSize += 32; /* CsrUint8 primitive->ssid.ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->ssid.length */
+ bufferSize += 1; /* CsrWifiSmeRadioIF primitive->ifIndex */
+ bufferSize += 1; /* CsrUint8 primitive->channel */
+ bufferSize += 1; /* CsrWifiSmeApAuthType primitive->apCredentials.authType */
+ switch (primitive->apCredentials.authType)
+ {
+ case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
+ bufferSize += 1; /* CsrUint8 primitive->apCredentials.nmeAuthType.openSystemEmpty.empty */
+ break;
+ case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
+ bufferSize += 1; /* CsrWifiSmeWepCredentialType primitive->apCredentials.nmeAuthType.authwep.wepKeyType */
+ switch (primitive->apCredentials.nmeAuthType.authwep.wepKeyType)
+ {
+ case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
+ bufferSize += 1; /* CsrWifiSmeWepAuthMode primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType */
+ bufferSize += 1; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey */
+ bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1[13] */
+ bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2[13] */
+ bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3[13] */
+ bufferSize += 13; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4[13] */
+ break;
+ case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
+ bufferSize += 1; /* CsrWifiSmeWepAuthMode primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType */
+ bufferSize += 1; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey */
+ bufferSize += 5; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1[5] */
+ bufferSize += 5; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2[5] */
+ bufferSize += 5; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3[5] */
+ bufferSize += 5; /* CsrUint8 primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4[5] */
+ break;
+ default:
+ break;
+ }
+ break;
+ case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
+ bufferSize += 1; /* CsrWifiSmeApAuthSupportMask primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport */
+ bufferSize += 2; /* CsrWifiSmeApRsnCapabilitiesMask primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities */
+ bufferSize += 2; /* CsrWifiSmeApWapiCapabilitiesMask primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities */
+ bufferSize += 1; /* CsrWifiNmeApPersCredentialType primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase */
+ switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
+ {
+ case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
+ bufferSize += 2; /* CsrUint16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode */
+ bufferSize += 32; /* CsrUint8 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk[32] */
+ break;
+ case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
+ bufferSize += 2; /* CsrUint16 primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode */
+ bufferSize += (primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase?CsrStrLen(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase) : 0) + 1; /* CsrCharString* primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase (0 byte len + 1 for NULL Term) */
+ break;
+ default:
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+ bufferSize += 1; /* CsrUint8 primitive->maxConnections */
+ bufferSize += 1; /* CsrWifiSmeP2pGroupCapabilityMask primitive->p2pGoParam.groupCapability */
+ bufferSize += 3; /* CsrUint8 primitive->p2pGoParam.operatingChanList.country[3] */
+ bufferSize += 1; /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryListCount */
+ {
+ CsrUint16 i3;
+ for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
+ {
+ bufferSize += 1; /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass */
+ bufferSize += 1; /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount */
+ bufferSize += primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount; /* CsrUint8 primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel */
+ }
+ }
+ bufferSize += 1; /* CsrBool primitive->p2pGoParam.opPsEnabled */
+ bufferSize += 1; /* CsrUint8 primitive->p2pGoParam.ctWindow */
+ bufferSize += 1; /* CsrWifiSmeP2pNoaConfigMethod primitive->p2pGoParam.noaConfigMethod */
+ bufferSize += 1; /* CsrBool primitive->p2pGoParam.allowNoaWithNonP2pDevices */
+ bufferSize += 1; /* CsrBool primitive->wpsEnabled */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiNmeApStartReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apType);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakSsid);
+ CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid.length);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ifIndex);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->channel);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.authType);
+ switch (primitive->apCredentials.authType)
+ {
+ case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.openSystemEmpty.empty);
+ break;
+ case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepKeyType);
+ switch (primitive->apCredentials.nmeAuthType.authwep.wepKeyType)
+ {
+ case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey);
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, ((CsrUint16) (13)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, ((CsrUint16) (13)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, ((CsrUint16) (13)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, ((CsrUint16) (13)));
+ break;
+ case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey);
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, ((CsrUint16) (5)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, ((CsrUint16) (5)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, ((CsrUint16) (5)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, ((CsrUint16) (5)));
+ break;
+ default:
+ break;
+ }
+ break;
+ case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase);
+ switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
+ {
+ case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode);
+ CsrMemCpySer(ptr, len, (const void *) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, ((CsrUint16) (32)));
+ break;
+ case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode);
+ CsrCharStringSer(ptr, len, primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase);
+ break;
+ default:
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->maxConnections);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.groupCapability);
+ CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.country, ((CsrUint16) (3)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.operatingChanList.channelEntryListCount);
+ {
+ CsrUint16 i3;
+ for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
+ {
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
+ if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, ((CsrUint16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
+ }
+ }
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.opPsEnabled);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.ctWindow);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.noaConfigMethod);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->p2pGoParam.allowNoaWithNonP2pDevices);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsEnabled);
+ return(ptr);
+}
+
+
+void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apType, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->cloakSsid, buffer, &offset);
+ CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->ssid.length, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ifIndex, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->channel, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apCredentials.authType, buffer, &offset);
+ switch (primitive->apCredentials.authType)
+ {
+ case CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM:
+ CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.openSystemEmpty.empty, buffer, &offset);
+ break;
+ case CSR_WIFI_SME_AP_AUTH_TYPE_WEP:
+ CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepKeyType, buffer, &offset);
+ switch (primitive->apCredentials.nmeAuthType.authwep.wepKeyType)
+ {
+ case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128:
+ CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.wepAuthType, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.selectedWepKey, buffer, &offset);
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key1, buffer, &offset, ((CsrUint16) (13)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key2, buffer, &offset, ((CsrUint16) (13)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key3, buffer, &offset, ((CsrUint16) (13)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep128Key.key4, buffer, &offset, ((CsrUint16) (13)));
+ break;
+ case CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64:
+ CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.wepAuthType, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.selectedWepKey, buffer, &offset);
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key1, buffer, &offset, ((CsrUint16) (5)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key2, buffer, &offset, ((CsrUint16) (5)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key3, buffer, &offset, ((CsrUint16) (5)));
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authwep.wepCredentials.wep64Key.key4, buffer, &offset, ((CsrUint16) (5)));
+ break;
+ default:
+ break;
+ }
+ break;
+ case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
+ CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authSupport, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.rsnCapabilities, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.wapiCapabilities, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase, buffer, &offset);
+ switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
+ {
+ case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK:
+ CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.encryptionMode, buffer, &offset);
+ CsrMemCpyDes(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.psk.psk, buffer, &offset, ((CsrUint16) (32)));
+ break;
+ case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
+ CsrUint16Des((CsrUint16 *) &primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.encryptionMode, buffer, &offset);
+ CsrCharStringDes(&primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase, buffer, &offset);
+ break;
+ default:
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->maxConnections, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.groupCapability, buffer, &offset);
+ CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.country, buffer, &offset, ((CsrUint16) (3)));
+ CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.operatingChanList.channelEntryListCount, buffer, &offset);
+ primitive->p2pGoParam.operatingChanList.channelEntryList = NULL;
+ if (primitive->p2pGoParam.operatingChanList.channelEntryListCount)
+ {
+ primitive->p2pGoParam.operatingChanList.channelEntryList = (CsrWifiSmeApP2pOperatingChanEntry *)CsrPmemAlloc(sizeof(CsrWifiSmeApP2pOperatingChanEntry) * primitive->p2pGoParam.operatingChanList.channelEntryListCount);
+ }
+ {
+ CsrUint16 i3;
+ for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
+ {
+ CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingClass, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount, buffer, &offset);
+ if (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)
+ {
+ primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel = (CsrUint8 *)CsrPmemAlloc(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount);
+ CsrMemCpyDes(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel, buffer, &offset, ((CsrUint16) (primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannelCount)));
+ }
+ else
+ {
+ primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel = NULL;
+ }
+ }
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.opPsEnabled, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.ctWindow, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.noaConfigMethod, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->p2pGoParam.allowNoaWithNonP2pDevices, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->wpsEnabled, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiNmeApStartReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiNmeApStartReq *primitive = (CsrWifiNmeApStartReq *) voidPrimitivePointer;
+ switch (primitive->apCredentials.authType)
+ {
+ case CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL:
+ switch (primitive->apCredentials.nmeAuthType.authTypePersonal.pskOrPassphrase)
+ {
+ case CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PASSPHRASE:
+ CsrPmemFree(primitive->apCredentials.nmeAuthType.authTypePersonal.authPers_credentials.passphrase.passphrase);
+ break;
+ default:
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+ {
+ CsrUint16 i3;
+ for (i3 = 0; i3 < primitive->p2pGoParam.operatingChanList.channelEntryListCount; i3++)
+ {
+ CsrPmemFree(primitive->p2pGoParam.operatingChanList.channelEntryList[i3].operatingChannel);
+ }
+ }
+ CsrPmemFree(primitive->p2pGoParam.operatingChanList.channelEntryList);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 51) */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 4; i1++)
+ {
+ bufferSize += 1; /* CsrUint8 primitive->wmmApParams[i1].cwMin */
+ bufferSize += 1; /* CsrUint8 primitive->wmmApParams[i1].cwMax */
+ bufferSize += 1; /* CsrUint8 primitive->wmmApParams[i1].aifs */
+ bufferSize += 2; /* CsrUint16 primitive->wmmApParams[i1].txopLimit */
+ bufferSize += 1; /* CsrBool primitive->wmmApParams[i1].admissionControlMandatory */
+ }
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 4; i1++)
+ {
+ bufferSize += 1; /* CsrUint8 primitive->wmmApBcParams[i1].cwMin */
+ bufferSize += 1; /* CsrUint8 primitive->wmmApBcParams[i1].cwMax */
+ bufferSize += 1; /* CsrUint8 primitive->wmmApBcParams[i1].aifs */
+ bufferSize += 2; /* CsrUint16 primitive->wmmApBcParams[i1].txopLimit */
+ bufferSize += 1; /* CsrBool primitive->wmmApBcParams[i1].admissionControlMandatory */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiNmeApWmmParamUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 4; i1++)
+ {
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].cwMin);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].cwMax);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].aifs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->wmmApParams[i1].txopLimit);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApParams[i1].admissionControlMandatory);
+ }
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 4; i1++)
+ {
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].cwMin);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].cwMax);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].aifs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->wmmApBcParams[i1].txopLimit);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wmmApBcParams[i1].admissionControlMandatory);
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiNmeApWmmParamUpdateReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiNmeApWmmParamUpdateReq *primitive = (CsrWifiNmeApWmmParamUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApWmmParamUpdateReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 4; i1++)
+ {
+ CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].cwMin, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].cwMax, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].aifs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->wmmApParams[i1].txopLimit, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->wmmApParams[i1].admissionControlMandatory, buffer, &offset);
+ }
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 4; i1++)
+ {
+ CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].cwMin, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].cwMax, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].aifs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->wmmApBcParams[i1].txopLimit, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->wmmApBcParams[i1].admissionControlMandatory, buffer, &offset);
+ }
+ }
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 6; /* CsrUint8 primitive->staMacAddress.a[6] */
+ bufferSize += 1; /* CsrBool primitive->keepBlocking */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiNmeApStaRemoveReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->staMacAddress.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->keepBlocking);
+ return(ptr);
+}
+
+
+void* CsrWifiNmeApStaRemoveReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiNmeApStaRemoveReq *primitive = (CsrWifiNmeApStaRemoveReq *) CsrPmemAlloc(sizeof(CsrWifiNmeApStaRemoveReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->staMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->keepBlocking, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiNmeApWpsRegisterCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiNmeApWpsRegisterCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiNmeApWpsRegisterCfm *primitive = (CsrWifiNmeApWpsRegisterCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApWpsRegisterCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiNmeApStartCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 40) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 32; /* CsrUint8 primitive->ssid.ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->ssid.length */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiNmeApStartCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid.length);
+ return(ptr);
+}
+
+
+void* CsrWifiNmeApStartCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiNmeApStartCfm *primitive = (CsrWifiNmeApStartCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStartCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->ssid.length, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiNmeApStopCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiNmeApStopCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiNmeApStopCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiNmeApStopCfm *primitive = (CsrWifiNmeApStopCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiNmeApStopIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeApType primitive->apType */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiNmeApStopIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->apType);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiNmeApStopIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiNmeApStopInd *primitive = (CsrWifiNmeApStopInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStopInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->apType, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiNmeApStationIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeMediaStatus primitive->mediaStatus */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 6; /* CsrUint8 primitive->peerDeviceAddress.a[6] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiNmeApStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->mediaStatus);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerDeviceAddress.a, ((CsrUint16) (6)));
+ return(ptr);
+}
+
+
+void* CsrWifiNmeApStationIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiNmeApStationInd *primitive = (CsrWifiNmeApStationInd *) CsrPmemAlloc(sizeof(CsrWifiNmeApStationInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->mediaStatus, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->peerDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+
+ return primitive;
+}
+
+
+#endif /* CSR_WIFI_NME_ENABLE */
+#endif /* CSR_WIFI_AP_ENABLE */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_NME_AP_SERIALIZE_H__
+#define CSR_WIFI_NME_AP_SERIALIZE_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_wifi_msgconv.h"
+
+#include "csr_wifi_nme_ap_prim.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_NME_ENABLE
+#error CSR_WIFI_NME_ENABLE MUST be defined inorder to use csr_wifi_nme_ap_serialize.h
+#endif
+#ifndef CSR_WIFI_AP_ENABLE
+#error CSR_WIFI_AP_ENABLE MUST be defined inorder to use csr_wifi_nme_ap_serialize.h
+#endif
+
+extern void CsrWifiNmeApPfree(void *ptr);
+
+extern CsrUint8* CsrWifiNmeApConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeApConfigSetReqSizeof(void *msg);
+extern void CsrWifiNmeApConfigSetReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiNmeApWpsRegisterReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApWpsRegisterReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeApWpsRegisterReqSizeof(void *msg);
+#define CsrWifiNmeApWpsRegisterReqSerFree CsrWifiNmeApPfree
+
+extern CsrUint8* CsrWifiNmeApStartReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStartReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeApStartReqSizeof(void *msg);
+extern void CsrWifiNmeApStartReqSerFree(void *msg);
+
+#define CsrWifiNmeApStopReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiNmeApStopReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiNmeApStopReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiNmeApStopReqSerFree CsrWifiNmeApPfree
+
+extern CsrUint8* CsrWifiNmeApWmmParamUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApWmmParamUpdateReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeApWmmParamUpdateReqSizeof(void *msg);
+#define CsrWifiNmeApWmmParamUpdateReqSerFree CsrWifiNmeApPfree
+
+extern CsrUint8* CsrWifiNmeApStaRemoveReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStaRemoveReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeApStaRemoveReqSizeof(void *msg);
+#define CsrWifiNmeApStaRemoveReqSerFree CsrWifiNmeApPfree
+
+#define CsrWifiNmeApConfigSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiNmeApConfigSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiNmeApConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiNmeApConfigSetCfmSerFree CsrWifiNmeApPfree
+
+extern CsrUint8* CsrWifiNmeApWpsRegisterCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApWpsRegisterCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeApWpsRegisterCfmSizeof(void *msg);
+#define CsrWifiNmeApWpsRegisterCfmSerFree CsrWifiNmeApPfree
+
+extern CsrUint8* CsrWifiNmeApStartCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStartCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeApStartCfmSizeof(void *msg);
+#define CsrWifiNmeApStartCfmSerFree CsrWifiNmeApPfree
+
+extern CsrUint8* CsrWifiNmeApStopCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStopCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeApStopCfmSizeof(void *msg);
+#define CsrWifiNmeApStopCfmSerFree CsrWifiNmeApPfree
+
+extern CsrUint8* CsrWifiNmeApStopIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStopIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeApStopIndSizeof(void *msg);
+#define CsrWifiNmeApStopIndSerFree CsrWifiNmeApPfree
+
+#define CsrWifiNmeApWmmParamUpdateCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiNmeApWmmParamUpdateCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiNmeApWmmParamUpdateCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiNmeApWmmParamUpdateCfmSerFree CsrWifiNmeApPfree
+
+extern CsrUint8* CsrWifiNmeApStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeApStationIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeApStationIndSizeof(void *msg);
+#define CsrWifiNmeApStationIndSerFree CsrWifiNmeApPfree
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* CSR_WIFI_NME_AP_SERIALIZE_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_NME_CONVERTER_INIT_H__
+#define CSR_WIFI_NME_CONVERTER_INIT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_NME_ENABLE
+#error CSR_WIFI_NME_ENABLE MUST be defined inorder to use csr_wifi_nme_converter_init.h
+#endif
+
+#ifndef EXCLUDE_CSR_WIFI_NME_MODULE
+
+#include "csr_msgconv.h"
+
+#ifdef CSR_LOG_ENABLE
+#include "csr_log.h"
+
+extern const CsrLogPrimitiveInformation* CsrWifiNmeTechInfoGet(void);
+#endif /* CSR_LOG_ENABLE */
+
+extern void CsrWifiNmeConverterInit(void);
+
+#else /* EXCLUDE_CSR_WIFI_NME_MODULE */
+
+#define CsrWifiNmeConverterInit()
+
+#endif /* EXCLUDE_CSR_WIFI_NME_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_NME_CONVERTER_INIT_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_NME_LIB_H__
+#define CSR_WIFI_NME_LIB_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_sched.h"
+#include "csr_util.h"
+#include "csr_msg_transport.h"
+
+#include "csr_wifi_lib.h"
+
+#include "csr_wifi_nme_prim.h"
+#include "csr_wifi_nme_task.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_NME_ENABLE
+#error CSR_WIFI_NME_ENABLE MUST be defined inorder to use csr_wifi_nme_lib.h
+#endif
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiNmeFreeUpstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_NME upstream message. Does not
+ * free the message itself, and can only be used for upstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_NME upstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiNmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiNmeFreeDownstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_NME downstream message. Does not
+ * free the message itself, and can only be used for downstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_NME downstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiNmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * Enum to string functions
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiNmeAuthModeToString(CsrWifiNmeAuthMode value);
+const CsrCharString* CsrWifiNmeBssTypeToString(CsrWifiNmeBssType value);
+const CsrCharString* CsrWifiNmeCcxOptionsMaskToString(CsrWifiNmeCcxOptionsMask value);
+const CsrCharString* CsrWifiNmeConfigActionToString(CsrWifiNmeConfigAction value);
+const CsrCharString* CsrWifiNmeConnectionStatusToString(CsrWifiNmeConnectionStatus value);
+const CsrCharString* CsrWifiNmeCredentialTypeToString(CsrWifiNmeCredentialType value);
+const CsrCharString* CsrWifiNmeEapMethodToString(CsrWifiNmeEapMethod value);
+const CsrCharString* CsrWifiNmeEncryptionToString(CsrWifiNmeEncryption value);
+const CsrCharString* CsrWifiNmeIndicationsToString(CsrWifiNmeIndications value);
+const CsrCharString* CsrWifiNmeSecErrorToString(CsrWifiNmeSecError value);
+const CsrCharString* CsrWifiNmeSimCardTypeToString(CsrWifiNmeSimCardType value);
+const CsrCharString* CsrWifiNmeUmtsAuthResultToString(CsrWifiNmeUmtsAuthResult value);
+const CsrCharString* CsrWifiNmeWmmQosInfoToString(CsrWifiNmeWmmQosInfo value);
+
+
+/*----------------------------------------------------------------------------*
+ * CsrPrim Type toString function.
+ * Converts a message type to the String name of the Message
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiNmePrimTypeToString(CsrPrim msgType);
+
+/*----------------------------------------------------------------------------*
+ * Lookup arrays for PrimType name Strings
+ *----------------------------------------------------------------------------*/
+extern const CsrCharString *CsrWifiNmeUpstreamPrimNames[CSR_WIFI_NME_PRIM_UPSTREAM_COUNT];
+extern const CsrCharString *CsrWifiNmeDownstreamPrimNames[CSR_WIFI_NME_PRIM_DOWNSTREAM_COUNT];
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeConnectionStatusGetReqSend
+
+ DESCRIPTION
+ Requests the current connection status of the NME.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiNmeConnectionStatusGetReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiNmeConnectionStatusGetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeConnectionStatusGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_CONNECTION_STATUS_GET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiNmeConnectionStatusGetReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiNmeConnectionStatusGetReq *msg__; \
+ CsrWifiNmeConnectionStatusGetReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeConnectionStatusGetReqSend(src__, interfaceTag__) \
+ CsrWifiNmeConnectionStatusGetReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeConnectionStatusGetCfmSend
+
+ DESCRIPTION
+ Reports the connection status of the NME.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Indicates the success or otherwise of the requested
+ operation.
+ connectionStatus - NME current connection status
+
+*******************************************************************************/
+#define CsrWifiNmeConnectionStatusGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionStatus__) \
+ msg__ = (CsrWifiNmeConnectionStatusGetCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeConnectionStatusGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_CONNECTION_STATUS_GET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->connectionStatus = (connectionStatus__);
+
+#define CsrWifiNmeConnectionStatusGetCfmSendTo(dst__, src__, interfaceTag__, status__, connectionStatus__) \
+ { \
+ CsrWifiNmeConnectionStatusGetCfm *msg__; \
+ CsrWifiNmeConnectionStatusGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionStatus__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeConnectionStatusGetCfmSend(dst__, interfaceTag__, status__, connectionStatus__) \
+ CsrWifiNmeConnectionStatusGetCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, status__, connectionStatus__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeEventMaskSetReqSend
+
+ DESCRIPTION
+ The wireless manager application may register with the NME to receive
+ notification of interesting events. Indications will be sent only if the
+ wireless manager explicitly registers to be notified of that event.
+ indMask is a bit mask of values defined in CsrWifiNmeIndicationsMask.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ indMask - Set mask with values from CsrWifiNmeIndications
+
+*******************************************************************************/
+#define CsrWifiNmeEventMaskSetReqCreate(msg__, dst__, src__, indMask__) \
+ msg__ = (CsrWifiNmeEventMaskSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeEventMaskSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_EVENT_MASK_SET_REQ, dst__, src__); \
+ msg__->indMask = (indMask__);
+
+#define CsrWifiNmeEventMaskSetReqSendTo(dst__, src__, indMask__) \
+ { \
+ CsrWifiNmeEventMaskSetReq *msg__; \
+ CsrWifiNmeEventMaskSetReqCreate(msg__, dst__, src__, indMask__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeEventMaskSetReqSend(src__, indMask__) \
+ CsrWifiNmeEventMaskSetReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, indMask__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeEventMaskSetCfmSend
+
+ DESCRIPTION
+ The NME calls the primitive to report the result of the request
+ primitive.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiNmeEventMaskSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiNmeEventMaskSetCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeEventMaskSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_EVENT_MASK_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeEventMaskSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiNmeEventMaskSetCfm *msg__; \
+ CsrWifiNmeEventMaskSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeEventMaskSetCfmSend(dst__, status__) \
+ CsrWifiNmeEventMaskSetCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileConnectReqSend
+
+ DESCRIPTION
+ Requests the NME to attempt to connect to the specified profile.
+ Overrides any current connection attempt.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ profileIdentity - Identity (BSSID, SSID) of profile to be connected to.
+ It must match an existing profile in the NME.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileConnectReqCreate(msg__, dst__, src__, interfaceTag__, profileIdentity__) \
+ msg__ = (CsrWifiNmeProfileConnectReq *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileConnectReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_CONNECT_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->profileIdentity = (profileIdentity__);
+
+#define CsrWifiNmeProfileConnectReqSendTo(dst__, src__, interfaceTag__, profileIdentity__) \
+ { \
+ CsrWifiNmeProfileConnectReq *msg__; \
+ CsrWifiNmeProfileConnectReqCreate(msg__, dst__, src__, interfaceTag__, profileIdentity__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileConnectReqSend(src__, interfaceTag__, profileIdentity__) \
+ CsrWifiNmeProfileConnectReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, interfaceTag__, profileIdentity__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileConnectCfmSend
+
+ DESCRIPTION
+ Reports the status of the NME PROFILE CONNECT REQ. If unsuccessful the
+ connectAttempt parameters contain details of the APs that the NME
+ attempted to connect to before reporting the failure of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an
+ interface
+ status - Indicates the success or otherwise of the requested
+ operation.
+ connectAttemptsCount - This parameter is relevant only if
+ status!=CSR_WIFI_NME_STATUS_SUCCESS.
+ Number of connection attempt elements provided with
+ this primitive
+ connectAttempts - This parameter is relevant only if
+ status!=CSR_WIFI_NME_STATUS_SUCCESS.
+ Points to the list of connection attempt elements
+ provided with this primitive
+ Each element of the list provides information about
+ an AP on which the connection attempt was made and
+ the error that occurred during the attempt.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileConnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectAttemptsCount__, connectAttempts__) \
+ msg__ = (CsrWifiNmeProfileConnectCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileConnectCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_CONNECT_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->connectAttemptsCount = (connectAttemptsCount__); \
+ msg__->connectAttempts = (connectAttempts__);
+
+#define CsrWifiNmeProfileConnectCfmSendTo(dst__, src__, interfaceTag__, status__, connectAttemptsCount__, connectAttempts__) \
+ { \
+ CsrWifiNmeProfileConnectCfm *msg__; \
+ CsrWifiNmeProfileConnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectAttemptsCount__, connectAttempts__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileConnectCfmSend(dst__, interfaceTag__, status__, connectAttemptsCount__, connectAttempts__) \
+ CsrWifiNmeProfileConnectCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, status__, connectAttemptsCount__, connectAttempts__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileDeleteAllReqSend
+
+ DESCRIPTION
+ Deletes all profiles present in the NME, but does NOT modify the
+ preferred profile list.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiNmeProfileDeleteAllReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiNmeProfileDeleteAllReq *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileDeleteAllReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_DELETE_ALL_REQ, dst__, src__);
+
+#define CsrWifiNmeProfileDeleteAllReqSendTo(dst__, src__) \
+ { \
+ CsrWifiNmeProfileDeleteAllReq *msg__; \
+ CsrWifiNmeProfileDeleteAllReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileDeleteAllReqSend(src__) \
+ CsrWifiNmeProfileDeleteAllReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileDeleteAllCfmSend
+
+ DESCRIPTION
+ Reports the status of the CSR_WIFI_NME_PROFILE_DELETE_ALL_REQ.
+ Returns always CSR_WIFI_NME_STATUS_SUCCESS.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Indicates the success or otherwise of the requested operation, but
+ in this case it always set to success.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileDeleteAllCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiNmeProfileDeleteAllCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileDeleteAllCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_DELETE_ALL_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeProfileDeleteAllCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiNmeProfileDeleteAllCfm *msg__; \
+ CsrWifiNmeProfileDeleteAllCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileDeleteAllCfmSend(dst__, status__) \
+ CsrWifiNmeProfileDeleteAllCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileDeleteReqSend
+
+ DESCRIPTION
+ Will delete the profile with a matching identity, but does NOT modify the
+ preferred profile list.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ profileIdentity - Identity (BSSID, SSID) of profile to be deleted.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileDeleteReqCreate(msg__, dst__, src__, profileIdentity__) \
+ msg__ = (CsrWifiNmeProfileDeleteReq *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileDeleteReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_DELETE_REQ, dst__, src__); \
+ msg__->profileIdentity = (profileIdentity__);
+
+#define CsrWifiNmeProfileDeleteReqSendTo(dst__, src__, profileIdentity__) \
+ { \
+ CsrWifiNmeProfileDeleteReq *msg__; \
+ CsrWifiNmeProfileDeleteReqCreate(msg__, dst__, src__, profileIdentity__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileDeleteReqSend(src__, profileIdentity__) \
+ CsrWifiNmeProfileDeleteReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, profileIdentity__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileDeleteCfmSend
+
+ DESCRIPTION
+ Reports the status of the CSR_WIFI_NME_PROFILE_DELETE_REQ.
+ Returns CSR_WIFI_NME_STATUS_NOT_FOUND if there is no matching profile.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Indicates the success or otherwise of the requested operation.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileDeleteCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiNmeProfileDeleteCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileDeleteCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_DELETE_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeProfileDeleteCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiNmeProfileDeleteCfm *msg__; \
+ CsrWifiNmeProfileDeleteCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileDeleteCfmSend(dst__, status__) \
+ CsrWifiNmeProfileDeleteCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileDisconnectIndSend
+
+ DESCRIPTION
+ Indication generated from the NME (if an application subscribes to
+ receive it) that informs that application that the current profile
+ connection has disconnected. The indication will contain information
+ about APs that it attempted to maintain the connection via i.e. in the
+ case of failed roaming.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an
+ interface
+ connectAttemptsCount - Number of connection attempt elements provided with
+ this primitive
+ connectAttempts - Points to the list of connection attempt elements
+ provided with this primitive
+ Each element of the list provides information about
+ an AP on which the connection attempt was made and
+ the error occurred during the attempt.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileDisconnectIndCreate(msg__, dst__, src__, interfaceTag__, connectAttemptsCount__, connectAttempts__) \
+ msg__ = (CsrWifiNmeProfileDisconnectInd *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileDisconnectInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_DISCONNECT_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->connectAttemptsCount = (connectAttemptsCount__); \
+ msg__->connectAttempts = (connectAttempts__);
+
+#define CsrWifiNmeProfileDisconnectIndSendTo(dst__, src__, interfaceTag__, connectAttemptsCount__, connectAttempts__) \
+ { \
+ CsrWifiNmeProfileDisconnectInd *msg__; \
+ CsrWifiNmeProfileDisconnectIndCreate(msg__, dst__, src__, interfaceTag__, connectAttemptsCount__, connectAttempts__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileDisconnectIndSend(dst__, interfaceTag__, connectAttemptsCount__, connectAttempts__) \
+ CsrWifiNmeProfileDisconnectIndSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, connectAttemptsCount__, connectAttempts__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileOrderSetReqSend
+
+ DESCRIPTION
+ Defines the preferred order that profiles present in the NME should be
+ used during the NME auto-connect behaviour.
+ If profileIdentitysCount == 0, it removes any existing preferred profile
+ list already present in the NME, effectively disabling the auto-connect
+ behaviour.
+ NOTE: Profile identities that do not match any profile stored in the NME
+ are ignored during the auto-connect procedure.
+ NOTE: during auto-connect the NME will only attempt to join an existing
+ adhoc network and it will never attempt to host an adhoc network; for
+ hosting and adhoc network, use CSR_WIFI_NME_PROFILE_CONNECT_REQ
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an
+ interface
+ profileIdentitysCount - The number of profiles identities in the list.
+ profileIdentitys - Points to the list of profile identities.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileOrderSetReqCreate(msg__, dst__, src__, interfaceTag__, profileIdentitysCount__, profileIdentitys__) \
+ msg__ = (CsrWifiNmeProfileOrderSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileOrderSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_ORDER_SET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->profileIdentitysCount = (profileIdentitysCount__); \
+ msg__->profileIdentitys = (profileIdentitys__);
+
+#define CsrWifiNmeProfileOrderSetReqSendTo(dst__, src__, interfaceTag__, profileIdentitysCount__, profileIdentitys__) \
+ { \
+ CsrWifiNmeProfileOrderSetReq *msg__; \
+ CsrWifiNmeProfileOrderSetReqCreate(msg__, dst__, src__, interfaceTag__, profileIdentitysCount__, profileIdentitys__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileOrderSetReqSend(src__, interfaceTag__, profileIdentitysCount__, profileIdentitys__) \
+ CsrWifiNmeProfileOrderSetReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, interfaceTag__, profileIdentitysCount__, profileIdentitys__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileOrderSetCfmSend
+
+ DESCRIPTION
+ Confirmation to UNIFI_NME_PROFILE_ORDER_SET.request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Indicates the success or otherwise of the requested
+ operation.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileOrderSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiNmeProfileOrderSetCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileOrderSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_ORDER_SET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeProfileOrderSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiNmeProfileOrderSetCfm *msg__; \
+ CsrWifiNmeProfileOrderSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileOrderSetCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiNmeProfileOrderSetCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileSetReqSend
+
+ DESCRIPTION
+ Creates or updates an existing profile in the NME that matches the unique
+ identity of the profile. Each profile is identified by the combination of
+ BSSID and SSID. The profile contains all the required credentials for
+ attempting to connect to the network. Creating or updating a profile via
+ the NME PROFILE SET REQ does NOT add the profile to the preferred profile
+ list within the NME used for the NME auto-connect behaviour.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ profile - Specifies the identity and credentials of the network.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileSetReqCreate(msg__, dst__, src__, profile__) \
+ msg__ = (CsrWifiNmeProfileSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_SET_REQ, dst__, src__); \
+ msg__->profile = (profile__);
+
+#define CsrWifiNmeProfileSetReqSendTo(dst__, src__, profile__) \
+ { \
+ CsrWifiNmeProfileSetReq *msg__; \
+ CsrWifiNmeProfileSetReqCreate(msg__, dst__, src__, profile__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileSetReqSend(src__, profile__) \
+ CsrWifiNmeProfileSetReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, profile__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileSetCfmSend
+
+ DESCRIPTION
+ Reports the status of the NME PROFILE SET REQ; the request will only fail
+ if the details specified in the profile contains an invalid combination
+ of parameters for example specifying the profile as cloaked but not
+ specifying the SSID. The NME doesn't limit the number of profiles that
+ may be created. The NME assumes that the entity configuring it is aware
+ of the appropriate limits.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Indicates the success or otherwise of the requested operation.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiNmeProfileSetCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeProfileSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiNmeProfileSetCfm *msg__; \
+ CsrWifiNmeProfileSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileSetCfmSend(dst__, status__) \
+ CsrWifiNmeProfileSetCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileUpdateIndSend
+
+ DESCRIPTION
+ Indication generated from the NME (if an application subscribes to
+ receive it) that informs that application that the contained profile has
+ changed.
+ For example, either the credentials EAP-FAST PAC file or the session data
+ within the profile has changed.
+ It is up to the application whether it stores this updated profile or
+ not.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ profile - The identity and credentials of the network.
+
+*******************************************************************************/
+#define CsrWifiNmeProfileUpdateIndCreate(msg__, dst__, src__, interfaceTag__, profile__) \
+ msg__ = (CsrWifiNmeProfileUpdateInd *) CsrPmemAlloc(sizeof(CsrWifiNmeProfileUpdateInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_PROFILE_UPDATE_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->profile = (profile__);
+
+#define CsrWifiNmeProfileUpdateIndSendTo(dst__, src__, interfaceTag__, profile__) \
+ { \
+ CsrWifiNmeProfileUpdateInd *msg__; \
+ CsrWifiNmeProfileUpdateIndCreate(msg__, dst__, src__, interfaceTag__, profile__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeProfileUpdateIndSend(dst__, interfaceTag__, profile__) \
+ CsrWifiNmeProfileUpdateIndSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, profile__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimGsmAuthIndSend
+
+ DESCRIPTION
+ Indication generated from the NME (if an application subscribes to
+ receive it) that requests the UICC Manager to perform a GSM
+ authentication on behalf of the NME. This indication is generated when
+ the NME is attempting to connect to a profile configured for EAP-SIM. An
+ application MUST register to receive this indication for the NME to
+ support the EAP-SIM credential types. Otherwise the NME has no route to
+ obtain the information from the UICC. EAP-SIM authentication requires 2
+ or 3 GSM authentication rounds and therefore 2 or 3 RANDS (GSM Random
+ Challenges) are included.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ randsLength - GSM RAND is 16 bytes long hence valid values are 32 (2 RANDS)
+ or 48 (3 RANDs).
+ rands - 2 or 3 RANDs values.
+
+*******************************************************************************/
+#define CsrWifiNmeSimGsmAuthIndCreate(msg__, dst__, src__, randsLength__, rands__) \
+ msg__ = (CsrWifiNmeSimGsmAuthInd *) CsrPmemAlloc(sizeof(CsrWifiNmeSimGsmAuthInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_SIM_GSM_AUTH_IND, dst__, src__); \
+ msg__->randsLength = (randsLength__); \
+ msg__->rands = (rands__);
+
+#define CsrWifiNmeSimGsmAuthIndSendTo(dst__, src__, randsLength__, rands__) \
+ { \
+ CsrWifiNmeSimGsmAuthInd *msg__; \
+ CsrWifiNmeSimGsmAuthIndCreate(msg__, dst__, src__, randsLength__, rands__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeSimGsmAuthIndSend(dst__, randsLength__, rands__) \
+ CsrWifiNmeSimGsmAuthIndSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, randsLength__, rands__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimGsmAuthResSend
+
+ DESCRIPTION
+ Response from the application that received the NME SIM GSM AUTH IND. For
+ each GSM authentication round a GSM Ciphering key (Kc) and a signed
+ response (SRES) are produced. Since 2 or 3 GSM authentication rounds are
+ used the 2 or 3 Kc's obtained respectively are combined into one buffer
+ and similarly the 2 or 3 SRES's obtained are combined into another
+ buffer. The order of Kc values (SRES values respectively) in their buffer
+ is the same as that of their corresponding RAND values in the incoming
+ indication.
+
+ PARAMETERS
+ status - Indicates the outcome of the requested operation:
+ STATUS_SUCCESS or STATUS_ERROR
+ kcsLength - Length in Bytes of Kc buffer. Legal values are: 16 or 24.
+ kcs - Kc buffer holding 2 or 3 Kc values.
+ sresLength - Length in Bytes of SRES buffer. Legal values are: 8 or 12.
+ sres - SRES buffer holding 2 or 3 SRES values.
+
+*******************************************************************************/
+#define CsrWifiNmeSimGsmAuthResCreate(msg__, dst__, src__, status__, kcsLength__, kcs__, sresLength__, sres__) \
+ msg__ = (CsrWifiNmeSimGsmAuthRes *) CsrPmemAlloc(sizeof(CsrWifiNmeSimGsmAuthRes)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_SIM_GSM_AUTH_RES, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->kcsLength = (kcsLength__); \
+ msg__->kcs = (kcs__); \
+ msg__->sresLength = (sresLength__); \
+ msg__->sres = (sres__);
+
+#define CsrWifiNmeSimGsmAuthResSendTo(dst__, src__, status__, kcsLength__, kcs__, sresLength__, sres__) \
+ { \
+ CsrWifiNmeSimGsmAuthRes *msg__; \
+ CsrWifiNmeSimGsmAuthResCreate(msg__, dst__, src__, status__, kcsLength__, kcs__, sresLength__, sres__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeSimGsmAuthResSend(src__, status__, kcsLength__, kcs__, sresLength__, sres__) \
+ CsrWifiNmeSimGsmAuthResSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, status__, kcsLength__, kcs__, sresLength__, sres__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimImsiGetIndSend
+
+ DESCRIPTION
+ Indication generated from the NME (if an application subscribes to
+ receive it) that requests the IMSI and UICC type from the UICC Manager.
+ This indication is generated when the NME is attempting to connect to a
+ profile configured for EAP-SIM/AKA. An application MUST register to
+ receive this indication for the NME to support the EAP-SIM/AKA credential
+ types. Otherwise the NME has no route to obtain the information from the
+ UICC.
+
+ PARAMETERS
+ queue - Destination Task Queue
+
+*******************************************************************************/
+#define CsrWifiNmeSimImsiGetIndCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiNmeSimImsiGetInd *) CsrPmemAlloc(sizeof(CsrWifiNmeSimImsiGetInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_SIM_IMSI_GET_IND, dst__, src__);
+
+#define CsrWifiNmeSimImsiGetIndSendTo(dst__, src__) \
+ { \
+ CsrWifiNmeSimImsiGetInd *msg__; \
+ CsrWifiNmeSimImsiGetIndCreate(msg__, dst__, src__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeSimImsiGetIndSend(dst__) \
+ CsrWifiNmeSimImsiGetIndSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimImsiGetResSend
+
+ DESCRIPTION
+ Response from the application that received the NME SIM IMSI GET IND.
+
+ PARAMETERS
+ status - Indicates the outcome of the requested operation: STATUS_SUCCESS
+ or STATUS_ERROR.
+ imsi - The value of the IMSI obtained from the UICC.
+ cardType - The UICC type (GSM only (SIM), UMTS only (USIM), Both).
+
+*******************************************************************************/
+#define CsrWifiNmeSimImsiGetResCreate(msg__, dst__, src__, status__, imsi__, cardType__) \
+ msg__ = (CsrWifiNmeSimImsiGetRes *) CsrPmemAlloc(sizeof(CsrWifiNmeSimImsiGetRes)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_SIM_IMSI_GET_RES, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->imsi = (imsi__); \
+ msg__->cardType = (cardType__);
+
+#define CsrWifiNmeSimImsiGetResSendTo(dst__, src__, status__, imsi__, cardType__) \
+ { \
+ CsrWifiNmeSimImsiGetRes *msg__; \
+ CsrWifiNmeSimImsiGetResCreate(msg__, dst__, src__, status__, imsi__, cardType__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeSimImsiGetResSend(src__, status__, imsi__, cardType__) \
+ CsrWifiNmeSimImsiGetResSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, status__, imsi__, cardType__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimUmtsAuthIndSend
+
+ DESCRIPTION
+ Indication generated from the NME (if an application subscribes to
+ receive it) that requests the UICC Manager to perform a UMTS
+ authentication on behalf of the NME. This indication is generated when
+ the NME is attempting to connect to a profile configured for EAP-AKA. An
+ application MUST register to receive this indication for the NME to
+ support the EAP-AKA credential types. Otherwise the NME has no route to
+ obtain the information from the USIM. EAP-AKA requires one UMTS
+ authentication round and therefore only one RAND and one AUTN values are
+ included.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ rand - UMTS RAND value.
+ autn - UMTS AUTN value.
+
+*******************************************************************************/
+#define CsrWifiNmeSimUmtsAuthIndCreate(msg__, dst__, src__, rand__, autn__) \
+ msg__ = (CsrWifiNmeSimUmtsAuthInd *) CsrPmemAlloc(sizeof(CsrWifiNmeSimUmtsAuthInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_SIM_UMTS_AUTH_IND, dst__, src__); \
+ CsrMemCpy(msg__->rand, (rand__), sizeof(CsrUint8) * 16); \
+ CsrMemCpy(msg__->autn, (autn__), sizeof(CsrUint8) * 16);
+
+#define CsrWifiNmeSimUmtsAuthIndSendTo(dst__, src__, rand__, autn__) \
+ { \
+ CsrWifiNmeSimUmtsAuthInd *msg__; \
+ CsrWifiNmeSimUmtsAuthIndCreate(msg__, dst__, src__, rand__, autn__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeSimUmtsAuthIndSend(dst__, rand__, autn__) \
+ CsrWifiNmeSimUmtsAuthIndSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, rand__, autn__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimUmtsAuthResSend
+
+ DESCRIPTION
+ Response from the application that received the NME SIM UMTS AUTH IND.
+ The values of umtsCipherKey, umtsIntegrityKey, resParameterLength and
+ resParameter are only meanigful when result = UMTS_AUTH_RESULT_SUCCESS.
+ The value of auts is only meaningful when
+ result=UMTS_AUTH_RESULT_SYNC_FAIL.
+
+ PARAMETERS
+ status - Indicates the outcome of the requested operation:
+ STATUS_SUCCESS or STATUS_ERROR.
+ result - The result of UMTS authentication as performed by the
+ UICC which could be: Success, Authentication Reject or
+ Synchronisation Failure. For all these 3 outcomes the
+ value of status is success.
+ umtsCipherKey - The UMTS Cipher Key as calculated and returned by the
+ UICC.
+ umtsIntegrityKey - The UMTS Integrity Key as calculated and returned by
+ the UICC.
+ resParameterLength - The length (in bytes) of the RES parameter (min=4; max
+ = 16).
+ resParameter - The RES parameter as calculated and returned by the
+ UICC.
+ auts - The AUTS parameter as calculated and returned by the
+ UICC.
+
+*******************************************************************************/
+#define CsrWifiNmeSimUmtsAuthResCreate(msg__, dst__, src__, status__, result__, umtsCipherKey__, umtsIntegrityKey__, resParameterLength__, resParameter__, auts__) \
+ msg__ = (CsrWifiNmeSimUmtsAuthRes *) CsrPmemAlloc(sizeof(CsrWifiNmeSimUmtsAuthRes)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_SIM_UMTS_AUTH_RES, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->result = (result__); \
+ CsrMemCpy(msg__->umtsCipherKey, (umtsCipherKey__), sizeof(CsrUint8) * 16); \
+ CsrMemCpy(msg__->umtsIntegrityKey, (umtsIntegrityKey__), sizeof(CsrUint8) * 16); \
+ msg__->resParameterLength = (resParameterLength__); \
+ msg__->resParameter = (resParameter__); \
+ CsrMemCpy(msg__->auts, (auts__), sizeof(CsrUint8) * 14);
+
+#define CsrWifiNmeSimUmtsAuthResSendTo(dst__, src__, status__, result__, umtsCipherKey__, umtsIntegrityKey__, resParameterLength__, resParameter__, auts__) \
+ { \
+ CsrWifiNmeSimUmtsAuthRes *msg__; \
+ CsrWifiNmeSimUmtsAuthResCreate(msg__, dst__, src__, status__, result__, umtsCipherKey__, umtsIntegrityKey__, resParameterLength__, resParameter__, auts__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeSimUmtsAuthResSend(src__, status__, result__, umtsCipherKey__, umtsIntegrityKey__, resParameterLength__, resParameter__, auts__) \
+ CsrWifiNmeSimUmtsAuthResSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, status__, result__, umtsCipherKey__, umtsIntegrityKey__, resParameterLength__, resParameter__, auts__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsCancelReqSend
+
+ DESCRIPTION
+ Requests the NME to cancel any WPS procedure that it is currently
+ performing. This includes WPS registrar activities started because of
+ CSR_WIFI_NME_AP_REGISTER.request
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiNmeWpsCancelReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiNmeWpsCancelReq *) CsrPmemAlloc(sizeof(CsrWifiNmeWpsCancelReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_WPS_CANCEL_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiNmeWpsCancelReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiNmeWpsCancelReq *msg__; \
+ CsrWifiNmeWpsCancelReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeWpsCancelReqSend(src__, interfaceTag__) \
+ CsrWifiNmeWpsCancelReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsCancelCfmSend
+
+ DESCRIPTION
+ Reports the status of the NME WPS REQ, the request is always SUCCESSFUL.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Only returns CSR_WIFI_NME_STATUS_SUCCESS
+
+*******************************************************************************/
+#define CsrWifiNmeWpsCancelCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiNmeWpsCancelCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeWpsCancelCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_WPS_CANCEL_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeWpsCancelCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiNmeWpsCancelCfm *msg__; \
+ CsrWifiNmeWpsCancelCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeWpsCancelCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiNmeWpsCancelCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsCfmSend
+
+ DESCRIPTION
+ Reports the status of the NME WPS REQ.
+ If CSR_WIFI_NME_STATUS_SUCCESS, the profile parameter contains the
+ identity and credentials of the AP.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Indicates the success or otherwise of the requested
+ operation.
+ profile - This parameter is relevant only if
+ status==CSR_WIFI_NME_STATUS_SUCCESS.
+ The identity and credentials of the network.
+
+*******************************************************************************/
+#define CsrWifiNmeWpsCfmCreate(msg__, dst__, src__, interfaceTag__, status__, profile__) \
+ msg__ = (CsrWifiNmeWpsCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeWpsCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_WPS_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->profile = (profile__);
+
+#define CsrWifiNmeWpsCfmSendTo(dst__, src__, interfaceTag__, status__, profile__) \
+ { \
+ CsrWifiNmeWpsCfm *msg__; \
+ CsrWifiNmeWpsCfmCreate(msg__, dst__, src__, interfaceTag__, status__, profile__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeWpsCfmSend(dst__, interfaceTag__, status__, profile__) \
+ CsrWifiNmeWpsCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, interfaceTag__, status__, profile__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsConfigSetReqSend
+
+ DESCRIPTION
+ This primitive passes the WPS information for the device to NME. This may
+ be accepted only if no interface is active.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ wpsConfig - WPS config.
+
+*******************************************************************************/
+#define CsrWifiNmeWpsConfigSetReqCreate(msg__, dst__, src__, wpsConfig__) \
+ msg__ = (CsrWifiNmeWpsConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiNmeWpsConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_WPS_CONFIG_SET_REQ, dst__, src__); \
+ msg__->wpsConfig = (wpsConfig__);
+
+#define CsrWifiNmeWpsConfigSetReqSendTo(dst__, src__, wpsConfig__) \
+ { \
+ CsrWifiNmeWpsConfigSetReq *msg__; \
+ CsrWifiNmeWpsConfigSetReqCreate(msg__, dst__, src__, wpsConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeWpsConfigSetReqSend(src__, wpsConfig__) \
+ CsrWifiNmeWpsConfigSetReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, wpsConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsConfigSetCfmSend
+
+ DESCRIPTION
+ Confirm.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Status of the request.
+
+*******************************************************************************/
+#define CsrWifiNmeWpsConfigSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiNmeWpsConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiNmeWpsConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_WPS_CONFIG_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiNmeWpsConfigSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiNmeWpsConfigSetCfm *msg__; \
+ CsrWifiNmeWpsConfigSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeWpsConfigSetCfmSend(dst__, status__) \
+ CsrWifiNmeWpsConfigSetCfmSendTo(dst__, CSR_WIFI_NME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsReqSend
+
+ DESCRIPTION
+ Requests the NME to look for WPS enabled APs and attempt to perform WPS
+ to determine the appropriate security credentials to connect to the AP.
+ If the PIN == '00000000' then 'push button mode' is indicated, otherwise
+ the PIN has to match that of the AP. 4 digit pin is passed by sending the
+ pin digits in pin[0]..pin[3] and rest of the contents filled with '-'.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ pin - PIN value.
+ ssid - Service Set identifier
+ bssid - ID of Basic Service Set for which a WPS connection attempt is
+ being made.
+
+*******************************************************************************/
+#define CsrWifiNmeWpsReqCreate(msg__, dst__, src__, interfaceTag__, pin__, ssid__, bssid__) \
+ msg__ = (CsrWifiNmeWpsReq *) CsrPmemAlloc(sizeof(CsrWifiNmeWpsReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_NME_PRIM, CSR_WIFI_NME_WPS_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ CsrMemCpy(msg__->pin, (pin__), sizeof(CsrUint8) * 8); \
+ msg__->ssid = (ssid__); \
+ msg__->bssid = (bssid__);
+
+#define CsrWifiNmeWpsReqSendTo(dst__, src__, interfaceTag__, pin__, ssid__, bssid__) \
+ { \
+ CsrWifiNmeWpsReq *msg__; \
+ CsrWifiNmeWpsReqCreate(msg__, dst__, src__, interfaceTag__, pin__, ssid__, bssid__); \
+ CsrMsgTransport(dst__, CSR_WIFI_NME_PRIM, msg__); \
+ }
+
+#define CsrWifiNmeWpsReqSend(src__, interfaceTag__, pin__, ssid__, bssid__) \
+ CsrWifiNmeWpsReqSendTo(CSR_WIFI_NME_IFACEQUEUE, src__, interfaceTag__, pin__, ssid__, bssid__)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_NME_LIB_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_NME_PRIM_H__
+#define CSR_WIFI_NME_PRIM_H__
+
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+#include "csr_sched.h"
+#include "csr_wifi_common.h"
+#include "csr_result.h"
+#include "csr_wifi_fsm_event.h"
+#include "csr_wifi_sme_prim.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_NME_ENABLE
+#error CSR_WIFI_NME_ENABLE MUST be defined inorder to use csr_wifi_nme_prim.h
+#endif
+
+#define CSR_WIFI_NME_PRIM (0x0424)
+
+typedef CsrPrim CsrWifiNmePrim;
+
+typedef void (*CsrWifiNmeFrameFreeFunction)(void *frame);
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeAuthMode
+
+ DESCRIPTION
+ WiFi Authentication Mode
+
+ VALUES
+ CSR_WIFI_NME_AUTH_MODE_80211_OPEN
+ - Connects to an open system network (i.e. no authentication,
+ no encryption) or to a WEP enabled network.
+ CSR_WIFI_NME_AUTH_MODE_80211_SHARED
+ - Connect to a WEP enabled network.
+ CSR_WIFI_NME_AUTH_MODE_8021X_WPA
+ - Connects to a WPA Enterprise enabled network.
+ CSR_WIFI_NME_AUTH_MODE_8021X_WPAPSK
+ - Connects to a WPA with Pre-Shared Key enabled network.
+ CSR_WIFI_NME_AUTH_MODE_8021X_WPA2
+ - Connects to a WPA2 Enterprise enabled network.
+ CSR_WIFI_NME_AUTH_MODE_8021X_WPA2PSK
+ - Connects to a WPA2 with Pre-Shared Key enabled network.
+ CSR_WIFI_NME_AUTH_MODE_8021X_CCKM
+ - Connects to a CCKM enabled network.
+ CSR_WIFI_NME_AUTH_MODE_WAPI_WAI
+ - Connects to a WAPI Enterprise enabled network.
+ CSR_WIFI_NME_AUTH_MODE_WAPI_WAIPSK
+ - Connects to a WAPI with Pre-Shared Key enabled network.
+ CSR_WIFI_NME_AUTH_MODE_8021X_OTHER1X
+ - For future use.
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiNmeAuthMode;
+#define CSR_WIFI_NME_AUTH_MODE_80211_OPEN ((CsrWifiNmeAuthMode) 0x0001)
+#define CSR_WIFI_NME_AUTH_MODE_80211_SHARED ((CsrWifiNmeAuthMode) 0x0002)
+#define CSR_WIFI_NME_AUTH_MODE_8021X_WPA ((CsrWifiNmeAuthMode) 0x0004)
+#define CSR_WIFI_NME_AUTH_MODE_8021X_WPAPSK ((CsrWifiNmeAuthMode) 0x0008)
+#define CSR_WIFI_NME_AUTH_MODE_8021X_WPA2 ((CsrWifiNmeAuthMode) 0x0010)
+#define CSR_WIFI_NME_AUTH_MODE_8021X_WPA2PSK ((CsrWifiNmeAuthMode) 0x0020)
+#define CSR_WIFI_NME_AUTH_MODE_8021X_CCKM ((CsrWifiNmeAuthMode) 0x0040)
+#define CSR_WIFI_NME_AUTH_MODE_WAPI_WAI ((CsrWifiNmeAuthMode) 0x0080)
+#define CSR_WIFI_NME_AUTH_MODE_WAPI_WAIPSK ((CsrWifiNmeAuthMode) 0x0100)
+#define CSR_WIFI_NME_AUTH_MODE_8021X_OTHER1X ((CsrWifiNmeAuthMode) 0x0200)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeBssType
+
+ DESCRIPTION
+ Type of BSS
+
+ VALUES
+ CSR_WIFI_NME_BSS_TYPE_INFRASTRUCTURE
+ - Infrastructure BSS type where access to the network is via
+ one or several Access Points.
+ CSR_WIFI_NME_BSS_TYPE_ADHOC
+ - Adhoc or Independent BSS Type where one Station acts as a
+ host and future stations can join the adhoc network without
+ needing an access point.
+ CSR_WIFI_NME_BSS_TYPE_RESERVED
+ - To be in sync with SME.This is not used.
+ CSR_WIFI_NME_BSS_TYPE_P2P
+ - P2P mode of operation.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiNmeBssType;
+#define CSR_WIFI_NME_BSS_TYPE_INFRASTRUCTURE ((CsrWifiNmeBssType) 0x00)
+#define CSR_WIFI_NME_BSS_TYPE_ADHOC ((CsrWifiNmeBssType) 0x01)
+#define CSR_WIFI_NME_BSS_TYPE_RESERVED ((CsrWifiNmeBssType) 0x02)
+#define CSR_WIFI_NME_BSS_TYPE_P2P ((CsrWifiNmeBssType) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeCcxOptionsMask
+
+ DESCRIPTION
+ Enumeration type defining possible mask values for setting CCX options.
+
+ VALUES
+ CSR_WIFI_NME_CCX_OPTION_NONE - No CCX option is set.
+ CSR_WIFI_NME_CCX_OPTION_CCKM - CCX option cckm is set.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiNmeCcxOptionsMask;
+#define CSR_WIFI_NME_CCX_OPTION_NONE ((CsrWifiNmeCcxOptionsMask) 0x00)
+#define CSR_WIFI_NME_CCX_OPTION_CCKM ((CsrWifiNmeCcxOptionsMask) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeConfigAction
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_PIN_ENTRY_PUSH_BUTTON -
+ CSR_WIFI_PIN_ENTRY_DISPLAY_PIN -
+ CSR_WIFI_PIN_ENTRY_ENTER_PIN -
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiNmeConfigAction;
+#define CSR_WIFI_PIN_ENTRY_PUSH_BUTTON ((CsrWifiNmeConfigAction) 0x00)
+#define CSR_WIFI_PIN_ENTRY_DISPLAY_PIN ((CsrWifiNmeConfigAction) 0x01)
+#define CSR_WIFI_PIN_ENTRY_ENTER_PIN ((CsrWifiNmeConfigAction) 0x02)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeConnectionStatus
+
+ DESCRIPTION
+ Indicate the NME Connection Status when connecting or when disconnecting
+
+ VALUES
+ CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_DISCONNECTED
+ - NME is disconnected.
+ CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_CONNECTING
+ - NME is in the process of connecting.
+ CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_AUTHENTICATING
+ - NME is in the authentication stage of a connection attempt.
+ CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_CONNECTED
+ - NME is connected.
+ CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_DISCONNECTING
+ - NME is in the process of disconnecting.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiNmeConnectionStatus;
+#define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_DISCONNECTED ((CsrWifiNmeConnectionStatus) 0x00)
+#define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_CONNECTING ((CsrWifiNmeConnectionStatus) 0x01)
+#define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_AUTHENTICATING ((CsrWifiNmeConnectionStatus) 0x02)
+#define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_CONNECTED ((CsrWifiNmeConnectionStatus) 0x03)
+#define CSR_WIFI_NME_CONNECTION_STATUS_CONNECTION_STATUS_DISCONNECTING ((CsrWifiNmeConnectionStatus) 0x04)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeCredentialType
+
+ DESCRIPTION
+ NME Credential Types
+
+ VALUES
+ CSR_WIFI_NME_CREDENTIAL_TYPE_OPEN_SYSTEM
+ - Credential Type Open System.
+ CSR_WIFI_NME_CREDENTIAL_TYPE_WEP64
+ - Credential Type WEP-64
+ CSR_WIFI_NME_CREDENTIAL_TYPE_WEP128
+ - Credential Type WEP-128
+ CSR_WIFI_NME_CREDENTIAL_TYPE_WPA_PSK
+ - Credential Type WPA Pre-Shared Key
+ CSR_WIFI_NME_CREDENTIAL_TYPE_WPA_PASSPHRASE
+ - Credential Type WPA pass phrase
+ CSR_WIFI_NME_CREDENTIAL_TYPE_WPA2_PSK
+ - Credential Type WPA2 Pre-Shared Key.
+ CSR_WIFI_NME_CREDENTIAL_TYPE_WPA2_PASSPHRASE
+ - Credential Type WPA2 pass phrase
+ CSR_WIFI_NME_CREDENTIAL_TYPE_WAPI_PSK
+ - Credential Type WAPI Pre-Shared Key.
+ CSR_WIFI_NME_CREDENTIAL_TYPE_WAPI_PASSPHRASE
+ - Credential Type WAPI pass phrase
+ CSR_WIFI_NME_CREDENTIAL_TYPE_WAPI
+ - Credential Type WAPI certificates
+ CSR_WIFI_NME_CREDENTIAL_TYPE_8021X
+ - Credential Type 802.1X: the associated type supports
+ FAST/LEAP/TLS/TTLS/PEAP/etc.
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiNmeCredentialType;
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_OPEN_SYSTEM ((CsrWifiNmeCredentialType) 0x0000)
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_WEP64 ((CsrWifiNmeCredentialType) 0x0001)
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_WEP128 ((CsrWifiNmeCredentialType) 0x0002)
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_WPA_PSK ((CsrWifiNmeCredentialType) 0x0003)
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_WPA_PASSPHRASE ((CsrWifiNmeCredentialType) 0x0004)
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_WPA2_PSK ((CsrWifiNmeCredentialType) 0x0005)
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_WPA2_PASSPHRASE ((CsrWifiNmeCredentialType) 0x0006)
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_WAPI_PSK ((CsrWifiNmeCredentialType) 0x0007)
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_WAPI_PASSPHRASE ((CsrWifiNmeCredentialType) 0x0008)
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_WAPI ((CsrWifiNmeCredentialType) 0x0009)
+#define CSR_WIFI_NME_CREDENTIAL_TYPE_8021X ((CsrWifiNmeCredentialType) 0x000A)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeEapMethod
+
+ DESCRIPTION
+ Outer EAP method with possibly inner method.
+
+ VALUES
+ CSR_WIFI_NME_EAP_METHOD_TLS
+ - EAP-TLS Method.
+ CSR_WIFI_NME_EAP_METHOD_TTLS_MSCHAPV2
+ - EAP-TTLS Method with MSCHAPV2.
+ CSR_WIFI_NME_EAP_METHOD_PEAP_GTC
+ - EAP-PEAP Method with GTC.
+ CSR_WIFI_NME_EAP_METHOD_PEAP_MSCHAPV2
+ - EAP-PEAP Method with MSCHAPV2.
+ CSR_WIFI_NME_EAP_METHOD_SIM
+ - EAP-SIM Method.
+ CSR_WIFI_NME_EAP_METHOD_AKA
+ - EAP-AKA Method.
+ CSR_WIFI_NME_EAP_METHOD_FAST_GTC
+ - EAP-FAST Method with GTC.
+ CSR_WIFI_NME_EAP_METHOD_FAST_MSCHAPV2
+ - EAP-FAST Method with MSCHAPV2.
+ CSR_WIFI_NME_EAP_METHOD_LEAP
+ - EAP-LEAP Method.
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiNmeEapMethod;
+#define CSR_WIFI_NME_EAP_METHOD_TLS ((CsrWifiNmeEapMethod) 0x0001)
+#define CSR_WIFI_NME_EAP_METHOD_TTLS_MSCHAPV2 ((CsrWifiNmeEapMethod) 0x0002)
+#define CSR_WIFI_NME_EAP_METHOD_PEAP_GTC ((CsrWifiNmeEapMethod) 0x0004)
+#define CSR_WIFI_NME_EAP_METHOD_PEAP_MSCHAPV2 ((CsrWifiNmeEapMethod) 0x0008)
+#define CSR_WIFI_NME_EAP_METHOD_SIM ((CsrWifiNmeEapMethod) 0x0010)
+#define CSR_WIFI_NME_EAP_METHOD_AKA ((CsrWifiNmeEapMethod) 0x0020)
+#define CSR_WIFI_NME_EAP_METHOD_FAST_GTC ((CsrWifiNmeEapMethod) 0x0040)
+#define CSR_WIFI_NME_EAP_METHOD_FAST_MSCHAPV2 ((CsrWifiNmeEapMethod) 0x0080)
+#define CSR_WIFI_NME_EAP_METHOD_LEAP ((CsrWifiNmeEapMethod) 0x0100)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeEncryption
+
+ DESCRIPTION
+ WiFi Encryption method
+
+ VALUES
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_NONE
+ - No encryprion set.
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_WEP40
+ - 40 bytes WEP key for peer to peer communication.
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_WEP104
+ - 104 bytes WEP key for peer to peer communication.
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_TKIP
+ - TKIP key for peer to peer communication.
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_CCMP
+ - CCMP key for peer to peer communication.
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_SMS4
+ - SMS4 key for peer to peer communication.
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_WEP40
+ - 40 bytes WEP key for broadcast messages.
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_WEP104
+ - 104 bytes WEP key for broadcast messages.
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_TKIP
+ - TKIP key for broadcast messages.
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_CCMP
+ - CCMP key for broadcast messages
+ CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_SMS4
+ - SMS4 key for broadcast messages.
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiNmeEncryption;
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_NONE ((CsrWifiNmeEncryption) 0x0000)
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_WEP40 ((CsrWifiNmeEncryption) 0x0001)
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_WEP104 ((CsrWifiNmeEncryption) 0x0002)
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_TKIP ((CsrWifiNmeEncryption) 0x0004)
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_CCMP ((CsrWifiNmeEncryption) 0x0008)
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_SMS4 ((CsrWifiNmeEncryption) 0x0010)
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_WEP40 ((CsrWifiNmeEncryption) 0x0020)
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_WEP104 ((CsrWifiNmeEncryption) 0x0040)
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_TKIP ((CsrWifiNmeEncryption) 0x0080)
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_CCMP ((CsrWifiNmeEncryption) 0x0100)
+#define CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_SMS4 ((CsrWifiNmeEncryption) 0x0200)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeIndications
+
+ DESCRIPTION
+ NME indications
+
+ VALUES
+ CSR_WIFI_NME_INDICATIONS_IND_AP_STATION
+ - NME AP Station Indication.
+ CSR_WIFI_NME_INDICATIONS_IND_AP_STOP
+ - NME AP Stop Indication.
+ CSR_WIFI_NME_INDICATIONS_IND_SIM_UMTS_AUTH
+ - NME UMTS Authentication Indication.
+ CSR_WIFI_NME_INDICATIONS_IND_P2P_GROUP_START
+ - NME P2P Group Start Indication.
+ CSR_WIFI_NME_INDICATIONS_IND_P2P_GROUP_STATUS
+ - NME P2P Group Status Indication.
+ CSR_WIFI_NME_INDICATIONS_IND_P2P_GROUP_ROLE
+ - NME P2P Group Role Indication.
+ CSR_WIFI_NME_INDICATIONS_IND_PROFILE_DISCONNECT
+ - NME Profile Disconnect Indication.
+ CSR_WIFI_NME_INDICATIONS_IND_PROFILE_UPDATE
+ - NME Profile Update Indication.
+ CSR_WIFI_NME_INDICATIONS_IND_SIM_IMSI_GET
+ - NME GET IMSI Indication.
+ CSR_WIFI_NME_INDICATIONS_IND_SIM_GSM_AUTH
+ - NME GSM Authentication Indication.
+ CSR_WIFI_NME_INDICATIONS_ALL
+ - Used to register for all available indications
+
+*******************************************************************************/
+typedef CsrUint32 CsrWifiNmeIndications;
+#define CSR_WIFI_NME_INDICATIONS_IND_AP_STATION ((CsrWifiNmeIndications) 0x00100000)
+#define CSR_WIFI_NME_INDICATIONS_IND_AP_STOP ((CsrWifiNmeIndications) 0x00200000)
+#define CSR_WIFI_NME_INDICATIONS_IND_SIM_UMTS_AUTH ((CsrWifiNmeIndications) 0x01000000)
+#define CSR_WIFI_NME_INDICATIONS_IND_P2P_GROUP_START ((CsrWifiNmeIndications) 0x02000000)
+#define CSR_WIFI_NME_INDICATIONS_IND_P2P_GROUP_STATUS ((CsrWifiNmeIndications) 0x04000000)
+#define CSR_WIFI_NME_INDICATIONS_IND_P2P_GROUP_ROLE ((CsrWifiNmeIndications) 0x08000000)
+#define CSR_WIFI_NME_INDICATIONS_IND_PROFILE_DISCONNECT ((CsrWifiNmeIndications) 0x10000000)
+#define CSR_WIFI_NME_INDICATIONS_IND_PROFILE_UPDATE ((CsrWifiNmeIndications) 0x20000000)
+#define CSR_WIFI_NME_INDICATIONS_IND_SIM_IMSI_GET ((CsrWifiNmeIndications) 0x40000000)
+#define CSR_WIFI_NME_INDICATIONS_IND_SIM_GSM_AUTH ((CsrWifiNmeIndications) 0x80000000)
+#define CSR_WIFI_NME_INDICATIONS_ALL ((CsrWifiNmeIndications) 0xFFFFFFFF)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSecError
+
+ DESCRIPTION
+ NME Security Errors
+ place holder for the security library abort reason
+
+ VALUES
+ CSR_WIFI_NME_SEC_ERROR_SEC_ERROR_UNKNOWN
+ - Unknown Security Error.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiNmeSecError;
+#define CSR_WIFI_NME_SEC_ERROR_SEC_ERROR_UNKNOWN ((CsrWifiNmeSecError) 0x00)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimCardType
+
+ DESCRIPTION
+ (U)SIM Card (or UICC) types
+
+ VALUES
+ CSR_WIFI_NME_SIM_CARD_TYPE_2G - 2G SIM card, capable of performing GSM
+ authentication only.
+ CSR_WIFI_NME_SIM_CARD_TYPE_3G - UICC supporting USIM application, capable
+ of performing UMTS authentication only.
+ CSR_WIFI_NME_SIM_CARD_TYPE_2G3G - UICC supporting both USIM and SIM
+ applications, capable of performing both
+ UMTS and GSM authentications.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiNmeSimCardType;
+#define CSR_WIFI_NME_SIM_CARD_TYPE_2G ((CsrWifiNmeSimCardType) 0x01)
+#define CSR_WIFI_NME_SIM_CARD_TYPE_3G ((CsrWifiNmeSimCardType) 0x02)
+#define CSR_WIFI_NME_SIM_CARD_TYPE_2G3G ((CsrWifiNmeSimCardType) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeUmtsAuthResult
+
+ DESCRIPTION
+ Only relevant for UMTS Authentication. It indicates if the UICC has
+ successfully authenticated the network or otherwise.
+
+ VALUES
+ CSR_WIFI_NME_UMTS_AUTH_RESULT_SUCCESS
+ - Successful outcome from USIM indicating that the card has
+ successfully authenticated the network.
+ CSR_WIFI_NME_UMTS_AUTH_RESULT_SYNC_FAIL
+ - Unsuccessful outcome from USIM indicating that the card is
+ requesting the network to synchronise and re-try again. If
+ no further request is received an NME timer will expire and
+ the authentication is aborted.
+ CSR_WIFI_NME_UMTS_AUTH_RESULT_REJECT
+ - Unsuccessful outcome from USIM indicating that the card has
+ rejected the network and that the authentication is
+ aborted.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiNmeUmtsAuthResult;
+#define CSR_WIFI_NME_UMTS_AUTH_RESULT_SUCCESS ((CsrWifiNmeUmtsAuthResult) 0x00)
+#define CSR_WIFI_NME_UMTS_AUTH_RESULT_SYNC_FAIL ((CsrWifiNmeUmtsAuthResult) 0x01)
+#define CSR_WIFI_NME_UMTS_AUTH_RESULT_REJECT ((CsrWifiNmeUmtsAuthResult) 0x02)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWmmQosInfo
+
+ DESCRIPTION
+ Defines bits for the QoS Info octect as defined in the WMM specification.
+ The values of this type are used across the NME/SME/Router API's and they
+ must be kept consistent with the corresponding types in the .xml of the
+ other interfaces
+
+ VALUES
+ CSR_WIFI_NME_WMM_QOS_INFO_AC_MAX_SP_ALL
+ - WMM AP may deliver all buffered frames.
+ CSR_WIFI_NME_WMM_QOS_INFO_AC_VO
+ - To enable the triggering and delivery of QoS Voice.
+ CSR_WIFI_NME_WMM_QOS_INFO_AC_VI
+ - To enable the triggering and delivery of QoS Video.
+ CSR_WIFI_NME_WMM_QOS_INFO_AC_BK
+ - To enable the triggering and delivery of QoS Background.
+ CSR_WIFI_NME_WMM_QOS_INFO_AC_BE
+ - To enable the triggering and delivery of QoS Best Effort.
+ CSR_WIFI_NME_WMM_QOS_INFO_AC_MAX_SP_TWO
+ - WMM AP may deliver a maximum of 2 buffered frames per
+ Unscheduled Service Period (USP).
+ CSR_WIFI_NME_WMM_QOS_INFO_AC_MAX_SP_FOUR
+ - WMM AP may deliver a maximum of 4 buffered frames per USP.
+ CSR_WIFI_NME_WMM_QOS_INFO_AC_MAX_SP_SIX
+ - WMM AP may deliver a maximum of 6 buffered frames per USP.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiNmeWmmQosInfo;
+#define CSR_WIFI_NME_WMM_QOS_INFO_AC_MAX_SP_ALL ((CsrWifiNmeWmmQosInfo) 0x00)
+#define CSR_WIFI_NME_WMM_QOS_INFO_AC_VO ((CsrWifiNmeWmmQosInfo) 0x01)
+#define CSR_WIFI_NME_WMM_QOS_INFO_AC_VI ((CsrWifiNmeWmmQosInfo) 0x02)
+#define CSR_WIFI_NME_WMM_QOS_INFO_AC_BK ((CsrWifiNmeWmmQosInfo) 0x04)
+#define CSR_WIFI_NME_WMM_QOS_INFO_AC_BE ((CsrWifiNmeWmmQosInfo) 0x08)
+#define CSR_WIFI_NME_WMM_QOS_INFO_AC_MAX_SP_TWO ((CsrWifiNmeWmmQosInfo) 0x20)
+#define CSR_WIFI_NME_WMM_QOS_INFO_AC_MAX_SP_FOUR ((CsrWifiNmeWmmQosInfo) 0x40)
+#define CSR_WIFI_NME_WMM_QOS_INFO_AC_MAX_SP_SIX ((CsrWifiNmeWmmQosInfo) 0x60)
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeEapMethodMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiNmeEapMethod.
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiNmeEapMethodMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeEncryptionMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiNmeEncryption
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiNmeEncryptionMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeIndicationsMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiNmeIndications
+
+*******************************************************************************/
+typedef CsrUint32 CsrWifiNmeIndicationsMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeNmeIndicationsMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiNmeNmeIndications.
+ Used to overlap the unused portion of the unifi_IndicationsMask For NME
+ specific indications
+
+*******************************************************************************/
+typedef CsrUint32 CsrWifiNmeNmeIndicationsMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWmmQosInfoMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiNmeWmmQosInfo
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiNmeWmmQosInfoMask;
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeEmpty
+
+ DESCRIPTION
+ Empty Structure to indicate that no credentials are available.
+
+ MEMBERS
+ empty - Only element of the empty structure (always set to 0).
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 empty;
+} CsrWifiNmeEmpty;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmePassphrase
+
+ DESCRIPTION
+ Structure holding the ASCII Pass Phrase data.
+
+ MEMBERS
+ encryptionMode - Encryption type as defined in CsrWifiSmeEncryption.
+ passphrase - Pass phrase ASCII value.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint16 encryptionMode;
+ CsrCharString *passphrase;
+} CsrWifiNmePassphrase;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmePsk
+
+ DESCRIPTION
+ Structure holding the Pre-Shared Key data.
+
+ MEMBERS
+ encryptionMode - Encryption type as defined in CsrWifiSmeEncryption.
+ psk - Pre-Shared Key value.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint16 encryptionMode;
+ CsrUint8 psk[32];
+} CsrWifiNmePsk;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWapiCredentials
+
+ DESCRIPTION
+ Structure holding WAPI credentials data.
+
+ MEMBERS
+ certificateLength - Length in bytes of the following client certificate.
+ certificate - The actual client certificate data (if present).
+ DER/PEM format supported.
+ privateKeyLength - Length in bytes of the following private key.
+ privateKey - The actual private key. DER/PEM format.
+ caCertificateLength - Length in bytes of the following certificate authority
+ certificate.
+ caCertificate - The actual certificate authority certificate data. If
+ not supplied the received certificate authority
+ certificate is assumed to be validate, if present the
+ received certificate is validated against it. DER/PEM
+ format supported.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint32 certificateLength;
+ CsrUint8 *certificate;
+ CsrUint16 privateKeyLength;
+ CsrUint8 *privateKey;
+ CsrUint32 caCertificateLength;
+ CsrUint8 *caCertificate;
+} CsrWifiNmeWapiCredentials;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeConnectAttempt
+
+ DESCRIPTION
+ Structure holding Connection attempt data.
+
+ MEMBERS
+ bssid - Id of Basic Service Set connections attempt have been made
+ to.
+ status - Status returned to indicate the success or otherwise of the
+ connection attempt.
+ securityError - Security error status indicating the nature of the failure
+ to connect.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiMacAddress bssid;
+ CsrResult status;
+ CsrWifiNmeSecError securityError;
+} CsrWifiNmeConnectAttempt;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeEapCredentials
+
+ DESCRIPTION
+ Supports the use of multiple EAP methods via a single structure. The
+ methods required are indicated by the value set in the eapMethodMask
+
+ MEMBERS
+ eapMethodMask
+ - Bit mask of supported EAP methods
+ Currently only supports the setting of one bit.
+ Required for all the EAP methods.
+ authMode
+ - Bit mask representing the authentication types that may be
+ supported by a suitable AP. An AP must support at least one
+ of the authentication types specified to be considered for
+ connection. Required for all EAP methods.
+ encryptionMode
+ - Bit mask representing the encryption types that may be
+ supported by a suitable AP. An AP must support a suitable
+ mix of the pairwise and group encryption types requested to
+ be considered for connection. Required for all EAP methods.
+ userName
+ - User name. Required for all EAP methods except: SIM or AKA.
+ userPassword
+ - User Password. Required for all EAP methods except: TLS,
+ SIM or AKA.
+ authServerUserIdentity
+ - Authentication server user Identity. Required for all EAP
+ methods except: TLS, SIM, AKA or FAST.
+ clientCertificateLength
+ - Length in bytes of the following client certificate (if
+ present). Only required for TLS.
+ clientCertificate
+ - The actual client certificate data (if present). Only
+ required for TLS. DER/PEM format supported.
+ certificateAuthorityCertificateLength
+ - Length in bytes of the following certificate authority
+ certificate (if present). Optional for TLS, TTLS, PEAP.
+ certificateAuthorityCertificate
+ - The actual certificate authority certificate data (if
+ present). If not supplied the received certificate
+ authority certificate is assumed to be valid, if present
+ the received certificate is validated against it. Optional
+ for TLS, TTLS, PEAP. DER/PEM format supported.
+ privateKeyLength
+ - Length in bytes of the following private key (if present).
+ Only required for TLS.
+ privateKey
+ - The actual private key (if present). Only required for TLS.
+ DER/PEM format, maybe password protected.
+ privateKeyPassword
+ - Optional password to protect the private key.
+ sessionLength
+ - Length in bytes of the following session field Supported
+ for all EAP methods except: SIM or AKA.
+ session
+ - Session information to support faster re-authentication.
+ Supported for all EAP methods except: SIM or AKA.
+ allowPacProvisioning
+ - If TRUE: PAC provisioning is allowed 'over-the_air';
+ If FALSE: a PAC must be supplied.
+ Only required for FAST.
+ pacLength
+ - Length the following PAC field. If allowPacProvisioning is
+ FALSE then the PAC MUST be supplied (i.e. non-zero). Only
+ required for FAST.
+ pac
+ - The actual PAC data. If allowPacProvisioning is FALSE then
+ the PAC MUST be supplied. Only required for FAST.
+ pacPassword
+ - Optional password to protect the PAC. Only required for
+ FAST.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiNmeEapMethodMask eapMethodMask;
+ CsrWifiSmeAuthModeMask authMode;
+ CsrWifiNmeEncryptionMask encryptionMode;
+ CsrCharString *userName;
+ CsrCharString *userPassword;
+ CsrCharString *authServerUserIdentity;
+ CsrUint32 clientCertificateLength;
+ CsrUint8 *clientCertificate;
+ CsrUint32 certificateAuthorityCertificateLength;
+ CsrUint8 *certificateAuthorityCertificate;
+ CsrUint16 privateKeyLength;
+ CsrUint8 *privateKey;
+ CsrCharString *privateKeyPassword;
+ CsrUint32 sessionLength;
+ CsrUint8 *session;
+ CsrBool allowPacProvisioning;
+ CsrUint32 pacLength;
+ CsrUint8 *pac;
+ CsrCharString *pacPassword;
+} CsrWifiNmeEapCredentials;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmePeerConfig
+
+ DESCRIPTION
+ Structure holding Peer Config data.
+
+ MEMBERS
+ p2pDeviceId -
+ groupCapabilityMask -
+ groupOwnerIntent -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiMacAddress p2pDeviceId;
+ CsrWifiSmeP2pGroupCapabilityMask groupCapabilityMask;
+ CsrUint8 groupOwnerIntent;
+} CsrWifiNmePeerConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileIdentity
+
+ DESCRIPTION
+ The identity of a profile is defined as the unique combination the BSSID
+ and SSID.
+
+ MEMBERS
+ bssid - ID of Basic Service Set for or the P2pDevice address of the GO for
+ which a connection attempt was made.
+ ssid - Service Set Id.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiMacAddress bssid;
+ CsrWifiSsid ssid;
+} CsrWifiNmeProfileIdentity;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWep128Keys
+
+ DESCRIPTION
+ Structure holding WEP Authentication Type and WEP keys that can be used
+ when using WEP128.
+
+ MEMBERS
+ wepAuthType - Mask to select the WEP authentication type (Open or Shared)
+ selectedWepKey - Index to one of the four keys below indicating the
+ currently used WEP key.
+ key1 - Value for key number 1.
+ key2 - Value for key number 2.
+ key3 - Value for key number 3.
+ key4 - Value for key number 4.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeAuthModeMask wepAuthType;
+ CsrUint8 selectedWepKey;
+ CsrUint8 key1[13];
+ CsrUint8 key2[13];
+ CsrUint8 key3[13];
+ CsrUint8 key4[13];
+} CsrWifiNmeWep128Keys;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWep64Keys
+
+ DESCRIPTION
+ Structure for holding WEP Authentication Type and WEP keys that can be
+ used when using WEP64.
+
+ MEMBERS
+ wepAuthType - Mask to select the WEP authentication type (Open or Shared)
+ selectedWepKey - Index to one of the four keys below indicating the
+ currently used WEP key.
+ key1 - Value for key number 1.
+ key2 - Value for key number 2.
+ key3 - Value for key number 3.
+ key4 - Value for key number 4.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeAuthModeMask wepAuthType;
+ CsrUint8 selectedWepKey;
+ CsrUint8 key1[5];
+ CsrUint8 key2[5];
+ CsrUint8 key3[5];
+ CsrUint8 key4[5];
+} CsrWifiNmeWep64Keys;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeCredentials
+
+ DESCRIPTION
+ Structure containing the Credentials data.
+
+ MEMBERS
+ credentialType - Credential type value (as defined in the
+ enumeration type).
+ credential - Union containing credentials which depends on
+ credentialType parameter.
+ credentialeap -
+ credentialwapiPassphrase -
+ credentialwpa2Passphrase -
+ credentialwpa2Psk -
+ credentialwapiPsk -
+ credentialwpaPassphrase -
+ credentialwapi -
+ credentialwep128Key -
+ credentialwpaPsk -
+ credentialopenSystem -
+ credentialwep64Key -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiNmeCredentialType credentialType;
+ union {
+ CsrWifiNmeEapCredentials eap;
+ CsrWifiNmePassphrase wapiPassphrase;
+ CsrWifiNmePassphrase wpa2Passphrase;
+ CsrWifiNmePsk wpa2Psk;
+ CsrWifiNmePsk wapiPsk;
+ CsrWifiNmePassphrase wpaPassphrase;
+ CsrWifiNmeWapiCredentials wapi;
+ CsrWifiNmeWep128Keys wep128Key;
+ CsrWifiNmePsk wpaPsk;
+ CsrWifiNmeEmpty openSystem;
+ CsrWifiNmeWep64Keys wep64Key;
+ } credential;
+} CsrWifiNmeCredentials;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfile
+
+ DESCRIPTION
+ Structure containing the Profile data.
+
+ MEMBERS
+ profileIdentity - Profile Identity.
+ wmmQosInfoMask - Mask for WMM QoS information.
+ bssType - Type of BSS (Infrastructure or Adhoc).
+ channelNo - Channel Number.
+ ccxOptionsMask - Options mask for Cisco Compatible Extentions.
+ cloakedSsid - Flag to decide whether the SSID is cloaked (not
+ transmitted) or not.
+ credentials - Credentials data.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiNmeProfileIdentity profileIdentity;
+ CsrWifiNmeWmmQosInfoMask wmmQosInfoMask;
+ CsrWifiNmeBssType bssType;
+ CsrUint8 channelNo;
+ CsrUint8 ccxOptionsMask;
+ CsrBool cloakedSsid;
+ CsrWifiNmeCredentials credentials;
+} CsrWifiNmeProfile;
+
+
+/* Downstream */
+#define CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST (0x0000)
+
+#define CSR_WIFI_NME_PROFILE_SET_REQ ((CsrWifiNmePrim) (0x0000 + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_PROFILE_DELETE_REQ ((CsrWifiNmePrim) (0x0001 + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_PROFILE_DELETE_ALL_REQ ((CsrWifiNmePrim) (0x0002 + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_PROFILE_ORDER_SET_REQ ((CsrWifiNmePrim) (0x0003 + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_PROFILE_CONNECT_REQ ((CsrWifiNmePrim) (0x0004 + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_WPS_REQ ((CsrWifiNmePrim) (0x0005 + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_WPS_CANCEL_REQ ((CsrWifiNmePrim) (0x0006 + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_CONNECTION_STATUS_GET_REQ ((CsrWifiNmePrim) (0x0007 + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_SIM_IMSI_GET_RES ((CsrWifiNmePrim) (0x0008 + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_SIM_GSM_AUTH_RES ((CsrWifiNmePrim) (0x0009 + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_SIM_UMTS_AUTH_RES ((CsrWifiNmePrim) (0x000A + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_WPS_CONFIG_SET_REQ ((CsrWifiNmePrim) (0x000B + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_NME_EVENT_MASK_SET_REQ ((CsrWifiNmePrim) (0x000C + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST))
+
+
+#define CSR_WIFI_NME_PRIM_DOWNSTREAM_HIGHEST (0x000C + CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST)
+
+/* Upstream */
+#define CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST (0x0000 + CSR_PRIM_UPSTREAM)
+
+#define CSR_WIFI_NME_PROFILE_SET_CFM ((CsrWifiNmePrim)(0x0000 + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_PROFILE_DELETE_CFM ((CsrWifiNmePrim)(0x0001 + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_PROFILE_DELETE_ALL_CFM ((CsrWifiNmePrim)(0x0002 + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_PROFILE_ORDER_SET_CFM ((CsrWifiNmePrim)(0x0003 + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_PROFILE_CONNECT_CFM ((CsrWifiNmePrim)(0x0004 + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_WPS_CFM ((CsrWifiNmePrim)(0x0005 + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_WPS_CANCEL_CFM ((CsrWifiNmePrim)(0x0006 + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_CONNECTION_STATUS_GET_CFM ((CsrWifiNmePrim)(0x0007 + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_PROFILE_UPDATE_IND ((CsrWifiNmePrim)(0x0008 + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_PROFILE_DISCONNECT_IND ((CsrWifiNmePrim)(0x0009 + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_SIM_IMSI_GET_IND ((CsrWifiNmePrim)(0x000A + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_SIM_GSM_AUTH_IND ((CsrWifiNmePrim)(0x000B + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_SIM_UMTS_AUTH_IND ((CsrWifiNmePrim)(0x000C + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_WPS_CONFIG_SET_CFM ((CsrWifiNmePrim)(0x000D + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_NME_EVENT_MASK_SET_CFM ((CsrWifiNmePrim)(0x000E + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST))
+
+#define CSR_WIFI_NME_PRIM_UPSTREAM_HIGHEST (0x000E + CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST)
+
+#define CSR_WIFI_NME_PRIM_DOWNSTREAM_COUNT (CSR_WIFI_NME_PRIM_DOWNSTREAM_HIGHEST + 1 - CSR_WIFI_NME_PRIM_DOWNSTREAM_LOWEST)
+#define CSR_WIFI_NME_PRIM_UPSTREAM_COUNT (CSR_WIFI_NME_PRIM_UPSTREAM_HIGHEST + 1 - CSR_WIFI_NME_PRIM_UPSTREAM_LOWEST)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileSetReq
+
+ DESCRIPTION
+ Creates or updates an existing profile in the NME that matches the unique
+ identity of the profile. Each profile is identified by the combination of
+ BSSID and SSID. The profile contains all the required credentials for
+ attempting to connect to the network. Creating or updating a profile via
+ the NME PROFILE SET REQ does NOT add the profile to the preferred profile
+ list within the NME used for the NME auto-connect behaviour.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ profile - Specifies the identity and credentials of the network.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiNmeProfile profile;
+} CsrWifiNmeProfileSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileDeleteReq
+
+ DESCRIPTION
+ Will delete the profile with a matching identity, but does NOT modify the
+ preferred profile list.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ profileIdentity - Identity (BSSID, SSID) of profile to be deleted.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiNmeProfileIdentity profileIdentity;
+} CsrWifiNmeProfileDeleteReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileDeleteAllReq
+
+ DESCRIPTION
+ Deletes all profiles present in the NME, but does NOT modify the
+ preferred profile list.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiNmeProfileDeleteAllReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileOrderSetReq
+
+ DESCRIPTION
+ Defines the preferred order that profiles present in the NME should be
+ used during the NME auto-connect behaviour.
+ If profileIdentitysCount == 0, it removes any existing preferred profile
+ list already present in the NME, effectively disabling the auto-connect
+ behaviour.
+ NOTE: Profile identities that do not match any profile stored in the NME
+ are ignored during the auto-connect procedure.
+ NOTE: during auto-connect the NME will only attempt to join an existing
+ adhoc network and it will never attempt to host an adhoc network; for
+ hosting and adhoc network, use CSR_WIFI_NME_PROFILE_CONNECT_REQ
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an
+ interface
+ profileIdentitysCount - The number of profiles identities in the list.
+ profileIdentitys - Points to the list of profile identities.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 profileIdentitysCount;
+ CsrWifiNmeProfileIdentity *profileIdentitys;
+} CsrWifiNmeProfileOrderSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileConnectReq
+
+ DESCRIPTION
+ Requests the NME to attempt to connect to the specified profile.
+ Overrides any current connection attempt.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ profileIdentity - Identity (BSSID, SSID) of profile to be connected to.
+ It must match an existing profile in the NME.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiNmeProfileIdentity profileIdentity;
+} CsrWifiNmeProfileConnectReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsReq
+
+ DESCRIPTION
+ Requests the NME to look for WPS enabled APs and attempt to perform WPS
+ to determine the appropriate security credentials to connect to the AP.
+ If the PIN == '00000000' then 'push button mode' is indicated, otherwise
+ the PIN has to match that of the AP. 4 digit pin is passed by sending the
+ pin digits in pin[0]..pin[3] and rest of the contents filled with '-'.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ pin - PIN value.
+ ssid - Service Set identifier
+ bssid - ID of Basic Service Set for which a WPS connection attempt is
+ being made.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 pin[8];
+ CsrWifiSsid ssid;
+ CsrWifiMacAddress bssid;
+} CsrWifiNmeWpsReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsCancelReq
+
+ DESCRIPTION
+ Requests the NME to cancel any WPS procedure that it is currently
+ performing. This includes WPS registrar activities started because of
+ CSR_WIFI_NME_AP_REGISTER.request
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiNmeWpsCancelReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeConnectionStatusGetReq
+
+ DESCRIPTION
+ Requests the current connection status of the NME.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiNmeConnectionStatusGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimImsiGetRes
+
+ DESCRIPTION
+ Response from the application that received the NME SIM IMSI GET IND.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Indicates the outcome of the requested operation: STATUS_SUCCESS
+ or STATUS_ERROR.
+ imsi - The value of the IMSI obtained from the UICC.
+ cardType - The UICC type (GSM only (SIM), UMTS only (USIM), Both).
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrCharString *imsi;
+ CsrWifiNmeSimCardType cardType;
+} CsrWifiNmeSimImsiGetRes;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimGsmAuthRes
+
+ DESCRIPTION
+ Response from the application that received the NME SIM GSM AUTH IND. For
+ each GSM authentication round a GSM Ciphering key (Kc) and a signed
+ response (SRES) are produced. Since 2 or 3 GSM authentication rounds are
+ used the 2 or 3 Kc's obtained respectively are combined into one buffer
+ and similarly the 2 or 3 SRES's obtained are combined into another
+ buffer. The order of Kc values (SRES values respectively) in their buffer
+ is the same as that of their corresponding RAND values in the incoming
+ indication.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Indicates the outcome of the requested operation:
+ STATUS_SUCCESS or STATUS_ERROR
+ kcsLength - Length in Bytes of Kc buffer. Legal values are: 16 or 24.
+ kcs - Kc buffer holding 2 or 3 Kc values.
+ sresLength - Length in Bytes of SRES buffer. Legal values are: 8 or 12.
+ sres - SRES buffer holding 2 or 3 SRES values.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrUint8 kcsLength;
+ CsrUint8 *kcs;
+ CsrUint8 sresLength;
+ CsrUint8 *sres;
+} CsrWifiNmeSimGsmAuthRes;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimUmtsAuthRes
+
+ DESCRIPTION
+ Response from the application that received the NME SIM UMTS AUTH IND.
+ The values of umtsCipherKey, umtsIntegrityKey, resParameterLength and
+ resParameter are only meanigful when result = UMTS_AUTH_RESULT_SUCCESS.
+ The value of auts is only meaningful when
+ result=UMTS_AUTH_RESULT_SYNC_FAIL.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Indicates the outcome of the requested operation:
+ STATUS_SUCCESS or STATUS_ERROR.
+ result - The result of UMTS authentication as performed by the
+ UICC which could be: Success, Authentication Reject or
+ Synchronisation Failure. For all these 3 outcomes the
+ value of status is success.
+ umtsCipherKey - The UMTS Cipher Key as calculated and returned by the
+ UICC.
+ umtsIntegrityKey - The UMTS Integrity Key as calculated and returned by
+ the UICC.
+ resParameterLength - The length (in bytes) of the RES parameter (min=4; max
+ = 16).
+ resParameter - The RES parameter as calculated and returned by the
+ UICC.
+ auts - The AUTS parameter as calculated and returned by the
+ UICC.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiNmeUmtsAuthResult result;
+ CsrUint8 umtsCipherKey[16];
+ CsrUint8 umtsIntegrityKey[16];
+ CsrUint8 resParameterLength;
+ CsrUint8 *resParameter;
+ CsrUint8 auts[14];
+} CsrWifiNmeSimUmtsAuthRes;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsConfigSetReq
+
+ DESCRIPTION
+ This primitive passes the WPS information for the device to NME. This may
+ be accepted only if no interface is active.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ wpsConfig - WPS config.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeWpsConfig wpsConfig;
+} CsrWifiNmeWpsConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeEventMaskSetReq
+
+ DESCRIPTION
+ The wireless manager application may register with the NME to receive
+ notification of interesting events. Indications will be sent only if the
+ wireless manager explicitly registers to be notified of that event.
+ indMask is a bit mask of values defined in CsrWifiNmeIndicationsMask.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ indMask - Set mask with values from CsrWifiNmeIndications
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiNmeIndicationsMask indMask;
+} CsrWifiNmeEventMaskSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileSetCfm
+
+ DESCRIPTION
+ Reports the status of the NME PROFILE SET REQ; the request will only fail
+ if the details specified in the profile contains an invalid combination
+ of parameters for example specifying the profile as cloaked but not
+ specifying the SSID. The NME doesn't limit the number of profiles that
+ may be created. The NME assumes that the entity configuring it is aware
+ of the appropriate limits.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Indicates the success or otherwise of the requested operation.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiNmeProfileSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileDeleteCfm
+
+ DESCRIPTION
+ Reports the status of the CSR_WIFI_NME_PROFILE_DELETE_REQ.
+ Returns CSR_WIFI_NME_STATUS_NOT_FOUND if there is no matching profile.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Indicates the success or otherwise of the requested operation.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiNmeProfileDeleteCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileDeleteAllCfm
+
+ DESCRIPTION
+ Reports the status of the CSR_WIFI_NME_PROFILE_DELETE_ALL_REQ.
+ Returns always CSR_WIFI_NME_STATUS_SUCCESS.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Indicates the success or otherwise of the requested operation, but
+ in this case it always set to success.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiNmeProfileDeleteAllCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileOrderSetCfm
+
+ DESCRIPTION
+ Confirmation to UNIFI_NME_PROFILE_ORDER_SET.request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Indicates the success or otherwise of the requested
+ operation.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiNmeProfileOrderSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileConnectCfm
+
+ DESCRIPTION
+ Reports the status of the NME PROFILE CONNECT REQ. If unsuccessful the
+ connectAttempt parameters contain details of the APs that the NME
+ attempted to connect to before reporting the failure of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an
+ interface
+ status - Indicates the success or otherwise of the requested
+ operation.
+ connectAttemptsCount - This parameter is relevant only if
+ status!=CSR_WIFI_NME_STATUS_SUCCESS.
+ Number of connection attempt elements provided with
+ this primitive
+ connectAttempts - This parameter is relevant only if
+ status!=CSR_WIFI_NME_STATUS_SUCCESS.
+ Points to the list of connection attempt elements
+ provided with this primitive
+ Each element of the list provides information about
+ an AP on which the connection attempt was made and
+ the error that occurred during the attempt.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrUint8 connectAttemptsCount;
+ CsrWifiNmeConnectAttempt *connectAttempts;
+} CsrWifiNmeProfileConnectCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsCfm
+
+ DESCRIPTION
+ Reports the status of the NME WPS REQ.
+ If CSR_WIFI_NME_STATUS_SUCCESS, the profile parameter contains the
+ identity and credentials of the AP.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Indicates the success or otherwise of the requested
+ operation.
+ profile - This parameter is relevant only if
+ status==CSR_WIFI_NME_STATUS_SUCCESS.
+ The identity and credentials of the network.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiNmeProfile profile;
+} CsrWifiNmeWpsCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsCancelCfm
+
+ DESCRIPTION
+ Reports the status of the NME WPS REQ, the request is always SUCCESSFUL.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Only returns CSR_WIFI_NME_STATUS_SUCCESS
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiNmeWpsCancelCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeConnectionStatusGetCfm
+
+ DESCRIPTION
+ Reports the connection status of the NME.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Indicates the success or otherwise of the requested
+ operation.
+ connectionStatus - NME current connection status
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiNmeConnectionStatus connectionStatus;
+} CsrWifiNmeConnectionStatusGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileUpdateInd
+
+ DESCRIPTION
+ Indication generated from the NME (if an application subscribes to
+ receive it) that informs that application that the contained profile has
+ changed.
+ For example, either the credentials EAP-FAST PAC file or the session data
+ within the profile has changed.
+ It is up to the application whether it stores this updated profile or
+ not.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ profile - The identity and credentials of the network.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiNmeProfile profile;
+} CsrWifiNmeProfileUpdateInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeProfileDisconnectInd
+
+ DESCRIPTION
+ Indication generated from the NME (if an application subscribes to
+ receive it) that informs that application that the current profile
+ connection has disconnected. The indication will contain information
+ about APs that it attempted to maintain the connection via i.e. in the
+ case of failed roaming.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an
+ interface
+ connectAttemptsCount - Number of connection attempt elements provided with
+ this primitive
+ connectAttempts - Points to the list of connection attempt elements
+ provided with this primitive
+ Each element of the list provides information about
+ an AP on which the connection attempt was made and
+ the error occurred during the attempt.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 connectAttemptsCount;
+ CsrWifiNmeConnectAttempt *connectAttempts;
+} CsrWifiNmeProfileDisconnectInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimImsiGetInd
+
+ DESCRIPTION
+ Indication generated from the NME (if an application subscribes to
+ receive it) that requests the IMSI and UICC type from the UICC Manager.
+ This indication is generated when the NME is attempting to connect to a
+ profile configured for EAP-SIM/AKA. An application MUST register to
+ receive this indication for the NME to support the EAP-SIM/AKA credential
+ types. Otherwise the NME has no route to obtain the information from the
+ UICC.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiNmeSimImsiGetInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimGsmAuthInd
+
+ DESCRIPTION
+ Indication generated from the NME (if an application subscribes to
+ receive it) that requests the UICC Manager to perform a GSM
+ authentication on behalf of the NME. This indication is generated when
+ the NME is attempting to connect to a profile configured for EAP-SIM. An
+ application MUST register to receive this indication for the NME to
+ support the EAP-SIM credential types. Otherwise the NME has no route to
+ obtain the information from the UICC. EAP-SIM authentication requires 2
+ or 3 GSM authentication rounds and therefore 2 or 3 RANDS (GSM Random
+ Challenges) are included.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ randsLength - GSM RAND is 16 bytes long hence valid values are 32 (2 RANDS)
+ or 48 (3 RANDs).
+ rands - 2 or 3 RANDs values.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint8 randsLength;
+ CsrUint8 *rands;
+} CsrWifiNmeSimGsmAuthInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeSimUmtsAuthInd
+
+ DESCRIPTION
+ Indication generated from the NME (if an application subscribes to
+ receive it) that requests the UICC Manager to perform a UMTS
+ authentication on behalf of the NME. This indication is generated when
+ the NME is attempting to connect to a profile configured for EAP-AKA. An
+ application MUST register to receive this indication for the NME to
+ support the EAP-AKA credential types. Otherwise the NME has no route to
+ obtain the information from the USIM. EAP-AKA requires one UMTS
+ authentication round and therefore only one RAND and one AUTN values are
+ included.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ rand - UMTS RAND value.
+ autn - UMTS AUTN value.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint8 rand[16];
+ CsrUint8 autn[16];
+} CsrWifiNmeSimUmtsAuthInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeWpsConfigSetCfm
+
+ DESCRIPTION
+ Confirm.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Status of the request.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiNmeWpsConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiNmeEventMaskSetCfm
+
+ DESCRIPTION
+ The NME calls the primitive to report the result of the request
+ primitive.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiNmeEventMaskSetCfm;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_NME_PRIM_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_NME_SERIALIZE_H__
+#define CSR_WIFI_NME_SERIALIZE_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_wifi_msgconv.h"
+
+#include "csr_wifi_nme_prim.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_NME_ENABLE
+#error CSR_WIFI_NME_ENABLE MUST be defined inorder to use csr_wifi_nme_serialize.h
+#endif
+
+extern void CsrWifiNmePfree(void *ptr);
+
+extern CsrUint8* CsrWifiNmeProfileSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeProfileSetReqSizeof(void *msg);
+extern void CsrWifiNmeProfileSetReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiNmeProfileDeleteReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileDeleteReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeProfileDeleteReqSizeof(void *msg);
+#define CsrWifiNmeProfileDeleteReqSerFree CsrWifiNmePfree
+
+#define CsrWifiNmeProfileDeleteAllReqSer CsrWifiEventSer
+#define CsrWifiNmeProfileDeleteAllReqDes CsrWifiEventDes
+#define CsrWifiNmeProfileDeleteAllReqSizeof CsrWifiEventSizeof
+#define CsrWifiNmeProfileDeleteAllReqSerFree CsrWifiNmePfree
+
+extern CsrUint8* CsrWifiNmeProfileOrderSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileOrderSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeProfileOrderSetReqSizeof(void *msg);
+extern void CsrWifiNmeProfileOrderSetReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiNmeProfileConnectReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileConnectReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeProfileConnectReqSizeof(void *msg);
+#define CsrWifiNmeProfileConnectReqSerFree CsrWifiNmePfree
+
+extern CsrUint8* CsrWifiNmeWpsReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeWpsReqSizeof(void *msg);
+#define CsrWifiNmeWpsReqSerFree CsrWifiNmePfree
+
+#define CsrWifiNmeWpsCancelReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiNmeWpsCancelReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiNmeWpsCancelReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiNmeWpsCancelReqSerFree CsrWifiNmePfree
+
+#define CsrWifiNmeConnectionStatusGetReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiNmeConnectionStatusGetReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiNmeConnectionStatusGetReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiNmeConnectionStatusGetReqSerFree CsrWifiNmePfree
+
+extern CsrUint8* CsrWifiNmeSimImsiGetResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimImsiGetResDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeSimImsiGetResSizeof(void *msg);
+extern void CsrWifiNmeSimImsiGetResSerFree(void *msg);
+
+extern CsrUint8* CsrWifiNmeSimGsmAuthResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimGsmAuthResDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeSimGsmAuthResSizeof(void *msg);
+extern void CsrWifiNmeSimGsmAuthResSerFree(void *msg);
+
+extern CsrUint8* CsrWifiNmeSimUmtsAuthResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimUmtsAuthResDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeSimUmtsAuthResSizeof(void *msg);
+extern void CsrWifiNmeSimUmtsAuthResSerFree(void *msg);
+
+extern CsrUint8* CsrWifiNmeWpsConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeWpsConfigSetReqSizeof(void *msg);
+extern void CsrWifiNmeWpsConfigSetReqSerFree(void *msg);
+
+#define CsrWifiNmeEventMaskSetReqSer CsrWifiEventCsrUint32Ser
+#define CsrWifiNmeEventMaskSetReqDes CsrWifiEventCsrUint32Des
+#define CsrWifiNmeEventMaskSetReqSizeof CsrWifiEventCsrUint32Sizeof
+#define CsrWifiNmeEventMaskSetReqSerFree CsrWifiNmePfree
+
+#define CsrWifiNmeProfileSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiNmeProfileSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiNmeProfileSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiNmeProfileSetCfmSerFree CsrWifiNmePfree
+
+#define CsrWifiNmeProfileDeleteCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiNmeProfileDeleteCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiNmeProfileDeleteCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiNmeProfileDeleteCfmSerFree CsrWifiNmePfree
+
+#define CsrWifiNmeProfileDeleteAllCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiNmeProfileDeleteAllCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiNmeProfileDeleteAllCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiNmeProfileDeleteAllCfmSerFree CsrWifiNmePfree
+
+extern CsrUint8* CsrWifiNmeProfileOrderSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileOrderSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeProfileOrderSetCfmSizeof(void *msg);
+#define CsrWifiNmeProfileOrderSetCfmSerFree CsrWifiNmePfree
+
+extern CsrUint8* CsrWifiNmeProfileConnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileConnectCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeProfileConnectCfmSizeof(void *msg);
+extern void CsrWifiNmeProfileConnectCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiNmeWpsCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeWpsCfmSizeof(void *msg);
+extern void CsrWifiNmeWpsCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiNmeWpsCancelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeWpsCancelCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeWpsCancelCfmSizeof(void *msg);
+#define CsrWifiNmeWpsCancelCfmSerFree CsrWifiNmePfree
+
+extern CsrUint8* CsrWifiNmeConnectionStatusGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeConnectionStatusGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeConnectionStatusGetCfmSizeof(void *msg);
+#define CsrWifiNmeConnectionStatusGetCfmSerFree CsrWifiNmePfree
+
+extern CsrUint8* CsrWifiNmeProfileUpdateIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileUpdateIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeProfileUpdateIndSizeof(void *msg);
+extern void CsrWifiNmeProfileUpdateIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiNmeProfileDisconnectIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeProfileDisconnectIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeProfileDisconnectIndSizeof(void *msg);
+extern void CsrWifiNmeProfileDisconnectIndSerFree(void *msg);
+
+#define CsrWifiNmeSimImsiGetIndSer CsrWifiEventSer
+#define CsrWifiNmeSimImsiGetIndDes CsrWifiEventDes
+#define CsrWifiNmeSimImsiGetIndSizeof CsrWifiEventSizeof
+#define CsrWifiNmeSimImsiGetIndSerFree CsrWifiNmePfree
+
+extern CsrUint8* CsrWifiNmeSimGsmAuthIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimGsmAuthIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeSimGsmAuthIndSizeof(void *msg);
+extern void CsrWifiNmeSimGsmAuthIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiNmeSimUmtsAuthIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiNmeSimUmtsAuthIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiNmeSimUmtsAuthIndSizeof(void *msg);
+#define CsrWifiNmeSimUmtsAuthIndSerFree CsrWifiNmePfree
+
+#define CsrWifiNmeWpsConfigSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiNmeWpsConfigSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiNmeWpsConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiNmeWpsConfigSetCfmSerFree CsrWifiNmePfree
+
+#define CsrWifiNmeEventMaskSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiNmeEventMaskSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiNmeEventMaskSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiNmeEventMaskSetCfmSerFree CsrWifiNmePfree
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* CSR_WIFI_NME_SERIALIZE_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_NME_TASK_H__
+#define CSR_WIFI_NME_TASK_H__
+
+#include "csr_types.h"
+#include "csr_sched.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_NME_ENABLE
+#error CSR_WIFI_NME_ENABLE MUST be defined inorder to use csr_wifi_nme_task.h
+#endif
+
+#define CSR_WIFI_NME_LOG_ID 0x1203FFFF
+extern CsrSchedQid CSR_WIFI_NME_IFACEQUEUE;
+void CsrWifiNmeInit(void **gash);
+void CsrWifiNmeDeinit(void **gash);
+void CsrWifiNmeHandler(void **gash);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_NME_TASK_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifndef CSR_WIFI_PRIVATE_COMMON_H__
+#define CSR_WIFI_PRIVATE_COMMON_H__
+
+#include "csr_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief maximum number of STAs allowed to be connected
+ *
+ * @par Description
+ * min & max Beacon Interval
+ */
+#define CSR_WIFI_AP_MAX_ASSOC_STA 8
+
+/** Number of only b rates */
+#define CSR_WIFI_SME_AP_MAX_ONLY_B_RATES 4
+
+
+/** Number of mandatory b rates */
+#define CSR_WIFI_SME_AP_MAX_MANDATORY_B_RATES 2
+
+
+/** Number of mandatory bg rates */
+#define CSR_WIFI_SME_AP_MAX_MANDATORY_BG_RATES 4
+
+
+/** Number of bg rates */
+#define CSR_WIFI_SME_AP_MAX_BG_RATES 12
+
+
+/** Number of no b only g rates */
+#define CSR_WIFI_SME_AP_MAX_NO_B_ONLY_G_RATES 8
+
+
+/** Number of mandatory g rates */
+#define CSR_WIFI_SME_AP_MAX_MANDATORY_G_RATES 7
+
+
+/* Number of g mandatory rates */
+#define CSR_WIFI_SME_AP_G_MANDATORY_RATES_NUM 7
+
+
+/* Number of b mandatory rates */
+#define CSR_WIFI_SME_AP_B_MANDATORY_RATES_NUM 2
+
+
+/* Number of b/g mandatory rates */
+#define CSR_WIFI_SME_AP_BG_MANDATORY_RATES_NUM 4
+
+
+/* The maximum allowed length of SSID */
+#define CSR_WIFI_SME_AP_SSID_MAX_LENGTH 32
+
+/* Refer 8.4.2.27 RSN element - we support TKIP, WPA2, WAPI and PSK only, no pmkid, group cipher suite */
+#define CSR_WIFI_SME_RSN_PACKED_SIZE (1 + 1 + 2 + 4 + 2 + 4 * 2 + 2 + 4 * 1 + 2 + 24)
+
+/* Refer 7.3.2.9 (ISO/IEC 8802-11:2006) WAPI element - we support WAPI PSK only, no bkid, group cipher suite */
+#define CSR_WIFI_SME_WAPI_PACKED_SIZE (1 + 1 + 2 + 2 + 4 * 1 + 2 + 4 * 1 + 4 + 2 + 24)
+
+
+/* Common structure for NME and SME to maintain Interface mode*/
+typedef CsrUint8 CsrWifiInterfaceMode;
+#define CSR_WIFI_MODE_NONE ((CsrWifiInterfaceMode) 0xFF)
+#define CSR_WIFI_MODE_STA ((CsrWifiInterfaceMode) 0x00)
+#define CSR_WIFI_MODE_AP ((CsrWifiInterfaceMode) 0x01)
+#define CSR_WIFI_MODE_P2P_DEVICE ((CsrWifiInterfaceMode) 0x02)
+#define CSR_WIFI_MODE_P2P_CLI ((CsrWifiInterfaceMode) 0x03)
+#define CSR_WIFI_MODE_P2P_GO ((CsrWifiInterfaceMode) 0x04)
+#define CSR_WIFI_MODE_AMP ((CsrWifiInterfaceMode) 0x05)
+#define CSR_WIFI_MODE_WPS_ENROLLEE ((CsrWifiInterfaceMode) 0x06)
+#define CSR_WIFI_MODE_IBSS ((CsrWifiInterfaceMode) 0x07)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifndef CSR_WIFI_RESULT_H__
+#define CSR_WIFI_RESULT_H__
+
+#include "csr_types.h"
+#include "csr_result.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* THIS FILE SHOULD CONTAIN ONLY RESULT CODES */
+
+/* Result Codes */
+#define CSR_WIFI_HIP_RESULT_INVALID_VALUE ((CsrResult) 1) /* Invalid argument value */
+#define CSR_WIFI_HIP_RESULT_NO_DEVICE ((CsrResult) 2) /* The specified device is no longer present */
+#define CSR_WIFI_HIP_RESULT_NO_SPACE ((CsrResult) 3) /* A queue or buffer is full */
+#define CSR_WIFI_HIP_RESULT_NO_MEMORY ((CsrResult) 4) /* Fatal error, no memory */
+#define CSR_WIFI_HIP_RESULT_RANGE ((CsrResult) 5) /* Request exceeds the range of a file or a buffer */
+#define CSR_WIFI_HIP_RESULT_NOT_FOUND ((CsrResult) 6) /* A file (typically a f/w patch) is not found */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_RESULT_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_msgconv.h"
+#include "csr_pmem.h"
+#include "csr_util.h"
+
+
+#ifdef CSR_LOG_ENABLE
+#include "csr_log.h"
+#endif
+
+#ifndef EXCLUDE_CSR_WIFI_ROUTER_MODULE
+#include "csr_wifi_router_serialize.h"
+#include "csr_wifi_router_prim.h"
+
+static CsrMsgConvMsgEntry csrwifirouter_conv_lut[] = {
+ { CSR_WIFI_ROUTER_MA_PACKET_SUBSCRIBE_REQ, CsrWifiRouterMaPacketSubscribeReqSizeof, CsrWifiRouterMaPacketSubscribeReqSer, CsrWifiRouterMaPacketSubscribeReqDes, CsrWifiRouterMaPacketSubscribeReqSerFree },
+ { CSR_WIFI_ROUTER_MA_PACKET_UNSUBSCRIBE_REQ, CsrWifiRouterMaPacketUnsubscribeReqSizeof, CsrWifiRouterMaPacketUnsubscribeReqSer, CsrWifiRouterMaPacketUnsubscribeReqDes, CsrWifiRouterMaPacketUnsubscribeReqSerFree },
+ { CSR_WIFI_ROUTER_MA_PACKET_REQ, CsrWifiRouterMaPacketReqSizeof, CsrWifiRouterMaPacketReqSer, CsrWifiRouterMaPacketReqDes, CsrWifiRouterMaPacketReqSerFree },
+ { CSR_WIFI_ROUTER_MA_PACKET_RES, CsrWifiRouterMaPacketResSizeof, CsrWifiRouterMaPacketResSer, CsrWifiRouterMaPacketResDes, CsrWifiRouterMaPacketResSerFree },
+ { CSR_WIFI_ROUTER_MA_PACKET_CANCEL_REQ, CsrWifiRouterMaPacketCancelReqSizeof, CsrWifiRouterMaPacketCancelReqSer, CsrWifiRouterMaPacketCancelReqDes, CsrWifiRouterMaPacketCancelReqSerFree },
+ { CSR_WIFI_ROUTER_MA_PACKET_SUBSCRIBE_CFM, CsrWifiRouterMaPacketSubscribeCfmSizeof, CsrWifiRouterMaPacketSubscribeCfmSer, CsrWifiRouterMaPacketSubscribeCfmDes, CsrWifiRouterMaPacketSubscribeCfmSerFree },
+ { CSR_WIFI_ROUTER_MA_PACKET_UNSUBSCRIBE_CFM, CsrWifiRouterMaPacketUnsubscribeCfmSizeof, CsrWifiRouterMaPacketUnsubscribeCfmSer, CsrWifiRouterMaPacketUnsubscribeCfmDes, CsrWifiRouterMaPacketUnsubscribeCfmSerFree },
+ { CSR_WIFI_ROUTER_MA_PACKET_CFM, CsrWifiRouterMaPacketCfmSizeof, CsrWifiRouterMaPacketCfmSer, CsrWifiRouterMaPacketCfmDes, CsrWifiRouterMaPacketCfmSerFree },
+ { CSR_WIFI_ROUTER_MA_PACKET_IND, CsrWifiRouterMaPacketIndSizeof, CsrWifiRouterMaPacketIndSer, CsrWifiRouterMaPacketIndDes, CsrWifiRouterMaPacketIndSerFree },
+
+ { 0, NULL, NULL, NULL, NULL },
+};
+
+CsrMsgConvMsgEntry* CsrWifiRouterConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+{
+ if (msgType & CSR_PRIM_UPSTREAM)
+ {
+ CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT;
+ if (idx < (CSR_WIFI_ROUTER_PRIM_UPSTREAM_COUNT + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT) &&
+ csrwifirouter_conv_lut[idx].msgType == msgType)
+ {
+ return &csrwifirouter_conv_lut[idx];
+ }
+ }
+ else
+ {
+ if (msgType < CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT &&
+ csrwifirouter_conv_lut[msgType].msgType == msgType)
+ {
+ return &csrwifirouter_conv_lut[msgType];
+ }
+ }
+ return NULL;
+}
+
+
+void CsrWifiRouterConverterInit(void)
+{
+ CsrMsgConvInsert(CSR_WIFI_ROUTER_PRIM, csrwifirouter_conv_lut);
+ CsrMsgConvCustomLookupRegister(CSR_WIFI_ROUTER_PRIM, CsrWifiRouterConverterLookup);
+}
+
+
+#ifdef CSR_LOG_ENABLE
+static const CsrLogPrimitiveInformation csrwifirouter_conv_info = {
+ CSR_WIFI_ROUTER_PRIM,
+ (CsrCharString *)"CSR_WIFI_ROUTER_PRIM",
+ csrwifirouter_conv_lut
+};
+const CsrLogPrimitiveInformation* CsrWifiRouterTechInfoGet(void)
+{
+ return &csrwifirouter_conv_info;
+}
+
+
+#endif /* CSR_LOG_ENABLE */
+#endif /* EXCLUDE_CSR_WIFI_ROUTER_MODULE */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_ROUTER_CONVERTER_INIT_H__
+#define CSR_WIFI_ROUTER_CONVERTER_INIT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXCLUDE_CSR_WIFI_ROUTER_MODULE
+
+#include "csr_msgconv.h"
+
+#ifdef CSR_LOG_ENABLE
+#include "csr_log.h"
+
+extern const CsrLogPrimitiveInformation* CsrWifiRouterTechInfoGet(void);
+#endif /* CSR_LOG_ENABLE */
+
+extern void CsrWifiRouterConverterInit(void);
+
+#else /* EXCLUDE_CSR_WIFI_ROUTER_MODULE */
+
+#define CsrWifiRouterConverterInit()
+
+#endif /* EXCLUDE_CSR_WIFI_ROUTER_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_CONVERTER_INIT_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_msgconv.h"
+#include "csr_pmem.h"
+#include "csr_util.h"
+
+
+#ifdef CSR_LOG_ENABLE
+#include "csr_log.h"
+#endif
+
+#ifndef EXCLUDE_CSR_WIFI_ROUTER_CTRL_MODULE
+#include "csr_wifi_router_ctrl_serialize.h"
+#include "csr_wifi_router_ctrl_prim.h"
+
+static CsrMsgConvMsgEntry csrwifirouterctrl_conv_lut[] = {
+ { CSR_WIFI_ROUTER_CTRL_CONFIGURE_POWER_MODE_REQ, CsrWifiRouterCtrlConfigurePowerModeReqSizeof, CsrWifiRouterCtrlConfigurePowerModeReqSer, CsrWifiRouterCtrlConfigurePowerModeReqDes, CsrWifiRouterCtrlConfigurePowerModeReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_HIP_REQ, CsrWifiRouterCtrlHipReqSizeof, CsrWifiRouterCtrlHipReqSer, CsrWifiRouterCtrlHipReqDes, CsrWifiRouterCtrlHipReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_REQ, CsrWifiRouterCtrlMediaStatusReqSizeof, CsrWifiRouterCtrlMediaStatusReqSer, CsrWifiRouterCtrlMediaStatusReqDes, CsrWifiRouterCtrlMediaStatusReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_MULTICAST_ADDRESS_RES, CsrWifiRouterCtrlMulticastAddressResSizeof, CsrWifiRouterCtrlMulticastAddressResSer, CsrWifiRouterCtrlMulticastAddressResDes, CsrWifiRouterCtrlMulticastAddressResSerFree },
+ { CSR_WIFI_ROUTER_CTRL_PORT_CONFIGURE_REQ, CsrWifiRouterCtrlPortConfigureReqSizeof, CsrWifiRouterCtrlPortConfigureReqSer, CsrWifiRouterCtrlPortConfigureReqDes, CsrWifiRouterCtrlPortConfigureReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_REQ, CsrWifiRouterCtrlQosControlReqSizeof, CsrWifiRouterCtrlQosControlReqSer, CsrWifiRouterCtrlQosControlReqDes, CsrWifiRouterCtrlQosControlReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_SUSPEND_RES, CsrWifiRouterCtrlSuspendResSizeof, CsrWifiRouterCtrlSuspendResSer, CsrWifiRouterCtrlSuspendResDes, CsrWifiRouterCtrlSuspendResSerFree },
+ { CSR_WIFI_ROUTER_CTRL_TCLAS_ADD_REQ, CsrWifiRouterCtrlTclasAddReqSizeof, CsrWifiRouterCtrlTclasAddReqSer, CsrWifiRouterCtrlTclasAddReqDes, CsrWifiRouterCtrlTclasAddReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_RESUME_RES, CsrWifiRouterCtrlResumeResSizeof, CsrWifiRouterCtrlResumeResSer, CsrWifiRouterCtrlResumeResDes, CsrWifiRouterCtrlResumeResSerFree },
+ { CSR_WIFI_ROUTER_CTRL_RAW_SDIO_DEINITIALISE_REQ, CsrWifiRouterCtrlRawSdioDeinitialiseReqSizeof, CsrWifiRouterCtrlRawSdioDeinitialiseReqSer, CsrWifiRouterCtrlRawSdioDeinitialiseReqDes, CsrWifiRouterCtrlRawSdioDeinitialiseReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_RAW_SDIO_INITIALISE_REQ, CsrWifiRouterCtrlRawSdioInitialiseReqSizeof, CsrWifiRouterCtrlRawSdioInitialiseReqSer, CsrWifiRouterCtrlRawSdioInitialiseReqDes, CsrWifiRouterCtrlRawSdioInitialiseReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_TCLAS_DEL_REQ, CsrWifiRouterCtrlTclasDelReqSizeof, CsrWifiRouterCtrlTclasDelReqSer, CsrWifiRouterCtrlTclasDelReqDes, CsrWifiRouterCtrlTclasDelReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_TRAFFIC_CLASSIFICATION_REQ, CsrWifiRouterCtrlTrafficClassificationReqSizeof, CsrWifiRouterCtrlTrafficClassificationReqSer, CsrWifiRouterCtrlTrafficClassificationReqDes, CsrWifiRouterCtrlTrafficClassificationReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_REQ, CsrWifiRouterCtrlTrafficConfigReqSizeof, CsrWifiRouterCtrlTrafficConfigReqSer, CsrWifiRouterCtrlTrafficConfigReqDes, CsrWifiRouterCtrlTrafficConfigReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WIFI_OFF_REQ, CsrWifiRouterCtrlWifiOffReqSizeof, CsrWifiRouterCtrlWifiOffReqSer, CsrWifiRouterCtrlWifiOffReqDes, CsrWifiRouterCtrlWifiOffReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WIFI_OFF_RES, CsrWifiRouterCtrlWifiOffResSizeof, CsrWifiRouterCtrlWifiOffResSer, CsrWifiRouterCtrlWifiOffResDes, CsrWifiRouterCtrlWifiOffResSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WIFI_ON_REQ, CsrWifiRouterCtrlWifiOnReqSizeof, CsrWifiRouterCtrlWifiOnReqSer, CsrWifiRouterCtrlWifiOnReqDes, CsrWifiRouterCtrlWifiOnReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WIFI_ON_RES, CsrWifiRouterCtrlWifiOnResSizeof, CsrWifiRouterCtrlWifiOnResSer, CsrWifiRouterCtrlWifiOnResDes, CsrWifiRouterCtrlWifiOnResSerFree },
+ { CSR_WIFI_ROUTER_CTRL_M4_TRANSMIT_REQ, CsrWifiRouterCtrlM4TransmitReqSizeof, CsrWifiRouterCtrlM4TransmitReqSer, CsrWifiRouterCtrlM4TransmitReqDes, CsrWifiRouterCtrlM4TransmitReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_MODE_SET_REQ, CsrWifiRouterCtrlModeSetReqSizeof, CsrWifiRouterCtrlModeSetReqSer, CsrWifiRouterCtrlModeSetReqDes, CsrWifiRouterCtrlModeSetReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_PEER_ADD_REQ, CsrWifiRouterCtrlPeerAddReqSizeof, CsrWifiRouterCtrlPeerAddReqSer, CsrWifiRouterCtrlPeerAddReqDes, CsrWifiRouterCtrlPeerAddReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_PEER_DEL_REQ, CsrWifiRouterCtrlPeerDelReqSizeof, CsrWifiRouterCtrlPeerDelReqSer, CsrWifiRouterCtrlPeerDelReqDes, CsrWifiRouterCtrlPeerDelReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_PEER_UPDATE_REQ, CsrWifiRouterCtrlPeerUpdateReqSizeof, CsrWifiRouterCtrlPeerUpdateReqSer, CsrWifiRouterCtrlPeerUpdateReqDes, CsrWifiRouterCtrlPeerUpdateReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_CAPABILITIES_REQ, CsrWifiRouterCtrlCapabilitiesReqSizeof, CsrWifiRouterCtrlCapabilitiesReqSer, CsrWifiRouterCtrlCapabilitiesReqDes, CsrWifiRouterCtrlCapabilitiesReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ENABLE_REQ, CsrWifiRouterCtrlBlockAckEnableReqSizeof, CsrWifiRouterCtrlBlockAckEnableReqSer, CsrWifiRouterCtrlBlockAckEnableReqDes, CsrWifiRouterCtrlBlockAckEnableReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_DISABLE_REQ, CsrWifiRouterCtrlBlockAckDisableReqSizeof, CsrWifiRouterCtrlBlockAckDisableReqSer, CsrWifiRouterCtrlBlockAckDisableReqDes, CsrWifiRouterCtrlBlockAckDisableReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WAPI_RX_PKT_REQ, CsrWifiRouterCtrlWapiRxPktReqSizeof, CsrWifiRouterCtrlWapiRxPktReqSer, CsrWifiRouterCtrlWapiRxPktReqDes, CsrWifiRouterCtrlWapiRxPktReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WAPI_MULTICAST_FILTER_REQ, CsrWifiRouterCtrlWapiMulticastFilterReqSizeof, CsrWifiRouterCtrlWapiMulticastFilterReqSer, CsrWifiRouterCtrlWapiMulticastFilterReqDes, CsrWifiRouterCtrlWapiMulticastFilterReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_FILTER_REQ, CsrWifiRouterCtrlWapiUnicastFilterReqSizeof, CsrWifiRouterCtrlWapiUnicastFilterReqSer, CsrWifiRouterCtrlWapiUnicastFilterReqDes, CsrWifiRouterCtrlWapiUnicastFilterReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_TX_PKT_REQ, CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof, CsrWifiRouterCtrlWapiUnicastTxPktReqSer, CsrWifiRouterCtrlWapiUnicastTxPktReqDes, CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WAPI_FILTER_REQ, CsrWifiRouterCtrlWapiFilterReqSizeof, CsrWifiRouterCtrlWapiFilterReqSer, CsrWifiRouterCtrlWapiFilterReqDes, CsrWifiRouterCtrlWapiFilterReqSerFree },
+ { CSR_WIFI_ROUTER_CTRL_HIP_IND, CsrWifiRouterCtrlHipIndSizeof, CsrWifiRouterCtrlHipIndSer, CsrWifiRouterCtrlHipIndDes, CsrWifiRouterCtrlHipIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_MULTICAST_ADDRESS_IND, CsrWifiRouterCtrlMulticastAddressIndSizeof, CsrWifiRouterCtrlMulticastAddressIndSer, CsrWifiRouterCtrlMulticastAddressIndDes, CsrWifiRouterCtrlMulticastAddressIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_PORT_CONFIGURE_CFM, CsrWifiRouterCtrlPortConfigureCfmSizeof, CsrWifiRouterCtrlPortConfigureCfmSer, CsrWifiRouterCtrlPortConfigureCfmDes, CsrWifiRouterCtrlPortConfigureCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_RESUME_IND, CsrWifiRouterCtrlResumeIndSizeof, CsrWifiRouterCtrlResumeIndSer, CsrWifiRouterCtrlResumeIndDes, CsrWifiRouterCtrlResumeIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_SUSPEND_IND, CsrWifiRouterCtrlSuspendIndSizeof, CsrWifiRouterCtrlSuspendIndSer, CsrWifiRouterCtrlSuspendIndDes, CsrWifiRouterCtrlSuspendIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_TCLAS_ADD_CFM, CsrWifiRouterCtrlTclasAddCfmSizeof, CsrWifiRouterCtrlTclasAddCfmSer, CsrWifiRouterCtrlTclasAddCfmDes, CsrWifiRouterCtrlTclasAddCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_RAW_SDIO_DEINITIALISE_CFM, CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof, CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer, CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes, CsrWifiRouterCtrlRawSdioDeinitialiseCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_RAW_SDIO_INITIALISE_CFM, CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof, CsrWifiRouterCtrlRawSdioInitialiseCfmSer, CsrWifiRouterCtrlRawSdioInitialiseCfmDes, CsrWifiRouterCtrlRawSdioInitialiseCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_TCLAS_DEL_CFM, CsrWifiRouterCtrlTclasDelCfmSizeof, CsrWifiRouterCtrlTclasDelCfmSer, CsrWifiRouterCtrlTclasDelCfmDes, CsrWifiRouterCtrlTclasDelCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_TRAFFIC_PROTOCOL_IND, CsrWifiRouterCtrlTrafficProtocolIndSizeof, CsrWifiRouterCtrlTrafficProtocolIndSer, CsrWifiRouterCtrlTrafficProtocolIndDes, CsrWifiRouterCtrlTrafficProtocolIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_TRAFFIC_SAMPLE_IND, CsrWifiRouterCtrlTrafficSampleIndSizeof, CsrWifiRouterCtrlTrafficSampleIndSer, CsrWifiRouterCtrlTrafficSampleIndDes, CsrWifiRouterCtrlTrafficSampleIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WIFI_OFF_IND, CsrWifiRouterCtrlWifiOffIndSizeof, CsrWifiRouterCtrlWifiOffIndSer, CsrWifiRouterCtrlWifiOffIndDes, CsrWifiRouterCtrlWifiOffIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WIFI_OFF_CFM, CsrWifiRouterCtrlWifiOffCfmSizeof, CsrWifiRouterCtrlWifiOffCfmSer, CsrWifiRouterCtrlWifiOffCfmDes, CsrWifiRouterCtrlWifiOffCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WIFI_ON_IND, CsrWifiRouterCtrlWifiOnIndSizeof, CsrWifiRouterCtrlWifiOnIndSer, CsrWifiRouterCtrlWifiOnIndDes, CsrWifiRouterCtrlWifiOnIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WIFI_ON_CFM, CsrWifiRouterCtrlWifiOnCfmSizeof, CsrWifiRouterCtrlWifiOnCfmSer, CsrWifiRouterCtrlWifiOnCfmDes, CsrWifiRouterCtrlWifiOnCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_M4_READY_TO_SEND_IND, CsrWifiRouterCtrlM4ReadyToSendIndSizeof, CsrWifiRouterCtrlM4ReadyToSendIndSer, CsrWifiRouterCtrlM4ReadyToSendIndDes, CsrWifiRouterCtrlM4ReadyToSendIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_M4_TRANSMITTED_IND, CsrWifiRouterCtrlM4TransmittedIndSizeof, CsrWifiRouterCtrlM4TransmittedIndSer, CsrWifiRouterCtrlM4TransmittedIndDes, CsrWifiRouterCtrlM4TransmittedIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_MIC_FAILURE_IND, CsrWifiRouterCtrlMicFailureIndSizeof, CsrWifiRouterCtrlMicFailureIndSer, CsrWifiRouterCtrlMicFailureIndDes, CsrWifiRouterCtrlMicFailureIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_CONNECTED_IND, CsrWifiRouterCtrlConnectedIndSizeof, CsrWifiRouterCtrlConnectedIndSer, CsrWifiRouterCtrlConnectedIndDes, CsrWifiRouterCtrlConnectedIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_PEER_ADD_CFM, CsrWifiRouterCtrlPeerAddCfmSizeof, CsrWifiRouterCtrlPeerAddCfmSer, CsrWifiRouterCtrlPeerAddCfmDes, CsrWifiRouterCtrlPeerAddCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_PEER_DEL_CFM, CsrWifiRouterCtrlPeerDelCfmSizeof, CsrWifiRouterCtrlPeerDelCfmSer, CsrWifiRouterCtrlPeerDelCfmDes, CsrWifiRouterCtrlPeerDelCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_UNEXPECTED_FRAME_IND, CsrWifiRouterCtrlUnexpectedFrameIndSizeof, CsrWifiRouterCtrlUnexpectedFrameIndSer, CsrWifiRouterCtrlUnexpectedFrameIndDes, CsrWifiRouterCtrlUnexpectedFrameIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_PEER_UPDATE_CFM, CsrWifiRouterCtrlPeerUpdateCfmSizeof, CsrWifiRouterCtrlPeerUpdateCfmSer, CsrWifiRouterCtrlPeerUpdateCfmDes, CsrWifiRouterCtrlPeerUpdateCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_CAPABILITIES_CFM, CsrWifiRouterCtrlCapabilitiesCfmSizeof, CsrWifiRouterCtrlCapabilitiesCfmSer, CsrWifiRouterCtrlCapabilitiesCfmDes, CsrWifiRouterCtrlCapabilitiesCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ENABLE_CFM, CsrWifiRouterCtrlBlockAckEnableCfmSizeof, CsrWifiRouterCtrlBlockAckEnableCfmSer, CsrWifiRouterCtrlBlockAckEnableCfmDes, CsrWifiRouterCtrlBlockAckEnableCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_DISABLE_CFM, CsrWifiRouterCtrlBlockAckDisableCfmSizeof, CsrWifiRouterCtrlBlockAckDisableCfmSer, CsrWifiRouterCtrlBlockAckDisableCfmDes, CsrWifiRouterCtrlBlockAckDisableCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ERROR_IND, CsrWifiRouterCtrlBlockAckErrorIndSizeof, CsrWifiRouterCtrlBlockAckErrorIndSer, CsrWifiRouterCtrlBlockAckErrorIndDes, CsrWifiRouterCtrlBlockAckErrorIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_STA_INACTIVE_IND, CsrWifiRouterCtrlStaInactiveIndSizeof, CsrWifiRouterCtrlStaInactiveIndSer, CsrWifiRouterCtrlStaInactiveIndDes, CsrWifiRouterCtrlStaInactiveIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WAPI_RX_MIC_CHECK_IND, CsrWifiRouterCtrlWapiRxMicCheckIndSizeof, CsrWifiRouterCtrlWapiRxMicCheckIndSer, CsrWifiRouterCtrlWapiRxMicCheckIndDes, CsrWifiRouterCtrlWapiRxMicCheckIndSerFree },
+ { CSR_WIFI_ROUTER_CTRL_MODE_SET_CFM, CsrWifiRouterCtrlModeSetCfmSizeof, CsrWifiRouterCtrlModeSetCfmSer, CsrWifiRouterCtrlModeSetCfmDes, CsrWifiRouterCtrlModeSetCfmSerFree },
+ { CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_TX_ENCRYPT_IND, CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof, CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer, CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes, CsrWifiRouterCtrlWapiUnicastTxEncryptIndSerFree },
+
+ { 0, NULL, NULL, NULL, NULL },
+};
+
+CsrMsgConvMsgEntry* CsrWifiRouterCtrlConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+{
+ if (msgType & CSR_PRIM_UPSTREAM)
+ {
+ CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT;
+ if (idx < (CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_COUNT + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT) &&
+ csrwifirouterctrl_conv_lut[idx].msgType == msgType)
+ {
+ return &csrwifirouterctrl_conv_lut[idx];
+ }
+ }
+ else
+ {
+ if (msgType < CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT &&
+ csrwifirouterctrl_conv_lut[msgType].msgType == msgType)
+ {
+ return &csrwifirouterctrl_conv_lut[msgType];
+ }
+ }
+ return NULL;
+}
+
+
+void CsrWifiRouterCtrlConverterInit(void)
+{
+ CsrMsgConvInsert(CSR_WIFI_ROUTER_CTRL_PRIM, csrwifirouterctrl_conv_lut);
+ CsrMsgConvCustomLookupRegister(CSR_WIFI_ROUTER_CTRL_PRIM, CsrWifiRouterCtrlConverterLookup);
+}
+
+
+#ifdef CSR_LOG_ENABLE
+static const CsrLogPrimitiveInformation csrwifirouterctrl_conv_info = {
+ CSR_WIFI_ROUTER_CTRL_PRIM,
+ (CsrCharString *)"CSR_WIFI_ROUTER_CTRL_PRIM",
+ csrwifirouterctrl_conv_lut
+};
+const CsrLogPrimitiveInformation* CsrWifiRouterCtrlTechInfoGet(void)
+{
+ return &csrwifirouterctrl_conv_info;
+}
+
+
+#endif /* CSR_LOG_ENABLE */
+#endif /* EXCLUDE_CSR_WIFI_ROUTER_CTRL_MODULE */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_ROUTER_CTRL_CONVERTER_INIT_H__
+#define CSR_WIFI_ROUTER_CTRL_CONVERTER_INIT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXCLUDE_CSR_WIFI_ROUTER_CTRL_MODULE
+
+#include "csr_msgconv.h"
+
+#ifdef CSR_LOG_ENABLE
+#include "csr_log.h"
+
+extern const CsrLogPrimitiveInformation* CsrWifiRouterCtrlTechInfoGet(void);
+#endif /* CSR_LOG_ENABLE */
+
+extern void CsrWifiRouterCtrlConverterInit(void);
+
+#else /* EXCLUDE_CSR_WIFI_ROUTER_CTRL_MODULE */
+
+#define CsrWifiRouterCtrlConverterInit()
+
+#endif /* EXCLUDE_CSR_WIFI_ROUTER_CTRL_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_CTRL_CONVERTER_INIT_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_wifi_router_ctrl_prim.h"
+#include "csr_wifi_router_ctrl_lib.h"
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrWifiRouterCtrlFreeDownstreamMessageContents
+ *
+ * DESCRIPTION
+ *
+ *
+ * PARAMETERS
+ * eventClass: only the value CSR_WIFI_ROUTER_CTRL_PRIM will be handled
+ * message: the message to free
+ *----------------------------------------------------------------------------*/
+void CsrWifiRouterCtrlFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+{
+ if (eventClass != CSR_WIFI_ROUTER_CTRL_PRIM)
+ {
+ return;
+ }
+ if (NULL == message)
+ {
+ return;
+ }
+
+ switch (*((CsrWifiRouterCtrlPrim *) message))
+ {
+ case CSR_WIFI_ROUTER_CTRL_HIP_REQ:
+ {
+ CsrWifiRouterCtrlHipReq *p = (CsrWifiRouterCtrlHipReq *)message;
+ CsrPmemFree(p->mlmeCommand);
+ p->mlmeCommand = NULL;
+ CsrPmemFree(p->dataRef1);
+ p->dataRef1 = NULL;
+ CsrPmemFree(p->dataRef2);
+ p->dataRef2 = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_MULTICAST_ADDRESS_RES:
+ {
+ CsrWifiRouterCtrlMulticastAddressRes *p = (CsrWifiRouterCtrlMulticastAddressRes *)message;
+ CsrPmemFree(p->getAddresses);
+ p->getAddresses = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_TCLAS_ADD_REQ:
+ {
+ CsrWifiRouterCtrlTclasAddReq *p = (CsrWifiRouterCtrlTclasAddReq *)message;
+ CsrPmemFree(p->tclas);
+ p->tclas = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_TCLAS_DEL_REQ:
+ {
+ CsrWifiRouterCtrlTclasDelReq *p = (CsrWifiRouterCtrlTclasDelReq *)message;
+ CsrPmemFree(p->tclas);
+ p->tclas = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_WIFI_ON_REQ:
+ {
+ CsrWifiRouterCtrlWifiOnReq *p = (CsrWifiRouterCtrlWifiOnReq *)message;
+ CsrPmemFree(p->data);
+ p->data = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_WIFI_ON_RES:
+ {
+ CsrWifiRouterCtrlWifiOnRes *p = (CsrWifiRouterCtrlWifiOnRes *)message;
+ CsrPmemFree(p->smeVersions.smeBuild);
+ p->smeVersions.smeBuild = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_WAPI_RX_PKT_REQ:
+ {
+ CsrWifiRouterCtrlWapiRxPktReq *p = (CsrWifiRouterCtrlWapiRxPktReq *)message;
+ CsrPmemFree(p->signal);
+ p->signal = NULL;
+ CsrPmemFree(p->data);
+ p->data = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_TX_PKT_REQ:
+ {
+ CsrWifiRouterCtrlWapiUnicastTxPktReq *p = (CsrWifiRouterCtrlWapiUnicastTxPktReq *)message;
+ CsrPmemFree(p->data);
+ p->data = NULL;
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_wifi_router_ctrl_prim.h"
+#include "csr_wifi_router_ctrl_lib.h"
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrWifiRouterCtrlFreeUpstreamMessageContents
+ *
+ * DESCRIPTION
+ *
+ *
+ * PARAMETERS
+ * eventClass: only the value CSR_WIFI_ROUTER_CTRL_PRIM will be handled
+ * message: the message to free
+ *----------------------------------------------------------------------------*/
+void CsrWifiRouterCtrlFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+{
+ if (eventClass != CSR_WIFI_ROUTER_CTRL_PRIM)
+ {
+ return;
+ }
+ if (NULL == message)
+ {
+ return;
+ }
+
+ switch (*((CsrWifiRouterCtrlPrim *) message))
+ {
+ case CSR_WIFI_ROUTER_CTRL_HIP_IND:
+ {
+ CsrWifiRouterCtrlHipInd *p = (CsrWifiRouterCtrlHipInd *)message;
+ CsrPmemFree(p->mlmeCommand);
+ p->mlmeCommand = NULL;
+ CsrPmemFree(p->dataRef1);
+ p->dataRef1 = NULL;
+ CsrPmemFree(p->dataRef2);
+ p->dataRef2 = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_MULTICAST_ADDRESS_IND:
+ {
+ CsrWifiRouterCtrlMulticastAddressInd *p = (CsrWifiRouterCtrlMulticastAddressInd *)message;
+ CsrPmemFree(p->setAddresses);
+ p->setAddresses = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_WIFI_ON_IND:
+ {
+ CsrWifiRouterCtrlWifiOnInd *p = (CsrWifiRouterCtrlWifiOnInd *)message;
+ CsrPmemFree(p->versions.routerBuild);
+ p->versions.routerBuild = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_WAPI_RX_MIC_CHECK_IND:
+ {
+ CsrWifiRouterCtrlWapiRxMicCheckInd *p = (CsrWifiRouterCtrlWapiRxMicCheckInd *)message;
+ CsrPmemFree(p->signal);
+ p->signal = NULL;
+ CsrPmemFree(p->data);
+ p->data = NULL;
+ break;
+ }
+ case CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_TX_ENCRYPT_IND:
+ {
+ CsrWifiRouterCtrlWapiUnicastTxEncryptInd *p = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *)message;
+ CsrPmemFree(p->data);
+ p->data = NULL;
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_ROUTER_CTRL_LIB_H__
+#define CSR_WIFI_ROUTER_CTRL_LIB_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_sched.h"
+#include "csr_util.h"
+#include "csr_msg_transport.h"
+
+#include "csr_wifi_lib.h"
+
+#include "csr_wifi_router_ctrl_prim.h"
+#include "csr_wifi_router_task.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiRouterCtrlFreeUpstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_ROUTER_CTRL upstream message. Does not
+ * free the message itself, and can only be used for upstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_ROUTER_CTRL upstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiRouterCtrlFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiRouterCtrlFreeDownstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_ROUTER_CTRL downstream message. Does not
+ * free the message itself, and can only be used for downstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_ROUTER_CTRL downstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiRouterCtrlFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * Enum to string functions
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiRouterCtrlBlockAckRoleToString(CsrWifiRouterCtrlBlockAckRole value);
+const CsrCharString* CsrWifiRouterCtrlControlIndicationToString(CsrWifiRouterCtrlControlIndication value);
+const CsrCharString* CsrWifiRouterCtrlListActionToString(CsrWifiRouterCtrlListAction value);
+const CsrCharString* CsrWifiRouterCtrlLowPowerModeToString(CsrWifiRouterCtrlLowPowerMode value);
+const CsrCharString* CsrWifiRouterCtrlMediaStatusToString(CsrWifiRouterCtrlMediaStatus value);
+const CsrCharString* CsrWifiRouterCtrlModeToString(CsrWifiRouterCtrlMode value);
+const CsrCharString* CsrWifiRouterCtrlPeerStatusToString(CsrWifiRouterCtrlPeerStatus value);
+const CsrCharString* CsrWifiRouterCtrlPortActionToString(CsrWifiRouterCtrlPortAction value);
+const CsrCharString* CsrWifiRouterCtrlPowersaveTypeToString(CsrWifiRouterCtrlPowersaveType value);
+const CsrCharString* CsrWifiRouterCtrlProtocolDirectionToString(CsrWifiRouterCtrlProtocolDirection value);
+const CsrCharString* CsrWifiRouterCtrlQoSControlToString(CsrWifiRouterCtrlQoSControl value);
+const CsrCharString* CsrWifiRouterCtrlQueueConfigToString(CsrWifiRouterCtrlQueueConfig value);
+const CsrCharString* CsrWifiRouterCtrlTrafficConfigTypeToString(CsrWifiRouterCtrlTrafficConfigType value);
+const CsrCharString* CsrWifiRouterCtrlTrafficPacketTypeToString(CsrWifiRouterCtrlTrafficPacketType value);
+const CsrCharString* CsrWifiRouterCtrlTrafficTypeToString(CsrWifiRouterCtrlTrafficType value);
+
+
+/*----------------------------------------------------------------------------*
+ * CsrPrim Type toString function.
+ * Converts a message type to the String name of the Message
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiRouterCtrlPrimTypeToString(CsrPrim msgType);
+
+/*----------------------------------------------------------------------------*
+ * Lookup arrays for PrimType name Strings
+ *----------------------------------------------------------------------------*/
+extern const CsrCharString *CsrWifiRouterCtrlUpstreamPrimNames[CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_COUNT];
+extern const CsrCharString *CsrWifiRouterCtrlDownstreamPrimNames[CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT];
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckDisableReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ macAddress -
+ trafficStreamID -
+ role -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlBlockAckDisableReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, macAddress__, trafficStreamID__, role__) \
+ msg__ = (CsrWifiRouterCtrlBlockAckDisableReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckDisableReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_DISABLE_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->macAddress = (macAddress__); \
+ msg__->trafficStreamID = (trafficStreamID__); \
+ msg__->role = (role__);
+
+#define CsrWifiRouterCtrlBlockAckDisableReqSendTo(dst__, src__, interfaceTag__, clientData__, macAddress__, trafficStreamID__, role__) \
+ { \
+ CsrWifiRouterCtrlBlockAckDisableReq *msg__; \
+ CsrWifiRouterCtrlBlockAckDisableReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, macAddress__, trafficStreamID__, role__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlBlockAckDisableReqSend(src__, interfaceTag__, clientData__, macAddress__, trafficStreamID__, role__) \
+ CsrWifiRouterCtrlBlockAckDisableReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, macAddress__, trafficStreamID__, role__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckDisableCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlBlockAckDisableCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__) \
+ msg__ = (CsrWifiRouterCtrlBlockAckDisableCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckDisableCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_DISABLE_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlBlockAckDisableCfmSendTo(dst__, src__, clientData__, interfaceTag__, status__) \
+ { \
+ CsrWifiRouterCtrlBlockAckDisableCfm *msg__; \
+ CsrWifiRouterCtrlBlockAckDisableCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlBlockAckDisableCfmSend(dst__, clientData__, interfaceTag__, status__) \
+ CsrWifiRouterCtrlBlockAckDisableCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckEnableReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ macAddress -
+ trafficStreamID -
+ role -
+ bufferSize -
+ timeout -
+ ssn -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlBlockAckEnableReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, macAddress__, trafficStreamID__, role__, bufferSize__, timeout__, ssn__) \
+ msg__ = (CsrWifiRouterCtrlBlockAckEnableReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckEnableReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ENABLE_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->macAddress = (macAddress__); \
+ msg__->trafficStreamID = (trafficStreamID__); \
+ msg__->role = (role__); \
+ msg__->bufferSize = (bufferSize__); \
+ msg__->timeout = (timeout__); \
+ msg__->ssn = (ssn__);
+
+#define CsrWifiRouterCtrlBlockAckEnableReqSendTo(dst__, src__, interfaceTag__, clientData__, macAddress__, trafficStreamID__, role__, bufferSize__, timeout__, ssn__) \
+ { \
+ CsrWifiRouterCtrlBlockAckEnableReq *msg__; \
+ CsrWifiRouterCtrlBlockAckEnableReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, macAddress__, trafficStreamID__, role__, bufferSize__, timeout__, ssn__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlBlockAckEnableReqSend(src__, interfaceTag__, clientData__, macAddress__, trafficStreamID__, role__, bufferSize__, timeout__, ssn__) \
+ CsrWifiRouterCtrlBlockAckEnableReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, macAddress__, trafficStreamID__, role__, bufferSize__, timeout__, ssn__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckEnableCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlBlockAckEnableCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__) \
+ msg__ = (CsrWifiRouterCtrlBlockAckEnableCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckEnableCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ENABLE_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlBlockAckEnableCfmSendTo(dst__, src__, clientData__, interfaceTag__, status__) \
+ { \
+ CsrWifiRouterCtrlBlockAckEnableCfm *msg__; \
+ CsrWifiRouterCtrlBlockAckEnableCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlBlockAckEnableCfmSend(dst__, clientData__, interfaceTag__, status__) \
+ CsrWifiRouterCtrlBlockAckEnableCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckErrorIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ trafficStreamID -
+ peerMacAddress -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlBlockAckErrorIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, trafficStreamID__, peerMacAddress__, status__) \
+ msg__ = (CsrWifiRouterCtrlBlockAckErrorInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckErrorInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ERROR_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->trafficStreamID = (trafficStreamID__); \
+ msg__->peerMacAddress = (peerMacAddress__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlBlockAckErrorIndSendTo(dst__, src__, clientData__, interfaceTag__, trafficStreamID__, peerMacAddress__, status__) \
+ { \
+ CsrWifiRouterCtrlBlockAckErrorInd *msg__; \
+ CsrWifiRouterCtrlBlockAckErrorIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, trafficStreamID__, peerMacAddress__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlBlockAckErrorIndSend(dst__, clientData__, interfaceTag__, trafficStreamID__, peerMacAddress__, status__) \
+ CsrWifiRouterCtrlBlockAckErrorIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, trafficStreamID__, peerMacAddress__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlCapabilitiesReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ clientData -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlCapabilitiesReqCreate(msg__, dst__, src__, clientData__) \
+ msg__ = (CsrWifiRouterCtrlCapabilitiesReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlCapabilitiesReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_CAPABILITIES_REQ, dst__, src__); \
+ msg__->clientData = (clientData__);
+
+#define CsrWifiRouterCtrlCapabilitiesReqSendTo(dst__, src__, clientData__) \
+ { \
+ CsrWifiRouterCtrlCapabilitiesReq *msg__; \
+ CsrWifiRouterCtrlCapabilitiesReqCreate(msg__, dst__, src__, clientData__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlCapabilitiesReqSend(src__, clientData__) \
+ CsrWifiRouterCtrlCapabilitiesReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, clientData__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlCapabilitiesCfmSend
+
+ DESCRIPTION
+ The router sends this primitive to confirm the size of the queues of the
+ HIP.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ commandQueueSize - Size of command queue
+ trafficQueueSize - Size of traffic queue (per AC)
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlCapabilitiesCfmCreate(msg__, dst__, src__, clientData__, commandQueueSize__, trafficQueueSize__) \
+ msg__ = (CsrWifiRouterCtrlCapabilitiesCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlCapabilitiesCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_CAPABILITIES_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->commandQueueSize = (commandQueueSize__); \
+ msg__->trafficQueueSize = (trafficQueueSize__);
+
+#define CsrWifiRouterCtrlCapabilitiesCfmSendTo(dst__, src__, clientData__, commandQueueSize__, trafficQueueSize__) \
+ { \
+ CsrWifiRouterCtrlCapabilitiesCfm *msg__; \
+ CsrWifiRouterCtrlCapabilitiesCfmCreate(msg__, dst__, src__, clientData__, commandQueueSize__, trafficQueueSize__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlCapabilitiesCfmSend(dst__, clientData__, commandQueueSize__, trafficQueueSize__) \
+ CsrWifiRouterCtrlCapabilitiesCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, commandQueueSize__, trafficQueueSize__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlConfigurePowerModeReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ clientData -
+ mode -
+ wakeHost -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlConfigurePowerModeReqCreate(msg__, dst__, src__, clientData__, mode__, wakeHost__) \
+ msg__ = (CsrWifiRouterCtrlConfigurePowerModeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlConfigurePowerModeReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_CONFIGURE_POWER_MODE_REQ, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->mode = (mode__); \
+ msg__->wakeHost = (wakeHost__);
+
+#define CsrWifiRouterCtrlConfigurePowerModeReqSendTo(dst__, src__, clientData__, mode__, wakeHost__) \
+ { \
+ CsrWifiRouterCtrlConfigurePowerModeReq *msg__; \
+ CsrWifiRouterCtrlConfigurePowerModeReqCreate(msg__, dst__, src__, clientData__, mode__, wakeHost__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlConfigurePowerModeReqSend(src__, clientData__, mode__, wakeHost__) \
+ CsrWifiRouterCtrlConfigurePowerModeReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, clientData__, mode__, wakeHost__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlConnectedIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+ peerStatus -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlConnectedIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__, peerStatus__) \
+ msg__ = (CsrWifiRouterCtrlConnectedInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlConnectedInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_CONNECTED_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->peerMacAddress = (peerMacAddress__); \
+ msg__->peerStatus = (peerStatus__);
+
+#define CsrWifiRouterCtrlConnectedIndSendTo(dst__, src__, clientData__, interfaceTag__, peerMacAddress__, peerStatus__) \
+ { \
+ CsrWifiRouterCtrlConnectedInd *msg__; \
+ CsrWifiRouterCtrlConnectedIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__, peerStatus__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlConnectedIndSend(dst__, clientData__, interfaceTag__, peerMacAddress__, peerStatus__) \
+ CsrWifiRouterCtrlConnectedIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, peerMacAddress__, peerStatus__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlHipReqSend
+
+ DESCRIPTION
+ This primitive is used for transferring MLME messages to the HIP.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ mlmeCommandLength - Length of the MLME signal
+ mlmeCommand - Pointer to the MLME signal
+ dataRef1Length - Length of the dataRef1 bulk data
+ dataRef1 - Pointer to the bulk data 1
+ dataRef2Length - Length of the dataRef2 bulk data
+ dataRef2 - Pointer to the bulk data 2
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlHipReqCreate(msg__, dst__, src__, mlmeCommandLength__, mlmeCommand__, dataRef1Length__, dataRef1__, dataRef2Length__, dataRef2__) \
+ msg__ = (CsrWifiRouterCtrlHipReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlHipReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_HIP_REQ, dst__, src__); \
+ msg__->mlmeCommandLength = (mlmeCommandLength__); \
+ msg__->mlmeCommand = (mlmeCommand__); \
+ msg__->dataRef1Length = (dataRef1Length__); \
+ msg__->dataRef1 = (dataRef1__); \
+ msg__->dataRef2Length = (dataRef2Length__); \
+ msg__->dataRef2 = (dataRef2__);
+
+#define CsrWifiRouterCtrlHipReqSendTo(dst__, src__, mlmeCommandLength__, mlmeCommand__, dataRef1Length__, dataRef1__, dataRef2Length__, dataRef2__) \
+ { \
+ CsrWifiRouterCtrlHipReq *msg__; \
+ CsrWifiRouterCtrlHipReqCreate(msg__, dst__, src__, mlmeCommandLength__, mlmeCommand__, dataRef1Length__, dataRef1__, dataRef2Length__, dataRef2__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlHipReqSend(src__, mlmeCommandLength__, mlmeCommand__, dataRef1Length__, dataRef1__, dataRef2Length__, dataRef2__) \
+ CsrWifiRouterCtrlHipReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, mlmeCommandLength__, mlmeCommand__, dataRef1Length__, dataRef1__, dataRef2Length__, dataRef2__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlHipIndSend
+
+ DESCRIPTION
+ This primitive is used for transferring MLME messages from the HIP.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ mlmeCommandLength - Length of the MLME signal
+ mlmeCommand - Pointer to the MLME signal
+ dataRef1Length - Length of the dataRef1 bulk data
+ dataRef1 - Pointer to the bulk data 1
+ dataRef2Length - Length of the dataRef2 bulk data
+ dataRef2 - Pointer to the bulk data 2
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlHipIndCreate(msg__, dst__, src__, mlmeCommandLength__, mlmeCommand__, dataRef1Length__, dataRef1__, dataRef2Length__, dataRef2__) \
+ msg__ = (CsrWifiRouterCtrlHipInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlHipInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_HIP_IND, dst__, src__); \
+ msg__->mlmeCommandLength = (mlmeCommandLength__); \
+ msg__->mlmeCommand = (mlmeCommand__); \
+ msg__->dataRef1Length = (dataRef1Length__); \
+ msg__->dataRef1 = (dataRef1__); \
+ msg__->dataRef2Length = (dataRef2Length__); \
+ msg__->dataRef2 = (dataRef2__);
+
+#define CsrWifiRouterCtrlHipIndSendTo(dst__, src__, mlmeCommandLength__, mlmeCommand__, dataRef1Length__, dataRef1__, dataRef2Length__, dataRef2__) \
+ { \
+ CsrWifiRouterCtrlHipInd *msg__; \
+ CsrWifiRouterCtrlHipIndCreate(msg__, dst__, src__, mlmeCommandLength__, mlmeCommand__, dataRef1Length__, dataRef1__, dataRef2Length__, dataRef2__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlHipIndSend(dst__, mlmeCommandLength__, mlmeCommand__, dataRef1Length__, dataRef1__, dataRef2Length__, dataRef2__) \
+ CsrWifiRouterCtrlHipIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, mlmeCommandLength__, mlmeCommand__, dataRef1Length__, dataRef1__, dataRef2Length__, dataRef2__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlM4ReadyToSendIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlM4ReadyToSendIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__) \
+ msg__ = (CsrWifiRouterCtrlM4ReadyToSendInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4ReadyToSendInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_M4_READY_TO_SEND_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->peerMacAddress = (peerMacAddress__);
+
+#define CsrWifiRouterCtrlM4ReadyToSendIndSendTo(dst__, src__, clientData__, interfaceTag__, peerMacAddress__) \
+ { \
+ CsrWifiRouterCtrlM4ReadyToSendInd *msg__; \
+ CsrWifiRouterCtrlM4ReadyToSendIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlM4ReadyToSendIndSend(dst__, clientData__, interfaceTag__, peerMacAddress__) \
+ CsrWifiRouterCtrlM4ReadyToSendIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, peerMacAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlM4TransmitReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlM4TransmitReqCreate(msg__, dst__, src__, interfaceTag__, clientData__) \
+ msg__ = (CsrWifiRouterCtrlM4TransmitReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4TransmitReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_M4_TRANSMIT_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__);
+
+#define CsrWifiRouterCtrlM4TransmitReqSendTo(dst__, src__, interfaceTag__, clientData__) \
+ { \
+ CsrWifiRouterCtrlM4TransmitReq *msg__; \
+ CsrWifiRouterCtrlM4TransmitReqCreate(msg__, dst__, src__, interfaceTag__, clientData__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlM4TransmitReqSend(src__, interfaceTag__, clientData__) \
+ CsrWifiRouterCtrlM4TransmitReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlM4TransmittedIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlM4TransmittedIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__, status__) \
+ msg__ = (CsrWifiRouterCtrlM4TransmittedInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4TransmittedInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_M4_TRANSMITTED_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->peerMacAddress = (peerMacAddress__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlM4TransmittedIndSendTo(dst__, src__, clientData__, interfaceTag__, peerMacAddress__, status__) \
+ { \
+ CsrWifiRouterCtrlM4TransmittedInd *msg__; \
+ CsrWifiRouterCtrlM4TransmittedIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlM4TransmittedIndSend(dst__, clientData__, interfaceTag__, peerMacAddress__, status__) \
+ CsrWifiRouterCtrlM4TransmittedIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, peerMacAddress__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlMediaStatusReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ mediaStatus -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlMediaStatusReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, mediaStatus__) \
+ msg__ = (CsrWifiRouterCtrlMediaStatusReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMediaStatusReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->mediaStatus = (mediaStatus__);
+
+#define CsrWifiRouterCtrlMediaStatusReqSendTo(dst__, src__, interfaceTag__, clientData__, mediaStatus__) \
+ { \
+ CsrWifiRouterCtrlMediaStatusReq *msg__; \
+ CsrWifiRouterCtrlMediaStatusReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, mediaStatus__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlMediaStatusReqSend(src__, interfaceTag__, clientData__, mediaStatus__) \
+ CsrWifiRouterCtrlMediaStatusReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, mediaStatus__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlMicFailureIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+ unicastPdu -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlMicFailureIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__, unicastPdu__) \
+ msg__ = (CsrWifiRouterCtrlMicFailureInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMicFailureInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_MIC_FAILURE_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->peerMacAddress = (peerMacAddress__); \
+ msg__->unicastPdu = (unicastPdu__);
+
+#define CsrWifiRouterCtrlMicFailureIndSendTo(dst__, src__, clientData__, interfaceTag__, peerMacAddress__, unicastPdu__) \
+ { \
+ CsrWifiRouterCtrlMicFailureInd *msg__; \
+ CsrWifiRouterCtrlMicFailureIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__, unicastPdu__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlMicFailureIndSend(dst__, clientData__, interfaceTag__, peerMacAddress__, unicastPdu__) \
+ CsrWifiRouterCtrlMicFailureIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, peerMacAddress__, unicastPdu__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlModeSetReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ mode -
+ bssid - BSSID of the network the device is going to be a part
+ of
+ protection - Set to TRUE if encryption is enabled for the
+ connection/broadcast frames
+ intraBssDistEnabled - If set to TRUE, intra BSS destribution will be
+ enabled. If set to FALSE, any unicast PDU which does
+ not have the RA as the the local MAC address, shall be
+ ignored. This field is interpreted by the receive if
+ mode is set to CSR_WIFI_ROUTER_CTRL_MODE_P2PGO
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlModeSetReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, mode__, bssid__, protection__, intraBssDistEnabled__) \
+ msg__ = (CsrWifiRouterCtrlModeSetReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlModeSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_MODE_SET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->mode = (mode__); \
+ msg__->bssid = (bssid__); \
+ msg__->protection = (protection__); \
+ msg__->intraBssDistEnabled = (intraBssDistEnabled__);
+
+#define CsrWifiRouterCtrlModeSetReqSendTo(dst__, src__, interfaceTag__, clientData__, mode__, bssid__, protection__, intraBssDistEnabled__) \
+ { \
+ CsrWifiRouterCtrlModeSetReq *msg__; \
+ CsrWifiRouterCtrlModeSetReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, mode__, bssid__, protection__, intraBssDistEnabled__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlModeSetReqSend(src__, interfaceTag__, clientData__, mode__, bssid__, protection__, intraBssDistEnabled__) \
+ CsrWifiRouterCtrlModeSetReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, mode__, bssid__, protection__, intraBssDistEnabled__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlModeSetCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ mode -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlModeSetCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, mode__, status__) \
+ msg__ = (CsrWifiRouterCtrlModeSetCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlModeSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_MODE_SET_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->mode = (mode__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlModeSetCfmSendTo(dst__, src__, clientData__, interfaceTag__, mode__, status__) \
+ { \
+ CsrWifiRouterCtrlModeSetCfm *msg__; \
+ CsrWifiRouterCtrlModeSetCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, mode__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlModeSetCfmSend(dst__, clientData__, interfaceTag__, mode__, status__) \
+ CsrWifiRouterCtrlModeSetCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, mode__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlMulticastAddressIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ action -
+ setAddressesCount -
+ setAddresses -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlMulticastAddressIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \
+ msg__ = (CsrWifiRouterCtrlMulticastAddressInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMulticastAddressInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_MULTICAST_ADDRESS_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->action = (action__); \
+ msg__->setAddressesCount = (setAddressesCount__); \
+ msg__->setAddresses = (setAddresses__);
+
+#define CsrWifiRouterCtrlMulticastAddressIndSendTo(dst__, src__, clientData__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \
+ { \
+ CsrWifiRouterCtrlMulticastAddressInd *msg__; \
+ CsrWifiRouterCtrlMulticastAddressIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, action__, setAddressesCount__, setAddresses__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlMulticastAddressIndSend(dst__, clientData__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \
+ CsrWifiRouterCtrlMulticastAddressIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, action__, setAddressesCount__, setAddresses__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlMulticastAddressResSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ interfaceTag -
+ clientData -
+ status -
+ action -
+ getAddressesCount -
+ getAddresses -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlMulticastAddressResCreate(msg__, dst__, src__, interfaceTag__, clientData__, status__, action__, getAddressesCount__, getAddresses__) \
+ msg__ = (CsrWifiRouterCtrlMulticastAddressRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMulticastAddressRes)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_MULTICAST_ADDRESS_RES, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->status = (status__); \
+ msg__->action = (action__); \
+ msg__->getAddressesCount = (getAddressesCount__); \
+ msg__->getAddresses = (getAddresses__);
+
+#define CsrWifiRouterCtrlMulticastAddressResSendTo(dst__, src__, interfaceTag__, clientData__, status__, action__, getAddressesCount__, getAddresses__) \
+ { \
+ CsrWifiRouterCtrlMulticastAddressRes *msg__; \
+ CsrWifiRouterCtrlMulticastAddressResCreate(msg__, dst__, src__, interfaceTag__, clientData__, status__, action__, getAddressesCount__, getAddresses__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlMulticastAddressResSend(src__, interfaceTag__, clientData__, status__, action__, getAddressesCount__, getAddresses__) \
+ CsrWifiRouterCtrlMulticastAddressResSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, status__, action__, getAddressesCount__, getAddresses__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerAddReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ peerMacAddress -
+ associationId -
+ staInfo -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlPeerAddReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, peerMacAddress__, associationId__, staInfo__) \
+ msg__ = (CsrWifiRouterCtrlPeerAddReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerAddReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_PEER_ADD_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->peerMacAddress = (peerMacAddress__); \
+ msg__->associationId = (associationId__); \
+ msg__->staInfo = (staInfo__);
+
+#define CsrWifiRouterCtrlPeerAddReqSendTo(dst__, src__, interfaceTag__, clientData__, peerMacAddress__, associationId__, staInfo__) \
+ { \
+ CsrWifiRouterCtrlPeerAddReq *msg__; \
+ CsrWifiRouterCtrlPeerAddReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, peerMacAddress__, associationId__, staInfo__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlPeerAddReqSend(src__, interfaceTag__, clientData__, peerMacAddress__, associationId__, staInfo__) \
+ CsrWifiRouterCtrlPeerAddReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, peerMacAddress__, associationId__, staInfo__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerAddCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+ peerRecordHandle -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlPeerAddCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__, peerRecordHandle__, status__) \
+ msg__ = (CsrWifiRouterCtrlPeerAddCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerAddCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_PEER_ADD_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->peerMacAddress = (peerMacAddress__); \
+ msg__->peerRecordHandle = (peerRecordHandle__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlPeerAddCfmSendTo(dst__, src__, clientData__, interfaceTag__, peerMacAddress__, peerRecordHandle__, status__) \
+ { \
+ CsrWifiRouterCtrlPeerAddCfm *msg__; \
+ CsrWifiRouterCtrlPeerAddCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__, peerRecordHandle__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlPeerAddCfmSend(dst__, clientData__, interfaceTag__, peerMacAddress__, peerRecordHandle__, status__) \
+ CsrWifiRouterCtrlPeerAddCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, peerMacAddress__, peerRecordHandle__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerDelReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ peerRecordHandle -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlPeerDelReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, peerRecordHandle__) \
+ msg__ = (CsrWifiRouterCtrlPeerDelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerDelReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_PEER_DEL_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->peerRecordHandle = (peerRecordHandle__);
+
+#define CsrWifiRouterCtrlPeerDelReqSendTo(dst__, src__, interfaceTag__, clientData__, peerRecordHandle__) \
+ { \
+ CsrWifiRouterCtrlPeerDelReq *msg__; \
+ CsrWifiRouterCtrlPeerDelReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, peerRecordHandle__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlPeerDelReqSend(src__, interfaceTag__, clientData__, peerRecordHandle__) \
+ CsrWifiRouterCtrlPeerDelReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, peerRecordHandle__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerDelCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlPeerDelCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__) \
+ msg__ = (CsrWifiRouterCtrlPeerDelCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerDelCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_PEER_DEL_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlPeerDelCfmSendTo(dst__, src__, clientData__, interfaceTag__, status__) \
+ { \
+ CsrWifiRouterCtrlPeerDelCfm *msg__; \
+ CsrWifiRouterCtrlPeerDelCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlPeerDelCfmSend(dst__, clientData__, interfaceTag__, status__) \
+ CsrWifiRouterCtrlPeerDelCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerUpdateReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ peerRecordHandle -
+ powersaveMode -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlPeerUpdateReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, peerRecordHandle__, powersaveMode__) \
+ msg__ = (CsrWifiRouterCtrlPeerUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerUpdateReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_PEER_UPDATE_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->peerRecordHandle = (peerRecordHandle__); \
+ msg__->powersaveMode = (powersaveMode__);
+
+#define CsrWifiRouterCtrlPeerUpdateReqSendTo(dst__, src__, interfaceTag__, clientData__, peerRecordHandle__, powersaveMode__) \
+ { \
+ CsrWifiRouterCtrlPeerUpdateReq *msg__; \
+ CsrWifiRouterCtrlPeerUpdateReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, peerRecordHandle__, powersaveMode__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlPeerUpdateReqSend(src__, interfaceTag__, clientData__, peerRecordHandle__, powersaveMode__) \
+ CsrWifiRouterCtrlPeerUpdateReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, peerRecordHandle__, powersaveMode__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerUpdateCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlPeerUpdateCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__) \
+ msg__ = (CsrWifiRouterCtrlPeerUpdateCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerUpdateCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_PEER_UPDATE_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlPeerUpdateCfmSendTo(dst__, src__, clientData__, interfaceTag__, status__) \
+ { \
+ CsrWifiRouterCtrlPeerUpdateCfm *msg__; \
+ CsrWifiRouterCtrlPeerUpdateCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlPeerUpdateCfmSend(dst__, clientData__, interfaceTag__, status__) \
+ CsrWifiRouterCtrlPeerUpdateCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPortConfigureReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ uncontrolledPortAction -
+ controlledPortAction -
+ macAddress -
+ setProtection -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlPortConfigureReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, uncontrolledPortAction__, controlledPortAction__, macAddress__, setProtection__) \
+ msg__ = (CsrWifiRouterCtrlPortConfigureReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPortConfigureReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_PORT_CONFIGURE_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->uncontrolledPortAction = (uncontrolledPortAction__); \
+ msg__->controlledPortAction = (controlledPortAction__); \
+ msg__->macAddress = (macAddress__); \
+ msg__->setProtection = (setProtection__);
+
+#define CsrWifiRouterCtrlPortConfigureReqSendTo(dst__, src__, interfaceTag__, clientData__, uncontrolledPortAction__, controlledPortAction__, macAddress__, setProtection__) \
+ { \
+ CsrWifiRouterCtrlPortConfigureReq *msg__; \
+ CsrWifiRouterCtrlPortConfigureReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, uncontrolledPortAction__, controlledPortAction__, macAddress__, setProtection__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlPortConfigureReqSend(src__, interfaceTag__, clientData__, uncontrolledPortAction__, controlledPortAction__, macAddress__, setProtection__) \
+ CsrWifiRouterCtrlPortConfigureReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, uncontrolledPortAction__, controlledPortAction__, macAddress__, setProtection__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPortConfigureCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ status -
+ macAddress -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlPortConfigureCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__, macAddress__) \
+ msg__ = (CsrWifiRouterCtrlPortConfigureCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPortConfigureCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_PORT_CONFIGURE_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->macAddress = (macAddress__);
+
+#define CsrWifiRouterCtrlPortConfigureCfmSendTo(dst__, src__, clientData__, interfaceTag__, status__, macAddress__) \
+ { \
+ CsrWifiRouterCtrlPortConfigureCfm *msg__; \
+ CsrWifiRouterCtrlPortConfigureCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__, macAddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlPortConfigureCfmSend(dst__, clientData__, interfaceTag__, status__, macAddress__) \
+ CsrWifiRouterCtrlPortConfigureCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, status__, macAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlQosControlReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ control -
+ queueConfig -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlQosControlReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, control__, queueConfig__) \
+ msg__ = (CsrWifiRouterCtrlQosControlReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlQosControlReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->control = (control__); \
+ msg__->queueConfig = (queueConfig__);
+
+#define CsrWifiRouterCtrlQosControlReqSendTo(dst__, src__, interfaceTag__, clientData__, control__, queueConfig__) \
+ { \
+ CsrWifiRouterCtrlQosControlReq *msg__; \
+ CsrWifiRouterCtrlQosControlReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, control__, queueConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlQosControlReqSend(src__, interfaceTag__, clientData__, control__, queueConfig__) \
+ CsrWifiRouterCtrlQosControlReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, control__, queueConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlRawSdioDeinitialiseReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ clientData -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlRawSdioDeinitialiseReqCreate(msg__, dst__, src__, clientData__) \
+ msg__ = (CsrWifiRouterCtrlRawSdioDeinitialiseReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioDeinitialiseReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_RAW_SDIO_DEINITIALISE_REQ, dst__, src__); \
+ msg__->clientData = (clientData__);
+
+#define CsrWifiRouterCtrlRawSdioDeinitialiseReqSendTo(dst__, src__, clientData__) \
+ { \
+ CsrWifiRouterCtrlRawSdioDeinitialiseReq *msg__; \
+ CsrWifiRouterCtrlRawSdioDeinitialiseReqCreate(msg__, dst__, src__, clientData__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlRawSdioDeinitialiseReqSend(src__, clientData__) \
+ CsrWifiRouterCtrlRawSdioDeinitialiseReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, clientData__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlRawSdioDeinitialiseCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ result -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlRawSdioDeinitialiseCfmCreate(msg__, dst__, src__, clientData__, result__) \
+ msg__ = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioDeinitialiseCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_RAW_SDIO_DEINITIALISE_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->result = (result__);
+
+#define CsrWifiRouterCtrlRawSdioDeinitialiseCfmSendTo(dst__, src__, clientData__, result__) \
+ { \
+ CsrWifiRouterCtrlRawSdioDeinitialiseCfm *msg__; \
+ CsrWifiRouterCtrlRawSdioDeinitialiseCfmCreate(msg__, dst__, src__, clientData__, result__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlRawSdioDeinitialiseCfmSend(dst__, clientData__, result__) \
+ CsrWifiRouterCtrlRawSdioDeinitialiseCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, result__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlRawSdioInitialiseReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ clientData -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlRawSdioInitialiseReqCreate(msg__, dst__, src__, clientData__) \
+ msg__ = (CsrWifiRouterCtrlRawSdioInitialiseReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioInitialiseReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_RAW_SDIO_INITIALISE_REQ, dst__, src__); \
+ msg__->clientData = (clientData__);
+
+#define CsrWifiRouterCtrlRawSdioInitialiseReqSendTo(dst__, src__, clientData__) \
+ { \
+ CsrWifiRouterCtrlRawSdioInitialiseReq *msg__; \
+ CsrWifiRouterCtrlRawSdioInitialiseReqCreate(msg__, dst__, src__, clientData__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlRawSdioInitialiseReqSend(src__, clientData__) \
+ CsrWifiRouterCtrlRawSdioInitialiseReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, clientData__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlRawSdioInitialiseCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ result -
+ byteRead -
+ byteWrite -
+ firmwareDownload -
+ reset -
+ coreDumpPrepare -
+ byteBlockRead -
+ gpRead16 -
+ gpWrite16 -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlRawSdioInitialiseCfmCreate(msg__, dst__, src__, clientData__, result__, byteRead__, byteWrite__, firmwareDownload__, reset__, coreDumpPrepare__, byteBlockRead__, gpRead16__, gpWrite16__) \
+ msg__ = (CsrWifiRouterCtrlRawSdioInitialiseCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioInitialiseCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_RAW_SDIO_INITIALISE_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->result = (result__); \
+ msg__->byteRead = (byteRead__); \
+ msg__->byteWrite = (byteWrite__); \
+ msg__->firmwareDownload = (firmwareDownload__); \
+ msg__->reset = (reset__); \
+ msg__->coreDumpPrepare = (coreDumpPrepare__); \
+ msg__->byteBlockRead = (byteBlockRead__); \
+ msg__->gpRead16 = (gpRead16__); \
+ msg__->gpWrite16 = (gpWrite16__);
+
+#define CsrWifiRouterCtrlRawSdioInitialiseCfmSendTo(dst__, src__, clientData__, result__, byteRead__, byteWrite__, firmwareDownload__, reset__, coreDumpPrepare__, byteBlockRead__, gpRead16__, gpWrite16__) \
+ { \
+ CsrWifiRouterCtrlRawSdioInitialiseCfm *msg__; \
+ CsrWifiRouterCtrlRawSdioInitialiseCfmCreate(msg__, dst__, src__, clientData__, result__, byteRead__, byteWrite__, firmwareDownload__, reset__, coreDumpPrepare__, byteBlockRead__, gpRead16__, gpWrite16__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlRawSdioInitialiseCfmSend(dst__, clientData__, result__, byteRead__, byteWrite__, firmwareDownload__, reset__, coreDumpPrepare__, byteBlockRead__, gpRead16__, gpWrite16__) \
+ CsrWifiRouterCtrlRawSdioInitialiseCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, result__, byteRead__, byteWrite__, firmwareDownload__, reset__, coreDumpPrepare__, byteBlockRead__, gpRead16__, gpWrite16__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlResumeIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ powerMaintained -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlResumeIndCreate(msg__, dst__, src__, clientData__, powerMaintained__) \
+ msg__ = (CsrWifiRouterCtrlResumeInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlResumeInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_RESUME_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->powerMaintained = (powerMaintained__);
+
+#define CsrWifiRouterCtrlResumeIndSendTo(dst__, src__, clientData__, powerMaintained__) \
+ { \
+ CsrWifiRouterCtrlResumeInd *msg__; \
+ CsrWifiRouterCtrlResumeIndCreate(msg__, dst__, src__, clientData__, powerMaintained__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlResumeIndSend(dst__, clientData__, powerMaintained__) \
+ CsrWifiRouterCtrlResumeIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, powerMaintained__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlResumeResSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ clientData -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlResumeResCreate(msg__, dst__, src__, clientData__, status__) \
+ msg__ = (CsrWifiRouterCtrlResumeRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlResumeRes)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_RESUME_RES, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlResumeResSendTo(dst__, src__, clientData__, status__) \
+ { \
+ CsrWifiRouterCtrlResumeRes *msg__; \
+ CsrWifiRouterCtrlResumeResCreate(msg__, dst__, src__, clientData__, status__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlResumeResSend(src__, clientData__, status__) \
+ CsrWifiRouterCtrlResumeResSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, clientData__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlStaInactiveIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ staAddress -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlStaInactiveIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, staAddress__) \
+ msg__ = (CsrWifiRouterCtrlStaInactiveInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlStaInactiveInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_STA_INACTIVE_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->staAddress = (staAddress__);
+
+#define CsrWifiRouterCtrlStaInactiveIndSendTo(dst__, src__, clientData__, interfaceTag__, staAddress__) \
+ { \
+ CsrWifiRouterCtrlStaInactiveInd *msg__; \
+ CsrWifiRouterCtrlStaInactiveIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, staAddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlStaInactiveIndSend(dst__, clientData__, interfaceTag__, staAddress__) \
+ CsrWifiRouterCtrlStaInactiveIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, staAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlSuspendIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ hardSuspend -
+ d3Suspend -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlSuspendIndCreate(msg__, dst__, src__, clientData__, hardSuspend__, d3Suspend__) \
+ msg__ = (CsrWifiRouterCtrlSuspendInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlSuspendInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_SUSPEND_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->hardSuspend = (hardSuspend__); \
+ msg__->d3Suspend = (d3Suspend__);
+
+#define CsrWifiRouterCtrlSuspendIndSendTo(dst__, src__, clientData__, hardSuspend__, d3Suspend__) \
+ { \
+ CsrWifiRouterCtrlSuspendInd *msg__; \
+ CsrWifiRouterCtrlSuspendIndCreate(msg__, dst__, src__, clientData__, hardSuspend__, d3Suspend__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlSuspendIndSend(dst__, clientData__, hardSuspend__, d3Suspend__) \
+ CsrWifiRouterCtrlSuspendIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, hardSuspend__, d3Suspend__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlSuspendResSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ clientData -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlSuspendResCreate(msg__, dst__, src__, clientData__, status__) \
+ msg__ = (CsrWifiRouterCtrlSuspendRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlSuspendRes)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_SUSPEND_RES, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlSuspendResSendTo(dst__, src__, clientData__, status__) \
+ { \
+ CsrWifiRouterCtrlSuspendRes *msg__; \
+ CsrWifiRouterCtrlSuspendResCreate(msg__, dst__, src__, clientData__, status__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlSuspendResSend(src__, clientData__, status__) \
+ CsrWifiRouterCtrlSuspendResSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, clientData__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTclasAddReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ tclasLength -
+ tclas -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlTclasAddReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, tclasLength__, tclas__) \
+ msg__ = (CsrWifiRouterCtrlTclasAddReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasAddReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_TCLAS_ADD_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->tclasLength = (tclasLength__); \
+ msg__->tclas = (tclas__);
+
+#define CsrWifiRouterCtrlTclasAddReqSendTo(dst__, src__, interfaceTag__, clientData__, tclasLength__, tclas__) \
+ { \
+ CsrWifiRouterCtrlTclasAddReq *msg__; \
+ CsrWifiRouterCtrlTclasAddReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, tclasLength__, tclas__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlTclasAddReqSend(src__, interfaceTag__, clientData__, tclasLength__, tclas__) \
+ CsrWifiRouterCtrlTclasAddReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, tclasLength__, tclas__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTclasAddCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlTclasAddCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__) \
+ msg__ = (CsrWifiRouterCtrlTclasAddCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasAddCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_TCLAS_ADD_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlTclasAddCfmSendTo(dst__, src__, clientData__, interfaceTag__, status__) \
+ { \
+ CsrWifiRouterCtrlTclasAddCfm *msg__; \
+ CsrWifiRouterCtrlTclasAddCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlTclasAddCfmSend(dst__, clientData__, interfaceTag__, status__) \
+ CsrWifiRouterCtrlTclasAddCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTclasDelReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ tclasLength -
+ tclas -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlTclasDelReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, tclasLength__, tclas__) \
+ msg__ = (CsrWifiRouterCtrlTclasDelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasDelReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_TCLAS_DEL_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->tclasLength = (tclasLength__); \
+ msg__->tclas = (tclas__);
+
+#define CsrWifiRouterCtrlTclasDelReqSendTo(dst__, src__, interfaceTag__, clientData__, tclasLength__, tclas__) \
+ { \
+ CsrWifiRouterCtrlTclasDelReq *msg__; \
+ CsrWifiRouterCtrlTclasDelReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, tclasLength__, tclas__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlTclasDelReqSend(src__, interfaceTag__, clientData__, tclasLength__, tclas__) \
+ CsrWifiRouterCtrlTclasDelReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, tclasLength__, tclas__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTclasDelCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlTclasDelCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__) \
+ msg__ = (CsrWifiRouterCtrlTclasDelCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasDelCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_TCLAS_DEL_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlTclasDelCfmSendTo(dst__, src__, clientData__, interfaceTag__, status__) \
+ { \
+ CsrWifiRouterCtrlTclasDelCfm *msg__; \
+ CsrWifiRouterCtrlTclasDelCfmCreate(msg__, dst__, src__, clientData__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlTclasDelCfmSend(dst__, clientData__, interfaceTag__, status__) \
+ CsrWifiRouterCtrlTclasDelCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficClassificationReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ trafficType -
+ period -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlTrafficClassificationReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, trafficType__, period__) \
+ msg__ = (CsrWifiRouterCtrlTrafficClassificationReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficClassificationReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_TRAFFIC_CLASSIFICATION_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->trafficType = (trafficType__); \
+ msg__->period = (period__);
+
+#define CsrWifiRouterCtrlTrafficClassificationReqSendTo(dst__, src__, interfaceTag__, clientData__, trafficType__, period__) \
+ { \
+ CsrWifiRouterCtrlTrafficClassificationReq *msg__; \
+ CsrWifiRouterCtrlTrafficClassificationReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, trafficType__, period__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlTrafficClassificationReqSend(src__, interfaceTag__, clientData__, trafficType__, period__) \
+ CsrWifiRouterCtrlTrafficClassificationReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, trafficType__, period__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficConfigReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ clientData -
+ trafficConfigType -
+ config -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlTrafficConfigReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, trafficConfigType__, config__) \
+ msg__ = (CsrWifiRouterCtrlTrafficConfigReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficConfigReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->clientData = (clientData__); \
+ msg__->trafficConfigType = (trafficConfigType__); \
+ msg__->config = (config__);
+
+#define CsrWifiRouterCtrlTrafficConfigReqSendTo(dst__, src__, interfaceTag__, clientData__, trafficConfigType__, config__) \
+ { \
+ CsrWifiRouterCtrlTrafficConfigReq *msg__; \
+ CsrWifiRouterCtrlTrafficConfigReqCreate(msg__, dst__, src__, interfaceTag__, clientData__, trafficConfigType__, config__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlTrafficConfigReqSend(src__, interfaceTag__, clientData__, trafficConfigType__, config__) \
+ CsrWifiRouterCtrlTrafficConfigReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, clientData__, trafficConfigType__, config__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficProtocolIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ packetType -
+ direction -
+ srcAddress -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlTrafficProtocolIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, packetType__, direction__, srcAddress__) \
+ msg__ = (CsrWifiRouterCtrlTrafficProtocolInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficProtocolInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_TRAFFIC_PROTOCOL_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->packetType = (packetType__); \
+ msg__->direction = (direction__); \
+ msg__->srcAddress = (srcAddress__);
+
+#define CsrWifiRouterCtrlTrafficProtocolIndSendTo(dst__, src__, clientData__, interfaceTag__, packetType__, direction__, srcAddress__) \
+ { \
+ CsrWifiRouterCtrlTrafficProtocolInd *msg__; \
+ CsrWifiRouterCtrlTrafficProtocolIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, packetType__, direction__, srcAddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlTrafficProtocolIndSend(dst__, clientData__, interfaceTag__, packetType__, direction__, srcAddress__) \
+ CsrWifiRouterCtrlTrafficProtocolIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, packetType__, direction__, srcAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficSampleIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ stats -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlTrafficSampleIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, stats__) \
+ msg__ = (CsrWifiRouterCtrlTrafficSampleInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficSampleInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_TRAFFIC_SAMPLE_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->stats = (stats__);
+
+#define CsrWifiRouterCtrlTrafficSampleIndSendTo(dst__, src__, clientData__, interfaceTag__, stats__) \
+ { \
+ CsrWifiRouterCtrlTrafficSampleInd *msg__; \
+ CsrWifiRouterCtrlTrafficSampleIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, stats__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlTrafficSampleIndSend(dst__, clientData__, interfaceTag__, stats__) \
+ CsrWifiRouterCtrlTrafficSampleIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, stats__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlUnexpectedFrameIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlUnexpectedFrameIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__) \
+ msg__ = (CsrWifiRouterCtrlUnexpectedFrameInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlUnexpectedFrameInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_UNEXPECTED_FRAME_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->peerMacAddress = (peerMacAddress__);
+
+#define CsrWifiRouterCtrlUnexpectedFrameIndSendTo(dst__, src__, clientData__, interfaceTag__, peerMacAddress__) \
+ { \
+ CsrWifiRouterCtrlUnexpectedFrameInd *msg__; \
+ CsrWifiRouterCtrlUnexpectedFrameIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, peerMacAddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlUnexpectedFrameIndSend(dst__, clientData__, interfaceTag__, peerMacAddress__) \
+ CsrWifiRouterCtrlUnexpectedFrameIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, peerMacAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiFilterReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ isWapiConnected -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWapiFilterReqCreate(msg__, dst__, src__, interfaceTag__, isWapiConnected__) \
+ msg__ = (CsrWifiRouterCtrlWapiFilterReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiFilterReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WAPI_FILTER_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->isWapiConnected = (isWapiConnected__);
+
+#define CsrWifiRouterCtrlWapiFilterReqSendTo(dst__, src__, interfaceTag__, isWapiConnected__) \
+ { \
+ CsrWifiRouterCtrlWapiFilterReq *msg__; \
+ CsrWifiRouterCtrlWapiFilterReqCreate(msg__, dst__, src__, interfaceTag__, isWapiConnected__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWapiFilterReqSend(src__, interfaceTag__, isWapiConnected__) \
+ CsrWifiRouterCtrlWapiFilterReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, isWapiConnected__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiMulticastFilterReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWapiMulticastFilterReqCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiRouterCtrlWapiMulticastFilterReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiMulticastFilterReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WAPI_MULTICAST_FILTER_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlWapiMulticastFilterReqSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiRouterCtrlWapiMulticastFilterReq *msg__; \
+ CsrWifiRouterCtrlWapiMulticastFilterReqCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWapiMulticastFilterReqSend(src__, interfaceTag__, status__) \
+ CsrWifiRouterCtrlWapiMulticastFilterReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiRxMicCheckIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ signalLength -
+ signal -
+ dataLength -
+ data -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWapiRxMicCheckIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, signalLength__, signal__, dataLength__, data__) \
+ msg__ = (CsrWifiRouterCtrlWapiRxMicCheckInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiRxMicCheckInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WAPI_RX_MIC_CHECK_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->signalLength = (signalLength__); \
+ msg__->signal = (signal__); \
+ msg__->dataLength = (dataLength__); \
+ msg__->data = (data__);
+
+#define CsrWifiRouterCtrlWapiRxMicCheckIndSendTo(dst__, src__, clientData__, interfaceTag__, signalLength__, signal__, dataLength__, data__) \
+ { \
+ CsrWifiRouterCtrlWapiRxMicCheckInd *msg__; \
+ CsrWifiRouterCtrlWapiRxMicCheckIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, signalLength__, signal__, dataLength__, data__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWapiRxMicCheckIndSend(dst__, clientData__, interfaceTag__, signalLength__, signal__, dataLength__, data__) \
+ CsrWifiRouterCtrlWapiRxMicCheckIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, signalLength__, signal__, dataLength__, data__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiRxPktReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ signalLength -
+ signal -
+ dataLength -
+ data -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWapiRxPktReqCreate(msg__, dst__, src__, interfaceTag__, signalLength__, signal__, dataLength__, data__) \
+ msg__ = (CsrWifiRouterCtrlWapiRxPktReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiRxPktReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WAPI_RX_PKT_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->signalLength = (signalLength__); \
+ msg__->signal = (signal__); \
+ msg__->dataLength = (dataLength__); \
+ msg__->data = (data__);
+
+#define CsrWifiRouterCtrlWapiRxPktReqSendTo(dst__, src__, interfaceTag__, signalLength__, signal__, dataLength__, data__) \
+ { \
+ CsrWifiRouterCtrlWapiRxPktReq *msg__; \
+ CsrWifiRouterCtrlWapiRxPktReqCreate(msg__, dst__, src__, interfaceTag__, signalLength__, signal__, dataLength__, data__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWapiRxPktReqSend(src__, interfaceTag__, signalLength__, signal__, dataLength__, data__) \
+ CsrWifiRouterCtrlWapiRxPktReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, signalLength__, signal__, dataLength__, data__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiUnicastFilterReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWapiUnicastFilterReqCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiRouterCtrlWapiUnicastFilterReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastFilterReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_FILTER_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlWapiUnicastFilterReqSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiRouterCtrlWapiUnicastFilterReq *msg__; \
+ CsrWifiRouterCtrlWapiUnicastFilterReqCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWapiUnicastFilterReqSend(src__, interfaceTag__, status__) \
+ CsrWifiRouterCtrlWapiUnicastFilterReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiUnicastTxEncryptIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ interfaceTag -
+ dataLength -
+ data -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWapiUnicastTxEncryptIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, dataLength__, data__) \
+ msg__ = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxEncryptInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_TX_ENCRYPT_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->dataLength = (dataLength__); \
+ msg__->data = (data__);
+
+#define CsrWifiRouterCtrlWapiUnicastTxEncryptIndSendTo(dst__, src__, clientData__, interfaceTag__, dataLength__, data__) \
+ { \
+ CsrWifiRouterCtrlWapiUnicastTxEncryptInd *msg__; \
+ CsrWifiRouterCtrlWapiUnicastTxEncryptIndCreate(msg__, dst__, src__, clientData__, interfaceTag__, dataLength__, data__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWapiUnicastTxEncryptIndSend(dst__, clientData__, interfaceTag__, dataLength__, data__) \
+ CsrWifiRouterCtrlWapiUnicastTxEncryptIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, interfaceTag__, dataLength__, data__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiUnicastTxPktReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ dataLength -
+ data -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWapiUnicastTxPktReqCreate(msg__, dst__, src__, interfaceTag__, dataLength__, data__) \
+ msg__ = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxPktReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_TX_PKT_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->dataLength = (dataLength__); \
+ msg__->data = (data__);
+
+#define CsrWifiRouterCtrlWapiUnicastTxPktReqSendTo(dst__, src__, interfaceTag__, dataLength__, data__) \
+ { \
+ CsrWifiRouterCtrlWapiUnicastTxPktReq *msg__; \
+ CsrWifiRouterCtrlWapiUnicastTxPktReqCreate(msg__, dst__, src__, interfaceTag__, dataLength__, data__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWapiUnicastTxPktReqSend(src__, interfaceTag__, dataLength__, data__) \
+ CsrWifiRouterCtrlWapiUnicastTxPktReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, dataLength__, data__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOffReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ clientData -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWifiOffReqCreate(msg__, dst__, src__, clientData__) \
+ msg__ = (CsrWifiRouterCtrlWifiOffReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOffReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WIFI_OFF_REQ, dst__, src__); \
+ msg__->clientData = (clientData__);
+
+#define CsrWifiRouterCtrlWifiOffReqSendTo(dst__, src__, clientData__) \
+ { \
+ CsrWifiRouterCtrlWifiOffReq *msg__; \
+ CsrWifiRouterCtrlWifiOffReqCreate(msg__, dst__, src__, clientData__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWifiOffReqSend(src__, clientData__) \
+ CsrWifiRouterCtrlWifiOffReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, clientData__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOffIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ controlIndication -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWifiOffIndCreate(msg__, dst__, src__, clientData__, controlIndication__) \
+ msg__ = (CsrWifiRouterCtrlWifiOffInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOffInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WIFI_OFF_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->controlIndication = (controlIndication__);
+
+#define CsrWifiRouterCtrlWifiOffIndSendTo(dst__, src__, clientData__, controlIndication__) \
+ { \
+ CsrWifiRouterCtrlWifiOffInd *msg__; \
+ CsrWifiRouterCtrlWifiOffIndCreate(msg__, dst__, src__, clientData__, controlIndication__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWifiOffIndSend(dst__, clientData__, controlIndication__) \
+ CsrWifiRouterCtrlWifiOffIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, controlIndication__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOffResSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ clientData -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWifiOffResCreate(msg__, dst__, src__, clientData__) \
+ msg__ = (CsrWifiRouterCtrlWifiOffRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOffRes)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WIFI_OFF_RES, dst__, src__); \
+ msg__->clientData = (clientData__);
+
+#define CsrWifiRouterCtrlWifiOffResSendTo(dst__, src__, clientData__) \
+ { \
+ CsrWifiRouterCtrlWifiOffRes *msg__; \
+ CsrWifiRouterCtrlWifiOffResCreate(msg__, dst__, src__, clientData__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWifiOffResSend(src__, clientData__) \
+ CsrWifiRouterCtrlWifiOffResSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, clientData__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOffCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWifiOffCfmCreate(msg__, dst__, src__, clientData__) \
+ msg__ = (CsrWifiRouterCtrlWifiOffCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOffCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WIFI_OFF_CFM, dst__, src__); \
+ msg__->clientData = (clientData__);
+
+#define CsrWifiRouterCtrlWifiOffCfmSendTo(dst__, src__, clientData__) \
+ { \
+ CsrWifiRouterCtrlWifiOffCfm *msg__; \
+ CsrWifiRouterCtrlWifiOffCfmCreate(msg__, dst__, src__, clientData__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWifiOffCfmSend(dst__, clientData__) \
+ CsrWifiRouterCtrlWifiOffCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOnReqSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ clientData -
+ dataLength - Number of bytes in the buffer pointed to by 'data'
+ data - Pointer to the buffer containing 'dataLength' bytes
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWifiOnReqCreate(msg__, dst__, src__, clientData__, dataLength__, data__) \
+ msg__ = (CsrWifiRouterCtrlWifiOnReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WIFI_ON_REQ, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->dataLength = (dataLength__); \
+ msg__->data = (data__);
+
+#define CsrWifiRouterCtrlWifiOnReqSendTo(dst__, src__, clientData__, dataLength__, data__) \
+ { \
+ CsrWifiRouterCtrlWifiOnReq *msg__; \
+ CsrWifiRouterCtrlWifiOnReqCreate(msg__, dst__, src__, clientData__, dataLength__, data__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWifiOnReqSend(src__, clientData__, dataLength__, data__) \
+ CsrWifiRouterCtrlWifiOnReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, clientData__, dataLength__, data__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOnIndSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ status -
+ versions -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWifiOnIndCreate(msg__, dst__, src__, clientData__, status__, versions__) \
+ msg__ = (CsrWifiRouterCtrlWifiOnInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WIFI_ON_IND, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->status = (status__); \
+ msg__->versions = (versions__);
+
+#define CsrWifiRouterCtrlWifiOnIndSendTo(dst__, src__, clientData__, status__, versions__) \
+ { \
+ CsrWifiRouterCtrlWifiOnInd *msg__; \
+ CsrWifiRouterCtrlWifiOnIndCreate(msg__, dst__, src__, clientData__, status__, versions__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWifiOnIndSend(dst__, clientData__, status__, versions__) \
+ CsrWifiRouterCtrlWifiOnIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, status__, versions__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOnResSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ clientData -
+ status -
+ numInterfaceAddress -
+ stationMacAddress - array size 1 MUST match CSR_WIFI_NUM_INTERFACES
+ smeVersions -
+ scheduledInterrupt -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWifiOnResCreate(msg__, dst__, src__, clientData__, status__, numInterfaceAddress__, stationMacAddress__, smeVersions__, scheduledInterrupt__) \
+ msg__ = (CsrWifiRouterCtrlWifiOnRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnRes)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WIFI_ON_RES, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->status = (status__); \
+ msg__->numInterfaceAddress = (numInterfaceAddress__); \
+ CsrMemCpy(msg__->stationMacAddress, (stationMacAddress__), sizeof(CsrWifiMacAddress) * 2); \
+ msg__->smeVersions = (smeVersions__); \
+ msg__->scheduledInterrupt = (scheduledInterrupt__);
+
+#define CsrWifiRouterCtrlWifiOnResSendTo(dst__, src__, clientData__, status__, numInterfaceAddress__, stationMacAddress__, smeVersions__, scheduledInterrupt__) \
+ { \
+ CsrWifiRouterCtrlWifiOnRes *msg__; \
+ CsrWifiRouterCtrlWifiOnResCreate(msg__, dst__, src__, clientData__, status__, numInterfaceAddress__, stationMacAddress__, smeVersions__, scheduledInterrupt__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWifiOnResSend(src__, clientData__, status__, numInterfaceAddress__, stationMacAddress__, smeVersions__, scheduledInterrupt__) \
+ CsrWifiRouterCtrlWifiOnResSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, clientData__, status__, numInterfaceAddress__, stationMacAddress__, smeVersions__, scheduledInterrupt__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOnCfmSend
+
+ DESCRIPTION
+
+ PARAMETERS
+ queue - Destination Task Queue
+ clientData -
+ status -
+
+*******************************************************************************/
+#define CsrWifiRouterCtrlWifiOnCfmCreate(msg__, dst__, src__, clientData__, status__) \
+ msg__ = (CsrWifiRouterCtrlWifiOnCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_CTRL_PRIM, CSR_WIFI_ROUTER_CTRL_WIFI_ON_CFM, dst__, src__); \
+ msg__->clientData = (clientData__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterCtrlWifiOnCfmSendTo(dst__, src__, clientData__, status__) \
+ { \
+ CsrWifiRouterCtrlWifiOnCfm *msg__; \
+ CsrWifiRouterCtrlWifiOnCfmCreate(msg__, dst__, src__, clientData__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_CTRL_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterCtrlWifiOnCfmSend(dst__, clientData__, status__) \
+ CsrWifiRouterCtrlWifiOnCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, clientData__, status__)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_CTRL_LIB_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_ROUTER_CTRL_PRIM_H__
+#define CSR_WIFI_ROUTER_CTRL_PRIM_H__
+
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+#include "csr_sched.h"
+#include "csr_wifi_common.h"
+#include "csr_result.h"
+#include "csr_wifi_fsm_event.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CSR_WIFI_ROUTER_CTRL_PRIM (0x0401)
+
+typedef CsrPrim CsrWifiRouterCtrlPrim;
+
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteWrite)(CsrUint8 func, CsrUint32 address, CsrUint8 data);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteRead)(CsrUint8 func, CsrUint32 address, CsrUint8 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioFirmwareDownload)(CsrUint32 length, const CsrUint8 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioReset)(void);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioCoreDumpPrepare)(CsrBool suspendSme);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioByteBlockRead)(CsrUint8 func, CsrUint32 address, CsrUint8 *pdata, CsrUint32 length);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpRead16)(CsrUint8 func, CsrUint32 address, CsrUint16 *pdata);
+typedef CsrResult (*CsrWifiRouterCtrlRawSdioGpWrite16)(CsrUint8 func, CsrUint32 address, CsrUint16 data);
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckRole
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ORIGINATOR
+ -
+ CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_RECIPIENT
+ -
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterCtrlBlockAckRole;
+#define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ORIGINATOR ((CsrWifiRouterCtrlBlockAckRole) 0x00)
+#define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_RECIPIENT ((CsrWifiRouterCtrlBlockAckRole) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlControlIndication
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_ERROR
+ -
+ CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_EXIT
+ -
+ CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_USER_REQUESTED
+ -
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterCtrlControlIndication;
+#define CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_ERROR ((CsrWifiRouterCtrlControlIndication) 0x01)
+#define CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_EXIT ((CsrWifiRouterCtrlControlIndication) 0x02)
+#define CSR_WIFI_ROUTER_CTRL_CONTROL_INDICATION_USER_REQUESTED ((CsrWifiRouterCtrlControlIndication) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlListAction
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_LIST_ACTION_GET
+ -
+ CSR_WIFI_ROUTER_CTRL_LIST_ACTION_ADD
+ -
+ CSR_WIFI_ROUTER_CTRL_LIST_ACTION_REMOVE
+ -
+ CSR_WIFI_ROUTER_CTRL_LIST_ACTION_FLUSH
+ -
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterCtrlListAction;
+#define CSR_WIFI_ROUTER_CTRL_LIST_ACTION_GET ((CsrWifiRouterCtrlListAction) 0x00)
+#define CSR_WIFI_ROUTER_CTRL_LIST_ACTION_ADD ((CsrWifiRouterCtrlListAction) 0x01)
+#define CSR_WIFI_ROUTER_CTRL_LIST_ACTION_REMOVE ((CsrWifiRouterCtrlListAction) 0x02)
+#define CSR_WIFI_ROUTER_CTRL_LIST_ACTION_FLUSH ((CsrWifiRouterCtrlListAction) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlLowPowerMode
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_LOW_POWER_MODE_DISABLED
+ -
+ CSR_WIFI_ROUTER_CTRL_LOW_POWER_MODE_ENABLED
+ -
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiRouterCtrlLowPowerMode;
+#define CSR_WIFI_ROUTER_CTRL_LOW_POWER_MODE_DISABLED ((CsrWifiRouterCtrlLowPowerMode) 0x0000)
+#define CSR_WIFI_ROUTER_CTRL_LOW_POWER_MODE_ENABLED ((CsrWifiRouterCtrlLowPowerMode) 0x0001)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlMediaStatus
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_CONNECTED
+ -
+ CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_DISCONNECTED
+ -
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterCtrlMediaStatus;
+#define CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_CONNECTED ((CsrWifiRouterCtrlMediaStatus) 0x00)
+#define CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_DISCONNECTED ((CsrWifiRouterCtrlMediaStatus) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlMode
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_MODE_NONE -
+ CSR_WIFI_ROUTER_CTRL_MODE_IBSS -
+ CSR_WIFI_ROUTER_CTRL_MODE_STA -
+ CSR_WIFI_ROUTER_CTRL_MODE_AP -
+ CSR_WIFI_ROUTER_CTRL_MODE_MONITOR -
+ CSR_WIFI_ROUTER_CTRL_MODE_AMP -
+ CSR_WIFI_ROUTER_CTRL_MODE_P2P -
+ CSR_WIFI_ROUTER_CTRL_MODE_P2PGO -
+ CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI -
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterCtrlMode;
+#define CSR_WIFI_ROUTER_CTRL_MODE_NONE ((CsrWifiRouterCtrlMode) 0x00)
+#define CSR_WIFI_ROUTER_CTRL_MODE_IBSS ((CsrWifiRouterCtrlMode) 0x01)
+#define CSR_WIFI_ROUTER_CTRL_MODE_STA ((CsrWifiRouterCtrlMode) 0x02)
+#define CSR_WIFI_ROUTER_CTRL_MODE_AP ((CsrWifiRouterCtrlMode) 0x03)
+#define CSR_WIFI_ROUTER_CTRL_MODE_MONITOR ((CsrWifiRouterCtrlMode) 0x04)
+#define CSR_WIFI_ROUTER_CTRL_MODE_AMP ((CsrWifiRouterCtrlMode) 0x05)
+#define CSR_WIFI_ROUTER_CTRL_MODE_P2P ((CsrWifiRouterCtrlMode) 0x06)
+#define CSR_WIFI_ROUTER_CTRL_MODE_P2PGO ((CsrWifiRouterCtrlMode) 0x07)
+#define CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI ((CsrWifiRouterCtrlMode) 0x08)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerStatus
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE
+ -
+ CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE
+ -
+ CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED
+ -
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterCtrlPeerStatus;
+#define CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE ((CsrWifiRouterCtrlPeerStatus) 0x00)
+#define CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE ((CsrWifiRouterCtrlPeerStatus) 0x01)
+#define CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED ((CsrWifiRouterCtrlPeerStatus) 0x02)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPortAction
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN
+ -
+ CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD
+ -
+ CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_BLOCK
+ -
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiRouterCtrlPortAction;
+#define CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN ((CsrWifiRouterCtrlPortAction) 0x0000)
+#define CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD ((CsrWifiRouterCtrlPortAction) 0x0001)
+#define CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_BLOCK ((CsrWifiRouterCtrlPortAction) 0x0002)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPowersaveType
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_AC_BK_PS_INFO_PRESENT
+ - If set, AC BK PS info is present in b4 and b5
+ CSR_WIFI_ROUTER_CTRL_AC_BE_PS_INFO_PRESENT
+ - If set, AC BE PS info is present in b6 and b7
+ CSR_WIFI_ROUTER_CTRL_AC_VI_PS_INFO_PRESENT
+ - If set, AC VI PS info is present in b8 and b9
+ CSR_WIFI_ROUTER_CTRL_AC_VO_PS_INFO_PRESENT
+ - If set, AC VO PS info is present in b10 and b11
+ CSR_WIFI_ROUTER_CTRL_AC_BK_TRIGGER_ENABLED
+ -
+ CSR_WIFI_ROUTER_CTRL_AC_BK_DELIVERY_ENABLED
+ -
+ CSR_WIFI_ROUTER_CTRL_AC_BE_TRIGGER_ENABLED
+ -
+ CSR_WIFI_ROUTER_CTRL_AC_BE_DELIVERY_ENABLED
+ -
+ CSR_WIFI_ROUTER_CTRL_AC_VI_TRIGGER_ENABLED
+ -
+ CSR_WIFI_ROUTER_CTRL_AC_VI_DELIVERY_ENABLED
+ -
+ CSR_WIFI_ROUTER_CTRL_AC_VO_TRIGGER_ENABLED
+ -
+ CSR_WIFI_ROUTER_CTRL_AC_VO_DELIVERY_ENABLED
+ -
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiRouterCtrlPowersaveType;
+#define CSR_WIFI_ROUTER_CTRL_AC_BK_PS_INFO_PRESENT ((CsrWifiRouterCtrlPowersaveType) 0x0001)
+#define CSR_WIFI_ROUTER_CTRL_AC_BE_PS_INFO_PRESENT ((CsrWifiRouterCtrlPowersaveType) 0x0002)
+#define CSR_WIFI_ROUTER_CTRL_AC_VI_PS_INFO_PRESENT ((CsrWifiRouterCtrlPowersaveType) 0x0004)
+#define CSR_WIFI_ROUTER_CTRL_AC_VO_PS_INFO_PRESENT ((CsrWifiRouterCtrlPowersaveType) 0x0008)
+#define CSR_WIFI_ROUTER_CTRL_AC_BK_TRIGGER_ENABLED ((CsrWifiRouterCtrlPowersaveType) 0x0010)
+#define CSR_WIFI_ROUTER_CTRL_AC_BK_DELIVERY_ENABLED ((CsrWifiRouterCtrlPowersaveType) 0x0020)
+#define CSR_WIFI_ROUTER_CTRL_AC_BE_TRIGGER_ENABLED ((CsrWifiRouterCtrlPowersaveType) 0x0040)
+#define CSR_WIFI_ROUTER_CTRL_AC_BE_DELIVERY_ENABLED ((CsrWifiRouterCtrlPowersaveType) 0x0080)
+#define CSR_WIFI_ROUTER_CTRL_AC_VI_TRIGGER_ENABLED ((CsrWifiRouterCtrlPowersaveType) 0x0100)
+#define CSR_WIFI_ROUTER_CTRL_AC_VI_DELIVERY_ENABLED ((CsrWifiRouterCtrlPowersaveType) 0x0200)
+#define CSR_WIFI_ROUTER_CTRL_AC_VO_TRIGGER_ENABLED ((CsrWifiRouterCtrlPowersaveType) 0x0400)
+#define CSR_WIFI_ROUTER_CTRL_AC_VO_DELIVERY_ENABLED ((CsrWifiRouterCtrlPowersaveType) 0x0800)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlProtocolDirection
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_RX
+ -
+ CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX
+ -
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiRouterCtrlProtocolDirection;
+#define CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_RX ((CsrWifiRouterCtrlProtocolDirection) 0x0000)
+#define CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX ((CsrWifiRouterCtrlProtocolDirection) 0x0001)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlQoSControl
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_OFF
+ -
+ CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_WMM_ON
+ -
+ CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_80211_ON
+ -
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiRouterCtrlQoSControl;
+#define CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_OFF ((CsrWifiRouterCtrlQoSControl) 0x0000)
+#define CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_WMM_ON ((CsrWifiRouterCtrlQoSControl) 0x0001)
+#define CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_80211_ON ((CsrWifiRouterCtrlQoSControl) 0x0002)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlQueueConfig
+
+ DESCRIPTION
+ Defines which Queues are enabled for use.
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_QUEUE_BE_ENABLE
+ -
+ CSR_WIFI_ROUTER_CTRL_QUEUE_BK_ENABLE
+ -
+ CSR_WIFI_ROUTER_CTRL_QUEUE_VI_ENABLE
+ -
+ CSR_WIFI_ROUTER_CTRL_QUEUE_VO_ENABLE
+ -
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterCtrlQueueConfig;
+#define CSR_WIFI_ROUTER_CTRL_QUEUE_BE_ENABLE ((CsrWifiRouterCtrlQueueConfig) 0x01)
+#define CSR_WIFI_ROUTER_CTRL_QUEUE_BK_ENABLE ((CsrWifiRouterCtrlQueueConfig) 0x02)
+#define CSR_WIFI_ROUTER_CTRL_QUEUE_VI_ENABLE ((CsrWifiRouterCtrlQueueConfig) 0x04)
+#define CSR_WIFI_ROUTER_CTRL_QUEUE_VO_ENABLE ((CsrWifiRouterCtrlQueueConfig) 0x08)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficConfigType
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_RESET
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_FILTER
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_CLS
+ -
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiRouterCtrlTrafficConfigType;
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_RESET ((CsrWifiRouterCtrlTrafficConfigType) 0x0000)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_FILTER ((CsrWifiRouterCtrlTrafficConfigType) 0x0001)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_CLS ((CsrWifiRouterCtrlTrafficConfigType) 0x0002)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficPacketType
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_NONE
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_EAPOL
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP_ACK
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_ARP
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_AIRONET
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_ALL
+ -
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiRouterCtrlTrafficPacketType;
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_NONE ((CsrWifiRouterCtrlTrafficPacketType) 0x0000)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_EAPOL ((CsrWifiRouterCtrlTrafficPacketType) 0x0001)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP ((CsrWifiRouterCtrlTrafficPacketType) 0x0002)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP_ACK ((CsrWifiRouterCtrlTrafficPacketType) 0x0004)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_ARP ((CsrWifiRouterCtrlTrafficPacketType) 0x0008)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_AIRONET ((CsrWifiRouterCtrlTrafficPacketType) 0x0010)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM ((CsrWifiRouterCtrlTrafficPacketType) 0x0020)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_ALL ((CsrWifiRouterCtrlTrafficPacketType) 0x00FF)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficType
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_OCCASIONAL
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_BURSTY
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_PERIODIC
+ -
+ CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_CONTINUOUS
+ -
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterCtrlTrafficType;
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_OCCASIONAL ((CsrWifiRouterCtrlTrafficType) 0x00)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_BURSTY ((CsrWifiRouterCtrlTrafficType) 0x01)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_PERIODIC ((CsrWifiRouterCtrlTrafficType) 0x02)
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_CONTINUOUS ((CsrWifiRouterCtrlTrafficType) 0x03)
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerRecordHandle
+
+ DESCRIPTION
+
+*******************************************************************************/
+typedef CsrUint32 CsrWifiRouterCtrlPeerRecordHandle;
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPowersaveTypeMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by
+ CsrWifiRouterCtrlPowersaveType
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiRouterCtrlPowersaveTypeMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlQueueConfigMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiRouterCtrlQueueConfig
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterCtrlQueueConfigMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlRequestorInfo
+
+ DESCRIPTION
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiRouterCtrlRequestorInfo;
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficStreamId
+
+ DESCRIPTION
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterCtrlTrafficStreamId;
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlSmeVersions
+
+ DESCRIPTION
+
+ MEMBERS
+ firmwarePatch -
+ smeBuild -
+ smeHip -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint32 firmwarePatch;
+ CsrCharString *smeBuild;
+ CsrUint32 smeHip;
+} CsrWifiRouterCtrlSmeVersions;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlStaInfo
+
+ DESCRIPTION
+
+ MEMBERS
+ wmmOrQosEnabled -
+ powersaveMode -
+ maxSpLength -
+ listenIntervalInTus -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrBool wmmOrQosEnabled;
+ CsrWifiRouterCtrlPowersaveTypeMask powersaveMode;
+ CsrUint8 maxSpLength;
+ CsrUint16 listenIntervalInTus;
+} CsrWifiRouterCtrlStaInfo;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficFilter
+
+ DESCRIPTION
+
+ MEMBERS
+ etherType -
+ ipType -
+ udpSourcePort -
+ udpDestPort -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint32 etherType;
+ CsrUint8 ipType;
+ CsrUint32 udpSourcePort;
+ CsrUint32 udpDestPort;
+} CsrWifiRouterCtrlTrafficFilter;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficStats
+
+ DESCRIPTION
+
+ MEMBERS
+ rxMeanRate - Mean rx data rate over the interval
+ rxFramesNum - Keep number of Rx frames per second, for CYCLE_3.
+ txFramesNum - Keep number of Tx frames per second, for CYCLE_3.
+ rxBytesCount - Keep calculated Rx throughput per second, for CYCLE_2.
+ txBytesCount - Keep calculated Tx throughput per second, for CYCLE_2.
+ intervals - array size 11 MUST match TA_INTERVALS_NUM
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint32 rxMeanRate;
+ CsrUint32 rxFramesNum;
+ CsrUint32 txFramesNum;
+ CsrUint32 rxBytesCount;
+ CsrUint32 txBytesCount;
+ CsrUint8 intervals[11];
+} CsrWifiRouterCtrlTrafficStats;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlVersions
+
+ DESCRIPTION
+
+ MEMBERS
+ chipId -
+ chipVersion -
+ firmwareBuild -
+ firmwareHip -
+ routerBuild -
+ routerHip -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint32 chipId;
+ CsrUint32 chipVersion;
+ CsrUint32 firmwareBuild;
+ CsrUint32 firmwareHip;
+ CsrCharString *routerBuild;
+ CsrUint32 routerHip;
+} CsrWifiRouterCtrlVersions;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficConfig
+
+ DESCRIPTION
+
+ MEMBERS
+ packetFilter -
+ customFilter -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint16 packetFilter;
+ CsrWifiRouterCtrlTrafficFilter customFilter;
+} CsrWifiRouterCtrlTrafficConfig;
+
+
+/* Downstream */
+#define CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST (0x0000)
+
+#define CSR_WIFI_ROUTER_CTRL_CONFIGURE_POWER_MODE_REQ ((CsrWifiRouterCtrlPrim) (0x0000 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_HIP_REQ ((CsrWifiRouterCtrlPrim) (0x0001 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_MEDIA_STATUS_REQ ((CsrWifiRouterCtrlPrim) (0x0002 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_MULTICAST_ADDRESS_RES ((CsrWifiRouterCtrlPrim) (0x0003 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_PORT_CONFIGURE_REQ ((CsrWifiRouterCtrlPrim) (0x0004 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_REQ ((CsrWifiRouterCtrlPrim) (0x0005 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_SUSPEND_RES ((CsrWifiRouterCtrlPrim) (0x0006 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_TCLAS_ADD_REQ ((CsrWifiRouterCtrlPrim) (0x0007 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_RESUME_RES ((CsrWifiRouterCtrlPrim) (0x0008 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_RAW_SDIO_DEINITIALISE_REQ ((CsrWifiRouterCtrlPrim) (0x0009 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_RAW_SDIO_INITIALISE_REQ ((CsrWifiRouterCtrlPrim) (0x000A + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_TCLAS_DEL_REQ ((CsrWifiRouterCtrlPrim) (0x000B + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CLASSIFICATION_REQ ((CsrWifiRouterCtrlPrim) (0x000C + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_REQ ((CsrWifiRouterCtrlPrim) (0x000D + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WIFI_OFF_REQ ((CsrWifiRouterCtrlPrim) (0x000E + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WIFI_OFF_RES ((CsrWifiRouterCtrlPrim) (0x000F + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WIFI_ON_REQ ((CsrWifiRouterCtrlPrim) (0x0010 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WIFI_ON_RES ((CsrWifiRouterCtrlPrim) (0x0011 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_M4_TRANSMIT_REQ ((CsrWifiRouterCtrlPrim) (0x0012 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_MODE_SET_REQ ((CsrWifiRouterCtrlPrim) (0x0013 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_PEER_ADD_REQ ((CsrWifiRouterCtrlPrim) (0x0014 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_PEER_DEL_REQ ((CsrWifiRouterCtrlPrim) (0x0015 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_PEER_UPDATE_REQ ((CsrWifiRouterCtrlPrim) (0x0016 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_CAPABILITIES_REQ ((CsrWifiRouterCtrlPrim) (0x0017 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ENABLE_REQ ((CsrWifiRouterCtrlPrim) (0x0018 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_DISABLE_REQ ((CsrWifiRouterCtrlPrim) (0x0019 + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WAPI_RX_PKT_REQ ((CsrWifiRouterCtrlPrim) (0x001A + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WAPI_MULTICAST_FILTER_REQ ((CsrWifiRouterCtrlPrim) (0x001B + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_FILTER_REQ ((CsrWifiRouterCtrlPrim) (0x001C + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_TX_PKT_REQ ((CsrWifiRouterCtrlPrim) (0x001D + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WAPI_FILTER_REQ ((CsrWifiRouterCtrlPrim) (0x001E + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST))
+
+
+#define CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_HIGHEST (0x001E + CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST)
+
+/* Upstream */
+#define CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST (0x0000 + CSR_PRIM_UPSTREAM)
+
+#define CSR_WIFI_ROUTER_CTRL_HIP_IND ((CsrWifiRouterCtrlPrim)(0x0000 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_MULTICAST_ADDRESS_IND ((CsrWifiRouterCtrlPrim)(0x0001 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_PORT_CONFIGURE_CFM ((CsrWifiRouterCtrlPrim)(0x0002 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_RESUME_IND ((CsrWifiRouterCtrlPrim)(0x0003 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_SUSPEND_IND ((CsrWifiRouterCtrlPrim)(0x0004 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_TCLAS_ADD_CFM ((CsrWifiRouterCtrlPrim)(0x0005 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_RAW_SDIO_DEINITIALISE_CFM ((CsrWifiRouterCtrlPrim)(0x0006 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_RAW_SDIO_INITIALISE_CFM ((CsrWifiRouterCtrlPrim)(0x0007 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_TCLAS_DEL_CFM ((CsrWifiRouterCtrlPrim)(0x0008 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_PROTOCOL_IND ((CsrWifiRouterCtrlPrim)(0x0009 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_TRAFFIC_SAMPLE_IND ((CsrWifiRouterCtrlPrim)(0x000A + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WIFI_OFF_IND ((CsrWifiRouterCtrlPrim)(0x000B + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WIFI_OFF_CFM ((CsrWifiRouterCtrlPrim)(0x000C + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WIFI_ON_IND ((CsrWifiRouterCtrlPrim)(0x000D + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WIFI_ON_CFM ((CsrWifiRouterCtrlPrim)(0x000E + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_M4_READY_TO_SEND_IND ((CsrWifiRouterCtrlPrim)(0x000F + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_M4_TRANSMITTED_IND ((CsrWifiRouterCtrlPrim)(0x0010 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_MIC_FAILURE_IND ((CsrWifiRouterCtrlPrim)(0x0011 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_CONNECTED_IND ((CsrWifiRouterCtrlPrim)(0x0012 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_PEER_ADD_CFM ((CsrWifiRouterCtrlPrim)(0x0013 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_PEER_DEL_CFM ((CsrWifiRouterCtrlPrim)(0x0014 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_UNEXPECTED_FRAME_IND ((CsrWifiRouterCtrlPrim)(0x0015 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_PEER_UPDATE_CFM ((CsrWifiRouterCtrlPrim)(0x0016 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_CAPABILITIES_CFM ((CsrWifiRouterCtrlPrim)(0x0017 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ENABLE_CFM ((CsrWifiRouterCtrlPrim)(0x0018 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_DISABLE_CFM ((CsrWifiRouterCtrlPrim)(0x0019 + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ERROR_IND ((CsrWifiRouterCtrlPrim)(0x001A + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_STA_INACTIVE_IND ((CsrWifiRouterCtrlPrim)(0x001B + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WAPI_RX_MIC_CHECK_IND ((CsrWifiRouterCtrlPrim)(0x001C + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_MODE_SET_CFM ((CsrWifiRouterCtrlPrim)(0x001D + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_CTRL_WAPI_UNICAST_TX_ENCRYPT_IND ((CsrWifiRouterCtrlPrim)(0x001E + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST))
+
+#define CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_HIGHEST (0x001E + CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST)
+
+#define CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT (CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_HIGHEST + 1 - CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST)
+#define CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_COUNT (CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_HIGHEST + 1 - CSR_WIFI_ROUTER_CTRL_PRIM_UPSTREAM_LOWEST)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlConfigurePowerModeReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ mode -
+ wakeHost -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiRouterCtrlLowPowerMode mode;
+ CsrBool wakeHost;
+} CsrWifiRouterCtrlConfigurePowerModeReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlHipReq
+
+ DESCRIPTION
+ This primitive is used for transferring MLME messages to the HIP.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ mlmeCommandLength - Length of the MLME signal
+ mlmeCommand - Pointer to the MLME signal
+ dataRef1Length - Length of the dataRef1 bulk data
+ dataRef1 - Pointer to the bulk data 1
+ dataRef2Length - Length of the dataRef2 bulk data
+ dataRef2 - Pointer to the bulk data 2
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 mlmeCommandLength;
+ CsrUint8 *mlmeCommand;
+ CsrUint16 dataRef1Length;
+ CsrUint8 *dataRef1;
+ CsrUint16 dataRef2Length;
+ CsrUint8 *dataRef2;
+} CsrWifiRouterCtrlHipReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlMediaStatusReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ mediaStatus -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiRouterCtrlMediaStatus mediaStatus;
+} CsrWifiRouterCtrlMediaStatusReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlMulticastAddressRes
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ status -
+ action -
+ getAddressesCount -
+ getAddresses -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrResult status;
+ CsrWifiRouterCtrlListAction action;
+ CsrUint8 getAddressesCount;
+ CsrWifiMacAddress *getAddresses;
+} CsrWifiRouterCtrlMulticastAddressRes;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPortConfigureReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ uncontrolledPortAction -
+ controlledPortAction -
+ macAddress -
+ setProtection -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiRouterCtrlPortAction uncontrolledPortAction;
+ CsrWifiRouterCtrlPortAction controlledPortAction;
+ CsrWifiMacAddress macAddress;
+ CsrBool setProtection;
+} CsrWifiRouterCtrlPortConfigureReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlQosControlReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ control -
+ queueConfig -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiRouterCtrlQoSControl control;
+ CsrWifiRouterCtrlQueueConfigMask queueConfig;
+} CsrWifiRouterCtrlQosControlReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlSuspendRes
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrResult status;
+} CsrWifiRouterCtrlSuspendRes;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTclasAddReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ tclasLength -
+ tclas -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 tclasLength;
+ CsrUint8 *tclas;
+} CsrWifiRouterCtrlTclasAddReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlResumeRes
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrResult status;
+} CsrWifiRouterCtrlResumeRes;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlRawSdioDeinitialiseReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+} CsrWifiRouterCtrlRawSdioDeinitialiseReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlRawSdioInitialiseReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+} CsrWifiRouterCtrlRawSdioInitialiseReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTclasDelReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ tclasLength -
+ tclas -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 tclasLength;
+ CsrUint8 *tclas;
+} CsrWifiRouterCtrlTclasDelReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficClassificationReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ trafficType -
+ period -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiRouterCtrlTrafficType trafficType;
+ CsrUint16 period;
+} CsrWifiRouterCtrlTrafficClassificationReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficConfigReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ trafficConfigType -
+ config -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiRouterCtrlTrafficConfigType trafficConfigType;
+ CsrWifiRouterCtrlTrafficConfig config;
+} CsrWifiRouterCtrlTrafficConfigReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOffReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+} CsrWifiRouterCtrlWifiOffReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOffRes
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+} CsrWifiRouterCtrlWifiOffRes;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOnReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ dataLength - Number of bytes in the buffer pointed to by 'data'
+ data - Pointer to the buffer containing 'dataLength' bytes
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint32 dataLength;
+ CsrUint8 *data;
+} CsrWifiRouterCtrlWifiOnReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOnRes
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ status -
+ numInterfaceAddress -
+ stationMacAddress - array size 1 MUST match CSR_WIFI_NUM_INTERFACES
+ smeVersions -
+ scheduledInterrupt -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrResult status;
+ CsrUint16 numInterfaceAddress;
+ CsrWifiMacAddress stationMacAddress[2];
+ CsrWifiRouterCtrlSmeVersions smeVersions;
+ CsrBool scheduledInterrupt;
+} CsrWifiRouterCtrlWifiOnRes;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlM4TransmitReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+} CsrWifiRouterCtrlM4TransmitReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlModeSetReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ mode -
+ bssid - BSSID of the network the device is going to be a part
+ of
+ protection - Set to TRUE if encryption is enabled for the
+ connection/broadcast frames
+ intraBssDistEnabled - If set to TRUE, intra BSS destribution will be
+ enabled. If set to FALSE, any unicast PDU which does
+ not have the RA as the the local MAC address, shall be
+ ignored. This field is interpreted by the receive if
+ mode is set to CSR_WIFI_ROUTER_CTRL_MODE_P2PGO
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiRouterCtrlMode mode;
+ CsrWifiMacAddress bssid;
+ CsrBool protection;
+ CsrBool intraBssDistEnabled;
+} CsrWifiRouterCtrlModeSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerAddReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ peerMacAddress -
+ associationId -
+ staInfo -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiMacAddress peerMacAddress;
+ CsrUint16 associationId;
+ CsrWifiRouterCtrlStaInfo staInfo;
+} CsrWifiRouterCtrlPeerAddReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerDelReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ peerRecordHandle -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiRouterCtrlPeerRecordHandle peerRecordHandle;
+} CsrWifiRouterCtrlPeerDelReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerUpdateReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ peerRecordHandle -
+ powersaveMode -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiRouterCtrlPeerRecordHandle peerRecordHandle;
+ CsrWifiRouterCtrlPowersaveTypeMask powersaveMode;
+} CsrWifiRouterCtrlPeerUpdateReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlCapabilitiesReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+} CsrWifiRouterCtrlCapabilitiesReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckEnableReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ macAddress -
+ trafficStreamID -
+ role -
+ bufferSize -
+ timeout -
+ ssn -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiMacAddress macAddress;
+ CsrWifiRouterCtrlTrafficStreamId trafficStreamID;
+ CsrWifiRouterCtrlBlockAckRole role;
+ CsrUint16 bufferSize;
+ CsrUint16 timeout;
+ CsrUint16 ssn;
+} CsrWifiRouterCtrlBlockAckEnableReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckDisableReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ clientData -
+ macAddress -
+ trafficStreamID -
+ role -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiMacAddress macAddress;
+ CsrWifiRouterCtrlTrafficStreamId trafficStreamID;
+ CsrWifiRouterCtrlBlockAckRole role;
+} CsrWifiRouterCtrlBlockAckDisableReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiRxPktReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ signalLength -
+ signal -
+ dataLength -
+ data -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint16 signalLength;
+ CsrUint8 *signal;
+ CsrUint16 dataLength;
+ CsrUint8 *data;
+} CsrWifiRouterCtrlWapiRxPktReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiMulticastFilterReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 status;
+} CsrWifiRouterCtrlWapiMulticastFilterReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiUnicastFilterReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 status;
+} CsrWifiRouterCtrlWapiUnicastFilterReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiUnicastTxPktReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ dataLength -
+ data -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint16 dataLength;
+ CsrUint8 *data;
+} CsrWifiRouterCtrlWapiUnicastTxPktReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiFilterReq
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ isWapiConnected -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrBool isWapiConnected;
+} CsrWifiRouterCtrlWapiFilterReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlHipInd
+
+ DESCRIPTION
+ This primitive is used for transferring MLME messages from the HIP.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ mlmeCommandLength - Length of the MLME signal
+ mlmeCommand - Pointer to the MLME signal
+ dataRef1Length - Length of the dataRef1 bulk data
+ dataRef1 - Pointer to the bulk data 1
+ dataRef2Length - Length of the dataRef2 bulk data
+ dataRef2 - Pointer to the bulk data 2
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 mlmeCommandLength;
+ CsrUint8 *mlmeCommand;
+ CsrUint16 dataRef1Length;
+ CsrUint8 *dataRef1;
+ CsrUint16 dataRef2Length;
+ CsrUint8 *dataRef2;
+} CsrWifiRouterCtrlHipInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlMulticastAddressInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ action -
+ setAddressesCount -
+ setAddresses -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlListAction action;
+ CsrUint8 setAddressesCount;
+ CsrWifiMacAddress *setAddresses;
+} CsrWifiRouterCtrlMulticastAddressInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPortConfigureCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ status -
+ macAddress -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiMacAddress macAddress;
+} CsrWifiRouterCtrlPortConfigureCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlResumeInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ powerMaintained -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrBool powerMaintained;
+} CsrWifiRouterCtrlResumeInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlSuspendInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ hardSuspend -
+ d3Suspend -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrBool hardSuspend;
+ CsrBool d3Suspend;
+} CsrWifiRouterCtrlSuspendInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTclasAddCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiRouterCtrlTclasAddCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlRawSdioDeinitialiseCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ result -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrResult result;
+} CsrWifiRouterCtrlRawSdioDeinitialiseCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlRawSdioInitialiseCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ result -
+ byteRead -
+ byteWrite -
+ firmwareDownload -
+ reset -
+ coreDumpPrepare -
+ byteBlockRead -
+ gpRead16 -
+ gpWrite16 -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrResult result;
+ CsrWifiRouterCtrlRawSdioByteRead byteRead;
+ CsrWifiRouterCtrlRawSdioByteWrite byteWrite;
+ CsrWifiRouterCtrlRawSdioFirmwareDownload firmwareDownload;
+ CsrWifiRouterCtrlRawSdioReset reset;
+ CsrWifiRouterCtrlRawSdioCoreDumpPrepare coreDumpPrepare;
+ CsrWifiRouterCtrlRawSdioByteBlockRead byteBlockRead;
+ CsrWifiRouterCtrlRawSdioGpRead16 gpRead16;
+ CsrWifiRouterCtrlRawSdioGpWrite16 gpWrite16;
+} CsrWifiRouterCtrlRawSdioInitialiseCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTclasDelCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiRouterCtrlTclasDelCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficProtocolInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ packetType -
+ direction -
+ srcAddress -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlTrafficPacketType packetType;
+ CsrWifiRouterCtrlProtocolDirection direction;
+ CsrWifiMacAddress srcAddress;
+} CsrWifiRouterCtrlTrafficProtocolInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlTrafficSampleInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ stats -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlTrafficStats stats;
+} CsrWifiRouterCtrlTrafficSampleInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOffInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ controlIndication -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrWifiRouterCtrlControlIndication controlIndication;
+} CsrWifiRouterCtrlWifiOffInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOffCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+} CsrWifiRouterCtrlWifiOffCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOnInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ status -
+ versions -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrResult status;
+ CsrWifiRouterCtrlVersions versions;
+} CsrWifiRouterCtrlWifiOnInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWifiOnCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrResult status;
+} CsrWifiRouterCtrlWifiOnCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlM4ReadyToSendInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress peerMacAddress;
+} CsrWifiRouterCtrlM4ReadyToSendInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlM4TransmittedInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress peerMacAddress;
+ CsrResult status;
+} CsrWifiRouterCtrlM4TransmittedInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlMicFailureInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+ unicastPdu -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress peerMacAddress;
+ CsrBool unicastPdu;
+} CsrWifiRouterCtrlMicFailureInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlConnectedInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+ peerStatus -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress peerMacAddress;
+ CsrWifiRouterCtrlPeerStatus peerStatus;
+} CsrWifiRouterCtrlConnectedInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerAddCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+ peerRecordHandle -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress peerMacAddress;
+ CsrWifiRouterCtrlPeerRecordHandle peerRecordHandle;
+ CsrResult status;
+} CsrWifiRouterCtrlPeerAddCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerDelCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiRouterCtrlPeerDelCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlUnexpectedFrameInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ peerMacAddress -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress peerMacAddress;
+} CsrWifiRouterCtrlUnexpectedFrameInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlPeerUpdateCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiRouterCtrlPeerUpdateCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlCapabilitiesCfm
+
+ DESCRIPTION
+ The router sends this primitive to confirm the size of the queues of the
+ HIP.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ commandQueueSize - Size of command queue
+ trafficQueueSize - Size of traffic queue (per AC)
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 commandQueueSize;
+ CsrUint16 trafficQueueSize;
+} CsrWifiRouterCtrlCapabilitiesCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckEnableCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiRouterCtrlBlockAckEnableCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckDisableCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiRouterCtrlBlockAckDisableCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlBlockAckErrorInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ trafficStreamID -
+ peerMacAddress -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlTrafficStreamId trafficStreamID;
+ CsrWifiMacAddress peerMacAddress;
+ CsrResult status;
+} CsrWifiRouterCtrlBlockAckErrorInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlStaInactiveInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ staAddress -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress staAddress;
+} CsrWifiRouterCtrlStaInactiveInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiRxMicCheckInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ signalLength -
+ signal -
+ dataLength -
+ data -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrUint16 signalLength;
+ CsrUint8 *signal;
+ CsrUint16 dataLength;
+ CsrUint8 *data;
+} CsrWifiRouterCtrlWapiRxMicCheckInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlModeSetCfm
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ mode -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterCtrlMode mode;
+ CsrResult status;
+} CsrWifiRouterCtrlModeSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterCtrlWapiUnicastTxEncryptInd
+
+ DESCRIPTION
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ clientData -
+ interfaceTag -
+ dataLength -
+ data -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiRouterCtrlRequestorInfo clientData;
+ CsrUint16 interfaceTag;
+ CsrUint16 dataLength;
+ CsrUint8 *data;
+} CsrWifiRouterCtrlWapiUnicastTxEncryptInd;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_CTRL_PRIM_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ Confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+ *****************************************************************************/
+#include "csr_wifi_router_ctrl_sef.h"
+
+const CsrWifiRouterCtrlStateHandlerType CsrWifiRouterCtrlDownstreamStateHandlers[CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT] =
+{
+ /* 0x0000 */ CsrWifiRouterCtrlConfigurePowerModeReqHandler,
+ /* 0x0001 */ CsrWifiRouterCtrlHipReqHandler,
+ /* 0x0002 */ CsrWifiRouterCtrlMediaStatusReqHandler,
+ /* 0x0003 */ CsrWifiRouterCtrlMulticastAddressResHandler,
+ /* 0x0004 */ CsrWifiRouterCtrlPortConfigureReqHandler,
+ /* 0x0005 */ CsrWifiRouterCtrlQosControlReqHandler,
+ /* 0x0006 */ CsrWifiRouterCtrlSuspendResHandler,
+ /* 0x0007 */ CsrWifiRouterCtrlTclasAddReqHandler,
+ /* 0x0008 */ CsrWifiRouterCtrlResumeResHandler,
+ /* 0x0009 */ CsrWifiRouterCtrlRawSdioDeinitialiseReqHandler,
+ /* 0x000A */ CsrWifiRouterCtrlRawSdioInitialiseReqHandler,
+ /* 0x000B */ CsrWifiRouterCtrlTclasDelReqHandler,
+ /* 0x000C */ CsrWifiRouterCtrlTrafficClassificationReqHandler,
+ /* 0x000D */ CsrWifiRouterCtrlTrafficConfigReqHandler,
+ /* 0x000E */ CsrWifiRouterCtrlWifiOffReqHandler,
+ /* 0x000F */ CsrWifiRouterCtrlWifiOffResHandler,
+ /* 0x0010 */ CsrWifiRouterCtrlWifiOnReqHandler,
+ /* 0x0011 */ CsrWifiRouterCtrlWifiOnResHandler,
+ /* 0x0012 */ CsrWifiRouterCtrlM4TransmitReqHandler,
+ /* 0x0013 */ CsrWifiRouterCtrlModeSetReqHandler,
+ /* 0x0014 */ CsrWifiRouterCtrlPeerAddReqHandler,
+ /* 0x0015 */ CsrWifiRouterCtrlPeerDelReqHandler,
+ /* 0x0016 */ CsrWifiRouterCtrlPeerUpdateReqHandler,
+ /* 0x0017 */ CsrWifiRouterCtrlCapabilitiesReqHandler,
+ /* 0x0018 */ CsrWifiRouterCtrlBlockAckEnableReqHandler,
+ /* 0x0019 */ CsrWifiRouterCtrlBlockAckDisableReqHandler,
+ /* 0x001A */ CsrWifiRouterCtrlWapiRxPktReqHandler,
+ /* 0x001B */ CsrWifiRouterCtrlWapiMulticastFilterReqHandler,
+ /* 0x001C */ CsrWifiRouterCtrlWapiUnicastFilterReqHandler,
+ /* 0x001D */ CsrWifiRouterCtrlWapiUnicastTxPktReqHandler,
+ /* 0x001E */ CsrWifiRouterCtrlWapiFilterReqHandler,
+};
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ Confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+ *****************************************************************************/
+#ifndef CSR_WIFI_ROUTER_SEF_CSR_WIFI_ROUTER_CTRL_H__
+#define CSR_WIFI_ROUTER_SEF_CSR_WIFI_ROUTER_CTRL_H__
+
+#include "csr_wifi_router_ctrl_prim.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ typedef void (*CsrWifiRouterCtrlStateHandlerType)(void* drvpriv, CsrWifiFsmEvent* msg);
+
+ extern const CsrWifiRouterCtrlStateHandlerType CsrWifiRouterCtrlDownstreamStateHandlers[CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_COUNT];
+
+ extern void CsrWifiRouterCtrlConfigurePowerModeReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlHipReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlMediaStatusReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlMulticastAddressResHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlPortConfigureReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlQosControlReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlSuspendResHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlTclasAddReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlResumeResHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlRawSdioDeinitialiseReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlRawSdioInitialiseReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlTclasDelReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlTrafficClassificationReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlTrafficConfigReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlWifiOffReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlWifiOffResHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlWifiOnReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlWifiOnResHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlM4TransmitReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlModeSetReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlPeerAddReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlPeerDelReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlPeerUpdateReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlCapabilitiesReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlBlockAckEnableReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlBlockAckDisableReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlWapiMulticastFilterReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlWapiRxPktReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlWapiUnicastTxPktReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlWapiUnicastFilterReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterCtrlWapiFilterReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_SEF_CSR_WIFI_ROUTER_CTRL_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_msgconv.h"
+#include "csr_unicode.h"
+
+
+#include "csr_wifi_router_ctrl_prim.h"
+#include "csr_wifi_router_ctrl_serialize.h"
+
+void CsrWifiRouterCtrlPfree(void *ptr)
+{
+ CsrPmemFree(ptr);
+}
+
+
+CsrSize CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrWifiRouterCtrlLowPowerMode primitive->mode */
+ bufferSize += 1; /* CsrBool primitive->wakeHost */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlConfigurePowerModeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mode);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wakeHost);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlConfigurePowerModeReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlConfigurePowerModeReq *primitive = (CsrWifiRouterCtrlConfigurePowerModeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlConfigurePowerModeReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mode, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->wakeHost, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlHipReqSizeof(void *msg)
+{
+ CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
+ bufferSize += 2; /* CsrUint16 primitive->mlmeCommandLength */
+ bufferSize += primitive->mlmeCommandLength; /* CsrUint8 primitive->mlmeCommand */
+ bufferSize += 2; /* CsrUint16 primitive->dataRef1Length */
+ bufferSize += primitive->dataRef1Length; /* CsrUint8 primitive->dataRef1 */
+ bufferSize += 2; /* CsrUint16 primitive->dataRef2Length */
+ bufferSize += primitive->dataRef2Length; /* CsrUint8 primitive->dataRef2 */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlHipReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mlmeCommandLength);
+ if (primitive->mlmeCommandLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((CsrUint16) (primitive->mlmeCommandLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef1Length);
+ if (primitive->dataRef1Length)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((CsrUint16) (primitive->dataRef1Length)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef2Length);
+ if (primitive->dataRef2Length)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((CsrUint16) (primitive->dataRef2Length)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlHipReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlHipReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mlmeCommandLength, buffer, &offset);
+ if (primitive->mlmeCommandLength)
+ {
+ primitive->mlmeCommand = (CsrUint8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
+ CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((CsrUint16) (primitive->mlmeCommandLength)));
+ }
+ else
+ {
+ primitive->mlmeCommand = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->dataRef1Length, buffer, &offset);
+ if (primitive->dataRef1Length)
+ {
+ primitive->dataRef1 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef1Length);
+ CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((CsrUint16) (primitive->dataRef1Length)));
+ }
+ else
+ {
+ primitive->dataRef1 = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->dataRef2Length, buffer, &offset);
+ if (primitive->dataRef2Length)
+ {
+ primitive->dataRef2 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef2Length);
+ CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((CsrUint16) (primitive->dataRef2Length)));
+ }
+ else
+ {
+ primitive->dataRef2 = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlHipReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlHipReq *primitive = (CsrWifiRouterCtrlHipReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->mlmeCommand);
+ CsrPmemFree(primitive->dataRef1);
+ CsrPmemFree(primitive->dataRef2);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 1; /* CsrWifiRouterCtrlMediaStatus primitive->mediaStatus */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlMediaStatusReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->mediaStatus);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlMediaStatusReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlMediaStatusReq *primitive = (CsrWifiRouterCtrlMediaStatusReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMediaStatusReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->mediaStatus, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg)
+{
+ CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
+ bufferSize += 1; /* CsrUint8 primitive->getAddressesCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->getAddresses[i1].a[6] */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlMulticastAddressResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->getAddressesCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((CsrUint16) (6)));
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlMulticastAddressResDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMulticastAddressRes));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->getAddressesCount, buffer, &offset);
+ primitive->getAddresses = NULL;
+ if (primitive->getAddressesCount)
+ {
+ primitive->getAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->getAddressesCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
+ {
+ CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlMulticastAddressResSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlMulticastAddressRes *primitive = (CsrWifiRouterCtrlMulticastAddressRes *) voidPrimitivePointer;
+ CsrPmemFree(primitive->getAddresses);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->uncontrolledPortAction */
+ bufferSize += 2; /* CsrWifiRouterCtrlPortAction primitive->controlledPortAction */
+ bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+ bufferSize += 1; /* CsrBool primitive->setProtection */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlPortConfigureReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->uncontrolledPortAction);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->controlledPortAction);
+ CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->setProtection);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlPortConfigureReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlPortConfigureReq *primitive = (CsrWifiRouterCtrlPortConfigureReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPortConfigureReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->uncontrolledPortAction, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->controlledPortAction, buffer, &offset);
+ CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->setProtection, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlQosControlReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrWifiRouterCtrlQoSControl primitive->control */
+ bufferSize += 1; /* CsrWifiRouterCtrlQueueConfigMask primitive->queueConfig */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlQosControlReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->control);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->queueConfig);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlQosControlReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlQosControlReq *primitive = (CsrWifiRouterCtrlQosControlReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlQosControlReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->control, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->queueConfig, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlSuspendResSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlSuspendResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlSuspendResDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlSuspendRes *primitive = (CsrWifiRouterCtrlSuspendRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlSuspendRes));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlTclasAddReqSizeof(void *msg)
+{
+ CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->tclasLength */
+ bufferSize += primitive->tclasLength; /* CsrUint8 primitive->tclas */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlTclasAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->tclasLength);
+ if (primitive->tclasLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((CsrUint16) (primitive->tclasLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlTclasAddReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasAddReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
+ if (primitive->tclasLength)
+ {
+ primitive->tclas = (CsrUint8 *)CsrPmemAlloc(primitive->tclasLength);
+ CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
+ }
+ else
+ {
+ primitive->tclas = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlTclasAddReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlTclasAddReq *primitive = (CsrWifiRouterCtrlTclasAddReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->tclas);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlResumeResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlResumeResDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlResumeRes *primitive = (CsrWifiRouterCtrlResumeRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlResumeRes));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlTclasDelReqSizeof(void *msg)
+{
+ CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->tclasLength */
+ bufferSize += primitive->tclasLength; /* CsrUint8 primitive->tclas */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlTclasDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->tclasLength);
+ if (primitive->tclasLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((CsrUint16) (primitive->tclasLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlTclasDelReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasDelReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
+ if (primitive->tclasLength)
+ {
+ primitive->tclas = (CsrUint8 *)CsrPmemAlloc(primitive->tclasLength);
+ CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
+ }
+ else
+ {
+ primitive->tclas = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlTclasDelReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlTclasDelReq *primitive = (CsrWifiRouterCtrlTclasDelReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->tclas);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 1; /* CsrWifiRouterCtrlTrafficType primitive->trafficType */
+ bufferSize += 2; /* CsrUint16 primitive->period */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlTrafficClassificationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficType);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->period);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlTrafficClassificationReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlTrafficClassificationReq *primitive = (CsrWifiRouterCtrlTrafficClassificationReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficClassificationReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->trafficType, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->period, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 24) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrWifiRouterCtrlTrafficConfigType primitive->trafficConfigType */
+ bufferSize += 2; /* CsrUint16 primitive->config.packetFilter */
+ bufferSize += 4; /* CsrUint32 primitive->config.customFilter.etherType */
+ bufferSize += 1; /* CsrUint8 primitive->config.customFilter.ipType */
+ bufferSize += 4; /* CsrUint32 primitive->config.customFilter.udpSourcePort */
+ bufferSize += 4; /* CsrUint32 primitive->config.customFilter.udpDestPort */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlTrafficConfigReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->trafficConfigType);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->config.packetFilter);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.etherType);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->config.customFilter.ipType);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.udpSourcePort);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->config.customFilter.udpDestPort);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlTrafficConfigReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlTrafficConfigReq *primitive = (CsrWifiRouterCtrlTrafficConfigReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficConfigReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->trafficConfigType, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->config.packetFilter, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.etherType, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->config.customFilter.ipType, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.udpSourcePort, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->config.customFilter.udpDestPort, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlWifiOnReqSizeof(void *msg)
+{
+ CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 4; /* CsrUint32 primitive->dataLength */
+ bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
+ if (primitive->dataLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlWifiOnReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
+ if (primitive->dataLength)
+ {
+ primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ }
+ else
+ {
+ primitive->data = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlWifiOnReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlWifiOnReq *primitive = (CsrWifiRouterCtrlWifiOnReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->data);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg)
+{
+ CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 30) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 2; /* CsrUint16 primitive->numInterfaceAddress */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 2; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->stationMacAddress[i1].a[6] */
+ }
+ }
+ bufferSize += 4; /* CsrUint32 primitive->smeVersions.firmwarePatch */
+ bufferSize += (primitive->smeVersions.smeBuild?CsrStrLen(primitive->smeVersions.smeBuild) : 0) + 1; /* CsrCharString* primitive->smeVersions.smeBuild (0 byte len + 1 for NULL Term) */
+ bufferSize += 4; /* CsrUint32 primitive->smeVersions.smeHip */
+ bufferSize += 1; /* CsrBool primitive->scheduledInterrupt */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlWifiOnResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->numInterfaceAddress);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 2; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((CsrUint16) (6)));
+ }
+ }
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->smeVersions.firmwarePatch);
+ CsrCharStringSer(ptr, len, primitive->smeVersions.smeBuild);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->smeVersions.smeHip);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scheduledInterrupt);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlWifiOnResDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnRes));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->numInterfaceAddress, buffer, &offset);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 2; i1++)
+ {
+ CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ }
+ }
+ CsrUint32Des((CsrUint32 *) &primitive->smeVersions.firmwarePatch, buffer, &offset);
+ CsrCharStringDes(&primitive->smeVersions.smeBuild, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->smeVersions.smeHip, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scheduledInterrupt, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlWifiOnResSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlWifiOnRes *primitive = (CsrWifiRouterCtrlWifiOnRes *) voidPrimitivePointer;
+ CsrPmemFree(primitive->smeVersions.smeBuild);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlM4TransmitReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlM4TransmitReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlM4TransmitReq *primitive = (CsrWifiRouterCtrlM4TransmitReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4TransmitReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlModeSetReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
+ bufferSize += 6; /* CsrUint8 primitive->bssid.a[6] */
+ bufferSize += 1; /* CsrBool primitive->protection */
+ bufferSize += 1; /* CsrBool primitive->intraBssDistEnabled */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlModeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->mode);
+ CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->protection);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->intraBssDistEnabled);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlModeSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlModeSetReq *primitive = (CsrWifiRouterCtrlModeSetReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlModeSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->mode, buffer, &offset);
+ CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->protection, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->intraBssDistEnabled, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlPeerAddReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 2; /* CsrUint16 primitive->associationId */
+ bufferSize += 1; /* CsrBool primitive->staInfo.wmmOrQosEnabled */
+ bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->staInfo.powersaveMode */
+ bufferSize += 1; /* CsrUint8 primitive->staInfo.maxSpLength */
+ bufferSize += 2; /* CsrUint16 primitive->staInfo.listenIntervalInTus */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlPeerAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->associationId);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->staInfo.wmmOrQosEnabled);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->staInfo.powersaveMode);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->staInfo.maxSpLength);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->staInfo.listenIntervalInTus);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlPeerAddReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlPeerAddReq *primitive = (CsrWifiRouterCtrlPeerAddReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerAddReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->associationId, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->staInfo.wmmOrQosEnabled, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->staInfo.powersaveMode, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->staInfo.maxSpLength, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->staInfo.listenIntervalInTus, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlPeerDelReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlPeerDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlPeerDelReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlPeerDelReq *primitive = (CsrWifiRouterCtrlPeerDelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerDelReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
+ bufferSize += 2; /* CsrWifiRouterCtrlPowersaveTypeMask primitive->powersaveMode */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlPeerUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->powersaveMode);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlPeerUpdateReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlPeerUpdateReq *primitive = (CsrWifiRouterCtrlPeerUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerUpdateReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->powersaveMode, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+ bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
+ bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
+ bufferSize += 2; /* CsrUint16 primitive->bufferSize */
+ bufferSize += 2; /* CsrUint16 primitive->timeout */
+ bufferSize += 2; /* CsrUint16 primitive->ssn */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlBlockAckEnableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficStreamID);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->role);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->bufferSize);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->timeout);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->ssn);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlBlockAckEnableReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlBlockAckEnableReq *primitive = (CsrWifiRouterCtrlBlockAckEnableReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckEnableReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->trafficStreamID, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->role, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->bufferSize, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->timeout, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->ssn, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+ bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
+ bufferSize += 1; /* CsrWifiRouterCtrlBlockAckRole primitive->role */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlBlockAckDisableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficStreamID);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->role);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlBlockAckDisableReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlBlockAckDisableReq *primitive = (CsrWifiRouterCtrlBlockAckDisableReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckDisableReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->trafficStreamID, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->role, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg)
+{
+ CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrUint16 primitive->signalLength */
+ bufferSize += primitive->signalLength; /* CsrUint8 primitive->signal */
+ bufferSize += 2; /* CsrUint16 primitive->dataLength */
+ bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlWapiRxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->signalLength);
+ if (primitive->signalLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((CsrUint16) (primitive->signalLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+ if (primitive->dataLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlWapiRxPktReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiRxPktReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->signalLength, buffer, &offset);
+ if (primitive->signalLength)
+ {
+ primitive->signal = (CsrUint8 *)CsrPmemAlloc(primitive->signalLength);
+ CsrMemCpyDes(primitive->signal, buffer, &offset, ((CsrUint16) (primitive->signalLength)));
+ }
+ else
+ {
+ primitive->signal = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+ if (primitive->dataLength)
+ {
+ primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ }
+ else
+ {
+ primitive->data = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlWapiRxPktReq *primitive = (CsrWifiRouterCtrlWapiRxPktReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->signal);
+ CsrPmemFree(primitive->data);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg)
+{
+ CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrUint16 primitive->dataLength */
+ bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+ if (primitive->dataLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxPktReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+ if (primitive->dataLength)
+ {
+ primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ }
+ else
+ {
+ primitive->data = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlWapiUnicastTxPktReq *primitive = (CsrWifiRouterCtrlWapiUnicastTxPktReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->data);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlHipIndSizeof(void *msg)
+{
+ CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
+ bufferSize += 2; /* CsrUint16 primitive->mlmeCommandLength */
+ bufferSize += primitive->mlmeCommandLength; /* CsrUint8 primitive->mlmeCommand */
+ bufferSize += 2; /* CsrUint16 primitive->dataRef1Length */
+ bufferSize += primitive->dataRef1Length; /* CsrUint8 primitive->dataRef1 */
+ bufferSize += 2; /* CsrUint16 primitive->dataRef2Length */
+ bufferSize += primitive->dataRef2Length; /* CsrUint8 primitive->dataRef2 */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlHipIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mlmeCommandLength);
+ if (primitive->mlmeCommandLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->mlmeCommand, ((CsrUint16) (primitive->mlmeCommandLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef1Length);
+ if (primitive->dataRef1Length)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->dataRef1, ((CsrUint16) (primitive->dataRef1Length)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataRef2Length);
+ if (primitive->dataRef2Length)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->dataRef2, ((CsrUint16) (primitive->dataRef2Length)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlHipIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlHipInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mlmeCommandLength, buffer, &offset);
+ if (primitive->mlmeCommandLength)
+ {
+ primitive->mlmeCommand = (CsrUint8 *)CsrPmemAlloc(primitive->mlmeCommandLength);
+ CsrMemCpyDes(primitive->mlmeCommand, buffer, &offset, ((CsrUint16) (primitive->mlmeCommandLength)));
+ }
+ else
+ {
+ primitive->mlmeCommand = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->dataRef1Length, buffer, &offset);
+ if (primitive->dataRef1Length)
+ {
+ primitive->dataRef1 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef1Length);
+ CsrMemCpyDes(primitive->dataRef1, buffer, &offset, ((CsrUint16) (primitive->dataRef1Length)));
+ }
+ else
+ {
+ primitive->dataRef1 = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->dataRef2Length, buffer, &offset);
+ if (primitive->dataRef2Length)
+ {
+ primitive->dataRef2 = (CsrUint8 *)CsrPmemAlloc(primitive->dataRef2Length);
+ CsrMemCpyDes(primitive->dataRef2, buffer, &offset, ((CsrUint16) (primitive->dataRef2Length)));
+ }
+ else
+ {
+ primitive->dataRef2 = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlHipIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlHipInd *primitive = (CsrWifiRouterCtrlHipInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->mlmeCommand);
+ CsrPmemFree(primitive->dataRef1);
+ CsrPmemFree(primitive->dataRef2);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg)
+{
+ CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiRouterCtrlListAction primitive->action */
+ bufferSize += 1; /* CsrUint8 primitive->setAddressesCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->setAddresses[i1].a[6] */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlMulticastAddressIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->setAddressesCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((CsrUint16) (6)));
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlMulticastAddressIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMulticastAddressInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->setAddressesCount, buffer, &offset);
+ primitive->setAddresses = NULL;
+ if (primitive->setAddressesCount)
+ {
+ primitive->setAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->setAddressesCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
+ {
+ CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlMulticastAddressIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlMulticastAddressInd *primitive = (CsrWifiRouterCtrlMulticastAddressInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->setAddresses);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 6; /* CsrUint8 primitive->macAddress.a[6] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlPortConfigureCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->macAddress.a, ((CsrUint16) (6)));
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlPortConfigureCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlPortConfigureCfm *primitive = (CsrWifiRouterCtrlPortConfigureCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPortConfigureCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->macAddress.a, buffer, &offset, ((CsrUint16) (6)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlSuspendIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 1; /* CsrBool primitive->hardSuspend */
+ bufferSize += 1; /* CsrBool primitive->d3Suspend */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlSuspendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->hardSuspend);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->d3Suspend);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlSuspendIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlSuspendInd *primitive = (CsrWifiRouterCtrlSuspendInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlSuspendInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->hardSuspend, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->d3Suspend, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlTclasAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlTclasAddCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlTclasAddCfm *primitive = (CsrWifiRouterCtrlTclasAddCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasAddCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrResult primitive->result */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlRawSdioDeinitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioDeinitialiseCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioDeinitialiseCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 39) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrResult primitive->result */
+ bufferSize += 4; /* CsrWifiRouterCtrlRawSdioByteRead primitive->byteRead */
+ bufferSize += 4; /* CsrWifiRouterCtrlRawSdioByteWrite primitive->byteWrite */
+ bufferSize += 4; /* CsrWifiRouterCtrlRawSdioFirmwareDownload primitive->firmwareDownload */
+ bufferSize += 4; /* CsrWifiRouterCtrlRawSdioReset primitive->reset */
+ bufferSize += 4; /* CsrWifiRouterCtrlRawSdioCoreDumpPrepare primitive->coreDumpPrepare */
+ bufferSize += 4; /* CsrWifiRouterCtrlRawSdioByteBlockRead primitive->byteBlockRead */
+ bufferSize += 4; /* CsrWifiRouterCtrlRawSdioGpRead16 primitive->gpRead16 */
+ bufferSize += 4; /* CsrWifiRouterCtrlRawSdioGpWrite16 primitive->gpWrite16 */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+ CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteRead */
+ CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteWrite */
+ CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->firmwareDownload */
+ CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->reset */
+ CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->coreDumpPrepare */
+ CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->byteBlockRead */
+ CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->gpRead16 */
+ CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->gpWrite16 */
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlRawSdioInitialiseCfm *primitive = (CsrWifiRouterCtrlRawSdioInitialiseCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlRawSdioInitialiseCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+ primitive->byteRead = NULL; /* Special for Function Pointers... */
+ offset += 4;
+ primitive->byteWrite = NULL; /* Special for Function Pointers... */
+ offset += 4;
+ primitive->firmwareDownload = NULL; /* Special for Function Pointers... */
+ offset += 4;
+ primitive->reset = NULL; /* Special for Function Pointers... */
+ offset += 4;
+ primitive->coreDumpPrepare = NULL; /* Special for Function Pointers... */
+ offset += 4;
+ primitive->byteBlockRead = NULL; /* Special for Function Pointers... */
+ offset += 4;
+ primitive->gpRead16 = NULL; /* Special for Function Pointers... */
+ offset += 4;
+ primitive->gpWrite16 = NULL; /* Special for Function Pointers... */
+ offset += 4;
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlTclasDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlTclasDelCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlTclasDelCfm *primitive = (CsrWifiRouterCtrlTclasDelCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTclasDelCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrWifiRouterCtrlTrafficPacketType primitive->packetType */
+ bufferSize += 2; /* CsrWifiRouterCtrlProtocolDirection primitive->direction */
+ bufferSize += 6; /* CsrUint8 primitive->srcAddress.a[6] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlTrafficProtocolIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->packetType);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->direction);
+ CsrMemCpySer(ptr, len, (const void *) primitive->srcAddress.a, ((CsrUint16) (6)));
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlTrafficProtocolIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlTrafficProtocolInd *primitive = (CsrWifiRouterCtrlTrafficProtocolInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficProtocolInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->packetType, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->direction, buffer, &offset);
+ CsrMemCpyDes(primitive->srcAddress.a, buffer, &offset, ((CsrUint16) (6)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 38) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 4; /* CsrUint32 primitive->stats.rxMeanRate */
+ bufferSize += 4; /* CsrUint32 primitive->stats.rxFramesNum */
+ bufferSize += 4; /* CsrUint32 primitive->stats.txFramesNum */
+ bufferSize += 4; /* CsrUint32 primitive->stats.rxBytesCount */
+ bufferSize += 4; /* CsrUint32 primitive->stats.txBytesCount */
+ bufferSize += 11; /* CsrUint8 primitive->stats.intervals[11] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlTrafficSampleIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.rxMeanRate);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.rxFramesNum);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.txFramesNum);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.rxBytesCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->stats.txBytesCount);
+ CsrMemCpySer(ptr, len, (const void *) primitive->stats.intervals, ((CsrUint16) (11)));
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlTrafficSampleIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlTrafficSampleInd *primitive = (CsrWifiRouterCtrlTrafficSampleInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlTrafficSampleInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->stats.rxMeanRate, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->stats.rxFramesNum, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->stats.txFramesNum, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->stats.rxBytesCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->stats.txBytesCount, buffer, &offset);
+ CsrMemCpyDes(primitive->stats.intervals, buffer, &offset, ((CsrUint16) (11)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlWifiOnIndSizeof(void *msg)
+{
+ CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 27) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 4; /* CsrUint32 primitive->versions.chipId */
+ bufferSize += 4; /* CsrUint32 primitive->versions.chipVersion */
+ bufferSize += 4; /* CsrUint32 primitive->versions.firmwareBuild */
+ bufferSize += 4; /* CsrUint32 primitive->versions.firmwareHip */
+ bufferSize += (primitive->versions.routerBuild?CsrStrLen(primitive->versions.routerBuild) : 0) + 1; /* CsrCharString* primitive->versions.routerBuild (0 byte len + 1 for NULL Term) */
+ bufferSize += 4; /* CsrUint32 primitive->versions.routerHip */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipId);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipVersion);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwareBuild);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwareHip);
+ CsrCharStringSer(ptr, len, primitive->versions.routerBuild);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.routerHip);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlWifiOnIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.chipId, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.chipVersion, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.firmwareBuild, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.firmwareHip, buffer, &offset);
+ CsrCharStringDes(&primitive->versions.routerBuild, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.routerHip, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlWifiOnIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlWifiOnInd *primitive = (CsrWifiRouterCtrlWifiOnInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->versions.routerBuild);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlWifiOnCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlWifiOnCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlWifiOnCfm *primitive = (CsrWifiRouterCtrlWifiOnCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWifiOnCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlM4ReadyToSendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlM4ReadyToSendIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlM4ReadyToSendInd *primitive = (CsrWifiRouterCtrlM4ReadyToSendInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4ReadyToSendInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlM4TransmittedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlM4TransmittedIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlM4TransmittedInd *primitive = (CsrWifiRouterCtrlM4TransmittedInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlM4TransmittedInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlMicFailureIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 1; /* CsrBool primitive->unicastPdu */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->unicastPdu);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlMicFailureIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlMicFailureInd *primitive = (CsrWifiRouterCtrlMicFailureInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlMicFailureInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->unicastPdu, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlConnectedIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 1; /* CsrWifiRouterCtrlPeerStatus primitive->peerStatus */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlConnectedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->peerStatus);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlConnectedIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlConnectedInd *primitive = (CsrWifiRouterCtrlConnectedInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlConnectedInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->peerStatus, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 19) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 4; /* CsrWifiRouterCtrlPeerRecordHandle primitive->peerRecordHandle */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlPeerAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->peerRecordHandle);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlPeerAddCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlPeerAddCfm *primitive = (CsrWifiRouterCtrlPeerAddCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerAddCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint32Des((CsrUint32 *) &primitive->peerRecordHandle, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlPeerDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlPeerDelCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlPeerDelCfm *primitive = (CsrWifiRouterCtrlPeerDelCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerDelCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlUnexpectedFrameIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlUnexpectedFrameIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlUnexpectedFrameInd *primitive = (CsrWifiRouterCtrlUnexpectedFrameInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlUnexpectedFrameInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlPeerUpdateCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlPeerUpdateCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlPeerUpdateCfm *primitive = (CsrWifiRouterCtrlPeerUpdateCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlPeerUpdateCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->commandQueueSize */
+ bufferSize += 2; /* CsrUint16 primitive->trafficQueueSize */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlCapabilitiesCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->commandQueueSize);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->trafficQueueSize);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlCapabilitiesCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlCapabilitiesCfm *primitive = (CsrWifiRouterCtrlCapabilitiesCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlCapabilitiesCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->commandQueueSize, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->trafficQueueSize, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlBlockAckEnableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlBlockAckEnableCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlBlockAckEnableCfm *primitive = (CsrWifiRouterCtrlBlockAckEnableCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckEnableCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlBlockAckDisableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlBlockAckDisableCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlBlockAckDisableCfm *primitive = (CsrWifiRouterCtrlBlockAckDisableCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckDisableCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 16) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiRouterCtrlTrafficStreamId primitive->trafficStreamID */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlBlockAckErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->trafficStreamID);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlBlockAckErrorIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlBlockAckErrorInd *primitive = (CsrWifiRouterCtrlBlockAckErrorInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlBlockAckErrorInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->trafficStreamID, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 6; /* CsrUint8 primitive->staAddress.a[6] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlStaInactiveIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->staAddress.a, ((CsrUint16) (6)));
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlStaInactiveIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlStaInactiveInd *primitive = (CsrWifiRouterCtrlStaInactiveInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlStaInactiveInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->staAddress.a, buffer, &offset, ((CsrUint16) (6)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg)
+{
+ CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrUint16 primitive->signalLength */
+ bufferSize += primitive->signalLength; /* CsrUint8 primitive->signal */
+ bufferSize += 2; /* CsrUint16 primitive->dataLength */
+ bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->signalLength);
+ if (primitive->signalLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->signal, ((CsrUint16) (primitive->signalLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+ if (primitive->dataLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiRxMicCheckInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->signalLength, buffer, &offset);
+ if (primitive->signalLength)
+ {
+ primitive->signal = (CsrUint8 *)CsrPmemAlloc(primitive->signalLength);
+ CsrMemCpyDes(primitive->signal, buffer, &offset, ((CsrUint16) (primitive->signalLength)));
+ }
+ else
+ {
+ primitive->signal = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+ if (primitive->dataLength)
+ {
+ primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ }
+ else
+ {
+ primitive->data = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlWapiRxMicCheckIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlWapiRxMicCheckInd *primitive = (CsrWifiRouterCtrlWapiRxMicCheckInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->signal);
+ CsrPmemFree(primitive->data);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterCtrlModeSetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiRouterCtrlMode primitive->mode */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlModeSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->mode);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlModeSetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlModeSetCfm *primitive = (CsrWifiRouterCtrlModeSetCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlModeSetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->mode, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg)
+{
+ CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrWifiRouterCtrlRequestorInfo primitive->clientData */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrUint16 primitive->dataLength */
+ bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->clientData);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->dataLength);
+ if (primitive->dataLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) CsrPmemAlloc(sizeof(CsrWifiRouterCtrlWapiUnicastTxEncryptInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->clientData, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->dataLength, buffer, &offset);
+ if (primitive->dataLength)
+ {
+ primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ }
+ else
+ {
+ primitive->data = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiRouterCtrlWapiUnicastTxEncryptIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterCtrlWapiUnicastTxEncryptInd *primitive = (CsrWifiRouterCtrlWapiUnicastTxEncryptInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->data);
+ CsrPmemFree(primitive);
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_ROUTER_CTRL_SERIALIZE_H__
+#define CSR_WIFI_ROUTER_CTRL_SERIALIZE_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_wifi_msgconv.h"
+
+#include "csr_wifi_router_ctrl_prim.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void CsrWifiRouterCtrlPfree(void *ptr);
+
+extern CsrUint8* CsrWifiRouterCtrlConfigurePowerModeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlConfigurePowerModeReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlConfigurePowerModeReqSizeof(void *msg);
+#define CsrWifiRouterCtrlConfigurePowerModeReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlHipReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlHipReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlHipReqSizeof(void *msg);
+extern void CsrWifiRouterCtrlHipReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterCtrlMediaStatusReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMediaStatusReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlMediaStatusReqSizeof(void *msg);
+#define CsrWifiRouterCtrlMediaStatusReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlMulticastAddressResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMulticastAddressResDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlMulticastAddressResSizeof(void *msg);
+extern void CsrWifiRouterCtrlMulticastAddressResSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterCtrlPortConfigureReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPortConfigureReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlPortConfigureReqSizeof(void *msg);
+#define CsrWifiRouterCtrlPortConfigureReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlQosControlReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlQosControlReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlQosControlReqSizeof(void *msg);
+#define CsrWifiRouterCtrlQosControlReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlSuspendResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlSuspendResDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlSuspendResSizeof(void *msg);
+#define CsrWifiRouterCtrlSuspendResSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlTclasAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasAddReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlTclasAddReqSizeof(void *msg);
+extern void CsrWifiRouterCtrlTclasAddReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterCtrlResumeResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlResumeResDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlResumeResSizeof(void *msg);
+#define CsrWifiRouterCtrlResumeResSerFree CsrWifiRouterCtrlPfree
+
+#define CsrWifiRouterCtrlRawSdioDeinitialiseReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiRouterCtrlRawSdioDeinitialiseReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiRouterCtrlRawSdioDeinitialiseReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiRouterCtrlRawSdioDeinitialiseReqSerFree CsrWifiRouterCtrlPfree
+
+#define CsrWifiRouterCtrlRawSdioInitialiseReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiRouterCtrlRawSdioInitialiseReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiRouterCtrlRawSdioInitialiseReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiRouterCtrlRawSdioInitialiseReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlTclasDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasDelReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlTclasDelReqSizeof(void *msg);
+extern void CsrWifiRouterCtrlTclasDelReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterCtrlTrafficClassificationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficClassificationReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlTrafficClassificationReqSizeof(void *msg);
+#define CsrWifiRouterCtrlTrafficClassificationReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlTrafficConfigReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficConfigReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlTrafficConfigReqSizeof(void *msg);
+#define CsrWifiRouterCtrlTrafficConfigReqSerFree CsrWifiRouterCtrlPfree
+
+#define CsrWifiRouterCtrlWifiOffReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiRouterCtrlWifiOffReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiRouterCtrlWifiOffReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiRouterCtrlWifiOffReqSerFree CsrWifiRouterCtrlPfree
+
+#define CsrWifiRouterCtrlWifiOffResSer CsrWifiEventCsrUint16Ser
+#define CsrWifiRouterCtrlWifiOffResDes CsrWifiEventCsrUint16Des
+#define CsrWifiRouterCtrlWifiOffResSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiRouterCtrlWifiOffResSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlWifiOnReqSizeof(void *msg);
+extern void CsrWifiRouterCtrlWifiOnReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterCtrlWifiOnResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnResDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlWifiOnResSizeof(void *msg);
+extern void CsrWifiRouterCtrlWifiOnResSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterCtrlM4TransmitReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlM4TransmitReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlM4TransmitReqSizeof(void *msg);
+#define CsrWifiRouterCtrlM4TransmitReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlModeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlModeSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlModeSetReqSizeof(void *msg);
+#define CsrWifiRouterCtrlModeSetReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlPeerAddReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerAddReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlPeerAddReqSizeof(void *msg);
+#define CsrWifiRouterCtrlPeerAddReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlPeerDelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerDelReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlPeerDelReqSizeof(void *msg);
+#define CsrWifiRouterCtrlPeerDelReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlPeerUpdateReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerUpdateReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlPeerUpdateReqSizeof(void *msg);
+#define CsrWifiRouterCtrlPeerUpdateReqSerFree CsrWifiRouterCtrlPfree
+
+#define CsrWifiRouterCtrlCapabilitiesReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiRouterCtrlCapabilitiesReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiRouterCtrlCapabilitiesReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiRouterCtrlCapabilitiesReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlBlockAckEnableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckEnableReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlBlockAckEnableReqSizeof(void *msg);
+#define CsrWifiRouterCtrlBlockAckEnableReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlBlockAckDisableReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckDisableReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlBlockAckDisableReqSizeof(void *msg);
+#define CsrWifiRouterCtrlBlockAckDisableReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlWapiRxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiRxPktReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlWapiRxPktReqSizeof(void *msg);
+extern void CsrWifiRouterCtrlWapiRxPktReqSerFree(void *msg);
+
+#define CsrWifiRouterCtrlWapiMulticastFilterReqSer CsrWifiEventCsrUint16CsrUint8Ser
+#define CsrWifiRouterCtrlWapiMulticastFilterReqDes CsrWifiEventCsrUint16CsrUint8Des
+#define CsrWifiRouterCtrlWapiMulticastFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
+#define CsrWifiRouterCtrlWapiMulticastFilterReqSerFree CsrWifiRouterCtrlPfree
+
+#define CsrWifiRouterCtrlWapiUnicastFilterReqSer CsrWifiEventCsrUint16CsrUint8Ser
+#define CsrWifiRouterCtrlWapiUnicastFilterReqDes CsrWifiEventCsrUint16CsrUint8Des
+#define CsrWifiRouterCtrlWapiUnicastFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
+#define CsrWifiRouterCtrlWapiUnicastFilterReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlWapiUnicastTxPktReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiUnicastTxPktReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlWapiUnicastTxPktReqSizeof(void *msg);
+extern void CsrWifiRouterCtrlWapiUnicastTxPktReqSerFree(void *msg);
+
+#define CsrWifiRouterCtrlWapiFilterReqSer CsrWifiEventCsrUint16CsrUint8Ser
+#define CsrWifiRouterCtrlWapiFilterReqDes CsrWifiEventCsrUint16CsrUint8Des
+#define CsrWifiRouterCtrlWapiFilterReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
+#define CsrWifiRouterCtrlWapiFilterReqSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlHipIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlHipIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlHipIndSizeof(void *msg);
+extern void CsrWifiRouterCtrlHipIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterCtrlMulticastAddressIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMulticastAddressIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlMulticastAddressIndSizeof(void *msg);
+extern void CsrWifiRouterCtrlMulticastAddressIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterCtrlPortConfigureCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPortConfigureCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlPortConfigureCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlPortConfigureCfmSerFree CsrWifiRouterCtrlPfree
+
+#define CsrWifiRouterCtrlResumeIndSer CsrWifiEventCsrUint16CsrUint8Ser
+#define CsrWifiRouterCtrlResumeIndDes CsrWifiEventCsrUint16CsrUint8Des
+#define CsrWifiRouterCtrlResumeIndSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
+#define CsrWifiRouterCtrlResumeIndSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlSuspendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlSuspendIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlSuspendIndSizeof(void *msg);
+#define CsrWifiRouterCtrlSuspendIndSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlTclasAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasAddCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlTclasAddCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlTclasAddCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlRawSdioDeinitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlRawSdioDeinitialiseCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlRawSdioDeinitialiseCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlRawSdioInitialiseCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlRawSdioInitialiseCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlRawSdioInitialiseCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlRawSdioInitialiseCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlTclasDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTclasDelCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlTclasDelCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlTclasDelCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlTrafficProtocolIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficProtocolIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlTrafficProtocolIndSizeof(void *msg);
+#define CsrWifiRouterCtrlTrafficProtocolIndSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlTrafficSampleIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlTrafficSampleIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlTrafficSampleIndSizeof(void *msg);
+#define CsrWifiRouterCtrlTrafficSampleIndSerFree CsrWifiRouterCtrlPfree
+
+#define CsrWifiRouterCtrlWifiOffIndSer CsrWifiEventCsrUint16CsrUint8Ser
+#define CsrWifiRouterCtrlWifiOffIndDes CsrWifiEventCsrUint16CsrUint8Des
+#define CsrWifiRouterCtrlWifiOffIndSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
+#define CsrWifiRouterCtrlWifiOffIndSerFree CsrWifiRouterCtrlPfree
+
+#define CsrWifiRouterCtrlWifiOffCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiRouterCtrlWifiOffCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiRouterCtrlWifiOffCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiRouterCtrlWifiOffCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlWifiOnIndSizeof(void *msg);
+extern void CsrWifiRouterCtrlWifiOnIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterCtrlWifiOnCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWifiOnCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlWifiOnCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlWifiOnCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlM4ReadyToSendIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlM4ReadyToSendIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlM4ReadyToSendIndSizeof(void *msg);
+#define CsrWifiRouterCtrlM4ReadyToSendIndSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlM4TransmittedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlM4TransmittedIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlM4TransmittedIndSizeof(void *msg);
+#define CsrWifiRouterCtrlM4TransmittedIndSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlMicFailureIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlMicFailureIndSizeof(void *msg);
+#define CsrWifiRouterCtrlMicFailureIndSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlConnectedIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlConnectedIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlConnectedIndSizeof(void *msg);
+#define CsrWifiRouterCtrlConnectedIndSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlPeerAddCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerAddCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlPeerAddCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlPeerAddCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlPeerDelCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerDelCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlPeerDelCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlPeerDelCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlUnexpectedFrameIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlUnexpectedFrameIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlUnexpectedFrameIndSizeof(void *msg);
+#define CsrWifiRouterCtrlUnexpectedFrameIndSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlPeerUpdateCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlPeerUpdateCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlPeerUpdateCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlPeerUpdateCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlCapabilitiesCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlCapabilitiesCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlCapabilitiesCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlCapabilitiesCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlBlockAckEnableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckEnableCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlBlockAckEnableCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlBlockAckEnableCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlBlockAckDisableCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckDisableCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlBlockAckDisableCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlBlockAckDisableCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlBlockAckErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlBlockAckErrorIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlBlockAckErrorIndSizeof(void *msg);
+#define CsrWifiRouterCtrlBlockAckErrorIndSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlStaInactiveIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlStaInactiveIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlStaInactiveIndSizeof(void *msg);
+#define CsrWifiRouterCtrlStaInactiveIndSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlWapiRxMicCheckIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiRxMicCheckIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlWapiRxMicCheckIndSizeof(void *msg);
+extern void CsrWifiRouterCtrlWapiRxMicCheckIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterCtrlModeSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlModeSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlModeSetCfmSizeof(void *msg);
+#define CsrWifiRouterCtrlModeSetCfmSerFree CsrWifiRouterCtrlPfree
+
+extern CsrUint8* CsrWifiRouterCtrlWapiUnicastTxEncryptIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterCtrlWapiUnicastTxEncryptIndSizeof(void *msg);
+extern void CsrWifiRouterCtrlWapiUnicastTxEncryptIndSerFree(void *msg);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* CSR_WIFI_ROUTER_CTRL_SERIALIZE_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_wifi_router_prim.h"
+#include "csr_wifi_router_lib.h"
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrWifiRouterFreeDownstreamMessageContents
+ *
+ * DESCRIPTION
+ *
+ *
+ * PARAMETERS
+ * eventClass: only the value CSR_WIFI_ROUTER_PRIM will be handled
+ * message: the message to free
+ *----------------------------------------------------------------------------*/
+void CsrWifiRouterFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+{
+ if (eventClass != CSR_WIFI_ROUTER_PRIM)
+ {
+ return;
+ }
+ if (NULL == message)
+ {
+ return;
+ }
+
+ switch (*((CsrWifiRouterPrim *) message))
+ {
+ case CSR_WIFI_ROUTER_MA_PACKET_REQ:
+ {
+ CsrWifiRouterMaPacketReq *p = (CsrWifiRouterMaPacketReq *)message;
+ CsrPmemFree(p->frame);
+ p->frame = NULL;
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_wifi_router_prim.h"
+#include "csr_wifi_router_lib.h"
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrWifiRouterFreeUpstreamMessageContents
+ *
+ * DESCRIPTION
+ *
+ *
+ * PARAMETERS
+ * eventClass: only the value CSR_WIFI_ROUTER_PRIM will be handled
+ * message: the message to free
+ *----------------------------------------------------------------------------*/
+void CsrWifiRouterFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+{
+ if (eventClass != CSR_WIFI_ROUTER_PRIM)
+ {
+ return;
+ }
+ if (NULL == message)
+ {
+ return;
+ }
+
+ switch (*((CsrWifiRouterPrim *) message))
+ {
+ case CSR_WIFI_ROUTER_MA_PACKET_IND:
+ {
+ CsrWifiRouterMaPacketInd *p = (CsrWifiRouterMaPacketInd *)message;
+ CsrPmemFree(p->frame);
+ p->frame = NULL;
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_ROUTER_LIB_H__
+#define CSR_WIFI_ROUTER_LIB_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_sched.h"
+#include "csr_util.h"
+#include "csr_msg_transport.h"
+
+#include "csr_wifi_lib.h"
+
+#include "csr_wifi_router_prim.h"
+#include "csr_wifi_router_task.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiRouterFreeUpstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_ROUTER upstream message. Does not
+ * free the message itself, and can only be used for upstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_ROUTER upstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiRouterFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiRouterFreeDownstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_ROUTER downstream message. Does not
+ * free the message itself, and can only be used for downstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_ROUTER downstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiRouterFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * Enum to string functions
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiRouterAppTypeToString(CsrWifiRouterAppType value);
+const CsrCharString* CsrWifiRouterEncapsulationToString(CsrWifiRouterEncapsulation value);
+const CsrCharString* CsrWifiRouterOuiToString(CsrWifiRouterOui value);
+const CsrCharString* CsrWifiRouterPriorityToString(CsrWifiRouterPriority value);
+
+
+/*----------------------------------------------------------------------------*
+ * CsrPrim Type toString function.
+ * Converts a message type to the String name of the Message
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiRouterPrimTypeToString(CsrPrim msgType);
+
+/*----------------------------------------------------------------------------*
+ * Lookup arrays for PrimType name Strings
+ *----------------------------------------------------------------------------*/
+extern const CsrCharString *CsrWifiRouterUpstreamPrimNames[CSR_WIFI_ROUTER_PRIM_UPSTREAM_COUNT];
+extern const CsrCharString *CsrWifiRouterDownstreamPrimNames[CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT];
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketCancelReqSend
+
+ DESCRIPTION
+ This primitive is used to request cancellation of a previously send
+ CsrWifiRouterMaPacketReq.
+ The frame may already have been transmitted so there is no guarantees
+ that the CsrWifiRouterMaPacketCancelReq actually cancels the transmission
+ of the frame in question.
+ If the cancellation fails, the Router will send, if required,
+ CsrWifiRouterMaPacketCfm.
+ If the cancellation succeeds, the Router will not send
+ CsrWifiRouterMaPacketCfm.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ hostTag - The hostTag for the frame, which should be cancelled.
+ priority - Priority of the frame, which should be cancelled
+ peerMacAddress - Destination MAC address of the frame, which should be
+ cancelled
+
+*******************************************************************************/
+#define CsrWifiRouterMaPacketCancelReqCreate(msg__, dst__, src__, interfaceTag__, hostTag__, priority__, peerMacAddress__) \
+ msg__ = (CsrWifiRouterMaPacketCancelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCancelReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_PRIM, CSR_WIFI_ROUTER_MA_PACKET_CANCEL_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->hostTag = (hostTag__); \
+ msg__->priority = (priority__); \
+ msg__->peerMacAddress = (peerMacAddress__);
+
+#define CsrWifiRouterMaPacketCancelReqSendTo(dst__, src__, interfaceTag__, hostTag__, priority__, peerMacAddress__) \
+ { \
+ CsrWifiRouterMaPacketCancelReq *msg__; \
+ CsrWifiRouterMaPacketCancelReqCreate(msg__, dst__, src__, interfaceTag__, hostTag__, priority__, peerMacAddress__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterMaPacketCancelReqSend(src__, interfaceTag__, hostTag__, priority__, peerMacAddress__) \
+ CsrWifiRouterMaPacketCancelReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, hostTag__, priority__, peerMacAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketReqSend
+
+ DESCRIPTION
+ A task sends this primitive to transmit a frame.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ subscriptionHandle - The handle of the subscription
+ frameLength - Length of the frame to be sent in bytes
+ frame - Pointer to the frame to be sent
+ freeFunction - Pointer to function to be used to free the frame
+ priority - Priority of the frame, which should be sent
+ hostTag - An application shall set the bits b31..b28 using one of
+ the CSR_WIFI_ROUTER_APP_TYPE_* masks. Bits b0..b27 can
+ be used by the requestor without any restrictions, but
+ the hostTag shall be unique so the hostTag for
+ CSR_WIFI_ROUTER_APP _TYPE_OTHER should be constructured
+ in the following way [ CSR_WIFI_ROUTER_APP_TYPE_OTHER
+ (4 bits) | SubscriptionHandle (8 bits) | Sequence no.
+ (20 bits) ]. If the hostTag is not unique, the
+ behaviour of the system is unpredicatable with respect
+ to data/management frame transfer.
+ cfmRequested - Indicates if the requestor needs a confirm for packet
+ requests sent under this subscription. If set to TRUE,
+ the router will send a confirm, else it will not send
+ any confirm
+
+*******************************************************************************/
+#define CsrWifiRouterMaPacketReqCreate(msg__, dst__, src__, interfaceTag__, subscriptionHandle__, frameLength__, frame__, freeFunction__, priority__, hostTag__, cfmRequested__) \
+ msg__ = (CsrWifiRouterMaPacketReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_PRIM, CSR_WIFI_ROUTER_MA_PACKET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->subscriptionHandle = (subscriptionHandle__); \
+ msg__->frameLength = (frameLength__); \
+ msg__->frame = (frame__); \
+ msg__->freeFunction = (freeFunction__); \
+ msg__->priority = (priority__); \
+ msg__->hostTag = (hostTag__); \
+ msg__->cfmRequested = (cfmRequested__);
+
+#define CsrWifiRouterMaPacketReqSendTo(dst__, src__, interfaceTag__, subscriptionHandle__, frameLength__, frame__, freeFunction__, priority__, hostTag__, cfmRequested__) \
+ { \
+ CsrWifiRouterMaPacketReq *msg__; \
+ CsrWifiRouterMaPacketReqCreate(msg__, dst__, src__, interfaceTag__, subscriptionHandle__, frameLength__, frame__, freeFunction__, priority__, hostTag__, cfmRequested__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterMaPacketReqSend(src__, interfaceTag__, subscriptionHandle__, frameLength__, frame__, freeFunction__, priority__, hostTag__, cfmRequested__) \
+ CsrWifiRouterMaPacketReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, subscriptionHandle__, frameLength__, frame__, freeFunction__, priority__, hostTag__, cfmRequested__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketIndSend
+
+ DESCRIPTION
+ The router sends the primitive to a subscribed task when it receives a
+ frame matching the subscription.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ subscriptionHandle - The handle of the subscription
+ result - Status of the operation
+ frameLength - Length of the received frame in bytes
+ frame - Pointer to the received frame
+ freeFunction - Pointer to function to be used to free the frame
+ rssi - Received signal strength indication in dBm
+ snr - Signal to Noise Ratio
+ rate - Transmission/Reception rate
+
+*******************************************************************************/
+#define CsrWifiRouterMaPacketIndCreate(msg__, dst__, src__, interfaceTag__, subscriptionHandle__, result__, frameLength__, frame__, freeFunction__, rssi__, snr__, rate__) \
+ msg__ = (CsrWifiRouterMaPacketInd *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_PRIM, CSR_WIFI_ROUTER_MA_PACKET_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->subscriptionHandle = (subscriptionHandle__); \
+ msg__->result = (result__); \
+ msg__->frameLength = (frameLength__); \
+ msg__->frame = (frame__); \
+ msg__->freeFunction = (freeFunction__); \
+ msg__->rssi = (rssi__); \
+ msg__->snr = (snr__); \
+ msg__->rate = (rate__);
+
+#define CsrWifiRouterMaPacketIndSendTo(dst__, src__, interfaceTag__, subscriptionHandle__, result__, frameLength__, frame__, freeFunction__, rssi__, snr__, rate__) \
+ { \
+ CsrWifiRouterMaPacketInd *msg__; \
+ CsrWifiRouterMaPacketIndCreate(msg__, dst__, src__, interfaceTag__, subscriptionHandle__, result__, frameLength__, frame__, freeFunction__, rssi__, snr__, rate__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterMaPacketIndSend(dst__, interfaceTag__, subscriptionHandle__, result__, frameLength__, frame__, freeFunction__, rssi__, snr__, rate__) \
+ CsrWifiRouterMaPacketIndSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, interfaceTag__, subscriptionHandle__, result__, frameLength__, frame__, freeFunction__, rssi__, snr__, rate__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketResSend
+
+ DESCRIPTION
+ A task send this primitive to confirm the reception of the received
+ frame.
+
+ PARAMETERS
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ subscriptionHandle - The handle of the subscription
+ result - Status of the operation
+
+*******************************************************************************/
+#define CsrWifiRouterMaPacketResCreate(msg__, dst__, src__, interfaceTag__, subscriptionHandle__, result__) \
+ msg__ = (CsrWifiRouterMaPacketRes *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketRes)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_PRIM, CSR_WIFI_ROUTER_MA_PACKET_RES, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->subscriptionHandle = (subscriptionHandle__); \
+ msg__->result = (result__);
+
+#define CsrWifiRouterMaPacketResSendTo(dst__, src__, interfaceTag__, subscriptionHandle__, result__) \
+ { \
+ CsrWifiRouterMaPacketRes *msg__; \
+ CsrWifiRouterMaPacketResCreate(msg__, dst__, src__, interfaceTag__, subscriptionHandle__, result__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterMaPacketResSend(src__, interfaceTag__, subscriptionHandle__, result__) \
+ CsrWifiRouterMaPacketResSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, subscriptionHandle__, result__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketCfmSend
+
+ DESCRIPTION
+ The router sends the primitive to confirm the result of the transmission
+ of the packet of the corresponding CSR_WIFI_ROUTER MA_PACKET_REQ request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ result - Status of the operation
+ hostTag - The hostTrag will match the hostTag sent in the request.
+ rate - Transmission/Reception rate
+
+*******************************************************************************/
+#define CsrWifiRouterMaPacketCfmCreate(msg__, dst__, src__, interfaceTag__, result__, hostTag__, rate__) \
+ msg__ = (CsrWifiRouterMaPacketCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_PRIM, CSR_WIFI_ROUTER_MA_PACKET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->result = (result__); \
+ msg__->hostTag = (hostTag__); \
+ msg__->rate = (rate__);
+
+#define CsrWifiRouterMaPacketCfmSendTo(dst__, src__, interfaceTag__, result__, hostTag__, rate__) \
+ { \
+ CsrWifiRouterMaPacketCfm *msg__; \
+ CsrWifiRouterMaPacketCfmCreate(msg__, dst__, src__, interfaceTag__, result__, hostTag__, rate__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterMaPacketCfmSend(dst__, interfaceTag__, result__, hostTag__, rate__) \
+ CsrWifiRouterMaPacketCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, interfaceTag__, result__, hostTag__, rate__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketSubscribeReqSend
+
+ DESCRIPTION
+ A task can use this primitive to subscribe for a particular OUI/protocol
+ and transmit and receive frames matching the subscription.
+ NOTE: Multiple subscriptions for a given protocol and OUI will result in
+ the first subscription receiving the data and not the subsequent
+ subscriptions.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ encapsulation - Specifies the encapsulation type, which will be used for the
+ subscription
+ protocol - Together with the OUI, specifies the protocol, which a task
+ wants to subscribe to
+ oui - Specifies the OUI for the protocol, which a task wants to
+ subscribe to
+
+*******************************************************************************/
+#define CsrWifiRouterMaPacketSubscribeReqCreate(msg__, dst__, src__, interfaceTag__, encapsulation__, protocol__, oui__) \
+ msg__ = (CsrWifiRouterMaPacketSubscribeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_PRIM, CSR_WIFI_ROUTER_MA_PACKET_SUBSCRIBE_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->encapsulation = (encapsulation__); \
+ msg__->protocol = (protocol__); \
+ msg__->oui = (oui__);
+
+#define CsrWifiRouterMaPacketSubscribeReqSendTo(dst__, src__, interfaceTag__, encapsulation__, protocol__, oui__) \
+ { \
+ CsrWifiRouterMaPacketSubscribeReq *msg__; \
+ CsrWifiRouterMaPacketSubscribeReqCreate(msg__, dst__, src__, interfaceTag__, encapsulation__, protocol__, oui__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterMaPacketSubscribeReqSend(src__, interfaceTag__, encapsulation__, protocol__, oui__) \
+ CsrWifiRouterMaPacketSubscribeReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, encapsulation__, protocol__, oui__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketSubscribeCfmSend
+
+ DESCRIPTION
+ The router sends this primitive to confirm the result of the
+ subscription.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ subscriptionHandle - Handle to the subscription
+ This handle must be used in all subsequent requests
+ status - Status of the operation
+ allocOffset - Size of the offset for the frames of the subscription
+
+*******************************************************************************/
+#define CsrWifiRouterMaPacketSubscribeCfmCreate(msg__, dst__, src__, interfaceTag__, subscriptionHandle__, status__, allocOffset__) \
+ msg__ = (CsrWifiRouterMaPacketSubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_PRIM, CSR_WIFI_ROUTER_MA_PACKET_SUBSCRIBE_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->subscriptionHandle = (subscriptionHandle__); \
+ msg__->status = (status__); \
+ msg__->allocOffset = (allocOffset__);
+
+#define CsrWifiRouterMaPacketSubscribeCfmSendTo(dst__, src__, interfaceTag__, subscriptionHandle__, status__, allocOffset__) \
+ { \
+ CsrWifiRouterMaPacketSubscribeCfm *msg__; \
+ CsrWifiRouterMaPacketSubscribeCfmCreate(msg__, dst__, src__, interfaceTag__, subscriptionHandle__, status__, allocOffset__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterMaPacketSubscribeCfmSend(dst__, interfaceTag__, subscriptionHandle__, status__, allocOffset__) \
+ CsrWifiRouterMaPacketSubscribeCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, interfaceTag__, subscriptionHandle__, status__, allocOffset__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketUnsubscribeReqSend
+
+ DESCRIPTION
+ A task sends this primitive to unsubscribe a subscription
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ subscriptionHandle - The handle of the subscription
+
+*******************************************************************************/
+#define CsrWifiRouterMaPacketUnsubscribeReqCreate(msg__, dst__, src__, interfaceTag__, subscriptionHandle__) \
+ msg__ = (CsrWifiRouterMaPacketUnsubscribeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketUnsubscribeReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_PRIM, CSR_WIFI_ROUTER_MA_PACKET_UNSUBSCRIBE_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->subscriptionHandle = (subscriptionHandle__);
+
+#define CsrWifiRouterMaPacketUnsubscribeReqSendTo(dst__, src__, interfaceTag__, subscriptionHandle__) \
+ { \
+ CsrWifiRouterMaPacketUnsubscribeReq *msg__; \
+ CsrWifiRouterMaPacketUnsubscribeReqCreate(msg__, dst__, src__, interfaceTag__, subscriptionHandle__); \
+ CsrMsgTransport(dst__, CSR_WIFI_ROUTER_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterMaPacketUnsubscribeReqSend(src__, interfaceTag__, subscriptionHandle__) \
+ CsrWifiRouterMaPacketUnsubscribeReqSendTo(CSR_WIFI_ROUTER_IFACEQUEUE, src__, interfaceTag__, subscriptionHandle__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketUnsubscribeCfmSend
+
+ DESCRIPTION
+ The router sends this primitive to confirm the result of the
+ unsubscription.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Status of the operation
+
+*******************************************************************************/
+#define CsrWifiRouterMaPacketUnsubscribeCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiRouterMaPacketUnsubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketUnsubscribeCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_ROUTER_PRIM, CSR_WIFI_ROUTER_MA_PACKET_UNSUBSCRIBE_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiRouterMaPacketUnsubscribeCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiRouterMaPacketUnsubscribeCfm *msg__; \
+ CsrWifiRouterMaPacketUnsubscribeCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_ROUTER_PRIM, msg__); \
+ }
+
+#define CsrWifiRouterMaPacketUnsubscribeCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiRouterMaPacketUnsubscribeCfmSendTo(dst__, CSR_WIFI_ROUTER_IFACEQUEUE, interfaceTag__, status__)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_LIB_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_ROUTER_PRIM_H__
+#define CSR_WIFI_ROUTER_PRIM_H__
+
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+#include "csr_sched.h"
+#include "csr_wifi_common.h"
+#include "csr_result.h"
+#include "csr_wifi_fsm_event.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CSR_WIFI_ROUTER_PRIM (0x0400)
+
+typedef CsrPrim CsrWifiRouterPrim;
+
+typedef void (*CsrWifiRouterFrameFreeFunction)(void *frame);
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterAppType
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_APP_TYPE_SME -
+ CSR_WIFI_ROUTER_APP_TYPE_PAL -
+ CSR_WIFI_ROUTER_APP_TYPE_NME -
+ CSR_WIFI_ROUTER_APP_TYPE_OTHER -
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterAppType;
+#define CSR_WIFI_ROUTER_APP_TYPE_SME ((CsrWifiRouterAppType) 0x0)
+#define CSR_WIFI_ROUTER_APP_TYPE_PAL ((CsrWifiRouterAppType) 0x1)
+#define CSR_WIFI_ROUTER_APP_TYPE_NME ((CsrWifiRouterAppType) 0x2)
+#define CSR_WIFI_ROUTER_APP_TYPE_OTHER ((CsrWifiRouterAppType) 0x3)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterEncapsulation
+
+ DESCRIPTION
+ Indicates the type of encapsulation used for the subscription
+
+ VALUES
+ CSR_WIFI_ROUTER_ENCAPSULATION_ETHERNET
+ - Ethernet encapsulation
+ CSR_WIFI_ROUTER_ENCAPSULATION_LLC_SNAP
+ - LLC/SNAP encapsulation
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiRouterEncapsulation;
+#define CSR_WIFI_ROUTER_ENCAPSULATION_ETHERNET ((CsrWifiRouterEncapsulation) 0x00)
+#define CSR_WIFI_ROUTER_ENCAPSULATION_LLC_SNAP ((CsrWifiRouterEncapsulation) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterOui
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_ROUTER_OUI_RFC_1042 -
+ CSR_WIFI_ROUTER_OUI_BT -
+
+*******************************************************************************/
+typedef CsrUint32 CsrWifiRouterOui;
+#define CSR_WIFI_ROUTER_OUI_RFC_1042 ((CsrWifiRouterOui) 0x000000)
+#define CSR_WIFI_ROUTER_OUI_BT ((CsrWifiRouterOui) 0x001958)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterPriority
+
+ DESCRIPTION
+ As defined in the IEEE 802.11 standards
+
+ VALUES
+ CSR_WIFI_ROUTER_PRIORITY_QOS_UP0
+ - See IEEE 802.11 Standard
+ CSR_WIFI_ROUTER_PRIORITY_QOS_UP1
+ - See IEEE 802.11 Standard
+ CSR_WIFI_ROUTER_PRIORITY_QOS_UP2
+ - See IEEE 802.11 Standard
+ CSR_WIFI_ROUTER_PRIORITY_QOS_UP3
+ - See IEEE 802.11 Standard
+ CSR_WIFI_ROUTER_PRIORITY_QOS_UP4
+ - See IEEE 802.11 Standard
+ CSR_WIFI_ROUTER_PRIORITY_QOS_UP5
+ - See IEEE 802.11 Standard
+ CSR_WIFI_ROUTER_PRIORITY_QOS_UP6
+ - See IEEE 802.11 Standard
+ CSR_WIFI_ROUTER_PRIORITY_QOS_UP7
+ - See IEEE 802.11 Standard
+ CSR_WIFI_ROUTER_PRIORITY_CONTENTION
+ - See IEEE 802.11 Standard
+ CSR_WIFI_ROUTER_PRIORITY_MANAGEMENT
+ - See IEEE 802.11 Standard
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiRouterPriority;
+#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP0 ((CsrWifiRouterPriority) 0x0000)
+#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP1 ((CsrWifiRouterPriority) 0x0001)
+#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP2 ((CsrWifiRouterPriority) 0x0002)
+#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP3 ((CsrWifiRouterPriority) 0x0003)
+#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP4 ((CsrWifiRouterPriority) 0x0004)
+#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP5 ((CsrWifiRouterPriority) 0x0005)
+#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP6 ((CsrWifiRouterPriority) 0x0006)
+#define CSR_WIFI_ROUTER_PRIORITY_QOS_UP7 ((CsrWifiRouterPriority) 0x0007)
+#define CSR_WIFI_ROUTER_PRIORITY_CONTENTION ((CsrWifiRouterPriority) 0x8000)
+#define CSR_WIFI_ROUTER_PRIORITY_MANAGEMENT ((CsrWifiRouterPriority) 0x8010)
+
+
+/* Downstream */
+#define CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_LOWEST (0x0000)
+
+#define CSR_WIFI_ROUTER_MA_PACKET_SUBSCRIBE_REQ ((CsrWifiRouterPrim) (0x0000 + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_MA_PACKET_UNSUBSCRIBE_REQ ((CsrWifiRouterPrim) (0x0001 + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_MA_PACKET_REQ ((CsrWifiRouterPrim) (0x0002 + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_MA_PACKET_RES ((CsrWifiRouterPrim) (0x0003 + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_MA_PACKET_CANCEL_REQ ((CsrWifiRouterPrim) (0x0004 + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_LOWEST))
+
+
+#define CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_HIGHEST (0x0004 + CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_LOWEST)
+
+/* Upstream */
+#define CSR_WIFI_ROUTER_PRIM_UPSTREAM_LOWEST (0x0000 + CSR_PRIM_UPSTREAM)
+
+#define CSR_WIFI_ROUTER_MA_PACKET_SUBSCRIBE_CFM ((CsrWifiRouterPrim)(0x0000 + CSR_WIFI_ROUTER_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_MA_PACKET_UNSUBSCRIBE_CFM ((CsrWifiRouterPrim)(0x0001 + CSR_WIFI_ROUTER_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_MA_PACKET_CFM ((CsrWifiRouterPrim)(0x0002 + CSR_WIFI_ROUTER_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_ROUTER_MA_PACKET_IND ((CsrWifiRouterPrim)(0x0003 + CSR_WIFI_ROUTER_PRIM_UPSTREAM_LOWEST))
+
+#define CSR_WIFI_ROUTER_PRIM_UPSTREAM_HIGHEST (0x0003 + CSR_WIFI_ROUTER_PRIM_UPSTREAM_LOWEST)
+
+#define CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT (CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_HIGHEST + 1 - CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_LOWEST)
+#define CSR_WIFI_ROUTER_PRIM_UPSTREAM_COUNT (CSR_WIFI_ROUTER_PRIM_UPSTREAM_HIGHEST + 1 - CSR_WIFI_ROUTER_PRIM_UPSTREAM_LOWEST)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketSubscribeReq
+
+ DESCRIPTION
+ A task can use this primitive to subscribe for a particular OUI/protocol
+ and transmit and receive frames matching the subscription.
+ NOTE: Multiple subscriptions for a given protocol and OUI will result in
+ the first subscription receiving the data and not the subsequent
+ subscriptions.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ encapsulation - Specifies the encapsulation type, which will be used for the
+ subscription
+ protocol - Together with the OUI, specifies the protocol, which a task
+ wants to subscribe to
+ oui - Specifies the OUI for the protocol, which a task wants to
+ subscribe to
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiRouterEncapsulation encapsulation;
+ CsrUint16 protocol;
+ CsrUint32 oui;
+} CsrWifiRouterMaPacketSubscribeReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketUnsubscribeReq
+
+ DESCRIPTION
+ A task sends this primitive to unsubscribe a subscription
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ subscriptionHandle - The handle of the subscription
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 subscriptionHandle;
+} CsrWifiRouterMaPacketUnsubscribeReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketReq
+
+ DESCRIPTION
+ A task sends this primitive to transmit a frame.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ subscriptionHandle - The handle of the subscription
+ frameLength - Length of the frame to be sent in bytes
+ frame - Pointer to the frame to be sent
+ freeFunction - Pointer to function to be used to free the frame
+ priority - Priority of the frame, which should be sent
+ hostTag - An application shall set the bits b31..b28 using one of
+ the CSR_WIFI_ROUTER_APP_TYPE_* masks. Bits b0..b27 can
+ be used by the requestor without any restrictions, but
+ the hostTag shall be unique so the hostTag for
+ CSR_WIFI_ROUTER_APP _TYPE_OTHER should be constructured
+ in the following way [ CSR_WIFI_ROUTER_APP_TYPE_OTHER
+ (4 bits) | SubscriptionHandle (8 bits) | Sequence no.
+ (20 bits) ]. If the hostTag is not unique, the
+ behaviour of the system is unpredicatable with respect
+ to data/management frame transfer.
+ cfmRequested - Indicates if the requestor needs a confirm for packet
+ requests sent under this subscription. If set to TRUE,
+ the router will send a confirm, else it will not send
+ any confirm
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 subscriptionHandle;
+ CsrUint16 frameLength;
+ CsrUint8 *frame;
+ CsrWifiRouterFrameFreeFunction freeFunction;
+ CsrWifiRouterPriority priority;
+ CsrUint32 hostTag;
+ CsrBool cfmRequested;
+} CsrWifiRouterMaPacketReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketRes
+
+ DESCRIPTION
+ A task send this primitive to confirm the reception of the received
+ frame.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ subscriptionHandle - The handle of the subscription
+ result - Status of the operation
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 subscriptionHandle;
+ CsrResult result;
+} CsrWifiRouterMaPacketRes;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketCancelReq
+
+ DESCRIPTION
+ This primitive is used to request cancellation of a previously send
+ CsrWifiRouterMaPacketReq.
+ The frame may already have been transmitted so there is no guarantees
+ that the CsrWifiRouterMaPacketCancelReq actually cancels the transmission
+ of the frame in question.
+ If the cancellation fails, the Router will send, if required,
+ CsrWifiRouterMaPacketCfm.
+ If the cancellation succeeds, the Router will not send
+ CsrWifiRouterMaPacketCfm.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ hostTag - The hostTag for the frame, which should be cancelled.
+ priority - Priority of the frame, which should be cancelled
+ peerMacAddress - Destination MAC address of the frame, which should be
+ cancelled
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint32 hostTag;
+ CsrWifiRouterPriority priority;
+ CsrWifiMacAddress peerMacAddress;
+} CsrWifiRouterMaPacketCancelReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketSubscribeCfm
+
+ DESCRIPTION
+ The router sends this primitive to confirm the result of the
+ subscription.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ subscriptionHandle - Handle to the subscription
+ This handle must be used in all subsequent requests
+ status - Status of the operation
+ allocOffset - Size of the offset for the frames of the subscription
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 subscriptionHandle;
+ CsrResult status;
+ CsrUint16 allocOffset;
+} CsrWifiRouterMaPacketSubscribeCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketUnsubscribeCfm
+
+ DESCRIPTION
+ The router sends this primitive to confirm the result of the
+ unsubscription.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Status of the operation
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiRouterMaPacketUnsubscribeCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketCfm
+
+ DESCRIPTION
+ The router sends the primitive to confirm the result of the transmission
+ of the packet of the corresponding CSR_WIFI_ROUTER MA_PACKET_REQ request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ result - Status of the operation
+ hostTag - The hostTrag will match the hostTag sent in the request.
+ rate - Transmission/Reception rate
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult result;
+ CsrUint32 hostTag;
+ CsrUint16 rate;
+} CsrWifiRouterMaPacketCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiRouterMaPacketInd
+
+ DESCRIPTION
+ The router sends the primitive to a subscribed task when it receives a
+ frame matching the subscription.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ subscriptionHandle - The handle of the subscription
+ result - Status of the operation
+ frameLength - Length of the received frame in bytes
+ frame - Pointer to the received frame
+ freeFunction - Pointer to function to be used to free the frame
+ rssi - Received signal strength indication in dBm
+ snr - Signal to Noise Ratio
+ rate - Transmission/Reception rate
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 subscriptionHandle;
+ CsrResult result;
+ CsrUint16 frameLength;
+ CsrUint8 *frame;
+ CsrWifiRouterFrameFreeFunction freeFunction;
+ CsrInt16 rssi;
+ CsrInt16 snr;
+ CsrUint16 rate;
+} CsrWifiRouterMaPacketInd;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_PRIM_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ Confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+ *****************************************************************************/
+#include "csr_wifi_router_sef.h"
+
+const CsrWifiRouterStateHandlerType CsrWifiRouterDownstreamStateHandlers[CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT] =
+{
+ /* 0x0000 */ CsrWifiRouterMaPacketSubscribeReqHandler,
+ /* 0x0001 */ CsrWifiRouterMaPacketUnsubscribeReqHandler,
+ /* 0x0002 */ CsrWifiRouterMaPacketReqHandler,
+ /* 0x0003 */ CsrWifiRouterMaPacketResHandler,
+ /* 0x0004 */ CsrWifiRouterMaPacketCancelReqHandler,
+};
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ Confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+ *****************************************************************************/
+#ifndef CSR_WIFI_ROUTER_SEF_CSR_WIFI_ROUTER_H__
+#define CSR_WIFI_ROUTER_SEF_CSR_WIFI_ROUTER_H__
+
+#include "csr_wifi_router_prim.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ typedef void (*CsrWifiRouterStateHandlerType)(void* drvpriv, CsrWifiFsmEvent* msg);
+
+ extern const CsrWifiRouterStateHandlerType CsrWifiRouterDownstreamStateHandlers[CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_COUNT];
+
+ extern void CsrWifiRouterMaPacketSubscribeReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterMaPacketUnsubscribeReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterMaPacketReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterMaPacketResHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+ extern void CsrWifiRouterMaPacketCancelReqHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_SEF_CSR_WIFI_ROUTER_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_msgconv.h"
+#include "csr_unicode.h"
+
+
+#include "csr_wifi_router_prim.h"
+#include "csr_wifi_router_serialize.h"
+
+void CsrWifiRouterPfree(void *ptr)
+{
+ CsrPmemFree(ptr);
+}
+
+
+CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 12) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiRouterEncapsulation primitive->encapsulation */
+ bufferSize += 2; /* CsrUint16 primitive->protocol */
+ bufferSize += 4; /* CsrUint32 primitive->oui */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterMaPacketSubscribeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->encapsulation);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->protocol);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->oui);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterMaPacketSubscribeReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterMaPacketSubscribeReq *primitive = (CsrWifiRouterMaPacketSubscribeReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->encapsulation, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->protocol, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->oui, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg)
+{
+ CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 20) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrUint8 primitive->subscriptionHandle */
+ bufferSize += 2; /* CsrUint16 primitive->frameLength */
+ bufferSize += primitive->frameLength; /* CsrUint8 primitive->frame */
+ bufferSize += 4; /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
+ bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
+ bufferSize += 4; /* CsrUint32 primitive->hostTag */
+ bufferSize += 1; /* CsrBool primitive->cfmRequested */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterMaPacketReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->frameLength);
+ if (primitive->frameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((CsrUint16) (primitive->frameLength)));
+ }
+ CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->priority);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->cfmRequested);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterMaPacketReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->frameLength, buffer, &offset);
+ if (primitive->frameLength)
+ {
+ primitive->frame = (CsrUint8 *)CsrPmemAlloc(primitive->frameLength);
+ CsrMemCpyDes(primitive->frame, buffer, &offset, ((CsrUint16) (primitive->frameLength)));
+ }
+ else
+ {
+ primitive->frame = NULL;
+ }
+ primitive->freeFunction = NULL; /* Special for Function Pointers... */
+ offset += 4;
+ CsrUint16Des((CsrUint16 *) &primitive->priority, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->cfmRequested, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiRouterMaPacketReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterMaPacketReq *primitive = (CsrWifiRouterMaPacketReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->frame);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiRouterMaPacketResSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrUint8 primitive->subscriptionHandle */
+ bufferSize += 2; /* CsrResult primitive->result */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterMaPacketResSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterMaPacketResDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterMaPacketRes *primitive = (CsrWifiRouterMaPacketRes *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketRes));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 4; /* CsrUint32 primitive->hostTag */
+ bufferSize += 2; /* CsrWifiRouterPriority primitive->priority */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterMaPacketCancelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->priority);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ return(ptr);
+}
+
+
+void* CsrWifiRouterMaPacketCancelReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterMaPacketCancelReq *primitive = (CsrWifiRouterMaPacketCancelReq *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCancelReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->priority, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrUint8 primitive->subscriptionHandle */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 2; /* CsrUint16 primitive->allocOffset */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterMaPacketSubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->allocOffset);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterMaPacketSubscribeCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterMaPacketSubscribeCfm *primitive = (CsrWifiRouterMaPacketSubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketSubscribeCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->allocOffset, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterMaPacketUnsubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterMaPacketUnsubscribeCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterMaPacketUnsubscribeCfm *primitive = (CsrWifiRouterMaPacketUnsubscribeCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketUnsubscribeCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->result */
+ bufferSize += 4; /* CsrUint32 primitive->hostTag */
+ bufferSize += 2; /* CsrUint16 primitive->rate */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterMaPacketCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->hostTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->rate);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterMaPacketCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterMaPacketCfm *primitive = (CsrWifiRouterMaPacketCfm *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->hostTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->rate, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg)
+{
+ CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 21) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrUint8 primitive->subscriptionHandle */
+ bufferSize += 2; /* CsrResult primitive->result */
+ bufferSize += 2; /* CsrUint16 primitive->frameLength */
+ bufferSize += primitive->frameLength; /* CsrUint8 primitive->frame */
+ bufferSize += 4; /* CsrWifiRouterFrameFreeFunction primitive->freeFunction */
+ bufferSize += 2; /* CsrInt16 primitive->rssi */
+ bufferSize += 2; /* CsrInt16 primitive->snr */
+ bufferSize += 2; /* CsrUint16 primitive->rate */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiRouterMaPacketIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->subscriptionHandle);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->frameLength);
+ if (primitive->frameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->frame, ((CsrUint16) (primitive->frameLength)));
+ }
+ CsrUint32Ser(ptr, len, 0); /* Special for Function Pointers... primitive->freeFunction */
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->rssi);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->snr);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->rate);
+ return(ptr);
+}
+
+
+void* CsrWifiRouterMaPacketIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) CsrPmemAlloc(sizeof(CsrWifiRouterMaPacketInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->subscriptionHandle, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->result, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->frameLength, buffer, &offset);
+ if (primitive->frameLength)
+ {
+ primitive->frame = (CsrUint8 *)CsrPmemAlloc(primitive->frameLength);
+ CsrMemCpyDes(primitive->frame, buffer, &offset, ((CsrUint16) (primitive->frameLength)));
+ }
+ else
+ {
+ primitive->frame = NULL;
+ }
+ primitive->freeFunction = NULL; /* Special for Function Pointers... */
+ offset += 4;
+ CsrUint16Des((CsrUint16 *) &primitive->rssi, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->snr, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->rate, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiRouterMaPacketIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiRouterMaPacketInd *primitive = (CsrWifiRouterMaPacketInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->frame);
+ CsrPmemFree(primitive);
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_ROUTER_SERIALIZE_H__
+#define CSR_WIFI_ROUTER_SERIALIZE_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_wifi_msgconv.h"
+
+#include "csr_wifi_router_prim.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void CsrWifiRouterPfree(void *ptr);
+
+extern CsrUint8* CsrWifiRouterMaPacketSubscribeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketSubscribeReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterMaPacketSubscribeReqSizeof(void *msg);
+#define CsrWifiRouterMaPacketSubscribeReqSerFree CsrWifiRouterPfree
+
+#define CsrWifiRouterMaPacketUnsubscribeReqSer CsrWifiEventCsrUint16CsrUint8Ser
+#define CsrWifiRouterMaPacketUnsubscribeReqDes CsrWifiEventCsrUint16CsrUint8Des
+#define CsrWifiRouterMaPacketUnsubscribeReqSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
+#define CsrWifiRouterMaPacketUnsubscribeReqSerFree CsrWifiRouterPfree
+
+extern CsrUint8* CsrWifiRouterMaPacketReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterMaPacketReqSizeof(void *msg);
+extern void CsrWifiRouterMaPacketReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiRouterMaPacketResSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketResDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterMaPacketResSizeof(void *msg);
+#define CsrWifiRouterMaPacketResSerFree CsrWifiRouterPfree
+
+extern CsrUint8* CsrWifiRouterMaPacketCancelReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketCancelReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterMaPacketCancelReqSizeof(void *msg);
+#define CsrWifiRouterMaPacketCancelReqSerFree CsrWifiRouterPfree
+
+extern CsrUint8* CsrWifiRouterMaPacketSubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketSubscribeCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterMaPacketSubscribeCfmSizeof(void *msg);
+#define CsrWifiRouterMaPacketSubscribeCfmSerFree CsrWifiRouterPfree
+
+extern CsrUint8* CsrWifiRouterMaPacketUnsubscribeCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketUnsubscribeCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterMaPacketUnsubscribeCfmSizeof(void *msg);
+#define CsrWifiRouterMaPacketUnsubscribeCfmSerFree CsrWifiRouterPfree
+
+extern CsrUint8* CsrWifiRouterMaPacketCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterMaPacketCfmSizeof(void *msg);
+#define CsrWifiRouterMaPacketCfmSerFree CsrWifiRouterPfree
+
+extern CsrUint8* CsrWifiRouterMaPacketIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiRouterMaPacketIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiRouterMaPacketIndSizeof(void *msg);
+extern void CsrWifiRouterMaPacketIndSerFree(void *msg);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* CSR_WIFI_ROUTER_SERIALIZE_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_ROUTER_TASK_H__
+#define CSR_WIFI_ROUTER_TASK_H__
+
+#include "csr_types.h"
+#include "csr_sched.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CSR_WIFI_ROUTER_LOG_ID 0x1201FFFF
+extern CsrSchedQid CSR_WIFI_ROUTER_IFACEQUEUE;
+void CsrWifiRouterInit(void **gash);
+void CsrWifiRouterDeinit(void **gash);
+void CsrWifiRouterHandler(void **gash);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_TASK_H__ */
+
--- /dev/null
+/** @file router_transport.c
+ *
+ *
+ * Copyright (C) Cambridge Silicon Radio Ltd 2006-2010. All rights reserved.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ ****************************************************************************/
+
+#include "unifi_priv.h"
+
+#include "csr_types.h"
+#include "csr_sched.h"
+#include "csr_msgconv.h"
+
+#include "sme_userspace.h"
+
+#include "csr_wifi_hostio_prim.h"
+#include "csr_wifi_router_lib.h"
+#include "csr_wifi_router_sef.h"
+#include "csr_wifi_router_converter_init.h"
+#include "csr_wifi_router_ctrl_lib.h"
+#include "csr_wifi_router_ctrl_sef.h"
+#include "csr_wifi_router_ctrl_converter_init.h"
+#include "csr_wifi_sme_prim.h"
+#include "csr_wifi_sme_sef.h"
+#include "csr_wifi_sme_converter_init.h"
+#ifdef CSR_SUPPORT_WEXT
+#ifdef CSR_SUPPORT_WEXT_AP
+#include "csr_wifi_nme_ap_prim.h"
+#include "csr_wifi_nme_ap_sef.h"
+#include "csr_wifi_nme_ap_converter_init.h"
+#endif
+#endif
+
+static unifi_priv_t *drvpriv = NULL;
+void CsrWifiRouterTransportInit(unifi_priv_t *priv)
+{
+ unifi_trace(priv, UDBG1, "CsrWifiRouterTransportInit: \n");
+
+ drvpriv = priv;
+ (void)CsrMsgConvInit();
+ CsrWifiRouterConverterInit();
+ CsrWifiRouterCtrlConverterInit();
+ CsrWifiSmeConverterInit();
+#ifdef CSR_SUPPORT_WEXT
+#ifdef CSR_SUPPORT_WEXT_AP
+ CsrWifiNmeApConverterInit();
+#endif
+#endif
+}
+
+void CsrWifiRouterTransportDeinit(unifi_priv_t *priv)
+{
+ unifi_trace(priv, UDBG1, "CsrWifiRouterTransportDeinit: \n");
+ if (priv == drvpriv)
+ {
+ CsrMsgConvDeinit();
+ drvpriv = NULL;
+ }
+}
+
+void CsrWifiRouterTransportRecv(unifi_priv_t *priv, CsrUint8* buffer, CsrSize bufferLength)
+{
+ CsrMsgConvMsgEntry* msgEntry;
+ CsrUint16 primType;
+ CsrSchedQid src;
+ CsrSchedQid dest;
+ CsrUint16 msgType;
+ CsrSize offset = 0;
+ CsrWifiFsmEvent* msg;
+
+ /* Decode the prim and message type */
+ CsrUint16Des(&primType, buffer, &offset);
+ CsrUint16Des(&src, buffer, &offset);
+ CsrUint16Des(&dest, buffer, &offset);
+ CsrUint16Des(&msgType, buffer, &offset);
+ offset -= 2; /* Adjust as the Deserialise Function will read this as well */
+
+ unifi_trace(priv, UDBG4, "CsrWifiRouterTransportRecv: primType=0x%.4X, msgType=0x%.4X, bufferLength=%d\n",
+ primType, msgType, bufferLength);
+
+ /* Special handling for HOSTIO messages.... */
+ if (primType == CSR_WIFI_HOSTIO_PRIM)
+ {
+ CsrWifiRouterCtrlHipReq req = {{CSR_WIFI_ROUTER_CTRL_HIP_REQ, CSR_WIFI_ROUTER_CTRL_PRIM, dest, src, NULL}, 0, NULL, 0, NULL, 0, NULL};
+
+ req.mlmeCommandLength = bufferLength;
+ req.mlmeCommand = buffer;
+
+ offset += 8;/* Skip the id, src, dest and slot number */
+ CsrUint16Des(&req.dataRef1Length, buffer, &offset);
+ offset += 2; /* Skip the slot number */
+ CsrUint16Des(&req.dataRef2Length, buffer, &offset);
+
+ if (req.dataRef1Length)
+ {
+ CsrUint16 dr1Offset = (bufferLength - req.dataRef2Length) - req.dataRef1Length;
+ req.dataRef1 = &buffer[dr1Offset];
+ }
+
+ if (req.dataRef2Length)
+ {
+ CsrUint16 dr2Offset = bufferLength - req.dataRef2Length;
+ req.dataRef2 = &buffer[dr2Offset];
+ }
+
+ /* Copy the hip data but strip off the prim type */
+ req.mlmeCommandLength -= (req.dataRef1Length + req.dataRef2Length + 6);
+ req.mlmeCommand = &buffer[6];
+
+ CsrWifiRouterCtrlHipReqHandler(priv, &req.common);
+ return;
+ }
+
+ msgEntry = CsrMsgConvFindEntry(primType, msgType);
+ if (!msgEntry)
+ {
+ unifi_error(priv, "CsrWifiRouterTransportDeserialiseAndSend can not process the message. primType=0x%.4X, msgType=0x%.4X\n",
+ primType, msgType);
+ dump(buffer, bufferLength);
+ return;
+ }
+
+ msg = (CsrWifiFsmEvent*)(msgEntry->deserFunc)(&buffer[offset], bufferLength - offset);
+
+ msg->primtype = primType;
+ msg->type = msgType;
+ msg->source = src;
+ msg->destination = dest;
+
+ switch(primType)
+ {
+ case CSR_WIFI_ROUTER_CTRL_PRIM:
+ CsrWifiRouterCtrlDownstreamStateHandlers[msg->type - CSR_WIFI_ROUTER_CTRL_PRIM_DOWNSTREAM_LOWEST](priv, msg);
+ CsrWifiRouterCtrlFreeDownstreamMessageContents(CSR_WIFI_ROUTER_CTRL_PRIM, msg);
+ break;
+ case CSR_WIFI_ROUTER_PRIM:
+ CsrWifiRouterDownstreamStateHandlers[msg->type - CSR_WIFI_ROUTER_PRIM_DOWNSTREAM_LOWEST](priv, msg);
+ CsrWifiRouterFreeDownstreamMessageContents(CSR_WIFI_ROUTER_PRIM, msg);
+ break;
+ case CSR_WIFI_SME_PRIM:
+ CsrWifiSmeUpstreamStateHandlers[msg->type - CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST](priv, msg);
+ CsrWifiSmeFreeUpstreamMessageContents(CSR_WIFI_SME_PRIM, msg);
+ break;
+#ifdef CSR_SUPPORT_WEXT
+#ifdef CSR_SUPPORT_WEXT_AP
+ case CSR_WIFI_NME_AP_PRIM:
+ CsrWifiNmeApUpstreamStateHandlers(priv, msg);
+ CsrWifiNmeApFreeUpstreamMessageContents(CSR_WIFI_NME_AP_PRIM, msg);
+ break;
+#endif
+#endif
+ default:
+ unifi_error(priv, "CsrWifiRouterTransportDeserialiseAndSend unhandled prim type 0x%.4X\n", primType);
+ break;
+ }
+ CsrPmemFree(msg);
+}
+
+static void CsrWifiRouterTransportSerialiseAndSend(CsrUint16 primType, void* msg)
+{
+ CsrWifiFsmEvent* evt = (CsrWifiFsmEvent*)msg;
+ CsrMsgConvMsgEntry* msgEntry;
+ CsrSize msgSize;
+ CsrSize encodeBufferLen = 0;
+ CsrSize offset = 0;
+ CsrUint8* encodeBuffer;
+
+ unifi_trace(drvpriv, UDBG4, "CsrWifiRouterTransportSerialiseAndSend: primType=0x%.4X, msgType=0x%.4X\n",
+ primType, evt->type);
+
+ msgEntry = CsrMsgConvFindEntry(primType, evt->type);
+ if (!msgEntry)
+ {
+ unifi_error(drvpriv, "CsrWifiRouterTransportSerialiseAndSend can not process the message. primType=0x%.4X, msgType=0x%.4X\n",
+ primType, evt->type);
+ return;
+ }
+
+ msgSize = 6 + (msgEntry->sizeofFunc)((void*)msg);
+
+ encodeBuffer = CsrPmemAlloc(msgSize);
+
+ /* Encode PrimType */
+ CsrUint16Ser(encodeBuffer, &encodeBufferLen, primType);
+ CsrUint16Ser(encodeBuffer, &encodeBufferLen, evt->source);
+ CsrUint16Ser(encodeBuffer, &encodeBufferLen, evt->destination);
+
+ (void)(msgEntry->serFunc)(&encodeBuffer[encodeBufferLen], &offset, msg);
+ encodeBufferLen += offset;
+
+ uf_sme_queue_message(drvpriv, encodeBuffer, encodeBufferLen);
+
+ /* Do not use msgEntry->freeFunc because the memory is owned by the driver */
+ CsrPmemFree(msg);
+}
+
+#if defined(CSR_LOG_ENABLE) && defined(CSR_LOG_INCLUDE_FILE_NAME_AND_LINE_NUMBER)
+void CsrSchedMessagePutStringLog(CsrSchedQid q, CsrUint16 mi, void *mv, CsrUint32 line, CsrCharString *file)
+#else
+void CsrSchedMessagePut(CsrSchedQid q, CsrUint16 mi, void *mv)
+#endif
+{
+ CsrWifiFsmEvent* evt = (CsrWifiFsmEvent*)mv;
+ evt->destination = q;
+ CsrWifiRouterTransportSerialiseAndSend(mi, mv);
+}
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#include <linux/module.h>
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_util.h"
+#include "csr_msgconv.h"
+#include "csr_wifi_msgconv.h"
+#include "csr_wifi_lib.h"
+
+void CsrUint24Des(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
+{
+ CsrUint32 val;
+
+ val = ((buffer[(*offset) + 2] << 16) |
+ (buffer[(*offset) + 1] << 8) |
+ (buffer[(*offset)]));
+
+ *offset += 3;
+ *v = val;
+}
+
+
+/* Big endian :e.g WSC, TCLAS */
+void CsrUint16DesBigEndian(CsrUint16 *v, CsrUint8 *buffer, CsrSize *offset)
+{
+ CsrUint16 val;
+
+ val = (buffer[(*offset)] << 8) | (buffer[(*offset) + 1]);
+ *offset += 2;
+
+ *v = val;
+}
+
+
+void CsrUint24DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
+{
+ CsrUint32 val;
+
+ val = ((buffer[(*offset)] << 16) |
+ (buffer[(*offset) + 1] << 8) |
+ (buffer[(*offset) + 2]));
+
+ *offset += 3;
+ *v = val;
+}
+
+
+void CsrUint32DesBigEndian(CsrUint32 *v, CsrUint8 *buffer, CsrSize *offset)
+{
+ CsrUint32 val;
+
+ val = ((buffer[(*offset)] << 24) |
+ (buffer[(*offset) + 1] << 16) |
+ (buffer[(*offset) + 2] << 8) |
+ (buffer[(*offset) + 3]));
+
+ *offset += 4;
+ *v = val;
+}
+
+
+void CsrUint24Ser(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
+{
+ ptr[(*len) + 2] = (CsrUint8)((v & 0x00ff0000) >> 16);
+ ptr[(*len) + 1] = (CsrUint8)((v & 0x0000ff00) >> 8);
+ ptr[(*len)] = (CsrUint8)((v & 0x000000ff));
+
+ *len += 3;
+}
+
+
+/* Big endian :e.g WSC, TCLAS */
+void CsrUint16SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint16 v)
+{
+ ptr[(*len)] = (CsrUint8)((v & 0xff00) >> 8);
+ ptr[(*len) + 1] = (CsrUint8)((v & 0x00ff));
+
+ *len += 2;
+}
+
+
+void CsrUint32SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
+{
+ ptr[(*len)] = (CsrUint8)((v & 0xff000000) >> 24);
+ ptr[(*len) + 1] = (CsrUint8)((v & 0x00ff0000) >> 16);
+ ptr[(*len) + 2] = (CsrUint8)((v & 0x0000ff00) >> 8);
+ ptr[(*len) + 3] = (CsrUint8)((v & 0x000000ff));
+
+ *len += 4;
+}
+
+
+void CsrUint24SerBigEndian(CsrUint8 *ptr, CsrSize *len, CsrUint32 v)
+{
+ ptr[(*len)] = (CsrUint8)((v & 0x00ff0000) >> 16);
+ ptr[(*len) + 1] = (CsrUint8)((v & 0x0000ff00) >> 8);
+ ptr[(*len) + 2] = (CsrUint8)((v & 0x000000ff));
+
+ *len += 3;
+}
+
+
+CsrSize CsrWifiEventSizeof(void *msg)
+{
+ return 2;
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventSizeof);
+
+CsrUint8* CsrWifiEventSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->type);
+ return(ptr);
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventSer);
+
+void* CsrWifiEventDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiFsmEvent *primitive = (CsrWifiFsmEvent *) CsrPmemAlloc(sizeof(CsrWifiFsmEvent));
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->type, buffer, &offset);
+
+ return primitive;
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventDes);
+
+CsrSize CsrWifiEventCsrUint8Sizeof(void *msg)
+{
+ return 3;
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Sizeof);
+
+CsrUint8* CsrWifiEventCsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint8Ser(ptr, len, primitive->value);
+ return(ptr);
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Ser);
+
+
+void* CsrWifiEventCsrUint8Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiEventCsrUint8 *primitive = (CsrWifiEventCsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint8));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint8Des(&primitive->value, buffer, &offset);
+
+ return primitive;
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint8Des);
+
+
+CsrSize CsrWifiEventCsrUint16Sizeof(void *msg)
+{
+ return 4;
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Sizeof);
+
+
+CsrUint8* CsrWifiEventCsrUint16Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, primitive->value);
+ return(ptr);
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Ser);
+
+void* CsrWifiEventCsrUint16Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiEventCsrUint16 *primitive = (CsrWifiEventCsrUint16 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des(&primitive->value, buffer, &offset);
+
+ return primitive;
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16Des);
+
+
+CsrSize CsrWifiEventCsrUint32Sizeof(void *msg)
+{
+ return 6;
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Sizeof);
+
+CsrUint8* CsrWifiEventCsrUint32Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint32Ser(ptr, len, primitive->value);
+ return(ptr);
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Ser);
+
+
+void* CsrWifiEventCsrUint32Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiEventCsrUint32 *primitive = (CsrWifiEventCsrUint32 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint32));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint32Des(&primitive->value, buffer, &offset);
+
+ return primitive;
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint32Des);
+
+CsrSize CsrWifiEventCsrUint16CsrUint8Sizeof(void *msg)
+{
+ return 5;
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Sizeof);
+
+CsrUint8* CsrWifiEventCsrUint16CsrUint8Ser(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, primitive->value16);
+ CsrUint8Ser(ptr, len, primitive->value8);
+ return(ptr);
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Ser);
+
+
+void* CsrWifiEventCsrUint16CsrUint8Des(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiEventCsrUint16CsrUint8 *primitive = (CsrWifiEventCsrUint16CsrUint8 *) CsrPmemAlloc(sizeof(CsrWifiEventCsrUint16CsrUint8));
+
+ CsrSize offset = 0;
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des(&primitive->value16, buffer, &offset);
+ CsrUint8Des(&primitive->value8, buffer, &offset);
+
+ return primitive;
+}
+EXPORT_SYMBOL_GPL(CsrWifiEventCsrUint16CsrUint8Des);
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_SME_AP_LIB_H__
+#define CSR_WIFI_SME_AP_LIB_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_sched.h"
+#include "csr_util.h"
+#include "csr_msg_transport.h"
+
+#include "csr_wifi_lib.h"
+
+#include "csr_wifi_sme_ap_prim.h"
+#include "csr_wifi_sme_task.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_AP_ENABLE
+#error CSR_WIFI_AP_ENABLE MUST be defined inorder to use csr_wifi_sme_ap_lib.h
+#endif
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiSmeApFreeUpstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_SME_AP upstream message. Does not
+ * free the message itself, and can only be used for upstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_SME_AP upstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiSmeApFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiSmeApFreeDownstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_SME_AP downstream message. Does not
+ * free the message itself, and can only be used for downstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_SME_AP downstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiSmeApFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * Enum to string functions
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiSmeApAccessTypeToString(CsrWifiSmeApAccessType value);
+const CsrCharString* CsrWifiSmeApAuthSupportToString(CsrWifiSmeApAuthSupport value);
+const CsrCharString* CsrWifiSmeApAuthTypeToString(CsrWifiSmeApAuthType value);
+const CsrCharString* CsrWifiSmeApDirectionToString(CsrWifiSmeApDirection value);
+const CsrCharString* CsrWifiSmeApPhySupportToString(CsrWifiSmeApPhySupport value);
+const CsrCharString* CsrWifiSmeApTypeToString(CsrWifiSmeApType value);
+
+
+/*----------------------------------------------------------------------------*
+ * CsrPrim Type toString function.
+ * Converts a message type to the String name of the Message
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiSmeApPrimTypeToString(CsrPrim msgType);
+
+/*----------------------------------------------------------------------------*
+ * Lookup arrays for PrimType name Strings
+ *----------------------------------------------------------------------------*/
+extern const CsrCharString *CsrWifiSmeApUpstreamPrimNames[CSR_WIFI_SME_AP_PRIM_UPSTREAM_COUNT];
+extern const CsrCharString *CsrWifiSmeApDownstreamPrimNames[CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_COUNT];
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApActiveBaGetReqSend
+
+ DESCRIPTION
+ This primitive used to retrieve information related to the active block
+ ack sessions
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+
+*******************************************************************************/
+#define CsrWifiSmeApActiveBaGetReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeApActiveBaGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeApActiveBaGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_ACTIVE_BA_GET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeApActiveBaGetReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeApActiveBaGetReq *msg__; \
+ CsrWifiSmeApActiveBaGetReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApActiveBaGetReqSend(src__, interfaceTag__) \
+ CsrWifiSmeApActiveBaGetReqSendTo(CSR_WIFI_SME_IFACEQUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApActiveBaGetCfmSend
+
+ DESCRIPTION
+ This primitive carries the information related to the active ba sessions
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag -
+ status - Reports the result of the request
+ activeBaCount - Number of active block ack session
+ activeBaSessions - Points to a buffer containing an array of
+ CsrWifiSmeApBaSession structures.
+
+*******************************************************************************/
+#define CsrWifiSmeApActiveBaGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, activeBaCount__, activeBaSessions__) \
+ msg__ = (CsrWifiSmeApActiveBaGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeApActiveBaGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_ACTIVE_BA_GET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->activeBaCount = (activeBaCount__); \
+ msg__->activeBaSessions = (activeBaSessions__);
+
+#define CsrWifiSmeApActiveBaGetCfmSendTo(dst__, src__, interfaceTag__, status__, activeBaCount__, activeBaSessions__) \
+ { \
+ CsrWifiSmeApActiveBaGetCfm *msg__; \
+ CsrWifiSmeApActiveBaGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, activeBaCount__, activeBaSessions__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApActiveBaGetCfmSend(dst__, interfaceTag__, status__, activeBaCount__, activeBaSessions__) \
+ CsrWifiSmeApActiveBaGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, activeBaCount__, activeBaSessions__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBaDeleteReqSend
+
+ DESCRIPTION
+ This primitive is used to delete an active block ack session
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ reason -
+ baSession - BA session to be deleted
+
+*******************************************************************************/
+#define CsrWifiSmeApBaDeleteReqCreate(msg__, dst__, src__, interfaceTag__, reason__, baSession__) \
+ msg__ = (CsrWifiSmeApBaDeleteReq *) CsrPmemAlloc(sizeof(CsrWifiSmeApBaDeleteReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_BA_DELETE_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->reason = (reason__); \
+ msg__->baSession = (baSession__);
+
+#define CsrWifiSmeApBaDeleteReqSendTo(dst__, src__, interfaceTag__, reason__, baSession__) \
+ { \
+ CsrWifiSmeApBaDeleteReq *msg__; \
+ CsrWifiSmeApBaDeleteReqCreate(msg__, dst__, src__, interfaceTag__, reason__, baSession__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApBaDeleteReqSend(src__, interfaceTag__, reason__, baSession__) \
+ CsrWifiSmeApBaDeleteReqSendTo(CSR_WIFI_SME_IFACEQUEUE, src__, interfaceTag__, reason__, baSession__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBaDeleteCfmSend
+
+ DESCRIPTION
+ This primitive confirms the BA is deleted
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag -
+ status - Reports the result of the request
+ baSession - deleted BA session
+
+*******************************************************************************/
+#define CsrWifiSmeApBaDeleteCfmCreate(msg__, dst__, src__, interfaceTag__, status__, baSession__) \
+ msg__ = (CsrWifiSmeApBaDeleteCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeApBaDeleteCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_BA_DELETE_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->baSession = (baSession__);
+
+#define CsrWifiSmeApBaDeleteCfmSendTo(dst__, src__, interfaceTag__, status__, baSession__) \
+ { \
+ CsrWifiSmeApBaDeleteCfm *msg__; \
+ CsrWifiSmeApBaDeleteCfmCreate(msg__, dst__, src__, interfaceTag__, status__, baSession__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApBaDeleteCfmSend(dst__, interfaceTag__, status__, baSession__) \
+ CsrWifiSmeApBaDeleteCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, baSession__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBeaconingStartReqSend
+
+ DESCRIPTION
+ This primitive requests the SME to start AP or GO functionality
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ initialPresence - Set to 0, if Not in a group fomration phase, set to 1 ,
+ during group formation phase
+ apType - apType : Legacy AP or P2PGO
+ cloakSsid - cloakSsid flag.
+ ssid - ssid.
+ ifIndex - Radio Interface
+ channel - channel.
+ maxConnections - Maximum Stations + P2PClients allowed
+ apCredentials - AP security credeitals used to advertise in beacon /probe
+ response
+ smeApConfig - AP configuration
+ p2pGoParam - P2P specific GO parameters. Ignored if it is a leagacy AP
+
+*******************************************************************************/
+#define CsrWifiSmeApBeaconingStartReqCreate(msg__, dst__, src__, interfaceTag__, initialPresence__, apType__, cloakSsid__, ssid__, ifIndex__, channel__, maxConnections__, apCredentials__, smeApConfig__, p2pGoParam__) \
+ msg__ = (CsrWifiSmeApBeaconingStartReq *) CsrPmemAlloc(sizeof(CsrWifiSmeApBeaconingStartReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_BEACONING_START_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->initialPresence = (initialPresence__); \
+ msg__->apType = (apType__); \
+ msg__->cloakSsid = (cloakSsid__); \
+ msg__->ssid = (ssid__); \
+ msg__->ifIndex = (ifIndex__); \
+ msg__->channel = (channel__); \
+ msg__->maxConnections = (maxConnections__); \
+ msg__->apCredentials = (apCredentials__); \
+ msg__->smeApConfig = (smeApConfig__); \
+ msg__->p2pGoParam = (p2pGoParam__);
+
+#define CsrWifiSmeApBeaconingStartReqSendTo(dst__, src__, interfaceTag__, initialPresence__, apType__, cloakSsid__, ssid__, ifIndex__, channel__, maxConnections__, apCredentials__, smeApConfig__, p2pGoParam__) \
+ { \
+ CsrWifiSmeApBeaconingStartReq *msg__; \
+ CsrWifiSmeApBeaconingStartReqCreate(msg__, dst__, src__, interfaceTag__, initialPresence__, apType__, cloakSsid__, ssid__, ifIndex__, channel__, maxConnections__, apCredentials__, smeApConfig__, p2pGoParam__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApBeaconingStartReqSend(src__, interfaceTag__, initialPresence__, apType__, cloakSsid__, ssid__, ifIndex__, channel__, maxConnections__, apCredentials__, smeApConfig__, p2pGoParam__) \
+ CsrWifiSmeApBeaconingStartReqSendTo(CSR_WIFI_SME_IFACEQUEUE, src__, interfaceTag__, initialPresence__, apType__, cloakSsid__, ssid__, ifIndex__, channel__, maxConnections__, apCredentials__, smeApConfig__, p2pGoParam__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBeaconingStartCfmSend
+
+ DESCRIPTION
+ This primitive confirms the completion of the request along with the
+ status
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag -
+ status -
+ secIeLength -
+ secIe -
+
+*******************************************************************************/
+#define CsrWifiSmeApBeaconingStartCfmCreate(msg__, dst__, src__, interfaceTag__, status__, secIeLength__, secIe__) \
+ msg__ = (CsrWifiSmeApBeaconingStartCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeApBeaconingStartCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_BEACONING_START_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->secIeLength = (secIeLength__); \
+ msg__->secIe = (secIe__);
+
+#define CsrWifiSmeApBeaconingStartCfmSendTo(dst__, src__, interfaceTag__, status__, secIeLength__, secIe__) \
+ { \
+ CsrWifiSmeApBeaconingStartCfm *msg__; \
+ CsrWifiSmeApBeaconingStartCfmCreate(msg__, dst__, src__, interfaceTag__, status__, secIeLength__, secIe__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApBeaconingStartCfmSend(dst__, interfaceTag__, status__, secIeLength__, secIe__) \
+ CsrWifiSmeApBeaconingStartCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, secIeLength__, secIe__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBeaconingStopReqSend
+
+ DESCRIPTION
+ This primitive requests the SME to STOP AP or P2PGO operation
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+
+*******************************************************************************/
+#define CsrWifiSmeApBeaconingStopReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeApBeaconingStopReq *) CsrPmemAlloc(sizeof(CsrWifiSmeApBeaconingStopReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_BEACONING_STOP_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeApBeaconingStopReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeApBeaconingStopReq *msg__; \
+ CsrWifiSmeApBeaconingStopReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApBeaconingStopReqSend(src__, interfaceTag__) \
+ CsrWifiSmeApBeaconingStopReqSendTo(CSR_WIFI_SME_IFACEQUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBeaconingStopCfmSend
+
+ DESCRIPTION
+ This primitive confirms AP or P2PGO operation is terminated
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiSmeApBeaconingStopCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeApBeaconingStopCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeApBeaconingStopCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_BEACONING_STOP_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeApBeaconingStopCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeApBeaconingStopCfm *msg__; \
+ CsrWifiSmeApBeaconingStopCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApBeaconingStopCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeApBeaconingStopCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApErrorIndSend
+
+ DESCRIPTION
+ This primitve is sent by SME to indicate some error in AP operationi
+ after AP operations were started successfully and continuing the AP
+ operation may lead to undesired behaviour. It is the responsibility of
+ the upper layers to stop AP operation if needed
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Range 0-1
+ apType -
+ status - Contains the error status
+
+*******************************************************************************/
+#define CsrWifiSmeApErrorIndCreate(msg__, dst__, src__, interfaceTag__, apType__, status__) \
+ msg__ = (CsrWifiSmeApErrorInd *) CsrPmemAlloc(sizeof(CsrWifiSmeApErrorInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_ERROR_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->apType = (apType__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeApErrorIndSendTo(dst__, src__, interfaceTag__, apType__, status__) \
+ { \
+ CsrWifiSmeApErrorInd *msg__; \
+ CsrWifiSmeApErrorIndCreate(msg__, dst__, src__, interfaceTag__, apType__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApErrorIndSend(dst__, interfaceTag__, apType__, status__) \
+ CsrWifiSmeApErrorIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, apType__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApStaConnectStartIndSend
+
+ DESCRIPTION
+ This primitive indicates that a stations request to join the group/BSS is
+ accepted
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag -
+ peerMacAddress -
+
+*******************************************************************************/
+#define CsrWifiSmeApStaConnectStartIndCreate(msg__, dst__, src__, interfaceTag__, peerMacAddress__) \
+ msg__ = (CsrWifiSmeApStaConnectStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeApStaConnectStartInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_STA_CONNECT_START_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->peerMacAddress = (peerMacAddress__);
+
+#define CsrWifiSmeApStaConnectStartIndSendTo(dst__, src__, interfaceTag__, peerMacAddress__) \
+ { \
+ CsrWifiSmeApStaConnectStartInd *msg__; \
+ CsrWifiSmeApStaConnectStartIndCreate(msg__, dst__, src__, interfaceTag__, peerMacAddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApStaConnectStartIndSend(dst__, interfaceTag__, peerMacAddress__) \
+ CsrWifiSmeApStaConnectStartIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, peerMacAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApStaDisconnectReqSend
+
+ DESCRIPTION
+ This primitive tells SME to deauth ot disassociate a particular station
+ within BSS
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ deauthReason -
+ disassocReason -
+ peerMacaddress -
+ keepBlocking - If TRUE, the station is blocked. If FALSE and the station
+ is connected, disconnect the station. If FALSE and the
+ station is not connected, no action is taken.
+
+*******************************************************************************/
+#define CsrWifiSmeApStaDisconnectReqCreate(msg__, dst__, src__, interfaceTag__, deauthReason__, disassocReason__, peerMacaddress__, keepBlocking__) \
+ msg__ = (CsrWifiSmeApStaDisconnectReq *) CsrPmemAlloc(sizeof(CsrWifiSmeApStaDisconnectReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_STA_DISCONNECT_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->deauthReason = (deauthReason__); \
+ msg__->disassocReason = (disassocReason__); \
+ msg__->peerMacaddress = (peerMacaddress__); \
+ msg__->keepBlocking = (keepBlocking__);
+
+#define CsrWifiSmeApStaDisconnectReqSendTo(dst__, src__, interfaceTag__, deauthReason__, disassocReason__, peerMacaddress__, keepBlocking__) \
+ { \
+ CsrWifiSmeApStaDisconnectReq *msg__; \
+ CsrWifiSmeApStaDisconnectReqCreate(msg__, dst__, src__, interfaceTag__, deauthReason__, disassocReason__, peerMacaddress__, keepBlocking__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApStaDisconnectReqSend(src__, interfaceTag__, deauthReason__, disassocReason__, peerMacaddress__, keepBlocking__) \
+ CsrWifiSmeApStaDisconnectReqSendTo(CSR_WIFI_SME_IFACEQUEUE, src__, interfaceTag__, deauthReason__, disassocReason__, peerMacaddress__, keepBlocking__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApStaDisconnectCfmSend
+
+ DESCRIPTION
+ This primitive confirms the station is disconnected
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag -
+ status -
+ peerMacaddress -
+
+*******************************************************************************/
+#define CsrWifiSmeApStaDisconnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__, peerMacaddress__) \
+ msg__ = (CsrWifiSmeApStaDisconnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeApStaDisconnectCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_STA_DISCONNECT_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->peerMacaddress = (peerMacaddress__);
+
+#define CsrWifiSmeApStaDisconnectCfmSendTo(dst__, src__, interfaceTag__, status__, peerMacaddress__) \
+ { \
+ CsrWifiSmeApStaDisconnectCfm *msg__; \
+ CsrWifiSmeApStaDisconnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__, peerMacaddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApStaDisconnectCfmSend(dst__, interfaceTag__, status__, peerMacaddress__) \
+ CsrWifiSmeApStaDisconnectCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, peerMacaddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApStaNotifyIndSend
+
+ DESCRIPTION
+ This primitive indicates that a station has joined or a previously joined
+ station has left the BSS/group
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag -
+ mediaStatus -
+ peerMacAddress -
+ peerDeviceAddress -
+ disassocReason -
+ deauthReason -
+ WpsRegistration -
+ secIeLength -
+ secIe -
+ groupKeyId -
+ seqNumber -
+
+*******************************************************************************/
+#define CsrWifiSmeApStaNotifyIndCreate(msg__, dst__, src__, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__, disassocReason__, deauthReason__, WpsRegistration__, secIeLength__, secIe__, groupKeyId__, seqNumber__) \
+ msg__ = (CsrWifiSmeApStaNotifyInd *) CsrPmemAlloc(sizeof(CsrWifiSmeApStaNotifyInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_STA_NOTIFY_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->mediaStatus = (mediaStatus__); \
+ msg__->peerMacAddress = (peerMacAddress__); \
+ msg__->peerDeviceAddress = (peerDeviceAddress__); \
+ msg__->disassocReason = (disassocReason__); \
+ msg__->deauthReason = (deauthReason__); \
+ msg__->WpsRegistration = (WpsRegistration__); \
+ msg__->secIeLength = (secIeLength__); \
+ msg__->secIe = (secIe__); \
+ msg__->groupKeyId = (groupKeyId__); \
+ CsrMemCpy(msg__->seqNumber, (seqNumber__), sizeof(CsrUint16) * 8);
+
+#define CsrWifiSmeApStaNotifyIndSendTo(dst__, src__, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__, disassocReason__, deauthReason__, WpsRegistration__, secIeLength__, secIe__, groupKeyId__, seqNumber__) \
+ { \
+ CsrWifiSmeApStaNotifyInd *msg__; \
+ CsrWifiSmeApStaNotifyIndCreate(msg__, dst__, src__, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__, disassocReason__, deauthReason__, WpsRegistration__, secIeLength__, secIe__, groupKeyId__, seqNumber__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApStaNotifyIndSend(dst__, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__, disassocReason__, deauthReason__, WpsRegistration__, secIeLength__, secIe__, groupKeyId__, seqNumber__) \
+ CsrWifiSmeApStaNotifyIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, mediaStatus__, peerMacAddress__, peerDeviceAddress__, disassocReason__, deauthReason__, WpsRegistration__, secIeLength__, secIe__, groupKeyId__, seqNumber__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWmmParamUpdateReqSend
+
+ DESCRIPTION
+ Application uses this primitive to update the WMM parameters on the fly
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ wmmApParams - WMM parameters to be used for local firmware queue
+ configuration
+ wmmApBcParams - WMM parameters to be advertised in beacon/probe response
+
+*******************************************************************************/
+#define CsrWifiSmeApWmmParamUpdateReqCreate(msg__, dst__, src__, interfaceTag__, wmmApParams__, wmmApBcParams__) \
+ msg__ = (CsrWifiSmeApWmmParamUpdateReq *) CsrPmemAlloc(sizeof(CsrWifiSmeApWmmParamUpdateReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_WMM_PARAM_UPDATE_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ CsrMemCpy(msg__->wmmApParams, (wmmApParams__), sizeof(CsrWifiSmeWmmAcParams) * 4); \
+ CsrMemCpy(msg__->wmmApBcParams, (wmmApBcParams__), sizeof(CsrWifiSmeWmmAcParams) * 4);
+
+#define CsrWifiSmeApWmmParamUpdateReqSendTo(dst__, src__, interfaceTag__, wmmApParams__, wmmApBcParams__) \
+ { \
+ CsrWifiSmeApWmmParamUpdateReq *msg__; \
+ CsrWifiSmeApWmmParamUpdateReqCreate(msg__, dst__, src__, interfaceTag__, wmmApParams__, wmmApBcParams__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApWmmParamUpdateReqSend(src__, interfaceTag__, wmmApParams__, wmmApBcParams__) \
+ CsrWifiSmeApWmmParamUpdateReqSendTo(CSR_WIFI_SME_IFACEQUEUE, src__, interfaceTag__, wmmApParams__, wmmApBcParams__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWmmParamUpdateCfmSend
+
+ DESCRIPTION
+ A confirm for CSR_WIFI_SME_AP_WMM_PARAM_UPDATE.request
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiSmeApWmmParamUpdateCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeApWmmParamUpdateCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeApWmmParamUpdateCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_WMM_PARAM_UPDATE_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeApWmmParamUpdateCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeApWmmParamUpdateCfm *msg__; \
+ CsrWifiSmeApWmmParamUpdateCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApWmmParamUpdateCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeApWmmParamUpdateCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsConfigurationReqSend
+
+ DESCRIPTION
+ This primitive passes the WPS information for the device to SME. This may
+ be accepted only if no interface is active.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ wpsConfig - WPS config.
+
+*******************************************************************************/
+#define CsrWifiSmeApWpsConfigurationReqCreate(msg__, dst__, src__, wpsConfig__) \
+ msg__ = (CsrWifiSmeApWpsConfigurationReq *) CsrPmemAlloc(sizeof(CsrWifiSmeApWpsConfigurationReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_WPS_CONFIGURATION_REQ, dst__, src__); \
+ msg__->wpsConfig = (wpsConfig__);
+
+#define CsrWifiSmeApWpsConfigurationReqSendTo(dst__, src__, wpsConfig__) \
+ { \
+ CsrWifiSmeApWpsConfigurationReq *msg__; \
+ CsrWifiSmeApWpsConfigurationReqCreate(msg__, dst__, src__, wpsConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApWpsConfigurationReqSend(src__, wpsConfig__) \
+ CsrWifiSmeApWpsConfigurationReqSendTo(CSR_WIFI_SME_IFACEQUEUE, src__, wpsConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsConfigurationCfmSend
+
+ DESCRIPTION
+ Confirm.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Status of the request.
+
+*******************************************************************************/
+#define CsrWifiSmeApWpsConfigurationCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeApWpsConfigurationCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeApWpsConfigurationCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_WPS_CONFIGURATION_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeApWpsConfigurationCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeApWpsConfigurationCfm *msg__; \
+ CsrWifiSmeApWpsConfigurationCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApWpsConfigurationCfmSend(dst__, status__) \
+ CsrWifiSmeApWpsConfigurationCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsRegistrationFinishedReqSend
+
+ DESCRIPTION
+ This primitive tells SME that WPS registration procedure has finished
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+
+*******************************************************************************/
+#define CsrWifiSmeApWpsRegistrationFinishedReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeApWpsRegistrationFinishedReq *) CsrPmemAlloc(sizeof(CsrWifiSmeApWpsRegistrationFinishedReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_WPS_REGISTRATION_FINISHED_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeApWpsRegistrationFinishedReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeApWpsRegistrationFinishedReq *msg__; \
+ CsrWifiSmeApWpsRegistrationFinishedReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApWpsRegistrationFinishedReqSend(src__, interfaceTag__) \
+ CsrWifiSmeApWpsRegistrationFinishedReqSendTo(CSR_WIFI_SME_IFACEQUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsRegistrationFinishedCfmSend
+
+ DESCRIPTION
+ A confirm for UNIFI_MGT_AP_WPS_REGISTRATION_FINISHED.request
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiSmeApWpsRegistrationFinishedCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeApWpsRegistrationFinishedCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeApWpsRegistrationFinishedCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_WPS_REGISTRATION_FINISHED_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeApWpsRegistrationFinishedCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeApWpsRegistrationFinishedCfm *msg__; \
+ CsrWifiSmeApWpsRegistrationFinishedCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApWpsRegistrationFinishedCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeApWpsRegistrationFinishedCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsRegistrationStartedReqSend
+
+ DESCRIPTION
+ This primitive tells SME that WPS registration procedure has started
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag -
+ SelectedDevicePasswordId -
+ SelectedconfigMethod -
+
+*******************************************************************************/
+#define CsrWifiSmeApWpsRegistrationStartedReqCreate(msg__, dst__, src__, interfaceTag__, SelectedDevicePasswordId__, SelectedconfigMethod__) \
+ msg__ = (CsrWifiSmeApWpsRegistrationStartedReq *) CsrPmemAlloc(sizeof(CsrWifiSmeApWpsRegistrationStartedReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_WPS_REGISTRATION_STARTED_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->SelectedDevicePasswordId = (SelectedDevicePasswordId__); \
+ msg__->SelectedconfigMethod = (SelectedconfigMethod__);
+
+#define CsrWifiSmeApWpsRegistrationStartedReqSendTo(dst__, src__, interfaceTag__, SelectedDevicePasswordId__, SelectedconfigMethod__) \
+ { \
+ CsrWifiSmeApWpsRegistrationStartedReq *msg__; \
+ CsrWifiSmeApWpsRegistrationStartedReqCreate(msg__, dst__, src__, interfaceTag__, SelectedDevicePasswordId__, SelectedconfigMethod__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApWpsRegistrationStartedReqSend(src__, interfaceTag__, SelectedDevicePasswordId__, SelectedconfigMethod__) \
+ CsrWifiSmeApWpsRegistrationStartedReqSendTo(CSR_WIFI_SME_IFACEQUEUE, src__, interfaceTag__, SelectedDevicePasswordId__, SelectedconfigMethod__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsRegistrationStartedCfmSend
+
+ DESCRIPTION
+ A confirm for UNIFI_MGT_AP_WPS_REGISTRATION_STARTED.request
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+#define CsrWifiSmeApWpsRegistrationStartedCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeApWpsRegistrationStartedCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeApWpsRegistrationStartedCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_AP_PRIM, CSR_WIFI_SME_AP_WPS_REGISTRATION_STARTED_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeApWpsRegistrationStartedCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeApWpsRegistrationStartedCfm *msg__; \
+ CsrWifiSmeApWpsRegistrationStartedCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_AP_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeApWpsRegistrationStartedCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeApWpsRegistrationStartedCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_SME_AP_LIB_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_SME_AP_PRIM_H__
+#define CSR_WIFI_SME_AP_PRIM_H__
+
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+#include "csr_sched.h"
+#include "csr_wifi_common.h"
+#include "csr_result.h"
+#include "csr_wifi_fsm_event.h"
+#include "csr_wifi_sme_prim.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CSR_WIFI_AP_ENABLE
+#error CSR_WIFI_AP_ENABLE MUST be defined inorder to use csr_wifi_sme_ap_prim.h
+#endif
+
+#define CSR_WIFI_SME_AP_PRIM (0x0407)
+
+typedef CsrPrim CsrWifiSmeApPrim;
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApAccessType
+
+ DESCRIPTION
+ Allow or deny STAs based on MAC address
+
+ VALUES
+ CSR_WIFI_AP_ACCESS_TYPE_NONE - None
+ CSR_WIFI_AP_ACCESS_TYPE_ALLOW - Allow only if MAC address is from the list
+ CSR_WIFI_AP_ACCESS_TYPE_DENY - Disallow if MAC address is from the list
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeApAccessType;
+#define CSR_WIFI_AP_ACCESS_TYPE_NONE ((CsrWifiSmeApAccessType) 0x00)
+#define CSR_WIFI_AP_ACCESS_TYPE_ALLOW ((CsrWifiSmeApAccessType) 0x01)
+#define CSR_WIFI_AP_ACCESS_TYPE_DENY ((CsrWifiSmeApAccessType) 0x02)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApAuthSupport
+
+ DESCRIPTION
+ Define bits for AP authentication support
+
+ VALUES
+ CSR_WIFI_SME_RSN_AUTH_WPAPSK - RSN WPA-PSK Support
+ CSR_WIFI_SME_RSN_AUTH_WPA2PSK - RSN WPA2-PSK Support
+ CSR_WIFI_SME_AUTH_WAPIPSK - WAPI-PSK Support
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeApAuthSupport;
+#define CSR_WIFI_SME_RSN_AUTH_WPAPSK ((CsrWifiSmeApAuthSupport) 0x01)
+#define CSR_WIFI_SME_RSN_AUTH_WPA2PSK ((CsrWifiSmeApAuthSupport) 0x02)
+#define CSR_WIFI_SME_AUTH_WAPIPSK ((CsrWifiSmeApAuthSupport) 0x04)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApAuthType
+
+ DESCRIPTION
+ Definition of the SME AP Authentication Options
+
+ VALUES
+ CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM
+ - Open authentication
+ CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL
+ - Personal authentication using a passphrase or a pre-shared
+ key.
+ CSR_WIFI_SME_AP_AUTH_TYPE_WEP
+ - WEP authentication. This can be either open or shared key
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeApAuthType;
+#define CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM ((CsrWifiSmeApAuthType) 0x00)
+#define CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL ((CsrWifiSmeApAuthType) 0x01)
+#define CSR_WIFI_SME_AP_AUTH_TYPE_WEP ((CsrWifiSmeApAuthType) 0x02)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApDirection
+
+ DESCRIPTION
+ Definition of Direction
+
+ VALUES
+ CSR_WIFI_AP_DIRECTION_RECEIPIENT - Receipient
+ CSR_WIFI_AP_DIRECTION_ORIGINATOR - Originator
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeApDirection;
+#define CSR_WIFI_AP_DIRECTION_RECEIPIENT ((CsrWifiSmeApDirection) 0x00)
+#define CSR_WIFI_AP_DIRECTION_ORIGINATOR ((CsrWifiSmeApDirection) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApPhySupport
+
+ DESCRIPTION
+ Define bits for CsrWifiSmeApPhySupportMask
+
+ VALUES
+ CSR_WIFI_SME_AP_PHY_SUPPORT_A - 802.11a. It is not supported in the current
+ release.
+ CSR_WIFI_SME_AP_PHY_SUPPORT_B - 802.11b
+ CSR_WIFI_SME_AP_PHY_SUPPORT_G - 802.11g
+ CSR_WIFI_SME_AP_PHY_SUPPORT_N - 802.11n
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeApPhySupport;
+#define CSR_WIFI_SME_AP_PHY_SUPPORT_A ((CsrWifiSmeApPhySupport) 0x01)
+#define CSR_WIFI_SME_AP_PHY_SUPPORT_B ((CsrWifiSmeApPhySupport) 0x02)
+#define CSR_WIFI_SME_AP_PHY_SUPPORT_G ((CsrWifiSmeApPhySupport) 0x04)
+#define CSR_WIFI_SME_AP_PHY_SUPPORT_N ((CsrWifiSmeApPhySupport) 0x08)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApType
+
+ DESCRIPTION
+ Definition of AP types
+
+ VALUES
+ CSR_WIFI_AP_TYPE_LEGACY - Legacy AP
+ CSR_WIFI_AP_TYPE_P2P - P2P Group Owner(GO)
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeApType;
+#define CSR_WIFI_AP_TYPE_LEGACY ((CsrWifiSmeApType) 0x00)
+#define CSR_WIFI_AP_TYPE_P2P ((CsrWifiSmeApType) 0x01)
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApAuthSupportMask
+
+ DESCRIPTION
+ See CsrWifiSmeApAuthSupport for bit definitions
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeApAuthSupportMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApPhySupportMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeApPhySupport
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeApPhySupportMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApRsnCapabilities
+
+ DESCRIPTION
+ Set to 0 for the current release
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeApRsnCapabilities;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApRsnCapabilitiesMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeApRsnCapabilities
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeApRsnCapabilitiesMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWapiCapabilities
+
+ DESCRIPTION
+ Ignored by the stack as WAPI is not supported for AP operations in the
+ current release
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeApWapiCapabilities;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWapiCapabilitiesMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeApWapiCapabilities
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeApWapiCapabilitiesMask;
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApHtParams
+
+ DESCRIPTION
+ Structure holding HT parameters
+
+ MEMBERS
+ greenfieldSupported - Indicates if the AP supports Htgreenfield operation
+ subject to the chip capability. If the chip does not
+ support Htgreenfield operation, this parameter will be
+ ignored.
+ NOTE: if shortGi20MHz is set to TRUE and the chip
+ supports short GI operation for 20MHz this field will
+ be be ignored and the AP will not support Htgreenfield
+ operation.
+ NOTE: This field is ignored by the Wi-Fi stack for the
+ current release. It implies that AP does not support
+ greenfield operation.
+ shortGi20MHz - Indicates if the AP support short GI operation for
+ 20MHz subject to the chip capability.If the chip does
+ not support short GI for 20MHz, this parameter is
+ ignored
+ rxStbc - Support for STBC for receive. 0 => No support for STBC
+ , 1=> Use STBC for Rx
+ rifsModeAllowed - RIFS Mode is allowed to protect overlapping non-HT BSS
+ htProtection - Deprecated
+ dualCtsProtection - Dual CTS Protection enabled
+
+*******************************************************************************/
+typedef struct
+{
+ CsrBool greenfieldSupported;
+ CsrBool shortGi20MHz;
+ CsrUint8 rxStbc;
+ CsrBool rifsModeAllowed;
+ CsrUint8 htProtection;
+ CsrBool dualCtsProtection;
+} CsrWifiSmeApHtParams;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApP2pOperatingChanEntry
+
+ DESCRIPTION
+
+ MEMBERS
+ operatingClass - Channel operating class
+ operatingChannelCount - Number of channels in this entry
+ operatingChannel - List of channels
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 operatingClass;
+ CsrUint8 operatingChannelCount;
+ CsrUint8 *operatingChannel;
+} CsrWifiSmeApP2pOperatingChanEntry;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApP2pOperatingChanList
+
+ DESCRIPTION
+ This structure contains the lists of P2P operating channels
+
+ MEMBERS
+ country - Country
+ channelEntryListCount - Number of entries
+ channelEntryList - List of entries
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 country[3];
+ CsrUint8 channelEntryListCount;
+ CsrWifiSmeApP2pOperatingChanEntry *channelEntryList;
+} CsrWifiSmeApP2pOperatingChanList;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApAuthPers
+
+ DESCRIPTION
+
+ MEMBERS
+ authSupport -
+ encryptionModeMask -
+ rsnCapabilities -
+ wapiCapabilities -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeApAuthSupportMask authSupport;
+ CsrWifiSmeEncryptionMask encryptionModeMask;
+ CsrWifiSmeApRsnCapabilitiesMask rsnCapabilities;
+ CsrWifiSmeApWapiCapabilitiesMask wapiCapabilities;
+} CsrWifiSmeApAuthPers;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBaSession
+
+ DESCRIPTION
+
+ MEMBERS
+ peerMacAddress - Indicates MAC address of the peer station
+ tid - Specifies the TID of the MSDUs for which this Block Ack has
+ been set up. Range: 0-15
+ direction - Specifies if the AP is the originator or the recipient of
+ the data stream that uses the Block Ack.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiMacAddress peerMacAddress;
+ CsrUint8 tid;
+ CsrWifiSmeApDirection direction;
+} CsrWifiSmeApBaSession;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApMacConfig
+
+ DESCRIPTION
+ Structure holding AP MAC configuration.
+
+ MEMBERS
+ phySupportedBitmap - Indicates supported physical layers
+ beaconInterval - Beacon interval in terms of TUs
+ dtimPeriod - DTIM period in terms of number of beacon intervals
+ maxListenInterval - Maximum allowed listen interval as number of beacon
+ intervals
+ supportedRatesCount - Number of supported rates. Range : 0 to 20
+ supportedRates - List of supportedRates. A rate is specied in the
+ units of 500kbps. An entry for a basic rate shall
+ have the MSB set to 1.
+ preamble - Preamble to be advertised in beacons and probe
+ responses
+ shortSlotTimeEnabled - TRUE indicates the AP shall use short slot time if
+ all the stations use short slot operation.
+ ctsProtectionType - CTS protection to be used
+ wmmEnabled - Indicate whether WMM is enabled or not. If set to
+ FALSE,the WMM parameters shall be ignored by the
+ receiver.
+ wmmApParams - WMM parameters to be used for local firmware queue
+ configuration. Array index corresponds to the ACI.
+ wmmApBcParams - WMM parameters to be advertised in beacon/probe
+ response. Array index corresponds to the ACI
+ accessType - Specifies whether the MAC addresses from the list
+ should be allowed or denied
+ macAddressListCount - Number of MAC addresses
+ macAddressList - List of MAC addresses
+ apHtParams - AP HT parameters. The stack shall use these
+ parameters only if phySupportedBitmap indicates
+ support for IEEE 802.11n
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeApPhySupportMask phySupportedBitmap;
+ CsrUint16 beaconInterval;
+ CsrUint8 dtimPeriod;
+ CsrUint16 maxListenInterval;
+ CsrUint8 supportedRatesCount;
+ CsrUint8 supportedRates[20];
+ CsrWifiSmePreambleType preamble;
+ CsrBool shortSlotTimeEnabled;
+ CsrWifiSmeCtsProtectionType ctsProtectionType;
+ CsrBool wmmEnabled;
+ CsrWifiSmeWmmAcParams wmmApParams[4];
+ CsrWifiSmeWmmAcParams wmmApBcParams[4];
+ CsrWifiSmeApAccessType accessType;
+ CsrUint8 macAddressListCount;
+ CsrWifiMacAddress *macAddressList;
+ CsrWifiSmeApHtParams apHtParams;
+} CsrWifiSmeApMacConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApP2pGoConfig
+
+ DESCRIPTION
+
+ MEMBERS
+ groupCapability - Indicates the P2P group capabilities
+ operatingChanList - List of operating channels in the order of
+ decreasing priority. It may contain channel
+ entry/entries not supported by the wifi stack.
+ These shall be filtered out by the wifi stack
+ opPsEnabled - Indicates whether opportunistic power save can
+ be used.
+ Note: This parameter is ignored by the WiFi
+ stack for the current release
+ ctWindow - Define Client Traffic window to be used in terms
+ of number of TUs. Range: 0 to 127.
+ Note: This parameter is ignored by the WiFi
+ stack for the current release.
+ noaConfigMethod - Notice of Absence configuration method.
+ Note: This parameter is ignored by the WiFi
+ stack for the current release.
+ allowNoaWithNonP2pDevices - Indicates if NOA should be allowed if non P2P
+ devices are connected. If allowed the non P2P
+ devices may suffer in throughput.
+ Note: This parameter is ignored by the WiFi
+ stack for the current release.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeP2pGroupCapabilityMask groupCapability;
+ CsrWifiSmeApP2pOperatingChanList operatingChanList;
+ CsrBool opPsEnabled;
+ CsrUint8 ctWindow;
+ CsrWifiSmeP2pNoaConfigMethod noaConfigMethod;
+ CsrBool allowNoaWithNonP2pDevices;
+} CsrWifiSmeApP2pGoConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApCredentials
+
+ DESCRIPTION
+
+ MEMBERS
+ authType -
+ smeAuthType -
+ smeAuthTypeopenSystemEmpty -
+ smeAuthTypeauthwep -
+ smeAuthTypeauthPers -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeApAuthType authType;
+ union {
+ CsrWifiSmeEmpty openSystemEmpty;
+ CsrWifiSmeWepAuth authwep;
+ CsrWifiSmeApAuthPers authPers;
+ } smeAuthType;
+} CsrWifiSmeApCredentials;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApSecConfig
+
+ DESCRIPTION
+
+ MEMBERS
+ apCredentials -
+ wpsEnabled -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeApCredentials apCredentials;
+ CsrBool wpsEnabled;
+} CsrWifiSmeApSecConfig;
+
+
+/* Downstream */
+#define CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST (0x0000)
+
+#define CSR_WIFI_SME_AP_BEACONING_START_REQ ((CsrWifiSmeApPrim) (0x0000 + CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_BEACONING_STOP_REQ ((CsrWifiSmeApPrim) (0x0001 + CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_WPS_REGISTRATION_STARTED_REQ ((CsrWifiSmeApPrim) (0x0002 + CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_WPS_REGISTRATION_FINISHED_REQ ((CsrWifiSmeApPrim) (0x0003 + CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_WMM_PARAM_UPDATE_REQ ((CsrWifiSmeApPrim) (0x0004 + CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_STA_DISCONNECT_REQ ((CsrWifiSmeApPrim) (0x0005 + CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_WPS_CONFIGURATION_REQ ((CsrWifiSmeApPrim) (0x0006 + CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_ACTIVE_BA_GET_REQ ((CsrWifiSmeApPrim) (0x0007 + CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_BA_DELETE_REQ ((CsrWifiSmeApPrim) (0x0008 + CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST))
+
+
+#define CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_HIGHEST (0x0008 + CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST)
+
+/* Upstream */
+#define CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST (0x0000 + CSR_PRIM_UPSTREAM)
+
+#define CSR_WIFI_SME_AP_BEACONING_START_CFM ((CsrWifiSmeApPrim)(0x0000 + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_BEACONING_STOP_CFM ((CsrWifiSmeApPrim)(0x0001 + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_STA_NOTIFY_IND ((CsrWifiSmeApPrim)(0x0002 + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_STA_CONNECT_START_IND ((CsrWifiSmeApPrim)(0x0003 + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_WPS_REGISTRATION_STARTED_CFM ((CsrWifiSmeApPrim)(0x0004 + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_WPS_REGISTRATION_FINISHED_CFM ((CsrWifiSmeApPrim)(0x0005 + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_WMM_PARAM_UPDATE_CFM ((CsrWifiSmeApPrim)(0x0006 + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_STA_DISCONNECT_CFM ((CsrWifiSmeApPrim)(0x0007 + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_WPS_CONFIGURATION_CFM ((CsrWifiSmeApPrim)(0x0008 + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_ERROR_IND ((CsrWifiSmeApPrim)(0x0009 + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_ACTIVE_BA_GET_CFM ((CsrWifiSmeApPrim)(0x000A + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AP_BA_DELETE_CFM ((CsrWifiSmeApPrim)(0x000B + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST))
+
+#define CSR_WIFI_SME_AP_PRIM_UPSTREAM_HIGHEST (0x000B + CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST)
+
+#define CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_COUNT (CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_HIGHEST + 1 - CSR_WIFI_SME_AP_PRIM_DOWNSTREAM_LOWEST)
+#define CSR_WIFI_SME_AP_PRIM_UPSTREAM_COUNT (CSR_WIFI_SME_AP_PRIM_UPSTREAM_HIGHEST + 1 - CSR_WIFI_SME_AP_PRIM_UPSTREAM_LOWEST)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBeaconingStartReq
+
+ DESCRIPTION
+ This primitive requests the SME to start AP or GO functionality
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ initialPresence - Set to 0, if Not in a group fomration phase, set to 1 ,
+ during group formation phase
+ apType - apType : Legacy AP or P2PGO
+ cloakSsid - cloakSsid flag.
+ ssid - ssid.
+ ifIndex - Radio Interface
+ channel - channel.
+ maxConnections - Maximum Stations + P2PClients allowed
+ apCredentials - AP security credeitals used to advertise in beacon /probe
+ response
+ smeApConfig - AP configuration
+ p2pGoParam - P2P specific GO parameters. Ignored if it is a leagacy AP
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 initialPresence;
+ CsrWifiSmeApType apType;
+ CsrBool cloakSsid;
+ CsrWifiSsid ssid;
+ CsrWifiSmeRadioIF ifIndex;
+ CsrUint8 channel;
+ CsrUint8 maxConnections;
+ CsrWifiSmeApSecConfig apCredentials;
+ CsrWifiSmeApMacConfig smeApConfig;
+ CsrWifiSmeApP2pGoConfig p2pGoParam;
+} CsrWifiSmeApBeaconingStartReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBeaconingStopReq
+
+ DESCRIPTION
+ This primitive requests the SME to STOP AP or P2PGO operation
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeApBeaconingStopReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsRegistrationStartedReq
+
+ DESCRIPTION
+ This primitive tells SME that WPS registration procedure has started
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ SelectedDevicePasswordId -
+ SelectedconfigMethod -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeWpsDpid SelectedDevicePasswordId;
+ CsrWifiSmeWpsConfigType SelectedconfigMethod;
+} CsrWifiSmeApWpsRegistrationStartedReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsRegistrationFinishedReq
+
+ DESCRIPTION
+ This primitive tells SME that WPS registration procedure has finished
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeApWpsRegistrationFinishedReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWmmParamUpdateReq
+
+ DESCRIPTION
+ Application uses this primitive to update the WMM parameters on the fly
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ wmmApParams - WMM parameters to be used for local firmware queue
+ configuration
+ wmmApBcParams - WMM parameters to be advertised in beacon/probe response
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeWmmAcParams wmmApParams[4];
+ CsrWifiSmeWmmAcParams wmmApBcParams[4];
+} CsrWifiSmeApWmmParamUpdateReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApStaDisconnectReq
+
+ DESCRIPTION
+ This primitive tells SME to deauth ot disassociate a particular station
+ within BSS
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ deauthReason -
+ disassocReason -
+ peerMacaddress -
+ keepBlocking - If TRUE, the station is blocked. If FALSE and the station
+ is connected, disconnect the station. If FALSE and the
+ station is not connected, no action is taken.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeIEEE80211Reason deauthReason;
+ CsrWifiSmeIEEE80211Reason disassocReason;
+ CsrWifiMacAddress peerMacaddress;
+ CsrBool keepBlocking;
+} CsrWifiSmeApStaDisconnectReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsConfigurationReq
+
+ DESCRIPTION
+ This primitive passes the WPS information for the device to SME. This may
+ be accepted only if no interface is active.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ wpsConfig - WPS config.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeWpsConfig wpsConfig;
+} CsrWifiSmeApWpsConfigurationReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApActiveBaGetReq
+
+ DESCRIPTION
+ This primitive used to retrieve information related to the active block
+ ack sessions
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeApActiveBaGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBaDeleteReq
+
+ DESCRIPTION
+ This primitive is used to delete an active block ack session
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ reason -
+ baSession - BA session to be deleted
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeIEEE80211Reason reason;
+ CsrWifiSmeApBaSession baSession;
+} CsrWifiSmeApBaDeleteReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBeaconingStartCfm
+
+ DESCRIPTION
+ This primitive confirms the completion of the request along with the
+ status
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ status -
+ secIeLength -
+ secIe -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrUint16 secIeLength;
+ CsrUint8 *secIe;
+} CsrWifiSmeApBeaconingStartCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBeaconingStopCfm
+
+ DESCRIPTION
+ This primitive confirms AP or P2PGO operation is terminated
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeApBeaconingStopCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApStaNotifyInd
+
+ DESCRIPTION
+ This primitive indicates that a station has joined or a previously joined
+ station has left the BSS/group
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ mediaStatus -
+ peerMacAddress -
+ peerDeviceAddress -
+ disassocReason -
+ deauthReason -
+ WpsRegistration -
+ secIeLength -
+ secIe -
+ groupKeyId -
+ seqNumber -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeMediaStatus mediaStatus;
+ CsrWifiMacAddress peerMacAddress;
+ CsrWifiMacAddress peerDeviceAddress;
+ CsrWifiSmeIEEE80211Reason disassocReason;
+ CsrWifiSmeIEEE80211Reason deauthReason;
+ CsrWifiSmeWpsRegistration WpsRegistration;
+ CsrUint8 secIeLength;
+ CsrUint8 *secIe;
+ CsrUint8 groupKeyId;
+ CsrUint16 seqNumber[8];
+} CsrWifiSmeApStaNotifyInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApStaConnectStartInd
+
+ DESCRIPTION
+ This primitive indicates that a stations request to join the group/BSS is
+ accepted
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ peerMacAddress -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress peerMacAddress;
+} CsrWifiSmeApStaConnectStartInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsRegistrationStartedCfm
+
+ DESCRIPTION
+ A confirm for UNIFI_MGT_AP_WPS_REGISTRATION_STARTED.request
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeApWpsRegistrationStartedCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsRegistrationFinishedCfm
+
+ DESCRIPTION
+ A confirm for UNIFI_MGT_AP_WPS_REGISTRATION_FINISHED.request
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeApWpsRegistrationFinishedCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWmmParamUpdateCfm
+
+ DESCRIPTION
+ A confirm for CSR_WIFI_SME_AP_WMM_PARAM_UPDATE.request
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ status -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeApWmmParamUpdateCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApStaDisconnectCfm
+
+ DESCRIPTION
+ This primitive confirms the station is disconnected
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ status -
+ peerMacaddress -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiMacAddress peerMacaddress;
+} CsrWifiSmeApStaDisconnectCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApWpsConfigurationCfm
+
+ DESCRIPTION
+ Confirm.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Status of the request.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeApWpsConfigurationCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApErrorInd
+
+ DESCRIPTION
+ This primitve is sent by SME to indicate some error in AP operationi
+ after AP operations were started successfully and continuing the AP
+ operation may lead to undesired behaviour. It is the responsibility of
+ the upper layers to stop AP operation if needed
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Range 0-1
+ apType -
+ status - Contains the error status
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeApType apType;
+ CsrResult status;
+} CsrWifiSmeApErrorInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApActiveBaGetCfm
+
+ DESCRIPTION
+ This primitive carries the information related to the active ba sessions
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ status - Reports the result of the request
+ activeBaCount - Number of active block ack session
+ activeBaSessions - Points to a buffer containing an array of
+ CsrWifiSmeApBaSession structures.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrUint16 activeBaCount;
+ CsrWifiSmeApBaSession *activeBaSessions;
+} CsrWifiSmeApActiveBaGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeApBaDeleteCfm
+
+ DESCRIPTION
+ This primitive confirms the BA is deleted
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag -
+ status - Reports the result of the request
+ baSession - deleted BA session
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeApBaSession baSession;
+} CsrWifiSmeApBaDeleteCfm;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_SME_AP_PRIM_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_msgconv.h"
+#include "csr_pmem.h"
+#include "csr_util.h"
+
+
+#ifdef CSR_LOG_ENABLE
+#include "csr_log.h"
+#endif
+
+#ifndef EXCLUDE_CSR_WIFI_SME_MODULE
+#include "csr_wifi_sme_serialize.h"
+#include "csr_wifi_sme_prim.h"
+
+static CsrMsgConvMsgEntry csrwifisme_conv_lut[] = {
+ { CSR_WIFI_SME_ACTIVATE_REQ, CsrWifiSmeActivateReqSizeof, CsrWifiSmeActivateReqSer, CsrWifiSmeActivateReqDes, CsrWifiSmeActivateReqSerFree },
+ { CSR_WIFI_SME_ADHOC_CONFIG_GET_REQ, CsrWifiSmeAdhocConfigGetReqSizeof, CsrWifiSmeAdhocConfigGetReqSer, CsrWifiSmeAdhocConfigGetReqDes, CsrWifiSmeAdhocConfigGetReqSerFree },
+ { CSR_WIFI_SME_ADHOC_CONFIG_SET_REQ, CsrWifiSmeAdhocConfigSetReqSizeof, CsrWifiSmeAdhocConfigSetReqSer, CsrWifiSmeAdhocConfigSetReqDes, CsrWifiSmeAdhocConfigSetReqSerFree },
+ { CSR_WIFI_SME_BLACKLIST_REQ, CsrWifiSmeBlacklistReqSizeof, CsrWifiSmeBlacklistReqSer, CsrWifiSmeBlacklistReqDes, CsrWifiSmeBlacklistReqSerFree },
+ { CSR_WIFI_SME_CALIBRATION_DATA_GET_REQ, CsrWifiSmeCalibrationDataGetReqSizeof, CsrWifiSmeCalibrationDataGetReqSer, CsrWifiSmeCalibrationDataGetReqDes, CsrWifiSmeCalibrationDataGetReqSerFree },
+ { CSR_WIFI_SME_CALIBRATION_DATA_SET_REQ, CsrWifiSmeCalibrationDataSetReqSizeof, CsrWifiSmeCalibrationDataSetReqSer, CsrWifiSmeCalibrationDataSetReqDes, CsrWifiSmeCalibrationDataSetReqSerFree },
+ { CSR_WIFI_SME_CCX_CONFIG_GET_REQ, CsrWifiSmeCcxConfigGetReqSizeof, CsrWifiSmeCcxConfigGetReqSer, CsrWifiSmeCcxConfigGetReqDes, CsrWifiSmeCcxConfigGetReqSerFree },
+ { CSR_WIFI_SME_CCX_CONFIG_SET_REQ, CsrWifiSmeCcxConfigSetReqSizeof, CsrWifiSmeCcxConfigSetReqSer, CsrWifiSmeCcxConfigSetReqDes, CsrWifiSmeCcxConfigSetReqSerFree },
+ { CSR_WIFI_SME_COEX_CONFIG_GET_REQ, CsrWifiSmeCoexConfigGetReqSizeof, CsrWifiSmeCoexConfigGetReqSer, CsrWifiSmeCoexConfigGetReqDes, CsrWifiSmeCoexConfigGetReqSerFree },
+ { CSR_WIFI_SME_COEX_CONFIG_SET_REQ, CsrWifiSmeCoexConfigSetReqSizeof, CsrWifiSmeCoexConfigSetReqSer, CsrWifiSmeCoexConfigSetReqDes, CsrWifiSmeCoexConfigSetReqSerFree },
+ { CSR_WIFI_SME_COEX_INFO_GET_REQ, CsrWifiSmeCoexInfoGetReqSizeof, CsrWifiSmeCoexInfoGetReqSer, CsrWifiSmeCoexInfoGetReqDes, CsrWifiSmeCoexInfoGetReqSerFree },
+ { CSR_WIFI_SME_CONNECT_REQ, CsrWifiSmeConnectReqSizeof, CsrWifiSmeConnectReqSer, CsrWifiSmeConnectReqDes, CsrWifiSmeConnectReqSerFree },
+ { CSR_WIFI_SME_CONNECTION_CONFIG_GET_REQ, CsrWifiSmeConnectionConfigGetReqSizeof, CsrWifiSmeConnectionConfigGetReqSer, CsrWifiSmeConnectionConfigGetReqDes, CsrWifiSmeConnectionConfigGetReqSerFree },
+ { CSR_WIFI_SME_CONNECTION_INFO_GET_REQ, CsrWifiSmeConnectionInfoGetReqSizeof, CsrWifiSmeConnectionInfoGetReqSer, CsrWifiSmeConnectionInfoGetReqDes, CsrWifiSmeConnectionInfoGetReqSerFree },
+ { CSR_WIFI_SME_CONNECTION_STATS_GET_REQ, CsrWifiSmeConnectionStatsGetReqSizeof, CsrWifiSmeConnectionStatsGetReqSer, CsrWifiSmeConnectionStatsGetReqDes, CsrWifiSmeConnectionStatsGetReqSerFree },
+ { CSR_WIFI_SME_DEACTIVATE_REQ, CsrWifiSmeDeactivateReqSizeof, CsrWifiSmeDeactivateReqSer, CsrWifiSmeDeactivateReqDes, CsrWifiSmeDeactivateReqSerFree },
+ { CSR_WIFI_SME_DISCONNECT_REQ, CsrWifiSmeDisconnectReqSizeof, CsrWifiSmeDisconnectReqSer, CsrWifiSmeDisconnectReqDes, CsrWifiSmeDisconnectReqSerFree },
+ { CSR_WIFI_SME_EVENT_MASK_SET_REQ, CsrWifiSmeEventMaskSetReqSizeof, CsrWifiSmeEventMaskSetReqSer, CsrWifiSmeEventMaskSetReqDes, CsrWifiSmeEventMaskSetReqSerFree },
+ { CSR_WIFI_SME_HOST_CONFIG_GET_REQ, CsrWifiSmeHostConfigGetReqSizeof, CsrWifiSmeHostConfigGetReqSer, CsrWifiSmeHostConfigGetReqDes, CsrWifiSmeHostConfigGetReqSerFree },
+ { CSR_WIFI_SME_HOST_CONFIG_SET_REQ, CsrWifiSmeHostConfigSetReqSizeof, CsrWifiSmeHostConfigSetReqSer, CsrWifiSmeHostConfigSetReqDes, CsrWifiSmeHostConfigSetReqSerFree },
+ { CSR_WIFI_SME_KEY_REQ, CsrWifiSmeKeyReqSizeof, CsrWifiSmeKeyReqSer, CsrWifiSmeKeyReqDes, CsrWifiSmeKeyReqSerFree },
+ { CSR_WIFI_SME_LINK_QUALITY_GET_REQ, CsrWifiSmeLinkQualityGetReqSizeof, CsrWifiSmeLinkQualityGetReqSer, CsrWifiSmeLinkQualityGetReqDes, CsrWifiSmeLinkQualityGetReqSerFree },
+ { CSR_WIFI_SME_MIB_CONFIG_GET_REQ, CsrWifiSmeMibConfigGetReqSizeof, CsrWifiSmeMibConfigGetReqSer, CsrWifiSmeMibConfigGetReqDes, CsrWifiSmeMibConfigGetReqSerFree },
+ { CSR_WIFI_SME_MIB_CONFIG_SET_REQ, CsrWifiSmeMibConfigSetReqSizeof, CsrWifiSmeMibConfigSetReqSer, CsrWifiSmeMibConfigSetReqDes, CsrWifiSmeMibConfigSetReqSerFree },
+ { CSR_WIFI_SME_MIB_GET_NEXT_REQ, CsrWifiSmeMibGetNextReqSizeof, CsrWifiSmeMibGetNextReqSer, CsrWifiSmeMibGetNextReqDes, CsrWifiSmeMibGetNextReqSerFree },
+ { CSR_WIFI_SME_MIB_GET_REQ, CsrWifiSmeMibGetReqSizeof, CsrWifiSmeMibGetReqSer, CsrWifiSmeMibGetReqDes, CsrWifiSmeMibGetReqSerFree },
+ { CSR_WIFI_SME_MIB_SET_REQ, CsrWifiSmeMibSetReqSizeof, CsrWifiSmeMibSetReqSer, CsrWifiSmeMibSetReqDes, CsrWifiSmeMibSetReqSerFree },
+ { CSR_WIFI_SME_MULTICAST_ADDRESS_REQ, CsrWifiSmeMulticastAddressReqSizeof, CsrWifiSmeMulticastAddressReqSer, CsrWifiSmeMulticastAddressReqDes, CsrWifiSmeMulticastAddressReqSerFree },
+ { CSR_WIFI_SME_PACKET_FILTER_SET_REQ, CsrWifiSmePacketFilterSetReqSizeof, CsrWifiSmePacketFilterSetReqSer, CsrWifiSmePacketFilterSetReqDes, CsrWifiSmePacketFilterSetReqSerFree },
+ { CSR_WIFI_SME_PERMANENT_MAC_ADDRESS_GET_REQ, CsrWifiSmePermanentMacAddressGetReqSizeof, CsrWifiSmePermanentMacAddressGetReqSer, CsrWifiSmePermanentMacAddressGetReqDes, CsrWifiSmePermanentMacAddressGetReqSerFree },
+ { CSR_WIFI_SME_PMKID_REQ, CsrWifiSmePmkidReqSizeof, CsrWifiSmePmkidReqSer, CsrWifiSmePmkidReqDes, CsrWifiSmePmkidReqSerFree },
+ { CSR_WIFI_SME_POWER_CONFIG_GET_REQ, CsrWifiSmePowerConfigGetReqSizeof, CsrWifiSmePowerConfigGetReqSer, CsrWifiSmePowerConfigGetReqDes, CsrWifiSmePowerConfigGetReqSerFree },
+ { CSR_WIFI_SME_POWER_CONFIG_SET_REQ, CsrWifiSmePowerConfigSetReqSizeof, CsrWifiSmePowerConfigSetReqSer, CsrWifiSmePowerConfigSetReqDes, CsrWifiSmePowerConfigSetReqSerFree },
+ { CSR_WIFI_SME_REGULATORY_DOMAIN_INFO_GET_REQ, CsrWifiSmeRegulatoryDomainInfoGetReqSizeof, CsrWifiSmeRegulatoryDomainInfoGetReqSer, CsrWifiSmeRegulatoryDomainInfoGetReqDes, CsrWifiSmeRegulatoryDomainInfoGetReqSerFree },
+ { CSR_WIFI_SME_ROAMING_CONFIG_GET_REQ, CsrWifiSmeRoamingConfigGetReqSizeof, CsrWifiSmeRoamingConfigGetReqSer, CsrWifiSmeRoamingConfigGetReqDes, CsrWifiSmeRoamingConfigGetReqSerFree },
+ { CSR_WIFI_SME_ROAMING_CONFIG_SET_REQ, CsrWifiSmeRoamingConfigSetReqSizeof, CsrWifiSmeRoamingConfigSetReqSer, CsrWifiSmeRoamingConfigSetReqDes, CsrWifiSmeRoamingConfigSetReqSerFree },
+ { CSR_WIFI_SME_SCAN_CONFIG_GET_REQ, CsrWifiSmeScanConfigGetReqSizeof, CsrWifiSmeScanConfigGetReqSer, CsrWifiSmeScanConfigGetReqDes, CsrWifiSmeScanConfigGetReqSerFree },
+ { CSR_WIFI_SME_SCAN_CONFIG_SET_REQ, CsrWifiSmeScanConfigSetReqSizeof, CsrWifiSmeScanConfigSetReqSer, CsrWifiSmeScanConfigSetReqDes, CsrWifiSmeScanConfigSetReqSerFree },
+ { CSR_WIFI_SME_SCAN_FULL_REQ, CsrWifiSmeScanFullReqSizeof, CsrWifiSmeScanFullReqSer, CsrWifiSmeScanFullReqDes, CsrWifiSmeScanFullReqSerFree },
+ { CSR_WIFI_SME_SCAN_RESULTS_FLUSH_REQ, CsrWifiSmeScanResultsFlushReqSizeof, CsrWifiSmeScanResultsFlushReqSer, CsrWifiSmeScanResultsFlushReqDes, CsrWifiSmeScanResultsFlushReqSerFree },
+ { CSR_WIFI_SME_SCAN_RESULTS_GET_REQ, CsrWifiSmeScanResultsGetReqSizeof, CsrWifiSmeScanResultsGetReqSer, CsrWifiSmeScanResultsGetReqDes, CsrWifiSmeScanResultsGetReqSerFree },
+ { CSR_WIFI_SME_SME_STA_CONFIG_GET_REQ, CsrWifiSmeSmeStaConfigGetReqSizeof, CsrWifiSmeSmeStaConfigGetReqSer, CsrWifiSmeSmeStaConfigGetReqDes, CsrWifiSmeSmeStaConfigGetReqSerFree },
+ { CSR_WIFI_SME_SME_STA_CONFIG_SET_REQ, CsrWifiSmeSmeStaConfigSetReqSizeof, CsrWifiSmeSmeStaConfigSetReqSer, CsrWifiSmeSmeStaConfigSetReqDes, CsrWifiSmeSmeStaConfigSetReqSerFree },
+ { CSR_WIFI_SME_STATION_MAC_ADDRESS_GET_REQ, CsrWifiSmeStationMacAddressGetReqSizeof, CsrWifiSmeStationMacAddressGetReqSer, CsrWifiSmeStationMacAddressGetReqDes, CsrWifiSmeStationMacAddressGetReqSerFree },
+ { CSR_WIFI_SME_TSPEC_REQ, CsrWifiSmeTspecReqSizeof, CsrWifiSmeTspecReqSer, CsrWifiSmeTspecReqDes, CsrWifiSmeTspecReqSerFree },
+ { CSR_WIFI_SME_VERSIONS_GET_REQ, CsrWifiSmeVersionsGetReqSizeof, CsrWifiSmeVersionsGetReqSer, CsrWifiSmeVersionsGetReqDes, CsrWifiSmeVersionsGetReqSerFree },
+ { CSR_WIFI_SME_WIFI_FLIGHTMODE_REQ, CsrWifiSmeWifiFlightmodeReqSizeof, CsrWifiSmeWifiFlightmodeReqSer, CsrWifiSmeWifiFlightmodeReqDes, CsrWifiSmeWifiFlightmodeReqSerFree },
+ { CSR_WIFI_SME_WIFI_OFF_REQ, CsrWifiSmeWifiOffReqSizeof, CsrWifiSmeWifiOffReqSer, CsrWifiSmeWifiOffReqDes, CsrWifiSmeWifiOffReqSerFree },
+ { CSR_WIFI_SME_WIFI_ON_REQ, CsrWifiSmeWifiOnReqSizeof, CsrWifiSmeWifiOnReqSer, CsrWifiSmeWifiOnReqDes, CsrWifiSmeWifiOnReqSerFree },
+ { CSR_WIFI_SME_CLOAKED_SSIDS_SET_REQ, CsrWifiSmeCloakedSsidsSetReqSizeof, CsrWifiSmeCloakedSsidsSetReqSer, CsrWifiSmeCloakedSsidsSetReqDes, CsrWifiSmeCloakedSsidsSetReqSerFree },
+ { CSR_WIFI_SME_CLOAKED_SSIDS_GET_REQ, CsrWifiSmeCloakedSsidsGetReqSizeof, CsrWifiSmeCloakedSsidsGetReqSer, CsrWifiSmeCloakedSsidsGetReqDes, CsrWifiSmeCloakedSsidsGetReqSerFree },
+ { CSR_WIFI_SME_SME_COMMON_CONFIG_GET_REQ, CsrWifiSmeSmeCommonConfigGetReqSizeof, CsrWifiSmeSmeCommonConfigGetReqSer, CsrWifiSmeSmeCommonConfigGetReqDes, CsrWifiSmeSmeCommonConfigGetReqSerFree },
+ { CSR_WIFI_SME_SME_COMMON_CONFIG_SET_REQ, CsrWifiSmeSmeCommonConfigSetReqSizeof, CsrWifiSmeSmeCommonConfigSetReqSer, CsrWifiSmeSmeCommonConfigSetReqDes, CsrWifiSmeSmeCommonConfigSetReqSerFree },
+ { CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_REQ, CsrWifiSmeInterfaceCapabilityGetReqSizeof, CsrWifiSmeInterfaceCapabilityGetReqSer, CsrWifiSmeInterfaceCapabilityGetReqDes, CsrWifiSmeInterfaceCapabilityGetReqSerFree },
+ { CSR_WIFI_SME_WPS_CONFIGURATION_REQ, CsrWifiSmeWpsConfigurationReqSizeof, CsrWifiSmeWpsConfigurationReqSer, CsrWifiSmeWpsConfigurationReqDes, CsrWifiSmeWpsConfigurationReqSerFree },
+ { CSR_WIFI_SME_SET_REQ, CsrWifiSmeSetReqSizeof, CsrWifiSmeSetReqSer, CsrWifiSmeSetReqDes, CsrWifiSmeSetReqSerFree },
+ { CSR_WIFI_SME_ACTIVATE_CFM, CsrWifiSmeActivateCfmSizeof, CsrWifiSmeActivateCfmSer, CsrWifiSmeActivateCfmDes, CsrWifiSmeActivateCfmSerFree },
+ { CSR_WIFI_SME_ADHOC_CONFIG_GET_CFM, CsrWifiSmeAdhocConfigGetCfmSizeof, CsrWifiSmeAdhocConfigGetCfmSer, CsrWifiSmeAdhocConfigGetCfmDes, CsrWifiSmeAdhocConfigGetCfmSerFree },
+ { CSR_WIFI_SME_ADHOC_CONFIG_SET_CFM, CsrWifiSmeAdhocConfigSetCfmSizeof, CsrWifiSmeAdhocConfigSetCfmSer, CsrWifiSmeAdhocConfigSetCfmDes, CsrWifiSmeAdhocConfigSetCfmSerFree },
+ { CSR_WIFI_SME_ASSOCIATION_COMPLETE_IND, CsrWifiSmeAssociationCompleteIndSizeof, CsrWifiSmeAssociationCompleteIndSer, CsrWifiSmeAssociationCompleteIndDes, CsrWifiSmeAssociationCompleteIndSerFree },
+ { CSR_WIFI_SME_ASSOCIATION_START_IND, CsrWifiSmeAssociationStartIndSizeof, CsrWifiSmeAssociationStartIndSer, CsrWifiSmeAssociationStartIndDes, CsrWifiSmeAssociationStartIndSerFree },
+ { CSR_WIFI_SME_BLACKLIST_CFM, CsrWifiSmeBlacklistCfmSizeof, CsrWifiSmeBlacklistCfmSer, CsrWifiSmeBlacklistCfmDes, CsrWifiSmeBlacklistCfmSerFree },
+ { CSR_WIFI_SME_CALIBRATION_DATA_GET_CFM, CsrWifiSmeCalibrationDataGetCfmSizeof, CsrWifiSmeCalibrationDataGetCfmSer, CsrWifiSmeCalibrationDataGetCfmDes, CsrWifiSmeCalibrationDataGetCfmSerFree },
+ { CSR_WIFI_SME_CALIBRATION_DATA_SET_CFM, CsrWifiSmeCalibrationDataSetCfmSizeof, CsrWifiSmeCalibrationDataSetCfmSer, CsrWifiSmeCalibrationDataSetCfmDes, CsrWifiSmeCalibrationDataSetCfmSerFree },
+ { CSR_WIFI_SME_CCX_CONFIG_GET_CFM, CsrWifiSmeCcxConfigGetCfmSizeof, CsrWifiSmeCcxConfigGetCfmSer, CsrWifiSmeCcxConfigGetCfmDes, CsrWifiSmeCcxConfigGetCfmSerFree },
+ { CSR_WIFI_SME_CCX_CONFIG_SET_CFM, CsrWifiSmeCcxConfigSetCfmSizeof, CsrWifiSmeCcxConfigSetCfmSer, CsrWifiSmeCcxConfigSetCfmDes, CsrWifiSmeCcxConfigSetCfmSerFree },
+ { CSR_WIFI_SME_COEX_CONFIG_GET_CFM, CsrWifiSmeCoexConfigGetCfmSizeof, CsrWifiSmeCoexConfigGetCfmSer, CsrWifiSmeCoexConfigGetCfmDes, CsrWifiSmeCoexConfigGetCfmSerFree },
+ { CSR_WIFI_SME_COEX_CONFIG_SET_CFM, CsrWifiSmeCoexConfigSetCfmSizeof, CsrWifiSmeCoexConfigSetCfmSer, CsrWifiSmeCoexConfigSetCfmDes, CsrWifiSmeCoexConfigSetCfmSerFree },
+ { CSR_WIFI_SME_COEX_INFO_GET_CFM, CsrWifiSmeCoexInfoGetCfmSizeof, CsrWifiSmeCoexInfoGetCfmSer, CsrWifiSmeCoexInfoGetCfmDes, CsrWifiSmeCoexInfoGetCfmSerFree },
+ { CSR_WIFI_SME_CONNECT_CFM, CsrWifiSmeConnectCfmSizeof, CsrWifiSmeConnectCfmSer, CsrWifiSmeConnectCfmDes, CsrWifiSmeConnectCfmSerFree },
+ { CSR_WIFI_SME_CONNECTION_CONFIG_GET_CFM, CsrWifiSmeConnectionConfigGetCfmSizeof, CsrWifiSmeConnectionConfigGetCfmSer, CsrWifiSmeConnectionConfigGetCfmDes, CsrWifiSmeConnectionConfigGetCfmSerFree },
+ { CSR_WIFI_SME_CONNECTION_INFO_GET_CFM, CsrWifiSmeConnectionInfoGetCfmSizeof, CsrWifiSmeConnectionInfoGetCfmSer, CsrWifiSmeConnectionInfoGetCfmDes, CsrWifiSmeConnectionInfoGetCfmSerFree },
+ { CSR_WIFI_SME_CONNECTION_QUALITY_IND, CsrWifiSmeConnectionQualityIndSizeof, CsrWifiSmeConnectionQualityIndSer, CsrWifiSmeConnectionQualityIndDes, CsrWifiSmeConnectionQualityIndSerFree },
+ { CSR_WIFI_SME_CONNECTION_STATS_GET_CFM, CsrWifiSmeConnectionStatsGetCfmSizeof, CsrWifiSmeConnectionStatsGetCfmSer, CsrWifiSmeConnectionStatsGetCfmDes, CsrWifiSmeConnectionStatsGetCfmSerFree },
+ { CSR_WIFI_SME_DEACTIVATE_CFM, CsrWifiSmeDeactivateCfmSizeof, CsrWifiSmeDeactivateCfmSer, CsrWifiSmeDeactivateCfmDes, CsrWifiSmeDeactivateCfmSerFree },
+ { CSR_WIFI_SME_DISCONNECT_CFM, CsrWifiSmeDisconnectCfmSizeof, CsrWifiSmeDisconnectCfmSer, CsrWifiSmeDisconnectCfmDes, CsrWifiSmeDisconnectCfmSerFree },
+ { CSR_WIFI_SME_EVENT_MASK_SET_CFM, CsrWifiSmeEventMaskSetCfmSizeof, CsrWifiSmeEventMaskSetCfmSer, CsrWifiSmeEventMaskSetCfmDes, CsrWifiSmeEventMaskSetCfmSerFree },
+ { CSR_WIFI_SME_HOST_CONFIG_GET_CFM, CsrWifiSmeHostConfigGetCfmSizeof, CsrWifiSmeHostConfigGetCfmSer, CsrWifiSmeHostConfigGetCfmDes, CsrWifiSmeHostConfigGetCfmSerFree },
+ { CSR_WIFI_SME_HOST_CONFIG_SET_CFM, CsrWifiSmeHostConfigSetCfmSizeof, CsrWifiSmeHostConfigSetCfmSer, CsrWifiSmeHostConfigSetCfmDes, CsrWifiSmeHostConfigSetCfmSerFree },
+ { CSR_WIFI_SME_IBSS_STATION_IND, CsrWifiSmeIbssStationIndSizeof, CsrWifiSmeIbssStationIndSer, CsrWifiSmeIbssStationIndDes, CsrWifiSmeIbssStationIndSerFree },
+ { CSR_WIFI_SME_KEY_CFM, CsrWifiSmeKeyCfmSizeof, CsrWifiSmeKeyCfmSer, CsrWifiSmeKeyCfmDes, CsrWifiSmeKeyCfmSerFree },
+ { CSR_WIFI_SME_LINK_QUALITY_GET_CFM, CsrWifiSmeLinkQualityGetCfmSizeof, CsrWifiSmeLinkQualityGetCfmSer, CsrWifiSmeLinkQualityGetCfmDes, CsrWifiSmeLinkQualityGetCfmSerFree },
+ { CSR_WIFI_SME_MEDIA_STATUS_IND, CsrWifiSmeMediaStatusIndSizeof, CsrWifiSmeMediaStatusIndSer, CsrWifiSmeMediaStatusIndDes, CsrWifiSmeMediaStatusIndSerFree },
+ { CSR_WIFI_SME_MIB_CONFIG_GET_CFM, CsrWifiSmeMibConfigGetCfmSizeof, CsrWifiSmeMibConfigGetCfmSer, CsrWifiSmeMibConfigGetCfmDes, CsrWifiSmeMibConfigGetCfmSerFree },
+ { CSR_WIFI_SME_MIB_CONFIG_SET_CFM, CsrWifiSmeMibConfigSetCfmSizeof, CsrWifiSmeMibConfigSetCfmSer, CsrWifiSmeMibConfigSetCfmDes, CsrWifiSmeMibConfigSetCfmSerFree },
+ { CSR_WIFI_SME_MIB_GET_CFM, CsrWifiSmeMibGetCfmSizeof, CsrWifiSmeMibGetCfmSer, CsrWifiSmeMibGetCfmDes, CsrWifiSmeMibGetCfmSerFree },
+ { CSR_WIFI_SME_MIB_GET_NEXT_CFM, CsrWifiSmeMibGetNextCfmSizeof, CsrWifiSmeMibGetNextCfmSer, CsrWifiSmeMibGetNextCfmDes, CsrWifiSmeMibGetNextCfmSerFree },
+ { CSR_WIFI_SME_MIB_SET_CFM, CsrWifiSmeMibSetCfmSizeof, CsrWifiSmeMibSetCfmSer, CsrWifiSmeMibSetCfmDes, CsrWifiSmeMibSetCfmSerFree },
+ { CSR_WIFI_SME_MIC_FAILURE_IND, CsrWifiSmeMicFailureIndSizeof, CsrWifiSmeMicFailureIndSer, CsrWifiSmeMicFailureIndDes, CsrWifiSmeMicFailureIndSerFree },
+ { CSR_WIFI_SME_MULTICAST_ADDRESS_CFM, CsrWifiSmeMulticastAddressCfmSizeof, CsrWifiSmeMulticastAddressCfmSer, CsrWifiSmeMulticastAddressCfmDes, CsrWifiSmeMulticastAddressCfmSerFree },
+ { CSR_WIFI_SME_PACKET_FILTER_SET_CFM, CsrWifiSmePacketFilterSetCfmSizeof, CsrWifiSmePacketFilterSetCfmSer, CsrWifiSmePacketFilterSetCfmDes, CsrWifiSmePacketFilterSetCfmSerFree },
+ { CSR_WIFI_SME_PERMANENT_MAC_ADDRESS_GET_CFM, CsrWifiSmePermanentMacAddressGetCfmSizeof, CsrWifiSmePermanentMacAddressGetCfmSer, CsrWifiSmePermanentMacAddressGetCfmDes, CsrWifiSmePermanentMacAddressGetCfmSerFree },
+ { CSR_WIFI_SME_PMKID_CANDIDATE_LIST_IND, CsrWifiSmePmkidCandidateListIndSizeof, CsrWifiSmePmkidCandidateListIndSer, CsrWifiSmePmkidCandidateListIndDes, CsrWifiSmePmkidCandidateListIndSerFree },
+ { CSR_WIFI_SME_PMKID_CFM, CsrWifiSmePmkidCfmSizeof, CsrWifiSmePmkidCfmSer, CsrWifiSmePmkidCfmDes, CsrWifiSmePmkidCfmSerFree },
+ { CSR_WIFI_SME_POWER_CONFIG_GET_CFM, CsrWifiSmePowerConfigGetCfmSizeof, CsrWifiSmePowerConfigGetCfmSer, CsrWifiSmePowerConfigGetCfmDes, CsrWifiSmePowerConfigGetCfmSerFree },
+ { CSR_WIFI_SME_POWER_CONFIG_SET_CFM, CsrWifiSmePowerConfigSetCfmSizeof, CsrWifiSmePowerConfigSetCfmSer, CsrWifiSmePowerConfigSetCfmDes, CsrWifiSmePowerConfigSetCfmSerFree },
+ { CSR_WIFI_SME_REGULATORY_DOMAIN_INFO_GET_CFM, CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof, CsrWifiSmeRegulatoryDomainInfoGetCfmSer, CsrWifiSmeRegulatoryDomainInfoGetCfmDes, CsrWifiSmeRegulatoryDomainInfoGetCfmSerFree },
+ { CSR_WIFI_SME_ROAM_COMPLETE_IND, CsrWifiSmeRoamCompleteIndSizeof, CsrWifiSmeRoamCompleteIndSer, CsrWifiSmeRoamCompleteIndDes, CsrWifiSmeRoamCompleteIndSerFree },
+ { CSR_WIFI_SME_ROAM_START_IND, CsrWifiSmeRoamStartIndSizeof, CsrWifiSmeRoamStartIndSer, CsrWifiSmeRoamStartIndDes, CsrWifiSmeRoamStartIndSerFree },
+ { CSR_WIFI_SME_ROAMING_CONFIG_GET_CFM, CsrWifiSmeRoamingConfigGetCfmSizeof, CsrWifiSmeRoamingConfigGetCfmSer, CsrWifiSmeRoamingConfigGetCfmDes, CsrWifiSmeRoamingConfigGetCfmSerFree },
+ { CSR_WIFI_SME_ROAMING_CONFIG_SET_CFM, CsrWifiSmeRoamingConfigSetCfmSizeof, CsrWifiSmeRoamingConfigSetCfmSer, CsrWifiSmeRoamingConfigSetCfmDes, CsrWifiSmeRoamingConfigSetCfmSerFree },
+ { CSR_WIFI_SME_SCAN_CONFIG_GET_CFM, CsrWifiSmeScanConfigGetCfmSizeof, CsrWifiSmeScanConfigGetCfmSer, CsrWifiSmeScanConfigGetCfmDes, CsrWifiSmeScanConfigGetCfmSerFree },
+ { CSR_WIFI_SME_SCAN_CONFIG_SET_CFM, CsrWifiSmeScanConfigSetCfmSizeof, CsrWifiSmeScanConfigSetCfmSer, CsrWifiSmeScanConfigSetCfmDes, CsrWifiSmeScanConfigSetCfmSerFree },
+ { CSR_WIFI_SME_SCAN_FULL_CFM, CsrWifiSmeScanFullCfmSizeof, CsrWifiSmeScanFullCfmSer, CsrWifiSmeScanFullCfmDes, CsrWifiSmeScanFullCfmSerFree },
+ { CSR_WIFI_SME_SCAN_RESULT_IND, CsrWifiSmeScanResultIndSizeof, CsrWifiSmeScanResultIndSer, CsrWifiSmeScanResultIndDes, CsrWifiSmeScanResultIndSerFree },
+ { CSR_WIFI_SME_SCAN_RESULTS_FLUSH_CFM, CsrWifiSmeScanResultsFlushCfmSizeof, CsrWifiSmeScanResultsFlushCfmSer, CsrWifiSmeScanResultsFlushCfmDes, CsrWifiSmeScanResultsFlushCfmSerFree },
+ { CSR_WIFI_SME_SCAN_RESULTS_GET_CFM, CsrWifiSmeScanResultsGetCfmSizeof, CsrWifiSmeScanResultsGetCfmSer, CsrWifiSmeScanResultsGetCfmDes, CsrWifiSmeScanResultsGetCfmSerFree },
+ { CSR_WIFI_SME_SME_STA_CONFIG_GET_CFM, CsrWifiSmeSmeStaConfigGetCfmSizeof, CsrWifiSmeSmeStaConfigGetCfmSer, CsrWifiSmeSmeStaConfigGetCfmDes, CsrWifiSmeSmeStaConfigGetCfmSerFree },
+ { CSR_WIFI_SME_SME_STA_CONFIG_SET_CFM, CsrWifiSmeSmeStaConfigSetCfmSizeof, CsrWifiSmeSmeStaConfigSetCfmSer, CsrWifiSmeSmeStaConfigSetCfmDes, CsrWifiSmeSmeStaConfigSetCfmSerFree },
+ { CSR_WIFI_SME_STATION_MAC_ADDRESS_GET_CFM, CsrWifiSmeStationMacAddressGetCfmSizeof, CsrWifiSmeStationMacAddressGetCfmSer, CsrWifiSmeStationMacAddressGetCfmDes, CsrWifiSmeStationMacAddressGetCfmSerFree },
+ { CSR_WIFI_SME_TSPEC_IND, CsrWifiSmeTspecIndSizeof, CsrWifiSmeTspecIndSer, CsrWifiSmeTspecIndDes, CsrWifiSmeTspecIndSerFree },
+ { CSR_WIFI_SME_TSPEC_CFM, CsrWifiSmeTspecCfmSizeof, CsrWifiSmeTspecCfmSer, CsrWifiSmeTspecCfmDes, CsrWifiSmeTspecCfmSerFree },
+ { CSR_WIFI_SME_VERSIONS_GET_CFM, CsrWifiSmeVersionsGetCfmSizeof, CsrWifiSmeVersionsGetCfmSer, CsrWifiSmeVersionsGetCfmDes, CsrWifiSmeVersionsGetCfmSerFree },
+ { CSR_WIFI_SME_WIFI_FLIGHTMODE_CFM, CsrWifiSmeWifiFlightmodeCfmSizeof, CsrWifiSmeWifiFlightmodeCfmSer, CsrWifiSmeWifiFlightmodeCfmDes, CsrWifiSmeWifiFlightmodeCfmSerFree },
+ { CSR_WIFI_SME_WIFI_OFF_IND, CsrWifiSmeWifiOffIndSizeof, CsrWifiSmeWifiOffIndSer, CsrWifiSmeWifiOffIndDes, CsrWifiSmeWifiOffIndSerFree },
+ { CSR_WIFI_SME_WIFI_OFF_CFM, CsrWifiSmeWifiOffCfmSizeof, CsrWifiSmeWifiOffCfmSer, CsrWifiSmeWifiOffCfmDes, CsrWifiSmeWifiOffCfmSerFree },
+ { CSR_WIFI_SME_WIFI_ON_CFM, CsrWifiSmeWifiOnCfmSizeof, CsrWifiSmeWifiOnCfmSer, CsrWifiSmeWifiOnCfmDes, CsrWifiSmeWifiOnCfmSerFree },
+ { CSR_WIFI_SME_CLOAKED_SSIDS_SET_CFM, CsrWifiSmeCloakedSsidsSetCfmSizeof, CsrWifiSmeCloakedSsidsSetCfmSer, CsrWifiSmeCloakedSsidsSetCfmDes, CsrWifiSmeCloakedSsidsSetCfmSerFree },
+ { CSR_WIFI_SME_CLOAKED_SSIDS_GET_CFM, CsrWifiSmeCloakedSsidsGetCfmSizeof, CsrWifiSmeCloakedSsidsGetCfmSer, CsrWifiSmeCloakedSsidsGetCfmDes, CsrWifiSmeCloakedSsidsGetCfmSerFree },
+ { CSR_WIFI_SME_WIFI_ON_IND, CsrWifiSmeWifiOnIndSizeof, CsrWifiSmeWifiOnIndSer, CsrWifiSmeWifiOnIndDes, CsrWifiSmeWifiOnIndSerFree },
+ { CSR_WIFI_SME_SME_COMMON_CONFIG_GET_CFM, CsrWifiSmeSmeCommonConfigGetCfmSizeof, CsrWifiSmeSmeCommonConfigGetCfmSer, CsrWifiSmeSmeCommonConfigGetCfmDes, CsrWifiSmeSmeCommonConfigGetCfmSerFree },
+ { CSR_WIFI_SME_SME_COMMON_CONFIG_SET_CFM, CsrWifiSmeSmeCommonConfigSetCfmSizeof, CsrWifiSmeSmeCommonConfigSetCfmSer, CsrWifiSmeSmeCommonConfigSetCfmDes, CsrWifiSmeSmeCommonConfigSetCfmSerFree },
+ { CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_CFM, CsrWifiSmeInterfaceCapabilityGetCfmSizeof, CsrWifiSmeInterfaceCapabilityGetCfmSer, CsrWifiSmeInterfaceCapabilityGetCfmDes, CsrWifiSmeInterfaceCapabilityGetCfmSerFree },
+ { CSR_WIFI_SME_ERROR_IND, CsrWifiSmeErrorIndSizeof, CsrWifiSmeErrorIndSer, CsrWifiSmeErrorIndDes, CsrWifiSmeErrorIndSerFree },
+ { CSR_WIFI_SME_INFO_IND, CsrWifiSmeInfoIndSizeof, CsrWifiSmeInfoIndSer, CsrWifiSmeInfoIndDes, CsrWifiSmeInfoIndSerFree },
+ { CSR_WIFI_SME_CORE_DUMP_IND, CsrWifiSmeCoreDumpIndSizeof, CsrWifiSmeCoreDumpIndSer, CsrWifiSmeCoreDumpIndDes, CsrWifiSmeCoreDumpIndSerFree },
+ { CSR_WIFI_SME_AMP_STATUS_CHANGE_IND, CsrWifiSmeAmpStatusChangeIndSizeof, CsrWifiSmeAmpStatusChangeIndSer, CsrWifiSmeAmpStatusChangeIndDes, CsrWifiSmeAmpStatusChangeIndSerFree },
+ { CSR_WIFI_SME_WPS_CONFIGURATION_CFM, CsrWifiSmeWpsConfigurationCfmSizeof, CsrWifiSmeWpsConfigurationCfmSer, CsrWifiSmeWpsConfigurationCfmDes, CsrWifiSmeWpsConfigurationCfmSerFree },
+
+ { 0, NULL, NULL, NULL, NULL },
+};
+
+CsrMsgConvMsgEntry* CsrWifiSmeConverterLookup(CsrMsgConvMsgEntry *ce, CsrUint16 msgType)
+{
+ if (msgType & CSR_PRIM_UPSTREAM)
+ {
+ CsrUint16 idx = (msgType & ~CSR_PRIM_UPSTREAM) + CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT;
+ if (idx < (CSR_WIFI_SME_PRIM_UPSTREAM_COUNT + CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT) &&
+ csrwifisme_conv_lut[idx].msgType == msgType)
+ {
+ return &csrwifisme_conv_lut[idx];
+ }
+ }
+ else
+ {
+ if (msgType < CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT &&
+ csrwifisme_conv_lut[msgType].msgType == msgType)
+ {
+ return &csrwifisme_conv_lut[msgType];
+ }
+ }
+ return NULL;
+}
+
+
+void CsrWifiSmeConverterInit(void)
+{
+ CsrMsgConvInsert(CSR_WIFI_SME_PRIM, csrwifisme_conv_lut);
+ CsrMsgConvCustomLookupRegister(CSR_WIFI_SME_PRIM, CsrWifiSmeConverterLookup);
+}
+
+
+#ifdef CSR_LOG_ENABLE
+static const CsrLogPrimitiveInformation csrwifisme_conv_info = {
+ CSR_WIFI_SME_PRIM,
+ (CsrCharString *)"CSR_WIFI_SME_PRIM",
+ csrwifisme_conv_lut
+};
+const CsrLogPrimitiveInformation* CsrWifiSmeTechInfoGet(void)
+{
+ return &csrwifisme_conv_info;
+}
+
+
+#endif /* CSR_LOG_ENABLE */
+#endif /* EXCLUDE_CSR_WIFI_SME_MODULE */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_SME_CONVERTER_INIT_H__
+#define CSR_WIFI_SME_CONVERTER_INIT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef EXCLUDE_CSR_WIFI_SME_MODULE
+
+#include "csr_msgconv.h"
+
+#ifdef CSR_LOG_ENABLE
+#include "csr_log.h"
+
+extern const CsrLogPrimitiveInformation* CsrWifiSmeTechInfoGet(void);
+#endif /* CSR_LOG_ENABLE */
+
+extern void CsrWifiSmeConverterInit(void);
+
+#else /* EXCLUDE_CSR_WIFI_SME_MODULE */
+
+#define CsrWifiSmeConverterInit()
+
+#endif /* EXCLUDE_CSR_WIFI_SME_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_SME_CONVERTER_INIT_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_wifi_sme_prim.h"
+#include "csr_wifi_sme_lib.h"
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrWifiSmeFreeDownstreamMessageContents
+ *
+ * DESCRIPTION
+ *
+ *
+ * PARAMETERS
+ * eventClass: only the value CSR_WIFI_SME_PRIM will be handled
+ * message: the message to free
+ *----------------------------------------------------------------------------*/
+void CsrWifiSmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message)
+{
+ if (eventClass != CSR_WIFI_SME_PRIM)
+ {
+ return;
+ }
+ if (NULL == message)
+ {
+ return;
+ }
+
+ switch (*((CsrWifiSmePrim *) message))
+ {
+ case CSR_WIFI_SME_BLACKLIST_REQ:
+ {
+ CsrWifiSmeBlacklistReq *p = (CsrWifiSmeBlacklistReq *)message;
+ CsrPmemFree(p->setAddresses);
+ p->setAddresses = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_CALIBRATION_DATA_SET_REQ:
+ {
+ CsrWifiSmeCalibrationDataSetReq *p = (CsrWifiSmeCalibrationDataSetReq *)message;
+ CsrPmemFree(p->calibrationData);
+ p->calibrationData = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_CONNECT_REQ:
+ {
+ CsrWifiSmeConnectReq *p = (CsrWifiSmeConnectReq *)message;
+ CsrPmemFree(p->connectionConfig.mlmeAssociateReqInformationElements);
+ p->connectionConfig.mlmeAssociateReqInformationElements = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_MIB_GET_NEXT_REQ:
+ {
+ CsrWifiSmeMibGetNextReq *p = (CsrWifiSmeMibGetNextReq *)message;
+ CsrPmemFree(p->mibAttribute);
+ p->mibAttribute = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_MIB_GET_REQ:
+ {
+ CsrWifiSmeMibGetReq *p = (CsrWifiSmeMibGetReq *)message;
+ CsrPmemFree(p->mibAttribute);
+ p->mibAttribute = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_MIB_SET_REQ:
+ {
+ CsrWifiSmeMibSetReq *p = (CsrWifiSmeMibSetReq *)message;
+ CsrPmemFree(p->mibAttribute);
+ p->mibAttribute = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_MULTICAST_ADDRESS_REQ:
+ {
+ CsrWifiSmeMulticastAddressReq *p = (CsrWifiSmeMulticastAddressReq *)message;
+ CsrPmemFree(p->setAddresses);
+ p->setAddresses = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_PACKET_FILTER_SET_REQ:
+ {
+ CsrWifiSmePacketFilterSetReq *p = (CsrWifiSmePacketFilterSetReq *)message;
+ CsrPmemFree(p->filter);
+ p->filter = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_PMKID_REQ:
+ {
+ CsrWifiSmePmkidReq *p = (CsrWifiSmePmkidReq *)message;
+ CsrPmemFree(p->setPmkids);
+ p->setPmkids = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_SCAN_CONFIG_SET_REQ:
+ {
+ CsrWifiSmeScanConfigSetReq *p = (CsrWifiSmeScanConfigSetReq *)message;
+ CsrPmemFree(p->scanConfig.passiveChannelList);
+ p->scanConfig.passiveChannelList = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_SCAN_FULL_REQ:
+ {
+ CsrWifiSmeScanFullReq *p = (CsrWifiSmeScanFullReq *)message;
+ CsrPmemFree(p->ssid);
+ p->ssid = NULL;
+ CsrPmemFree(p->channelList);
+ p->channelList = NULL;
+ CsrPmemFree(p->probeIe);
+ p->probeIe = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_TSPEC_REQ:
+ {
+ CsrWifiSmeTspecReq *p = (CsrWifiSmeTspecReq *)message;
+ CsrPmemFree(p->tspec);
+ p->tspec = NULL;
+ CsrPmemFree(p->tclas);
+ p->tclas = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_WIFI_FLIGHTMODE_REQ:
+ {
+ CsrWifiSmeWifiFlightmodeReq *p = (CsrWifiSmeWifiFlightmodeReq *)message;
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < p->mibFilesCount; i1++)
+ {
+ CsrPmemFree(p->mibFiles[i1].data);
+ p->mibFiles[i1].data = NULL;
+ }
+ }
+ CsrPmemFree(p->mibFiles);
+ p->mibFiles = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_WIFI_ON_REQ:
+ {
+ CsrWifiSmeWifiOnReq *p = (CsrWifiSmeWifiOnReq *)message;
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < p->mibFilesCount; i1++)
+ {
+ CsrPmemFree(p->mibFiles[i1].data);
+ p->mibFiles[i1].data = NULL;
+ }
+ }
+ CsrPmemFree(p->mibFiles);
+ p->mibFiles = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_CLOAKED_SSIDS_SET_REQ:
+ {
+ CsrWifiSmeCloakedSsidsSetReq *p = (CsrWifiSmeCloakedSsidsSetReq *)message;
+ CsrPmemFree(p->cloakedSsids.cloakedSsids);
+ p->cloakedSsids.cloakedSsids = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_WPS_CONFIGURATION_REQ:
+ {
+ CsrWifiSmeWpsConfigurationReq *p = (CsrWifiSmeWpsConfigurationReq *)message;
+ CsrPmemFree(p->wpsConfig.secondaryDeviceType);
+ p->wpsConfig.secondaryDeviceType = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_SET_REQ:
+ {
+ CsrWifiSmeSetReq *p = (CsrWifiSmeSetReq *)message;
+ CsrPmemFree(p->data);
+ p->data = NULL;
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_wifi_sme_prim.h"
+#include "csr_wifi_sme_lib.h"
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrWifiSmeFreeUpstreamMessageContents
+ *
+ * DESCRIPTION
+ *
+ *
+ * PARAMETERS
+ * eventClass: only the value CSR_WIFI_SME_PRIM will be handled
+ * message: the message to free
+ *----------------------------------------------------------------------------*/
+void CsrWifiSmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message)
+{
+ if (eventClass != CSR_WIFI_SME_PRIM)
+ {
+ return;
+ }
+ if (NULL == message)
+ {
+ return;
+ }
+
+ switch (*((CsrWifiSmePrim *) message))
+ {
+ case CSR_WIFI_SME_ASSOCIATION_COMPLETE_IND:
+ {
+ CsrWifiSmeAssociationCompleteInd *p = (CsrWifiSmeAssociationCompleteInd *)message;
+ CsrPmemFree(p->connectionInfo.beaconFrame);
+ p->connectionInfo.beaconFrame = NULL;
+ CsrPmemFree(p->connectionInfo.associationReqFrame);
+ p->connectionInfo.associationReqFrame = NULL;
+ CsrPmemFree(p->connectionInfo.associationRspFrame);
+ p->connectionInfo.associationRspFrame = NULL;
+ CsrPmemFree(p->connectionInfo.assocScanInfoElements);
+ p->connectionInfo.assocScanInfoElements = NULL;
+ CsrPmemFree(p->connectionInfo.assocReqInfoElements);
+ p->connectionInfo.assocReqInfoElements = NULL;
+ CsrPmemFree(p->connectionInfo.assocRspInfoElements);
+ p->connectionInfo.assocRspInfoElements = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_BLACKLIST_CFM:
+ {
+ CsrWifiSmeBlacklistCfm *p = (CsrWifiSmeBlacklistCfm *)message;
+ CsrPmemFree(p->getAddresses);
+ p->getAddresses = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_CALIBRATION_DATA_GET_CFM:
+ {
+ CsrWifiSmeCalibrationDataGetCfm *p = (CsrWifiSmeCalibrationDataGetCfm *)message;
+ CsrPmemFree(p->calibrationData);
+ p->calibrationData = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_CONNECTION_CONFIG_GET_CFM:
+ {
+ CsrWifiSmeConnectionConfigGetCfm *p = (CsrWifiSmeConnectionConfigGetCfm *)message;
+ CsrPmemFree(p->connectionConfig.mlmeAssociateReqInformationElements);
+ p->connectionConfig.mlmeAssociateReqInformationElements = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_CONNECTION_INFO_GET_CFM:
+ {
+ CsrWifiSmeConnectionInfoGetCfm *p = (CsrWifiSmeConnectionInfoGetCfm *)message;
+ CsrPmemFree(p->connectionInfo.beaconFrame);
+ p->connectionInfo.beaconFrame = NULL;
+ CsrPmemFree(p->connectionInfo.associationReqFrame);
+ p->connectionInfo.associationReqFrame = NULL;
+ CsrPmemFree(p->connectionInfo.associationRspFrame);
+ p->connectionInfo.associationRspFrame = NULL;
+ CsrPmemFree(p->connectionInfo.assocScanInfoElements);
+ p->connectionInfo.assocScanInfoElements = NULL;
+ CsrPmemFree(p->connectionInfo.assocReqInfoElements);
+ p->connectionInfo.assocReqInfoElements = NULL;
+ CsrPmemFree(p->connectionInfo.assocRspInfoElements);
+ p->connectionInfo.assocRspInfoElements = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_MEDIA_STATUS_IND:
+ {
+ CsrWifiSmeMediaStatusInd *p = (CsrWifiSmeMediaStatusInd *)message;
+ CsrPmemFree(p->connectionInfo.beaconFrame);
+ p->connectionInfo.beaconFrame = NULL;
+ CsrPmemFree(p->connectionInfo.associationReqFrame);
+ p->connectionInfo.associationReqFrame = NULL;
+ CsrPmemFree(p->connectionInfo.associationRspFrame);
+ p->connectionInfo.associationRspFrame = NULL;
+ CsrPmemFree(p->connectionInfo.assocScanInfoElements);
+ p->connectionInfo.assocScanInfoElements = NULL;
+ CsrPmemFree(p->connectionInfo.assocReqInfoElements);
+ p->connectionInfo.assocReqInfoElements = NULL;
+ CsrPmemFree(p->connectionInfo.assocRspInfoElements);
+ p->connectionInfo.assocRspInfoElements = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_MIB_GET_CFM:
+ {
+ CsrWifiSmeMibGetCfm *p = (CsrWifiSmeMibGetCfm *)message;
+ CsrPmemFree(p->mibAttribute);
+ p->mibAttribute = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_MIB_GET_NEXT_CFM:
+ {
+ CsrWifiSmeMibGetNextCfm *p = (CsrWifiSmeMibGetNextCfm *)message;
+ CsrPmemFree(p->mibAttribute);
+ p->mibAttribute = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_MULTICAST_ADDRESS_CFM:
+ {
+ CsrWifiSmeMulticastAddressCfm *p = (CsrWifiSmeMulticastAddressCfm *)message;
+ CsrPmemFree(p->getAddresses);
+ p->getAddresses = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_PMKID_CANDIDATE_LIST_IND:
+ {
+ CsrWifiSmePmkidCandidateListInd *p = (CsrWifiSmePmkidCandidateListInd *)message;
+ CsrPmemFree(p->pmkidCandidates);
+ p->pmkidCandidates = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_PMKID_CFM:
+ {
+ CsrWifiSmePmkidCfm *p = (CsrWifiSmePmkidCfm *)message;
+ CsrPmemFree(p->getPmkids);
+ p->getPmkids = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_SCAN_CONFIG_GET_CFM:
+ {
+ CsrWifiSmeScanConfigGetCfm *p = (CsrWifiSmeScanConfigGetCfm *)message;
+ CsrPmemFree(p->scanConfig.passiveChannelList);
+ p->scanConfig.passiveChannelList = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_SCAN_RESULT_IND:
+ {
+ CsrWifiSmeScanResultInd *p = (CsrWifiSmeScanResultInd *)message;
+ CsrPmemFree(p->result.informationElements);
+ p->result.informationElements = NULL;
+ switch (p->result.p2pDeviceRole)
+ {
+ case CSR_WIFI_SME_P2P_ROLE_GO:
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < p->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
+ {
+ CsrPmemFree(p->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
+ p->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = NULL;
+ }
+ }
+ CsrPmemFree(p->result.deviceInfo.groupInfo.p2PClientInfo);
+ p->result.deviceInfo.groupInfo.p2PClientInfo = NULL;
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
+ CsrPmemFree(p->result.deviceInfo.standalonedevInfo.secDeviceType);
+ p->result.deviceInfo.standalonedevInfo.secDeviceType = NULL;
+ break;
+ default:
+ break;
+ }
+ break;
+ }
+ case CSR_WIFI_SME_SCAN_RESULTS_GET_CFM:
+ {
+ CsrWifiSmeScanResultsGetCfm *p = (CsrWifiSmeScanResultsGetCfm *)message;
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < p->scanResultsCount; i1++)
+ {
+ CsrPmemFree(p->scanResults[i1].informationElements);
+ p->scanResults[i1].informationElements = NULL;
+ switch (p->scanResults[i1].p2pDeviceRole)
+ {
+ case CSR_WIFI_SME_P2P_ROLE_GO:
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < p->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
+ {
+ CsrPmemFree(p->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
+ p->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = NULL;
+ }
+ }
+ CsrPmemFree(p->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo);
+ p->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo = NULL;
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
+ CsrPmemFree(p->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType);
+ p->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType = NULL;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ CsrPmemFree(p->scanResults);
+ p->scanResults = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_TSPEC_IND:
+ {
+ CsrWifiSmeTspecInd *p = (CsrWifiSmeTspecInd *)message;
+ CsrPmemFree(p->tspec);
+ p->tspec = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_TSPEC_CFM:
+ {
+ CsrWifiSmeTspecCfm *p = (CsrWifiSmeTspecCfm *)message;
+ CsrPmemFree(p->tspec);
+ p->tspec = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_VERSIONS_GET_CFM:
+ {
+ CsrWifiSmeVersionsGetCfm *p = (CsrWifiSmeVersionsGetCfm *)message;
+ CsrPmemFree(p->versions.routerBuild);
+ p->versions.routerBuild = NULL;
+ CsrPmemFree(p->versions.smeBuild);
+ p->versions.smeBuild = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_CLOAKED_SSIDS_GET_CFM:
+ {
+ CsrWifiSmeCloakedSsidsGetCfm *p = (CsrWifiSmeCloakedSsidsGetCfm *)message;
+ CsrPmemFree(p->cloakedSsids.cloakedSsids);
+ p->cloakedSsids.cloakedSsids = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_ERROR_IND:
+ {
+ CsrWifiSmeErrorInd *p = (CsrWifiSmeErrorInd *)message;
+ CsrPmemFree(p->errorMessage);
+ p->errorMessage = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_INFO_IND:
+ {
+ CsrWifiSmeInfoInd *p = (CsrWifiSmeInfoInd *)message;
+ CsrPmemFree(p->infoMessage);
+ p->infoMessage = NULL;
+ break;
+ }
+ case CSR_WIFI_SME_CORE_DUMP_IND:
+ {
+ CsrWifiSmeCoreDumpInd *p = (CsrWifiSmeCoreDumpInd *)message;
+ CsrPmemFree(p->data);
+ p->data = NULL;
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_SME_LIB_H__
+#define CSR_WIFI_SME_LIB_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_sched.h"
+#include "csr_util.h"
+#include "csr_msg_transport.h"
+
+#include "csr_wifi_lib.h"
+
+#include "csr_wifi_sme_prim.h"
+#include "csr_wifi_sme_task.h"
+
+
+#ifndef CSR_WIFI_SME_LIB_DESTINATION_QUEUE
+# ifdef CSR_WIFI_NME_ENABLE
+# include "csr_wifi_nme_task.h"
+# define CSR_WIFI_SME_LIB_DESTINATION_QUEUE CSR_WIFI_NME_IFACEQUEUE
+# else
+# define CSR_WIFI_SME_LIB_DESTINATION_QUEUE CSR_WIFI_SME_IFACEQUEUE
+# endif
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiSmeFreeUpstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_SME upstream message. Does not
+ * free the message itself, and can only be used for upstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_SME upstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiSmeFreeUpstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * CsrWifiSmeFreeDownstreamMessageContents
+ *
+ * DESCRIPTION
+ * Free the allocated memory in a CSR_WIFI_SME downstream message. Does not
+ * free the message itself, and can only be used for downstream messages.
+ *
+ * PARAMETERS
+ * Deallocates the resources in a CSR_WIFI_SME downstream message
+ *----------------------------------------------------------------------------*/
+void CsrWifiSmeFreeDownstreamMessageContents(CsrUint16 eventClass, void *message);
+
+/*----------------------------------------------------------------------------*
+ * Enum to string functions
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiSme80211NetworkTypeToString(CsrWifiSme80211NetworkType value);
+const CsrCharString* CsrWifiSme80211PrivacyModeToString(CsrWifiSme80211PrivacyMode value);
+const CsrCharString* CsrWifiSme80211dTrustLevelToString(CsrWifiSme80211dTrustLevel value);
+const CsrCharString* CsrWifiSmeAmpStatusToString(CsrWifiSmeAmpStatus value);
+const CsrCharString* CsrWifiSmeAuthModeToString(CsrWifiSmeAuthMode value);
+const CsrCharString* CsrWifiSmeBasicUsabilityToString(CsrWifiSmeBasicUsability value);
+const CsrCharString* CsrWifiSmeBssTypeToString(CsrWifiSmeBssType value);
+const CsrCharString* CsrWifiSmeCoexSchemeToString(CsrWifiSmeCoexScheme value);
+const CsrCharString* CsrWifiSmeControlIndicationToString(CsrWifiSmeControlIndication value);
+const CsrCharString* CsrWifiSmeCtsProtectionTypeToString(CsrWifiSmeCtsProtectionType value);
+const CsrCharString* CsrWifiSmeD3AutoScanModeToString(CsrWifiSmeD3AutoScanMode value);
+const CsrCharString* CsrWifiSmeEncryptionToString(CsrWifiSmeEncryption value);
+const CsrCharString* CsrWifiSmeFirmwareDriverInterfaceToString(CsrWifiSmeFirmwareDriverInterface value);
+const CsrCharString* CsrWifiSmeHostPowerModeToString(CsrWifiSmeHostPowerMode value);
+const CsrCharString* CsrWifiSmeIEEE80211ReasonToString(CsrWifiSmeIEEE80211Reason value);
+const CsrCharString* CsrWifiSmeIEEE80211ResultToString(CsrWifiSmeIEEE80211Result value);
+const CsrCharString* CsrWifiSmeIndicationsToString(CsrWifiSmeIndications value);
+const CsrCharString* CsrWifiSmeKeyTypeToString(CsrWifiSmeKeyType value);
+const CsrCharString* CsrWifiSmeListActionToString(CsrWifiSmeListAction value);
+const CsrCharString* CsrWifiSmeMediaStatusToString(CsrWifiSmeMediaStatus value);
+const CsrCharString* CsrWifiSmeP2pCapabilityToString(CsrWifiSmeP2pCapability value);
+const CsrCharString* CsrWifiSmeP2pGroupCapabilityToString(CsrWifiSmeP2pGroupCapability value);
+const CsrCharString* CsrWifiSmeP2pNoaConfigMethodToString(CsrWifiSmeP2pNoaConfigMethod value);
+const CsrCharString* CsrWifiSmeP2pRoleToString(CsrWifiSmeP2pRole value);
+const CsrCharString* CsrWifiSmeP2pStatusToString(CsrWifiSmeP2pStatus value);
+const CsrCharString* CsrWifiSmePacketFilterModeToString(CsrWifiSmePacketFilterMode value);
+const CsrCharString* CsrWifiSmePowerSaveLevelToString(CsrWifiSmePowerSaveLevel value);
+const CsrCharString* CsrWifiSmePreambleTypeToString(CsrWifiSmePreambleType value);
+const CsrCharString* CsrWifiSmeRadioIFToString(CsrWifiSmeRadioIF value);
+const CsrCharString* CsrWifiSmeRegulatoryDomainToString(CsrWifiSmeRegulatoryDomain value);
+const CsrCharString* CsrWifiSmeRoamReasonToString(CsrWifiSmeRoamReason value);
+const CsrCharString* CsrWifiSmeScanTypeToString(CsrWifiSmeScanType value);
+const CsrCharString* CsrWifiSmeTrafficTypeToString(CsrWifiSmeTrafficType value);
+const CsrCharString* CsrWifiSmeTspecCtrlToString(CsrWifiSmeTspecCtrl value);
+const CsrCharString* CsrWifiSmeTspecResultCodeToString(CsrWifiSmeTspecResultCode value);
+const CsrCharString* CsrWifiSmeWepAuthModeToString(CsrWifiSmeWepAuthMode value);
+const CsrCharString* CsrWifiSmeWepCredentialTypeToString(CsrWifiSmeWepCredentialType value);
+const CsrCharString* CsrWifiSmeWmmModeToString(CsrWifiSmeWmmMode value);
+const CsrCharString* CsrWifiSmeWmmQosInfoToString(CsrWifiSmeWmmQosInfo value);
+const CsrCharString* CsrWifiSmeWpsConfigTypeToString(CsrWifiSmeWpsConfigType value);
+const CsrCharString* CsrWifiSmeWpsDeviceCategoryToString(CsrWifiSmeWpsDeviceCategory value);
+const CsrCharString* CsrWifiSmeWpsDeviceSubCategoryToString(CsrWifiSmeWpsDeviceSubCategory value);
+const CsrCharString* CsrWifiSmeWpsDpidToString(CsrWifiSmeWpsDpid value);
+const CsrCharString* CsrWifiSmeWpsRegistrationToString(CsrWifiSmeWpsRegistration value);
+
+
+/*----------------------------------------------------------------------------*
+ * CsrPrim Type toString function.
+ * Converts a message type to the String name of the Message
+ *----------------------------------------------------------------------------*/
+const CsrCharString* CsrWifiSmePrimTypeToString(CsrPrim msgType);
+
+/*----------------------------------------------------------------------------*
+ * Lookup arrays for PrimType name Strings
+ *----------------------------------------------------------------------------*/
+extern const CsrCharString *CsrWifiSmeUpstreamPrimNames[CSR_WIFI_SME_PRIM_UPSTREAM_COUNT];
+extern const CsrCharString *CsrWifiSmeDownstreamPrimNames[CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT];
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeActivateReqSend
+
+ DESCRIPTION
+ The WMA sends this primitive to activate the SME.
+ The WMA must activate the SME before it can send any other primitive.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeActivateReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeActivateReq *) CsrPmemAlloc(sizeof(CsrWifiSmeActivateReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ACTIVATE_REQ, dst__, src__);
+
+#define CsrWifiSmeActivateReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeActivateReq *msg__; \
+ CsrWifiSmeActivateReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeActivateReqSend(src__) \
+ CsrWifiSmeActivateReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeActivateCfmSend
+
+ DESCRIPTION
+ The SME sends this primitive when the activation is complete.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeActivateCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeActivateCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeActivateCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ACTIVATE_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeActivateCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeActivateCfm *msg__; \
+ CsrWifiSmeActivateCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeActivateCfmSend(dst__, status__) \
+ CsrWifiSmeActivateCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAdhocConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the adHocConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeAdhocConfigGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeAdhocConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeAdhocConfigGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeAdhocConfigGetReq *msg__; \
+ CsrWifiSmeAdhocConfigGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeAdhocConfigGetReqSend(src__) \
+ CsrWifiSmeAdhocConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAdhocConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ adHocConfig - Contains the values used when starting an Ad-hoc (IBSS)
+ connection.
+
+*******************************************************************************/
+#define CsrWifiSmeAdhocConfigGetCfmCreate(msg__, dst__, src__, status__, adHocConfig__) \
+ msg__ = (CsrWifiSmeAdhocConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->adHocConfig = (adHocConfig__);
+
+#define CsrWifiSmeAdhocConfigGetCfmSendTo(dst__, src__, status__, adHocConfig__) \
+ { \
+ CsrWifiSmeAdhocConfigGetCfm *msg__; \
+ CsrWifiSmeAdhocConfigGetCfmCreate(msg__, dst__, src__, status__, adHocConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeAdhocConfigGetCfmSend(dst__, status__, adHocConfig__) \
+ CsrWifiSmeAdhocConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, adHocConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAdhocConfigSetReqSend
+
+ DESCRIPTION
+ This primitive sets the value of the adHocConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ adHocConfig - Sets the values to use when starting an ad hoc network.
+
+*******************************************************************************/
+#define CsrWifiSmeAdhocConfigSetReqCreate(msg__, dst__, src__, adHocConfig__) \
+ msg__ = (CsrWifiSmeAdhocConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_SET_REQ, dst__, src__); \
+ msg__->adHocConfig = (adHocConfig__);
+
+#define CsrWifiSmeAdhocConfigSetReqSendTo(dst__, src__, adHocConfig__) \
+ { \
+ CsrWifiSmeAdhocConfigSetReq *msg__; \
+ CsrWifiSmeAdhocConfigSetReqCreate(msg__, dst__, src__, adHocConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeAdhocConfigSetReqSend(src__, adHocConfig__) \
+ CsrWifiSmeAdhocConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, adHocConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAdhocConfigSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeAdhocConfigSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeAdhocConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ADHOC_CONFIG_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeAdhocConfigSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeAdhocConfigSetCfm *msg__; \
+ CsrWifiSmeAdhocConfigSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeAdhocConfigSetCfmSend(dst__, status__) \
+ CsrWifiSmeAdhocConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAmpStatusChangeIndSend
+
+ DESCRIPTION
+ Indication of change to AMP activity.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface on which the AMP activity changed.
+ ampStatus - The new status of AMP activity.Range: {AMP_ACTIVE,
+ AMP_INACTIVE}.
+
+*******************************************************************************/
+#define CsrWifiSmeAmpStatusChangeIndCreate(msg__, dst__, src__, interfaceTag__, ampStatus__) \
+ msg__ = (CsrWifiSmeAmpStatusChangeInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAmpStatusChangeInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_AMP_STATUS_CHANGE_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->ampStatus = (ampStatus__);
+
+#define CsrWifiSmeAmpStatusChangeIndSendTo(dst__, src__, interfaceTag__, ampStatus__) \
+ { \
+ CsrWifiSmeAmpStatusChangeInd *msg__; \
+ CsrWifiSmeAmpStatusChangeIndCreate(msg__, dst__, src__, interfaceTag__, ampStatus__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeAmpStatusChangeIndSend(dst__, interfaceTag__, ampStatus__) \
+ CsrWifiSmeAmpStatusChangeIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, ampStatus__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAssociationCompleteIndSend
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive it whenever it completes an attempt to associate with an AP. If
+ the association was successful, status will be set to
+ CSR_WIFI_SME_STATUS_SUCCESS, otherwise status and deauthReason shall be
+ set to appropriate error codes.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the association procedure
+ connectionInfo - This parameter is relevant only if result is
+ CSR_WIFI_SME_STATUS_SUCCESS:
+ it points to the connection information for the new network
+ deauthReason - This parameter is relevant only if result is not
+ CSR_WIFI_SME_STATUS_SUCCESS:
+ if the AP deauthorised the station, it gives the reason of
+ the deauthorization
+
+*******************************************************************************/
+#define CsrWifiSmeAssociationCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__, deauthReason__) \
+ msg__ = (CsrWifiSmeAssociationCompleteInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAssociationCompleteInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ASSOCIATION_COMPLETE_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->connectionInfo = (connectionInfo__); \
+ msg__->deauthReason = (deauthReason__);
+
+#define CsrWifiSmeAssociationCompleteIndSendTo(dst__, src__, interfaceTag__, status__, connectionInfo__, deauthReason__) \
+ { \
+ CsrWifiSmeAssociationCompleteInd *msg__; \
+ CsrWifiSmeAssociationCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__, deauthReason__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeAssociationCompleteIndSend(dst__, interfaceTag__, status__, connectionInfo__, deauthReason__) \
+ CsrWifiSmeAssociationCompleteIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionInfo__, deauthReason__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAssociationStartIndSend
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive it whenever it begins an attempt to associate with an AP.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ address - BSSID of the associating network
+ ssid - Service Set identifier of the associating network
+
+*******************************************************************************/
+#define CsrWifiSmeAssociationStartIndCreate(msg__, dst__, src__, interfaceTag__, address__, ssid__) \
+ msg__ = (CsrWifiSmeAssociationStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAssociationStartInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ASSOCIATION_START_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->address = (address__); \
+ msg__->ssid = (ssid__);
+
+#define CsrWifiSmeAssociationStartIndSendTo(dst__, src__, interfaceTag__, address__, ssid__) \
+ { \
+ CsrWifiSmeAssociationStartInd *msg__; \
+ CsrWifiSmeAssociationStartIndCreate(msg__, dst__, src__, interfaceTag__, address__, ssid__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeAssociationStartIndSend(dst__, interfaceTag__, address__, ssid__) \
+ CsrWifiSmeAssociationStartIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, address__, ssid__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeBlacklistReqSend
+
+ DESCRIPTION
+ The wireless manager application should call this primitive to notify the
+ driver of any networks that should not be connected to. The interface
+ allows the wireless manager application to query, add, remove, and flush
+ the BSSIDs that the driver may not connect or roam to.
+ When this primitive adds to the black list the BSSID to which the SME is
+ currently connected, the SME will try to roam, if applicable, to another
+ BSSID in the same ESS; if the roaming procedure fails, the SME will
+ disconnect.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ action - The value of the CsrWifiSmeListAction parameter instructs
+ the driver to modify or provide the list of blacklisted
+ networks.
+ setAddressCount - Number of BSSIDs sent with this primitive
+ setAddresses - Pointer to the list of BBSIDs sent with the primitive, set
+ to NULL if none is sent.
+
+*******************************************************************************/
+#define CsrWifiSmeBlacklistReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressCount__, setAddresses__) \
+ msg__ = (CsrWifiSmeBlacklistReq *) CsrPmemAlloc(sizeof(CsrWifiSmeBlacklistReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_BLACKLIST_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->action = (action__); \
+ msg__->setAddressCount = (setAddressCount__); \
+ msg__->setAddresses = (setAddresses__);
+
+#define CsrWifiSmeBlacklistReqSendTo(dst__, src__, interfaceTag__, action__, setAddressCount__, setAddresses__) \
+ { \
+ CsrWifiSmeBlacklistReq *msg__; \
+ CsrWifiSmeBlacklistReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressCount__, setAddresses__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeBlacklistReqSend(src__, interfaceTag__, action__, setAddressCount__, setAddresses__) \
+ CsrWifiSmeBlacklistReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, setAddressCount__, setAddresses__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeBlacklistCfmSend
+
+ DESCRIPTION
+ The SME will call this primitive when the action on the blacklist has
+ completed. For a GET action, this primitive also reports the list of
+ BBSIDs in the blacklist.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ action - Action in the request
+ getAddressCount - This parameter is only relevant if action is
+ CSR_WIFI_SME_LIST_ACTION_GET:
+ number of BSSIDs sent with this primitive
+ getAddresses - Pointer to the list of BBSIDs sent with the primitive, set
+ to NULL if none is sent.
+
+*******************************************************************************/
+#define CsrWifiSmeBlacklistCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__) \
+ msg__ = (CsrWifiSmeBlacklistCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeBlacklistCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_BLACKLIST_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->action = (action__); \
+ msg__->getAddressCount = (getAddressCount__); \
+ msg__->getAddresses = (getAddresses__);
+
+#define CsrWifiSmeBlacklistCfmSendTo(dst__, src__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__) \
+ { \
+ CsrWifiSmeBlacklistCfm *msg__; \
+ CsrWifiSmeBlacklistCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeBlacklistCfmSend(dst__, interfaceTag__, status__, action__, getAddressCount__, getAddresses__) \
+ CsrWifiSmeBlacklistCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, getAddressCount__, getAddresses__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCalibrationDataGetReqSend
+
+ DESCRIPTION
+ This primitive retrieves the Wi-Fi radio calibration data.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeCalibrationDataGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeCalibrationDataGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeCalibrationDataGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeCalibrationDataGetReq *msg__; \
+ CsrWifiSmeCalibrationDataGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCalibrationDataGetReqSend(src__) \
+ CsrWifiSmeCalibrationDataGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCalibrationDataGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ calibrationDataLength - Number of bytes in the buffer pointed by
+ calibrationData
+ calibrationData - Pointer to a buffer of length calibrationDataLength
+ containing the calibration data
+
+*******************************************************************************/
+#define CsrWifiSmeCalibrationDataGetCfmCreate(msg__, dst__, src__, status__, calibrationDataLength__, calibrationData__) \
+ msg__ = (CsrWifiSmeCalibrationDataGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->calibrationDataLength = (calibrationDataLength__); \
+ msg__->calibrationData = (calibrationData__);
+
+#define CsrWifiSmeCalibrationDataGetCfmSendTo(dst__, src__, status__, calibrationDataLength__, calibrationData__) \
+ { \
+ CsrWifiSmeCalibrationDataGetCfm *msg__; \
+ CsrWifiSmeCalibrationDataGetCfmCreate(msg__, dst__, src__, status__, calibrationDataLength__, calibrationData__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCalibrationDataGetCfmSend(dst__, status__, calibrationDataLength__, calibrationData__) \
+ CsrWifiSmeCalibrationDataGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, calibrationDataLength__, calibrationData__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCalibrationDataSetReqSend
+
+ DESCRIPTION
+ This primitive sets the Wi-Fi radio calibration data.
+ The usage of the primitive with proper calibration data will avoid
+ time-consuming configuration after power-up.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ calibrationDataLength - Number of bytes in the buffer pointed by
+ calibrationData
+ calibrationData - Pointer to a buffer of length calibrationDataLength
+ containing the calibration data
+
+*******************************************************************************/
+#define CsrWifiSmeCalibrationDataSetReqCreate(msg__, dst__, src__, calibrationDataLength__, calibrationData__) \
+ msg__ = (CsrWifiSmeCalibrationDataSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_SET_REQ, dst__, src__); \
+ msg__->calibrationDataLength = (calibrationDataLength__); \
+ msg__->calibrationData = (calibrationData__);
+
+#define CsrWifiSmeCalibrationDataSetReqSendTo(dst__, src__, calibrationDataLength__, calibrationData__) \
+ { \
+ CsrWifiSmeCalibrationDataSetReq *msg__; \
+ CsrWifiSmeCalibrationDataSetReqCreate(msg__, dst__, src__, calibrationDataLength__, calibrationData__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCalibrationDataSetReqSend(src__, calibrationDataLength__, calibrationData__) \
+ CsrWifiSmeCalibrationDataSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, calibrationDataLength__, calibrationData__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCalibrationDataSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeCalibrationDataSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeCalibrationDataSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CALIBRATION_DATA_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeCalibrationDataSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeCalibrationDataSetCfm *msg__; \
+ CsrWifiSmeCalibrationDataSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCalibrationDataSetCfmSend(dst__, status__) \
+ CsrWifiSmeCalibrationDataSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCcxConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the CcxConfig parameter.
+ CURRENTLY NOT SUPPORTED.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiSmeCcxConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeCcxConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_GET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeCcxConfigGetReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeCcxConfigGetReq *msg__; \
+ CsrWifiSmeCcxConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCcxConfigGetReqSend(src__, interfaceTag__) \
+ CsrWifiSmeCcxConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCcxConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ ccxConfig - Currently not supported
+
+*******************************************************************************/
+#define CsrWifiSmeCcxConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, ccxConfig__) \
+ msg__ = (CsrWifiSmeCcxConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_GET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->ccxConfig = (ccxConfig__);
+
+#define CsrWifiSmeCcxConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, ccxConfig__) \
+ { \
+ CsrWifiSmeCcxConfigGetCfm *msg__; \
+ CsrWifiSmeCcxConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, ccxConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCcxConfigGetCfmSend(dst__, interfaceTag__, status__, ccxConfig__) \
+ CsrWifiSmeCcxConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, ccxConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCcxConfigSetReqSend
+
+ DESCRIPTION
+ This primitive sets the value of the CcxConfig parameter.
+ CURRENTLY NOT SUPPORTED.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ ccxConfig - Currently not supported
+
+*******************************************************************************/
+#define CsrWifiSmeCcxConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, ccxConfig__) \
+ msg__ = (CsrWifiSmeCcxConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_SET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->ccxConfig = (ccxConfig__);
+
+#define CsrWifiSmeCcxConfigSetReqSendTo(dst__, src__, interfaceTag__, ccxConfig__) \
+ { \
+ CsrWifiSmeCcxConfigSetReq *msg__; \
+ CsrWifiSmeCcxConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, ccxConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCcxConfigSetReqSend(src__, interfaceTag__, ccxConfig__) \
+ CsrWifiSmeCcxConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, ccxConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCcxConfigSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeCcxConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeCcxConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CCX_CONFIG_SET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeCcxConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeCcxConfigSetCfm *msg__; \
+ CsrWifiSmeCcxConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCcxConfigSetCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeCcxConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCloakedSsidsGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the CloakedSsids parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeCloakedSsidsGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeCloakedSsidsGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeCloakedSsidsGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeCloakedSsidsGetReq *msg__; \
+ CsrWifiSmeCloakedSsidsGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCloakedSsidsGetReqSend(src__) \
+ CsrWifiSmeCloakedSsidsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCloakedSsidsGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ cloakedSsids - Reports list of cloaked SSIDs that are explicitly scanned for
+ by the driver
+
+*******************************************************************************/
+#define CsrWifiSmeCloakedSsidsGetCfmCreate(msg__, dst__, src__, status__, cloakedSsids__) \
+ msg__ = (CsrWifiSmeCloakedSsidsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->cloakedSsids = (cloakedSsids__);
+
+#define CsrWifiSmeCloakedSsidsGetCfmSendTo(dst__, src__, status__, cloakedSsids__) \
+ { \
+ CsrWifiSmeCloakedSsidsGetCfm *msg__; \
+ CsrWifiSmeCloakedSsidsGetCfmCreate(msg__, dst__, src__, status__, cloakedSsids__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCloakedSsidsGetCfmSend(dst__, status__, cloakedSsids__) \
+ CsrWifiSmeCloakedSsidsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, cloakedSsids__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCloakedSsidsSetReqSend
+
+ DESCRIPTION
+ This primitive sets the list of cloaked SSIDs for which the WMA possesses
+ profiles.
+ When the driver detects a cloaked AP, the SME will explicitly scan for it
+ using the list of cloaked SSIDs provided it, and, if the scan succeeds,
+ it will report the AP to the WMA either via CSR_WIFI_SME_SCAN_RESULT_IND
+ (if registered) or via CSR_WIFI_SCAN_RESULT_GET_CFM.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ cloakedSsids - Sets the list of cloaked SSIDs
+
+*******************************************************************************/
+#define CsrWifiSmeCloakedSsidsSetReqCreate(msg__, dst__, src__, cloakedSsids__) \
+ msg__ = (CsrWifiSmeCloakedSsidsSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_SET_REQ, dst__, src__); \
+ msg__->cloakedSsids = (cloakedSsids__);
+
+#define CsrWifiSmeCloakedSsidsSetReqSendTo(dst__, src__, cloakedSsids__) \
+ { \
+ CsrWifiSmeCloakedSsidsSetReq *msg__; \
+ CsrWifiSmeCloakedSsidsSetReqCreate(msg__, dst__, src__, cloakedSsids__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCloakedSsidsSetReqSend(src__, cloakedSsids__) \
+ CsrWifiSmeCloakedSsidsSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, cloakedSsids__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCloakedSsidsSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeCloakedSsidsSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeCloakedSsidsSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CLOAKED_SSIDS_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeCloakedSsidsSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeCloakedSsidsSetCfm *msg__; \
+ CsrWifiSmeCloakedSsidsSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCloakedSsidsSetCfmSend(dst__, status__) \
+ CsrWifiSmeCloakedSsidsSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the CoexConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeCoexConfigGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeCoexConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeCoexConfigGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeCoexConfigGetReq *msg__; \
+ CsrWifiSmeCoexConfigGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCoexConfigGetReqSend(src__) \
+ CsrWifiSmeCoexConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ coexConfig - Reports the parameters used to configure the coexistence
+ behaviour
+
+*******************************************************************************/
+#define CsrWifiSmeCoexConfigGetCfmCreate(msg__, dst__, src__, status__, coexConfig__) \
+ msg__ = (CsrWifiSmeCoexConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->coexConfig = (coexConfig__);
+
+#define CsrWifiSmeCoexConfigGetCfmSendTo(dst__, src__, status__, coexConfig__) \
+ { \
+ CsrWifiSmeCoexConfigGetCfm *msg__; \
+ CsrWifiSmeCoexConfigGetCfmCreate(msg__, dst__, src__, status__, coexConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCoexConfigGetCfmSend(dst__, status__, coexConfig__) \
+ CsrWifiSmeCoexConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, coexConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexConfigSetReqSend
+
+ DESCRIPTION
+ This primitive sets the value of the CoexConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ coexConfig - Configures the coexistence behaviour
+
+*******************************************************************************/
+#define CsrWifiSmeCoexConfigSetReqCreate(msg__, dst__, src__, coexConfig__) \
+ msg__ = (CsrWifiSmeCoexConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_SET_REQ, dst__, src__); \
+ msg__->coexConfig = (coexConfig__);
+
+#define CsrWifiSmeCoexConfigSetReqSendTo(dst__, src__, coexConfig__) \
+ { \
+ CsrWifiSmeCoexConfigSetReq *msg__; \
+ CsrWifiSmeCoexConfigSetReqCreate(msg__, dst__, src__, coexConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCoexConfigSetReqSend(src__, coexConfig__) \
+ CsrWifiSmeCoexConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, coexConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexConfigSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeCoexConfigSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeCoexConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_CONFIG_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeCoexConfigSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeCoexConfigSetCfm *msg__; \
+ CsrWifiSmeCoexConfigSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCoexConfigSetCfmSend(dst__, status__) \
+ CsrWifiSmeCoexConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexInfoGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the CoexInfo parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeCoexInfoGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeCoexInfoGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexInfoGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_INFO_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeCoexInfoGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeCoexInfoGetReq *msg__; \
+ CsrWifiSmeCoexInfoGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCoexInfoGetReqSend(src__) \
+ CsrWifiSmeCoexInfoGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexInfoGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ coexInfo - Reports information and state related to coexistence.
+
+*******************************************************************************/
+#define CsrWifiSmeCoexInfoGetCfmCreate(msg__, dst__, src__, status__, coexInfo__) \
+ msg__ = (CsrWifiSmeCoexInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexInfoGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_COEX_INFO_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->coexInfo = (coexInfo__);
+
+#define CsrWifiSmeCoexInfoGetCfmSendTo(dst__, src__, status__, coexInfo__) \
+ { \
+ CsrWifiSmeCoexInfoGetCfm *msg__; \
+ CsrWifiSmeCoexInfoGetCfmCreate(msg__, dst__, src__, status__, coexInfo__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCoexInfoGetCfmSend(dst__, status__, coexInfo__) \
+ CsrWifiSmeCoexInfoGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, coexInfo__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectReqSend
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to start the
+ process of joining an 802.11 wireless network or to start an ad hoc
+ network.
+ The structure pointed by connectionConfig contains parameters describing
+ the network to join or, in case of an ad hoc network, to host or join.
+ The SME will select a network, perform the IEEE 802.11 Join, Authenticate
+ and Associate exchanges.
+ The SME selects the networks from the current scan list that match both
+ the SSID and BSSID, however either or both of these may be the wildcard
+ value. Using this rule, the following operations are possible:
+ * To connect to a network by name, specify the SSID and set the BSSID to
+ 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF. If there are two or more networks visible,
+ the SME will select the one with the strongest signal.
+ * To connect to a specific network, specify the BSSID. The SSID is
+ optional, but if given it must match the SSID of the network. An empty
+ SSID may be specified by setting the SSID length to zero. Please note
+ that if the BSSID is specified (i.e. not equal to 0xFF 0xFF 0xFF 0xFF
+ 0xFF 0xFF), the SME will not attempt to roam if signal conditions become
+ poor, even if there is an alternative AP with an SSID that matches the
+ current network SSID.
+ * To connect to any network matching the other parameters (i.e. security,
+ etc), set the SSID length to zero and set the BSSID to 0xFF 0xFF 0xFF
+ 0xFF 0xFF 0xFF. In this case, the SME will order all available networks
+ by their signal strengths and will iterate through this list until it
+ successfully connects.
+ NOTE: Specifying the BSSID will restrict the selection to one specific
+ network. If SSID and BSSID are given, they must both match the network
+ for it to be selected. To select a network based on the SSID only, the
+ wireless manager application must set the BSSID to 0xFF 0xFF 0xFF 0xFF
+ 0xFF 0xFF.
+ The SME will try to connect to each network that matches the provided
+ parameters, one by one, until it succeeds or has tried unsuccessfully
+ with all the matching networks.
+ If there is no network that matches the parameters and the request allows
+ to host an ad hoc network, the SME will advertise a new ad hoc network
+ instead.
+ If the SME cannot connect, it will notify the failure in the confirm.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ connectionConfig - Describes the candidate network to join or to host.
+
+*******************************************************************************/
+#define CsrWifiSmeConnectReqCreate(msg__, dst__, src__, interfaceTag__, connectionConfig__) \
+ msg__ = (CsrWifiSmeConnectReq *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECT_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->connectionConfig = (connectionConfig__);
+
+#define CsrWifiSmeConnectReqSendTo(dst__, src__, interfaceTag__, connectionConfig__) \
+ { \
+ CsrWifiSmeConnectReq *msg__; \
+ CsrWifiSmeConnectReqCreate(msg__, dst__, src__, interfaceTag__, connectionConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeConnectReqSend(src__, interfaceTag__, connectionConfig__) \
+ CsrWifiSmeConnectReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, connectionConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectCfmSend
+
+ DESCRIPTION
+ The SME calls this primitive when the connection exchange is complete or
+ all connection attempts fail.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request.
+ CSR_WIFI_SME_STATUS_NOT_FOUND: all attempts by the SME to
+ locate the requested AP failed
+
+*******************************************************************************/
+#define CsrWifiSmeConnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeConnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECT_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeConnectCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeConnectCfm *msg__; \
+ CsrWifiSmeConnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeConnectCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeConnectCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the ConnectionConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiSmeConnectionConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeConnectionConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_CONFIG_GET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeConnectionConfigGetReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeConnectionConfigGetReq *msg__; \
+ CsrWifiSmeConnectionConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeConnectionConfigGetReqSend(src__, interfaceTag__) \
+ CsrWifiSmeConnectionConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ connectionConfig - Parameters used by the SME for selecting a network
+
+*******************************************************************************/
+#define CsrWifiSmeConnectionConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionConfig__) \
+ msg__ = (CsrWifiSmeConnectionConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_CONFIG_GET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->connectionConfig = (connectionConfig__);
+
+#define CsrWifiSmeConnectionConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, connectionConfig__) \
+ { \
+ CsrWifiSmeConnectionConfigGetCfm *msg__; \
+ CsrWifiSmeConnectionConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeConnectionConfigGetCfmSend(dst__, interfaceTag__, status__, connectionConfig__) \
+ CsrWifiSmeConnectionConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionInfoGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the ConnectionInfo parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiSmeConnectionInfoGetReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeConnectionInfoGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionInfoGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_INFO_GET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeConnectionInfoGetReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeConnectionInfoGetReq *msg__; \
+ CsrWifiSmeConnectionInfoGetReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeConnectionInfoGetReqSend(src__, interfaceTag__) \
+ CsrWifiSmeConnectionInfoGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionInfoGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ connectionInfo - Information about the current connection
+
+*******************************************************************************/
+#define CsrWifiSmeConnectionInfoGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__) \
+ msg__ = (CsrWifiSmeConnectionInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionInfoGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_INFO_GET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->connectionInfo = (connectionInfo__);
+
+#define CsrWifiSmeConnectionInfoGetCfmSendTo(dst__, src__, interfaceTag__, status__, connectionInfo__) \
+ { \
+ CsrWifiSmeConnectionInfoGetCfm *msg__; \
+ CsrWifiSmeConnectionInfoGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionInfo__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeConnectionInfoGetCfmSend(dst__, interfaceTag__, status__, connectionInfo__) \
+ CsrWifiSmeConnectionInfoGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionInfo__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionQualityIndSend
+
+ DESCRIPTION
+ The SME sends this primitive to all the tasks that have registered to
+ receive it whenever the value of the current connection quality
+ parameters change by more than a certain configurable amount.
+ The wireless manager application may configure the trigger thresholds for
+ this indication using the field in smeConfig parameter of
+ CSR_WIFI_SME_SME_CONFIG_SET_REQ.
+ Connection quality messages can be suppressed by setting both thresholds
+ to zero.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ linkQuality - Indicates the quality of the link
+
+*******************************************************************************/
+#define CsrWifiSmeConnectionQualityIndCreate(msg__, dst__, src__, interfaceTag__, linkQuality__) \
+ msg__ = (CsrWifiSmeConnectionQualityInd *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionQualityInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_QUALITY_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->linkQuality = (linkQuality__);
+
+#define CsrWifiSmeConnectionQualityIndSendTo(dst__, src__, interfaceTag__, linkQuality__) \
+ { \
+ CsrWifiSmeConnectionQualityInd *msg__; \
+ CsrWifiSmeConnectionQualityIndCreate(msg__, dst__, src__, interfaceTag__, linkQuality__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeConnectionQualityIndSend(dst__, interfaceTag__, linkQuality__) \
+ CsrWifiSmeConnectionQualityIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, linkQuality__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionStatsGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the ConnectionStats parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiSmeConnectionStatsGetReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeConnectionStatsGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionStatsGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_STATS_GET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeConnectionStatsGetReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeConnectionStatsGetReq *msg__; \
+ CsrWifiSmeConnectionStatsGetReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeConnectionStatsGetReqSend(src__, interfaceTag__) \
+ CsrWifiSmeConnectionStatsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionStatsGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ connectionStats - Statistics for current connection.
+
+*******************************************************************************/
+#define CsrWifiSmeConnectionStatsGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionStats__) \
+ msg__ = (CsrWifiSmeConnectionStatsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionStatsGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CONNECTION_STATS_GET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->connectionStats = (connectionStats__);
+
+#define CsrWifiSmeConnectionStatsGetCfmSendTo(dst__, src__, interfaceTag__, status__, connectionStats__) \
+ { \
+ CsrWifiSmeConnectionStatsGetCfm *msg__; \
+ CsrWifiSmeConnectionStatsGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, connectionStats__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeConnectionStatsGetCfmSend(dst__, interfaceTag__, status__, connectionStats__) \
+ CsrWifiSmeConnectionStatsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, connectionStats__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoreDumpIndSend
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive Wi-Fi Chip core dump data.
+ The core dump data may be fragmented and sent using more than one
+ indication.
+ To indicate that all the data has been sent, the last indication contains
+ a 'length' of 0 and 'data' of NULL.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ dataLength - Number of bytes in the buffer pointed to by 'data'
+ data - Pointer to the buffer containing 'dataLength' bytes of core
+ dump data
+
+*******************************************************************************/
+#define CsrWifiSmeCoreDumpIndCreate(msg__, dst__, src__, dataLength__, data__) \
+ msg__ = (CsrWifiSmeCoreDumpInd *) CsrPmemAlloc(sizeof(CsrWifiSmeCoreDumpInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_CORE_DUMP_IND, dst__, src__); \
+ msg__->dataLength = (dataLength__); \
+ msg__->data = (data__);
+
+#define CsrWifiSmeCoreDumpIndSendTo(dst__, src__, dataLength__, data__) \
+ { \
+ CsrWifiSmeCoreDumpInd *msg__; \
+ CsrWifiSmeCoreDumpIndCreate(msg__, dst__, src__, dataLength__, data__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeCoreDumpIndSend(dst__, dataLength__, data__) \
+ CsrWifiSmeCoreDumpIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, dataLength__, data__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDeactivateReqSend
+
+ DESCRIPTION
+ The WMA sends this primitive to deactivate the SME.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeDeactivateReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeDeactivateReq *) CsrPmemAlloc(sizeof(CsrWifiSmeDeactivateReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DEACTIVATE_REQ, dst__, src__);
+
+#define CsrWifiSmeDeactivateReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeDeactivateReq *msg__; \
+ CsrWifiSmeDeactivateReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeDeactivateReqSend(src__) \
+ CsrWifiSmeDeactivateReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDeactivateCfmSend
+
+ DESCRIPTION
+ The SME sends this primitive when the deactivation is complete.
+ The WMA cannot send any more primitives until it actives the SME again
+ sending another CSR_WIFI_SME_ACTIVATE_REQ.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeDeactivateCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeDeactivateCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeDeactivateCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DEACTIVATE_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeDeactivateCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeDeactivateCfm *msg__; \
+ CsrWifiSmeDeactivateCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeDeactivateCfmSend(dst__, status__) \
+ CsrWifiSmeDeactivateCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDisconnectReqSend
+
+ DESCRIPTION
+ The wireless manager application may disconnect from the current network
+ by calling this primitive
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiSmeDisconnectReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeDisconnectReq *) CsrPmemAlloc(sizeof(CsrWifiSmeDisconnectReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DISCONNECT_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeDisconnectReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeDisconnectReq *msg__; \
+ CsrWifiSmeDisconnectReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeDisconnectReqSend(src__, interfaceTag__) \
+ CsrWifiSmeDisconnectReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDisconnectCfmSend
+
+ DESCRIPTION
+ On reception of CSR_WIFI_SME_DISCONNECT_REQ the SME will perform a
+ disconnect operation, sending a CsrWifiSmeMediaStatusInd with
+ CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED and then call this primitive when
+ disconnection is complete.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeDisconnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeDisconnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeDisconnectCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_DISCONNECT_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeDisconnectCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeDisconnectCfm *msg__; \
+ CsrWifiSmeDisconnectCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeDisconnectCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeDisconnectCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeErrorIndSend
+
+ DESCRIPTION
+ Important error message indicating a error of some importance
+
+ PARAMETERS
+ queue - Destination Task Queue
+ errorMessage - Contains the error message.
+
+*******************************************************************************/
+#define CsrWifiSmeErrorIndCreate(msg__, dst__, src__, errorMessage__) \
+ msg__ = (CsrWifiSmeErrorInd *) CsrPmemAlloc(sizeof(CsrWifiSmeErrorInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ERROR_IND, dst__, src__); \
+ msg__->errorMessage = (errorMessage__);
+
+#define CsrWifiSmeErrorIndSendTo(dst__, src__, errorMessage__) \
+ { \
+ CsrWifiSmeErrorInd *msg__; \
+ CsrWifiSmeErrorIndCreate(msg__, dst__, src__, errorMessage__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeErrorIndSend(dst__, errorMessage__) \
+ CsrWifiSmeErrorIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, errorMessage__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeEventMaskSetReqSend
+
+ DESCRIPTION
+ The wireless manager application may register with the SME to receive
+ notification of interesting events. Indications will be sent only if the
+ wireless manager explicitly registers to be notified of that event.
+ indMask is a bit mask of values defined in CsrWifiSmeIndicationsMask.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ indMask - Set mask with values from CsrWifiSmeIndications
+
+*******************************************************************************/
+#define CsrWifiSmeEventMaskSetReqCreate(msg__, dst__, src__, indMask__) \
+ msg__ = (CsrWifiSmeEventMaskSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeEventMaskSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_EVENT_MASK_SET_REQ, dst__, src__); \
+ msg__->indMask = (indMask__);
+
+#define CsrWifiSmeEventMaskSetReqSendTo(dst__, src__, indMask__) \
+ { \
+ CsrWifiSmeEventMaskSetReq *msg__; \
+ CsrWifiSmeEventMaskSetReqCreate(msg__, dst__, src__, indMask__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeEventMaskSetReqSend(src__, indMask__) \
+ CsrWifiSmeEventMaskSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, indMask__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeEventMaskSetCfmSend
+
+ DESCRIPTION
+ The SME calls the primitive to report the result of the request
+ primitive.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeEventMaskSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeEventMaskSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeEventMaskSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_EVENT_MASK_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeEventMaskSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeEventMaskSetCfm *msg__; \
+ CsrWifiSmeEventMaskSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeEventMaskSetCfmSend(dst__, status__) \
+ CsrWifiSmeEventMaskSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeHostConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the hostConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiSmeHostConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeHostConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_GET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeHostConfigGetReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeHostConfigGetReq *msg__; \
+ CsrWifiSmeHostConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeHostConfigGetReqSend(src__, interfaceTag__) \
+ CsrWifiSmeHostConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeHostConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ hostConfig - Current host power state.
+
+*******************************************************************************/
+#define CsrWifiSmeHostConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, hostConfig__) \
+ msg__ = (CsrWifiSmeHostConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_GET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->hostConfig = (hostConfig__);
+
+#define CsrWifiSmeHostConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, hostConfig__) \
+ { \
+ CsrWifiSmeHostConfigGetCfm *msg__; \
+ CsrWifiSmeHostConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, hostConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeHostConfigGetCfmSend(dst__, interfaceTag__, status__, hostConfig__) \
+ CsrWifiSmeHostConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, hostConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeHostConfigSetReqSend
+
+ DESCRIPTION
+ This primitive sets the value of the hostConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ hostConfig - Communicates a change of host power state (for example, on
+ mains power, on battery power etc) and of the periodicity of
+ traffic data
+
+*******************************************************************************/
+#define CsrWifiSmeHostConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, hostConfig__) \
+ msg__ = (CsrWifiSmeHostConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_SET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->hostConfig = (hostConfig__);
+
+#define CsrWifiSmeHostConfigSetReqSendTo(dst__, src__, interfaceTag__, hostConfig__) \
+ { \
+ CsrWifiSmeHostConfigSetReq *msg__; \
+ CsrWifiSmeHostConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, hostConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeHostConfigSetReqSend(src__, interfaceTag__, hostConfig__) \
+ CsrWifiSmeHostConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, hostConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeHostConfigSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeHostConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeHostConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_HOST_CONFIG_SET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeHostConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeHostConfigSetCfm *msg__; \
+ CsrWifiSmeHostConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeHostConfigSetCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeHostConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeIbssStationIndSend
+
+ DESCRIPTION
+ The SME will send this primitive to indicate that a station has joined or
+ left the ad-hoc network.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ address - MAC address of the station that has joined or left
+ isconnected - TRUE if the station joined, FALSE if the station left
+
+*******************************************************************************/
+#define CsrWifiSmeIbssStationIndCreate(msg__, dst__, src__, address__, isconnected__) \
+ msg__ = (CsrWifiSmeIbssStationInd *) CsrPmemAlloc(sizeof(CsrWifiSmeIbssStationInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_IBSS_STATION_IND, dst__, src__); \
+ msg__->address = (address__); \
+ msg__->isconnected = (isconnected__);
+
+#define CsrWifiSmeIbssStationIndSendTo(dst__, src__, address__, isconnected__) \
+ { \
+ CsrWifiSmeIbssStationInd *msg__; \
+ CsrWifiSmeIbssStationIndCreate(msg__, dst__, src__, address__, isconnected__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeIbssStationIndSend(dst__, address__, isconnected__) \
+ CsrWifiSmeIbssStationIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, address__, isconnected__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeInfoIndSend
+
+ DESCRIPTION
+ Message indicating a some info about current activity. Mostly of interest
+ in testing but may be useful in the field.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ infoMessage - Contains the message.
+
+*******************************************************************************/
+#define CsrWifiSmeInfoIndCreate(msg__, dst__, src__, infoMessage__) \
+ msg__ = (CsrWifiSmeInfoInd *) CsrPmemAlloc(sizeof(CsrWifiSmeInfoInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INFO_IND, dst__, src__); \
+ msg__->infoMessage = (infoMessage__);
+
+#define CsrWifiSmeInfoIndSendTo(dst__, src__, infoMessage__) \
+ { \
+ CsrWifiSmeInfoInd *msg__; \
+ CsrWifiSmeInfoIndCreate(msg__, dst__, src__, infoMessage__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeInfoIndSend(dst__, infoMessage__) \
+ CsrWifiSmeInfoIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, infoMessage__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeInterfaceCapabilityGetReqSend
+
+ DESCRIPTION
+ The Wireless Manager calls this primitive to ask the SME for the
+ capabilities of the supported interfaces
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeInterfaceCapabilityGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeInterfaceCapabilityGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeInterfaceCapabilityGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeInterfaceCapabilityGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeInterfaceCapabilityGetReq *msg__; \
+ CsrWifiSmeInterfaceCapabilityGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeInterfaceCapabilityGetReqSend(src__) \
+ CsrWifiSmeInterfaceCapabilityGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeInterfaceCapabilityGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Result of the request
+ numInterfaces - Number of the interfaces supported
+ capBitmap - Points to the list of capabilities bitmaps provided for each
+ interface.
+ The bits represent the following capabilities:
+ -bits 7 to 4-Reserved
+ -bit 3-AMP
+ -bit 2-P2P
+ -bit 1-AP
+ -bit 0-STA
+
+*******************************************************************************/
+#define CsrWifiSmeInterfaceCapabilityGetCfmCreate(msg__, dst__, src__, status__, numInterfaces__, capBitmap__) \
+ msg__ = (CsrWifiSmeInterfaceCapabilityGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeInterfaceCapabilityGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->numInterfaces = (numInterfaces__); \
+ CsrMemCpy(msg__->capBitmap, (capBitmap__), sizeof(CsrUint8) * 2);
+
+#define CsrWifiSmeInterfaceCapabilityGetCfmSendTo(dst__, src__, status__, numInterfaces__, capBitmap__) \
+ { \
+ CsrWifiSmeInterfaceCapabilityGetCfm *msg__; \
+ CsrWifiSmeInterfaceCapabilityGetCfmCreate(msg__, dst__, src__, status__, numInterfaces__, capBitmap__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeInterfaceCapabilityGetCfmSend(dst__, status__, numInterfaces__, capBitmap__) \
+ CsrWifiSmeInterfaceCapabilityGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, numInterfaces__, capBitmap__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeKeyReqSend
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to add or remove
+ keys that the chip should use for encryption of data.
+ The interface allows the wireless manager application to add and remove
+ keys according to the specified action.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ action - The value of the CsrWifiSmeListAction parameter instructs the
+ driver to modify or provide the list of keys.
+ CSR_WIFI_SME_LIST_ACTION_GET is not supported here.
+ key - Key to be added or removed
+
+*******************************************************************************/
+#define CsrWifiSmeKeyReqCreate(msg__, dst__, src__, interfaceTag__, action__, key__) \
+ msg__ = (CsrWifiSmeKeyReq *) CsrPmemAlloc(sizeof(CsrWifiSmeKeyReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_KEY_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->action = (action__); \
+ msg__->key = (key__);
+
+#define CsrWifiSmeKeyReqSendTo(dst__, src__, interfaceTag__, action__, key__) \
+ { \
+ CsrWifiSmeKeyReq *msg__; \
+ CsrWifiSmeKeyReqCreate(msg__, dst__, src__, interfaceTag__, action__, key__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeKeyReqSend(src__, interfaceTag__, action__, key__) \
+ CsrWifiSmeKeyReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, key__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeKeyCfmSend
+
+ DESCRIPTION
+ The SME calls the primitive to report the result of the request
+ primitive.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ action - Action in the request
+ keyType - Type of the key added/deleted
+ peerMacAddress - Peer MAC Address of the key added/deleted
+
+*******************************************************************************/
+#define CsrWifiSmeKeyCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, keyType__, peerMacAddress__) \
+ msg__ = (CsrWifiSmeKeyCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeKeyCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_KEY_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->action = (action__); \
+ msg__->keyType = (keyType__); \
+ msg__->peerMacAddress = (peerMacAddress__);
+
+#define CsrWifiSmeKeyCfmSendTo(dst__, src__, interfaceTag__, status__, action__, keyType__, peerMacAddress__) \
+ { \
+ CsrWifiSmeKeyCfm *msg__; \
+ CsrWifiSmeKeyCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, keyType__, peerMacAddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeKeyCfmSend(dst__, interfaceTag__, status__, action__, keyType__, peerMacAddress__) \
+ CsrWifiSmeKeyCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, keyType__, peerMacAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeLinkQualityGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the LinkQuality parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiSmeLinkQualityGetReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeLinkQualityGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeLinkQualityGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_LINK_QUALITY_GET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeLinkQualityGetReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeLinkQualityGetReq *msg__; \
+ CsrWifiSmeLinkQualityGetReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeLinkQualityGetReqSend(src__, interfaceTag__) \
+ CsrWifiSmeLinkQualityGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeLinkQualityGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ linkQuality - Indicates the quality of the link
+
+*******************************************************************************/
+#define CsrWifiSmeLinkQualityGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, linkQuality__) \
+ msg__ = (CsrWifiSmeLinkQualityGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeLinkQualityGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_LINK_QUALITY_GET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->linkQuality = (linkQuality__);
+
+#define CsrWifiSmeLinkQualityGetCfmSendTo(dst__, src__, interfaceTag__, status__, linkQuality__) \
+ { \
+ CsrWifiSmeLinkQualityGetCfm *msg__; \
+ CsrWifiSmeLinkQualityGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, linkQuality__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeLinkQualityGetCfmSend(dst__, interfaceTag__, status__, linkQuality__) \
+ CsrWifiSmeLinkQualityGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, linkQuality__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMediaStatusIndSend
+
+ DESCRIPTION
+ The SME sends this primitive to all the tasks that have registered to
+ receive it when a network connection is established, lost or has moved to
+ another AP.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ mediaStatus - Indicates the media status
+ connectionInfo - This parameter is relevant only if the mediaStatus is
+ CSR_WIFI_SME_MEDIA_STATUS_CONNECTED:
+ it points to the connection information for the new network
+ disassocReason - This parameter is relevant only if the mediaStatus is
+ CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED:
+ if a disassociation has occurred it gives the reason of the
+ disassociation
+ deauthReason - This parameter is relevant only if the mediaStatus is
+ CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED:
+ if a deauthentication has occurred it gives the reason of
+ the deauthentication
+
+*******************************************************************************/
+#define CsrWifiSmeMediaStatusIndCreate(msg__, dst__, src__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__) \
+ msg__ = (CsrWifiSmeMediaStatusInd *) CsrPmemAlloc(sizeof(CsrWifiSmeMediaStatusInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MEDIA_STATUS_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->mediaStatus = (mediaStatus__); \
+ msg__->connectionInfo = (connectionInfo__); \
+ msg__->disassocReason = (disassocReason__); \
+ msg__->deauthReason = (deauthReason__);
+
+#define CsrWifiSmeMediaStatusIndSendTo(dst__, src__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__) \
+ { \
+ CsrWifiSmeMediaStatusInd *msg__; \
+ CsrWifiSmeMediaStatusIndCreate(msg__, dst__, src__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMediaStatusIndSend(dst__, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__) \
+ CsrWifiSmeMediaStatusIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, mediaStatus__, connectionInfo__, disassocReason__, deauthReason__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the MibConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeMibConfigGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeMibConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeMibConfigGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeMibConfigGetReq *msg__; \
+ CsrWifiSmeMibConfigGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMibConfigGetReqSend(src__) \
+ CsrWifiSmeMibConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ mibConfig - Reports various IEEE 802.11 attributes as currently configured
+
+*******************************************************************************/
+#define CsrWifiSmeMibConfigGetCfmCreate(msg__, dst__, src__, status__, mibConfig__) \
+ msg__ = (CsrWifiSmeMibConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->mibConfig = (mibConfig__);
+
+#define CsrWifiSmeMibConfigGetCfmSendTo(dst__, src__, status__, mibConfig__) \
+ { \
+ CsrWifiSmeMibConfigGetCfm *msg__; \
+ CsrWifiSmeMibConfigGetCfmCreate(msg__, dst__, src__, status__, mibConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMibConfigGetCfmSend(dst__, status__, mibConfig__) \
+ CsrWifiSmeMibConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, mibConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibConfigSetReqSend
+
+ DESCRIPTION
+ This primitive sets the value of the MibConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ mibConfig - Conveys the desired value of various IEEE 802.11 attributes as
+ currently configured
+
+*******************************************************************************/
+#define CsrWifiSmeMibConfigSetReqCreate(msg__, dst__, src__, mibConfig__) \
+ msg__ = (CsrWifiSmeMibConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_SET_REQ, dst__, src__); \
+ msg__->mibConfig = (mibConfig__);
+
+#define CsrWifiSmeMibConfigSetReqSendTo(dst__, src__, mibConfig__) \
+ { \
+ CsrWifiSmeMibConfigSetReq *msg__; \
+ CsrWifiSmeMibConfigSetReqCreate(msg__, dst__, src__, mibConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMibConfigSetReqSend(src__, mibConfig__) \
+ CsrWifiSmeMibConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibConfigSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeMibConfigSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeMibConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_CONFIG_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeMibConfigSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeMibConfigSetCfm *msg__; \
+ CsrWifiSmeMibConfigSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMibConfigSetCfmSend(dst__, status__) \
+ CsrWifiSmeMibConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibGetCfmSend
+
+ DESCRIPTION
+ The SME calls this primitive to return the requested MIB variable values.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ mibAttributeLength - Length of mibAttribute
+ mibAttribute - Points to the VarBind or VarBindList containing the
+ names and values of the MIB variables requested
+
+*******************************************************************************/
+#define CsrWifiSmeMibGetCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__) \
+ msg__ = (CsrWifiSmeMibGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->mibAttributeLength = (mibAttributeLength__); \
+ msg__->mibAttribute = (mibAttribute__);
+
+#define CsrWifiSmeMibGetCfmSendTo(dst__, src__, status__, mibAttributeLength__, mibAttribute__) \
+ { \
+ CsrWifiSmeMibGetCfm *msg__; \
+ CsrWifiSmeMibGetCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMibGetCfmSend(dst__, status__, mibAttributeLength__, mibAttribute__) \
+ CsrWifiSmeMibGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, mibAttributeLength__, mibAttribute__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibGetNextReqSend
+
+ DESCRIPTION
+ To read a sequence of MIB parameters, for example a table, call this
+ primitive to find the name of the next MIB variable
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ mibAttributeLength - Length of mibAttribute
+ mibAttribute - Points to a VarBind or VarBindList containing the
+ name(s) of the MIB variable(s) to search from.
+
+*******************************************************************************/
+#define CsrWifiSmeMibGetNextReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__) \
+ msg__ = (CsrWifiSmeMibGetNextReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetNextReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_NEXT_REQ, dst__, src__); \
+ msg__->mibAttributeLength = (mibAttributeLength__); \
+ msg__->mibAttribute = (mibAttribute__);
+
+#define CsrWifiSmeMibGetNextReqSendTo(dst__, src__, mibAttributeLength__, mibAttribute__) \
+ { \
+ CsrWifiSmeMibGetNextReq *msg__; \
+ CsrWifiSmeMibGetNextReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMibGetNextReqSend(src__, mibAttributeLength__, mibAttribute__) \
+ CsrWifiSmeMibGetNextReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibAttributeLength__, mibAttribute__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibGetNextCfmSend
+
+ DESCRIPTION
+ The SME calls this primitive to return the requested MIB name(s).
+ The wireless manager application can then read the value of the MIB
+ variable using CSR_WIFI_SME_MIB_GET_REQ, using the names provided.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ mibAttributeLength - Length of mibAttribute
+ mibAttribute - Points to a VarBind or VarBindList containing the
+ name(s) of the MIB variable(s) lexicographically
+ following the name(s) given in the request
+
+*******************************************************************************/
+#define CsrWifiSmeMibGetNextCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__) \
+ msg__ = (CsrWifiSmeMibGetNextCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetNextCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_NEXT_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->mibAttributeLength = (mibAttributeLength__); \
+ msg__->mibAttribute = (mibAttribute__);
+
+#define CsrWifiSmeMibGetNextCfmSendTo(dst__, src__, status__, mibAttributeLength__, mibAttribute__) \
+ { \
+ CsrWifiSmeMibGetNextCfm *msg__; \
+ CsrWifiSmeMibGetNextCfmCreate(msg__, dst__, src__, status__, mibAttributeLength__, mibAttribute__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMibGetNextCfmSend(dst__, status__, mibAttributeLength__, mibAttribute__) \
+ CsrWifiSmeMibGetNextCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, mibAttributeLength__, mibAttribute__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibGetReqSend
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to retrieve one or
+ more MIB variables.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ mibAttributeLength - Length of mibAttribute
+ mibAttribute - Points to the VarBind or VarBindList containing the
+ names of the MIB variables to be retrieved
+
+*******************************************************************************/
+#define CsrWifiSmeMibGetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__) \
+ msg__ = (CsrWifiSmeMibGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_GET_REQ, dst__, src__); \
+ msg__->mibAttributeLength = (mibAttributeLength__); \
+ msg__->mibAttribute = (mibAttribute__);
+
+#define CsrWifiSmeMibGetReqSendTo(dst__, src__, mibAttributeLength__, mibAttribute__) \
+ { \
+ CsrWifiSmeMibGetReq *msg__; \
+ CsrWifiSmeMibGetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMibGetReqSend(src__, mibAttributeLength__, mibAttribute__) \
+ CsrWifiSmeMibGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibAttributeLength__, mibAttribute__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibSetReqSend
+
+ DESCRIPTION
+ The SME provides raw access to the MIB on the chip, which may be used by
+ some configuration or diagnostic utilities, but is not normally needed by
+ the wireless manager application.
+ The MIB access functions use BER encoded names (OID) of the MIB
+ parameters and BER encoded values, as described in the chip Host
+ Interface Protocol Specification.
+ The MIB parameters are described in 'Wi-Fi 5.0.0 Management Information
+ Base Reference Guide'.
+ The wireless manager application calls this primitive to set one or more
+ MIB variables
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ mibAttributeLength - Length of mibAttribute
+ mibAttribute - Points to the VarBind or VarBindList containing the
+ names and values of the MIB variables to set
+
+*******************************************************************************/
+#define CsrWifiSmeMibSetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__) \
+ msg__ = (CsrWifiSmeMibSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_SET_REQ, dst__, src__); \
+ msg__->mibAttributeLength = (mibAttributeLength__); \
+ msg__->mibAttribute = (mibAttribute__);
+
+#define CsrWifiSmeMibSetReqSendTo(dst__, src__, mibAttributeLength__, mibAttribute__) \
+ { \
+ CsrWifiSmeMibSetReq *msg__; \
+ CsrWifiSmeMibSetReqCreate(msg__, dst__, src__, mibAttributeLength__, mibAttribute__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMibSetReqSend(src__, mibAttributeLength__, mibAttribute__) \
+ CsrWifiSmeMibSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, mibAttributeLength__, mibAttribute__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibSetCfmSend
+
+ DESCRIPTION
+ The SME calls the primitive to report the result of the set primitive.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeMibSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeMibSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIB_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeMibSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeMibSetCfm *msg__; \
+ CsrWifiSmeMibSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMibSetCfmSend(dst__, status__) \
+ CsrWifiSmeMibSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMicFailureIndSend
+
+ DESCRIPTION
+ The SME sends this primitive to all the tasks that have registered to
+ receive it whenever the chip firmware reports a MIC failure.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ secondFailure - TRUE if this indication is for a second failure in 60
+ seconds
+ count - The number of MIC failure events since the connection was
+ established
+ address - MAC address of the transmitter that caused the MIC failure
+ keyType - Type of key for which the failure occurred
+
+*******************************************************************************/
+#define CsrWifiSmeMicFailureIndCreate(msg__, dst__, src__, interfaceTag__, secondFailure__, count__, address__, keyType__) \
+ msg__ = (CsrWifiSmeMicFailureInd *) CsrPmemAlloc(sizeof(CsrWifiSmeMicFailureInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MIC_FAILURE_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->secondFailure = (secondFailure__); \
+ msg__->count = (count__); \
+ msg__->address = (address__); \
+ msg__->keyType = (keyType__);
+
+#define CsrWifiSmeMicFailureIndSendTo(dst__, src__, interfaceTag__, secondFailure__, count__, address__, keyType__) \
+ { \
+ CsrWifiSmeMicFailureInd *msg__; \
+ CsrWifiSmeMicFailureIndCreate(msg__, dst__, src__, interfaceTag__, secondFailure__, count__, address__, keyType__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMicFailureIndSend(dst__, interfaceTag__, secondFailure__, count__, address__, keyType__) \
+ CsrWifiSmeMicFailureIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, secondFailure__, count__, address__, keyType__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMulticastAddressReqSend
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to specify the
+ multicast addresses which the chip should recognise. The interface allows
+ the wireless manager application to query, add, remove and flush the
+ multicast addresses for the network interface according to the specified
+ action.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ action - The value of the CsrWifiSmeListAction parameter
+ instructs the driver to modify or provide the list of
+ MAC addresses.
+ setAddressesCount - Number of MAC addresses sent with the primitive
+ setAddresses - Pointer to the list of MAC Addresses sent with the
+ primitive, set to NULL if none is sent.
+
+*******************************************************************************/
+#define CsrWifiSmeMulticastAddressReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \
+ msg__ = (CsrWifiSmeMulticastAddressReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMulticastAddressReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MULTICAST_ADDRESS_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->action = (action__); \
+ msg__->setAddressesCount = (setAddressesCount__); \
+ msg__->setAddresses = (setAddresses__);
+
+#define CsrWifiSmeMulticastAddressReqSendTo(dst__, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \
+ { \
+ CsrWifiSmeMulticastAddressReq *msg__; \
+ CsrWifiSmeMulticastAddressReqCreate(msg__, dst__, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMulticastAddressReqSend(src__, interfaceTag__, action__, setAddressesCount__, setAddresses__) \
+ CsrWifiSmeMulticastAddressReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, setAddressesCount__, setAddresses__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMulticastAddressCfmSend
+
+ DESCRIPTION
+ The SME will call this primitive when the operation is complete. For a
+ GET action, this primitive reports the current list of MAC addresses.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ action - Action in the request
+ getAddressesCount - This parameter is only relevant if action is
+ CSR_WIFI_SME_LIST_ACTION_GET:
+ number of MAC addresses sent with the primitive
+ getAddresses - Pointer to the list of MAC Addresses sent with the
+ primitive, set to NULL if none is sent.
+
+*******************************************************************************/
+#define CsrWifiSmeMulticastAddressCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__) \
+ msg__ = (CsrWifiSmeMulticastAddressCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMulticastAddressCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_MULTICAST_ADDRESS_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->action = (action__); \
+ msg__->getAddressesCount = (getAddressesCount__); \
+ msg__->getAddresses = (getAddresses__);
+
+#define CsrWifiSmeMulticastAddressCfmSendTo(dst__, src__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__) \
+ { \
+ CsrWifiSmeMulticastAddressCfm *msg__; \
+ CsrWifiSmeMulticastAddressCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeMulticastAddressCfmSend(dst__, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__) \
+ CsrWifiSmeMulticastAddressCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, getAddressesCount__, getAddresses__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePacketFilterSetReqSend
+
+ DESCRIPTION
+ The wireless manager application should call this primitive to enable or
+ disable filtering of broadcast packets: uninteresting broadcast packets
+ will be dropped by the Wi-Fi chip, instead of passing them up to the
+ host.
+ This has the advantage of saving power in the host application processor
+ as it removes the need to process unwanted packets.
+ All broadcast packets are filtered according to the filter and the filter
+ mode provided, except ARP packets, which are filtered using
+ arpFilterAddress.
+ Filters are not cumulative: only the parameters specified in the most
+ recent successful request are significant.
+ For more information, see 'UniFi Firmware API Specification'.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ filterLength - Length of the filter in bytes.
+ filterLength=0 disables the filter previously set
+ filter - Points to the first byte of the filter provided, if any.
+ This shall include zero or more instance of the
+ information elements of one of these types
+ * Traffic Classification (TCLAS) elements
+ * WMM-SA TCLAS elements
+ mode - Specifies whether the filter selects or excludes packets
+ matching the filter
+ arpFilterAddress - IPv4 address to be used for filtering the ARP packets.
+ * If the specified address is the IPv4 broadcast address
+ (255.255.255.255), all ARP packets are reported to the
+ host,
+ * If the specified address is NOT the IPv4 broadcast
+ address, only ARP packets with the specified address in
+ the Source or Target Protocol Address fields are reported
+ to the host
+
+*******************************************************************************/
+#define CsrWifiSmePacketFilterSetReqCreate(msg__, dst__, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__) \
+ msg__ = (CsrWifiSmePacketFilterSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePacketFilterSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PACKET_FILTER_SET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->filterLength = (filterLength__); \
+ msg__->filter = (filter__); \
+ msg__->mode = (mode__); \
+ msg__->arpFilterAddress = (arpFilterAddress__);
+
+#define CsrWifiSmePacketFilterSetReqSendTo(dst__, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__) \
+ { \
+ CsrWifiSmePacketFilterSetReq *msg__; \
+ CsrWifiSmePacketFilterSetReqCreate(msg__, dst__, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePacketFilterSetReqSend(src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__) \
+ CsrWifiSmePacketFilterSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, filterLength__, filter__, mode__, arpFilterAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePacketFilterSetCfmSend
+
+ DESCRIPTION
+ The SME calls the primitive to report the result of the set primitive.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmePacketFilterSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmePacketFilterSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePacketFilterSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PACKET_FILTER_SET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmePacketFilterSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmePacketFilterSetCfm *msg__; \
+ CsrWifiSmePacketFilterSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePacketFilterSetCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmePacketFilterSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePermanentMacAddressGetReqSend
+
+ DESCRIPTION
+ This primitive retrieves the MAC address stored in EEPROM
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmePermanentMacAddressGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmePermanentMacAddressGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePermanentMacAddressGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PERMANENT_MAC_ADDRESS_GET_REQ, dst__, src__);
+
+#define CsrWifiSmePermanentMacAddressGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmePermanentMacAddressGetReq *msg__; \
+ CsrWifiSmePermanentMacAddressGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePermanentMacAddressGetReqSend(src__) \
+ CsrWifiSmePermanentMacAddressGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePermanentMacAddressGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ permanentMacAddress - MAC address stored in the EEPROM
+
+*******************************************************************************/
+#define CsrWifiSmePermanentMacAddressGetCfmCreate(msg__, dst__, src__, status__, permanentMacAddress__) \
+ msg__ = (CsrWifiSmePermanentMacAddressGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePermanentMacAddressGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PERMANENT_MAC_ADDRESS_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->permanentMacAddress = (permanentMacAddress__);
+
+#define CsrWifiSmePermanentMacAddressGetCfmSendTo(dst__, src__, status__, permanentMacAddress__) \
+ { \
+ CsrWifiSmePermanentMacAddressGetCfm *msg__; \
+ CsrWifiSmePermanentMacAddressGetCfmCreate(msg__, dst__, src__, status__, permanentMacAddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePermanentMacAddressGetCfmSend(dst__, status__, permanentMacAddress__) \
+ CsrWifiSmePermanentMacAddressGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, permanentMacAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePmkidCandidateListIndSend
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive it when a new network supporting preauthentication and/or PMK
+ caching is seen.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an
+ interface
+ pmkidCandidatesCount - Number of PMKID candidates provided
+ pmkidCandidates - Points to the first PMKID candidate
+
+*******************************************************************************/
+#define CsrWifiSmePmkidCandidateListIndCreate(msg__, dst__, src__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__) \
+ msg__ = (CsrWifiSmePmkidCandidateListInd *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidCandidateListInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PMKID_CANDIDATE_LIST_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->pmkidCandidatesCount = (pmkidCandidatesCount__); \
+ msg__->pmkidCandidates = (pmkidCandidates__);
+
+#define CsrWifiSmePmkidCandidateListIndSendTo(dst__, src__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__) \
+ { \
+ CsrWifiSmePmkidCandidateListInd *msg__; \
+ CsrWifiSmePmkidCandidateListIndCreate(msg__, dst__, src__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePmkidCandidateListIndSend(dst__, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__) \
+ CsrWifiSmePmkidCandidateListIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, pmkidCandidatesCount__, pmkidCandidates__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePmkidReqSend
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to request an
+ operation on the SME PMKID list.
+ The action argument specifies the operation to perform.
+ When the connection is complete, the wireless manager application may
+ then send and receive EAPOL packets to complete WPA or WPA2
+ authentication if appropriate.
+ The wireless manager application can then pass the resulting encryption
+ keys using this primitive.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ action - The value of the CsrWifiSmeListAction parameter instructs
+ the driver to modify or provide the list of PMKIDs.
+ setPmkidsCount - Number of PMKIDs sent with the primitive
+ setPmkids - Pointer to the list of PMKIDs sent with the primitive, set
+ to NULL if none is sent.
+
+*******************************************************************************/
+#define CsrWifiSmePmkidReqCreate(msg__, dst__, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__) \
+ msg__ = (CsrWifiSmePmkidReq *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PMKID_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->action = (action__); \
+ msg__->setPmkidsCount = (setPmkidsCount__); \
+ msg__->setPmkids = (setPmkids__);
+
+#define CsrWifiSmePmkidReqSendTo(dst__, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__) \
+ { \
+ CsrWifiSmePmkidReq *msg__; \
+ CsrWifiSmePmkidReqCreate(msg__, dst__, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePmkidReqSend(src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__) \
+ CsrWifiSmePmkidReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, setPmkidsCount__, setPmkids__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePmkidCfmSend
+
+ DESCRIPTION
+ The SME will call this primitive when the operation is complete. For a
+ GET action, this primitive reports the current list of PMKIDs
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ action - Action in the request
+ getPmkidsCount - This parameter is only relevant if action is
+ CSR_WIFI_SME_LIST_ACTION_GET:
+ number of PMKIDs sent with the primitive
+ getPmkids - Pointer to the list of PMKIDs sent with the primitive, set
+ to NULL if none is sent.
+
+*******************************************************************************/
+#define CsrWifiSmePmkidCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__) \
+ msg__ = (CsrWifiSmePmkidCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_PMKID_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->action = (action__); \
+ msg__->getPmkidsCount = (getPmkidsCount__); \
+ msg__->getPmkids = (getPmkids__);
+
+#define CsrWifiSmePmkidCfmSendTo(dst__, src__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__) \
+ { \
+ CsrWifiSmePmkidCfm *msg__; \
+ CsrWifiSmePmkidCfmCreate(msg__, dst__, src__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePmkidCfmSend(dst__, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__) \
+ CsrWifiSmePmkidCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, action__, getPmkidsCount__, getPmkids__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePowerConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the PowerConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmePowerConfigGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmePowerConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_GET_REQ, dst__, src__);
+
+#define CsrWifiSmePowerConfigGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmePowerConfigGetReq *msg__; \
+ CsrWifiSmePowerConfigGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePowerConfigGetReqSend(src__) \
+ CsrWifiSmePowerConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePowerConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ powerConfig - Returns the current parameters for the power configuration of
+ the firmware
+
+*******************************************************************************/
+#define CsrWifiSmePowerConfigGetCfmCreate(msg__, dst__, src__, status__, powerConfig__) \
+ msg__ = (CsrWifiSmePowerConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->powerConfig = (powerConfig__);
+
+#define CsrWifiSmePowerConfigGetCfmSendTo(dst__, src__, status__, powerConfig__) \
+ { \
+ CsrWifiSmePowerConfigGetCfm *msg__; \
+ CsrWifiSmePowerConfigGetCfmCreate(msg__, dst__, src__, status__, powerConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePowerConfigGetCfmSend(dst__, status__, powerConfig__) \
+ CsrWifiSmePowerConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, powerConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePowerConfigSetReqSend
+
+ DESCRIPTION
+ This primitive sets the value of the PowerConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ powerConfig - Power saving configuration
+
+*******************************************************************************/
+#define CsrWifiSmePowerConfigSetReqCreate(msg__, dst__, src__, powerConfig__) \
+ msg__ = (CsrWifiSmePowerConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_SET_REQ, dst__, src__); \
+ msg__->powerConfig = (powerConfig__);
+
+#define CsrWifiSmePowerConfigSetReqSendTo(dst__, src__, powerConfig__) \
+ { \
+ CsrWifiSmePowerConfigSetReq *msg__; \
+ CsrWifiSmePowerConfigSetReqCreate(msg__, dst__, src__, powerConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePowerConfigSetReqSend(src__, powerConfig__) \
+ CsrWifiSmePowerConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, powerConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePowerConfigSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmePowerConfigSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmePowerConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_POWER_CONFIG_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmePowerConfigSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmePowerConfigSetCfm *msg__; \
+ CsrWifiSmePowerConfigSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmePowerConfigSetCfmSend(dst__, status__) \
+ CsrWifiSmePowerConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRegulatoryDomainInfoGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the RegulatoryDomainInfo parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeRegulatoryDomainInfoGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeRegulatoryDomainInfoGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeRegulatoryDomainInfoGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_REGULATORY_DOMAIN_INFO_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeRegulatoryDomainInfoGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeRegulatoryDomainInfoGetReq *msg__; \
+ CsrWifiSmeRegulatoryDomainInfoGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeRegulatoryDomainInfoGetReqSend(src__) \
+ CsrWifiSmeRegulatoryDomainInfoGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRegulatoryDomainInfoGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ regDomInfo - Reports information and state related to regulatory domain
+ operation.
+
+*******************************************************************************/
+#define CsrWifiSmeRegulatoryDomainInfoGetCfmCreate(msg__, dst__, src__, status__, regDomInfo__) \
+ msg__ = (CsrWifiSmeRegulatoryDomainInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRegulatoryDomainInfoGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_REGULATORY_DOMAIN_INFO_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->regDomInfo = (regDomInfo__);
+
+#define CsrWifiSmeRegulatoryDomainInfoGetCfmSendTo(dst__, src__, status__, regDomInfo__) \
+ { \
+ CsrWifiSmeRegulatoryDomainInfoGetCfm *msg__; \
+ CsrWifiSmeRegulatoryDomainInfoGetCfmCreate(msg__, dst__, src__, status__, regDomInfo__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeRegulatoryDomainInfoGetCfmSend(dst__, status__, regDomInfo__) \
+ CsrWifiSmeRegulatoryDomainInfoGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, regDomInfo__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamCompleteIndSend
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive it whenever it completes an attempt to roam to an AP. If the roam
+ attempt was successful, status will be set to CSR_WIFI_SME_SUCCESS,
+ otherwise it shall be set to the appropriate error code.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the roaming procedure
+
+*******************************************************************************/
+#define CsrWifiSmeRoamCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeRoamCompleteInd *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamCompleteInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAM_COMPLETE_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeRoamCompleteIndSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeRoamCompleteInd *msg__; \
+ CsrWifiSmeRoamCompleteIndCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeRoamCompleteIndSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeRoamCompleteIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamStartIndSend
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive it whenever it begins an attempt to roam to an AP.
+ If the wireless manager application connect request specified the SSID
+ and the BSSID was set to the broadcast address (0xFF 0xFF 0xFF 0xFF 0xFF
+ 0xFF), the SME monitors the signal quality and maintains a list of
+ candidates to roam to. When the signal quality of the current connection
+ falls below a threshold, and there is a candidate with better quality,
+ the SME will attempt to the candidate AP.
+ If the roaming procedure succeeds, the SME will also issue a Media
+ Connect indication to inform the wireless manager application of the
+ change.
+ NOTE: to prevent the SME from initiating roaming the WMA must specify the
+ BSSID in the connection request; this forces the SME to connect only to
+ that AP.
+ The wireless manager application can obtain statistics for roaming
+ purposes using CSR_WIFI_SME_CONNECTION_QUALITY_IND and
+ CSR_WIFI_SME_CONNECTION_STATS_GET_REQ.
+ When the wireless manager application wishes to roam to another AP, it
+ must issue a connection request specifying the BSSID of the desired AP.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ roamReason - Indicates the reason for starting the roaming procedure
+ reason80211 - Indicates the reason for deauthentication or disassociation
+
+*******************************************************************************/
+#define CsrWifiSmeRoamStartIndCreate(msg__, dst__, src__, interfaceTag__, roamReason__, reason80211__) \
+ msg__ = (CsrWifiSmeRoamStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamStartInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAM_START_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->roamReason = (roamReason__); \
+ msg__->reason80211 = (reason80211__);
+
+#define CsrWifiSmeRoamStartIndSendTo(dst__, src__, interfaceTag__, roamReason__, reason80211__) \
+ { \
+ CsrWifiSmeRoamStartInd *msg__; \
+ CsrWifiSmeRoamStartIndCreate(msg__, dst__, src__, interfaceTag__, roamReason__, reason80211__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeRoamStartIndSend(dst__, interfaceTag__, roamReason__, reason80211__) \
+ CsrWifiSmeRoamStartIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, roamReason__, reason80211__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamingConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the RoamingConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiSmeRoamingConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeRoamingConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_GET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeRoamingConfigGetReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeRoamingConfigGetReq *msg__; \
+ CsrWifiSmeRoamingConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeRoamingConfigGetReqSend(src__, interfaceTag__) \
+ CsrWifiSmeRoamingConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamingConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ roamingConfig - Reports the roaming behaviour of the driver and firmware
+
+*******************************************************************************/
+#define CsrWifiSmeRoamingConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, roamingConfig__) \
+ msg__ = (CsrWifiSmeRoamingConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_GET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->roamingConfig = (roamingConfig__);
+
+#define CsrWifiSmeRoamingConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, roamingConfig__) \
+ { \
+ CsrWifiSmeRoamingConfigGetCfm *msg__; \
+ CsrWifiSmeRoamingConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, roamingConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeRoamingConfigGetCfmSend(dst__, interfaceTag__, status__, roamingConfig__) \
+ CsrWifiSmeRoamingConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, roamingConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamingConfigSetReqSend
+
+ DESCRIPTION
+ This primitive sets the value of the RoamingConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ roamingConfig - Desired roaming behaviour values
+
+*******************************************************************************/
+#define CsrWifiSmeRoamingConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, roamingConfig__) \
+ msg__ = (CsrWifiSmeRoamingConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_SET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->roamingConfig = (roamingConfig__);
+
+#define CsrWifiSmeRoamingConfigSetReqSendTo(dst__, src__, interfaceTag__, roamingConfig__) \
+ { \
+ CsrWifiSmeRoamingConfigSetReq *msg__; \
+ CsrWifiSmeRoamingConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, roamingConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeRoamingConfigSetReqSend(src__, interfaceTag__, roamingConfig__) \
+ CsrWifiSmeRoamingConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, roamingConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamingConfigSetCfmSend
+
+ DESCRIPTION
+ This primitive sets the value of the RoamingConfig parameter.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeRoamingConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeRoamingConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_ROAMING_CONFIG_SET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeRoamingConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeRoamingConfigSetCfm *msg__; \
+ CsrWifiSmeRoamingConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeRoamingConfigSetCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeRoamingConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the ScanConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeScanConfigGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeScanConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeScanConfigGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeScanConfigGetReq *msg__; \
+ CsrWifiSmeScanConfigGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanConfigGetReqSend(src__) \
+ CsrWifiSmeScanConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ scanConfig - Returns the current parameters for the autonomous scanning
+ behaviour of the firmware
+
+*******************************************************************************/
+#define CsrWifiSmeScanConfigGetCfmCreate(msg__, dst__, src__, status__, scanConfig__) \
+ msg__ = (CsrWifiSmeScanConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->scanConfig = (scanConfig__);
+
+#define CsrWifiSmeScanConfigGetCfmSendTo(dst__, src__, status__, scanConfig__) \
+ { \
+ CsrWifiSmeScanConfigGetCfm *msg__; \
+ CsrWifiSmeScanConfigGetCfmCreate(msg__, dst__, src__, status__, scanConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanConfigGetCfmSend(dst__, status__, scanConfig__) \
+ CsrWifiSmeScanConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, scanConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanConfigSetReqSend
+
+ DESCRIPTION
+ This primitive sets the value of the ScanConfig parameter.
+ The SME normally configures the firmware to perform autonomous scanning
+ without involving the host.
+ The firmware passes beacon / probe response or indicates loss of beacon
+ on certain changes of state, for example:
+ * A new AP is seen for the first time
+ * An AP is no longer visible
+ * The signal strength of an AP changes by more than a certain amount, as
+ configured by the thresholds in the scanConfig parameter
+ In addition to the autonomous scan, the wireless manager application may
+ request a scan at any time using CSR_WIFI_SME_SCAN_FULL_REQ.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ scanConfig - Reports the configuration for the autonomous scanning behaviour
+ of the firmware
+
+*******************************************************************************/
+#define CsrWifiSmeScanConfigSetReqCreate(msg__, dst__, src__, scanConfig__) \
+ msg__ = (CsrWifiSmeScanConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_SET_REQ, dst__, src__); \
+ msg__->scanConfig = (scanConfig__);
+
+#define CsrWifiSmeScanConfigSetReqSendTo(dst__, src__, scanConfig__) \
+ { \
+ CsrWifiSmeScanConfigSetReq *msg__; \
+ CsrWifiSmeScanConfigSetReqCreate(msg__, dst__, src__, scanConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanConfigSetReqSend(src__, scanConfig__) \
+ CsrWifiSmeScanConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, scanConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanConfigSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeScanConfigSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeScanConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_CONFIG_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeScanConfigSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeScanConfigSetCfm *msg__; \
+ CsrWifiSmeScanConfigSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanConfigSetCfmSend(dst__, status__) \
+ CsrWifiSmeScanConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanFullReqSend
+
+ DESCRIPTION
+ The wireless manager application should call this primitive to request a
+ full scan.
+ Channels are scanned actively or passively according to the requirement
+ set by regulatory domain.
+ If the SME receives this primitive while a full scan is going on, the new
+ request is buffered and it will be served after the current full scan is
+ completed.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ ssidCount - Number of SSIDs provided.
+ If it is 0, the SME will attempt to detect any network
+ ssid - Points to the first SSID provided, if any.
+ bssid - BSS identifier.
+ If it is equal to FF-FF-FF-FF-FF, the SME will listen for
+ messages from any BSS.
+ If it is different from FF-FF-FF-FF-FF and any SSID is
+ provided, one SSID must match the network of the BSS.
+ forceScan - Forces the scan even if the SME is in a state which would
+ normally prevent it (e.g. autonomous scan is running).
+ bssType - Type of BSS to scan for
+ scanType - Type of scan to perform
+ channelListCount - Number of channels provided.
+ If it is 0, the SME will initiate a scan of all the
+ supported channels that are permitted by the current
+ regulatory domain.
+ channelList - Points to the first channel , or NULL if channelListCount
+ is zero.
+ probeIeLength - Length of the information element in bytes to be sent
+ with the probe message.
+ probeIe - Points to the first byte of the information element to be
+ sent with the probe message.
+
+*******************************************************************************/
+#define CsrWifiSmeScanFullReqCreate(msg__, dst__, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__) \
+ msg__ = (CsrWifiSmeScanFullReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanFullReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_FULL_REQ, dst__, src__); \
+ msg__->ssidCount = (ssidCount__); \
+ msg__->ssid = (ssid__); \
+ msg__->bssid = (bssid__); \
+ msg__->forceScan = (forceScan__); \
+ msg__->bssType = (bssType__); \
+ msg__->scanType = (scanType__); \
+ msg__->channelListCount = (channelListCount__); \
+ msg__->channelList = (channelList__); \
+ msg__->probeIeLength = (probeIeLength__); \
+ msg__->probeIe = (probeIe__);
+
+#define CsrWifiSmeScanFullReqSendTo(dst__, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__) \
+ { \
+ CsrWifiSmeScanFullReq *msg__; \
+ CsrWifiSmeScanFullReqCreate(msg__, dst__, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanFullReqSend(src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__) \
+ CsrWifiSmeScanFullReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, ssidCount__, ssid__, bssid__, forceScan__, bssType__, scanType__, channelListCount__, channelList__, probeIeLength__, probeIe__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanFullCfmSend
+
+ DESCRIPTION
+ The SME calls this primitive when the results from the scan are
+ available.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeScanFullCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeScanFullCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanFullCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_FULL_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeScanFullCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeScanFullCfm *msg__; \
+ CsrWifiSmeScanFullCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanFullCfmSend(dst__, status__) \
+ CsrWifiSmeScanFullCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResultIndSend
+
+ DESCRIPTION
+ The SME sends this primitive to all the tasks that have registered to
+ receive it whenever a scan indication is received from the firmware.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ result - Points to a buffer containing a scan result.
+
+*******************************************************************************/
+#define CsrWifiSmeScanResultIndCreate(msg__, dst__, src__, result__) \
+ msg__ = (CsrWifiSmeScanResultInd *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULT_IND, dst__, src__); \
+ msg__->result = (result__);
+
+#define CsrWifiSmeScanResultIndSendTo(dst__, src__, result__) \
+ { \
+ CsrWifiSmeScanResultInd *msg__; \
+ CsrWifiSmeScanResultIndCreate(msg__, dst__, src__, result__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanResultIndSend(dst__, result__) \
+ CsrWifiSmeScanResultIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, result__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResultsFlushReqSend
+
+ DESCRIPTION
+ The Wireless Manager calls this primitive to ask the SME to delete all
+ scan results from its cache, except for the scan result of any currently
+ connected network.
+ As scan results are received by the SME from the firmware, they are
+ cached in the SME memory.
+ Any time the Wireless Manager requests scan results, they are returned
+ from the SME internal cache.
+ For some applications it may be desirable to clear this cache prior to
+ requesting that a scan be performed; this will ensure that the cache then
+ only contains the networks detected in the most recent scan.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeScanResultsFlushReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeScanResultsFlushReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultsFlushReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_FLUSH_REQ, dst__, src__);
+
+#define CsrWifiSmeScanResultsFlushReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeScanResultsFlushReq *msg__; \
+ CsrWifiSmeScanResultsFlushReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanResultsFlushReqSend(src__) \
+ CsrWifiSmeScanResultsFlushReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResultsFlushCfmSend
+
+ DESCRIPTION
+ The SME will call this primitive when the cache has been cleared.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeScanResultsFlushCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeScanResultsFlushCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultsFlushCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_FLUSH_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeScanResultsFlushCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeScanResultsFlushCfm *msg__; \
+ CsrWifiSmeScanResultsFlushCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanResultsFlushCfmSend(dst__, status__) \
+ CsrWifiSmeScanResultsFlushCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResultsGetReqSend
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to retrieve the
+ current set of scan results, either after receiving a successful
+ CSR_WIFI_SME_SCAN_FULL_CFM, or to get autonomous scan results.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeScanResultsGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeScanResultsGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultsGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeScanResultsGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeScanResultsGetReq *msg__; \
+ CsrWifiSmeScanResultsGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanResultsGetReqSend(src__) \
+ CsrWifiSmeScanResultsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResultsGetCfmSend
+
+ DESCRIPTION
+ The SME sends this primitive to provide the current set of scan results.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ scanResultsCount - Number of scan results
+ scanResults - Points to a buffer containing an array of
+ CsrWifiSmeScanResult structures.
+
+*******************************************************************************/
+#define CsrWifiSmeScanResultsGetCfmCreate(msg__, dst__, src__, status__, scanResultsCount__, scanResults__) \
+ msg__ = (CsrWifiSmeScanResultsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultsGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SCAN_RESULTS_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->scanResultsCount = (scanResultsCount__); \
+ msg__->scanResults = (scanResults__);
+
+#define CsrWifiSmeScanResultsGetCfmSendTo(dst__, src__, status__, scanResultsCount__, scanResults__) \
+ { \
+ CsrWifiSmeScanResultsGetCfm *msg__; \
+ CsrWifiSmeScanResultsGetCfmCreate(msg__, dst__, src__, status__, scanResultsCount__, scanResults__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeScanResultsGetCfmSend(dst__, status__, scanResultsCount__, scanResults__) \
+ CsrWifiSmeScanResultsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, scanResultsCount__, scanResults__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSetReqSend
+
+ DESCRIPTION
+ Used to pass custom data to the SME. Format is the same as 802.11 Info
+ Elements => | Id | Length | Data
+ 1) Cmanr Test Mode "Id:0 Length:1 Data:0x00 = OFF 0x01 = ON" "0x00 0x01
+ (0x00|0x01)"
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ dataLength - Number of bytes in the buffer pointed to by 'data'
+ data - Pointer to the buffer containing 'dataLength' bytes
+
+*******************************************************************************/
+#define CsrWifiSmeSetReqCreate(msg__, dst__, src__, dataLength__, data__) \
+ msg__ = (CsrWifiSmeSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SET_REQ, dst__, src__); \
+ msg__->dataLength = (dataLength__); \
+ msg__->data = (data__);
+
+#define CsrWifiSmeSetReqSendTo(dst__, src__, dataLength__, data__) \
+ { \
+ CsrWifiSmeSetReq *msg__; \
+ CsrWifiSmeSetReqCreate(msg__, dst__, src__, dataLength__, data__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeSetReqSend(src__, dataLength__, data__) \
+ CsrWifiSmeSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, dataLength__, data__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeCommonConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the Sme common parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeSmeCommonConfigGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeSmeCommonConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeSmeCommonConfigGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeSmeCommonConfigGetReq *msg__; \
+ CsrWifiSmeSmeCommonConfigGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeSmeCommonConfigGetReqSend(src__) \
+ CsrWifiSmeSmeCommonConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeCommonConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ deviceConfig - Configuration options in the SME
+
+*******************************************************************************/
+#define CsrWifiSmeSmeCommonConfigGetCfmCreate(msg__, dst__, src__, status__, deviceConfig__) \
+ msg__ = (CsrWifiSmeSmeCommonConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->deviceConfig = (deviceConfig__);
+
+#define CsrWifiSmeSmeCommonConfigGetCfmSendTo(dst__, src__, status__, deviceConfig__) \
+ { \
+ CsrWifiSmeSmeCommonConfigGetCfm *msg__; \
+ CsrWifiSmeSmeCommonConfigGetCfmCreate(msg__, dst__, src__, status__, deviceConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeSmeCommonConfigGetCfmSend(dst__, status__, deviceConfig__) \
+ CsrWifiSmeSmeCommonConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, deviceConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeCommonConfigSetReqSend
+
+ DESCRIPTION
+ This primitive sets the value of the Sme common.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ deviceConfig - Configuration options in the SME
+
+*******************************************************************************/
+#define CsrWifiSmeSmeCommonConfigSetReqCreate(msg__, dst__, src__, deviceConfig__) \
+ msg__ = (CsrWifiSmeSmeCommonConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_SET_REQ, dst__, src__); \
+ msg__->deviceConfig = (deviceConfig__);
+
+#define CsrWifiSmeSmeCommonConfigSetReqSendTo(dst__, src__, deviceConfig__) \
+ { \
+ CsrWifiSmeSmeCommonConfigSetReq *msg__; \
+ CsrWifiSmeSmeCommonConfigSetReqCreate(msg__, dst__, src__, deviceConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeSmeCommonConfigSetReqSend(src__, deviceConfig__) \
+ CsrWifiSmeSmeCommonConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, deviceConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeCommonConfigSetCfmSend
+
+ DESCRIPTION
+ Reports the result of the request
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeSmeCommonConfigSetCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeSmeCommonConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_COMMON_CONFIG_SET_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeSmeCommonConfigSetCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeSmeCommonConfigSetCfm *msg__; \
+ CsrWifiSmeSmeCommonConfigSetCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeSmeCommonConfigSetCfmSend(dst__, status__) \
+ CsrWifiSmeSmeCommonConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeStaConfigGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the SmeStaConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+#define CsrWifiSmeSmeStaConfigGetReqCreate(msg__, dst__, src__, interfaceTag__) \
+ msg__ = (CsrWifiSmeSmeStaConfigGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_GET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__);
+
+#define CsrWifiSmeSmeStaConfigGetReqSendTo(dst__, src__, interfaceTag__) \
+ { \
+ CsrWifiSmeSmeStaConfigGetReq *msg__; \
+ CsrWifiSmeSmeStaConfigGetReqCreate(msg__, dst__, src__, interfaceTag__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeSmeStaConfigGetReqSend(src__, interfaceTag__) \
+ CsrWifiSmeSmeStaConfigGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeStaConfigGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ smeConfig - Current SME Station Parameters
+
+*******************************************************************************/
+#define CsrWifiSmeSmeStaConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, smeConfig__) \
+ msg__ = (CsrWifiSmeSmeStaConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_GET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->smeConfig = (smeConfig__);
+
+#define CsrWifiSmeSmeStaConfigGetCfmSendTo(dst__, src__, interfaceTag__, status__, smeConfig__) \
+ { \
+ CsrWifiSmeSmeStaConfigGetCfm *msg__; \
+ CsrWifiSmeSmeStaConfigGetCfmCreate(msg__, dst__, src__, interfaceTag__, status__, smeConfig__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeSmeStaConfigGetCfmSend(dst__, interfaceTag__, status__, smeConfig__) \
+ CsrWifiSmeSmeStaConfigGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, smeConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeStaConfigSetReqSend
+
+ DESCRIPTION
+ This primitive sets the value of the SmeConfig parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ smeConfig - SME Station Parameters to be set
+
+*******************************************************************************/
+#define CsrWifiSmeSmeStaConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, smeConfig__) \
+ msg__ = (CsrWifiSmeSmeStaConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigSetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_SET_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->smeConfig = (smeConfig__);
+
+#define CsrWifiSmeSmeStaConfigSetReqSendTo(dst__, src__, interfaceTag__, smeConfig__) \
+ { \
+ CsrWifiSmeSmeStaConfigSetReq *msg__; \
+ CsrWifiSmeSmeStaConfigSetReqCreate(msg__, dst__, src__, interfaceTag__, smeConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeSmeStaConfigSetReqSend(src__, interfaceTag__, smeConfig__) \
+ CsrWifiSmeSmeStaConfigSetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, smeConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeStaConfigSetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeSmeStaConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__) \
+ msg__ = (CsrWifiSmeSmeStaConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigSetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_SME_STA_CONFIG_SET_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeSmeStaConfigSetCfmSendTo(dst__, src__, interfaceTag__, status__) \
+ { \
+ CsrWifiSmeSmeStaConfigSetCfm *msg__; \
+ CsrWifiSmeSmeStaConfigSetCfmCreate(msg__, dst__, src__, interfaceTag__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeSmeStaConfigSetCfmSend(dst__, interfaceTag__, status__) \
+ CsrWifiSmeSmeStaConfigSetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeStationMacAddressGetReqSend
+
+ DESCRIPTION
+ This primitives is used to retrieve the current MAC address used by the
+ station.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeStationMacAddressGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeStationMacAddressGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeStationMacAddressGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_STATION_MAC_ADDRESS_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeStationMacAddressGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeStationMacAddressGetReq *msg__; \
+ CsrWifiSmeStationMacAddressGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeStationMacAddressGetReqSend(src__) \
+ CsrWifiSmeStationMacAddressGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeStationMacAddressGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ stationMacAddress - Current MAC address of the station.
+
+*******************************************************************************/
+#define CsrWifiSmeStationMacAddressGetCfmCreate(msg__, dst__, src__, status__, stationMacAddress__) \
+ msg__ = (CsrWifiSmeStationMacAddressGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeStationMacAddressGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_STATION_MAC_ADDRESS_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ CsrMemCpy(msg__->stationMacAddress, (stationMacAddress__), sizeof(CsrWifiMacAddress) * 2);
+
+#define CsrWifiSmeStationMacAddressGetCfmSendTo(dst__, src__, status__, stationMacAddress__) \
+ { \
+ CsrWifiSmeStationMacAddressGetCfm *msg__; \
+ CsrWifiSmeStationMacAddressGetCfmCreate(msg__, dst__, src__, status__, stationMacAddress__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeStationMacAddressGetCfmSend(dst__, status__, stationMacAddress__) \
+ CsrWifiSmeStationMacAddressGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, stationMacAddress__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTspecReqSend
+
+ DESCRIPTION
+ The wireless manager application should call this primitive to use the
+ TSPEC feature.
+ The chip supports the use of TSPECs and TCLAS for the use of IEEE
+ 802.11/WMM Quality of Service features.
+ The API allows the wireless manager application to supply a correctly
+ formatted TSPEC and TCLAS pair to the driver.
+ After performing basic validation, the driver negotiates the installation
+ of the TSPEC with the AP as defined by the 802.11 specification.
+ The driver retains all TSPEC and TCLAS pairs until they are specifically
+ removed.
+ It is not compulsory for a TSPEC to have a TCLAS (NULL is used to
+ indicate that no TCLAS is supplied), while a TCLASS always require a
+ TSPEC.
+ The format of the TSPEC element is specified in 'WMM (including WMM Power
+ Save) Specification - Version 1.1' and 'ANSI/IEEE Std 802.11-REVmb/D3.0'.
+ For more information, see 'UniFi Configuring WMM and WMM-PS'.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ action - Specifies the action to be carried out on the list of TSPECs.
+ CSR_WIFI_SME_LIST_ACTION_FLUSH is not applicable here.
+ transactionId - Unique Transaction ID for the TSPEC, as assigned by the
+ driver
+ strict - If it set to false, allows the SME to perform automatic
+ TSPEC negotiation
+ ctrlMask - Additional TSPEC configuration for CCX.
+ Set mask with values from CsrWifiSmeTspecCtrl.
+ CURRENTLY NOT SUPPORTED
+ tspecLength - Length of the TSPEC.
+ tspec - Points to the first byte of the TSPEC
+ tclasLength - Length of the TCLAS.
+ If it is equal to 0, no TCLASS is provided for the TSPEC
+ tclas - Points to the first byte of the TCLAS, if any.
+
+*******************************************************************************/
+#define CsrWifiSmeTspecReqCreate(msg__, dst__, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__) \
+ msg__ = (CsrWifiSmeTspecReq *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_TSPEC_REQ, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->action = (action__); \
+ msg__->transactionId = (transactionId__); \
+ msg__->strict = (strict__); \
+ msg__->ctrlMask = (ctrlMask__); \
+ msg__->tspecLength = (tspecLength__); \
+ msg__->tspec = (tspec__); \
+ msg__->tclasLength = (tclasLength__); \
+ msg__->tclas = (tclas__);
+
+#define CsrWifiSmeTspecReqSendTo(dst__, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__) \
+ { \
+ CsrWifiSmeTspecReq *msg__; \
+ CsrWifiSmeTspecReqCreate(msg__, dst__, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeTspecReqSend(src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__) \
+ CsrWifiSmeTspecReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, interfaceTag__, action__, transactionId__, strict__, ctrlMask__, tspecLength__, tspec__, tclasLength__, tclas__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTspecIndSend
+
+ DESCRIPTION
+ The SME will send this primitive to all the task that have registered to
+ receive it when a status change in the TSPEC occurs.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ transactionId - Unique Transaction ID for the TSPEC, as assigned by the
+ driver
+ tspecResultCode - Specifies the TSPEC operation requested by the peer
+ station
+ tspecLength - Length of the TSPEC.
+ tspec - Points to the first byte of the TSPEC
+
+*******************************************************************************/
+#define CsrWifiSmeTspecIndCreate(msg__, dst__, src__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
+ msg__ = (CsrWifiSmeTspecInd *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_TSPEC_IND, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->transactionId = (transactionId__); \
+ msg__->tspecResultCode = (tspecResultCode__); \
+ msg__->tspecLength = (tspecLength__); \
+ msg__->tspec = (tspec__);
+
+#define CsrWifiSmeTspecIndSendTo(dst__, src__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
+ { \
+ CsrWifiSmeTspecInd *msg__; \
+ CsrWifiSmeTspecIndCreate(msg__, dst__, src__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeTspecIndSend(dst__, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
+ CsrWifiSmeTspecIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, transactionId__, tspecResultCode__, tspecLength__, tspec__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTspecCfmSend
+
+ DESCRIPTION
+ The SME calls the primitive to report the result of the TSpec primitive
+ request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ transactionId - Unique Transaction ID for the TSPEC, as assigned by the
+ driver
+ tspecResultCode - Specifies the result of the negotiated TSPEC operation
+ tspecLength - Length of the TSPEC.
+ tspec - Points to the first byte of the TSPEC
+
+*******************************************************************************/
+#define CsrWifiSmeTspecCfmCreate(msg__, dst__, src__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
+ msg__ = (CsrWifiSmeTspecCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_TSPEC_CFM, dst__, src__); \
+ msg__->interfaceTag = (interfaceTag__); \
+ msg__->status = (status__); \
+ msg__->transactionId = (transactionId__); \
+ msg__->tspecResultCode = (tspecResultCode__); \
+ msg__->tspecLength = (tspecLength__); \
+ msg__->tspec = (tspec__);
+
+#define CsrWifiSmeTspecCfmSendTo(dst__, src__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
+ { \
+ CsrWifiSmeTspecCfm *msg__; \
+ CsrWifiSmeTspecCfmCreate(msg__, dst__, src__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeTspecCfmSend(dst__, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__) \
+ CsrWifiSmeTspecCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, interfaceTag__, status__, transactionId__, tspecResultCode__, tspecLength__, tspec__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeVersionsGetReqSend
+
+ DESCRIPTION
+ This primitive gets the value of the Versions parameter.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeVersionsGetReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeVersionsGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeVersionsGetReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_VERSIONS_GET_REQ, dst__, src__);
+
+#define CsrWifiSmeVersionsGetReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeVersionsGetReq *msg__; \
+ CsrWifiSmeVersionsGetReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeVersionsGetReqSend(src__) \
+ CsrWifiSmeVersionsGetReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeVersionsGetCfmSend
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+ versions - Version IDs of the product
+
+*******************************************************************************/
+#define CsrWifiSmeVersionsGetCfmCreate(msg__, dst__, src__, status__, versions__) \
+ msg__ = (CsrWifiSmeVersionsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeVersionsGetCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_VERSIONS_GET_CFM, dst__, src__); \
+ msg__->status = (status__); \
+ msg__->versions = (versions__);
+
+#define CsrWifiSmeVersionsGetCfmSendTo(dst__, src__, status__, versions__) \
+ { \
+ CsrWifiSmeVersionsGetCfm *msg__; \
+ CsrWifiSmeVersionsGetCfmCreate(msg__, dst__, src__, status__, versions__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeVersionsGetCfmSend(dst__, status__, versions__) \
+ CsrWifiSmeVersionsGetCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__, versions__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiFlightmodeReqSend
+
+ DESCRIPTION
+ The wireless manager application may call this primitive on boot-up of
+ the platform to ensure that the chip is placed in a mode that prevents
+ any emission of RF energy.
+ This primitive is an alternative to CSR_WIFI_SME_WIFI_ON_REQ.
+ As in CSR_WIFI_SME_WIFI_ON_REQ, it causes the download of the patch file
+ (if any) and the programming of the initial MIB settings (if supplied by
+ the WMA), but it also ensures that the chip is left in its lowest
+ possible power-mode with the radio subsystems disabled.
+ This feature is useful on platforms where power cannot be removed from
+ the chip (leaving the chip not initialised will cause it to consume more
+ power so calling this function ensures that the chip is initialised into
+ a low power mode but without entering a state where it could emit any RF
+ energy).
+ NOTE: this primitive does not cause the Wi-Fi to change state: Wi-Fi
+ stays conceptually off. Configuration primitives can be sent after
+ CSR_WIFI_SME_WIFI_FLIGHTMODE_REQ and the configuration will be maintained.
+ Requests that require the state of the Wi-Fi to be ON will return
+ CSR_WIFI_SME_STATUS_WIFI_OFF in their confirms.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ address - Optionally specifies a station MAC address.
+ In normal use, the manager should set the address to 0xFF
+ 0xFF 0xFF 0xFF 0xFF 0xFF, which will cause the chip to use
+ the MAC address in the MIB.
+ mibFilesCount - Number of provided data blocks with initial MIB values
+ mibFiles - Points to the first data block with initial MIB values.
+ These data blocks are typically the contents of the provided
+ files ufmib.dat and localmib.dat, available from the host
+ file system, if they exist.
+ These files typically contain radio tuning and calibration
+ values.
+ More values can be created using the Host Tools.
+
+*******************************************************************************/
+#define CsrWifiSmeWifiFlightmodeReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__) \
+ msg__ = (CsrWifiSmeWifiFlightmodeReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiFlightmodeReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_FLIGHTMODE_REQ, dst__, src__); \
+ msg__->address = (address__); \
+ msg__->mibFilesCount = (mibFilesCount__); \
+ msg__->mibFiles = (mibFiles__);
+
+#define CsrWifiSmeWifiFlightmodeReqSendTo(dst__, src__, address__, mibFilesCount__, mibFiles__) \
+ { \
+ CsrWifiSmeWifiFlightmodeReq *msg__; \
+ CsrWifiSmeWifiFlightmodeReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeWifiFlightmodeReqSend(src__, address__, mibFilesCount__, mibFiles__) \
+ CsrWifiSmeWifiFlightmodeReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, address__, mibFilesCount__, mibFiles__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiFlightmodeCfmSend
+
+ DESCRIPTION
+ The SME calls this primitive when the chip is initialised for low power
+ mode and with the radio subsystem disabled. To leave flight mode, and
+ enable Wi-Fi, the wireless manager application should call
+ CSR_WIFI_SME_WIFI_ON_REQ.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeWifiFlightmodeCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeWifiFlightmodeCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiFlightmodeCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_FLIGHTMODE_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeWifiFlightmodeCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeWifiFlightmodeCfm *msg__; \
+ CsrWifiSmeWifiFlightmodeCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeWifiFlightmodeCfmSend(dst__, status__) \
+ CsrWifiSmeWifiFlightmodeCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOffReqSend
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to turn off the
+ chip, thus saving power when Wi-Fi is not in use.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+
+*******************************************************************************/
+#define CsrWifiSmeWifiOffReqCreate(msg__, dst__, src__) \
+ msg__ = (CsrWifiSmeWifiOffReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOffReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_OFF_REQ, dst__, src__);
+
+#define CsrWifiSmeWifiOffReqSendTo(dst__, src__) \
+ { \
+ CsrWifiSmeWifiOffReq *msg__; \
+ CsrWifiSmeWifiOffReqCreate(msg__, dst__, src__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeWifiOffReqSend(src__) \
+ CsrWifiSmeWifiOffReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOffIndSend
+
+ DESCRIPTION
+ The SME sends this primitive to all the tasks that have registered to
+ receive it to report that the chip has been turned off.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ reason - Indicates the reason why the Wi-Fi has been switched off.
+
+*******************************************************************************/
+#define CsrWifiSmeWifiOffIndCreate(msg__, dst__, src__, reason__) \
+ msg__ = (CsrWifiSmeWifiOffInd *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOffInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_OFF_IND, dst__, src__); \
+ msg__->reason = (reason__);
+
+#define CsrWifiSmeWifiOffIndSendTo(dst__, src__, reason__) \
+ { \
+ CsrWifiSmeWifiOffInd *msg__; \
+ CsrWifiSmeWifiOffIndCreate(msg__, dst__, src__, reason__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeWifiOffIndSend(dst__, reason__) \
+ CsrWifiSmeWifiOffIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, reason__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOffCfmSend
+
+ DESCRIPTION
+ After receiving CSR_WIFI_SME_WIFI_OFF_REQ, if the chip is connected to a
+ network, the SME will perform a disconnect operation, will send a
+ CSR_WIFI_SME_MEDIA_STATUS_IND with
+ CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED, and then will call
+ CSR_WIFI_SME_WIFI_OFF_CFM when the chip is off.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeWifiOffCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeWifiOffCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOffCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_OFF_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeWifiOffCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeWifiOffCfm *msg__; \
+ CsrWifiSmeWifiOffCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeWifiOffCfmSend(dst__, status__) \
+ CsrWifiSmeWifiOffCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOnReqSend
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to turn on the
+ Wi-Fi chip.
+ If the Wi-Fi chip is currently off, the SME turns the Wi-Fi chip on,
+ downloads the patch file (if any), and programs the initial MIB settings
+ (if supplied by the WMA).
+ The patch file is not provided with the SME API; its downloading is
+ automatic and handled internally by the system.
+ The MIB settings, when provided, override the default values that the
+ firmware loads from EEPROM.
+ If the Wi-Fi chip is already on, the SME takes no action and returns a
+ successful status in the confirm.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ address - Optionally specifies a station MAC address.
+ In normal use, the manager should set the address to 0xFF
+ 0xFF 0xFF 0xFF 0xFF 0xFF, which will cause the chip to use
+ the MAC address in the MIB
+ mibFilesCount - Number of provided data blocks with initial MIB values
+ mibFiles - Points to the first data block with initial MIB values.
+ These data blocks are typically the contents of the provided
+ files ufmib.dat and localmib.dat, available from the host
+ file system, if they exist.
+ These files typically contain radio tuning and calibration
+ values.
+ More values can be created using the Host Tools.
+
+*******************************************************************************/
+#define CsrWifiSmeWifiOnReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__) \
+ msg__ = (CsrWifiSmeWifiOnReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_ON_REQ, dst__, src__); \
+ msg__->address = (address__); \
+ msg__->mibFilesCount = (mibFilesCount__); \
+ msg__->mibFiles = (mibFiles__);
+
+#define CsrWifiSmeWifiOnReqSendTo(dst__, src__, address__, mibFilesCount__, mibFiles__) \
+ { \
+ CsrWifiSmeWifiOnReq *msg__; \
+ CsrWifiSmeWifiOnReqCreate(msg__, dst__, src__, address__, mibFilesCount__, mibFiles__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeWifiOnReqSend(src__, address__, mibFilesCount__, mibFiles__) \
+ CsrWifiSmeWifiOnReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, address__, mibFilesCount__, mibFiles__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOnIndSend
+
+ DESCRIPTION
+ The SME sends this primitive to all tasks that have registered to receive
+ it once the chip becomes available and ready to use.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ address - Current MAC address
+
+*******************************************************************************/
+#define CsrWifiSmeWifiOnIndCreate(msg__, dst__, src__, address__) \
+ msg__ = (CsrWifiSmeWifiOnInd *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnInd)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_ON_IND, dst__, src__); \
+ msg__->address = (address__);
+
+#define CsrWifiSmeWifiOnIndSendTo(dst__, src__, address__) \
+ { \
+ CsrWifiSmeWifiOnInd *msg__; \
+ CsrWifiSmeWifiOnIndCreate(msg__, dst__, src__, address__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeWifiOnIndSend(dst__, address__) \
+ CsrWifiSmeWifiOnIndSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, address__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOnCfmSend
+
+ DESCRIPTION
+ The SME sends this primitive to the task that has sent the request once
+ the chip has been initialised and is available for use.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Reports the result of the request
+
+*******************************************************************************/
+#define CsrWifiSmeWifiOnCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeWifiOnCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WIFI_ON_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeWifiOnCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeWifiOnCfm *msg__; \
+ CsrWifiSmeWifiOnCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeWifiOnCfmSend(dst__, status__) \
+ CsrWifiSmeWifiOnCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsConfigurationReqSend
+
+ DESCRIPTION
+ This primitive passes the WPS information for the device to SME. This may
+ be accepted only if no interface is active.
+
+ PARAMETERS
+ queue - Message Source Task Queue (Cfm's will be sent to this Queue)
+ wpsConfig - WPS config.
+
+*******************************************************************************/
+#define CsrWifiSmeWpsConfigurationReqCreate(msg__, dst__, src__, wpsConfig__) \
+ msg__ = (CsrWifiSmeWpsConfigurationReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWpsConfigurationReq)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WPS_CONFIGURATION_REQ, dst__, src__); \
+ msg__->wpsConfig = (wpsConfig__);
+
+#define CsrWifiSmeWpsConfigurationReqSendTo(dst__, src__, wpsConfig__) \
+ { \
+ CsrWifiSmeWpsConfigurationReq *msg__; \
+ CsrWifiSmeWpsConfigurationReqCreate(msg__, dst__, src__, wpsConfig__); \
+ CsrMsgTransport(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeWpsConfigurationReqSend(src__, wpsConfig__) \
+ CsrWifiSmeWpsConfigurationReqSendTo(CSR_WIFI_SME_LIB_DESTINATION_QUEUE, src__, wpsConfig__)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsConfigurationCfmSend
+
+ DESCRIPTION
+ Confirm.
+
+ PARAMETERS
+ queue - Destination Task Queue
+ status - Status of the request.
+
+*******************************************************************************/
+#define CsrWifiSmeWpsConfigurationCfmCreate(msg__, dst__, src__, status__) \
+ msg__ = (CsrWifiSmeWpsConfigurationCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeWpsConfigurationCfm)); \
+ CsrWifiFsmEventInit(&msg__->common, CSR_WIFI_SME_PRIM, CSR_WIFI_SME_WPS_CONFIGURATION_CFM, dst__, src__); \
+ msg__->status = (status__);
+
+#define CsrWifiSmeWpsConfigurationCfmSendTo(dst__, src__, status__) \
+ { \
+ CsrWifiSmeWpsConfigurationCfm *msg__; \
+ CsrWifiSmeWpsConfigurationCfmCreate(msg__, dst__, src__, status__); \
+ CsrSchedMessagePut(dst__, CSR_WIFI_SME_PRIM, msg__); \
+ }
+
+#define CsrWifiSmeWpsConfigurationCfmSend(dst__, status__) \
+ CsrWifiSmeWpsConfigurationCfmSendTo(dst__, CSR_WIFI_SME_IFACEQUEUE, status__)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_SME_LIB_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_SME_PRIM_H__
+#define CSR_WIFI_SME_PRIM_H__
+
+#include "csr_types.h"
+#include "csr_prim_defs.h"
+#include "csr_sched.h"
+#include "csr_wifi_common.h"
+#include "csr_result.h"
+#include "csr_wifi_fsm_event.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CSR_WIFI_SME_PRIM (0x0404)
+
+typedef CsrPrim CsrWifiSmePrim;
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSme80211NetworkType
+
+ DESCRIPTION
+ Indicates the physical layer of the network
+
+ VALUES
+ CSR_WIFI_SME_80211_NETWORK_TYPE_DS
+ - Direct-sequence spread spectrum
+ CSR_WIFI_SME_80211_NETWORK_TYPE_OFDM24
+ - Orthogonal Frequency Division Multiplexing at 2.4 GHz
+ CSR_WIFI_SME_80211_NETWORK_TYPE_OFDM5
+ - Orthogonal Frequency Division Multiplexing at 5 GHz
+ CSR_WIFI_SME_80211_NETWORK_TYPE_AUTO
+ - Automatic
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSme80211NetworkType;
+#define CSR_WIFI_SME_80211_NETWORK_TYPE_DS ((CsrWifiSme80211NetworkType) 0x00)
+#define CSR_WIFI_SME_80211_NETWORK_TYPE_OFDM24 ((CsrWifiSme80211NetworkType) 0x01)
+#define CSR_WIFI_SME_80211_NETWORK_TYPE_OFDM5 ((CsrWifiSme80211NetworkType) 0x02)
+#define CSR_WIFI_SME_80211_NETWORK_TYPE_AUTO ((CsrWifiSme80211NetworkType) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSme80211PrivacyMode
+
+ DESCRIPTION
+ Bits to enable or disable the privacy mode
+
+ VALUES
+ CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED
+ - Privacy mode is enabled: use of WEP for confidentiality is
+ required.
+ CSR_WIFI_SME_80211_PRIVACY_MODE_ENABLED
+ - Privacy mode is disabled
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSme80211PrivacyMode;
+#define CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED ((CsrWifiSme80211PrivacyMode) 0x00)
+#define CSR_WIFI_SME_80211_PRIVACY_MODE_ENABLED ((CsrWifiSme80211PrivacyMode) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSme80211dTrustLevel
+
+ DESCRIPTION
+ Level of trust for the information coming from the network
+
+ VALUES
+ CSR_WIFI_SME_80211D_TRUST_LEVEL_STRICT
+ - Start with passive scanning and only accept country IE for
+ updating channel lists
+ CSR_WIFI_SME_80211D_TRUST_LEVEL_ADJUNCT
+ - As above plus accept adjunct technology location
+ information
+ CSR_WIFI_SME_80211D_TRUST_LEVEL_BSS
+ - As above accept plus receiving channel from infrastructure
+ networks
+ CSR_WIFI_SME_80211D_TRUST_LEVEL_IBSS
+ - As above accept plus receiving channel from the ad hoc
+ networks
+ CSR_WIFI_SME_80211D_TRUST_LEVEL_MIB
+ - Start with active scanning with list of active channels
+ from the MIB and accept as above
+ CSR_WIFI_SME_80211D_TRUST_LEVEL_DISABLED
+ - Start with active scanning with list of active channels
+ from the MIB and ignore any channel information from the
+ network
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSme80211dTrustLevel;
+#define CSR_WIFI_SME_80211D_TRUST_LEVEL_STRICT ((CsrWifiSme80211dTrustLevel) 0x01)
+#define CSR_WIFI_SME_80211D_TRUST_LEVEL_ADJUNCT ((CsrWifiSme80211dTrustLevel) 0x02)
+#define CSR_WIFI_SME_80211D_TRUST_LEVEL_BSS ((CsrWifiSme80211dTrustLevel) 0x03)
+#define CSR_WIFI_SME_80211D_TRUST_LEVEL_IBSS ((CsrWifiSme80211dTrustLevel) 0x04)
+#define CSR_WIFI_SME_80211D_TRUST_LEVEL_MIB ((CsrWifiSme80211dTrustLevel) 0x05)
+#define CSR_WIFI_SME_80211D_TRUST_LEVEL_DISABLED ((CsrWifiSme80211dTrustLevel) 0x06)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAmpStatus
+
+ DESCRIPTION
+ AMP Current Status
+
+ VALUES
+ CSR_WIFI_SME_AMP_ACTIVE - AMP ACTIVE.
+ CSR_WIFI_SME_AMP_INACTIVE - AMP INACTIVE
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeAmpStatus;
+#define CSR_WIFI_SME_AMP_ACTIVE ((CsrWifiSmeAmpStatus) 0x00)
+#define CSR_WIFI_SME_AMP_INACTIVE ((CsrWifiSmeAmpStatus) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAuthMode
+
+ DESCRIPTION
+ Define bits for CsrWifiSmeAuthMode
+
+ VALUES
+ CSR_WIFI_SME_AUTH_MODE_80211_OPEN
+ - Connects to an open system network (i.e. no authentication,
+ no encryption) or to a WEP enabled network.
+ CSR_WIFI_SME_AUTH_MODE_80211_SHARED
+ - Connect to a WEP enabled network.
+ CSR_WIFI_SME_AUTH_MODE_8021X_WPA
+ - Connects to a WPA Enterprise enabled network.
+ CSR_WIFI_SME_AUTH_MODE_8021X_WPAPSK
+ - Connects to a WPA with Pre-Shared Key enabled network.
+ CSR_WIFI_SME_AUTH_MODE_8021X_WPA2
+ - Connects to a WPA2 Enterprise enabled network.
+ CSR_WIFI_SME_AUTH_MODE_8021X_WPA2PSK
+ - Connects to a WPA2 with Pre-Shared Key enabled network.
+ CSR_WIFI_SME_AUTH_MODE_8021X_CCKM
+ - Connects to a CCKM enabled network.
+ CSR_WIFI_SME_AUTH_MODE_WAPI_WAI
+ - Connects to a WAPI Enterprise enabled network.
+ CSR_WIFI_SME_AUTH_MODE_WAPI_WAIPSK
+ - Connects to a WAPI with Pre-Shared Key enabled network.
+ CSR_WIFI_SME_AUTH_MODE_8021X_OTHER1X
+ - For future use.
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeAuthMode;
+#define CSR_WIFI_SME_AUTH_MODE_80211_OPEN ((CsrWifiSmeAuthMode) 0x0001)
+#define CSR_WIFI_SME_AUTH_MODE_80211_SHARED ((CsrWifiSmeAuthMode) 0x0002)
+#define CSR_WIFI_SME_AUTH_MODE_8021X_WPA ((CsrWifiSmeAuthMode) 0x0004)
+#define CSR_WIFI_SME_AUTH_MODE_8021X_WPAPSK ((CsrWifiSmeAuthMode) 0x0008)
+#define CSR_WIFI_SME_AUTH_MODE_8021X_WPA2 ((CsrWifiSmeAuthMode) 0x0010)
+#define CSR_WIFI_SME_AUTH_MODE_8021X_WPA2PSK ((CsrWifiSmeAuthMode) 0x0020)
+#define CSR_WIFI_SME_AUTH_MODE_8021X_CCKM ((CsrWifiSmeAuthMode) 0x0040)
+#define CSR_WIFI_SME_AUTH_MODE_WAPI_WAI ((CsrWifiSmeAuthMode) 0x0080)
+#define CSR_WIFI_SME_AUTH_MODE_WAPI_WAIPSK ((CsrWifiSmeAuthMode) 0x0100)
+#define CSR_WIFI_SME_AUTH_MODE_8021X_OTHER1X ((CsrWifiSmeAuthMode) 0x0200)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeBasicUsability
+
+ DESCRIPTION
+ Indicates the usability level of a channel
+
+ VALUES
+ CSR_WIFI_SME_BASIC_USABILITY_UNUSABLE
+ - Not usable; connection not recommended
+ CSR_WIFI_SME_BASIC_USABILITY_POOR
+ - Poor quality; connect only if nothing better is available
+ CSR_WIFI_SME_BASIC_USABILITY_SATISFACTORY
+ - Quality is satisfactory
+ CSR_WIFI_SME_BASIC_USABILITY_NOT_CONNECTED
+ - Not connected
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeBasicUsability;
+#define CSR_WIFI_SME_BASIC_USABILITY_UNUSABLE ((CsrWifiSmeBasicUsability) 0x00)
+#define CSR_WIFI_SME_BASIC_USABILITY_POOR ((CsrWifiSmeBasicUsability) 0x01)
+#define CSR_WIFI_SME_BASIC_USABILITY_SATISFACTORY ((CsrWifiSmeBasicUsability) 0x02)
+#define CSR_WIFI_SME_BASIC_USABILITY_NOT_CONNECTED ((CsrWifiSmeBasicUsability) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeBssType
+
+ DESCRIPTION
+ Indicates the BSS type
+
+ VALUES
+ CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE
+ - Infrastructure BSS.
+ CSR_WIFI_SME_BSS_TYPE_ADHOC
+ - Ad hoc or Independent BSS.
+ CSR_WIFI_SME_BSS_TYPE_ANY_BSS
+ - Specifies any type of BSS
+ CSR_WIFI_SME_BSS_TYPE_P2P
+ - Specifies P2P
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeBssType;
+#define CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE ((CsrWifiSmeBssType) 0x00)
+#define CSR_WIFI_SME_BSS_TYPE_ADHOC ((CsrWifiSmeBssType) 0x01)
+#define CSR_WIFI_SME_BSS_TYPE_ANY_BSS ((CsrWifiSmeBssType) 0x02)
+#define CSR_WIFI_SME_BSS_TYPE_P2P ((CsrWifiSmeBssType) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexScheme
+
+ DESCRIPTION
+ Options for the coexistence signalling
+ Same as MibValues
+
+ VALUES
+ CSR_WIFI_SME_COEX_SCHEME_DISABLED
+ - The coexistence signalling is disabled
+ CSR_WIFI_SME_COEX_SCHEME_CSR
+ - Basic CSR coexistence signalling
+ CSR_WIFI_SME_COEX_SCHEME_CSR_CHANNEL
+ - Full CSR coexistence signalling
+ CSR_WIFI_SME_COEX_SCHEME_PTA
+ - Packet Traffic Arbitrator coexistence signalling
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeCoexScheme;
+#define CSR_WIFI_SME_COEX_SCHEME_DISABLED ((CsrWifiSmeCoexScheme) 0x00)
+#define CSR_WIFI_SME_COEX_SCHEME_CSR ((CsrWifiSmeCoexScheme) 0x01)
+#define CSR_WIFI_SME_COEX_SCHEME_CSR_CHANNEL ((CsrWifiSmeCoexScheme) 0x02)
+#define CSR_WIFI_SME_COEX_SCHEME_PTA ((CsrWifiSmeCoexScheme) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeControlIndication
+
+ DESCRIPTION
+ Indicates the reason why the Wi-Fi has been switched off.
+ The values of this type are used across the NME/SME/Router API's and they
+ must be kept consistent with the corresponding types in the .xml of the
+ ottherinterfaces
+
+ VALUES
+ CSR_WIFI_SME_CONTROL_INDICATION_ERROR
+ - An unrecoverable error (for example, an unrecoverable SDIO
+ error) has occurred.
+ The wireless manager application should reinitialise the
+ chip by calling CSR_WIFI_SME_WIFI_ON_REQ.
+ CSR_WIFI_SME_CONTROL_INDICATION_EXIT
+ - The chip became unavailable due to an external action, for
+ example, when a plug-in card is ejected or the driver is
+ unloaded.
+ CSR_WIFI_SME_CONTROL_INDICATION_USER_REQUESTED
+ - The Wi-Fi has been switched off as the wireless manager
+ application has sent CSR_WIFI_SME_WIFI_OFF_REQ
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeControlIndication;
+#define CSR_WIFI_SME_CONTROL_INDICATION_ERROR ((CsrWifiSmeControlIndication) 0x01)
+#define CSR_WIFI_SME_CONTROL_INDICATION_EXIT ((CsrWifiSmeControlIndication) 0x02)
+#define CSR_WIFI_SME_CONTROL_INDICATION_USER_REQUESTED ((CsrWifiSmeControlIndication) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCtsProtectionType
+
+ DESCRIPTION
+ SME CTS Protection Types
+
+ VALUES
+ CSR_WIFI_SME_CTS_PROTECTION_AUTOMATIC
+ - AP CTS Protection automatic based on non-ERP station in own
+ BSS or neighbouring BSS on the same channel based on OLBC.
+ This requires monitoring of beacons from other APs.
+ CSR_WIFI_SME_CTS_PROTECTION_FORCE_ENABLED
+ - AP CTS Protection Force enabled
+ CSR_WIFI_SME_CTS_PROTECTION_FORCE_DISABLED
+ - AP CTS Protection Force disabled.
+ CSR_WIFI_SME_CTS_PROTECTION_AUTOMATIC_NO_OLBC
+ - AP CTS Protection automatic without considering OLBC but
+ considering non-ERP station in the own BSS Valid only if AP
+ is configured to work in 802.11bg or 802.11g mode otherwise
+ this option specifies the same behaviour as AUTOMATIC
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeCtsProtectionType;
+#define CSR_WIFI_SME_CTS_PROTECTION_AUTOMATIC ((CsrWifiSmeCtsProtectionType) 0x00)
+#define CSR_WIFI_SME_CTS_PROTECTION_FORCE_ENABLED ((CsrWifiSmeCtsProtectionType) 0x01)
+#define CSR_WIFI_SME_CTS_PROTECTION_FORCE_DISABLED ((CsrWifiSmeCtsProtectionType) 0x02)
+#define CSR_WIFI_SME_CTS_PROTECTION_AUTOMATIC_NO_OLBC ((CsrWifiSmeCtsProtectionType) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeD3AutoScanMode
+
+ DESCRIPTION
+ Autonomous scan status while in D3 suspended period
+
+ VALUES
+ CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSON
+ - Autonomous scan stays on
+ CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSOFF
+ - Autonomous scan is switched off
+ CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSAUTO
+ - Automatically select autoscanning behaviour.
+ CURRENTLY NOT SUPPORTED
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeD3AutoScanMode;
+#define CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSON ((CsrWifiSmeD3AutoScanMode) 0x00)
+#define CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSOFF ((CsrWifiSmeD3AutoScanMode) 0x01)
+#define CSR_WIFI_SME_D3AUTO_SCAN_MODE_PSAUTO ((CsrWifiSmeD3AutoScanMode) 0x02)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeEncryption
+
+ DESCRIPTION
+ Defines bits for CsrWifiSmeEncryption
+ For a WEP enabled network, the caller must specify the correct
+ combination of flags in the encryptionModeMask.
+
+ VALUES
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE
+ - No encryption set
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP40
+ - Selects 40 byte key WEP for unicast communication
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP104
+ - Selects 104 byte key WEP for unicast communication
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_TKIP
+ - Selects TKIP for unicast communication
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_CCMP
+ - Selects CCMP for unicast communication
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_SMS4
+ - Selects SMS4 for unicast communication
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP40
+ - Selects 40 byte key WEP for broadcast messages
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP104
+ - Selects 104 byte key WEP for broadcast messages
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_TKIP
+ - Selects a TKIP for broadcast messages
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_CCMP
+ - Selects CCMP for broadcast messages
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_SMS4
+ - Selects SMS4 for broadcast messages
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeEncryption;
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE ((CsrWifiSmeEncryption) 0x0000)
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP40 ((CsrWifiSmeEncryption) 0x0001)
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP104 ((CsrWifiSmeEncryption) 0x0002)
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_TKIP ((CsrWifiSmeEncryption) 0x0004)
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_CCMP ((CsrWifiSmeEncryption) 0x0008)
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_SMS4 ((CsrWifiSmeEncryption) 0x0010)
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP40 ((CsrWifiSmeEncryption) 0x0020)
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP104 ((CsrWifiSmeEncryption) 0x0040)
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_TKIP ((CsrWifiSmeEncryption) 0x0080)
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_CCMP ((CsrWifiSmeEncryption) 0x0100)
+#define CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_SMS4 ((CsrWifiSmeEncryption) 0x0200)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeFirmwareDriverInterface
+
+ DESCRIPTION
+ Type of communication between Host and Firmware
+
+ VALUES
+ CSR_WIFI_SME_FIRMWARE_DRIVER_INTERFACE_UNIT_DATA_INTERFACE
+ - No preformated header. NOT SUPPORTED in the current release
+ CSR_WIFI_SME_FIRMWARE_DRIVER_INTERFACE_PACKET_INTERFACE
+ - Preformated IEEE 802.11 header for user plane
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeFirmwareDriverInterface;
+#define CSR_WIFI_SME_FIRMWARE_DRIVER_INTERFACE_UNIT_DATA_INTERFACE ((CsrWifiSmeFirmwareDriverInterface) 0x00)
+#define CSR_WIFI_SME_FIRMWARE_DRIVER_INTERFACE_PACKET_INTERFACE ((CsrWifiSmeFirmwareDriverInterface) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeHostPowerMode
+
+ DESCRIPTION
+ Defines the power mode
+
+ VALUES
+ CSR_WIFI_SME_HOST_POWER_MODE_ACTIVE
+ - Host device is running on external power.
+ CSR_WIFI_SME_HOST_POWER_MODE_POWER_SAVE
+ - Host device is running on (internal) battery power.
+ CSR_WIFI_SME_HOST_POWER_MODE_FULL_POWER_SAVE
+ - For future use.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeHostPowerMode;
+#define CSR_WIFI_SME_HOST_POWER_MODE_ACTIVE ((CsrWifiSmeHostPowerMode) 0x00)
+#define CSR_WIFI_SME_HOST_POWER_MODE_POWER_SAVE ((CsrWifiSmeHostPowerMode) 0x01)
+#define CSR_WIFI_SME_HOST_POWER_MODE_FULL_POWER_SAVE ((CsrWifiSmeHostPowerMode) 0x02)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeIEEE80211Reason
+
+ DESCRIPTION
+ As definined in the IEEE 802.11 standards
+
+ VALUES
+ CSR_WIFI_SME_IEEE80211_REASON_SUCCESS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_UNSPECIFIED_REASON
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_AUTHENTICATION_NOT_VALID
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_DEAUTHENTICATED_LEAVE_BSS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_DISASSOCIATED_INACTIVITY
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_AP_OVERLOAD
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_CLASS_2FRAME_ERROR
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_CLASS_3FRAME_ERROR
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_DISASSOCIATED_LEAVE_BSS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_ASSOCIATION_NOT_AUTHENTICATED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_DISASSOCIATED_POWER_CAPABILITY
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_DISASSOCIATED_SUPPORTED_CHANNELS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_INVALID_INFORMATION_ELEMENT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_MICHAEL_MIC_FAILURE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_FOURWAY_HANDSHAKE_TIMEOUT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_GROUP_KEY_UPDATE_TIMEOUT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_HANDSHAKE_ELEMENT_DIFFERENT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_INVALID_GROUP_CIPHER
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_INVALID_PAIRWISE_CIPHER
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_INVALID_AKMP
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_UNSUPPORTED_RSN_IEVERSION
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_INVALID_RSN_IECAPABILITIES
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_DOT1X_AUTH_FAILED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_CIPHER_REJECTED_BY_POLICY
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_SERVICE_CHANGE_PRECLUDES_TS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_QOS_UNSPECIFIED_REASON
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_QOS_INSUFFICIENT_BANDWIDTH
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_QOS_EXCESSIVE_NOT_ACK
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_QOS_TXOPLIMIT_EXCEEDED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_QSTA_LEAVING
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_END_TS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_END_DLS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_END_BA
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_UNKNOWN_TS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_UNKNOWN_BA
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_UNKNOWN_DLS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_TIMEOUT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_STAKEY_MISMATCH
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_UNICAST_KEY_NEGOTIATION_TIMEOUT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_MULTICAST_KEY_ANNOUNCEMENT_TIMEOUT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_INCOMPATIBLE_UNICAST_KEY_NEGOTIATION_IE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_INVALID_MULTICAST_CIPHER
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_INVALID_UNICAST_CIPHER
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_UNSUPPORTED_WAPI_IE_VERSION
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_INVALID_WAPI_CAPABILITY_IE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_REASON_WAI_CERTIFICATE_AUTHENTICATION_FAILED
+ - See IEEE 802.11 Standard
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeIEEE80211Reason;
+#define CSR_WIFI_SME_IEEE80211_REASON_SUCCESS ((CsrWifiSmeIEEE80211Reason) 0x0000)
+#define CSR_WIFI_SME_IEEE80211_REASON_UNSPECIFIED_REASON ((CsrWifiSmeIEEE80211Reason) 0x0001)
+#define CSR_WIFI_SME_IEEE80211_REASON_AUTHENTICATION_NOT_VALID ((CsrWifiSmeIEEE80211Reason) 0x0002)
+#define CSR_WIFI_SME_IEEE80211_REASON_DEAUTHENTICATED_LEAVE_BSS ((CsrWifiSmeIEEE80211Reason) 0x0003)
+#define CSR_WIFI_SME_IEEE80211_REASON_DISASSOCIATED_INACTIVITY ((CsrWifiSmeIEEE80211Reason) 0x0004)
+#define CSR_WIFI_SME_IEEE80211_REASON_AP_OVERLOAD ((CsrWifiSmeIEEE80211Reason) 0x0005)
+#define CSR_WIFI_SME_IEEE80211_REASON_CLASS_2FRAME_ERROR ((CsrWifiSmeIEEE80211Reason) 0x0006)
+#define CSR_WIFI_SME_IEEE80211_REASON_CLASS_3FRAME_ERROR ((CsrWifiSmeIEEE80211Reason) 0x0007)
+#define CSR_WIFI_SME_IEEE80211_REASON_DISASSOCIATED_LEAVE_BSS ((CsrWifiSmeIEEE80211Reason) 0x0008)
+#define CSR_WIFI_SME_IEEE80211_REASON_ASSOCIATION_NOT_AUTHENTICATED ((CsrWifiSmeIEEE80211Reason) 0x0009)
+#define CSR_WIFI_SME_IEEE80211_REASON_DISASSOCIATED_POWER_CAPABILITY ((CsrWifiSmeIEEE80211Reason) 0x000a)
+#define CSR_WIFI_SME_IEEE80211_REASON_DISASSOCIATED_SUPPORTED_CHANNELS ((CsrWifiSmeIEEE80211Reason) 0x000b)
+#define CSR_WIFI_SME_IEEE80211_REASON_INVALID_INFORMATION_ELEMENT ((CsrWifiSmeIEEE80211Reason) 0x000d)
+#define CSR_WIFI_SME_IEEE80211_REASON_MICHAEL_MIC_FAILURE ((CsrWifiSmeIEEE80211Reason) 0x000e)
+#define CSR_WIFI_SME_IEEE80211_REASON_FOURWAY_HANDSHAKE_TIMEOUT ((CsrWifiSmeIEEE80211Reason) 0x000f)
+#define CSR_WIFI_SME_IEEE80211_REASON_GROUP_KEY_UPDATE_TIMEOUT ((CsrWifiSmeIEEE80211Reason) 0x0010)
+#define CSR_WIFI_SME_IEEE80211_REASON_HANDSHAKE_ELEMENT_DIFFERENT ((CsrWifiSmeIEEE80211Reason) 0x0011)
+#define CSR_WIFI_SME_IEEE80211_REASON_INVALID_GROUP_CIPHER ((CsrWifiSmeIEEE80211Reason) 0x0012)
+#define CSR_WIFI_SME_IEEE80211_REASON_INVALID_PAIRWISE_CIPHER ((CsrWifiSmeIEEE80211Reason) 0x0013)
+#define CSR_WIFI_SME_IEEE80211_REASON_INVALID_AKMP ((CsrWifiSmeIEEE80211Reason) 0x0014)
+#define CSR_WIFI_SME_IEEE80211_REASON_UNSUPPORTED_RSN_IEVERSION ((CsrWifiSmeIEEE80211Reason) 0x0015)
+#define CSR_WIFI_SME_IEEE80211_REASON_INVALID_RSN_IECAPABILITIES ((CsrWifiSmeIEEE80211Reason) 0x0016)
+#define CSR_WIFI_SME_IEEE80211_REASON_DOT1X_AUTH_FAILED ((CsrWifiSmeIEEE80211Reason) 0x0017)
+#define CSR_WIFI_SME_IEEE80211_REASON_CIPHER_REJECTED_BY_POLICY ((CsrWifiSmeIEEE80211Reason) 0x0018)
+#define CSR_WIFI_SME_IEEE80211_REASON_SERVICE_CHANGE_PRECLUDES_TS ((CsrWifiSmeIEEE80211Reason) 0x001F)
+#define CSR_WIFI_SME_IEEE80211_REASON_QOS_UNSPECIFIED_REASON ((CsrWifiSmeIEEE80211Reason) 0x0020)
+#define CSR_WIFI_SME_IEEE80211_REASON_QOS_INSUFFICIENT_BANDWIDTH ((CsrWifiSmeIEEE80211Reason) 0x0021)
+#define CSR_WIFI_SME_IEEE80211_REASON_QOS_EXCESSIVE_NOT_ACK ((CsrWifiSmeIEEE80211Reason) 0x0022)
+#define CSR_WIFI_SME_IEEE80211_REASON_QOS_TXOPLIMIT_EXCEEDED ((CsrWifiSmeIEEE80211Reason) 0x0023)
+#define CSR_WIFI_SME_IEEE80211_REASON_QSTA_LEAVING ((CsrWifiSmeIEEE80211Reason) 0x0024)
+#define CSR_WIFI_SME_IEEE80211_REASON_END_TS ((CsrWifiSmeIEEE80211Reason) 0x0025)
+#define CSR_WIFI_SME_IEEE80211_REASON_END_DLS ((CsrWifiSmeIEEE80211Reason) 0x0025)
+#define CSR_WIFI_SME_IEEE80211_REASON_END_BA ((CsrWifiSmeIEEE80211Reason) 0x0025)
+#define CSR_WIFI_SME_IEEE80211_REASON_UNKNOWN_TS ((CsrWifiSmeIEEE80211Reason) 0x0026)
+#define CSR_WIFI_SME_IEEE80211_REASON_UNKNOWN_BA ((CsrWifiSmeIEEE80211Reason) 0x0026)
+#define CSR_WIFI_SME_IEEE80211_REASON_UNKNOWN_DLS ((CsrWifiSmeIEEE80211Reason) 0x0026)
+#define CSR_WIFI_SME_IEEE80211_REASON_TIMEOUT ((CsrWifiSmeIEEE80211Reason) 0x0027)
+#define CSR_WIFI_SME_IEEE80211_REASON_STAKEY_MISMATCH ((CsrWifiSmeIEEE80211Reason) 0x002d)
+#define CSR_WIFI_SME_IEEE80211_REASON_UNICAST_KEY_NEGOTIATION_TIMEOUT ((CsrWifiSmeIEEE80211Reason) 0xf019)
+#define CSR_WIFI_SME_IEEE80211_REASON_MULTICAST_KEY_ANNOUNCEMENT_TIMEOUT ((CsrWifiSmeIEEE80211Reason) 0xf01a)
+#define CSR_WIFI_SME_IEEE80211_REASON_INCOMPATIBLE_UNICAST_KEY_NEGOTIATION_IE ((CsrWifiSmeIEEE80211Reason) 0xf01b)
+#define CSR_WIFI_SME_IEEE80211_REASON_INVALID_MULTICAST_CIPHER ((CsrWifiSmeIEEE80211Reason) 0xf01c)
+#define CSR_WIFI_SME_IEEE80211_REASON_INVALID_UNICAST_CIPHER ((CsrWifiSmeIEEE80211Reason) 0xf01d)
+#define CSR_WIFI_SME_IEEE80211_REASON_UNSUPPORTED_WAPI_IE_VERSION ((CsrWifiSmeIEEE80211Reason) 0xf01e)
+#define CSR_WIFI_SME_IEEE80211_REASON_INVALID_WAPI_CAPABILITY_IE ((CsrWifiSmeIEEE80211Reason) 0xf01f)
+#define CSR_WIFI_SME_IEEE80211_REASON_WAI_CERTIFICATE_AUTHENTICATION_FAILED ((CsrWifiSmeIEEE80211Reason) 0xf020)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeIEEE80211Result
+
+ DESCRIPTION
+ As definined in the IEEE 802.11 standards
+
+ VALUES
+ CSR_WIFI_SME_IEEE80211_RESULT_SUCCESS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_UNSPECIFIED_FAILURE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_CAPABILITIES_MISMATCH
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REASSOCIATION_DENIED_NO_ASSOCIATION
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_EXTERNAL_REASON
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_AUTHENTICATION_MISMATCH
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_INVALID_AUTHENTICATION_SEQUENCE_NUMBER
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_CHALLENGE_FAILURE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_AUTHENTICATION_TIMEOUT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_AP_OUT_OF_MEMORY
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_BASIC_RATES_MISMATCH
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_SHORT_PREAMBLE_REQUIRED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_PBCC_MODULATION_REQUIRED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_CHANNEL_AGILITY_REQUIRED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_SPECTRUM_MANAGEMENT_REQUIRED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_POWER_CAPABILITY_UNACCEPTABLE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_SUPPORTED_CHANNELS_UNACCEPTABLE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_SHORT_SLOT_REQUIRED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_DSSS_OFDMREQUIRED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_NO_HT_SUPPORT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_R0KH_UNREACHABLE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_PCO_TRANSITION_SUPPORT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_ASSOCIATION_REQUEST_REJECTED_TEMPORARILY
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_ROBUST_MANAGEMENT_FRAME_POLICY_VIOLATION
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_FAILURE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_AP_BANDWIDTH_INSUFFICIENT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_POOR_OPERATING_CHANNEL
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_QOS_REQUIRED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_REASON_UNSPECIFIED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_INVALID_PARAMETERS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_WITH_SUGGESTED_TSPEC_CHANGES
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_INVALID_IE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_INVALID_GROUP_CIPHER
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_INVALID_PAIRWISE_CIPHER
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_INVALID_AKMP
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_UNSUPPORTED_RSN_VERSION
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_INVALID_RSN_CAPABILITY
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_SECURITY_POLICY
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_FOR_DELAY_PERIOD
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_NOT_ALLOWED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_NOT_PRESENT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_NOT_QSTA
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_LISTEN_INTERVAL_TOO_LARGE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_INVALID_FT_ACTION_FRAME_COUNT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_INVALID_PMKID
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_INVALID_MDIE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_INVALID_FTIE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_UNSPECIFIED_QOS_FAILURE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_WRONG_POLICY
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_INSUFFICIENT_BANDWIDTH
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_INVALID_TSPEC_PARAMETERS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_TIMEOUT
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_TOO_MANY_SIMULTANEOUS_REQUESTS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_BSS_ALREADY_STARTED_OR_JOINED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_NOT_SUPPORTED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_TRANSMISSION_FAILURE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_NOT_AUTHENTICATED
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_RESET_REQUIRED_BEFORE_START
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_LM_INFO_UNAVAILABLE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_INVALID_UNICAST_CIPHER
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_INVALID_MULTICAST_CIPHER
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_UNSUPPORTED_WAPI_IE_VERSION
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_IEEE80211_RESULT_INVALID_WAPI_CAPABILITY_IE
+ - See IEEE 802.11 Standard
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeIEEE80211Result;
+#define CSR_WIFI_SME_IEEE80211_RESULT_SUCCESS ((CsrWifiSmeIEEE80211Result) 0x0000)
+#define CSR_WIFI_SME_IEEE80211_RESULT_UNSPECIFIED_FAILURE ((CsrWifiSmeIEEE80211Result) 0x0001)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_CAPABILITIES_MISMATCH ((CsrWifiSmeIEEE80211Result) 0x000a)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REASSOCIATION_DENIED_NO_ASSOCIATION ((CsrWifiSmeIEEE80211Result) 0x000b)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_EXTERNAL_REASON ((CsrWifiSmeIEEE80211Result) 0x000c)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_AUTHENTICATION_MISMATCH ((CsrWifiSmeIEEE80211Result) 0x000d)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_INVALID_AUTHENTICATION_SEQUENCE_NUMBER ((CsrWifiSmeIEEE80211Result) 0x000e)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_CHALLENGE_FAILURE ((CsrWifiSmeIEEE80211Result) 0x000f)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_AUTHENTICATION_TIMEOUT ((CsrWifiSmeIEEE80211Result) 0x0010)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_AP_OUT_OF_MEMORY ((CsrWifiSmeIEEE80211Result) 0x0011)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_BASIC_RATES_MISMATCH ((CsrWifiSmeIEEE80211Result) 0x0012)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_SHORT_PREAMBLE_REQUIRED ((CsrWifiSmeIEEE80211Result) 0x0013)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_PBCC_MODULATION_REQUIRED ((CsrWifiSmeIEEE80211Result) 0x0014)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_CHANNEL_AGILITY_REQUIRED ((CsrWifiSmeIEEE80211Result) 0x0015)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_SPECTRUM_MANAGEMENT_REQUIRED ((CsrWifiSmeIEEE80211Result) 0x0016)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_POWER_CAPABILITY_UNACCEPTABLE ((CsrWifiSmeIEEE80211Result) 0x0017)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_SUPPORTED_CHANNELS_UNACCEPTABLE ((CsrWifiSmeIEEE80211Result) 0x0018)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_SHORT_SLOT_REQUIRED ((CsrWifiSmeIEEE80211Result) 0x0019)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_DSSS_OFDMREQUIRED ((CsrWifiSmeIEEE80211Result) 0x001a)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_NO_HT_SUPPORT ((CsrWifiSmeIEEE80211Result) 0x001b)
+#define CSR_WIFI_SME_IEEE80211_RESULT_R0KH_UNREACHABLE ((CsrWifiSmeIEEE80211Result) 0x001c)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_PCO_TRANSITION_SUPPORT ((CsrWifiSmeIEEE80211Result) 0x001d)
+#define CSR_WIFI_SME_IEEE80211_RESULT_ASSOCIATION_REQUEST_REJECTED_TEMPORARILY ((CsrWifiSmeIEEE80211Result) 0x001e)
+#define CSR_WIFI_SME_IEEE80211_RESULT_ROBUST_MANAGEMENT_FRAME_POLICY_VIOLATION ((CsrWifiSmeIEEE80211Result) 0x001f)
+#define CSR_WIFI_SME_IEEE80211_RESULT_FAILURE ((CsrWifiSmeIEEE80211Result) 0x0020)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_AP_BANDWIDTH_INSUFFICIENT ((CsrWifiSmeIEEE80211Result) 0x0021)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_POOR_OPERATING_CHANNEL ((CsrWifiSmeIEEE80211Result) 0x0022)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_QOS_REQUIRED ((CsrWifiSmeIEEE80211Result) 0x0023)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_REASON_UNSPECIFIED ((CsrWifiSmeIEEE80211Result) 0x0025)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED ((CsrWifiSmeIEEE80211Result) 0x0025)
+#define CSR_WIFI_SME_IEEE80211_RESULT_INVALID_PARAMETERS ((CsrWifiSmeIEEE80211Result) 0x0026)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_WITH_SUGGESTED_TSPEC_CHANGES ((CsrWifiSmeIEEE80211Result) 0x0027)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_INVALID_IE ((CsrWifiSmeIEEE80211Result) 0x0028)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_INVALID_GROUP_CIPHER ((CsrWifiSmeIEEE80211Result) 0x0029)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_INVALID_PAIRWISE_CIPHER ((CsrWifiSmeIEEE80211Result) 0x002a)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_INVALID_AKMP ((CsrWifiSmeIEEE80211Result) 0x002b)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_UNSUPPORTED_RSN_VERSION ((CsrWifiSmeIEEE80211Result) 0x002c)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_INVALID_RSN_CAPABILITY ((CsrWifiSmeIEEE80211Result) 0x002d)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_SECURITY_POLICY ((CsrWifiSmeIEEE80211Result) 0x002e)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_FOR_DELAY_PERIOD ((CsrWifiSmeIEEE80211Result) 0x002f)
+#define CSR_WIFI_SME_IEEE80211_RESULT_NOT_ALLOWED ((CsrWifiSmeIEEE80211Result) 0x0030)
+#define CSR_WIFI_SME_IEEE80211_RESULT_NOT_PRESENT ((CsrWifiSmeIEEE80211Result) 0x0031)
+#define CSR_WIFI_SME_IEEE80211_RESULT_NOT_QSTA ((CsrWifiSmeIEEE80211Result) 0x0032)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REJECTED_LISTEN_INTERVAL_TOO_LARGE ((CsrWifiSmeIEEE80211Result) 0x0033)
+#define CSR_WIFI_SME_IEEE80211_RESULT_INVALID_FT_ACTION_FRAME_COUNT ((CsrWifiSmeIEEE80211Result) 0x0034)
+#define CSR_WIFI_SME_IEEE80211_RESULT_INVALID_PMKID ((CsrWifiSmeIEEE80211Result) 0x0035)
+#define CSR_WIFI_SME_IEEE80211_RESULT_INVALID_MDIE ((CsrWifiSmeIEEE80211Result) 0x0036)
+#define CSR_WIFI_SME_IEEE80211_RESULT_INVALID_FTIE ((CsrWifiSmeIEEE80211Result) 0x0037)
+#define CSR_WIFI_SME_IEEE80211_RESULT_UNSPECIFIED_QOS_FAILURE ((CsrWifiSmeIEEE80211Result) 0x00c8)
+#define CSR_WIFI_SME_IEEE80211_RESULT_WRONG_POLICY ((CsrWifiSmeIEEE80211Result) 0x00c9)
+#define CSR_WIFI_SME_IEEE80211_RESULT_INSUFFICIENT_BANDWIDTH ((CsrWifiSmeIEEE80211Result) 0x00ca)
+#define CSR_WIFI_SME_IEEE80211_RESULT_INVALID_TSPEC_PARAMETERS ((CsrWifiSmeIEEE80211Result) 0x00cb)
+#define CSR_WIFI_SME_IEEE80211_RESULT_TIMEOUT ((CsrWifiSmeIEEE80211Result) 0x8000)
+#define CSR_WIFI_SME_IEEE80211_RESULT_TOO_MANY_SIMULTANEOUS_REQUESTS ((CsrWifiSmeIEEE80211Result) 0x8001)
+#define CSR_WIFI_SME_IEEE80211_RESULT_BSS_ALREADY_STARTED_OR_JOINED ((CsrWifiSmeIEEE80211Result) 0x8002)
+#define CSR_WIFI_SME_IEEE80211_RESULT_NOT_SUPPORTED ((CsrWifiSmeIEEE80211Result) 0x8003)
+#define CSR_WIFI_SME_IEEE80211_RESULT_TRANSMISSION_FAILURE ((CsrWifiSmeIEEE80211Result) 0x8004)
+#define CSR_WIFI_SME_IEEE80211_RESULT_REFUSED_NOT_AUTHENTICATED ((CsrWifiSmeIEEE80211Result) 0x8005)
+#define CSR_WIFI_SME_IEEE80211_RESULT_RESET_REQUIRED_BEFORE_START ((CsrWifiSmeIEEE80211Result) 0x8006)
+#define CSR_WIFI_SME_IEEE80211_RESULT_LM_INFO_UNAVAILABLE ((CsrWifiSmeIEEE80211Result) 0x8007)
+#define CSR_WIFI_SME_IEEE80211_RESULT_INVALID_UNICAST_CIPHER ((CsrWifiSmeIEEE80211Result) 0xf02f)
+#define CSR_WIFI_SME_IEEE80211_RESULT_INVALID_MULTICAST_CIPHER ((CsrWifiSmeIEEE80211Result) 0xf030)
+#define CSR_WIFI_SME_IEEE80211_RESULT_UNSUPPORTED_WAPI_IE_VERSION ((CsrWifiSmeIEEE80211Result) 0xf031)
+#define CSR_WIFI_SME_IEEE80211_RESULT_INVALID_WAPI_CAPABILITY_IE ((CsrWifiSmeIEEE80211Result) 0xf032)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeIndications
+
+ DESCRIPTION
+ Defines bits for CsrWifiSmeIndicationsMask
+
+ VALUES
+ CSR_WIFI_SME_INDICATIONS_NONE
+ - Used to cancel the registrations for receiving indications
+ CSR_WIFI_SME_INDICATIONS_WIFIOFF
+ - Used to register for CSR_WIFI_SME_WIFI_OFF_IND events
+ CSR_WIFI_SME_INDICATIONS_SCANRESULT
+ - Used to register for CSR_WIFI_SME_SCAN_RESULT_IND events
+ CSR_WIFI_SME_INDICATIONS_CONNECTIONQUALITY
+ - Used to register for CSR_WIFI_SME_CONNECTION_QUALITY_IND
+ events
+ CSR_WIFI_SME_INDICATIONS_MEDIASTATUS
+ - Used to register for CSR_WIFI_SME_MEDIA_STATUS_IND events
+ CSR_WIFI_SME_INDICATIONS_MICFAILURE
+ - Used to register for CSR_WIFI_SME_MICFAILURE_IND events
+ CSR_WIFI_SME_INDICATIONS_PMKIDCANDIDATELIST
+ - Used to register for CSR_WIFI_SME_PMKIDCANDIDATE_LIST_IND
+ events
+ CSR_WIFI_SME_INDICATIONS_TSPEC
+ - Used to register for CSR_WIFI_SME_TSPEC_IND events
+ CSR_WIFI_SME_INDICATIONS_ROAMSTART
+ - Used to register for CSR_WIFI_SME_ROAM_START_IND events
+ CSR_WIFI_SME_INDICATIONS_ROAMCOMPLETE
+ - Used to register for CSR_WIFI_SME_ROAM_COMPLETE_IND events
+ CSR_WIFI_SME_INDICATIONS_ASSOCIATIONSTART
+ - Used to register for CSR_WIFI_SME_ASSOCIATION_START_IND
+ events
+ CSR_WIFI_SME_INDICATIONS_ASSOCIATIONCOMPLETE
+ - Used to register for CSR_WIFI_SME_ASSOCIATION_COMPLETE_IND
+ events
+ CSR_WIFI_SME_INDICATIONS_IBSSSTATION
+ - Used to register for CSR_WIFI_SME_IBSS_STATION_IND events
+ CSR_WIFI_SME_INDICATIONS_WIFION
+ - Used to register for CSR_WIFI_SME_WIFI_ON_IND events
+ CSR_WIFI_SME_INDICATIONS_ERROR
+ - Used to register for CSR_WIFI_SME_ERROR_IND events
+ CSR_WIFI_SME_INDICATIONS_INFO
+ - Used to register for CSR_WIFI_SME_INFO_IND events
+ CSR_WIFI_SME_INDICATIONS_COREDUMP
+ - Used to register for CSR_WIFI_SME_CORE_DUMP_IND events
+ CSR_WIFI_SME_INDICATIONS_ALL
+ - Used to register for all available indications
+
+*******************************************************************************/
+typedef CsrUint32 CsrWifiSmeIndications;
+#define CSR_WIFI_SME_INDICATIONS_NONE ((CsrWifiSmeIndications) 0x00000000)
+#define CSR_WIFI_SME_INDICATIONS_WIFIOFF ((CsrWifiSmeIndications) 0x00000001)
+#define CSR_WIFI_SME_INDICATIONS_SCANRESULT ((CsrWifiSmeIndications) 0x00000002)
+#define CSR_WIFI_SME_INDICATIONS_CONNECTIONQUALITY ((CsrWifiSmeIndications) 0x00000004)
+#define CSR_WIFI_SME_INDICATIONS_MEDIASTATUS ((CsrWifiSmeIndications) 0x00000008)
+#define CSR_WIFI_SME_INDICATIONS_MICFAILURE ((CsrWifiSmeIndications) 0x00000010)
+#define CSR_WIFI_SME_INDICATIONS_PMKIDCANDIDATELIST ((CsrWifiSmeIndications) 0x00000020)
+#define CSR_WIFI_SME_INDICATIONS_TSPEC ((CsrWifiSmeIndications) 0x00000040)
+#define CSR_WIFI_SME_INDICATIONS_ROAMSTART ((CsrWifiSmeIndications) 0x00000080)
+#define CSR_WIFI_SME_INDICATIONS_ROAMCOMPLETE ((CsrWifiSmeIndications) 0x00000100)
+#define CSR_WIFI_SME_INDICATIONS_ASSOCIATIONSTART ((CsrWifiSmeIndications) 0x00000200)
+#define CSR_WIFI_SME_INDICATIONS_ASSOCIATIONCOMPLETE ((CsrWifiSmeIndications) 0x00000400)
+#define CSR_WIFI_SME_INDICATIONS_IBSSSTATION ((CsrWifiSmeIndications) 0x00000800)
+#define CSR_WIFI_SME_INDICATIONS_WIFION ((CsrWifiSmeIndications) 0x00001000)
+#define CSR_WIFI_SME_INDICATIONS_ERROR ((CsrWifiSmeIndications) 0x00002000)
+#define CSR_WIFI_SME_INDICATIONS_INFO ((CsrWifiSmeIndications) 0x00004000)
+#define CSR_WIFI_SME_INDICATIONS_COREDUMP ((CsrWifiSmeIndications) 0x00008000)
+#define CSR_WIFI_SME_INDICATIONS_ALL ((CsrWifiSmeIndications) 0xFFFFFFFF)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeKeyType
+
+ DESCRIPTION
+ Indicates the type of the key
+
+ VALUES
+ CSR_WIFI_SME_KEY_TYPE_GROUP - Key for broadcast communication
+ CSR_WIFI_SME_KEY_TYPE_PAIRWISE - Key for unicast communication
+ CSR_WIFI_SME_KEY_TYPE_STAKEY - Key for direct link communication to
+ another station in infrastructure networks
+ CSR_WIFI_SME_KEY_TYPE_IGTK - Integrity Group Temporal Key
+ CSR_WIFI_SME_KEY_TYPE_CCKM - Key for Cisco Centralized Key Management
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeKeyType;
+#define CSR_WIFI_SME_KEY_TYPE_GROUP ((CsrWifiSmeKeyType) 0x00)
+#define CSR_WIFI_SME_KEY_TYPE_PAIRWISE ((CsrWifiSmeKeyType) 0x01)
+#define CSR_WIFI_SME_KEY_TYPE_STAKEY ((CsrWifiSmeKeyType) 0x02)
+#define CSR_WIFI_SME_KEY_TYPE_IGTK ((CsrWifiSmeKeyType) 0x03)
+#define CSR_WIFI_SME_KEY_TYPE_CCKM ((CsrWifiSmeKeyType) 0x04)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeListAction
+
+ DESCRIPTION
+ Identifies the type of action to be performed on a list of items
+ The values of this type are used across the NME/SME/Router API's and they
+ must be kept consistent with the corresponding types in the .xml of the
+ ottherinterfaces
+
+ VALUES
+ CSR_WIFI_SME_LIST_ACTION_GET - Retrieve the current list of items
+ CSR_WIFI_SME_LIST_ACTION_ADD - Add one or more items
+ CSR_WIFI_SME_LIST_ACTION_REMOVE - Remove one or more items
+ CSR_WIFI_SME_LIST_ACTION_FLUSH - Remove all items
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeListAction;
+#define CSR_WIFI_SME_LIST_ACTION_GET ((CsrWifiSmeListAction) 0x00)
+#define CSR_WIFI_SME_LIST_ACTION_ADD ((CsrWifiSmeListAction) 0x01)
+#define CSR_WIFI_SME_LIST_ACTION_REMOVE ((CsrWifiSmeListAction) 0x02)
+#define CSR_WIFI_SME_LIST_ACTION_FLUSH ((CsrWifiSmeListAction) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMediaStatus
+
+ DESCRIPTION
+ Indicates the connection status
+ The values of this type are used across the NME/SME/Router API's and they
+ must be kept consistent with the corresponding types in the .xml of the
+ ottherinterfaces
+
+ VALUES
+ CSR_WIFI_SME_MEDIA_STATUS_CONNECTED
+ - Value CSR_WIFI_SME_MEDIA_STATUS_CONNECTED can happen in two
+ situations:
+ * A network connection is established. Specifically, this is
+ when the MLME_ASSOCIATION completes or the first peer
+ relationship is established in an IBSS. In a WPA/WPA2
+ network, this indicates that the stack is ready to perform
+ the 4-way handshake or 802.1x authentication if CSR NME
+ security library is not used. If CSR NME security library
+ is used this indicates, completion of 4way handshake or
+ 802.1x authentication
+ * The SME roams to another AP on the same ESS
+ During the AP operation, it indicates that the peer station
+ is connected to the AP and is ready for data transfer.
+ CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED
+ - Value CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED can happen in
+ two situations:
+ * when the connection to a network is lost and there is no
+ alternative on the same ESS to roam to
+ * when a CSR_WIFI_SME_DISCONNECT_REQ request is issued
+ During AP or P2PGO operation, it indicates that the peer
+ station has disconnected from the AP
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeMediaStatus;
+#define CSR_WIFI_SME_MEDIA_STATUS_CONNECTED ((CsrWifiSmeMediaStatus) 0x00)
+#define CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED ((CsrWifiSmeMediaStatus) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeP2pCapability
+
+ DESCRIPTION
+ Defines P2P Device Capabilities
+
+ VALUES
+ CSR_WIFI_SME_P2P_SERVICE_DISCOVERY_CAPABILITY
+ - This field is set to 1 if the P2P Device supports Service
+ Discovery, and to 0 otherwise
+ CSR_WIFI_SME_P2P_CLIENT_DISCOVERABILITY_CAPABILITY
+ - This field is set to 1 when the P2P Device supports P2P
+ Client Discoverability, and to 0 otherwise.
+ CSR_WIFI_SME_P2P_CONCURRENT_OPERATION_CAPABILITY
+ - This field is set to 1 when the P2P Device supports
+ Concurrent Operation with WLAN, and to 0 otherwise.
+ CSR_WIFI_SME_P2P_MANAGED_DEVICE_CAPABILITY
+ - This field is set to 1 when the P2P interface of the P2P
+ Device is capable of being managed by the WLAN
+ (infrastructure network) based on P2P coexistence
+ parameters, and to 0 otherwise
+ CSR_WIFI_SME_P2P_INVITAION_CAPABILITY
+ - This field is set to 1 if the P2P Device is capable of
+ processing P2P Invitation Procedure signaling, and to 0
+ otherwise.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeP2pCapability;
+#define CSR_WIFI_SME_P2P_SERVICE_DISCOVERY_CAPABILITY ((CsrWifiSmeP2pCapability) 0x01)
+#define CSR_WIFI_SME_P2P_CLIENT_DISCOVERABILITY_CAPABILITY ((CsrWifiSmeP2pCapability) 0x02)
+#define CSR_WIFI_SME_P2P_CONCURRENT_OPERATION_CAPABILITY ((CsrWifiSmeP2pCapability) 0x04)
+#define CSR_WIFI_SME_P2P_MANAGED_DEVICE_CAPABILITY ((CsrWifiSmeP2pCapability) 0x08)
+#define CSR_WIFI_SME_P2P_INVITAION_CAPABILITY ((CsrWifiSmeP2pCapability) 0x20)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeP2pGroupCapability
+
+ DESCRIPTION
+ Define bits for P2P Group Capability
+
+ VALUES
+ CSR_WIFI_P2P_GRP_CAP_GO
+ - Indicates if the local device has become a GO after GO
+ negotiation
+ CSR_WIFI_P2P_GRP_CAP_PERSISTENT
+ - Persistent group
+ CSR_WIFI_P2P_GRP_CAP_INTRABSS_DIST
+ - Intra-BSS data distribution support
+ CSR_WIFI_P2P_GRP_CAP_CROSS_CONN
+ - Support of cross connection
+ CSR_WIFI_P2P_GRP_CAP_PERSISTENT_RECONNECT
+ - Support of persistent reconnect
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeP2pGroupCapability;
+#define CSR_WIFI_P2P_GRP_CAP_GO ((CsrWifiSmeP2pGroupCapability) 0x01)
+#define CSR_WIFI_P2P_GRP_CAP_PERSISTENT ((CsrWifiSmeP2pGroupCapability) 0x02)
+#define CSR_WIFI_P2P_GRP_CAP_INTRABSS_DIST ((CsrWifiSmeP2pGroupCapability) 0x08)
+#define CSR_WIFI_P2P_GRP_CAP_CROSS_CONN ((CsrWifiSmeP2pGroupCapability) 0x10)
+#define CSR_WIFI_P2P_GRP_CAP_PERSISTENT_RECONNECT ((CsrWifiSmeP2pGroupCapability) 0x20)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeP2pNoaConfigMethod
+
+ DESCRIPTION
+ Notice of Absece Configuration
+
+ VALUES
+ CSR_WIFI_P2P_NOA_NONE - Do not use NOA
+ CSR_WIFI_P2P_NOA_AUTONOMOUS - NOA based on the traffic analysis
+ CSR_WIFI_P2P_NOA_USER_DEFINED - NOA as specified by the user
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeP2pNoaConfigMethod;
+#define CSR_WIFI_P2P_NOA_NONE ((CsrWifiSmeP2pNoaConfigMethod) 0x00)
+#define CSR_WIFI_P2P_NOA_AUTONOMOUS ((CsrWifiSmeP2pNoaConfigMethod) 0x01)
+#define CSR_WIFI_P2P_NOA_USER_DEFINED ((CsrWifiSmeP2pNoaConfigMethod) 0x02)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeP2pRole
+
+ DESCRIPTION
+ Definition of roles for a P2P Device
+
+ VALUES
+ CSR_WIFI_SME_P2P_ROLE_NONE - A non-P2PDevice device
+ CSR_WIFI_SME_P2P_ROLE_STANDALONE - A Standalone P2P device
+ CSR_WIFI_SME_P2P_ROLE_GO - Role Assumed is that of a Group Owner
+ within a P2P Group
+ CSR_WIFI_SME_P2P_ROLE_CLI - Role Assumed is that of a P2P Client
+ within a P2P Group
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeP2pRole;
+#define CSR_WIFI_SME_P2P_ROLE_NONE ((CsrWifiSmeP2pRole) 0x00)
+#define CSR_WIFI_SME_P2P_ROLE_STANDALONE ((CsrWifiSmeP2pRole) 0x01)
+#define CSR_WIFI_SME_P2P_ROLE_GO ((CsrWifiSmeP2pRole) 0x02)
+#define CSR_WIFI_SME_P2P_ROLE_CLI ((CsrWifiSmeP2pRole) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeP2pStatus
+
+ DESCRIPTION
+ This data type enumerates the outcome of P2P procedure
+
+ VALUES
+ CSR_WIFI_SME_P2P_STATUS_SUCCESS
+ - Success
+ CSR_WIFI_SME_P2P_STATUS_FAIL_INFO_UNAVAILABLE
+ - Fail; information is currently unavailable
+ CSR_WIFI_SME_P2P_STATUS_FAIL_INCOMPATIBLE_PARAM
+ - Fail; incompatible parameters
+ CSR_WIFI_SME_P2P_STATUS_FAIL_LIMIT_REACHED
+ - Fail; limit reached
+ CSR_WIFI_SME_P2P_STATUS_FAIL_INVALID_PARAM
+ - Fail; invalid parameters
+ CSR_WIFI_SME_P2P_STATUS_FAIL_ACCOMODATE
+ - Fail; unable to accommodate request
+ CSR_WIFI_SME_P2P_STATUS_FAIL_PREV_ERROR
+ - Fail; previous protocol error, or disruptive behavior
+ CSR_WIFI_SME_P2P_STATUS_FAIL_COMMON_CHANNELS
+ - Fail; no common channels
+ CSR_WIFI_SME_P2P_STATUS_FAIL_UNKNOWN_GROUP
+ - Fail; unknown P2P Group
+ CSR_WIFI_SME_P2P_STATUS_FAIL_GO_INTENT
+ - Fail: both P2P Devices indicated an Intent of 15 in Group
+ Owner Negotiation
+ CSR_WIFI_SME_P2P_STATUS_FAIL_PROVISION_METHOD_INCOMPATIBLE
+ - Fail; incompatible provisioning method
+ CSR_WIFI_SME_P2P_STATUS_FAIL_REJECT
+ - Fail: rejected by user
+ CSR_WIFI_SME_P2P_STATUS_FAIL_RESERVED
+ - Fail; Status Reserved
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeP2pStatus;
+#define CSR_WIFI_SME_P2P_STATUS_SUCCESS ((CsrWifiSmeP2pStatus) 0x00)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_INFO_UNAVAILABLE ((CsrWifiSmeP2pStatus) 0x01)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_INCOMPATIBLE_PARAM ((CsrWifiSmeP2pStatus) 0x02)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_LIMIT_REACHED ((CsrWifiSmeP2pStatus) 0x03)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_INVALID_PARAM ((CsrWifiSmeP2pStatus) 0x04)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_ACCOMODATE ((CsrWifiSmeP2pStatus) 0x05)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_PREV_ERROR ((CsrWifiSmeP2pStatus) 0x06)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_COMMON_CHANNELS ((CsrWifiSmeP2pStatus) 0x07)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_UNKNOWN_GROUP ((CsrWifiSmeP2pStatus) 0x08)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_GO_INTENT ((CsrWifiSmeP2pStatus) 0x09)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_PROVISION_METHOD_INCOMPATIBLE ((CsrWifiSmeP2pStatus) 0x0A)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_REJECT ((CsrWifiSmeP2pStatus) 0x0B)
+#define CSR_WIFI_SME_P2P_STATUS_FAIL_RESERVED ((CsrWifiSmeP2pStatus) 0xFF)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePacketFilterMode
+
+ DESCRIPTION
+ Options for the filter mode parameter.
+ The Values here match the HIP interface
+
+ VALUES
+ CSR_WIFI_SME_PACKET_FILTER_MODE_OPT_OUT
+ - Broadcast packets are always reported to the host unless
+ they match at least one of the specified TCLAS IEs.
+ CSR_WIFI_SME_PACKET_FILTER_MODE_OPT_IN
+ - Broadcast packets are reported to the host only if they
+ match at least one of the specified TCLAS IEs.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmePacketFilterMode;
+#define CSR_WIFI_SME_PACKET_FILTER_MODE_OPT_OUT ((CsrWifiSmePacketFilterMode) 0x00)
+#define CSR_WIFI_SME_PACKET_FILTER_MODE_OPT_IN ((CsrWifiSmePacketFilterMode) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePowerSaveLevel
+
+ DESCRIPTION
+ Power Save Level options as defined in the IEEE 802.11 standards
+ First 3 values are set to match the mlme PowerManagementMode
+
+ VALUES
+ CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW - No power save: the driver will remain
+ active at all times
+ CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH - Enter power save after all packets in
+ the queues are transmitted and received
+ CSR_WIFI_SME_POWER_SAVE_LEVEL_MED - Enter power save after all packets in
+ the queues are transmitted and received
+ and a further configurable delay
+ (default 1s) has elapsed
+ CSR_WIFI_SME_POWER_SAVE_LEVEL_AUTO - The SME will decide when to enter power
+ save mode according to the traffic
+ analysis
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmePowerSaveLevel;
+#define CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW ((CsrWifiSmePowerSaveLevel) 0x00)
+#define CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH ((CsrWifiSmePowerSaveLevel) 0x01)
+#define CSR_WIFI_SME_POWER_SAVE_LEVEL_MED ((CsrWifiSmePowerSaveLevel) 0x02)
+#define CSR_WIFI_SME_POWER_SAVE_LEVEL_AUTO ((CsrWifiSmePowerSaveLevel) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePreambleType
+
+ DESCRIPTION
+ SME Preamble Types
+
+ VALUES
+ CSR_WIFI_SME_USE_LONG_PREAMBLE - Use legacy (long) preamble
+ CSR_WIFI_SME_USE_SHORT_PREAMBLE - Use short PPDU format
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmePreambleType;
+#define CSR_WIFI_SME_USE_LONG_PREAMBLE ((CsrWifiSmePreambleType) 0x00)
+#define CSR_WIFI_SME_USE_SHORT_PREAMBLE ((CsrWifiSmePreambleType) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRadioIF
+
+ DESCRIPTION
+ Indicates the frequency
+
+ VALUES
+ CSR_WIFI_SME_RADIO_IF_GHZ_2_4 - Indicates the 2.4 GHZ frequency
+ CSR_WIFI_SME_RADIO_IF_GHZ_5_0 - Future use: currently not supported
+ CSR_WIFI_SME_RADIO_IF_BOTH - Future use: currently not supported
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeRadioIF;
+#define CSR_WIFI_SME_RADIO_IF_GHZ_2_4 ((CsrWifiSmeRadioIF) 0x01)
+#define CSR_WIFI_SME_RADIO_IF_GHZ_5_0 ((CsrWifiSmeRadioIF) 0x02)
+#define CSR_WIFI_SME_RADIO_IF_BOTH ((CsrWifiSmeRadioIF) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRegulatoryDomain
+
+ DESCRIPTION
+ Indicates the regulatory domain as defined in IEEE 802.11 standards
+
+ VALUES
+ CSR_WIFI_SME_REGULATORY_DOMAIN_OTHER
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_REGULATORY_DOMAIN_FCC
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_REGULATORY_DOMAIN_IC
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_REGULATORY_DOMAIN_ETSI
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_REGULATORY_DOMAIN_SPAIN
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_REGULATORY_DOMAIN_FRANCE
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_REGULATORY_DOMAIN_JAPAN
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_REGULATORY_DOMAIN_JAPANBIS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_REGULATORY_DOMAIN_CHINA
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_REGULATORY_DOMAIN_CHINABIS
+ - See IEEE 802.11 Standard
+ CSR_WIFI_SME_REGULATORY_DOMAIN_NONE
+ - See IEEE 802.11 Standard
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeRegulatoryDomain;
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_OTHER ((CsrWifiSmeRegulatoryDomain) 0x00)
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_FCC ((CsrWifiSmeRegulatoryDomain) 0x10)
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_IC ((CsrWifiSmeRegulatoryDomain) 0x20)
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_ETSI ((CsrWifiSmeRegulatoryDomain) 0x30)
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_SPAIN ((CsrWifiSmeRegulatoryDomain) 0x31)
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_FRANCE ((CsrWifiSmeRegulatoryDomain) 0x32)
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_JAPAN ((CsrWifiSmeRegulatoryDomain) 0x40)
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_JAPANBIS ((CsrWifiSmeRegulatoryDomain) 0x41)
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_CHINA ((CsrWifiSmeRegulatoryDomain) 0x50)
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_CHINABIS ((CsrWifiSmeRegulatoryDomain) 0x51)
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_NONE ((CsrWifiSmeRegulatoryDomain) 0xFF)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamReason
+
+ DESCRIPTION
+ Indicates the reason for roaming
+
+ VALUES
+ CSR_WIFI_SME_ROAM_REASON_BEACONLOST
+ - The station cannot receive the beacon signal any more
+ CSR_WIFI_SME_ROAM_REASON_DISASSOCIATED
+ - The station has been disassociated
+ CSR_WIFI_SME_ROAM_REASON_DEAUTHENTICATED
+ - The station has been deauthenticated
+ CSR_WIFI_SME_ROAM_REASON_BETTERAPFOUND
+ - A better AP has been found
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeRoamReason;
+#define CSR_WIFI_SME_ROAM_REASON_BEACONLOST ((CsrWifiSmeRoamReason) 0x00)
+#define CSR_WIFI_SME_ROAM_REASON_DISASSOCIATED ((CsrWifiSmeRoamReason) 0x01)
+#define CSR_WIFI_SME_ROAM_REASON_DEAUTHENTICATED ((CsrWifiSmeRoamReason) 0x02)
+#define CSR_WIFI_SME_ROAM_REASON_BETTERAPFOUND ((CsrWifiSmeRoamReason) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanType
+
+ DESCRIPTION
+ Identifies the type of scan to be performed
+
+ VALUES
+ CSR_WIFI_SME_SCAN_TYPE_ALL - Scan actively or passively according to the
+ regulatory domain restrictions
+ CSR_WIFI_SME_SCAN_TYPE_ACTIVE - Scan actively only: send probes and listen
+ for answers
+ CSR_WIFI_SME_SCAN_TYPE_PASSIVE - Scan passively only: listen for beacon
+ messages
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeScanType;
+#define CSR_WIFI_SME_SCAN_TYPE_ALL ((CsrWifiSmeScanType) 0x00)
+#define CSR_WIFI_SME_SCAN_TYPE_ACTIVE ((CsrWifiSmeScanType) 0x01)
+#define CSR_WIFI_SME_SCAN_TYPE_PASSIVE ((CsrWifiSmeScanType) 0x02)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTrafficType
+
+ DESCRIPTION
+ Identifies the type of traffic going on on the connection.
+ The values of this type are used across the NME/SME/Router API's and they
+ must be kept consistent with the corresponding types in the .xml of the
+ ottherinterfaces
+
+ VALUES
+ CSR_WIFI_SME_TRAFFIC_TYPE_OCCASIONAL
+ - During the last 30 seconds there were fewer than 20 packets
+ per seconds in each second in both directions
+ CSR_WIFI_SME_TRAFFIC_TYPE_BURSTY
+ - During the last 30 seconds there was at least one second
+ during which more than 20 packets were received in either
+ direction
+ CSR_WIFI_SME_TRAFFIC_TYPE_PERIODIC
+ - During the last 5 seconds there were at least 10 packets
+ received each second and a defined period for the traffic
+ can be recognized
+ CSR_WIFI_SME_TRAFFIC_TYPE_CONTINUOUS
+ - During the last 5 seconds there were at least 20 packets
+ received each second in either direction
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeTrafficType;
+#define CSR_WIFI_SME_TRAFFIC_TYPE_OCCASIONAL ((CsrWifiSmeTrafficType) 0x00)
+#define CSR_WIFI_SME_TRAFFIC_TYPE_BURSTY ((CsrWifiSmeTrafficType) 0x01)
+#define CSR_WIFI_SME_TRAFFIC_TYPE_PERIODIC ((CsrWifiSmeTrafficType) 0x02)
+#define CSR_WIFI_SME_TRAFFIC_TYPE_CONTINUOUS ((CsrWifiSmeTrafficType) 0x03)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTspecCtrl
+
+ DESCRIPTION
+ Defines bits for CsrWifiSmeTspecCtrlMask for additional CCX configuration.
+ CURRENTLY NOT SUPPORTED.
+
+ VALUES
+ CSR_WIFI_SME_TSPEC_CTRL_STRICT
+ - No automatic negotiation
+ CSR_WIFI_SME_TSPEC_CTRL_CCX_SIGNALLING
+ - Signalling TSPEC
+ CSR_WIFI_SME_TSPEC_CTRL_CCX_VOICE
+ - Voice traffic TSPEC
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeTspecCtrl;
+#define CSR_WIFI_SME_TSPEC_CTRL_STRICT ((CsrWifiSmeTspecCtrl) 0x01)
+#define CSR_WIFI_SME_TSPEC_CTRL_CCX_SIGNALLING ((CsrWifiSmeTspecCtrl) 0x02)
+#define CSR_WIFI_SME_TSPEC_CTRL_CCX_VOICE ((CsrWifiSmeTspecCtrl) 0x04)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTspecResultCode
+
+ DESCRIPTION
+ Defines the result of the TSPEC exchanges with the AP
+
+ VALUES
+ CSR_WIFI_SME_TSPEC_RESULT_SUCCESS
+ - TSPEC command has been processed correctly
+ CSR_WIFI_SME_TSPEC_RESULT_UNSPECIFIED_QOS_FAILURE
+ - The Access Point reported a failure
+ CSR_WIFI_SME_TSPEC_RESULT_FAILURE
+ - Internal failure in the SME
+ CSR_WIFI_SME_TSPEC_RESULT_INVALID_TSPEC_PARAMETERS
+ - The TSPEC parameters are invalid
+ CSR_WIFI_SME_TSPEC_RESULT_INVALID_TCLAS_PARAMETERS
+ - The TCLASS parameters are invalid
+ CSR_WIFI_SME_TSPEC_RESULT_INSUFFICIENT_BANDWIDTH
+ - As specified by the WMM Spec
+ CSR_WIFI_SME_TSPEC_RESULT_WRONG_POLICY
+ - As specified by the WMM Spec
+ CSR_WIFI_SME_TSPEC_RESULT_REJECTED_WITH_SUGGESTED_CHANGES
+ - As specified by the WMM Spec
+ CSR_WIFI_SME_TSPEC_RESULT_TIMEOUT
+ - The TSPEC negotiation timed out
+ CSR_WIFI_SME_TSPEC_RESULT_NOT_SUPPORTED
+ - The Access Point does not support the TSPEC
+ CSR_WIFI_SME_TSPEC_RESULT_IE_LENGTH_INCORRECT
+ - The length of the TSPEC is not correct
+ CSR_WIFI_SME_TSPEC_RESULT_INVALID_TRANSACTION_ID
+ - The TSPEC transaction id is not in the list
+ CSR_WIFI_SME_TSPEC_RESULT_INSTALLED
+ - The TSPEC has been installed and it is now active.
+ CSR_WIFI_SME_TSPEC_RESULT_TID_ALREADY_INSTALLED
+ - The Traffic ID has already been installed
+ CSR_WIFI_SME_TSPEC_RESULT_TSPEC_REMOTELY_DELETED
+ - The AP has deleted the TSPEC
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeTspecResultCode;
+#define CSR_WIFI_SME_TSPEC_RESULT_SUCCESS ((CsrWifiSmeTspecResultCode) 0x00)
+#define CSR_WIFI_SME_TSPEC_RESULT_UNSPECIFIED_QOS_FAILURE ((CsrWifiSmeTspecResultCode) 0x01)
+#define CSR_WIFI_SME_TSPEC_RESULT_FAILURE ((CsrWifiSmeTspecResultCode) 0x02)
+#define CSR_WIFI_SME_TSPEC_RESULT_INVALID_TSPEC_PARAMETERS ((CsrWifiSmeTspecResultCode) 0x05)
+#define CSR_WIFI_SME_TSPEC_RESULT_INVALID_TCLAS_PARAMETERS ((CsrWifiSmeTspecResultCode) 0x06)
+#define CSR_WIFI_SME_TSPEC_RESULT_INSUFFICIENT_BANDWIDTH ((CsrWifiSmeTspecResultCode) 0x07)
+#define CSR_WIFI_SME_TSPEC_RESULT_WRONG_POLICY ((CsrWifiSmeTspecResultCode) 0x08)
+#define CSR_WIFI_SME_TSPEC_RESULT_REJECTED_WITH_SUGGESTED_CHANGES ((CsrWifiSmeTspecResultCode) 0x09)
+#define CSR_WIFI_SME_TSPEC_RESULT_TIMEOUT ((CsrWifiSmeTspecResultCode) 0x0D)
+#define CSR_WIFI_SME_TSPEC_RESULT_NOT_SUPPORTED ((CsrWifiSmeTspecResultCode) 0x0E)
+#define CSR_WIFI_SME_TSPEC_RESULT_IE_LENGTH_INCORRECT ((CsrWifiSmeTspecResultCode) 0x10)
+#define CSR_WIFI_SME_TSPEC_RESULT_INVALID_TRANSACTION_ID ((CsrWifiSmeTspecResultCode) 0x11)
+#define CSR_WIFI_SME_TSPEC_RESULT_INSTALLED ((CsrWifiSmeTspecResultCode) 0x12)
+#define CSR_WIFI_SME_TSPEC_RESULT_TID_ALREADY_INSTALLED ((CsrWifiSmeTspecResultCode) 0x13)
+#define CSR_WIFI_SME_TSPEC_RESULT_TSPEC_REMOTELY_DELETED ((CsrWifiSmeTspecResultCode) 0x14)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWepAuthMode
+
+ DESCRIPTION
+ Define bits for CsrWifiSmeWepAuthMode
+
+ VALUES
+ CSR_WIFI_SME_WEP_AUTH_MODE_OPEN - Open-WEP enabled network
+ CSR_WIFI_SME_WEP_AUTH_MODE_SHARED - Shared-key WEP enabled network.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeWepAuthMode;
+#define CSR_WIFI_SME_WEP_AUTH_MODE_OPEN ((CsrWifiSmeWepAuthMode) 0x00)
+#define CSR_WIFI_SME_WEP_AUTH_MODE_SHARED ((CsrWifiSmeWepAuthMode) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWepCredentialType
+
+ DESCRIPTION
+ Definition of types of WEP Credentials
+
+ VALUES
+ CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64
+ - WEP 64 credential
+ CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128
+ - WEP 128 credential
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeWepCredentialType;
+#define CSR_WIFI_SME_CREDENTIAL_TYPE_WEP64 ((CsrWifiSmeWepCredentialType) 0x00)
+#define CSR_WIFI_SME_CREDENTIAL_TYPE_WEP128 ((CsrWifiSmeWepCredentialType) 0x01)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWmmMode
+
+ DESCRIPTION
+ Defines bits for CsrWifiSmeWmmModeMask: enable/disable WMM features.
+
+ VALUES
+ CSR_WIFI_SME_WMM_MODE_DISABLED - Disables the WMM features.
+ CSR_WIFI_SME_WMM_MODE_AC_ENABLED - Enables support for WMM-AC.
+ CSR_WIFI_SME_WMM_MODE_PS_ENABLED - Enables support for WMM Power Save.
+ CSR_WIFI_SME_WMM_MODE_SA_ENABLED - Currently not supported
+ CSR_WIFI_SME_WMM_MODE_ENABLED - Enables support for all currently
+ available WMM features.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeWmmMode;
+#define CSR_WIFI_SME_WMM_MODE_DISABLED ((CsrWifiSmeWmmMode) 0x00)
+#define CSR_WIFI_SME_WMM_MODE_AC_ENABLED ((CsrWifiSmeWmmMode) 0x01)
+#define CSR_WIFI_SME_WMM_MODE_PS_ENABLED ((CsrWifiSmeWmmMode) 0x02)
+#define CSR_WIFI_SME_WMM_MODE_SA_ENABLED ((CsrWifiSmeWmmMode) 0x04)
+#define CSR_WIFI_SME_WMM_MODE_ENABLED ((CsrWifiSmeWmmMode) 0xFF)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWmmQosInfo
+
+ DESCRIPTION
+ Defines bits for the QoS Info Octect as defined in the WMM specification.
+ The first four values define one bit each that can be set or cleared.
+ Each of the last four values define all the remaining 4 bits and only one
+ of them at the time shall be used.
+ For more information, see 'WMM (including WMM Power Save) Specification -
+ Version 1.1' and 'UniFi Configuring WMM and WMM-PS, Application Note'.
+
+ VALUES
+ CSR_WIFI_SME_WMM_QOS_INFO_AC_MAX_SP_ALL
+ - WMM AP may deliver all buffered frames
+ CSR_WIFI_SME_WMM_QOS_INFO_AC_VO
+ - Enable UAPSD(both trigger and delivery) for Voice Access
+ Category
+ CSR_WIFI_SME_WMM_QOS_INFO_AC_VI
+ - Enable UAPSD(both trigger and delivery) for Video Access
+ Category
+ CSR_WIFI_SME_WMM_QOS_INFO_AC_BK
+ - Enable UAPSD(both trigger and delivery) for Background
+ Access Category
+ CSR_WIFI_SME_WMM_QOS_INFO_AC_BE
+ - Enable UAPSD(both trigger and delivery) for Best Effort
+ Access Category
+ CSR_WIFI_SME_WMM_QOS_INFO_AC_MAX_SP_TWO
+ - WMM AP may deliver a maximum of 2 buffered frames (MSDUs
+ and MMPDUs) per USP
+ CSR_WIFI_SME_WMM_QOS_INFO_AC_MAX_SP_FOUR
+ - WMM AP may deliver a maximum of 4 buffered frames (MSDUs
+ and MMPDUs) per USP
+ CSR_WIFI_SME_WMM_QOS_INFO_AC_MAX_SP_SIX
+ - WMM AP may deliver a maximum of 6 buffered frames (MSDUs
+ and MMPDUs) per USP
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeWmmQosInfo;
+#define CSR_WIFI_SME_WMM_QOS_INFO_AC_MAX_SP_ALL ((CsrWifiSmeWmmQosInfo) 0x00)
+#define CSR_WIFI_SME_WMM_QOS_INFO_AC_VO ((CsrWifiSmeWmmQosInfo) 0x01)
+#define CSR_WIFI_SME_WMM_QOS_INFO_AC_VI ((CsrWifiSmeWmmQosInfo) 0x02)
+#define CSR_WIFI_SME_WMM_QOS_INFO_AC_BK ((CsrWifiSmeWmmQosInfo) 0x04)
+#define CSR_WIFI_SME_WMM_QOS_INFO_AC_BE ((CsrWifiSmeWmmQosInfo) 0x08)
+#define CSR_WIFI_SME_WMM_QOS_INFO_AC_MAX_SP_TWO ((CsrWifiSmeWmmQosInfo) 0x20)
+#define CSR_WIFI_SME_WMM_QOS_INFO_AC_MAX_SP_FOUR ((CsrWifiSmeWmmQosInfo) 0x40)
+#define CSR_WIFI_SME_WMM_QOS_INFO_AC_MAX_SP_SIX ((CsrWifiSmeWmmQosInfo) 0x60)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsConfigType
+
+ DESCRIPTION
+ WPS config methods supported/used by a device
+
+ VALUES
+ CSR_WIFI_WPS_CONFIG_LABEL
+ - Label
+ CSR_WIFI_WPS_CONFIG_DISPLAY
+ - Display
+ CSR_WIFI_WPS_CONFIG_EXT_NFC
+ - External NFC : Not supported in this release
+ CSR_WIFI_WPS_CONFIG_INT_NFC
+ - Internal NFC : Not supported in this release
+ CSR_WIFI_WPS_CONFIG_NFC_IFACE
+ - NFC interface : Not supported in this release
+ CSR_WIFI_WPS_CONFIG_PBC
+ - PBC
+ CSR_WIFI_WPS_CONFIG_KEYPAD
+ - KeyPad
+ CSR_WIFI_WPS_CONFIG_VIRTUAL_PBC
+ - PBC through software user interface
+ CSR_WIFI_WPS_CONFIG_PHYSICAL_PBC
+ - Physical PBC
+ CSR_WIFI_WPS_CONFIG_VIRTUAL_DISPLAY
+ - Virtual Display : via html config page etc
+ CSR_WIFI_WPS_CONFIG_PHYSICAL_DISPLAY
+ - Physical Display : Attached to the device
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeWpsConfigType;
+#define CSR_WIFI_WPS_CONFIG_LABEL ((CsrWifiSmeWpsConfigType) 0x0004)
+#define CSR_WIFI_WPS_CONFIG_DISPLAY ((CsrWifiSmeWpsConfigType) 0x0008)
+#define CSR_WIFI_WPS_CONFIG_EXT_NFC ((CsrWifiSmeWpsConfigType) 0x0010)
+#define CSR_WIFI_WPS_CONFIG_INT_NFC ((CsrWifiSmeWpsConfigType) 0x0020)
+#define CSR_WIFI_WPS_CONFIG_NFC_IFACE ((CsrWifiSmeWpsConfigType) 0x0040)
+#define CSR_WIFI_WPS_CONFIG_PBC ((CsrWifiSmeWpsConfigType) 0x0080)
+#define CSR_WIFI_WPS_CONFIG_KEYPAD ((CsrWifiSmeWpsConfigType) 0x0100)
+#define CSR_WIFI_WPS_CONFIG_VIRTUAL_PBC ((CsrWifiSmeWpsConfigType) 0x0280)
+#define CSR_WIFI_WPS_CONFIG_PHYSICAL_PBC ((CsrWifiSmeWpsConfigType) 0x0480)
+#define CSR_WIFI_WPS_CONFIG_VIRTUAL_DISPLAY ((CsrWifiSmeWpsConfigType) 0x2008)
+#define CSR_WIFI_WPS_CONFIG_PHYSICAL_DISPLAY ((CsrWifiSmeWpsConfigType) 0x4008)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsDeviceCategory
+
+ DESCRIPTION
+ Wps Primary Device Types
+
+ VALUES
+ CSR_WIFI_SME_WPS_CATEGORY_UNSPECIFIED
+ - Unspecified.
+ CSR_WIFI_SME_WPS_CATEGORY_COMPUTER
+ - Computer.
+ CSR_WIFI_SME_WPS_CATEGORY_INPUT_DEV
+ - Input device
+ CSR_WIFI_SME_WPS_CATEGORY_PRT_SCAN_FX_CP
+ - Printer Scanner Fax Copier etc
+ CSR_WIFI_SME_WPS_CATEGORY_CAMERA
+ - Camera
+ CSR_WIFI_SME_WPS_CATEGORY_STORAGE
+ - Storage
+ CSR_WIFI_SME_WPS_CATEGORY_NET_INFRA
+ - Net Infra
+ CSR_WIFI_SME_WPS_CATEGORY_DISPLAY
+ - Display
+ CSR_WIFI_SME_WPS_CATEGORY_MULTIMEDIA
+ - Multimedia
+ CSR_WIFI_SME_WPS_CATEGORY_GAMING
+ - Gaming.
+ CSR_WIFI_SME_WPS_CATEGORY_TELEPHONE
+ - Telephone.
+ CSR_WIFI_SME_WPS_CATEGORY_AUDIO
+ - Audio
+ CSR_WIFI_SME_WPS_CATEOARY_OTHERS
+ - Others.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeWpsDeviceCategory;
+#define CSR_WIFI_SME_WPS_CATEGORY_UNSPECIFIED ((CsrWifiSmeWpsDeviceCategory) 0x00)
+#define CSR_WIFI_SME_WPS_CATEGORY_COMPUTER ((CsrWifiSmeWpsDeviceCategory) 0x01)
+#define CSR_WIFI_SME_WPS_CATEGORY_INPUT_DEV ((CsrWifiSmeWpsDeviceCategory) 0x02)
+#define CSR_WIFI_SME_WPS_CATEGORY_PRT_SCAN_FX_CP ((CsrWifiSmeWpsDeviceCategory) 0x03)
+#define CSR_WIFI_SME_WPS_CATEGORY_CAMERA ((CsrWifiSmeWpsDeviceCategory) 0x04)
+#define CSR_WIFI_SME_WPS_CATEGORY_STORAGE ((CsrWifiSmeWpsDeviceCategory) 0x05)
+#define CSR_WIFI_SME_WPS_CATEGORY_NET_INFRA ((CsrWifiSmeWpsDeviceCategory) 0x06)
+#define CSR_WIFI_SME_WPS_CATEGORY_DISPLAY ((CsrWifiSmeWpsDeviceCategory) 0x07)
+#define CSR_WIFI_SME_WPS_CATEGORY_MULTIMEDIA ((CsrWifiSmeWpsDeviceCategory) 0x08)
+#define CSR_WIFI_SME_WPS_CATEGORY_GAMING ((CsrWifiSmeWpsDeviceCategory) 0x09)
+#define CSR_WIFI_SME_WPS_CATEGORY_TELEPHONE ((CsrWifiSmeWpsDeviceCategory) 0x0A)
+#define CSR_WIFI_SME_WPS_CATEGORY_AUDIO ((CsrWifiSmeWpsDeviceCategory) 0x0B)
+#define CSR_WIFI_SME_WPS_CATEOARY_OTHERS ((CsrWifiSmeWpsDeviceCategory) 0xFF)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsDeviceSubCategory
+
+ DESCRIPTION
+ Wps Secondary Device Types
+
+ VALUES
+ CSR_WIFI_SME_WPS_SUB_CATEGORY_UNSPECIFIED
+ - Unspecied
+ CSR_WIFI_SME_WPS_STORAGE_SUB_CATEGORY_NAS
+ - Network Associated Storage
+ CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_PRNTR
+ - Printer or print server
+ CSR_WIFI_SME_WPS_TELEPHONE_SUB_CATEGORY_WM
+ - Windows mobile
+ CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_TUNER
+ - Audio tuner/receiver
+ CSR_WIFI_SME_WPS_CAMERA_SUB_CATEGORY_DIG_STL
+ - Digital still camera
+ CSR_WIFI_SME_WPS_NET_INFRA_SUB_CATEGORY_AP
+ - Access Point
+ CSR_WIFI_SME_WPS_DISPLAY_SUB_CATEGORY_TV
+ - TV.
+ CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_DAR
+ - DAR.
+ CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_KEYBD
+ - Keyboard.
+ CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_PC
+ - PC.
+ CSR_WIFI_SME_WPS_GAMING_SUB_CATEGORY_XBOX
+ - Xbox.
+ CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_SCNR
+ - Scanner
+ CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_SERVER
+ - Server
+ CSR_WIFI_SME_WPS_NET_INFRA_SUB_CATEGORY_ROUTER
+ - Router
+ CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_PVR
+ - PVR
+ CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_SPEAKER
+ - Speaker
+ CSR_WIFI_SME_WPS_TELEPHONE_SUB_CATEGORY_FP_SM
+ - Feature phone - Single mode
+ CSR_WIFI_SME_WPS_CAMERA_SUB_CATEGORY_VIDEO
+ - Video camera
+ CSR_WIFI_SME_WPS_DISPLAY_SUB_CATEGORY_PIC_FRM
+ - Picture frame
+ CSR_WIFI_SME_WPS_GAMING_SUB_CATEGORY_XBOX_360
+ - Xbox360
+ CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_MOUSE
+ - Mouse
+ CSR_WIFI_SME_WPS_NET_INFRA_SUB_CATEGORY_SWITCH
+ - Switch
+ CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_PMP
+ - Portable music player
+ CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_JOYSTK
+ - Joy stick
+ CSR_WIFI_SME_WPS_GAMING_SUB_CATEGORY_PLAY_STN
+ - Play-station
+ CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_MED_CENT
+ - Media Center
+ CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_MCX
+ - MCX
+ CSR_WIFI_SME_WPS_TELEPHONE_SUB_CATEGORY_FP_DM
+ - Feature phone - Dual mode
+ CSR_WIFI_SME_WPS_CAMERA_SUB_CATEGORY_WEB
+ - Web camera
+ CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_FAX
+ - Fax
+ CSR_WIFI_SME_WPS_DISPLAY_SUB_CATEGORY_PROJECTOR
+ - Projector
+ CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_TRKBL
+ - Track Ball
+ CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_ST_BOX
+ - Set-Top-Box
+ CSR_WIFI_SME_WPS_NET_INFRA_SUB_CATEGORY_GATEWAY
+ - GateWay.
+ CSR_WIFI_SME_WPS_CAMERA_SUB_CATEGORY_SECURITY
+ - Security camera
+ CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_ULTRA_MOB_PC
+ - Ultra mobile PC.
+ CSR_WIFI_SME_WPS_GAMING_SUB_CATEGORY_CONSOLE
+ - Game console/Game console adapter
+ CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_CPR
+ - Copier
+ CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_HEADSET
+ - Headset(headphones + microphone)
+ CSR_WIFI_SME_WPS_TELEPHONE_SUB_CATEGORY_SP_SM
+ - Smart phone - Single mode
+ CSR_WIFI_SME_WPS_DISPLAY_SUB_CATEGORY_MONITOR
+ - Monitor.
+ CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_GAME_CTRL
+ - Game control.
+ CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_ALL
+ - All-in-One
+ CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_MEDIA
+ - Media Server/Media Adapter/Media Extender
+ CSR_WIFI_SME_WPS_TELEPHONE_SUB_CATEGORY_SP_DM
+ - Smart phone - Dual mode
+ CSR_WIFI_SME_WPS_GAMING_SUB_CATEGORY_PORT_DEV
+ - Portable gaming device
+ CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_HEADPHONE
+ - Headphone.
+ CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_NOTEBOOK
+ - Notebook.
+ CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_REMOTE
+ - Remote control
+ CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_MIC
+ - Microphone
+ CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_DESKTOP
+ - Desktop.
+ CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_VP
+ - Portable video player
+ CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_MID
+ - Mobile internet device
+ CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_TOUCH_SCRN
+ - Touch screen
+ CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_BIOMET_RDR
+ - Biometric reader
+ CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_NETBOOK
+ - Netbook
+ CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_BRCD_RDR
+ - Bar code reader.
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeWpsDeviceSubCategory;
+#define CSR_WIFI_SME_WPS_SUB_CATEGORY_UNSPECIFIED ((CsrWifiSmeWpsDeviceSubCategory) 0x00)
+#define CSR_WIFI_SME_WPS_STORAGE_SUB_CATEGORY_NAS ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_PRNTR ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_TELEPHONE_SUB_CATEGORY_WM ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_TUNER ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_CAMERA_SUB_CATEGORY_DIG_STL ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_NET_INFRA_SUB_CATEGORY_AP ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_DISPLAY_SUB_CATEGORY_TV ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_DAR ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_KEYBD ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_PC ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_GAMING_SUB_CATEGORY_XBOX ((CsrWifiSmeWpsDeviceSubCategory) 0x01)
+#define CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_SCNR ((CsrWifiSmeWpsDeviceSubCategory) 0x02)
+#define CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_SERVER ((CsrWifiSmeWpsDeviceSubCategory) 0x02)
+#define CSR_WIFI_SME_WPS_NET_INFRA_SUB_CATEGORY_ROUTER ((CsrWifiSmeWpsDeviceSubCategory) 0x02)
+#define CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_PVR ((CsrWifiSmeWpsDeviceSubCategory) 0x02)
+#define CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_SPEAKER ((CsrWifiSmeWpsDeviceSubCategory) 0x02)
+#define CSR_WIFI_SME_WPS_TELEPHONE_SUB_CATEGORY_FP_SM ((CsrWifiSmeWpsDeviceSubCategory) 0x02)
+#define CSR_WIFI_SME_WPS_CAMERA_SUB_CATEGORY_VIDEO ((CsrWifiSmeWpsDeviceSubCategory) 0x02)
+#define CSR_WIFI_SME_WPS_DISPLAY_SUB_CATEGORY_PIC_FRM ((CsrWifiSmeWpsDeviceSubCategory) 0x02)
+#define CSR_WIFI_SME_WPS_GAMING_SUB_CATEGORY_XBOX_360 ((CsrWifiSmeWpsDeviceSubCategory) 0x02)
+#define CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_MOUSE ((CsrWifiSmeWpsDeviceSubCategory) 0x02)
+#define CSR_WIFI_SME_WPS_NET_INFRA_SUB_CATEGORY_SWITCH ((CsrWifiSmeWpsDeviceSubCategory) 0x03)
+#define CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_PMP ((CsrWifiSmeWpsDeviceSubCategory) 0x03)
+#define CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_JOYSTK ((CsrWifiSmeWpsDeviceSubCategory) 0x03)
+#define CSR_WIFI_SME_WPS_GAMING_SUB_CATEGORY_PLAY_STN ((CsrWifiSmeWpsDeviceSubCategory) 0x03)
+#define CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_MED_CENT ((CsrWifiSmeWpsDeviceSubCategory) 0x03)
+#define CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_MCX ((CsrWifiSmeWpsDeviceSubCategory) 0x03)
+#define CSR_WIFI_SME_WPS_TELEPHONE_SUB_CATEGORY_FP_DM ((CsrWifiSmeWpsDeviceSubCategory) 0x03)
+#define CSR_WIFI_SME_WPS_CAMERA_SUB_CATEGORY_WEB ((CsrWifiSmeWpsDeviceSubCategory) 0x03)
+#define CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_FAX ((CsrWifiSmeWpsDeviceSubCategory) 0x03)
+#define CSR_WIFI_SME_WPS_DISPLAY_SUB_CATEGORY_PROJECTOR ((CsrWifiSmeWpsDeviceSubCategory) 0x03)
+#define CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_TRKBL ((CsrWifiSmeWpsDeviceSubCategory) 0x04)
+#define CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_ST_BOX ((CsrWifiSmeWpsDeviceSubCategory) 0x04)
+#define CSR_WIFI_SME_WPS_NET_INFRA_SUB_CATEGORY_GATEWAY ((CsrWifiSmeWpsDeviceSubCategory) 0x04)
+#define CSR_WIFI_SME_WPS_CAMERA_SUB_CATEGORY_SECURITY ((CsrWifiSmeWpsDeviceSubCategory) 0x04)
+#define CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_ULTRA_MOB_PC ((CsrWifiSmeWpsDeviceSubCategory) 0x04)
+#define CSR_WIFI_SME_WPS_GAMING_SUB_CATEGORY_CONSOLE ((CsrWifiSmeWpsDeviceSubCategory) 0x04)
+#define CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_CPR ((CsrWifiSmeWpsDeviceSubCategory) 0x04)
+#define CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_HEADSET ((CsrWifiSmeWpsDeviceSubCategory) 0x04)
+#define CSR_WIFI_SME_WPS_TELEPHONE_SUB_CATEGORY_SP_SM ((CsrWifiSmeWpsDeviceSubCategory) 0x04)
+#define CSR_WIFI_SME_WPS_DISPLAY_SUB_CATEGORY_MONITOR ((CsrWifiSmeWpsDeviceSubCategory) 0x04)
+#define CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_GAME_CTRL ((CsrWifiSmeWpsDeviceSubCategory) 0x05)
+#define CSR_WIFI_SME_WPS_PSFC_SUB_CATEGORY_ALL ((CsrWifiSmeWpsDeviceSubCategory) 0x05)
+#define CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_MEDIA ((CsrWifiSmeWpsDeviceSubCategory) 0x05)
+#define CSR_WIFI_SME_WPS_TELEPHONE_SUB_CATEGORY_SP_DM ((CsrWifiSmeWpsDeviceSubCategory) 0x05)
+#define CSR_WIFI_SME_WPS_GAMING_SUB_CATEGORY_PORT_DEV ((CsrWifiSmeWpsDeviceSubCategory) 0x05)
+#define CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_HEADPHONE ((CsrWifiSmeWpsDeviceSubCategory) 0x05)
+#define CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_NOTEBOOK ((CsrWifiSmeWpsDeviceSubCategory) 0x05)
+#define CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_REMOTE ((CsrWifiSmeWpsDeviceSubCategory) 0x06)
+#define CSR_WIFI_SME_WPS_AUDIO_SUB_CATEGORY_MIC ((CsrWifiSmeWpsDeviceSubCategory) 0x06)
+#define CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_DESKTOP ((CsrWifiSmeWpsDeviceSubCategory) 0x06)
+#define CSR_WIFI_SME_WPS_MM_SUB_CATEGORY_VP ((CsrWifiSmeWpsDeviceSubCategory) 0x06)
+#define CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_MID ((CsrWifiSmeWpsDeviceSubCategory) 0x07)
+#define CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_TOUCH_SCRN ((CsrWifiSmeWpsDeviceSubCategory) 0x07)
+#define CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_BIOMET_RDR ((CsrWifiSmeWpsDeviceSubCategory) 0x08)
+#define CSR_WIFI_SME_WPS_COMPUTER_SUB_CATEGORY_NETBOOK ((CsrWifiSmeWpsDeviceSubCategory) 0x08)
+#define CSR_WIFI_SME_WPS_INPUT_DEV_SUB_CATEGORY_BRCD_RDR ((CsrWifiSmeWpsDeviceSubCategory) 0x09)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsDpid
+
+ DESCRIPTION
+ Device Password ID for the chosen config method
+
+ VALUES
+ CSR_WIFI_SME_WPS_DPID_PIN - PIN
+ CSR_WIFI_SME_WPS_DPID_USER - User specified : Used only during P2P GO
+ negotiation procedure
+ CSR_WIFI_SME_WPS_DPID_MACHINE - Machine specified i: Not used in this
+ release
+ CSR_WIFI_SME_WPS_DPID_REKEY - Rekey : Not used in this release
+ CSR_WIFI_SME_WPS_DPID_PBC - PBC
+ CSR_WIFI_SME_WPS_DPID_REGISTRAR - Registrar specified : Used only in P2P Go
+ negotiation procedure
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeWpsDpid;
+#define CSR_WIFI_SME_WPS_DPID_PIN ((CsrWifiSmeWpsDpid) 0x0000)
+#define CSR_WIFI_SME_WPS_DPID_USER ((CsrWifiSmeWpsDpid) 0x0001)
+#define CSR_WIFI_SME_WPS_DPID_MACHINE ((CsrWifiSmeWpsDpid) 0x0002)
+#define CSR_WIFI_SME_WPS_DPID_REKEY ((CsrWifiSmeWpsDpid) 0x0003)
+#define CSR_WIFI_SME_WPS_DPID_PBC ((CsrWifiSmeWpsDpid) 0x0004)
+#define CSR_WIFI_SME_WPS_DPID_REGISTRAR ((CsrWifiSmeWpsDpid) 0x0005)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsRegistration
+
+ DESCRIPTION
+
+ VALUES
+ CSR_WIFI_SME_WPS_REG_NOT_REQUIRED - No encryption set
+ CSR_WIFI_SME_WPS_REG_REQUIRED - No encryption set
+ CSR_WIFI_SME_WPS_REG_UNKNOWN - No encryption set
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeWpsRegistration;
+#define CSR_WIFI_SME_WPS_REG_NOT_REQUIRED ((CsrWifiSmeWpsRegistration) 0x00)
+#define CSR_WIFI_SME_WPS_REG_REQUIRED ((CsrWifiSmeWpsRegistration) 0x01)
+#define CSR_WIFI_SME_WPS_REG_UNKNOWN ((CsrWifiSmeWpsRegistration) 0x02)
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAuthModeMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeAuthMode
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeAuthModeMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeEncryptionMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeEncryption
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeEncryptionMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeIndicationsMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeIndications
+
+*******************************************************************************/
+typedef CsrUint32 CsrWifiSmeIndicationsMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeP2pCapabilityMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeP2pCapability
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeP2pCapabilityMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeP2pGroupCapabilityMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeP2pGroupCapability
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeP2pGroupCapabilityMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTspecCtrlMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeTspecCtrl
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeTspecCtrlMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWmmModeMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeWmmMode
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeWmmModeMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWmmQosInfoMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeWmmQosInfo
+
+*******************************************************************************/
+typedef CsrUint8 CsrWifiSmeWmmQosInfoMask;
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsConfigTypeMask
+
+ DESCRIPTION
+ Mask type for use with the values defined by CsrWifiSmeWpsConfigType
+
+*******************************************************************************/
+typedef CsrUint16 CsrWifiSmeWpsConfigTypeMask;
+
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAdHocConfig
+
+ DESCRIPTION
+ Defines values to use when starting an Ad-hoc (IBSS) network.
+
+ MEMBERS
+ atimWindowTu - ATIM window specified for IBSS
+ beaconPeriodTu - Interval between beacon packets
+ joinOnlyAttempts - Maximum number of attempts to join an ad-hoc network.
+ The default value is 1.
+ Set to 0 for infinite attempts.
+ joinAttemptIntervalMs - Time between scans for joining the requested IBSS.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint16 atimWindowTu;
+ CsrUint16 beaconPeriodTu;
+ CsrUint16 joinOnlyAttempts;
+ CsrUint16 joinAttemptIntervalMs;
+} CsrWifiSmeAdHocConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAvailabilityConfig
+
+ DESCRIPTION
+
+ MEMBERS
+ listenChannel -
+ availabilityDuration -
+ avalabilityPeriod -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 listenChannel;
+ CsrUint16 availabilityDuration;
+ CsrUint16 avalabilityPeriod;
+} CsrWifiSmeAvailabilityConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCcxConfig
+
+ DESCRIPTION
+ This type is reserved for future use and should not be used.
+
+ MEMBERS
+ keepAliveTimeMs - NOT USED
+ apRoamingEnabled - NOT USED
+ measurementsMask - NOT USED
+ ccxRadioMgtEnabled - NOT USED
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 keepAliveTimeMs;
+ CsrBool apRoamingEnabled;
+ CsrUint8 measurementsMask;
+ CsrBool ccxRadioMgtEnabled;
+} CsrWifiSmeCcxConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexConfig
+
+ DESCRIPTION
+ Parameters for the coexistence behaviour.
+
+ MEMBERS
+ coexEnableSchemeManagement - Enables the Coexistence Management Scheme
+ coexPeriodicWakeHost - If TRUE the firmware wakes up the host
+ periodically according to the traffic
+ period and latency parameters; the host
+ will then send the data to transmit only
+ when woken up.
+ If FALSE, the firmware does not wake up the
+ host and the host will send the data to
+ transmit to the firmware whenever there is
+ data to transmit
+ coexTrafficBurstyLatencyMs - Period of awakening for the firmware used
+ when bursty traffic is detected
+ coexTrafficContinuousLatencyMs - Period of awakening for the firmware used
+ when continuous traffic is detected
+ coexObexBlackoutDurationMs - Blackout Duration when a Obex Connection is
+ used
+ coexObexBlackoutPeriodMs - Blackout Period when a Obex Connection is
+ used
+ coexA2dpBrBlackoutDurationMs - Blackout Duration when a Basic Rate A2DP
+ Connection streaming data
+ coexA2dpBrBlackoutPeriodMs - Blackout Period when a Basic Rate A2DP
+ Connection streaming data
+ coexA2dpEdrBlackoutDurationMs - Blackout Duration when an Enhanced Data
+ Rate A2DP Connection streaming data
+ coexA2dpEdrBlackoutPeriodMs - Blackout Period when an Enhanced Data Rate
+ A2DP Connection streaming data
+ coexPagingBlackoutDurationMs - Blackout Duration when a BT page is active
+ coexPagingBlackoutPeriodMs - Blackout Period when a BT page is active
+ coexInquiryBlackoutDurationMs - Blackout Duration when a BT inquiry is
+ active
+ coexInquiryBlackoutPeriodMs - Blackout Period when a BT inquiry is active
+
+*******************************************************************************/
+typedef struct
+{
+ CsrBool coexEnableSchemeManagement;
+ CsrBool coexPeriodicWakeHost;
+ CsrUint16 coexTrafficBurstyLatencyMs;
+ CsrUint16 coexTrafficContinuousLatencyMs;
+ CsrUint16 coexObexBlackoutDurationMs;
+ CsrUint16 coexObexBlackoutPeriodMs;
+ CsrUint16 coexA2dpBrBlackoutDurationMs;
+ CsrUint16 coexA2dpBrBlackoutPeriodMs;
+ CsrUint16 coexA2dpEdrBlackoutDurationMs;
+ CsrUint16 coexA2dpEdrBlackoutPeriodMs;
+ CsrUint16 coexPagingBlackoutDurationMs;
+ CsrUint16 coexPagingBlackoutPeriodMs;
+ CsrUint16 coexInquiryBlackoutDurationMs;
+ CsrUint16 coexInquiryBlackoutPeriodMs;
+} CsrWifiSmeCoexConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionStats
+
+ DESCRIPTION
+ Indicates the statistics of the connection.
+ The dot11 fields are defined in the Annex D of the IEEE 802.11 standard.
+
+ MEMBERS
+ unifiTxDataRate
+ - The bit rate currently in use for transmissions of unicast
+ data frames; a data rate in units of 500kbit/s.
+ On an infrastructure BSS, this is the data rate used in
+ communicating with the associated access point; if there is
+ none, an error is returned.
+ On an IBSS, this is the data rate used for the last
+ transmission of a unicast data frame to any station in the
+ IBSS. If no such transmission has been made, an error is
+ returned.
+ unifiRxDataRate
+ - As above for receiving data
+ dot11RetryCount
+ - See IEEE 802.11 Standard
+ dot11MultipleRetryCount
+ - See IEEE 802.11 Standard
+ dot11AckFailureCount
+ - See IEEE 802.11 Standard
+ dot11FrameDuplicateCount
+ - See IEEE 802.11 Standard
+ dot11FcsErrorCount
+ - See IEEE 802.11 Standard
+ dot11RtsSuccessCount
+ - See IEEE 802.11 Standard
+ dot11RtsFailureCount
+ - See IEEE 802.11 Standard
+ dot11FailedCount
+ - See IEEE 802.11 Standard
+ dot11TransmittedFragmentCount
+ - See IEEE 802.11 Standard
+ dot11TransmittedFrameCount
+ - See IEEE 802.11 Standard
+ dot11WepExcludedCount
+ - See IEEE 802.11 Standard
+ dot11WepIcvErrorCount
+ - See IEEE 802.11 Standard
+ dot11WepUndecryptableCount
+ - See IEEE 802.11 Standard
+ dot11MulticastReceivedFrameCount
+ - See IEEE 802.11 Standard
+ dot11MulticastTransmittedFrameCount
+ - See IEEE 802.11 Standard
+ dot11ReceivedFragmentCount
+ - See IEEE 802.11 Standard
+ dot11Rsna4WayHandshakeFailures
+ - See IEEE 802.11 Standard
+ dot11RsnaTkipCounterMeasuresInvoked
+ - See IEEE 802.11 Standard
+ dot11RsnaStatsTkipLocalMicFailures
+ - See IEEE 802.11 Standard
+ dot11RsnaStatsTkipReplays
+ - See IEEE 802.11 Standard
+ dot11RsnaStatsTkipIcvErrors
+ - See IEEE 802.11 Standard
+ dot11RsnaStatsCcmpReplays
+ - See IEEE 802.11 Standard
+ dot11RsnaStatsCcmpDecryptErrors
+ - See IEEE 802.11 Standard
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 unifiTxDataRate;
+ CsrUint8 unifiRxDataRate;
+ CsrUint32 dot11RetryCount;
+ CsrUint32 dot11MultipleRetryCount;
+ CsrUint32 dot11AckFailureCount;
+ CsrUint32 dot11FrameDuplicateCount;
+ CsrUint32 dot11FcsErrorCount;
+ CsrUint32 dot11RtsSuccessCount;
+ CsrUint32 dot11RtsFailureCount;
+ CsrUint32 dot11FailedCount;
+ CsrUint32 dot11TransmittedFragmentCount;
+ CsrUint32 dot11TransmittedFrameCount;
+ CsrUint32 dot11WepExcludedCount;
+ CsrUint32 dot11WepIcvErrorCount;
+ CsrUint32 dot11WepUndecryptableCount;
+ CsrUint32 dot11MulticastReceivedFrameCount;
+ CsrUint32 dot11MulticastTransmittedFrameCount;
+ CsrUint32 dot11ReceivedFragmentCount;
+ CsrUint32 dot11Rsna4WayHandshakeFailures;
+ CsrUint32 dot11RsnaTkipCounterMeasuresInvoked;
+ CsrUint32 dot11RsnaStatsTkipLocalMicFailures;
+ CsrUint32 dot11RsnaStatsTkipReplays;
+ CsrUint32 dot11RsnaStatsTkipIcvErrors;
+ CsrUint32 dot11RsnaStatsCcmpReplays;
+ CsrUint32 dot11RsnaStatsCcmpDecryptErrors;
+} CsrWifiSmeConnectionStats;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDataBlock
+
+ DESCRIPTION
+ Holds a generic data block to be passed through the interface
+
+ MEMBERS
+ length - Length of the data block
+ data - Points to the first byte of the data block
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint16 length;
+ CsrUint8 *data;
+} CsrWifiSmeDataBlock;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeEmpty
+
+ DESCRIPTION
+ Empty Structure to indicate that no parameters are available.
+
+ MEMBERS
+ empty - Only element of the empty structure (always set to 0).
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 empty;
+} CsrWifiSmeEmpty;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeLinkQuality
+
+ DESCRIPTION
+ Indicates the quality of the link
+
+ MEMBERS
+ unifiRssi - Indicates the received signal strength indication of the link in
+ dBm
+ unifiSnr - Indicates the signal to noise ratio of the link in dB
+
+*******************************************************************************/
+typedef struct
+{
+ CsrInt16 unifiRssi;
+ CsrInt16 unifiSnr;
+} CsrWifiSmeLinkQuality;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibConfig
+
+ DESCRIPTION
+ Allows low level configuration in the chip.
+
+ MEMBERS
+ unifiFixMaxTxDataRate - This attribute is used in combination with
+ unifiFixTxDataRate. If it is FALSE, then
+ unifiFixTxDataRate specifies a specific data
+ rate to use. If it is TRUE, unifiFixTxDataRate
+ instead specifies a maximum data rate.
+ unifiFixTxDataRate - Transmit rate for unicast data.
+ See MIB description for more details
+ dot11RtsThreshold - See IEEE 802.11 Standard
+ dot11FragmentationThreshold - See IEEE 802.11 Standard
+ dot11CurrentTxPowerLevel - See IEEE 802.11 Standard
+
+*******************************************************************************/
+typedef struct
+{
+ CsrBool unifiFixMaxTxDataRate;
+ CsrUint8 unifiFixTxDataRate;
+ CsrUint16 dot11RtsThreshold;
+ CsrUint16 dot11FragmentationThreshold;
+ CsrUint16 dot11CurrentTxPowerLevel;
+} CsrWifiSmeMibConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeP2pProfileIdentity
+
+ DESCRIPTION
+ Details to be filled in
+
+ MEMBERS
+ listenChannel -
+ availabilityDuration -
+ avalabilityPeriod -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 listenChannel;
+ CsrUint16 availabilityDuration;
+ CsrUint16 avalabilityPeriod;
+} CsrWifiSmeP2pProfileIdentity;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePmkid
+
+ DESCRIPTION
+ Defines a PMKID association with BSS
+
+ MEMBERS
+ bssid - BSS identifier
+ pmkid - PMKID
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiMacAddress bssid;
+ CsrUint8 pmkid[16];
+} CsrWifiSmePmkid;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePmkidCandidate
+
+ DESCRIPTION
+ Information for a PMKID candidate
+
+ MEMBERS
+ bssid - BSS identifier
+ preAuthAllowed - Indicates whether preauthentication is allowed
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiMacAddress bssid;
+ CsrBool preAuthAllowed;
+} CsrWifiSmePmkidCandidate;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePmkidList
+
+ DESCRIPTION
+ NOT USED
+ Used in the Sync access API
+
+ MEMBERS
+ pmkidsCount - Number of PMKIDs in the list
+ pmkids - Points to the first PMKID in the list
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 pmkidsCount;
+ CsrWifiSmePmkid *pmkids;
+} CsrWifiSmePmkidList;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRegulatoryDomainInfo
+
+ DESCRIPTION
+ Regulatory domain options.
+
+ MEMBERS
+ dot11MultiDomainCapabilityImplemented
+ - TRUE is the multi domain capability is implemented
+ dot11MultiDomainCapabilityEnabled
+ - TRUE is the multi domain capability is enabled
+ currentRegulatoryDomain
+ - Current regulatory domain
+ currentCountryCode
+ - Current country code as defined by the IEEE 802.11
+ standards
+
+*******************************************************************************/
+typedef struct
+{
+ CsrBool dot11MultiDomainCapabilityImplemented;
+ CsrBool dot11MultiDomainCapabilityEnabled;
+ CsrWifiSmeRegulatoryDomain currentRegulatoryDomain;
+ CsrUint8 currentCountryCode[2];
+} CsrWifiSmeRegulatoryDomainInfo;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamingBandData
+
+ DESCRIPTION
+ Thresholds to define one usability level category for the received signal
+
+ MEMBERS
+ rssiHighThreshold - Received Signal Strength Indication upper bound in dBm
+ for the usability level
+ rssiLowThreshold - Received Signal Strength Indication lower bound in dBm
+ for the usability level
+ snrHighThreshold - Signal to Noise Ratio upper bound in dB for the
+ usability level
+ snrLowThreshold - Signal to Noise Ratio lower bound in dB for the
+ usability level
+
+*******************************************************************************/
+typedef struct
+{
+ CsrInt16 rssiHighThreshold;
+ CsrInt16 rssiLowThreshold;
+ CsrInt16 snrHighThreshold;
+ CsrInt16 snrLowThreshold;
+} CsrWifiSmeRoamingBandData;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanConfigData
+
+ DESCRIPTION
+ Configures the scanning behaviour of the driver and firmware
+
+ MEMBERS
+ intervalSeconds - All the channels will be scanned once in this time
+ interval.
+ If connected, the channel scans are spread across
+ the interval.
+ If disconnected, all the channels will be scanned
+ together
+ validitySeconds - How long the scan result are cached
+ minActiveChannelTimeTu - Minimum time of listening on a channel being
+ actively scanned before leaving if no probe
+ responses or beacon frames have been received
+ maxActiveChannelTimeTu - Maximum time of listening on a channel being
+ actively scanned
+ minPassiveChannelTimeTu - Minimum time of listening on a channel being
+ passive scanned before leaving if no beacon frames
+ have been received
+ maxPassiveChannelTimeTu - Maximum time of listening on a channel being
+ passively scanned
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint16 intervalSeconds;
+ CsrUint16 validitySeconds;
+ CsrUint16 minActiveChannelTimeTu;
+ CsrUint16 maxActiveChannelTimeTu;
+ CsrUint16 minPassiveChannelTimeTu;
+ CsrUint16 maxPassiveChannelTimeTu;
+} CsrWifiSmeScanConfigData;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTsfTime
+
+ DESCRIPTION
+ Time stamp representation
+
+ MEMBERS
+ data - TSF Bytes
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 data[8];
+} CsrWifiSmeTsfTime;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeVersions
+
+ DESCRIPTION
+ Reports version information for the chip, the firmware and the driver and
+ the SME.
+
+ MEMBERS
+ chipId - Chip ID
+ chipVersion - Chip version ID
+ firmwareBuild - Firmware Rom build number
+ firmwarePatch - Firmware Patch build number (if applicable)
+ firmwareHip - Firmware HIP protocol version number
+ routerBuild - Router build number
+ routerHip - Router HIP protocol version number
+ smeBuild - SME build number
+ smeHip - SME HIP protocol version number
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint32 chipId;
+ CsrUint32 chipVersion;
+ CsrUint32 firmwareBuild;
+ CsrUint32 firmwarePatch;
+ CsrUint32 firmwareHip;
+ CsrCharString *routerBuild;
+ CsrUint32 routerHip;
+ CsrCharString *smeBuild;
+ CsrUint32 smeHip;
+} CsrWifiSmeVersions;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWmmAcParams
+
+ DESCRIPTION
+ Structure holding WMM AC params data.
+
+ MEMBERS
+ cwMin - Exponent for the calculation of CWmin. Range: 0
+ to 15
+ cwMax - Exponent for the calculation of CWmax. Range: 0
+ to15
+ aifs - Arbitration Inter Frame Spacing in terms of
+ number of timeslots. Range 2 to 15
+ txopLimit - TXOP Limit in the units of 32 microseconds
+ admissionControlMandatory - Indicates whether the admission control is
+ mandatory or not. Current release does not
+ support admission control , hence shall be set
+ to FALSE.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 cwMin;
+ CsrUint8 cwMax;
+ CsrUint8 aifs;
+ CsrUint16 txopLimit;
+ CsrBool admissionControlMandatory;
+} CsrWifiSmeWmmAcParams;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsDeviceType
+
+ DESCRIPTION
+ Structure holding AP WPS device type data.
+
+ MEMBERS
+ deviceDetails - category , sub category etc
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 deviceDetails[8];
+} CsrWifiSmeWpsDeviceType;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsDeviceTypeCommon
+
+ DESCRIPTION
+
+ MEMBERS
+ spportWps -
+ deviceType -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrBool spportWps;
+ CsrUint8 deviceType;
+} CsrWifiSmeWpsDeviceTypeCommon;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsInfo
+
+ DESCRIPTION
+
+ MEMBERS
+ version -
+ configMethods -
+ devicePassworId -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint16 version;
+ CsrUint16 configMethods;
+ CsrUint16 devicePassworId;
+} CsrWifiSmeWpsInfo;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCloakedSsidConfig
+
+ DESCRIPTION
+ List of cloaked SSIDs .
+
+ MEMBERS
+ cloakedSsidsCount - Number of cloaked SSID
+ cloakedSsids - Points to the first byte of the first SSID provided
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 cloakedSsidsCount;
+ CsrWifiSsid *cloakedSsids;
+} CsrWifiSmeCloakedSsidConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexInfo
+
+ DESCRIPTION
+ Information and state related to coexistence.
+
+ MEMBERS
+ hasTrafficData - TRUE if any Wi-Fi traffic is detected
+ currentTrafficType - Current type of traffic
+ currentPeriodMs - Period of the traffic as detected by the traffic
+ analysis.
+ If the traffic is not periodic, it is set to 0.
+ currentPowerSave - Current power save level
+ currentCoexPeriodMs - Period of awakening for the firmware used when
+ periodic traffic is detected.
+ If the traffic is not periodic, it is set to 0.
+ currentCoexLatencyMs - Period of awakening for the firmware used when
+ non-periodic traffic is detected
+ hasBtDevice - TRUE if there is a Bluetooth device connected
+ currentBlackoutDurationUs - Current blackout duration for protecting
+ Bluetooth
+ currentBlackoutPeriodUs - Current blackout period
+ currentCoexScheme - Defines the scheme for the coexistence
+ signalling
+
+*******************************************************************************/
+typedef struct
+{
+ CsrBool hasTrafficData;
+ CsrWifiSmeTrafficType currentTrafficType;
+ CsrUint16 currentPeriodMs;
+ CsrWifiSmePowerSaveLevel currentPowerSave;
+ CsrUint16 currentCoexPeriodMs;
+ CsrUint16 currentCoexLatencyMs;
+ CsrBool hasBtDevice;
+ CsrUint32 currentBlackoutDurationUs;
+ CsrUint32 currentBlackoutPeriodUs;
+ CsrWifiSmeCoexScheme currentCoexScheme;
+} CsrWifiSmeCoexInfo;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionConfig
+
+ DESCRIPTION
+ Specifies the parameters that the SME should use in selecting a network.
+
+ MEMBERS
+ ssid
+ - Service Set identifier
+ bssid
+ - BSS identifier
+ bssType
+ - Indicates the type of BSS
+ ifIndex
+ - Indicates the radio interface
+ privacyMode
+ - Specifies whether the privacy mode is enabled or disabled.
+ authModeMask
+ - Sets the authentication options that the SME can use while
+ associating to the AP
+ Set mask with values from CsrWifiSmeAuthMode
+ encryptionModeMask
+ - Sets the encryption options that the SME can use while
+ associating to the AP
+ Set mask with values from CsrWifiSmeEncryption
+ mlmeAssociateReqInformationElementsLength
+ - Length in bytes of information elements to be sent in the
+ Association Request.
+ mlmeAssociateReqInformationElements
+ - Points to the first byte of the information elements, if
+ any.
+ wmmQosInfo
+ - This parameter allows the driver's WMM behaviour to be
+ configured.
+ To enable support for WMM, use
+ CSR_WIFI_SME_SME_CONFIG_SET_REQ with the
+ CSR_WIFI_SME_WMM_MODE_AC_ENABLED bit set in wmmModeMask
+ field in smeConfig parameter.
+ Set mask with values from CsrWifiSmeWmmQosInfo
+ adhocJoinOnly
+ - This parameter is relevant only if bssType is NOT set to
+ CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE:
+ if TRUE the SME will only try to join an ad-hoc network if
+ there is one already established;
+ if FALSE the SME will try to join an ad-hoc network if
+ there is one already established or it will try to
+ establish a new one
+ adhocChannel
+ - This parameter is relevant only if bssType is NOT set to
+ CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE:
+ it indicates the channel to use joining an ad hoc network.
+ Setting this to 0 causes the SME to select a channel from
+ those permitted in the regulatory domain.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSsid ssid;
+ CsrWifiMacAddress bssid;
+ CsrWifiSmeBssType bssType;
+ CsrWifiSmeRadioIF ifIndex;
+ CsrWifiSme80211PrivacyMode privacyMode;
+ CsrWifiSmeAuthModeMask authModeMask;
+ CsrWifiSmeEncryptionMask encryptionModeMask;
+ CsrUint16 mlmeAssociateReqInformationElementsLength;
+ CsrUint8 *mlmeAssociateReqInformationElements;
+ CsrWifiSmeWmmQosInfoMask wmmQosInfo;
+ CsrBool adhocJoinOnly;
+ CsrUint8 adhocChannel;
+} CsrWifiSmeConnectionConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionInfo
+
+ DESCRIPTION
+ Parameters that the SME should use in selecting a network
+
+ MEMBERS
+ ssid - Service set identifier
+ bssid - BSS identifier
+ networkType80211 - Physical layer used for the connection
+ channelNumber - Channel number
+ channelFrequency - Channel frequency
+ authMode - Authentication mode used for the connection
+ pairwiseCipher - Encryption type for peer to peer communication
+ groupCipher - Encryption type for broadcast and multicast
+ communication
+ ifIndex - Indicates the radio interface
+ atimWindowTu - ATIM window specified for IBSS
+ beaconPeriodTu - Interval between beacon packets
+ reassociation - Indicates whether a reassociation occurred
+ beaconFrameLength - Indicates the number of bytes of the beacon
+ frame
+ beaconFrame - Points at the first byte of the beacon frame
+ associationReqFrameLength - Indicates the number of bytes of the
+ association request frame
+ associationReqFrame - Points at the first byte of the association
+ request frame
+ associationRspFrameLength - Indicates the number of bytes of the
+ association response frame
+ associationRspFrame - Points at the first byte of the association
+ response frame
+ assocScanInfoElementsLength - Indicates the number of bytes in the buffer
+ pointed by assocScanInfoElements
+ assocScanInfoElements - Pointer to the buffer containing the
+ information elements of the probe response
+ received after the probe requests sent before
+ attempting to authenticate to the network
+ assocReqCapabilities - Reports the content of the Capability
+ information element as specified in the
+ association request.
+ assocReqListenIntervalTu - Listen Interval specified in the association
+ request
+ assocReqApAddress - AP address to which the association requests
+ has been sent
+ assocReqInfoElementsLength - Indicates the number of bytes of the
+ association request information elements
+ assocReqInfoElements - Points at the first byte of the association
+ request information elements
+ assocRspResult - Result reported in the association response
+ assocRspCapabilityInfo - Reports the content of the Capability
+ information element as received in the
+ association response.
+ assocRspAssociationId - Reports the association ID received in the
+ association response.
+ assocRspInfoElementsLength - Indicates the number of bytes of the
+ association response information elements
+ assocRspInfoElements - Points at the first byte of the association
+ response information elements
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSsid ssid;
+ CsrWifiMacAddress bssid;
+ CsrWifiSme80211NetworkType networkType80211;
+ CsrUint8 channelNumber;
+ CsrUint16 channelFrequency;
+ CsrWifiSmeAuthMode authMode;
+ CsrWifiSmeEncryption pairwiseCipher;
+ CsrWifiSmeEncryption groupCipher;
+ CsrWifiSmeRadioIF ifIndex;
+ CsrUint16 atimWindowTu;
+ CsrUint16 beaconPeriodTu;
+ CsrBool reassociation;
+ CsrUint16 beaconFrameLength;
+ CsrUint8 *beaconFrame;
+ CsrUint16 associationReqFrameLength;
+ CsrUint8 *associationReqFrame;
+ CsrUint16 associationRspFrameLength;
+ CsrUint8 *associationRspFrame;
+ CsrUint16 assocScanInfoElementsLength;
+ CsrUint8 *assocScanInfoElements;
+ CsrUint16 assocReqCapabilities;
+ CsrUint16 assocReqListenIntervalTu;
+ CsrWifiMacAddress assocReqApAddress;
+ CsrUint16 assocReqInfoElementsLength;
+ CsrUint8 *assocReqInfoElements;
+ CsrWifiSmeIEEE80211Result assocRspResult;
+ CsrUint16 assocRspCapabilityInfo;
+ CsrUint16 assocRspAssociationId;
+ CsrUint16 assocRspInfoElementsLength;
+ CsrUint8 *assocRspInfoElements;
+} CsrWifiSmeConnectionInfo;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDeviceConfig
+
+ DESCRIPTION
+ General configuration options in the SME
+
+ MEMBERS
+ trustLevel - Level of trust of the information coming from the
+ network
+ countryCode - Country code as specified by IEEE 802.11 standard
+ firmwareDriverInterface - Specifies the type of communication between Host
+ and Firmware
+ enableStrictDraftN - If TRUE TKIP is disallowed when connecting to
+ 802.11n enabled access points
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSme80211dTrustLevel trustLevel;
+ CsrUint8 countryCode[2];
+ CsrWifiSmeFirmwareDriverInterface firmwareDriverInterface;
+ CsrBool enableStrictDraftN;
+} CsrWifiSmeDeviceConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDeviceInfo
+
+ DESCRIPTION
+ P2P Information for a P2P Device
+
+ MEMBERS
+ deviceAddress - Device Address of the P2P device
+ configMethods - Supported WPS configuration methods.
+ p2PDeviceCap - P2P device capabilities
+ primDeviceType - Primary WPS device type
+ secondaryDeviceTypeCount - Number of secondary device types
+ secDeviceType - list of secondary WPS device types
+ deviceName - Device name without up to 32 characters'\0'.
+ deviceNameLength - Number of characters of the device name
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiMacAddress deviceAddress;
+ CsrWifiSmeWpsConfigTypeMask configMethods;
+ CsrWifiSmeP2pCapabilityMask p2PDeviceCap;
+ CsrWifiSmeWpsDeviceType primDeviceType;
+ CsrUint8 secondaryDeviceTypeCount;
+ CsrWifiSmeWpsDeviceType *secDeviceType;
+ CsrUint8 deviceName[32];
+ CsrUint8 deviceNameLength;
+} CsrWifiSmeDeviceInfo;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDeviceInfoCommon
+
+ DESCRIPTION
+ Structure holding device information.
+
+ MEMBERS
+ p2pDeviceAddress -
+ primaryDeviceType -
+ secondaryDeviceTypesCount -
+ secondaryDeviceTypes -
+ deviceNameLength -
+ deviceName -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiMacAddress p2pDeviceAddress;
+ CsrWifiSmeWpsDeviceTypeCommon primaryDeviceType;
+ CsrUint8 secondaryDeviceTypesCount;
+ CsrUint8 secondaryDeviceTypes[10];
+ CsrUint8 deviceNameLength;
+ CsrUint8 deviceName[32];
+} CsrWifiSmeDeviceInfoCommon;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeHostConfig
+
+ DESCRIPTION
+ Defines the host power state (for example, on mains power, on battery
+ power etc) and the periodicity of the traffic data.
+
+ MEMBERS
+ powerMode - The wireless manager application should use the
+ powerMode parameter to inform the SME of the host
+ power state.
+ applicationDataPeriodMs - The applicationDataPeriodMs parameter allows a
+ wireless manager application to inform the SME
+ that an application is running that generates
+ periodic network traffic and the period of the
+ traffic.
+ An example of such an application is a VoIP client.
+ The wireless manager application should set
+ applicationDataPeriodMs to the period in
+ milliseconds between data packets or zero if no
+ periodic application is running.
+ Voip etc 0 = No Periodic Data
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeHostPowerMode powerMode;
+ CsrUint16 applicationDataPeriodMs;
+} CsrWifiSmeHostConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeKey
+
+ DESCRIPTION
+ Information for a key to be used for encryption
+
+ MEMBERS
+ keyType - Specifies whether the key is a pairwise or group key; it
+ should be set to CSR_WIFI_SME_GROUP_KEY or
+ CSR_WIFI_SME_PAIRWISE_KEY, as required.
+ keyIndex - Specifies which WEP key (0-3) to set; it should be set to 0
+ for a WPA/WPA2 pairwise key and non-zero for a WPA/WPA2
+ group key.
+ wepTxKey - If wepTxKey is TRUE, and the key is a WEP key, the key will
+ be selected for encrypting transmitted packets.
+ To select a previously defined key as the transmit
+ encryption key, set keyIndex to the required key, wepTxKey
+ to TRUE and the keyLength to 0.
+ keyRsc - Key Receive Sequence Counter
+ authenticator - If TRUE the WMA will act as authenticator.
+ CURRENTLY NOT SUPPORTED
+ address - BSS identifier of the AP
+ keyLength - Length of the key in bytes
+ key - Points to the first byte of the key
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeKeyType keyType;
+ CsrUint8 keyIndex;
+ CsrBool wepTxKey;
+ CsrUint16 keyRsc[8];
+ CsrBool authenticator;
+ CsrWifiMacAddress address;
+ CsrUint8 keyLength;
+ CsrUint8 key[32];
+} CsrWifiSmeKey;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeP2pClientInfoType
+
+ DESCRIPTION
+ P2P Information for a P2P Client
+
+ MEMBERS
+ p2PClientInterfaceAddress - MAC address of the P2P Client
+ clientDeviceInfo - Device Information
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiMacAddress p2PClientInterfaceAddress;
+ CsrWifiSmeDeviceInfo clientDeviceInfo;
+} CsrWifiSmeP2pClientInfoType;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeP2pGroupInfo
+
+ DESCRIPTION
+ P2P Information for a P2P Group
+
+ MEMBERS
+ groupCapability - P2P group capabilities
+ p2pDeviceAddress - Device Address of the GO
+ p2pClientInfoCount - Number of P2P Clients that belong to the group.
+ p2PClientInfo - Pointer to the list containing client information for
+ each client in the group
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeP2pGroupCapabilityMask groupCapability;
+ CsrWifiMacAddress p2pDeviceAddress;
+ CsrUint8 p2pClientInfoCount;
+ CsrWifiSmeP2pClientInfoType *p2PClientInfo;
+} CsrWifiSmeP2pGroupInfo;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePowerConfig
+
+ DESCRIPTION
+ Configures the power-save behaviour of the driver and firmware.
+
+ MEMBERS
+ powerSaveLevel - Power Save Level option
+ listenIntervalTu - Interval for waking to receive beacon frames
+ rxDtims - If TRUE, wake for DTIM every beacon period, to
+ allow the reception broadcast packets
+ d3AutoScanMode - Defines whether the autonomous scanning will be
+ turned off or will stay on during a D3 suspended
+ period
+ clientTrafficWindow - Deprecated
+ opportunisticPowerSave - Deprecated
+ noticeOfAbsence - Deprecated
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmePowerSaveLevel powerSaveLevel;
+ CsrUint16 listenIntervalTu;
+ CsrBool rxDtims;
+ CsrWifiSmeD3AutoScanMode d3AutoScanMode;
+ CsrUint8 clientTrafficWindow;
+ CsrBool opportunisticPowerSave;
+ CsrBool noticeOfAbsence;
+} CsrWifiSmePowerConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamingConfig
+
+ DESCRIPTION
+ Configures the roaming behaviour of the driver and firmware
+
+ MEMBERS
+ roamingBands - Defines the thresholds to determine the usability
+ level of the current connection.
+ roamingBands is indexed by the first 3 entries of
+ the CsrWifiSmeBasicUsability enum
+ disableSmoothRoaming - Disable the RSSI/SNR triggers from the Firmware
+ that the SME uses to detect the quality of the
+ connection.
+ This implicitly disables disableRoamScans
+ disableRoamScans - Disables the scanning for the roaming operation
+ reconnectLimit - Maximum number of times SME may reconnect in the
+ given interval
+ reconnectLimitIntervalMs - Interval for maximum number of times SME may
+ reconnect to the same Access Point
+ roamScanCfg - Scanning behaviour for the specifically aimed at
+ improving roaming performance.
+ roamScanCfg is indexed by the first 3 entries of
+ the CsrWifiSmeBasicUsability enum
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeRoamingBandData roamingBands[3];
+ CsrBool disableSmoothRoaming;
+ CsrBool disableRoamScans;
+ CsrUint8 reconnectLimit;
+ CsrUint16 reconnectLimitIntervalMs;
+ CsrWifiSmeScanConfigData roamScanCfg[3];
+} CsrWifiSmeRoamingConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanConfig
+
+ DESCRIPTION
+ Parameters for the autonomous scanning behaviour of the system
+
+ MEMBERS
+ scanCfg - Scan configuration data.
+ Indexed by the CsrWifiSmeBasicUsability enum
+ disableAutonomousScans - Enables or disables the autonomous scan
+ maxResults - Maximum number of results to be cached in the SME
+ highRssiThreshold - High received signal strength indication threshold
+ in dBm for an AP above which the system will
+ report scan indications
+ lowRssiThreshold - Low received signal strength indication threshold
+ in dBm for an AP below which the system will
+ report scan indications
+ deltaRssiThreshold - Minimum difference for received signal strength
+ indication in dBm for an AP which trigger a scan
+ indication to be sent.
+ highSnrThreshold - High Signal to Noise Ratio threshold in dB for an
+ AP above which the system will report scan
+ indications
+ lowSnrThreshold - Low Signal to Noise Ratio threshold in dB for an
+ AP below which the system will report scan
+ indications
+ deltaSnrThreshold - Minimum difference for Signal to Noise Ratio in dB
+ for an AP which trigger a scan indication to be
+ sent.
+ passiveChannelListCount - Number of channels to be scanned passively.
+ passiveChannelList - Points to the first channel to be scanned
+ passively , if any.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeScanConfigData scanCfg[4];
+ CsrBool disableAutonomousScans;
+ CsrUint16 maxResults;
+ CsrInt8 highRssiThreshold;
+ CsrInt8 lowRssiThreshold;
+ CsrInt8 deltaRssiThreshold;
+ CsrInt8 highSnrThreshold;
+ CsrInt8 lowSnrThreshold;
+ CsrInt8 deltaSnrThreshold;
+ CsrUint16 passiveChannelListCount;
+ CsrUint8 *passiveChannelList;
+} CsrWifiSmeScanConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResult
+
+ DESCRIPTION
+ This structure defines the scan result for each BSS found
+
+ MEMBERS
+ ssid - Service set identifier
+ bssid - BSS identifier
+ rssi - Received signal strength indication in dBm
+ snr - Signal to noise ratio in dB
+ ifIndex - Indicates the radio interface
+ beaconPeriodTu - Interval between beacon frames
+ timeStamp - Timestamp in the BSS
+ localTime - Timestamp in the Access Point
+ channelFrequency - Channel frequency
+ capabilityInformation - Capabilities of the BSS.
+ channelNumber - Channel number
+ usability - Indicates the usability level.
+ bssType - Type of BSS.
+ informationElementsLength - Number of bytes of the information elements
+ received as part of the beacon or probe
+ response.
+ informationElements - Points to the first byte of the IEs received
+ as part of the beacon or probe response.
+ The format of the IEs is as specified in the
+ IEEE 802.11 specification.
+ p2pDeviceRole - Role of the P2P device.
+ Relevant only if bssType is
+ CSR_WIFI_SME_BSS_TYPE_P2P
+ deviceInfo - Union containing P2P device info which
+ depends on p2pDeviceRole parameter.
+ deviceInforeservedCli -
+ deviceInfogroupInfo -
+ deviceInforeservedNone -
+ deviceInfostandalonedevInfo -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSsid ssid;
+ CsrWifiMacAddress bssid;
+ CsrInt16 rssi;
+ CsrInt16 snr;
+ CsrWifiSmeRadioIF ifIndex;
+ CsrUint16 beaconPeriodTu;
+ CsrWifiSmeTsfTime timeStamp;
+ CsrWifiSmeTsfTime localTime;
+ CsrUint16 channelFrequency;
+ CsrUint16 capabilityInformation;
+ CsrUint8 channelNumber;
+ CsrWifiSmeBasicUsability usability;
+ CsrWifiSmeBssType bssType;
+ CsrUint16 informationElementsLength;
+ CsrUint8 *informationElements;
+ CsrWifiSmeP2pRole p2pDeviceRole;
+ union {
+ CsrWifiSmeEmpty reservedCli;
+ CsrWifiSmeP2pGroupInfo groupInfo;
+ CsrWifiSmeEmpty reservedNone;
+ CsrWifiSmeDeviceInfo standalonedevInfo;
+ } deviceInfo;
+} CsrWifiSmeScanResult;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeStaConfig
+
+ DESCRIPTION
+ Station configuration options in the SME
+
+ MEMBERS
+ connectionQualityRssiChangeTrigger - Sets the difference of RSSI
+ measurements which triggers reports
+ from the Firmware
+ connectionQualitySnrChangeTrigger - Sets the difference of SNR measurements
+ which triggers reports from the
+ Firmware
+ wmmModeMask - Mask containing one or more values from
+ CsrWifiSmeWmmMode
+ ifIndex - Indicates the band of frequencies used
+ allowUnicastUseGroupCipher - If TRUE, it allows to use groupwise
+ keys if no pairwise key is specified
+ enableOpportunisticKeyCaching - If TRUE, enables the Opportunistic Key
+ Caching feature
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 connectionQualityRssiChangeTrigger;
+ CsrUint8 connectionQualitySnrChangeTrigger;
+ CsrWifiSmeWmmModeMask wmmModeMask;
+ CsrWifiSmeRadioIF ifIndex;
+ CsrBool allowUnicastUseGroupCipher;
+ CsrBool enableOpportunisticKeyCaching;
+} CsrWifiSmeStaConfig;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWep128Keys
+
+ DESCRIPTION
+ Structure holding WEP Authentication Type and WEP keys that can be used
+ when using WEP128.
+
+ MEMBERS
+ wepAuthType - Mask to select the WEP authentication type (Open or Shared)
+ selectedWepKey - Index to one of the four keys below indicating the
+ currently used WEP key. Mapping From SME/User -> firmware.
+ Key 1 -> Index 0. Key 2 -> Index 1. key 3 -> Index 2. Key
+ 4-> Index 3.
+ key1 - Value for key number 1.
+ key2 - Value for key number 2.
+ key3 - Value for key number 3.
+ key4 - Value for key number 4.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeWepAuthMode wepAuthType;
+ CsrUint8 selectedWepKey;
+ CsrUint8 key1[13];
+ CsrUint8 key2[13];
+ CsrUint8 key3[13];
+ CsrUint8 key4[13];
+} CsrWifiSmeWep128Keys;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWep64Keys
+
+ DESCRIPTION
+ Structure holding WEP Authentication Type and WEP keys that can be used
+ when using WEP64.
+
+ MEMBERS
+ wepAuthType - Mask to select the WEP authentication type (Open or Shared)
+ selectedWepKey - Index to one of the four keys below indicating the
+ currently used WEP key. Mapping From SME/User -> firmware.
+ Key 1 -> Index 0. Key 2 -> Index 1. key 3 -> Index 2. Key
+ 4-> Index 3.
+ key1 - Value for key number 1.
+ key2 - Value for key number 2.
+ key3 - Value for key number 3.
+ key4 - Value for key number 4.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeWepAuthMode wepAuthType;
+ CsrUint8 selectedWepKey;
+ CsrUint8 key1[5];
+ CsrUint8 key2[5];
+ CsrUint8 key3[5];
+ CsrUint8 key4[5];
+} CsrWifiSmeWep64Keys;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWepAuth
+
+ DESCRIPTION
+ WEP authentication parameter structure
+
+ MEMBERS
+ wepKeyType - WEP key try (128 bit or 64 bit)
+ wepCredentials - Union containing credentials which depends on
+ wepKeyType parameter.
+ wepCredentialswep128Key -
+ wepCredentialswep64Key -
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiSmeWepCredentialType wepKeyType;
+ union {
+ CsrWifiSmeWep128Keys wep128Key;
+ CsrWifiSmeWep64Keys wep64Key;
+ } wepCredentials;
+} CsrWifiSmeWepAuth;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsConfig
+
+ DESCRIPTION
+ Structure holding AP WPS Config data.
+
+ MEMBERS
+ wpsVersion - wpsVersion should be 0x10 for WPS1.0h or 0x20 for
+ WSC2.0
+ uuid - uuid.
+ deviceName - Device name upto 32 characters without '\0'.
+ deviceNameLength - deviceNameLen.
+ manufacturer - manufacturer: CSR
+ manufacturerLength - manufacturerLen.
+ modelName - modelName Unifi
+ modelNameLength - modelNameLen.
+ modelNumber - modelNumber
+ modelNumberLength - modelNumberLen.
+ serialNumber - serialNumber
+ primDeviceType - Primary WPS device type
+ secondaryDeviceTypeCount - Number of secondary device types
+ secondaryDeviceType - list of secondary WPS device types
+ configMethods - Supported WPS config methods
+ rfBands - RfBands.
+ osVersion - Os version on which the device is running
+
+*******************************************************************************/
+typedef struct
+{
+ CsrUint8 wpsVersion;
+ CsrUint8 uuid[16];
+ CsrUint8 deviceName[32];
+ CsrUint8 deviceNameLength;
+ CsrUint8 manufacturer[64];
+ CsrUint8 manufacturerLength;
+ CsrUint8 modelName[32];
+ CsrUint8 modelNameLength;
+ CsrUint8 modelNumber[32];
+ CsrUint8 modelNumberLength;
+ CsrUint8 serialNumber[32];
+ CsrWifiSmeWpsDeviceType primDeviceType;
+ CsrUint8 secondaryDeviceTypeCount;
+ CsrWifiSmeWpsDeviceType *secondaryDeviceType;
+ CsrWifiSmeWpsConfigTypeMask configMethods;
+ CsrUint8 rfBands;
+ CsrUint8 osVersion[4];
+} CsrWifiSmeWpsConfig;
+
+
+/* Downstream */
+#define CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST (0x0000)
+
+#define CSR_WIFI_SME_ACTIVATE_REQ ((CsrWifiSmePrim) (0x0000 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_ADHOC_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x0001 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_ADHOC_CONFIG_SET_REQ ((CsrWifiSmePrim) (0x0002 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_BLACKLIST_REQ ((CsrWifiSmePrim) (0x0003 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_CALIBRATION_DATA_GET_REQ ((CsrWifiSmePrim) (0x0004 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_CALIBRATION_DATA_SET_REQ ((CsrWifiSmePrim) (0x0005 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_CCX_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x0006 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_CCX_CONFIG_SET_REQ ((CsrWifiSmePrim) (0x0007 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_COEX_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x0008 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_COEX_CONFIG_SET_REQ ((CsrWifiSmePrim) (0x0009 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_COEX_INFO_GET_REQ ((CsrWifiSmePrim) (0x000A + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_CONNECT_REQ ((CsrWifiSmePrim) (0x000B + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_CONNECTION_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x000C + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_CONNECTION_INFO_GET_REQ ((CsrWifiSmePrim) (0x000D + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_CONNECTION_STATS_GET_REQ ((CsrWifiSmePrim) (0x000E + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_DEACTIVATE_REQ ((CsrWifiSmePrim) (0x000F + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_DISCONNECT_REQ ((CsrWifiSmePrim) (0x0010 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_EVENT_MASK_SET_REQ ((CsrWifiSmePrim) (0x0011 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_HOST_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x0012 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_HOST_CONFIG_SET_REQ ((CsrWifiSmePrim) (0x0013 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_KEY_REQ ((CsrWifiSmePrim) (0x0014 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_LINK_QUALITY_GET_REQ ((CsrWifiSmePrim) (0x0015 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIB_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x0016 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIB_CONFIG_SET_REQ ((CsrWifiSmePrim) (0x0017 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIB_GET_NEXT_REQ ((CsrWifiSmePrim) (0x0018 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIB_GET_REQ ((CsrWifiSmePrim) (0x0019 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIB_SET_REQ ((CsrWifiSmePrim) (0x001A + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_MULTICAST_ADDRESS_REQ ((CsrWifiSmePrim) (0x001B + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_PACKET_FILTER_SET_REQ ((CsrWifiSmePrim) (0x001C + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_PERMANENT_MAC_ADDRESS_GET_REQ ((CsrWifiSmePrim) (0x001D + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_PMKID_REQ ((CsrWifiSmePrim) (0x001E + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_POWER_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x001F + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_POWER_CONFIG_SET_REQ ((CsrWifiSmePrim) (0x0020 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_INFO_GET_REQ ((CsrWifiSmePrim) (0x0021 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_ROAMING_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x0022 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_ROAMING_CONFIG_SET_REQ ((CsrWifiSmePrim) (0x0023 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x0024 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_CONFIG_SET_REQ ((CsrWifiSmePrim) (0x0025 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_FULL_REQ ((CsrWifiSmePrim) (0x0026 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_RESULTS_FLUSH_REQ ((CsrWifiSmePrim) (0x0027 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_RESULTS_GET_REQ ((CsrWifiSmePrim) (0x0028 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_SME_STA_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x0029 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_SME_STA_CONFIG_SET_REQ ((CsrWifiSmePrim) (0x002A + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_STATION_MAC_ADDRESS_GET_REQ ((CsrWifiSmePrim) (0x002B + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_TSPEC_REQ ((CsrWifiSmePrim) (0x002C + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_VERSIONS_GET_REQ ((CsrWifiSmePrim) (0x002D + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_WIFI_FLIGHTMODE_REQ ((CsrWifiSmePrim) (0x002E + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_WIFI_OFF_REQ ((CsrWifiSmePrim) (0x002F + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_WIFI_ON_REQ ((CsrWifiSmePrim) (0x0030 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_CLOAKED_SSIDS_SET_REQ ((CsrWifiSmePrim) (0x0031 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_CLOAKED_SSIDS_GET_REQ ((CsrWifiSmePrim) (0x0032 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_SME_COMMON_CONFIG_GET_REQ ((CsrWifiSmePrim) (0x0033 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_SME_COMMON_CONFIG_SET_REQ ((CsrWifiSmePrim) (0x0034 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_REQ ((CsrWifiSmePrim) (0x0035 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_WPS_CONFIGURATION_REQ ((CsrWifiSmePrim) (0x0036 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+#define CSR_WIFI_SME_SET_REQ ((CsrWifiSmePrim) (0x0037 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST))
+
+
+#define CSR_WIFI_SME_PRIM_DOWNSTREAM_HIGHEST (0x0037 + CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST)
+
+/* Upstream */
+#define CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST (0x0000 + CSR_PRIM_UPSTREAM)
+
+#define CSR_WIFI_SME_ACTIVATE_CFM ((CsrWifiSmePrim)(0x0000 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_ADHOC_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x0001 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_ADHOC_CONFIG_SET_CFM ((CsrWifiSmePrim)(0x0002 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_ASSOCIATION_COMPLETE_IND ((CsrWifiSmePrim)(0x0003 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_ASSOCIATION_START_IND ((CsrWifiSmePrim)(0x0004 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_BLACKLIST_CFM ((CsrWifiSmePrim)(0x0005 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CALIBRATION_DATA_GET_CFM ((CsrWifiSmePrim)(0x0006 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CALIBRATION_DATA_SET_CFM ((CsrWifiSmePrim)(0x0007 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CCX_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x0008 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CCX_CONFIG_SET_CFM ((CsrWifiSmePrim)(0x0009 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_COEX_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x000A + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_COEX_CONFIG_SET_CFM ((CsrWifiSmePrim)(0x000B + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_COEX_INFO_GET_CFM ((CsrWifiSmePrim)(0x000C + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CONNECT_CFM ((CsrWifiSmePrim)(0x000D + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CONNECTION_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x000E + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CONNECTION_INFO_GET_CFM ((CsrWifiSmePrim)(0x000F + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CONNECTION_QUALITY_IND ((CsrWifiSmePrim)(0x0010 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CONNECTION_STATS_GET_CFM ((CsrWifiSmePrim)(0x0011 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_DEACTIVATE_CFM ((CsrWifiSmePrim)(0x0012 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_DISCONNECT_CFM ((CsrWifiSmePrim)(0x0013 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_EVENT_MASK_SET_CFM ((CsrWifiSmePrim)(0x0014 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_HOST_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x0015 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_HOST_CONFIG_SET_CFM ((CsrWifiSmePrim)(0x0016 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_IBSS_STATION_IND ((CsrWifiSmePrim)(0x0017 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_KEY_CFM ((CsrWifiSmePrim)(0x0018 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_LINK_QUALITY_GET_CFM ((CsrWifiSmePrim)(0x0019 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_MEDIA_STATUS_IND ((CsrWifiSmePrim)(0x001A + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIB_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x001B + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIB_CONFIG_SET_CFM ((CsrWifiSmePrim)(0x001C + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIB_GET_CFM ((CsrWifiSmePrim)(0x001D + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIB_GET_NEXT_CFM ((CsrWifiSmePrim)(0x001E + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIB_SET_CFM ((CsrWifiSmePrim)(0x001F + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_MIC_FAILURE_IND ((CsrWifiSmePrim)(0x0020 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_MULTICAST_ADDRESS_CFM ((CsrWifiSmePrim)(0x0021 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_PACKET_FILTER_SET_CFM ((CsrWifiSmePrim)(0x0022 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_PERMANENT_MAC_ADDRESS_GET_CFM ((CsrWifiSmePrim)(0x0023 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_PMKID_CANDIDATE_LIST_IND ((CsrWifiSmePrim)(0x0024 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_PMKID_CFM ((CsrWifiSmePrim)(0x0025 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_POWER_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x0026 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_POWER_CONFIG_SET_CFM ((CsrWifiSmePrim)(0x0027 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_REGULATORY_DOMAIN_INFO_GET_CFM ((CsrWifiSmePrim)(0x0028 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_ROAM_COMPLETE_IND ((CsrWifiSmePrim)(0x0029 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_ROAM_START_IND ((CsrWifiSmePrim)(0x002A + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_ROAMING_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x002B + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_ROAMING_CONFIG_SET_CFM ((CsrWifiSmePrim)(0x002C + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x002D + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_CONFIG_SET_CFM ((CsrWifiSmePrim)(0x002E + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_FULL_CFM ((CsrWifiSmePrim)(0x002F + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_RESULT_IND ((CsrWifiSmePrim)(0x0030 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_RESULTS_FLUSH_CFM ((CsrWifiSmePrim)(0x0031 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_SCAN_RESULTS_GET_CFM ((CsrWifiSmePrim)(0x0032 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_SME_STA_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x0033 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_SME_STA_CONFIG_SET_CFM ((CsrWifiSmePrim)(0x0034 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_STATION_MAC_ADDRESS_GET_CFM ((CsrWifiSmePrim)(0x0035 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_TSPEC_IND ((CsrWifiSmePrim)(0x0036 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_TSPEC_CFM ((CsrWifiSmePrim)(0x0037 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_VERSIONS_GET_CFM ((CsrWifiSmePrim)(0x0038 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_WIFI_FLIGHTMODE_CFM ((CsrWifiSmePrim)(0x0039 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_WIFI_OFF_IND ((CsrWifiSmePrim)(0x003A + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_WIFI_OFF_CFM ((CsrWifiSmePrim)(0x003B + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_WIFI_ON_CFM ((CsrWifiSmePrim)(0x003C + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CLOAKED_SSIDS_SET_CFM ((CsrWifiSmePrim)(0x003D + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CLOAKED_SSIDS_GET_CFM ((CsrWifiSmePrim)(0x003E + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_WIFI_ON_IND ((CsrWifiSmePrim)(0x003F + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_SME_COMMON_CONFIG_GET_CFM ((CsrWifiSmePrim)(0x0040 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_SME_COMMON_CONFIG_SET_CFM ((CsrWifiSmePrim)(0x0041 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_INTERFACE_CAPABILITY_GET_CFM ((CsrWifiSmePrim)(0x0042 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_ERROR_IND ((CsrWifiSmePrim)(0x0043 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_INFO_IND ((CsrWifiSmePrim)(0x0044 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_CORE_DUMP_IND ((CsrWifiSmePrim)(0x0045 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_AMP_STATUS_CHANGE_IND ((CsrWifiSmePrim)(0x0046 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+#define CSR_WIFI_SME_WPS_CONFIGURATION_CFM ((CsrWifiSmePrim)(0x0047 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST))
+
+#define CSR_WIFI_SME_PRIM_UPSTREAM_HIGHEST (0x0047 + CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST)
+
+#define CSR_WIFI_SME_PRIM_DOWNSTREAM_COUNT (CSR_WIFI_SME_PRIM_DOWNSTREAM_HIGHEST + 1 - CSR_WIFI_SME_PRIM_DOWNSTREAM_LOWEST)
+#define CSR_WIFI_SME_PRIM_UPSTREAM_COUNT (CSR_WIFI_SME_PRIM_UPSTREAM_HIGHEST + 1 - CSR_WIFI_SME_PRIM_UPSTREAM_LOWEST)
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeActivateReq
+
+ DESCRIPTION
+ The WMA sends this primitive to activate the SME.
+ The WMA must activate the SME before it can send any other primitive.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeActivateReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAdhocConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the adHocConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeAdhocConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAdhocConfigSetReq
+
+ DESCRIPTION
+ This primitive sets the value of the adHocConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ adHocConfig - Sets the values to use when starting an ad hoc network.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeAdHocConfig adHocConfig;
+} CsrWifiSmeAdhocConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeBlacklistReq
+
+ DESCRIPTION
+ The wireless manager application should call this primitive to notify the
+ driver of any networks that should not be connected to. The interface
+ allows the wireless manager application to query, add, remove, and flush
+ the BSSIDs that the driver may not connect or roam to.
+ When this primitive adds to the black list the BSSID to which the SME is
+ currently connected, the SME will try to roam, if applicable, to another
+ BSSID in the same ESS; if the roaming procedure fails, the SME will
+ disconnect.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ action - The value of the CsrWifiSmeListAction parameter instructs
+ the driver to modify or provide the list of blacklisted
+ networks.
+ setAddressCount - Number of BSSIDs sent with this primitive
+ setAddresses - Pointer to the list of BBSIDs sent with the primitive, set
+ to NULL if none is sent.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeListAction action;
+ CsrUint8 setAddressCount;
+ CsrWifiMacAddress *setAddresses;
+} CsrWifiSmeBlacklistReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCalibrationDataGetReq
+
+ DESCRIPTION
+ This primitive retrieves the Wi-Fi radio calibration data.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeCalibrationDataGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCalibrationDataSetReq
+
+ DESCRIPTION
+ This primitive sets the Wi-Fi radio calibration data.
+ The usage of the primitive with proper calibration data will avoid
+ time-consuming configuration after power-up.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ calibrationDataLength - Number of bytes in the buffer pointed by
+ calibrationData
+ calibrationData - Pointer to a buffer of length calibrationDataLength
+ containing the calibration data
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 calibrationDataLength;
+ CsrUint8 *calibrationData;
+} CsrWifiSmeCalibrationDataSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCcxConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the CcxConfig parameter.
+ CURRENTLY NOT SUPPORTED.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeCcxConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCcxConfigSetReq
+
+ DESCRIPTION
+ This primitive sets the value of the CcxConfig parameter.
+ CURRENTLY NOT SUPPORTED.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ ccxConfig - Currently not supported
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeCcxConfig ccxConfig;
+} CsrWifiSmeCcxConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the CoexConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeCoexConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexConfigSetReq
+
+ DESCRIPTION
+ This primitive sets the value of the CoexConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ coexConfig - Configures the coexistence behaviour
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeCoexConfig coexConfig;
+} CsrWifiSmeCoexConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexInfoGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the CoexInfo parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeCoexInfoGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectReq
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to start the
+ process of joining an 802.11 wireless network or to start an ad hoc
+ network.
+ The structure pointed by connectionConfig contains parameters describing
+ the network to join or, in case of an ad hoc network, to host or join.
+ The SME will select a network, perform the IEEE 802.11 Join, Authenticate
+ and Associate exchanges.
+ The SME selects the networks from the current scan list that match both
+ the SSID and BSSID, however either or both of these may be the wildcard
+ value. Using this rule, the following operations are possible:
+ * To connect to a network by name, specify the SSID and set the BSSID to
+ 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF. If there are two or more networks visible,
+ the SME will select the one with the strongest signal.
+ * To connect to a specific network, specify the BSSID. The SSID is
+ optional, but if given it must match the SSID of the network. An empty
+ SSID may be specified by setting the SSID length to zero. Please note
+ that if the BSSID is specified (i.e. not equal to 0xFF 0xFF 0xFF 0xFF
+ 0xFF 0xFF), the SME will not attempt to roam if signal conditions become
+ poor, even if there is an alternative AP with an SSID that matches the
+ current network SSID.
+ * To connect to any network matching the other parameters (i.e. security,
+ etc), set the SSID length to zero and set the BSSID to 0xFF 0xFF 0xFF
+ 0xFF 0xFF 0xFF. In this case, the SME will order all available networks
+ by their signal strengths and will iterate through this list until it
+ successfully connects.
+ NOTE: Specifying the BSSID will restrict the selection to one specific
+ network. If SSID and BSSID are given, they must both match the network
+ for it to be selected. To select a network based on the SSID only, the
+ wireless manager application must set the BSSID to 0xFF 0xFF 0xFF 0xFF
+ 0xFF 0xFF.
+ The SME will try to connect to each network that matches the provided
+ parameters, one by one, until it succeeds or has tried unsuccessfully
+ with all the matching networks.
+ If there is no network that matches the parameters and the request allows
+ to host an ad hoc network, the SME will advertise a new ad hoc network
+ instead.
+ If the SME cannot connect, it will notify the failure in the confirm.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ connectionConfig - Describes the candidate network to join or to host.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeConnectionConfig connectionConfig;
+} CsrWifiSmeConnectReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the ConnectionConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeConnectionConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionInfoGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the ConnectionInfo parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeConnectionInfoGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionStatsGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the ConnectionStats parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeConnectionStatsGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDeactivateReq
+
+ DESCRIPTION
+ The WMA sends this primitive to deactivate the SME.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeDeactivateReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDisconnectReq
+
+ DESCRIPTION
+ The wireless manager application may disconnect from the current network
+ by calling this primitive
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeDisconnectReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeEventMaskSetReq
+
+ DESCRIPTION
+ The wireless manager application may register with the SME to receive
+ notification of interesting events. Indications will be sent only if the
+ wireless manager explicitly registers to be notified of that event.
+ indMask is a bit mask of values defined in CsrWifiSmeIndicationsMask.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ indMask - Set mask with values from CsrWifiSmeIndications
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeIndicationsMask indMask;
+} CsrWifiSmeEventMaskSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeHostConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the hostConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeHostConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeHostConfigSetReq
+
+ DESCRIPTION
+ This primitive sets the value of the hostConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ hostConfig - Communicates a change of host power state (for example, on
+ mains power, on battery power etc) and of the periodicity of
+ traffic data
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeHostConfig hostConfig;
+} CsrWifiSmeHostConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeKeyReq
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to add or remove
+ keys that the chip should use for encryption of data.
+ The interface allows the wireless manager application to add and remove
+ keys according to the specified action.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ action - The value of the CsrWifiSmeListAction parameter instructs the
+ driver to modify or provide the list of keys.
+ CSR_WIFI_SME_LIST_ACTION_GET is not supported here.
+ key - Key to be added or removed
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeListAction action;
+ CsrWifiSmeKey key;
+} CsrWifiSmeKeyReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeLinkQualityGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the LinkQuality parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeLinkQualityGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the MibConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeMibConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibConfigSetReq
+
+ DESCRIPTION
+ This primitive sets the value of the MibConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ mibConfig - Conveys the desired value of various IEEE 802.11 attributes as
+ currently configured
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeMibConfig mibConfig;
+} CsrWifiSmeMibConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibGetNextReq
+
+ DESCRIPTION
+ To read a sequence of MIB parameters, for example a table, call this
+ primitive to find the name of the next MIB variable
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ mibAttributeLength - Length of mibAttribute
+ mibAttribute - Points to a VarBind or VarBindList containing the
+ name(s) of the MIB variable(s) to search from.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 mibAttributeLength;
+ CsrUint8 *mibAttribute;
+} CsrWifiSmeMibGetNextReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibGetReq
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to retrieve one or
+ more MIB variables.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ mibAttributeLength - Length of mibAttribute
+ mibAttribute - Points to the VarBind or VarBindList containing the
+ names of the MIB variables to be retrieved
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 mibAttributeLength;
+ CsrUint8 *mibAttribute;
+} CsrWifiSmeMibGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibSetReq
+
+ DESCRIPTION
+ The SME provides raw access to the MIB on the chip, which may be used by
+ some configuration or diagnostic utilities, but is not normally needed by
+ the wireless manager application.
+ The MIB access functions use BER encoded names (OID) of the MIB
+ parameters and BER encoded values, as described in the chip Host
+ Interface Protocol Specification.
+ The MIB parameters are described in 'Wi-Fi 5.0.0 Management Information
+ Base Reference Guide'.
+ The wireless manager application calls this primitive to set one or more
+ MIB variables
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ mibAttributeLength - Length of mibAttribute
+ mibAttribute - Points to the VarBind or VarBindList containing the
+ names and values of the MIB variables to set
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 mibAttributeLength;
+ CsrUint8 *mibAttribute;
+} CsrWifiSmeMibSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMulticastAddressReq
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to specify the
+ multicast addresses which the chip should recognise. The interface allows
+ the wireless manager application to query, add, remove and flush the
+ multicast addresses for the network interface according to the specified
+ action.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ action - The value of the CsrWifiSmeListAction parameter
+ instructs the driver to modify or provide the list of
+ MAC addresses.
+ setAddressesCount - Number of MAC addresses sent with the primitive
+ setAddresses - Pointer to the list of MAC Addresses sent with the
+ primitive, set to NULL if none is sent.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeListAction action;
+ CsrUint8 setAddressesCount;
+ CsrWifiMacAddress *setAddresses;
+} CsrWifiSmeMulticastAddressReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePacketFilterSetReq
+
+ DESCRIPTION
+ The wireless manager application should call this primitive to enable or
+ disable filtering of broadcast packets: uninteresting broadcast packets
+ will be dropped by the Wi-Fi chip, instead of passing them up to the
+ host.
+ This has the advantage of saving power in the host application processor
+ as it removes the need to process unwanted packets.
+ All broadcast packets are filtered according to the filter and the filter
+ mode provided, except ARP packets, which are filtered using
+ arpFilterAddress.
+ Filters are not cumulative: only the parameters specified in the most
+ recent successful request are significant.
+ For more information, see 'UniFi Firmware API Specification'.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ filterLength - Length of the filter in bytes.
+ filterLength=0 disables the filter previously set
+ filter - Points to the first byte of the filter provided, if any.
+ This shall include zero or more instance of the
+ information elements of one of these types
+ * Traffic Classification (TCLAS) elements
+ * WMM-SA TCLAS elements
+ mode - Specifies whether the filter selects or excludes packets
+ matching the filter
+ arpFilterAddress - IPv4 address to be used for filtering the ARP packets.
+ * If the specified address is the IPv4 broadcast address
+ (255.255.255.255), all ARP packets are reported to the
+ host,
+ * If the specified address is NOT the IPv4 broadcast
+ address, only ARP packets with the specified address in
+ the Source or Target Protocol Address fields are reported
+ to the host
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint16 filterLength;
+ CsrUint8 *filter;
+ CsrWifiSmePacketFilterMode mode;
+ CsrWifiIp4Address arpFilterAddress;
+} CsrWifiSmePacketFilterSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePermanentMacAddressGetReq
+
+ DESCRIPTION
+ This primitive retrieves the MAC address stored in EEPROM
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmePermanentMacAddressGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePmkidReq
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to request an
+ operation on the SME PMKID list.
+ The action argument specifies the operation to perform.
+ When the connection is complete, the wireless manager application may
+ then send and receive EAPOL packets to complete WPA or WPA2
+ authentication if appropriate.
+ The wireless manager application can then pass the resulting encryption
+ keys using this primitive.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ action - The value of the CsrWifiSmeListAction parameter instructs
+ the driver to modify or provide the list of PMKIDs.
+ setPmkidsCount - Number of PMKIDs sent with the primitive
+ setPmkids - Pointer to the list of PMKIDs sent with the primitive, set
+ to NULL if none is sent.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeListAction action;
+ CsrUint8 setPmkidsCount;
+ CsrWifiSmePmkid *setPmkids;
+} CsrWifiSmePmkidReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePowerConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the PowerConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmePowerConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePowerConfigSetReq
+
+ DESCRIPTION
+ This primitive sets the value of the PowerConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ powerConfig - Power saving configuration
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmePowerConfig powerConfig;
+} CsrWifiSmePowerConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRegulatoryDomainInfoGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the RegulatoryDomainInfo parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeRegulatoryDomainInfoGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamingConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the RoamingConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeRoamingConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamingConfigSetReq
+
+ DESCRIPTION
+ This primitive sets the value of the RoamingConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ roamingConfig - Desired roaming behaviour values
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeRoamingConfig roamingConfig;
+} CsrWifiSmeRoamingConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the ScanConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeScanConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanConfigSetReq
+
+ DESCRIPTION
+ This primitive sets the value of the ScanConfig parameter.
+ The SME normally configures the firmware to perform autonomous scanning
+ without involving the host.
+ The firmware passes beacon / probe response or indicates loss of beacon
+ on certain changes of state, for example:
+ * A new AP is seen for the first time
+ * An AP is no longer visible
+ * The signal strength of an AP changes by more than a certain amount, as
+ configured by the thresholds in the scanConfig parameter
+ In addition to the autonomous scan, the wireless manager application may
+ request a scan at any time using CSR_WIFI_SME_SCAN_FULL_REQ.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ scanConfig - Reports the configuration for the autonomous scanning behaviour
+ of the firmware
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeScanConfig scanConfig;
+} CsrWifiSmeScanConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanFullReq
+
+ DESCRIPTION
+ The wireless manager application should call this primitive to request a
+ full scan.
+ Channels are scanned actively or passively according to the requirement
+ set by regulatory domain.
+ If the SME receives this primitive while a full scan is going on, the new
+ request is buffered and it will be served after the current full scan is
+ completed.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ ssidCount - Number of SSIDs provided.
+ If it is 0, the SME will attempt to detect any network
+ ssid - Points to the first SSID provided, if any.
+ bssid - BSS identifier.
+ If it is equal to FF-FF-FF-FF-FF, the SME will listen for
+ messages from any BSS.
+ If it is different from FF-FF-FF-FF-FF and any SSID is
+ provided, one SSID must match the network of the BSS.
+ forceScan - Forces the scan even if the SME is in a state which would
+ normally prevent it (e.g. autonomous scan is running).
+ bssType - Type of BSS to scan for
+ scanType - Type of scan to perform
+ channelListCount - Number of channels provided.
+ If it is 0, the SME will initiate a scan of all the
+ supported channels that are permitted by the current
+ regulatory domain.
+ channelList - Points to the first channel , or NULL if channelListCount
+ is zero.
+ probeIeLength - Length of the information element in bytes to be sent
+ with the probe message.
+ probeIe - Points to the first byte of the information element to be
+ sent with the probe message.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint8 ssidCount;
+ CsrWifiSsid *ssid;
+ CsrWifiMacAddress bssid;
+ CsrBool forceScan;
+ CsrWifiSmeBssType bssType;
+ CsrWifiSmeScanType scanType;
+ CsrUint16 channelListCount;
+ CsrUint8 *channelList;
+ CsrUint16 probeIeLength;
+ CsrUint8 *probeIe;
+} CsrWifiSmeScanFullReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResultsFlushReq
+
+ DESCRIPTION
+ The Wireless Manager calls this primitive to ask the SME to delete all
+ scan results from its cache, except for the scan result of any currently
+ connected network.
+ As scan results are received by the SME from the firmware, they are
+ cached in the SME memory.
+ Any time the Wireless Manager requests scan results, they are returned
+ from the SME internal cache.
+ For some applications it may be desirable to clear this cache prior to
+ requesting that a scan be performed; this will ensure that the cache then
+ only contains the networks detected in the most recent scan.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeScanResultsFlushReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResultsGetReq
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to retrieve the
+ current set of scan results, either after receiving a successful
+ CSR_WIFI_SME_SCAN_FULL_CFM, or to get autonomous scan results.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeScanResultsGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeStaConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the SmeStaConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+} CsrWifiSmeSmeStaConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeStaConfigSetReq
+
+ DESCRIPTION
+ This primitive sets the value of the SmeConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ smeConfig - SME Station Parameters to be set
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeStaConfig smeConfig;
+} CsrWifiSmeSmeStaConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeStationMacAddressGetReq
+
+ DESCRIPTION
+ This primitives is used to retrieve the current MAC address used by the
+ station.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeStationMacAddressGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTspecReq
+
+ DESCRIPTION
+ The wireless manager application should call this primitive to use the
+ TSPEC feature.
+ The chip supports the use of TSPECs and TCLAS for the use of IEEE
+ 802.11/WMM Quality of Service features.
+ The API allows the wireless manager application to supply a correctly
+ formatted TSPEC and TCLAS pair to the driver.
+ After performing basic validation, the driver negotiates the installation
+ of the TSPEC with the AP as defined by the 802.11 specification.
+ The driver retains all TSPEC and TCLAS pairs until they are specifically
+ removed.
+ It is not compulsory for a TSPEC to have a TCLAS (NULL is used to
+ indicate that no TCLAS is supplied), while a TCLASS always require a
+ TSPEC.
+ The format of the TSPEC element is specified in 'WMM (including WMM Power
+ Save) Specification - Version 1.1' and 'ANSI/IEEE Std 802.11-REVmb/D3.0'.
+ For more information, see 'UniFi Configuring WMM and WMM-PS'.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ action - Specifies the action to be carried out on the list of TSPECs.
+ CSR_WIFI_SME_LIST_ACTION_FLUSH is not applicable here.
+ transactionId - Unique Transaction ID for the TSPEC, as assigned by the
+ driver
+ strict - If it set to false, allows the SME to perform automatic
+ TSPEC negotiation
+ ctrlMask - Additional TSPEC configuration for CCX.
+ Set mask with values from CsrWifiSmeTspecCtrl.
+ CURRENTLY NOT SUPPORTED
+ tspecLength - Length of the TSPEC.
+ tspec - Points to the first byte of the TSPEC
+ tclasLength - Length of the TCLAS.
+ If it is equal to 0, no TCLASS is provided for the TSPEC
+ tclas - Points to the first byte of the TCLAS, if any.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeListAction action;
+ CsrUint32 transactionId;
+ CsrBool strict;
+ CsrWifiSmeTspecCtrlMask ctrlMask;
+ CsrUint16 tspecLength;
+ CsrUint8 *tspec;
+ CsrUint16 tclasLength;
+ CsrUint8 *tclas;
+} CsrWifiSmeTspecReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeVersionsGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the Versions parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeVersionsGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiFlightmodeReq
+
+ DESCRIPTION
+ The wireless manager application may call this primitive on boot-up of
+ the platform to ensure that the chip is placed in a mode that prevents
+ any emission of RF energy.
+ This primitive is an alternative to CSR_WIFI_SME_WIFI_ON_REQ.
+ As in CSR_WIFI_SME_WIFI_ON_REQ, it causes the download of the patch file
+ (if any) and the programming of the initial MIB settings (if supplied by
+ the WMA), but it also ensures that the chip is left in its lowest
+ possible power-mode with the radio subsystems disabled.
+ This feature is useful on platforms where power cannot be removed from
+ the chip (leaving the chip not initialised will cause it to consume more
+ power so calling this function ensures that the chip is initialised into
+ a low power mode but without entering a state where it could emit any RF
+ energy).
+ NOTE: this primitive does not cause the Wi-Fi to change state: Wi-Fi
+ stays conceptually off. Configuration primitives can be sent after
+ CSR_WIFI_SME_WIFI_FLIGHTMODE_REQ and the configuration will be maintained.
+ Requests that require the state of the Wi-Fi to be ON will return
+ CSR_WIFI_SME_STATUS_WIFI_OFF in their confirms.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ address - Optionally specifies a station MAC address.
+ In normal use, the manager should set the address to 0xFF
+ 0xFF 0xFF 0xFF 0xFF 0xFF, which will cause the chip to use
+ the MAC address in the MIB.
+ mibFilesCount - Number of provided data blocks with initial MIB values
+ mibFiles - Points to the first data block with initial MIB values.
+ These data blocks are typically the contents of the provided
+ files ufmib.dat and localmib.dat, available from the host
+ file system, if they exist.
+ These files typically contain radio tuning and calibration
+ values.
+ More values can be created using the Host Tools.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiMacAddress address;
+ CsrUint16 mibFilesCount;
+ CsrWifiSmeDataBlock *mibFiles;
+} CsrWifiSmeWifiFlightmodeReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOffReq
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to turn off the
+ chip, thus saving power when Wi-Fi is not in use.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeWifiOffReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOnReq
+
+ DESCRIPTION
+ The wireless manager application calls this primitive to turn on the
+ Wi-Fi chip.
+ If the Wi-Fi chip is currently off, the SME turns the Wi-Fi chip on,
+ downloads the patch file (if any), and programs the initial MIB settings
+ (if supplied by the WMA).
+ The patch file is not provided with the SME API; its downloading is
+ automatic and handled internally by the system.
+ The MIB settings, when provided, override the default values that the
+ firmware loads from EEPROM.
+ If the Wi-Fi chip is already on, the SME takes no action and returns a
+ successful status in the confirm.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ address - Optionally specifies a station MAC address.
+ In normal use, the manager should set the address to 0xFF
+ 0xFF 0xFF 0xFF 0xFF 0xFF, which will cause the chip to use
+ the MAC address in the MIB
+ mibFilesCount - Number of provided data blocks with initial MIB values
+ mibFiles - Points to the first data block with initial MIB values.
+ These data blocks are typically the contents of the provided
+ files ufmib.dat and localmib.dat, available from the host
+ file system, if they exist.
+ These files typically contain radio tuning and calibration
+ values.
+ More values can be created using the Host Tools.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiMacAddress address;
+ CsrUint16 mibFilesCount;
+ CsrWifiSmeDataBlock *mibFiles;
+} CsrWifiSmeWifiOnReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCloakedSsidsSetReq
+
+ DESCRIPTION
+ This primitive sets the list of cloaked SSIDs for which the WMA possesses
+ profiles.
+ When the driver detects a cloaked AP, the SME will explicitly scan for it
+ using the list of cloaked SSIDs provided it, and, if the scan succeeds,
+ it will report the AP to the WMA either via CSR_WIFI_SME_SCAN_RESULT_IND
+ (if registered) or via CSR_WIFI_SCAN_RESULT_GET_CFM.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ cloakedSsids - Sets the list of cloaked SSIDs
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeCloakedSsidConfig cloakedSsids;
+} CsrWifiSmeCloakedSsidsSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCloakedSsidsGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the CloakedSsids parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeCloakedSsidsGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeCommonConfigGetReq
+
+ DESCRIPTION
+ This primitive gets the value of the Sme common parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeSmeCommonConfigGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeCommonConfigSetReq
+
+ DESCRIPTION
+ This primitive sets the value of the Sme common.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ deviceConfig - Configuration options in the SME
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeDeviceConfig deviceConfig;
+} CsrWifiSmeSmeCommonConfigSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeInterfaceCapabilityGetReq
+
+ DESCRIPTION
+ The Wireless Manager calls this primitive to ask the SME for the
+ capabilities of the supported interfaces
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+} CsrWifiSmeInterfaceCapabilityGetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsConfigurationReq
+
+ DESCRIPTION
+ This primitive passes the WPS information for the device to SME. This may
+ be accepted only if no interface is active.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ wpsConfig - WPS config.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeWpsConfig wpsConfig;
+} CsrWifiSmeWpsConfigurationReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSetReq
+
+ DESCRIPTION
+ Used to pass custom data to the SME. Format is the same as 802.11 Info
+ Elements => | Id | Length | Data
+ 1) Cmanr Test Mode "Id:0 Length:1 Data:0x00 = OFF 0x01 = ON" "0x00 0x01
+ (0x00|0x01)"
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ dataLength - Number of bytes in the buffer pointed to by 'data'
+ data - Pointer to the buffer containing 'dataLength' bytes
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint32 dataLength;
+ CsrUint8 *data;
+} CsrWifiSmeSetReq;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeActivateCfm
+
+ DESCRIPTION
+ The SME sends this primitive when the activation is complete.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeActivateCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAdhocConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ adHocConfig - Contains the values used when starting an Ad-hoc (IBSS)
+ connection.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiSmeAdHocConfig adHocConfig;
+} CsrWifiSmeAdhocConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAdhocConfigSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeAdhocConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAssociationCompleteInd
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive it whenever it completes an attempt to associate with an AP. If
+ the association was successful, status will be set to
+ CSR_WIFI_SME_STATUS_SUCCESS, otherwise status and deauthReason shall be
+ set to appropriate error codes.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the association procedure
+ connectionInfo - This parameter is relevant only if result is
+ CSR_WIFI_SME_STATUS_SUCCESS:
+ it points to the connection information for the new network
+ deauthReason - This parameter is relevant only if result is not
+ CSR_WIFI_SME_STATUS_SUCCESS:
+ if the AP deauthorised the station, it gives the reason of
+ the deauthorization
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeConnectionInfo connectionInfo;
+ CsrWifiSmeIEEE80211Reason deauthReason;
+} CsrWifiSmeAssociationCompleteInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAssociationStartInd
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive it whenever it begins an attempt to associate with an AP.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ address - BSSID of the associating network
+ ssid - Service Set identifier of the associating network
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress address;
+ CsrWifiSsid ssid;
+} CsrWifiSmeAssociationStartInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeBlacklistCfm
+
+ DESCRIPTION
+ The SME will call this primitive when the action on the blacklist has
+ completed. For a GET action, this primitive also reports the list of
+ BBSIDs in the blacklist.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ action - Action in the request
+ getAddressCount - This parameter is only relevant if action is
+ CSR_WIFI_SME_LIST_ACTION_GET:
+ number of BSSIDs sent with this primitive
+ getAddresses - Pointer to the list of BBSIDs sent with the primitive, set
+ to NULL if none is sent.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeListAction action;
+ CsrUint8 getAddressCount;
+ CsrWifiMacAddress *getAddresses;
+} CsrWifiSmeBlacklistCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCalibrationDataGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ calibrationDataLength - Number of bytes in the buffer pointed by
+ calibrationData
+ calibrationData - Pointer to a buffer of length calibrationDataLength
+ containing the calibration data
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrUint16 calibrationDataLength;
+ CsrUint8 *calibrationData;
+} CsrWifiSmeCalibrationDataGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCalibrationDataSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeCalibrationDataSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCcxConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ ccxConfig - Currently not supported
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeCcxConfig ccxConfig;
+} CsrWifiSmeCcxConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCcxConfigSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeCcxConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ coexConfig - Reports the parameters used to configure the coexistence
+ behaviour
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiSmeCoexConfig coexConfig;
+} CsrWifiSmeCoexConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexConfigSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeCoexConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoexInfoGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ coexInfo - Reports information and state related to coexistence.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiSmeCoexInfo coexInfo;
+} CsrWifiSmeCoexInfoGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectCfm
+
+ DESCRIPTION
+ The SME calls this primitive when the connection exchange is complete or
+ all connection attempts fail.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request.
+ CSR_WIFI_SME_STATUS_NOT_FOUND: all attempts by the SME to
+ locate the requested AP failed
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeConnectCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ connectionConfig - Parameters used by the SME for selecting a network
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeConnectionConfig connectionConfig;
+} CsrWifiSmeConnectionConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionInfoGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ connectionInfo - Information about the current connection
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeConnectionInfo connectionInfo;
+} CsrWifiSmeConnectionInfoGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionQualityInd
+
+ DESCRIPTION
+ The SME sends this primitive to all the tasks that have registered to
+ receive it whenever the value of the current connection quality
+ parameters change by more than a certain configurable amount.
+ The wireless manager application may configure the trigger thresholds for
+ this indication using the field in smeConfig parameter of
+ CSR_WIFI_SME_SME_CONFIG_SET_REQ.
+ Connection quality messages can be suppressed by setting both thresholds
+ to zero.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ linkQuality - Indicates the quality of the link
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeLinkQuality linkQuality;
+} CsrWifiSmeConnectionQualityInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeConnectionStatsGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ connectionStats - Statistics for current connection.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeConnectionStats connectionStats;
+} CsrWifiSmeConnectionStatsGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDeactivateCfm
+
+ DESCRIPTION
+ The SME sends this primitive when the deactivation is complete.
+ The WMA cannot send any more primitives until it actives the SME again
+ sending another CSR_WIFI_SME_ACTIVATE_REQ.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeDeactivateCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeDisconnectCfm
+
+ DESCRIPTION
+ On reception of CSR_WIFI_SME_DISCONNECT_REQ the SME will perform a
+ disconnect operation, sending a CsrWifiSmeMediaStatusInd with
+ CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED and then call this primitive when
+ disconnection is complete.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeDisconnectCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeEventMaskSetCfm
+
+ DESCRIPTION
+ The SME calls the primitive to report the result of the request
+ primitive.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeEventMaskSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeHostConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ hostConfig - Current host power state.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeHostConfig hostConfig;
+} CsrWifiSmeHostConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeHostConfigSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeHostConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeIbssStationInd
+
+ DESCRIPTION
+ The SME will send this primitive to indicate that a station has joined or
+ left the ad-hoc network.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ address - MAC address of the station that has joined or left
+ isconnected - TRUE if the station joined, FALSE if the station left
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiMacAddress address;
+ CsrBool isconnected;
+} CsrWifiSmeIbssStationInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeKeyCfm
+
+ DESCRIPTION
+ The SME calls the primitive to report the result of the request
+ primitive.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ action - Action in the request
+ keyType - Type of the key added/deleted
+ peerMacAddress - Peer MAC Address of the key added/deleted
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeListAction action;
+ CsrWifiSmeKeyType keyType;
+ CsrWifiMacAddress peerMacAddress;
+} CsrWifiSmeKeyCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeLinkQualityGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ linkQuality - Indicates the quality of the link
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeLinkQuality linkQuality;
+} CsrWifiSmeLinkQualityGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMediaStatusInd
+
+ DESCRIPTION
+ The SME sends this primitive to all the tasks that have registered to
+ receive it when a network connection is established, lost or has moved to
+ another AP.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ mediaStatus - Indicates the media status
+ connectionInfo - This parameter is relevant only if the mediaStatus is
+ CSR_WIFI_SME_MEDIA_STATUS_CONNECTED:
+ it points to the connection information for the new network
+ disassocReason - This parameter is relevant only if the mediaStatus is
+ CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED:
+ if a disassociation has occurred it gives the reason of the
+ disassociation
+ deauthReason - This parameter is relevant only if the mediaStatus is
+ CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED:
+ if a deauthentication has occurred it gives the reason of
+ the deauthentication
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeMediaStatus mediaStatus;
+ CsrWifiSmeConnectionInfo connectionInfo;
+ CsrWifiSmeIEEE80211Reason disassocReason;
+ CsrWifiSmeIEEE80211Reason deauthReason;
+} CsrWifiSmeMediaStatusInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ mibConfig - Reports various IEEE 802.11 attributes as currently configured
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiSmeMibConfig mibConfig;
+} CsrWifiSmeMibConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibConfigSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeMibConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibGetCfm
+
+ DESCRIPTION
+ The SME calls this primitive to return the requested MIB variable values.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ mibAttributeLength - Length of mibAttribute
+ mibAttribute - Points to the VarBind or VarBindList containing the
+ names and values of the MIB variables requested
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrUint16 mibAttributeLength;
+ CsrUint8 *mibAttribute;
+} CsrWifiSmeMibGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibGetNextCfm
+
+ DESCRIPTION
+ The SME calls this primitive to return the requested MIB name(s).
+ The wireless manager application can then read the value of the MIB
+ variable using CSR_WIFI_SME_MIB_GET_REQ, using the names provided.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ mibAttributeLength - Length of mibAttribute
+ mibAttribute - Points to a VarBind or VarBindList containing the
+ name(s) of the MIB variable(s) lexicographically
+ following the name(s) given in the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrUint16 mibAttributeLength;
+ CsrUint8 *mibAttribute;
+} CsrWifiSmeMibGetNextCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMibSetCfm
+
+ DESCRIPTION
+ The SME calls the primitive to report the result of the set primitive.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeMibSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMicFailureInd
+
+ DESCRIPTION
+ The SME sends this primitive to all the tasks that have registered to
+ receive it whenever the chip firmware reports a MIC failure.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ secondFailure - TRUE if this indication is for a second failure in 60
+ seconds
+ count - The number of MIC failure events since the connection was
+ established
+ address - MAC address of the transmitter that caused the MIC failure
+ keyType - Type of key for which the failure occurred
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrBool secondFailure;
+ CsrUint16 count;
+ CsrWifiMacAddress address;
+ CsrWifiSmeKeyType keyType;
+} CsrWifiSmeMicFailureInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeMulticastAddressCfm
+
+ DESCRIPTION
+ The SME will call this primitive when the operation is complete. For a
+ GET action, this primitive reports the current list of MAC addresses.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ action - Action in the request
+ getAddressesCount - This parameter is only relevant if action is
+ CSR_WIFI_SME_LIST_ACTION_GET:
+ number of MAC addresses sent with the primitive
+ getAddresses - Pointer to the list of MAC Addresses sent with the
+ primitive, set to NULL if none is sent.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeListAction action;
+ CsrUint8 getAddressesCount;
+ CsrWifiMacAddress *getAddresses;
+} CsrWifiSmeMulticastAddressCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePacketFilterSetCfm
+
+ DESCRIPTION
+ The SME calls the primitive to report the result of the set primitive.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmePacketFilterSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePermanentMacAddressGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ permanentMacAddress - MAC address stored in the EEPROM
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiMacAddress permanentMacAddress;
+} CsrWifiSmePermanentMacAddressGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePmkidCandidateListInd
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive it when a new network supporting preauthentication and/or PMK
+ caching is seen.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an
+ interface
+ pmkidCandidatesCount - Number of PMKID candidates provided
+ pmkidCandidates - Points to the first PMKID candidate
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint8 pmkidCandidatesCount;
+ CsrWifiSmePmkidCandidate *pmkidCandidates;
+} CsrWifiSmePmkidCandidateListInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePmkidCfm
+
+ DESCRIPTION
+ The SME will call this primitive when the operation is complete. For a
+ GET action, this primitive reports the current list of PMKIDs
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ action - Action in the request
+ getPmkidsCount - This parameter is only relevant if action is
+ CSR_WIFI_SME_LIST_ACTION_GET:
+ number of PMKIDs sent with the primitive
+ getPmkids - Pointer to the list of PMKIDs sent with the primitive, set
+ to NULL if none is sent.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeListAction action;
+ CsrUint8 getPmkidsCount;
+ CsrWifiSmePmkid *getPmkids;
+} CsrWifiSmePmkidCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePowerConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ powerConfig - Returns the current parameters for the power configuration of
+ the firmware
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiSmePowerConfig powerConfig;
+} CsrWifiSmePowerConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmePowerConfigSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmePowerConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRegulatoryDomainInfoGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ regDomInfo - Reports information and state related to regulatory domain
+ operation.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiSmeRegulatoryDomainInfo regDomInfo;
+} CsrWifiSmeRegulatoryDomainInfoGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamCompleteInd
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive it whenever it completes an attempt to roam to an AP. If the roam
+ attempt was successful, status will be set to CSR_WIFI_SME_SUCCESS,
+ otherwise it shall be set to the appropriate error code.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the roaming procedure
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeRoamCompleteInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamStartInd
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive it whenever it begins an attempt to roam to an AP.
+ If the wireless manager application connect request specified the SSID
+ and the BSSID was set to the broadcast address (0xFF 0xFF 0xFF 0xFF 0xFF
+ 0xFF), the SME monitors the signal quality and maintains a list of
+ candidates to roam to. When the signal quality of the current connection
+ falls below a threshold, and there is a candidate with better quality,
+ the SME will attempt to the candidate AP.
+ If the roaming procedure succeeds, the SME will also issue a Media
+ Connect indication to inform the wireless manager application of the
+ change.
+ NOTE: to prevent the SME from initiating roaming the WMA must specify the
+ BSSID in the connection request; this forces the SME to connect only to
+ that AP.
+ The wireless manager application can obtain statistics for roaming
+ purposes using CSR_WIFI_SME_CONNECTION_QUALITY_IND and
+ CSR_WIFI_SME_CONNECTION_STATS_GET_REQ.
+ When the wireless manager application wishes to roam to another AP, it
+ must issue a connection request specifying the BSSID of the desired AP.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ roamReason - Indicates the reason for starting the roaming procedure
+ reason80211 - Indicates the reason for deauthentication or disassociation
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeRoamReason roamReason;
+ CsrWifiSmeIEEE80211Reason reason80211;
+} CsrWifiSmeRoamStartInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamingConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ roamingConfig - Reports the roaming behaviour of the driver and firmware
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeRoamingConfig roamingConfig;
+} CsrWifiSmeRoamingConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeRoamingConfigSetCfm
+
+ DESCRIPTION
+ This primitive sets the value of the RoamingConfig parameter.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeRoamingConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ scanConfig - Returns the current parameters for the autonomous scanning
+ behaviour of the firmware
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiSmeScanConfig scanConfig;
+} CsrWifiSmeScanConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanConfigSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeScanConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanFullCfm
+
+ DESCRIPTION
+ The SME calls this primitive when the results from the scan are
+ available.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeScanFullCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResultInd
+
+ DESCRIPTION
+ The SME sends this primitive to all the tasks that have registered to
+ receive it whenever a scan indication is received from the firmware.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ result - Points to a buffer containing a scan result.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeScanResult result;
+} CsrWifiSmeScanResultInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResultsFlushCfm
+
+ DESCRIPTION
+ The SME will call this primitive when the cache has been cleared.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeScanResultsFlushCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeScanResultsGetCfm
+
+ DESCRIPTION
+ The SME sends this primitive to provide the current set of scan results.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ scanResultsCount - Number of scan results
+ scanResults - Points to a buffer containing an array of
+ CsrWifiSmeScanResult structures.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrUint16 scanResultsCount;
+ CsrWifiSmeScanResult *scanResults;
+} CsrWifiSmeScanResultsGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeStaConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ smeConfig - Current SME Station Parameters
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrWifiSmeStaConfig smeConfig;
+} CsrWifiSmeSmeStaConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeStaConfigSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+} CsrWifiSmeSmeStaConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeStationMacAddressGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ stationMacAddress - Current MAC address of the station.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiMacAddress stationMacAddress[2];
+} CsrWifiSmeStationMacAddressGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTspecInd
+
+ DESCRIPTION
+ The SME will send this primitive to all the task that have registered to
+ receive it when a status change in the TSPEC occurs.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ transactionId - Unique Transaction ID for the TSPEC, as assigned by the
+ driver
+ tspecResultCode - Specifies the TSPEC operation requested by the peer
+ station
+ tspecLength - Length of the TSPEC.
+ tspec - Points to the first byte of the TSPEC
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrUint32 transactionId;
+ CsrWifiSmeTspecResultCode tspecResultCode;
+ CsrUint16 tspecLength;
+ CsrUint8 *tspec;
+} CsrWifiSmeTspecInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeTspecCfm
+
+ DESCRIPTION
+ The SME calls the primitive to report the result of the TSpec primitive
+ request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface Identifier; unique identifier of an interface
+ status - Reports the result of the request
+ transactionId - Unique Transaction ID for the TSPEC, as assigned by the
+ driver
+ tspecResultCode - Specifies the result of the negotiated TSPEC operation
+ tspecLength - Length of the TSPEC.
+ tspec - Points to the first byte of the TSPEC
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrResult status;
+ CsrUint32 transactionId;
+ CsrWifiSmeTspecResultCode tspecResultCode;
+ CsrUint16 tspecLength;
+ CsrUint8 *tspec;
+} CsrWifiSmeTspecCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeVersionsGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ versions - Version IDs of the product
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiSmeVersions versions;
+} CsrWifiSmeVersionsGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiFlightmodeCfm
+
+ DESCRIPTION
+ The SME calls this primitive when the chip is initialised for low power
+ mode and with the radio subsystem disabled. To leave flight mode, and
+ enable Wi-Fi, the wireless manager application should call
+ CSR_WIFI_SME_WIFI_ON_REQ.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeWifiFlightmodeCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOffInd
+
+ DESCRIPTION
+ The SME sends this primitive to all the tasks that have registered to
+ receive it to report that the chip has been turned off.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ reason - Indicates the reason why the Wi-Fi has been switched off.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiSmeControlIndication reason;
+} CsrWifiSmeWifiOffInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOffCfm
+
+ DESCRIPTION
+ After receiving CSR_WIFI_SME_WIFI_OFF_REQ, if the chip is connected to a
+ network, the SME will perform a disconnect operation, will send a
+ CSR_WIFI_SME_MEDIA_STATUS_IND with
+ CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED, and then will call
+ CSR_WIFI_SME_WIFI_OFF_CFM when the chip is off.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeWifiOffCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOnCfm
+
+ DESCRIPTION
+ The SME sends this primitive to the task that has sent the request once
+ the chip has been initialised and is available for use.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeWifiOnCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCloakedSsidsSetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeCloakedSsidsSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCloakedSsidsGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ cloakedSsids - Reports list of cloaked SSIDs that are explicitly scanned for
+ by the driver
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiSmeCloakedSsidConfig cloakedSsids;
+} CsrWifiSmeCloakedSsidsGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWifiOnInd
+
+ DESCRIPTION
+ The SME sends this primitive to all tasks that have registered to receive
+ it once the chip becomes available and ready to use.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ address - Current MAC address
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrWifiMacAddress address;
+} CsrWifiSmeWifiOnInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeCommonConfigGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+ deviceConfig - Configuration options in the SME
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrWifiSmeDeviceConfig deviceConfig;
+} CsrWifiSmeSmeCommonConfigGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeSmeCommonConfigSetCfm
+
+ DESCRIPTION
+ Reports the result of the request
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Reports the result of the request
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeSmeCommonConfigSetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeInterfaceCapabilityGetCfm
+
+ DESCRIPTION
+ This primitive reports the result of the request.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Result of the request
+ numInterfaces - Number of the interfaces supported
+ capBitmap - Points to the list of capabilities bitmaps provided for each
+ interface.
+ The bits represent the following capabilities:
+ -bits 7 to 4-Reserved
+ -bit 3-AMP
+ -bit 2-P2P
+ -bit 1-AP
+ -bit 0-STA
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+ CsrUint16 numInterfaces;
+ CsrUint8 capBitmap[2];
+} CsrWifiSmeInterfaceCapabilityGetCfm;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeErrorInd
+
+ DESCRIPTION
+ Important error message indicating a error of some importance
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ errorMessage - Contains the error message.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrCharString *errorMessage;
+} CsrWifiSmeErrorInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeInfoInd
+
+ DESCRIPTION
+ Message indicating a some info about current activity. Mostly of interest
+ in testing but may be useful in the field.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ infoMessage - Contains the message.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrCharString *infoMessage;
+} CsrWifiSmeInfoInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeCoreDumpInd
+
+ DESCRIPTION
+ The SME will send this primitive to all the tasks that have registered to
+ receive Wi-Fi Chip core dump data.
+ The core dump data may be fragmented and sent using more than one
+ indication.
+ To indicate that all the data has been sent, the last indication contains
+ a 'length' of 0 and 'data' of NULL.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ dataLength - Number of bytes in the buffer pointed to by 'data'
+ data - Pointer to the buffer containing 'dataLength' bytes of core
+ dump data
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint32 dataLength;
+ CsrUint8 *data;
+} CsrWifiSmeCoreDumpInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeAmpStatusChangeInd
+
+ DESCRIPTION
+ Indication of change to AMP activity.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ interfaceTag - Interface on which the AMP activity changed.
+ ampStatus - The new status of AMP activity.Range: {AMP_ACTIVE,
+ AMP_INACTIVE}.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrUint16 interfaceTag;
+ CsrWifiSmeAmpStatus ampStatus;
+} CsrWifiSmeAmpStatusChangeInd;
+
+/*******************************************************************************
+
+ NAME
+ CsrWifiSmeWpsConfigurationCfm
+
+ DESCRIPTION
+ Confirm.
+
+ MEMBERS
+ common - Common header for use with the CsrWifiFsm Module
+ status - Status of the request.
+
+*******************************************************************************/
+typedef struct
+{
+ CsrWifiFsmEvent common;
+ CsrResult status;
+} CsrWifiSmeWpsConfigurationCfm;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_SME_PRIM_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ Confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+ *****************************************************************************/
+#include "csr_wifi_sme_sef.h"
+
+const CsrWifiSmeStateHandlerType CsrWifiSmeUpstreamStateHandlers[CSR_WIFI_SME_PRIM_UPSTREAM_COUNT] =
+{
+ /* 0x8000 */ CsrWifiSmeActivateCfmHandler,
+ /* 0x8001 */ CsrWifiSmeAdhocConfigGetCfmHandler,
+ /* 0x8002 */ CsrWifiSmeAdhocConfigSetCfmHandler,
+ /* 0x8003 */ CsrWifiSmeAssociationCompleteIndHandler,
+ /* 0x8004 */ CsrWifiSmeAssociationStartIndHandler,
+ /* 0x8005 */ CsrWifiSmeBlacklistCfmHandler,
+ /* 0x8006 */ CsrWifiSmeCalibrationDataGetCfmHandler,
+ /* 0x8007 */ CsrWifiSmeCalibrationDataSetCfmHandler,
+ /* 0x8008 */ CsrWifiSmeCcxConfigGetCfmHandler,
+ /* 0x8009 */ CsrWifiSmeCcxConfigSetCfmHandler,
+ /* 0x800A */ CsrWifiSmeCoexConfigGetCfmHandler,
+ /* 0x800B */ CsrWifiSmeCoexConfigSetCfmHandler,
+ /* 0x800C */ CsrWifiSmeCoexInfoGetCfmHandler,
+ /* 0x800D */ CsrWifiSmeConnectCfmHandler,
+ /* 0x800E */ CsrWifiSmeConnectionConfigGetCfmHandler,
+ /* 0x800F */ CsrWifiSmeConnectionInfoGetCfmHandler,
+ /* 0x8010 */ CsrWifiSmeConnectionQualityIndHandler,
+ /* 0x8011 */ CsrWifiSmeConnectionStatsGetCfmHandler,
+ /* 0x8012 */ CsrWifiSmeDeactivateCfmHandler,
+ /* 0x8013 */ CsrWifiSmeDisconnectCfmHandler,
+ /* 0x8014 */ CsrWifiSmeEventMaskSetCfmHandler,
+ /* 0x8015 */ CsrWifiSmeHostConfigGetCfmHandler,
+ /* 0x8016 */ CsrWifiSmeHostConfigSetCfmHandler,
+ /* 0x8017 */ CsrWifiSmeIbssStationIndHandler,
+ /* 0x8018 */ CsrWifiSmeKeyCfmHandler,
+ /* 0x8019 */ CsrWifiSmeLinkQualityGetCfmHandler,
+ /* 0x801A */ CsrWifiSmeMediaStatusIndHandler,
+ /* 0x801B */ CsrWifiSmeMibConfigGetCfmHandler,
+ /* 0x801C */ CsrWifiSmeMibConfigSetCfmHandler,
+ /* 0x801D */ CsrWifiSmeMibGetCfmHandler,
+ /* 0x801E */ CsrWifiSmeMibGetNextCfmHandler,
+ /* 0x801F */ CsrWifiSmeMibSetCfmHandler,
+ /* 0x8020 */ CsrWifiSmeMicFailureIndHandler,
+ /* 0x8021 */ CsrWifiSmeMulticastAddressCfmHandler,
+ /* 0x8022 */ CsrWifiSmePacketFilterSetCfmHandler,
+ /* 0x8023 */ CsrWifiSmePermanentMacAddressGetCfmHandler,
+ /* 0x8024 */ CsrWifiSmePmkidCandidateListIndHandler,
+ /* 0x8025 */ CsrWifiSmePmkidCfmHandler,
+ /* 0x8026 */ CsrWifiSmePowerConfigGetCfmHandler,
+ /* 0x8027 */ CsrWifiSmePowerConfigSetCfmHandler,
+ /* 0x8028 */ CsrWifiSmeRegulatoryDomainInfoGetCfmHandler,
+ /* 0x8029 */ CsrWifiSmeRoamCompleteIndHandler,
+ /* 0x802A */ CsrWifiSmeRoamStartIndHandler,
+ /* 0x802B */ CsrWifiSmeRoamingConfigGetCfmHandler,
+ /* 0x802C */ CsrWifiSmeRoamingConfigSetCfmHandler,
+ /* 0x802D */ CsrWifiSmeScanConfigGetCfmHandler,
+ /* 0x802E */ CsrWifiSmeScanConfigSetCfmHandler,
+ /* 0x802F */ CsrWifiSmeScanFullCfmHandler,
+ /* 0x8030 */ CsrWifiSmeScanResultIndHandler,
+ /* 0x8031 */ CsrWifiSmeScanResultsFlushCfmHandler,
+ /* 0x8032 */ CsrWifiSmeScanResultsGetCfmHandler,
+ /* 0x8033 */ CsrWifiSmeSmeStaConfigGetCfmHandler,
+ /* 0x8034 */ CsrWifiSmeSmeStaConfigSetCfmHandler,
+ /* 0x8035 */ CsrWifiSmeStationMacAddressGetCfmHandler,
+ /* 0x8036 */ CsrWifiSmeTspecIndHandler,
+ /* 0x8037 */ CsrWifiSmeTspecCfmHandler,
+ /* 0x8038 */ CsrWifiSmeVersionsGetCfmHandler,
+ /* 0x8039 */ CsrWifiSmeWifiFlightmodeCfmHandler,
+ /* 0x803A */ CsrWifiSmeWifiOffIndHandler,
+ /* 0x803B */ CsrWifiSmeWifiOffCfmHandler,
+ /* 0x803C */ CsrWifiSmeWifiOnCfmHandler,
+ /* 0x803D */ CsrWifiSmeCloakedSsidsSetCfmHandler,
+ /* 0x803E */ CsrWifiSmeCloakedSsidsGetCfmHandler,
+ /* 0x803F */ CsrWifiSmeWifiOnIndHandler,
+ /* 0x8040 */ CsrWifiSmeSmeCommonConfigGetCfmHandler,
+ /* 0x8041 */ CsrWifiSmeSmeCommonConfigSetCfmHandler,
+ /* 0x8042 */ CsrWifiSmeGetInterfaceCapabilityCfmHandler,
+ /* 0x8043 */ CsrWifiSmeErrorIndHandler,
+ /* 0x8044 */ CsrWifiSmeInfoIndHandler,
+ /* 0x8045 */ CsrWifiSmeCoreDumpIndHandler,
+ /* 0x8046 */ CsrWifiSmeAmpStatusChangeIndHandler,
+};
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2010
+ Confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+#ifndef CSR_WIFI_ROUTER_SEF_CSR_WIFI_SME_H__
+#define CSR_WIFI_ROUTER_SEF_CSR_WIFI_SME_H__
+
+#include "csr_wifi_sme_prim.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*CsrWifiSmeStateHandlerType)(void* drvpriv, CsrWifiFsmEvent* msg);
+
+extern const CsrWifiSmeStateHandlerType CsrWifiSmeUpstreamStateHandlers[CSR_WIFI_SME_PRIM_UPSTREAM_COUNT];
+
+
+extern void CsrWifiSmeActivateCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeAdhocConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeAdhocConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeAssociationCompleteIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeAssociationStartIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeBlacklistCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeCalibrationDataGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeCalibrationDataSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeCcxConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeCcxConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeCoexConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeCoexConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeCoexInfoGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeConnectCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeConnectionConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeConnectionInfoGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeConnectionQualityIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeConnectionStatsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeDeactivateCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeDisconnectCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeEventMaskSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeHostConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeHostConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeIbssStationIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeKeyCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeLinkQualityGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeMediaStatusIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeMibConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeMibConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeMibGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeMibGetNextCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeMibSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeMicFailureIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeMulticastAddressCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmePacketFilterSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmePermanentMacAddressGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmePmkidCandidateListIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmePmkidCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmePowerConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmePowerConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeRegulatoryDomainInfoGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeRoamCompleteIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeRoamStartIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeRoamingConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeRoamingConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeScanConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeScanConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeScanFullCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeScanResultIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeScanResultsFlushCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeScanResultsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeSmeStaConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeSmeStaConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeStationMacAddressGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeTspecIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeTspecCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeVersionsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeWifiFlightmodeCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeWifiOffIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeWifiOffCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeWifiOnCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeCloakedSsidsSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeCloakedSsidsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeWifiOnIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeSmeCommonConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeSmeCommonConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeGetInterfaceCapabilityCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeErrorIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeInfoIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeCoreDumpIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+extern void CsrWifiSmeAmpStatusChangeIndHandler(void* drvpriv, CsrWifiFsmEvent* msg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_ROUTER_SEF_CSR_WIFI_SME_H__ */
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#include "csr_pmem.h"
+#include "csr_msgconv.h"
+#include "csr_unicode.h"
+
+
+#include "csr_wifi_sme_prim.h"
+#include "csr_wifi_sme_serialize.h"
+
+void CsrWifiSmePfree(void *ptr)
+{
+ CsrPmemFree(ptr);
+}
+
+
+CsrSize CsrWifiSmeAdhocConfigSetReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
+ bufferSize += 2; /* CsrUint16 primitive->adHocConfig.atimWindowTu */
+ bufferSize += 2; /* CsrUint16 primitive->adHocConfig.beaconPeriodTu */
+ bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinOnlyAttempts */
+ bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinAttemptIntervalMs */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeAdhocConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeAdhocConfigSetReq *primitive = (CsrWifiSmeAdhocConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.atimWindowTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.beaconPeriodTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinOnlyAttempts);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinAttemptIntervalMs);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeAdhocConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeAdhocConfigSetReq *primitive = (CsrWifiSmeAdhocConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.atimWindowTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.beaconPeriodTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinOnlyAttempts, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinAttemptIntervalMs, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeBlacklistReqSizeof(void *msg)
+{
+ CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
+ bufferSize += 1; /* CsrUint8 primitive->setAddressCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setAddressCount; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->setAddresses[i1].a[6] */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeBlacklistReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->setAddressCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setAddressCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((CsrUint16) (6)));
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeBlacklistReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *) CsrPmemAlloc(sizeof(CsrWifiSmeBlacklistReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->setAddressCount, buffer, &offset);
+ primitive->setAddresses = NULL;
+ if (primitive->setAddressCount)
+ {
+ primitive->setAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->setAddressCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setAddressCount; i1++)
+ {
+ CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeBlacklistReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeBlacklistReq *primitive = (CsrWifiSmeBlacklistReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->setAddresses);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeCalibrationDataSetReqSizeof(void *msg)
+{
+ CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
+ bufferSize += 2; /* CsrUint16 primitive->calibrationDataLength */
+ bufferSize += primitive->calibrationDataLength; /* CsrUint8 primitive->calibrationData */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCalibrationDataSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->calibrationDataLength);
+ if (primitive->calibrationDataLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->calibrationData, ((CsrUint16) (primitive->calibrationDataLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCalibrationDataSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->calibrationDataLength, buffer, &offset);
+ if (primitive->calibrationDataLength)
+ {
+ primitive->calibrationData = (CsrUint8 *)CsrPmemAlloc(primitive->calibrationDataLength);
+ CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((CsrUint16) (primitive->calibrationDataLength)));
+ }
+ else
+ {
+ primitive->calibrationData = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeCalibrationDataSetReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeCalibrationDataSetReq *primitive = (CsrWifiSmeCalibrationDataSetReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->calibrationData);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrUint8 primitive->ccxConfig.keepAliveTimeMs */
+ bufferSize += 1; /* CsrBool primitive->ccxConfig.apRoamingEnabled */
+ bufferSize += 1; /* CsrUint8 primitive->ccxConfig.measurementsMask */
+ bufferSize += 1; /* CsrBool primitive->ccxConfig.ccxRadioMgtEnabled */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCcxConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCcxConfigSetReq *primitive = (CsrWifiSmeCcxConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.keepAliveTimeMs);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.apRoamingEnabled);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.measurementsMask);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.ccxRadioMgtEnabled);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCcxConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCcxConfigSetReq *primitive = (CsrWifiSmeCcxConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.ccxRadioMgtEnabled, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 29) */
+ bufferSize += 1; /* CsrBool primitive->coexConfig.coexEnableSchemeManagement */
+ bufferSize += 1; /* CsrBool primitive->coexConfig.coexPeriodicWakeHost */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficBurstyLatencyMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficContinuousLatencyMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutDurationMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutPeriodMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutDurationMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutPeriodMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutDurationMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutDurationMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutPeriodMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutDurationMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutPeriodMs */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCoexConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCoexConfigSetReq *primitive = (CsrWifiSmeCoexConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexEnableSchemeManagement);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexPeriodicWakeHost);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutPeriodMs);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCoexConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCoexConfigSetReq *primitive = (CsrWifiSmeCoexConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexPeriodicWakeHost, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutPeriodMs, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeConnectReqSizeof(void *msg)
+{
+ CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 57) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 32; /* CsrUint8 primitive->connectionConfig.ssid.ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->connectionConfig.ssid.length */
+ bufferSize += 6; /* CsrUint8 primitive->connectionConfig.bssid.a[6] */
+ bufferSize += 1; /* CsrWifiSmeBssType primitive->connectionConfig.bssType */
+ bufferSize += 1; /* CsrWifiSmeRadioIF primitive->connectionConfig.ifIndex */
+ bufferSize += 1; /* CsrWifiSme80211PrivacyMode primitive->connectionConfig.privacyMode */
+ bufferSize += 2; /* CsrWifiSmeAuthModeMask primitive->connectionConfig.authModeMask */
+ bufferSize += 2; /* CsrWifiSmeEncryptionMask primitive->connectionConfig.encryptionModeMask */
+ bufferSize += 2; /* CsrUint16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
+ bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* CsrUint8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
+ bufferSize += 1; /* CsrWifiSmeWmmQosInfoMask primitive->connectionConfig.wmmQosInfo */
+ bufferSize += 1; /* CsrBool primitive->connectionConfig.adhocJoinOnly */
+ bufferSize += 1; /* CsrUint8 primitive->connectionConfig.adhocChannel */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeConnectReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ssid.length);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.bssType);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ifIndex);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.privacyMode);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.authModeMask);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.encryptionModeMask);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+ if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.wmmQosInfo);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocJoinOnly);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocChannel);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeConnectReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.bssType, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
+ if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
+ {
+ primitive->connectionConfig.mlmeAssociateReqInformationElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+ CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+ }
+ else
+ {
+ primitive->connectionConfig.mlmeAssociateReqInformationElements = NULL;
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.wmmQosInfo, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocJoinOnly, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocChannel, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiSmeConnectReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeConnectReq *primitive = (CsrWifiSmeConnectReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->connectionConfig.mlmeAssociateReqInformationElements);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeHostConfigSetReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeHostPowerMode primitive->hostConfig.powerMode */
+ bufferSize += 2; /* CsrUint16 primitive->hostConfig.applicationDataPeriodMs */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeHostConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeHostConfigSetReq *primitive = (CsrWifiSmeHostConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->hostConfig.powerMode);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->hostConfig.applicationDataPeriodMs);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeHostConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeHostConfigSetReq *primitive = (CsrWifiSmeHostConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->hostConfig.powerMode, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeKeyReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 65) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
+ bufferSize += 1; /* CsrWifiSmeKeyType primitive->key.keyType */
+ bufferSize += 1; /* CsrUint8 primitive->key.keyIndex */
+ bufferSize += 1; /* CsrBool primitive->key.wepTxKey */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 8; i2++)
+ {
+ bufferSize += 2; /* CsrUint16 primitive->key.keyRsc[8] */
+ }
+ }
+ bufferSize += 1; /* CsrBool primitive->key.authenticator */
+ bufferSize += 6; /* CsrUint8 primitive->key.address.a[6] */
+ bufferSize += 1; /* CsrUint8 primitive->key.keyLength */
+ bufferSize += 32; /* CsrUint8 primitive->key.key[32] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeKeyReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeKeyReq *primitive = (CsrWifiSmeKeyReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.keyType);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.keyIndex);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.wepTxKey);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 8; i2++)
+ {
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->key.keyRsc[i2]);
+ }
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.authenticator);
+ CsrMemCpySer(ptr, len, (const void *) primitive->key.address.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->key.keyLength);
+ CsrMemCpySer(ptr, len, (const void *) primitive->key.key, ((CsrUint16) (32)));
+ return(ptr);
+}
+
+
+void* CsrWifiSmeKeyReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeKeyReq *primitive = (CsrWifiSmeKeyReq *) CsrPmemAlloc(sizeof(CsrWifiSmeKeyReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->key.keyType, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->key.keyIndex, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->key.wepTxKey, buffer, &offset);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 8; i2++)
+ {
+ CsrUint16Des((CsrUint16 *) &primitive->key.keyRsc[i2], buffer, &offset);
+ }
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->key.authenticator, buffer, &offset);
+ CsrMemCpyDes(primitive->key.address.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->key.keyLength, buffer, &offset);
+ CsrMemCpyDes(primitive->key.key, buffer, &offset, ((CsrUint16) (32)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeMibConfigSetReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
+ bufferSize += 1; /* CsrBool primitive->mibConfig.unifiFixMaxTxDataRate */
+ bufferSize += 1; /* CsrUint8 primitive->mibConfig.unifiFixTxDataRate */
+ bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11RtsThreshold */
+ bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11FragmentationThreshold */
+ bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11CurrentTxPowerLevel */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMibConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMibConfigSetReq *primitive = (CsrWifiSmeMibConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixMaxTxDataRate);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixTxDataRate);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11RtsThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11FragmentationThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11CurrentTxPowerLevel);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMibConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMibConfigSetReq *primitive = (CsrWifiSmeMibConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixTxDataRate, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeMibGetNextReqSizeof(void *msg)
+{
+ CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
+ bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
+ bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMibGetNextReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+ if (primitive->mibAttributeLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMibGetNextReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetNextReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+ if (primitive->mibAttributeLength)
+ {
+ primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+ CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+ }
+ else
+ {
+ primitive->mibAttribute = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeMibGetNextReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeMibGetNextReq *primitive = (CsrWifiSmeMibGetNextReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->mibAttribute);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeMibGetReqSizeof(void *msg)
+{
+ CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
+ bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
+ bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMibGetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+ if (primitive->mibAttributeLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMibGetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+ if (primitive->mibAttributeLength)
+ {
+ primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+ CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+ }
+ else
+ {
+ primitive->mibAttribute = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeMibGetReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeMibGetReq *primitive = (CsrWifiSmeMibGetReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->mibAttribute);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeMibSetReqSizeof(void *msg)
+{
+ CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 6) */
+ bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
+ bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMibSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+ if (primitive->mibAttributeLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMibSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMibSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+ if (primitive->mibAttributeLength)
+ {
+ primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+ CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+ }
+ else
+ {
+ primitive->mibAttribute = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeMibSetReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeMibSetReq *primitive = (CsrWifiSmeMibSetReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->mibAttribute);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeMulticastAddressReqSizeof(void *msg)
+{
+ CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
+ bufferSize += 1; /* CsrUint8 primitive->setAddressesCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->setAddresses[i1].a[6] */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMulticastAddressReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->setAddressesCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->setAddresses[i1].a, ((CsrUint16) (6)));
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMulticastAddressReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *) CsrPmemAlloc(sizeof(CsrWifiSmeMulticastAddressReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->setAddressesCount, buffer, &offset);
+ primitive->setAddresses = NULL;
+ if (primitive->setAddressesCount)
+ {
+ primitive->setAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->setAddressesCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setAddressesCount; i1++)
+ {
+ CsrMemCpyDes(primitive->setAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeMulticastAddressReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeMulticastAddressReq *primitive = (CsrWifiSmeMulticastAddressReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->setAddresses);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmePacketFilterSetReqSizeof(void *msg)
+{
+ CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrUint16 primitive->filterLength */
+ bufferSize += primitive->filterLength; /* CsrUint8 primitive->filter */
+ bufferSize += 1; /* CsrWifiSmePacketFilterMode primitive->mode */
+ bufferSize += 4; /* CsrUint8 primitive->arpFilterAddress.a[4] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmePacketFilterSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->filterLength);
+ if (primitive->filterLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->filter, ((CsrUint16) (primitive->filterLength)));
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->mode);
+ CsrMemCpySer(ptr, len, (const void *) primitive->arpFilterAddress.a, ((CsrUint16) (4)));
+ return(ptr);
+}
+
+
+void* CsrWifiSmePacketFilterSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePacketFilterSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->filterLength, buffer, &offset);
+ if (primitive->filterLength)
+ {
+ primitive->filter = (CsrUint8 *)CsrPmemAlloc(primitive->filterLength);
+ CsrMemCpyDes(primitive->filter, buffer, &offset, ((CsrUint16) (primitive->filterLength)));
+ }
+ else
+ {
+ primitive->filter = NULL;
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->mode, buffer, &offset);
+ CsrMemCpyDes(primitive->arpFilterAddress.a, buffer, &offset, ((CsrUint16) (4)));
+
+ return primitive;
+}
+
+
+void CsrWifiSmePacketFilterSetReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmePacketFilterSetReq *primitive = (CsrWifiSmePacketFilterSetReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->filter);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmePmkidReqSizeof(void *msg)
+{
+ CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 29) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
+ bufferSize += 1; /* CsrUint8 primitive->setPmkidsCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->setPmkids[i1].bssid.a[6] */
+ bufferSize += 16; /* CsrUint8 primitive->setPmkids[i1].pmkid[16] */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmePmkidReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->setPmkidsCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->setPmkids[i1].bssid.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->setPmkids[i1].pmkid, ((CsrUint16) (16)));
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmePmkidReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->setPmkidsCount, buffer, &offset);
+ primitive->setPmkids = NULL;
+ if (primitive->setPmkidsCount)
+ {
+ primitive->setPmkids = (CsrWifiSmePmkid *)CsrPmemAlloc(sizeof(CsrWifiSmePmkid) * primitive->setPmkidsCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->setPmkidsCount; i1++)
+ {
+ CsrMemCpyDes(primitive->setPmkids[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->setPmkids[i1].pmkid, buffer, &offset, ((CsrUint16) (16)));
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmePmkidReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmePmkidReq *primitive = (CsrWifiSmePmkidReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->setPmkids);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
+ bufferSize += 1; /* CsrWifiSmePowerSaveLevel primitive->powerConfig.powerSaveLevel */
+ bufferSize += 2; /* CsrUint16 primitive->powerConfig.listenIntervalTu */
+ bufferSize += 1; /* CsrBool primitive->powerConfig.rxDtims */
+ bufferSize += 1; /* CsrWifiSmeD3AutoScanMode primitive->powerConfig.d3AutoScanMode */
+ bufferSize += 1; /* CsrUint8 primitive->powerConfig.clientTrafficWindow */
+ bufferSize += 1; /* CsrBool primitive->powerConfig.opportunisticPowerSave */
+ bufferSize += 1; /* CsrBool primitive->powerConfig.noticeOfAbsence */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmePowerConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmePowerConfigSetReq *primitive = (CsrWifiSmePowerConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.powerSaveLevel);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->powerConfig.listenIntervalTu);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.rxDtims);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.d3AutoScanMode);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.clientTrafficWindow);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.opportunisticPowerSave);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.noticeOfAbsence);
+ return(ptr);
+}
+
+
+void* CsrWifiSmePowerConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmePowerConfigSetReq *primitive = (CsrWifiSmePowerConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.opportunisticPowerSave, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.noticeOfAbsence, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 70) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].rssiHighThreshold */
+ bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].rssiLowThreshold */
+ bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].snrHighThreshold */
+ bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].snrLowThreshold */
+ }
+ }
+ bufferSize += 1; /* CsrBool primitive->roamingConfig.disableSmoothRoaming */
+ bufferSize += 1; /* CsrBool primitive->roamingConfig.disableRoamScans */
+ bufferSize += 1; /* CsrUint8 primitive->roamingConfig.reconnectLimit */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.reconnectLimitIntervalMs */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].intervalSeconds */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].validitySeconds */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeRoamingConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeRoamingConfigSetReq *primitive = (CsrWifiSmeRoamingConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiHighThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiLowThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrHighThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
+ }
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableSmoothRoaming);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableRoamScans);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.reconnectLimit);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.reconnectLimitIntervalMs);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].intervalSeconds);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].validitySeconds);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu);
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeRoamingConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeRoamingConfigSetReq *primitive = (CsrWifiSmeRoamingConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiHighThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiLowThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrHighThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
+ }
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.reconnectLimit, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].intervalSeconds, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].validitySeconds, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+ }
+ }
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeScanConfigSetReqSizeof(void *msg)
+{
+ CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 63) */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].intervalSeconds */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].validitySeconds */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu */
+ }
+ }
+ bufferSize += 1; /* CsrBool primitive->scanConfig.disableAutonomousScans */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.maxResults */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.highRssiThreshold */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.lowRssiThreshold */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.deltaRssiThreshold */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.highSnrThreshold */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.lowSnrThreshold */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.deltaSnrThreshold */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.passiveChannelListCount */
+ bufferSize += primitive->scanConfig.passiveChannelListCount; /* CsrUint8 primitive->scanConfig.passiveChannelList */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeScanConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].intervalSeconds);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].validitySeconds);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
+ }
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.disableAutonomousScans);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.maxResults);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highRssiThreshold);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowRssiThreshold);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaRssiThreshold);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highSnrThreshold);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowSnrThreshold);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaSnrThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.passiveChannelListCount);
+ if (primitive->scanConfig.passiveChannelListCount)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanConfig.passiveChannelList, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeScanConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].intervalSeconds, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].validitySeconds, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+ }
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.maxResults, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaSnrThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
+ if (primitive->scanConfig.passiveChannelListCount)
+ {
+ primitive->scanConfig.passiveChannelList = (CsrUint8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
+ CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+ }
+ else
+ {
+ primitive->scanConfig.passiveChannelList = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeScanConfigSetReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeScanConfigSetReq *primitive = (CsrWifiSmeScanConfigSetReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->scanConfig.passiveChannelList);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeScanFullReqSizeof(void *msg)
+{
+ CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 52) */
+ bufferSize += 1; /* CsrUint8 primitive->ssidCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->ssidCount; i1++)
+ {
+ bufferSize += 32; /* CsrUint8 primitive->ssid[i1].ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->ssid[i1].length */
+ }
+ }
+ bufferSize += 6; /* CsrUint8 primitive->bssid.a[6] */
+ bufferSize += 1; /* CsrBool primitive->forceScan */
+ bufferSize += 1; /* CsrWifiSmeBssType primitive->bssType */
+ bufferSize += 1; /* CsrWifiSmeScanType primitive->scanType */
+ bufferSize += 2; /* CsrUint16 primitive->channelListCount */
+ bufferSize += primitive->channelListCount; /* CsrUint8 primitive->channelList */
+ bufferSize += 2; /* CsrUint16 primitive->probeIeLength */
+ bufferSize += primitive->probeIeLength; /* CsrUint8 primitive->probeIe */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeScanFullReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssidCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->ssidCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->ssid[i1].ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid[i1].length);
+ }
+ }
+ CsrMemCpySer(ptr, len, (const void *) primitive->bssid.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->forceScan);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->bssType);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanType);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->channelListCount);
+ if (primitive->channelListCount)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->channelList, ((CsrUint16) (primitive->channelListCount)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->probeIeLength);
+ if (primitive->probeIeLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->probeIe, ((CsrUint16) (primitive->probeIeLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeScanFullReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *) CsrPmemAlloc(sizeof(CsrWifiSmeScanFullReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ssidCount, buffer, &offset);
+ primitive->ssid = NULL;
+ if (primitive->ssidCount)
+ {
+ primitive->ssid = (CsrWifiSsid *)CsrPmemAlloc(sizeof(CsrWifiSsid) * primitive->ssidCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->ssidCount; i1++)
+ {
+ CsrMemCpyDes(primitive->ssid[i1].ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->ssid[i1].length, buffer, &offset);
+ }
+ }
+ CsrMemCpyDes(primitive->bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->forceScan, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->bssType, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanType, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->channelListCount, buffer, &offset);
+ if (primitive->channelListCount)
+ {
+ primitive->channelList = (CsrUint8 *)CsrPmemAlloc(primitive->channelListCount);
+ CsrMemCpyDes(primitive->channelList, buffer, &offset, ((CsrUint16) (primitive->channelListCount)));
+ }
+ else
+ {
+ primitive->channelList = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->probeIeLength, buffer, &offset);
+ if (primitive->probeIeLength)
+ {
+ primitive->probeIe = (CsrUint8 *)CsrPmemAlloc(primitive->probeIeLength);
+ CsrMemCpyDes(primitive->probeIe, buffer, &offset, ((CsrUint16) (primitive->probeIeLength)));
+ }
+ else
+ {
+ primitive->probeIe = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeScanFullReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeScanFullReq *primitive = (CsrWifiSmeScanFullReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->ssid);
+ CsrPmemFree(primitive->channelList);
+ CsrPmemFree(primitive->probeIe);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
+ bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
+ bufferSize += 1; /* CsrWifiSmeWmmModeMask primitive->smeConfig.wmmModeMask */
+ bufferSize += 1; /* CsrWifiSmeRadioIF primitive->smeConfig.ifIndex */
+ bufferSize += 1; /* CsrBool primitive->smeConfig.allowUnicastUseGroupCipher */
+ bufferSize += 1; /* CsrBool primitive->smeConfig.enableOpportunisticKeyCaching */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeSmeStaConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeSmeStaConfigSetReq *primitive = (CsrWifiSmeSmeStaConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.wmmModeMask);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.ifIndex);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.allowUnicastUseGroupCipher);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.enableOpportunisticKeyCaching);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeSmeStaConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeSmeStaConfigSetReq *primitive = (CsrWifiSmeSmeStaConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.ifIndex, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.allowUnicastUseGroupCipher, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.enableOpportunisticKeyCaching, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeTspecReqSizeof(void *msg)
+{
+ CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 18) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
+ bufferSize += 4; /* CsrUint32 primitive->transactionId */
+ bufferSize += 1; /* CsrBool primitive->strict */
+ bufferSize += 1; /* CsrWifiSmeTspecCtrlMask primitive->ctrlMask */
+ bufferSize += 2; /* CsrUint16 primitive->tspecLength */
+ bufferSize += primitive->tspecLength; /* CsrUint8 primitive->tspec */
+ bufferSize += 2; /* CsrUint16 primitive->tclasLength */
+ bufferSize += primitive->tclasLength; /* CsrUint8 primitive->tclas */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeTspecReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->strict);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ctrlMask);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
+ if (primitive->tspecLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((CsrUint16) (primitive->tspecLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->tclasLength);
+ if (primitive->tclasLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->tclas, ((CsrUint16) (primitive->tclasLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeTspecReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->strict, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ctrlMask, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
+ if (primitive->tspecLength)
+ {
+ primitive->tspec = (CsrUint8 *)CsrPmemAlloc(primitive->tspecLength);
+ CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
+ }
+ else
+ {
+ primitive->tspec = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->tclasLength, buffer, &offset);
+ if (primitive->tclasLength)
+ {
+ primitive->tclas = (CsrUint8 *)CsrPmemAlloc(primitive->tclasLength);
+ CsrMemCpyDes(primitive->tclas, buffer, &offset, ((CsrUint16) (primitive->tclasLength)));
+ }
+ else
+ {
+ primitive->tclas = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeTspecReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeTspecReq *primitive = (CsrWifiSmeTspecReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->tspec);
+ CsrPmemFree(primitive->tclas);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeWifiFlightmodeReqSizeof(void *msg)
+{
+ CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
+ bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ bufferSize += 2; /* CsrUint16 primitive->mibFilesCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
+ {
+ bufferSize += 2; /* CsrUint16 primitive->mibFiles[i1].length */
+ bufferSize += primitive->mibFiles[i1].length; /* CsrUint8 primitive->mibFiles[i1].data */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeWifiFlightmodeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFilesCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
+ {
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFiles[i1].length);
+ if (primitive->mibFiles[i1].length)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibFiles[i1].data, ((CsrUint16) (primitive->mibFiles[i1].length)));
+ }
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeWifiFlightmodeReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiFlightmodeReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->mibFilesCount, buffer, &offset);
+ primitive->mibFiles = NULL;
+ if (primitive->mibFilesCount)
+ {
+ primitive->mibFiles = (CsrWifiSmeDataBlock *)CsrPmemAlloc(sizeof(CsrWifiSmeDataBlock) * primitive->mibFilesCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
+ {
+ CsrUint16Des((CsrUint16 *) &primitive->mibFiles[i1].length, buffer, &offset);
+ if (primitive->mibFiles[i1].length)
+ {
+ primitive->mibFiles[i1].data = (CsrUint8 *)CsrPmemAlloc(primitive->mibFiles[i1].length);
+ CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((CsrUint16) (primitive->mibFiles[i1].length)));
+ }
+ else
+ {
+ primitive->mibFiles[i1].data = NULL;
+ }
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeWifiFlightmodeReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeWifiFlightmodeReq *primitive = (CsrWifiSmeWifiFlightmodeReq *) voidPrimitivePointer;
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
+ {
+ CsrPmemFree(primitive->mibFiles[i1].data);
+ }
+ }
+ CsrPmemFree(primitive->mibFiles);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeWifiOnReqSizeof(void *msg)
+{
+ CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 14) */
+ bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ bufferSize += 2; /* CsrUint16 primitive->mibFilesCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
+ {
+ bufferSize += 2; /* CsrUint16 primitive->mibFiles[i1].length */
+ bufferSize += primitive->mibFiles[i1].length; /* CsrUint8 primitive->mibFiles[i1].data */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFilesCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
+ {
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibFiles[i1].length);
+ if (primitive->mibFiles[i1].length)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibFiles[i1].data, ((CsrUint16) (primitive->mibFiles[i1].length)));
+ }
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeWifiOnReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->mibFilesCount, buffer, &offset);
+ primitive->mibFiles = NULL;
+ if (primitive->mibFilesCount)
+ {
+ primitive->mibFiles = (CsrWifiSmeDataBlock *)CsrPmemAlloc(sizeof(CsrWifiSmeDataBlock) * primitive->mibFilesCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
+ {
+ CsrUint16Des((CsrUint16 *) &primitive->mibFiles[i1].length, buffer, &offset);
+ if (primitive->mibFiles[i1].length)
+ {
+ primitive->mibFiles[i1].data = (CsrUint8 *)CsrPmemAlloc(primitive->mibFiles[i1].length);
+ CsrMemCpyDes(primitive->mibFiles[i1].data, buffer, &offset, ((CsrUint16) (primitive->mibFiles[i1].length)));
+ }
+ else
+ {
+ primitive->mibFiles[i1].data = NULL;
+ }
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeWifiOnReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeWifiOnReq *primitive = (CsrWifiSmeWifiOnReq *) voidPrimitivePointer;
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->mibFilesCount; i1++)
+ {
+ CsrPmemFree(primitive->mibFiles[i1].data);
+ }
+ }
+ CsrPmemFree(primitive->mibFiles);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg)
+{
+ CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 37) */
+ bufferSize += 1; /* CsrUint8 primitive->cloakedSsids.cloakedSsidsCount */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
+ {
+ bufferSize += 32; /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].length */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCloakedSsidsSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsidsCount);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsids[i2].length);
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCloakedSsidsSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
+ primitive->cloakedSsids.cloakedSsids = NULL;
+ if (primitive->cloakedSsids.cloakedSsidsCount)
+ {
+ primitive->cloakedSsids.cloakedSsids = (CsrWifiSsid *)CsrPmemAlloc(sizeof(CsrWifiSsid) * primitive->cloakedSsids.cloakedSsidsCount);
+ }
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
+ {
+ CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeCloakedSsidsSetReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeCloakedSsidsSetReq *primitive = (CsrWifiSmeCloakedSsidsSetReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->cloakedSsids.cloakedSsids);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 1; /* CsrWifiSme80211dTrustLevel primitive->deviceConfig.trustLevel */
+ bufferSize += 2; /* CsrUint8 primitive->deviceConfig.countryCode[2] */
+ bufferSize += 1; /* CsrWifiSmeFirmwareDriverInterface primitive->deviceConfig.firmwareDriverInterface */
+ bufferSize += 1; /* CsrBool primitive->deviceConfig.enableStrictDraftN */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeSmeCommonConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeSmeCommonConfigSetReq *primitive = (CsrWifiSmeSmeCommonConfigSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.trustLevel);
+ CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((CsrUint16) (2)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.firmwareDriverInterface);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.enableStrictDraftN);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeSmeCommonConfigSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeSmeCommonConfigSetReq *primitive = (CsrWifiSmeSmeCommonConfigSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
+ CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((CsrUint16) (2)));
+ CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeWpsConfigurationReqSizeof(void *msg)
+{
+ CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 240) */
+ bufferSize += 1; /* CsrUint8 primitive->wpsConfig.wpsVersion */
+ bufferSize += 16; /* CsrUint8 primitive->wpsConfig.uuid[16] */
+ bufferSize += 32; /* CsrUint8 primitive->wpsConfig.deviceName[32] */
+ bufferSize += 1; /* CsrUint8 primitive->wpsConfig.deviceNameLength */
+ bufferSize += 64; /* CsrUint8 primitive->wpsConfig.manufacturer[64] */
+ bufferSize += 1; /* CsrUint8 primitive->wpsConfig.manufacturerLength */
+ bufferSize += 32; /* CsrUint8 primitive->wpsConfig.modelName[32] */
+ bufferSize += 1; /* CsrUint8 primitive->wpsConfig.modelNameLength */
+ bufferSize += 32; /* CsrUint8 primitive->wpsConfig.modelNumber[32] */
+ bufferSize += 1; /* CsrUint8 primitive->wpsConfig.modelNumberLength */
+ bufferSize += 32; /* CsrUint8 primitive->wpsConfig.serialNumber[32] */
+ bufferSize += 8; /* CsrUint8 primitive->wpsConfig.primDeviceType.deviceDetails[8] */
+ bufferSize += 1; /* CsrUint8 primitive->wpsConfig.secondaryDeviceTypeCount */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
+ {
+ bufferSize += 8; /* CsrUint8 primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails[8] */
+ }
+ }
+ bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->wpsConfig.configMethods */
+ bufferSize += 1; /* CsrUint8 primitive->wpsConfig.rfBands */
+ bufferSize += 4; /* CsrUint8 primitive->wpsConfig.osVersion[4] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeWpsConfigurationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.wpsVersion);
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.uuid, ((CsrUint16) (16)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.deviceName, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.deviceNameLength);
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.manufacturer, ((CsrUint16) (64)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.manufacturerLength);
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelName, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.modelNameLength);
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.modelNumber, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.modelNumberLength);
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.serialNumber, ((CsrUint16) (32)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.secondaryDeviceTypeCount);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails, ((CsrUint16) (8)));
+ }
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->wpsConfig.configMethods);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->wpsConfig.rfBands);
+ CsrMemCpySer(ptr, len, (const void *) primitive->wpsConfig.osVersion, ((CsrUint16) (4)));
+ return(ptr);
+}
+
+
+void* CsrWifiSmeWpsConfigurationReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *) CsrPmemAlloc(sizeof(CsrWifiSmeWpsConfigurationReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.wpsVersion, buffer, &offset);
+ CsrMemCpyDes(primitive->wpsConfig.uuid, buffer, &offset, ((CsrUint16) (16)));
+ CsrMemCpyDes(primitive->wpsConfig.deviceName, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.deviceNameLength, buffer, &offset);
+ CsrMemCpyDes(primitive->wpsConfig.manufacturer, buffer, &offset, ((CsrUint16) (64)));
+ CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.manufacturerLength, buffer, &offset);
+ CsrMemCpyDes(primitive->wpsConfig.modelName, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.modelNameLength, buffer, &offset);
+ CsrMemCpyDes(primitive->wpsConfig.modelNumber, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.modelNumberLength, buffer, &offset);
+ CsrMemCpyDes(primitive->wpsConfig.serialNumber, buffer, &offset, ((CsrUint16) (32)));
+ CsrMemCpyDes(primitive->wpsConfig.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.secondaryDeviceTypeCount, buffer, &offset);
+ primitive->wpsConfig.secondaryDeviceType = NULL;
+ if (primitive->wpsConfig.secondaryDeviceTypeCount)
+ {
+ primitive->wpsConfig.secondaryDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->wpsConfig.secondaryDeviceTypeCount);
+ }
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->wpsConfig.secondaryDeviceTypeCount; i2++)
+ {
+ CsrMemCpyDes(primitive->wpsConfig.secondaryDeviceType[i2].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ }
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->wpsConfig.configMethods, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->wpsConfig.rfBands, buffer, &offset);
+ CsrMemCpyDes(primitive->wpsConfig.osVersion, buffer, &offset, ((CsrUint16) (4)));
+
+ return primitive;
+}
+
+
+void CsrWifiSmeWpsConfigurationReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeWpsConfigurationReq *primitive = (CsrWifiSmeWpsConfigurationReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->wpsConfig.secondaryDeviceType);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeSetReqSizeof(void *msg)
+{
+ CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 4; /* CsrUint32 primitive->dataLength */
+ bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
+ if (primitive->dataLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeSetReqDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *) CsrPmemAlloc(sizeof(CsrWifiSmeSetReq));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
+ if (primitive->dataLength)
+ {
+ primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ }
+ else
+ {
+ primitive->data = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeSetReqSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeSetReq *primitive = (CsrWifiSmeSetReq *) voidPrimitivePointer;
+ CsrPmemFree(primitive->data);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 2; /* CsrUint16 primitive->adHocConfig.atimWindowTu */
+ bufferSize += 2; /* CsrUint16 primitive->adHocConfig.beaconPeriodTu */
+ bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinOnlyAttempts */
+ bufferSize += 2; /* CsrUint16 primitive->adHocConfig.joinAttemptIntervalMs */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeAdhocConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeAdhocConfigGetCfm *primitive = (CsrWifiSmeAdhocConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.atimWindowTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.beaconPeriodTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinOnlyAttempts);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->adHocConfig.joinAttemptIntervalMs);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeAdhocConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeAdhocConfigGetCfm *primitive = (CsrWifiSmeAdhocConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeAdhocConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.atimWindowTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.beaconPeriodTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinOnlyAttempts, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->adHocConfig.joinAttemptIntervalMs, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg)
+{
+ CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 98) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 32; /* CsrUint8 primitive->connectionInfo.ssid.ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->connectionInfo.ssid.length */
+ bufferSize += 6; /* CsrUint8 primitive->connectionInfo.bssid.a[6] */
+ bufferSize += 1; /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
+ bufferSize += 1; /* CsrUint8 primitive->connectionInfo.channelNumber */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.channelFrequency */
+ bufferSize += 2; /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
+ bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
+ bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.groupCipher */
+ bufferSize += 1; /* CsrWifiSmeRadioIF primitive->connectionInfo.ifIndex */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.atimWindowTu */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
+ bufferSize += 1; /* CsrBool primitive->connectionInfo.reassociation */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
+ bufferSize += primitive->connectionInfo.beaconFrameLength; /* CsrUint8 primitive->connectionInfo.beaconFrame */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
+ bufferSize += primitive->connectionInfo.associationReqFrameLength; /* CsrUint8 primitive->connectionInfo.associationReqFrame */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
+ bufferSize += primitive->connectionInfo.associationRspFrameLength; /* CsrUint8 primitive->connectionInfo.associationRspFrame */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
+ bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocScanInfoElements */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
+ bufferSize += 6; /* CsrUint8 primitive->connectionInfo.assocReqApAddress.a[6] */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
+ bufferSize += primitive->connectionInfo.assocReqInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocReqInfoElements */
+ bufferSize += 2; /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
+ bufferSize += primitive->connectionInfo.assocRspInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocRspInfoElements */
+ bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->deauthReason */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeAssociationCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ssid.length);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.networkType80211);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.channelNumber);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ifIndex);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.reassociation);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
+ if (primitive->connectionInfo.beaconFrameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationReqFrameLength);
+ if (primitive->connectionInfo.associationReqFrameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationRspFrameLength);
+ if (primitive->connectionInfo.associationRspFrameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocScanInfoElementsLength);
+ if (primitive->connectionInfo.assocScanInfoElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqCapabilities);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqListenIntervalTu);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqInfoElementsLength);
+ if (primitive->connectionInfo.assocReqInfoElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspResult);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspCapabilityInfo);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspAssociationId);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspInfoElementsLength);
+ if (primitive->connectionInfo.assocRspInfoElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->deauthReason);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAssociationCompleteInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
+ if (primitive->connectionInfo.beaconFrameLength)
+ {
+ primitive->connectionInfo.beaconFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
+ CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.beaconFrame = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
+ if (primitive->connectionInfo.associationReqFrameLength)
+ {
+ primitive->connectionInfo.associationReqFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
+ CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.associationReqFrame = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
+ if (primitive->connectionInfo.associationRspFrameLength)
+ {
+ primitive->connectionInfo.associationRspFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
+ CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.associationRspFrame = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
+ if (primitive->connectionInfo.assocScanInfoElementsLength)
+ {
+ primitive->connectionInfo.assocScanInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
+ CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.assocScanInfoElements = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
+ if (primitive->connectionInfo.assocReqInfoElementsLength)
+ {
+ primitive->connectionInfo.assocReqInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
+ CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.assocReqInfoElements = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
+ if (primitive->connectionInfo.assocRspInfoElementsLength)
+ {
+ primitive->connectionInfo.assocRspInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
+ CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.assocRspInfoElements = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->deauthReason, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiSmeAssociationCompleteIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeAssociationCompleteInd *primitive = (CsrWifiSmeAssociationCompleteInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->connectionInfo.beaconFrame);
+ CsrPmemFree(primitive->connectionInfo.associationReqFrame);
+ CsrPmemFree(primitive->connectionInfo.associationRspFrame);
+ CsrPmemFree(primitive->connectionInfo.assocScanInfoElements);
+ CsrPmemFree(primitive->connectionInfo.assocReqInfoElements);
+ CsrPmemFree(primitive->connectionInfo.assocRspInfoElements);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeAssociationStartIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 44) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ bufferSize += 32; /* CsrUint8 primitive->ssid.ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->ssid.length */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeAssociationStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeAssociationStartInd *primitive = (CsrWifiSmeAssociationStartInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->ssid.ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ssid.length);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeAssociationStartIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeAssociationStartInd *primitive = (CsrWifiSmeAssociationStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeAssociationStartInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->ssid.length, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeBlacklistCfmSizeof(void *msg)
+{
+ CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
+ bufferSize += 1; /* CsrUint8 primitive->getAddressCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getAddressCount; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->getAddresses[i1].a[6] */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeBlacklistCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->getAddressCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getAddressCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((CsrUint16) (6)));
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeBlacklistCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeBlacklistCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->getAddressCount, buffer, &offset);
+ primitive->getAddresses = NULL;
+ if (primitive->getAddressCount)
+ {
+ primitive->getAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->getAddressCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getAddressCount; i1++)
+ {
+ CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeBlacklistCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeBlacklistCfm *primitive = (CsrWifiSmeBlacklistCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->getAddresses);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg)
+{
+ CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 2; /* CsrUint16 primitive->calibrationDataLength */
+ bufferSize += primitive->calibrationDataLength; /* CsrUint8 primitive->calibrationData */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCalibrationDataGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->calibrationDataLength);
+ if (primitive->calibrationDataLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->calibrationData, ((CsrUint16) (primitive->calibrationDataLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCalibrationDataGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCalibrationDataGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->calibrationDataLength, buffer, &offset);
+ if (primitive->calibrationDataLength)
+ {
+ primitive->calibrationData = (CsrUint8 *)CsrPmemAlloc(primitive->calibrationDataLength);
+ CsrMemCpyDes(primitive->calibrationData, buffer, &offset, ((CsrUint16) (primitive->calibrationDataLength)));
+ }
+ else
+ {
+ primitive->calibrationData = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeCalibrationDataGetCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeCalibrationDataGetCfm *primitive = (CsrWifiSmeCalibrationDataGetCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->calibrationData);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeCcxConfigGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrUint8 primitive->ccxConfig.keepAliveTimeMs */
+ bufferSize += 1; /* CsrBool primitive->ccxConfig.apRoamingEnabled */
+ bufferSize += 1; /* CsrUint8 primitive->ccxConfig.measurementsMask */
+ bufferSize += 1; /* CsrBool primitive->ccxConfig.ccxRadioMgtEnabled */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCcxConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCcxConfigGetCfm *primitive = (CsrWifiSmeCcxConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.keepAliveTimeMs);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.apRoamingEnabled);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.measurementsMask);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->ccxConfig.ccxRadioMgtEnabled);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCcxConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCcxConfigGetCfm *primitive = (CsrWifiSmeCcxConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.keepAliveTimeMs, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.apRoamingEnabled, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.measurementsMask, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->ccxConfig.ccxRadioMgtEnabled, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeCcxConfigSetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCcxConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCcxConfigSetCfm *primitive = (CsrWifiSmeCcxConfigSetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCcxConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCcxConfigSetCfm *primitive = (CsrWifiSmeCcxConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCcxConfigSetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 31) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrBool primitive->coexConfig.coexEnableSchemeManagement */
+ bufferSize += 1; /* CsrBool primitive->coexConfig.coexPeriodicWakeHost */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficBurstyLatencyMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexTrafficContinuousLatencyMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutDurationMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexObexBlackoutPeriodMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutDurationMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpBrBlackoutPeriodMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutDurationMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutDurationMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexPagingBlackoutPeriodMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutDurationMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexConfig.coexInquiryBlackoutPeriodMs */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCoexConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCoexConfigGetCfm *primitive = (CsrWifiSmeCoexConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexEnableSchemeManagement);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexConfig.coexPeriodicWakeHost);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficBurstyLatencyMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexTrafficContinuousLatencyMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexObexBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpBrBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexPagingBlackoutPeriodMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutDurationMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexConfig.coexInquiryBlackoutPeriodMs);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCoexConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCoexConfigGetCfm *primitive = (CsrWifiSmeCoexConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexEnableSchemeManagement, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->coexConfig.coexPeriodicWakeHost, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficBurstyLatencyMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexTrafficContinuousLatencyMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexObexBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpBrBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexA2dpEdrBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexPagingBlackoutPeriodMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutDurationMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexConfig.coexInquiryBlackoutPeriodMs, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeCoexInfoGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 24) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrBool primitive->coexInfo.hasTrafficData */
+ bufferSize += 1; /* CsrWifiSmeTrafficType primitive->coexInfo.currentTrafficType */
+ bufferSize += 2; /* CsrUint16 primitive->coexInfo.currentPeriodMs */
+ bufferSize += 1; /* CsrWifiSmePowerSaveLevel primitive->coexInfo.currentPowerSave */
+ bufferSize += 2; /* CsrUint16 primitive->coexInfo.currentCoexPeriodMs */
+ bufferSize += 2; /* CsrUint16 primitive->coexInfo.currentCoexLatencyMs */
+ bufferSize += 1; /* CsrBool primitive->coexInfo.hasBtDevice */
+ bufferSize += 4; /* CsrUint32 primitive->coexInfo.currentBlackoutDurationUs */
+ bufferSize += 4; /* CsrUint32 primitive->coexInfo.currentBlackoutPeriodUs */
+ bufferSize += 1; /* CsrWifiSmeCoexScheme primitive->coexInfo.currentCoexScheme */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCoexInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCoexInfoGetCfm *primitive = (CsrWifiSmeCoexInfoGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.hasTrafficData);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.currentTrafficType);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentPeriodMs);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.currentPowerSave);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentCoexPeriodMs);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->coexInfo.currentCoexLatencyMs);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.hasBtDevice);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->coexInfo.currentBlackoutDurationUs);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->coexInfo.currentBlackoutPeriodUs);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->coexInfo.currentCoexScheme);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCoexInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCoexInfoGetCfm *primitive = (CsrWifiSmeCoexInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCoexInfoGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->coexInfo.hasTrafficData, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->coexInfo.currentTrafficType, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentPeriodMs, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->coexInfo.currentPowerSave, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentCoexPeriodMs, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->coexInfo.currentCoexLatencyMs, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->coexInfo.hasBtDevice, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->coexInfo.currentBlackoutDurationUs, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->coexInfo.currentBlackoutPeriodUs, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->coexInfo.currentCoexScheme, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeConnectCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeConnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeConnectCfm *primitive = (CsrWifiSmeConnectCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeConnectCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeConnectCfm *primitive = (CsrWifiSmeConnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg)
+{
+ CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 59) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 32; /* CsrUint8 primitive->connectionConfig.ssid.ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->connectionConfig.ssid.length */
+ bufferSize += 6; /* CsrUint8 primitive->connectionConfig.bssid.a[6] */
+ bufferSize += 1; /* CsrWifiSmeBssType primitive->connectionConfig.bssType */
+ bufferSize += 1; /* CsrWifiSmeRadioIF primitive->connectionConfig.ifIndex */
+ bufferSize += 1; /* CsrWifiSme80211PrivacyMode primitive->connectionConfig.privacyMode */
+ bufferSize += 2; /* CsrWifiSmeAuthModeMask primitive->connectionConfig.authModeMask */
+ bufferSize += 2; /* CsrWifiSmeEncryptionMask primitive->connectionConfig.encryptionModeMask */
+ bufferSize += 2; /* CsrUint16 primitive->connectionConfig.mlmeAssociateReqInformationElementsLength */
+ bufferSize += primitive->connectionConfig.mlmeAssociateReqInformationElementsLength; /* CsrUint8 primitive->connectionConfig.mlmeAssociateReqInformationElements */
+ bufferSize += 1; /* CsrWifiSmeWmmQosInfoMask primitive->connectionConfig.wmmQosInfo */
+ bufferSize += 1; /* CsrBool primitive->connectionConfig.adhocJoinOnly */
+ bufferSize += 1; /* CsrUint8 primitive->connectionConfig.adhocChannel */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeConnectionConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.ssid.ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ssid.length);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.bssid.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.bssType);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.ifIndex);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.privacyMode);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.authModeMask);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.encryptionModeMask);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+ if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionConfig.mlmeAssociateReqInformationElements, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.wmmQosInfo);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocJoinOnly);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionConfig.adhocChannel);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeConnectionConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionConfig.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ssid.length, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionConfig.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.bssType, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.ifIndex, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.privacyMode, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.authModeMask, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.encryptionModeMask, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionConfig.mlmeAssociateReqInformationElementsLength, buffer, &offset);
+ if (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)
+ {
+ primitive->connectionConfig.mlmeAssociateReqInformationElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionConfig.mlmeAssociateReqInformationElementsLength);
+ CsrMemCpyDes(primitive->connectionConfig.mlmeAssociateReqInformationElements, buffer, &offset, ((CsrUint16) (primitive->connectionConfig.mlmeAssociateReqInformationElementsLength)));
+ }
+ else
+ {
+ primitive->connectionConfig.mlmeAssociateReqInformationElements = NULL;
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.wmmQosInfo, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocJoinOnly, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionConfig.adhocChannel, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiSmeConnectionConfigGetCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeConnectionConfigGetCfm *primitive = (CsrWifiSmeConnectionConfigGetCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->connectionConfig.mlmeAssociateReqInformationElements);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg)
+{
+ CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 96) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 32; /* CsrUint8 primitive->connectionInfo.ssid.ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->connectionInfo.ssid.length */
+ bufferSize += 6; /* CsrUint8 primitive->connectionInfo.bssid.a[6] */
+ bufferSize += 1; /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
+ bufferSize += 1; /* CsrUint8 primitive->connectionInfo.channelNumber */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.channelFrequency */
+ bufferSize += 2; /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
+ bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
+ bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.groupCipher */
+ bufferSize += 1; /* CsrWifiSmeRadioIF primitive->connectionInfo.ifIndex */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.atimWindowTu */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
+ bufferSize += 1; /* CsrBool primitive->connectionInfo.reassociation */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
+ bufferSize += primitive->connectionInfo.beaconFrameLength; /* CsrUint8 primitive->connectionInfo.beaconFrame */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
+ bufferSize += primitive->connectionInfo.associationReqFrameLength; /* CsrUint8 primitive->connectionInfo.associationReqFrame */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
+ bufferSize += primitive->connectionInfo.associationRspFrameLength; /* CsrUint8 primitive->connectionInfo.associationRspFrame */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
+ bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocScanInfoElements */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
+ bufferSize += 6; /* CsrUint8 primitive->connectionInfo.assocReqApAddress.a[6] */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
+ bufferSize += primitive->connectionInfo.assocReqInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocReqInfoElements */
+ bufferSize += 2; /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
+ bufferSize += primitive->connectionInfo.assocRspInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocRspInfoElements */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeConnectionInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ssid.length);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.networkType80211);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.channelNumber);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ifIndex);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.reassociation);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
+ if (primitive->connectionInfo.beaconFrameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationReqFrameLength);
+ if (primitive->connectionInfo.associationReqFrameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationRspFrameLength);
+ if (primitive->connectionInfo.associationRspFrameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocScanInfoElementsLength);
+ if (primitive->connectionInfo.assocScanInfoElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqCapabilities);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqListenIntervalTu);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqInfoElementsLength);
+ if (primitive->connectionInfo.assocReqInfoElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspResult);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspCapabilityInfo);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspAssociationId);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspInfoElementsLength);
+ if (primitive->connectionInfo.assocRspInfoElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionInfoGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
+ if (primitive->connectionInfo.beaconFrameLength)
+ {
+ primitive->connectionInfo.beaconFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
+ CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.beaconFrame = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
+ if (primitive->connectionInfo.associationReqFrameLength)
+ {
+ primitive->connectionInfo.associationReqFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
+ CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.associationReqFrame = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
+ if (primitive->connectionInfo.associationRspFrameLength)
+ {
+ primitive->connectionInfo.associationRspFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
+ CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.associationRspFrame = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
+ if (primitive->connectionInfo.assocScanInfoElementsLength)
+ {
+ primitive->connectionInfo.assocScanInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
+ CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.assocScanInfoElements = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
+ if (primitive->connectionInfo.assocReqInfoElementsLength)
+ {
+ primitive->connectionInfo.assocReqInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
+ CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.assocReqInfoElements = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
+ if (primitive->connectionInfo.assocRspInfoElementsLength)
+ {
+ primitive->connectionInfo.assocRspInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
+ CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.assocRspInfoElements = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeConnectionInfoGetCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeConnectionInfoGetCfm *primitive = (CsrWifiSmeConnectionInfoGetCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->connectionInfo.beaconFrame);
+ CsrPmemFree(primitive->connectionInfo.associationReqFrame);
+ CsrPmemFree(primitive->connectionInfo.associationRspFrame);
+ CsrPmemFree(primitive->connectionInfo.assocScanInfoElements);
+ CsrPmemFree(primitive->connectionInfo.assocReqInfoElements);
+ CsrPmemFree(primitive->connectionInfo.assocRspInfoElements);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeConnectionQualityIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiRssi */
+ bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiSnr */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeConnectionQualityIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeConnectionQualityInd *primitive = (CsrWifiSmeConnectionQualityInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiRssi);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiSnr);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeConnectionQualityIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeConnectionQualityInd *primitive = (CsrWifiSmeConnectionQualityInd *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionQualityInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiRssi, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiSnr, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 101) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrUint8 primitive->connectionStats.unifiTxDataRate */
+ bufferSize += 1; /* CsrUint8 primitive->connectionStats.unifiRxDataRate */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RetryCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11MultipleRetryCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11AckFailureCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11FrameDuplicateCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11FcsErrorCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RtsSuccessCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RtsFailureCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11FailedCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11TransmittedFragmentCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11TransmittedFrameCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11WepExcludedCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11WepIcvErrorCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11WepUndecryptableCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11MulticastReceivedFrameCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11MulticastTransmittedFrameCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11ReceivedFragmentCount */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11Rsna4WayHandshakeFailures */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaTkipCounterMeasuresInvoked */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaStatsTkipLocalMicFailures */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaStatsTkipReplays */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaStatsTkipIcvErrors */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaStatsCcmpReplays */
+ bufferSize += 4; /* CsrUint32 primitive->connectionStats.dot11RsnaStatsCcmpDecryptErrors */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeConnectionStatsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeConnectionStatsGetCfm *primitive = (CsrWifiSmeConnectionStatsGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionStats.unifiTxDataRate);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionStats.unifiRxDataRate);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RetryCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11MultipleRetryCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11AckFailureCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11FrameDuplicateCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11FcsErrorCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RtsSuccessCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RtsFailureCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11FailedCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11TransmittedFragmentCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11TransmittedFrameCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11WepExcludedCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11WepIcvErrorCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11WepUndecryptableCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11MulticastReceivedFrameCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11MulticastTransmittedFrameCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11ReceivedFragmentCount);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11Rsna4WayHandshakeFailures);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaTkipCounterMeasuresInvoked);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaStatsTkipLocalMicFailures);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaStatsTkipReplays);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaStatsTkipIcvErrors);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaStatsCcmpReplays);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->connectionStats.dot11RsnaStatsCcmpDecryptErrors);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeConnectionStatsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeConnectionStatsGetCfm *primitive = (CsrWifiSmeConnectionStatsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeConnectionStatsGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionStats.unifiTxDataRate, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionStats.unifiRxDataRate, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RetryCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11MultipleRetryCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11AckFailureCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11FrameDuplicateCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11FcsErrorCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RtsSuccessCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RtsFailureCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11FailedCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11TransmittedFragmentCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11TransmittedFrameCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11WepExcludedCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11WepIcvErrorCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11WepUndecryptableCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11MulticastReceivedFrameCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11MulticastTransmittedFrameCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11ReceivedFragmentCount, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11Rsna4WayHandshakeFailures, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaTkipCounterMeasuresInvoked, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaStatsTkipLocalMicFailures, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaStatsTkipReplays, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaStatsTkipIcvErrors, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaStatsCcmpReplays, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->connectionStats.dot11RsnaStatsCcmpDecryptErrors, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeDisconnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeDisconnectCfm *primitive = (CsrWifiSmeDisconnectCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeDisconnectCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeDisconnectCfm *primitive = (CsrWifiSmeDisconnectCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeDisconnectCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeHostConfigGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrWifiSmeHostPowerMode primitive->hostConfig.powerMode */
+ bufferSize += 2; /* CsrUint16 primitive->hostConfig.applicationDataPeriodMs */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeHostConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeHostConfigGetCfm *primitive = (CsrWifiSmeHostConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->hostConfig.powerMode);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->hostConfig.applicationDataPeriodMs);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeHostConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeHostConfigGetCfm *primitive = (CsrWifiSmeHostConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->hostConfig.powerMode, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->hostConfig.applicationDataPeriodMs, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeHostConfigSetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeHostConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeHostConfigSetCfm *primitive = (CsrWifiSmeHostConfigSetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeHostConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeHostConfigSetCfm *primitive = (CsrWifiSmeHostConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeHostConfigSetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeIbssStationIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ bufferSize += 1; /* CsrBool primitive->isconnected */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeIbssStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeIbssStationInd *primitive = (CsrWifiSmeIbssStationInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->isconnected);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeIbssStationIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeIbssStationInd *primitive = (CsrWifiSmeIbssStationInd *) CsrPmemAlloc(sizeof(CsrWifiSmeIbssStationInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->isconnected, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeKeyCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
+ bufferSize += 1; /* CsrWifiSmeKeyType primitive->keyType */
+ bufferSize += 6; /* CsrUint8 primitive->peerMacAddress.a[6] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeKeyCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeKeyCfm *primitive = (CsrWifiSmeKeyCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->keyType);
+ CsrMemCpySer(ptr, len, (const void *) primitive->peerMacAddress.a, ((CsrUint16) (6)));
+ return(ptr);
+}
+
+
+void* CsrWifiSmeKeyCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeKeyCfm *primitive = (CsrWifiSmeKeyCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeKeyCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->keyType, buffer, &offset);
+ CsrMemCpyDes(primitive->peerMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeLinkQualityGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiRssi */
+ bufferSize += 2; /* CsrInt16 primitive->linkQuality.unifiSnr */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeLinkQualityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeLinkQualityGetCfm *primitive = (CsrWifiSmeLinkQualityGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiRssi);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->linkQuality.unifiSnr);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeLinkQualityGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeLinkQualityGetCfm *primitive = (CsrWifiSmeLinkQualityGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeLinkQualityGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiRssi, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->linkQuality.unifiSnr, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg)
+{
+ CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 99) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeMediaStatus primitive->mediaStatus */
+ bufferSize += 32; /* CsrUint8 primitive->connectionInfo.ssid.ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->connectionInfo.ssid.length */
+ bufferSize += 6; /* CsrUint8 primitive->connectionInfo.bssid.a[6] */
+ bufferSize += 1; /* CsrWifiSme80211NetworkType primitive->connectionInfo.networkType80211 */
+ bufferSize += 1; /* CsrUint8 primitive->connectionInfo.channelNumber */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.channelFrequency */
+ bufferSize += 2; /* CsrWifiSmeAuthMode primitive->connectionInfo.authMode */
+ bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.pairwiseCipher */
+ bufferSize += 2; /* CsrWifiSmeEncryption primitive->connectionInfo.groupCipher */
+ bufferSize += 1; /* CsrWifiSmeRadioIF primitive->connectionInfo.ifIndex */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.atimWindowTu */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconPeriodTu */
+ bufferSize += 1; /* CsrBool primitive->connectionInfo.reassociation */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.beaconFrameLength */
+ bufferSize += primitive->connectionInfo.beaconFrameLength; /* CsrUint8 primitive->connectionInfo.beaconFrame */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationReqFrameLength */
+ bufferSize += primitive->connectionInfo.associationReqFrameLength; /* CsrUint8 primitive->connectionInfo.associationReqFrame */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.associationRspFrameLength */
+ bufferSize += primitive->connectionInfo.associationRspFrameLength; /* CsrUint8 primitive->connectionInfo.associationRspFrame */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocScanInfoElementsLength */
+ bufferSize += primitive->connectionInfo.assocScanInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocScanInfoElements */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqCapabilities */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqListenIntervalTu */
+ bufferSize += 6; /* CsrUint8 primitive->connectionInfo.assocReqApAddress.a[6] */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocReqInfoElementsLength */
+ bufferSize += primitive->connectionInfo.assocReqInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocReqInfoElements */
+ bufferSize += 2; /* CsrWifiSmeIEEE80211Result primitive->connectionInfo.assocRspResult */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspCapabilityInfo */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspAssociationId */
+ bufferSize += 2; /* CsrUint16 primitive->connectionInfo.assocRspInfoElementsLength */
+ bufferSize += primitive->connectionInfo.assocRspInfoElementsLength; /* CsrUint8 primitive->connectionInfo.assocRspInfoElements */
+ bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->disassocReason */
+ bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->deauthReason */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMediaStatusIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->mediaStatus);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.ssid.ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ssid.length);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.bssid.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.networkType80211);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.channelNumber);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.channelFrequency);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.authMode);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.pairwiseCipher);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.groupCipher);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.ifIndex);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.atimWindowTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconPeriodTu);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->connectionInfo.reassociation);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.beaconFrameLength);
+ if (primitive->connectionInfo.beaconFrameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.beaconFrame, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationReqFrameLength);
+ if (primitive->connectionInfo.associationReqFrameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationReqFrame, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.associationRspFrameLength);
+ if (primitive->connectionInfo.associationRspFrameLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.associationRspFrame, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocScanInfoElementsLength);
+ if (primitive->connectionInfo.assocScanInfoElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocScanInfoElements, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqCapabilities);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqListenIntervalTu);
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqApAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocReqInfoElementsLength);
+ if (primitive->connectionInfo.assocReqInfoElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocReqInfoElements, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspResult);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspCapabilityInfo);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspAssociationId);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->connectionInfo.assocRspInfoElementsLength);
+ if (primitive->connectionInfo.assocRspInfoElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->connectionInfo.assocRspInfoElements, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ }
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->disassocReason);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->deauthReason);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *) CsrPmemAlloc(sizeof(CsrWifiSmeMediaStatusInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->mediaStatus, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ssid.length, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.networkType80211, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.channelNumber, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.channelFrequency, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.authMode, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.pairwiseCipher, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.groupCipher, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.ifIndex, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.atimWindowTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconPeriodTu, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->connectionInfo.reassociation, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.beaconFrameLength, buffer, &offset);
+ if (primitive->connectionInfo.beaconFrameLength)
+ {
+ primitive->connectionInfo.beaconFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.beaconFrameLength);
+ CsrMemCpyDes(primitive->connectionInfo.beaconFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.beaconFrameLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.beaconFrame = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationReqFrameLength, buffer, &offset);
+ if (primitive->connectionInfo.associationReqFrameLength)
+ {
+ primitive->connectionInfo.associationReqFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationReqFrameLength);
+ CsrMemCpyDes(primitive->connectionInfo.associationReqFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationReqFrameLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.associationReqFrame = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.associationRspFrameLength, buffer, &offset);
+ if (primitive->connectionInfo.associationRspFrameLength)
+ {
+ primitive->connectionInfo.associationRspFrame = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.associationRspFrameLength);
+ CsrMemCpyDes(primitive->connectionInfo.associationRspFrame, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.associationRspFrameLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.associationRspFrame = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocScanInfoElementsLength, buffer, &offset);
+ if (primitive->connectionInfo.assocScanInfoElementsLength)
+ {
+ primitive->connectionInfo.assocScanInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocScanInfoElementsLength);
+ CsrMemCpyDes(primitive->connectionInfo.assocScanInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocScanInfoElementsLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.assocScanInfoElements = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqCapabilities, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqListenIntervalTu, buffer, &offset);
+ CsrMemCpyDes(primitive->connectionInfo.assocReqApAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocReqInfoElementsLength, buffer, &offset);
+ if (primitive->connectionInfo.assocReqInfoElementsLength)
+ {
+ primitive->connectionInfo.assocReqInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocReqInfoElementsLength);
+ CsrMemCpyDes(primitive->connectionInfo.assocReqInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocReqInfoElementsLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.assocReqInfoElements = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspResult, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspCapabilityInfo, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspAssociationId, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->connectionInfo.assocRspInfoElementsLength, buffer, &offset);
+ if (primitive->connectionInfo.assocRspInfoElementsLength)
+ {
+ primitive->connectionInfo.assocRspInfoElements = (CsrUint8 *)CsrPmemAlloc(primitive->connectionInfo.assocRspInfoElementsLength);
+ CsrMemCpyDes(primitive->connectionInfo.assocRspInfoElements, buffer, &offset, ((CsrUint16) (primitive->connectionInfo.assocRspInfoElementsLength)));
+ }
+ else
+ {
+ primitive->connectionInfo.assocRspInfoElements = NULL;
+ }
+ CsrUint16Des((CsrUint16 *) &primitive->disassocReason, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->deauthReason, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiSmeMediaStatusIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeMediaStatusInd *primitive = (CsrWifiSmeMediaStatusInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->connectionInfo.beaconFrame);
+ CsrPmemFree(primitive->connectionInfo.associationReqFrame);
+ CsrPmemFree(primitive->connectionInfo.associationRspFrame);
+ CsrPmemFree(primitive->connectionInfo.assocScanInfoElements);
+ CsrPmemFree(primitive->connectionInfo.assocReqInfoElements);
+ CsrPmemFree(primitive->connectionInfo.assocRspInfoElements);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrBool primitive->mibConfig.unifiFixMaxTxDataRate */
+ bufferSize += 1; /* CsrUint8 primitive->mibConfig.unifiFixTxDataRate */
+ bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11RtsThreshold */
+ bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11FragmentationThreshold */
+ bufferSize += 2; /* CsrUint16 primitive->mibConfig.dot11CurrentTxPowerLevel */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMibConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMibConfigGetCfm *primitive = (CsrWifiSmeMibConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixMaxTxDataRate);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->mibConfig.unifiFixTxDataRate);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11RtsThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11FragmentationThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibConfig.dot11CurrentTxPowerLevel);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMibConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMibConfigGetCfm *primitive = (CsrWifiSmeMibConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixMaxTxDataRate, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->mibConfig.unifiFixTxDataRate, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11RtsThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11FragmentationThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibConfig.dot11CurrentTxPowerLevel, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeMibGetCfmSizeof(void *msg)
+{
+ CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
+ bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMibGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+ if (primitive->mibAttributeLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMibGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+ if (primitive->mibAttributeLength)
+ {
+ primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+ CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+ }
+ else
+ {
+ primitive->mibAttribute = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeMibGetCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeMibGetCfm *primitive = (CsrWifiSmeMibGetCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->mibAttribute);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeMibGetNextCfmSizeof(void *msg)
+{
+ CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 2; /* CsrUint16 primitive->mibAttributeLength */
+ bufferSize += primitive->mibAttributeLength; /* CsrUint8 primitive->mibAttribute */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMibGetNextCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->mibAttributeLength);
+ if (primitive->mibAttributeLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->mibAttribute, ((CsrUint16) (primitive->mibAttributeLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMibGetNextCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMibGetNextCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->mibAttributeLength, buffer, &offset);
+ if (primitive->mibAttributeLength)
+ {
+ primitive->mibAttribute = (CsrUint8 *)CsrPmemAlloc(primitive->mibAttributeLength);
+ CsrMemCpyDes(primitive->mibAttribute, buffer, &offset, ((CsrUint16) (primitive->mibAttributeLength)));
+ }
+ else
+ {
+ primitive->mibAttribute = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeMibGetNextCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeMibGetNextCfm *primitive = (CsrWifiSmeMibGetNextCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->mibAttribute);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeMicFailureIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrBool primitive->secondFailure */
+ bufferSize += 2; /* CsrUint16 primitive->count */
+ bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ bufferSize += 1; /* CsrWifiSmeKeyType primitive->keyType */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMicFailureInd *primitive = (CsrWifiSmeMicFailureInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->secondFailure);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->count);
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->keyType);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMicFailureIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMicFailureInd *primitive = (CsrWifiSmeMicFailureInd *) CsrPmemAlloc(sizeof(CsrWifiSmeMicFailureInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->secondFailure, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->count, buffer, &offset);
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->keyType, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeMulticastAddressCfmSizeof(void *msg)
+{
+ CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
+ bufferSize += 1; /* CsrUint8 primitive->getAddressesCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->getAddresses[i1].a[6] */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeMulticastAddressCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->getAddressesCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->getAddresses[i1].a, ((CsrUint16) (6)));
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeMulticastAddressCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeMulticastAddressCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->getAddressesCount, buffer, &offset);
+ primitive->getAddresses = NULL;
+ if (primitive->getAddressesCount)
+ {
+ primitive->getAddresses = (CsrWifiMacAddress *)CsrPmemAlloc(sizeof(CsrWifiMacAddress) * primitive->getAddressesCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getAddressesCount; i1++)
+ {
+ CsrMemCpyDes(primitive->getAddresses[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeMulticastAddressCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeMulticastAddressCfm *primitive = (CsrWifiSmeMulticastAddressCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->getAddresses);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmePacketFilterSetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmePacketFilterSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmePacketFilterSetCfm *primitive = (CsrWifiSmePacketFilterSetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiSmePacketFilterSetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmePacketFilterSetCfm *primitive = (CsrWifiSmePacketFilterSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePacketFilterSetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 11) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 6; /* CsrUint8 primitive->permanentMacAddress.a[6] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmePermanentMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmePermanentMacAddressGetCfm *primitive = (CsrWifiSmePermanentMacAddressGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrMemCpySer(ptr, len, (const void *) primitive->permanentMacAddress.a, ((CsrUint16) (6)));
+ return(ptr);
+}
+
+
+void* CsrWifiSmePermanentMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmePermanentMacAddressGetCfm *primitive = (CsrWifiSmePermanentMacAddressGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePermanentMacAddressGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrMemCpyDes(primitive->permanentMacAddress.a, buffer, &offset, ((CsrUint16) (6)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg)
+{
+ CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrUint8 primitive->pmkidCandidatesCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->pmkidCandidates[i1].bssid.a[6] */
+ bufferSize += 1; /* CsrBool primitive->pmkidCandidates[i1].preAuthAllowed */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmePmkidCandidateListIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->pmkidCandidatesCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->pmkidCandidates[i1].bssid.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->pmkidCandidates[i1].preAuthAllowed);
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmePmkidCandidateListIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidCandidateListInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->pmkidCandidatesCount, buffer, &offset);
+ primitive->pmkidCandidates = NULL;
+ if (primitive->pmkidCandidatesCount)
+ {
+ primitive->pmkidCandidates = (CsrWifiSmePmkidCandidate *)CsrPmemAlloc(sizeof(CsrWifiSmePmkidCandidate) * primitive->pmkidCandidatesCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->pmkidCandidatesCount; i1++)
+ {
+ CsrMemCpyDes(primitive->pmkidCandidates[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->pmkidCandidates[i1].preAuthAllowed, buffer, &offset);
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmePmkidCandidateListIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmePmkidCandidateListInd *primitive = (CsrWifiSmePmkidCandidateListInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->pmkidCandidates);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmePmkidCfmSizeof(void *msg)
+{
+ CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 31) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrWifiSmeListAction primitive->action */
+ bufferSize += 1; /* CsrUint8 primitive->getPmkidsCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->getPmkids[i1].bssid.a[6] */
+ bufferSize += 16; /* CsrUint8 primitive->getPmkids[i1].pmkid[16] */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmePmkidCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->action);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->getPmkidsCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->getPmkids[i1].bssid.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->getPmkids[i1].pmkid, ((CsrUint16) (16)));
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmePmkidCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePmkidCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->action, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->getPmkidsCount, buffer, &offset);
+ primitive->getPmkids = NULL;
+ if (primitive->getPmkidsCount)
+ {
+ primitive->getPmkids = (CsrWifiSmePmkid *)CsrPmemAlloc(sizeof(CsrWifiSmePmkid) * primitive->getPmkidsCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->getPmkidsCount; i1++)
+ {
+ CsrMemCpyDes(primitive->getPmkids[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->getPmkids[i1].pmkid, buffer, &offset, ((CsrUint16) (16)));
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmePmkidCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmePmkidCfm *primitive = (CsrWifiSmePmkidCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->getPmkids);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrWifiSmePowerSaveLevel primitive->powerConfig.powerSaveLevel */
+ bufferSize += 2; /* CsrUint16 primitive->powerConfig.listenIntervalTu */
+ bufferSize += 1; /* CsrBool primitive->powerConfig.rxDtims */
+ bufferSize += 1; /* CsrWifiSmeD3AutoScanMode primitive->powerConfig.d3AutoScanMode */
+ bufferSize += 1; /* CsrUint8 primitive->powerConfig.clientTrafficWindow */
+ bufferSize += 1; /* CsrBool primitive->powerConfig.opportunisticPowerSave */
+ bufferSize += 1; /* CsrBool primitive->powerConfig.noticeOfAbsence */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmePowerConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmePowerConfigGetCfm *primitive = (CsrWifiSmePowerConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.powerSaveLevel);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->powerConfig.listenIntervalTu);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.rxDtims);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.d3AutoScanMode);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.clientTrafficWindow);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.opportunisticPowerSave);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->powerConfig.noticeOfAbsence);
+ return(ptr);
+}
+
+
+void* CsrWifiSmePowerConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmePowerConfigGetCfm *primitive = (CsrWifiSmePowerConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmePowerConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.powerSaveLevel, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->powerConfig.listenIntervalTu, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.rxDtims, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.d3AutoScanMode, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.clientTrafficWindow, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.opportunisticPowerSave, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->powerConfig.noticeOfAbsence, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrBool primitive->regDomInfo.dot11MultiDomainCapabilityImplemented */
+ bufferSize += 1; /* CsrBool primitive->regDomInfo.dot11MultiDomainCapabilityEnabled */
+ bufferSize += 1; /* CsrWifiSmeRegulatoryDomain primitive->regDomInfo.currentRegulatoryDomain */
+ bufferSize += 2; /* CsrUint8 primitive->regDomInfo.currentCountryCode[2] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeRegulatoryDomainInfoGetCfm *primitive = (CsrWifiSmeRegulatoryDomainInfoGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->regDomInfo.dot11MultiDomainCapabilityImplemented);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->regDomInfo.dot11MultiDomainCapabilityEnabled);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->regDomInfo.currentRegulatoryDomain);
+ CsrMemCpySer(ptr, len, (const void *) primitive->regDomInfo.currentCountryCode, ((CsrUint16) (2)));
+ return(ptr);
+}
+
+
+void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeRegulatoryDomainInfoGetCfm *primitive = (CsrWifiSmeRegulatoryDomainInfoGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRegulatoryDomainInfoGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityImplemented, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->regDomInfo.dot11MultiDomainCapabilityEnabled, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->regDomInfo.currentRegulatoryDomain, buffer, &offset);
+ CsrMemCpyDes(primitive->regDomInfo.currentCountryCode, buffer, &offset, ((CsrUint16) (2)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeRoamCompleteIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeRoamCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeRoamCompleteInd *primitive = (CsrWifiSmeRoamCompleteInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeRoamCompleteIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeRoamCompleteInd *primitive = (CsrWifiSmeRoamCompleteInd *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamCompleteInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeRoamStartIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 1; /* CsrWifiSmeRoamReason primitive->roamReason */
+ bufferSize += 2; /* CsrWifiSmeIEEE80211Reason primitive->reason80211 */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeRoamStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeRoamStartInd *primitive = (CsrWifiSmeRoamStartInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamReason);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->reason80211);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeRoamStartIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeRoamStartInd *primitive = (CsrWifiSmeRoamStartInd *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamStartInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->roamReason, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->reason80211, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 72) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].rssiHighThreshold */
+ bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].rssiLowThreshold */
+ bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].snrHighThreshold */
+ bufferSize += 2; /* CsrInt16 primitive->roamingConfig.roamingBands[i2].snrLowThreshold */
+ }
+ }
+ bufferSize += 1; /* CsrBool primitive->roamingConfig.disableSmoothRoaming */
+ bufferSize += 1; /* CsrBool primitive->roamingConfig.disableRoamScans */
+ bufferSize += 1; /* CsrUint8 primitive->roamingConfig.reconnectLimit */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.reconnectLimitIntervalMs */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].intervalSeconds */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].validitySeconds */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeRoamingConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeRoamingConfigGetCfm *primitive = (CsrWifiSmeRoamingConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiHighThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].rssiLowThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrHighThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamingBands[i2].snrLowThreshold);
+ }
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableSmoothRoaming);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.disableRoamScans);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->roamingConfig.reconnectLimit);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.reconnectLimitIntervalMs);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].intervalSeconds);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].validitySeconds);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu);
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeRoamingConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeRoamingConfigGetCfm *primitive = (CsrWifiSmeRoamingConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiHighThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].rssiLowThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrHighThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamingBands[i2].snrLowThreshold, buffer, &offset);
+ }
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableSmoothRoaming, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.disableRoamScans, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->roamingConfig.reconnectLimit, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.reconnectLimitIntervalMs, buffer, &offset);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 3; i2++)
+ {
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].intervalSeconds, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].validitySeconds, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->roamingConfig.roamScanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+ }
+ }
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeRoamingConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeRoamingConfigSetCfm *primitive = (CsrWifiSmeRoamingConfigSetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeRoamingConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeRoamingConfigSetCfm *primitive = (CsrWifiSmeRoamingConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeRoamingConfigSetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeScanConfigGetCfmSizeof(void *msg)
+{
+ CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 65) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].intervalSeconds */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].validitySeconds */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu */
+ }
+ }
+ bufferSize += 1; /* CsrBool primitive->scanConfig.disableAutonomousScans */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.maxResults */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.highRssiThreshold */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.lowRssiThreshold */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.deltaRssiThreshold */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.highSnrThreshold */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.lowSnrThreshold */
+ bufferSize += 1; /* CsrInt8 primitive->scanConfig.deltaSnrThreshold */
+ bufferSize += 2; /* CsrUint16 primitive->scanConfig.passiveChannelListCount */
+ bufferSize += primitive->scanConfig.passiveChannelListCount; /* CsrUint8 primitive->scanConfig.passiveChannelList */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeScanConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].intervalSeconds);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].validitySeconds);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu);
+ }
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.disableAutonomousScans);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.maxResults);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highRssiThreshold);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowRssiThreshold);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaRssiThreshold);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.highSnrThreshold);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.lowSnrThreshold);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanConfig.deltaSnrThreshold);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanConfig.passiveChannelListCount);
+ if (primitive->scanConfig.passiveChannelListCount)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanConfig.passiveChannelList, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeScanConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < 4; i2++)
+ {
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].intervalSeconds, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].validitySeconds, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxActiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].minPassiveChannelTimeTu, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.scanCfg[i2].maxPassiveChannelTimeTu, buffer, &offset);
+ }
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.disableAutonomousScans, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.maxResults, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highRssiThreshold, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowRssiThreshold, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaRssiThreshold, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.highSnrThreshold, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.lowSnrThreshold, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanConfig.deltaSnrThreshold, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanConfig.passiveChannelListCount, buffer, &offset);
+ if (primitive->scanConfig.passiveChannelListCount)
+ {
+ primitive->scanConfig.passiveChannelList = (CsrUint8 *)CsrPmemAlloc(primitive->scanConfig.passiveChannelListCount);
+ CsrMemCpyDes(primitive->scanConfig.passiveChannelList, buffer, &offset, ((CsrUint16) (primitive->scanConfig.passiveChannelListCount)));
+ }
+ else
+ {
+ primitive->scanConfig.passiveChannelList = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeScanConfigGetCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeScanConfigGetCfm *primitive = (CsrWifiSmeScanConfigGetCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->scanConfig.passiveChannelList);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeScanResultIndSizeof(void *msg)
+{
+ CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 149) */
+ bufferSize += 32; /* CsrUint8 primitive->result.ssid.ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->result.ssid.length */
+ bufferSize += 6; /* CsrUint8 primitive->result.bssid.a[6] */
+ bufferSize += 2; /* CsrInt16 primitive->result.rssi */
+ bufferSize += 2; /* CsrInt16 primitive->result.snr */
+ bufferSize += 1; /* CsrWifiSmeRadioIF primitive->result.ifIndex */
+ bufferSize += 2; /* CsrUint16 primitive->result.beaconPeriodTu */
+ bufferSize += 8; /* CsrUint8 primitive->result.timeStamp.data[8] */
+ bufferSize += 8; /* CsrUint8 primitive->result.localTime.data[8] */
+ bufferSize += 2; /* CsrUint16 primitive->result.channelFrequency */
+ bufferSize += 2; /* CsrUint16 primitive->result.capabilityInformation */
+ bufferSize += 1; /* CsrUint8 primitive->result.channelNumber */
+ bufferSize += 1; /* CsrWifiSmeBasicUsability primitive->result.usability */
+ bufferSize += 1; /* CsrWifiSmeBssType primitive->result.bssType */
+ bufferSize += 2; /* CsrUint16 primitive->result.informationElementsLength */
+ bufferSize += primitive->result.informationElementsLength; /* CsrUint8 primitive->result.informationElements */
+ bufferSize += 1; /* CsrWifiSmeP2pRole primitive->result.p2pDeviceRole */
+ switch (primitive->result.p2pDeviceRole)
+ {
+ case CSR_WIFI_SME_P2P_ROLE_CLI:
+ bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.reservedCli.empty */
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_GO:
+ bufferSize += 1; /* CsrWifiSmeP2pGroupCapabilityMask primitive->result.deviceInfo.groupInfo.groupCapability */
+ bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
+ bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2pClientInfoCount */
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
+ bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a[6] */
+ bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods */
+ bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap */
+ bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
+ bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
+ {
+ CsrUint16 i6;
+ for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
+ {
+ bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
+ }
+ }
+ bufferSize += 32; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName[32] */
+ bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength */
+ }
+ }
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_NONE:
+ bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.reservedNone.empty */
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
+ bufferSize += 6; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a[6] */
+ bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->result.deviceInfo.standalonedevInfo.configMethods */
+ bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap */
+ bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
+ bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
+ {
+ bufferSize += 8; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
+ }
+ }
+ bufferSize += 32; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.deviceName[32] */
+ bufferSize += 1; /* CsrUint8 primitive->result.deviceInfo.standalonedevInfo.deviceNameLength */
+ break;
+ default:
+ break;
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeScanResultIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.ssid.ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.ssid.length);
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.bssid.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.rssi);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.snr);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.ifIndex);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.beaconPeriodTu);
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.timeStamp.data, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.localTime.data, ((CsrUint16) (8)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.channelFrequency);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.capabilityInformation);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.channelNumber);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.usability);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.bssType);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.informationElementsLength);
+ if (primitive->result.informationElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.informationElements, ((CsrUint16) (primitive->result.informationElementsLength)));
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.p2pDeviceRole);
+ switch (primitive->result.p2pDeviceRole)
+ {
+ case CSR_WIFI_SME_P2P_ROLE_CLI:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.reservedCli.empty);
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_GO:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.groupCapability);
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2pClientInfoCount);
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
+ {
+ CsrUint16 i6;
+ for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, ((CsrUint16) (8)));
+ }
+ }
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
+ }
+ }
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_NONE:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.reservedNone.empty);
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->result.deviceInfo.standalonedevInfo.configMethods);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap);
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, ((CsrUint16) (8)));
+ }
+ }
+ CsrMemCpySer(ptr, len, (const void *) primitive->result.deviceInfo.standalonedevInfo.deviceName, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->result.deviceInfo.standalonedevInfo.deviceNameLength);
+ break;
+ default:
+ break;
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeScanResultIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrMemCpyDes(primitive->result.ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->result.ssid.length, buffer, &offset);
+ CsrMemCpyDes(primitive->result.bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->result.rssi, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->result.snr, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->result.ifIndex, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->result.beaconPeriodTu, buffer, &offset);
+ CsrMemCpyDes(primitive->result.timeStamp.data, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->result.localTime.data, buffer, &offset, ((CsrUint16) (8)));
+ CsrUint16Des((CsrUint16 *) &primitive->result.channelFrequency, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->result.capabilityInformation, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->result.channelNumber, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->result.usability, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->result.bssType, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->result.informationElementsLength, buffer, &offset);
+ if (primitive->result.informationElementsLength)
+ {
+ primitive->result.informationElements = (CsrUint8 *)CsrPmemAlloc(primitive->result.informationElementsLength);
+ CsrMemCpyDes(primitive->result.informationElements, buffer, &offset, ((CsrUint16) (primitive->result.informationElementsLength)));
+ }
+ else
+ {
+ primitive->result.informationElements = NULL;
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->result.p2pDeviceRole, buffer, &offset);
+ switch (primitive->result.p2pDeviceRole)
+ {
+ case CSR_WIFI_SME_P2P_ROLE_CLI:
+ CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.reservedCli.empty, buffer, &offset);
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_GO:
+ CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.groupCapability, buffer, &offset);
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
+ primitive->result.deviceInfo.groupInfo.p2PClientInfo = NULL;
+ if (primitive->result.deviceInfo.groupInfo.p2pClientInfoCount)
+ {
+ primitive->result.deviceInfo.groupInfo.p2PClientInfo = (CsrWifiSmeP2pClientInfoType *)CsrPmemAlloc(sizeof(CsrWifiSmeP2pClientInfoType) * primitive->result.deviceInfo.groupInfo.p2pClientInfoCount);
+ }
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
+ {
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, buffer, &offset);
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
+ primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = NULL;
+ if (primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount)
+ {
+ primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
+ }
+ {
+ CsrUint16 i6;
+ for (i6 = 0; i6 < primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
+ {
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ }
+ }
+ CsrMemCpyDes(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
+ }
+ }
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_NONE:
+ CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.reservedNone.empty, buffer, &offset);
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
+ CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->result.deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
+ CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
+ primitive->result.deviceInfo.standalonedevInfo.secDeviceType = NULL;
+ if (primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount)
+ {
+ primitive->result.deviceInfo.standalonedevInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
+ }
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->result.deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
+ {
+ CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ }
+ }
+ CsrMemCpyDes(primitive->result.deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->result.deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
+ break;
+ default:
+ break;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeScanResultIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeScanResultInd *primitive = (CsrWifiSmeScanResultInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->result.informationElements);
+ switch (primitive->result.p2pDeviceRole)
+ {
+ case CSR_WIFI_SME_P2P_ROLE_GO:
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->result.deviceInfo.groupInfo.p2pClientInfoCount; i4++)
+ {
+ CsrPmemFree(primitive->result.deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
+ }
+ }
+ CsrPmemFree(primitive->result.deviceInfo.groupInfo.p2PClientInfo);
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
+ CsrPmemFree(primitive->result.deviceInfo.standalonedevInfo.secDeviceType);
+ break;
+ default:
+ break;
+ }
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg)
+{
+ CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 153) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 2; /* CsrUint16 primitive->scanResultsCount */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
+ {
+ bufferSize += 32; /* CsrUint8 primitive->scanResults[i1].ssid.ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].ssid.length */
+ bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].bssid.a[6] */
+ bufferSize += 2; /* CsrInt16 primitive->scanResults[i1].rssi */
+ bufferSize += 2; /* CsrInt16 primitive->scanResults[i1].snr */
+ bufferSize += 1; /* CsrWifiSmeRadioIF primitive->scanResults[i1].ifIndex */
+ bufferSize += 2; /* CsrUint16 primitive->scanResults[i1].beaconPeriodTu */
+ bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].timeStamp.data[8] */
+ bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].localTime.data[8] */
+ bufferSize += 2; /* CsrUint16 primitive->scanResults[i1].channelFrequency */
+ bufferSize += 2; /* CsrUint16 primitive->scanResults[i1].capabilityInformation */
+ bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].channelNumber */
+ bufferSize += 1; /* CsrWifiSmeBasicUsability primitive->scanResults[i1].usability */
+ bufferSize += 1; /* CsrWifiSmeBssType primitive->scanResults[i1].bssType */
+ bufferSize += 2; /* CsrUint16 primitive->scanResults[i1].informationElementsLength */
+ bufferSize += primitive->scanResults[i1].informationElementsLength; /* CsrUint8 primitive->scanResults[i1].informationElements */
+ bufferSize += 1; /* CsrWifiSmeP2pRole primitive->scanResults[i1].p2pDeviceRole */
+ switch (primitive->scanResults[i1].p2pDeviceRole)
+ {
+ case CSR_WIFI_SME_P2P_ROLE_CLI:
+ bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.reservedCli.empty */
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_GO:
+ bufferSize += 1; /* CsrWifiSmeP2pGroupCapabilityMask primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability */
+ bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a[6] */
+ bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount */
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a[6] */
+ bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a[6] */
+ bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods */
+ bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap */
+ bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails[8] */
+ bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount */
+ {
+ CsrUint16 i6;
+ for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
+ {
+ bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails[8] */
+ }
+ }
+ bufferSize += 32; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName[32] */
+ bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength */
+ }
+ }
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_NONE:
+ bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.reservedNone.empty */
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
+ bufferSize += 6; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a[6] */
+ bufferSize += 2; /* CsrWifiSmeWpsConfigTypeMask primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods */
+ bufferSize += 1; /* CsrWifiSmeP2pCapabilityMask primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap */
+ bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails[8] */
+ bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount */
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
+ {
+ bufferSize += 8; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails[8] */
+ }
+ }
+ bufferSize += 32; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName[32] */
+ bufferSize += 1; /* CsrUint8 primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength */
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResultsCount);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].ssid.ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].ssid.length);
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].bssid.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].rssi);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].snr);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].ifIndex);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].beaconPeriodTu);
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].timeStamp.data, ((CsrUint16) (8)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].localTime.data, ((CsrUint16) (8)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].channelFrequency);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].capabilityInformation);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].channelNumber);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].usability);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].bssType);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].informationElementsLength);
+ if (primitive->scanResults[i1].informationElementsLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].informationElements, ((CsrUint16) (primitive->scanResults[i1].informationElementsLength)));
+ }
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].p2pDeviceRole);
+ switch (primitive->scanResults[i1].p2pDeviceRole)
+ {
+ case CSR_WIFI_SME_P2P_ROLE_CLI:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.reservedCli.empty);
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_GO:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability);
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, ((CsrUint16) (6)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount);
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, ((CsrUint16) (6)));
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap);
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
+ {
+ CsrUint16 i6;
+ for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, ((CsrUint16) (8)));
+ }
+ }
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength);
+ }
+ }
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_NONE:
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.reservedNone.empty);
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, ((CsrUint16) (6)));
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap);
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, ((CsrUint16) (8)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, ((CsrUint16) (8)));
+ }
+ }
+ CsrMemCpySer(ptr, len, (const void *) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeScanResultsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeScanResultsGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanResultsCount, buffer, &offset);
+ primitive->scanResults = NULL;
+ if (primitive->scanResultsCount)
+ {
+ primitive->scanResults = (CsrWifiSmeScanResult *)CsrPmemAlloc(sizeof(CsrWifiSmeScanResult) * primitive->scanResultsCount);
+ }
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
+ {
+ CsrMemCpyDes(primitive->scanResults[i1].ssid.ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].ssid.length, buffer, &offset);
+ CsrMemCpyDes(primitive->scanResults[i1].bssid.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].rssi, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].snr, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].ifIndex, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].beaconPeriodTu, buffer, &offset);
+ CsrMemCpyDes(primitive->scanResults[i1].timeStamp.data, buffer, &offset, ((CsrUint16) (8)));
+ CsrMemCpyDes(primitive->scanResults[i1].localTime.data, buffer, &offset, ((CsrUint16) (8)));
+ CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].channelFrequency, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].capabilityInformation, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].channelNumber, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].usability, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].bssType, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].informationElementsLength, buffer, &offset);
+ if (primitive->scanResults[i1].informationElementsLength)
+ {
+ primitive->scanResults[i1].informationElements = (CsrUint8 *)CsrPmemAlloc(primitive->scanResults[i1].informationElementsLength);
+ CsrMemCpyDes(primitive->scanResults[i1].informationElements, buffer, &offset, ((CsrUint16) (primitive->scanResults[i1].informationElementsLength)));
+ }
+ else
+ {
+ primitive->scanResults[i1].informationElements = NULL;
+ }
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].p2pDeviceRole, buffer, &offset);
+ switch (primitive->scanResults[i1].p2pDeviceRole)
+ {
+ case CSR_WIFI_SME_P2P_ROLE_CLI:
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.reservedCli.empty, buffer, &offset);
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_GO:
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.groupCapability, buffer, &offset);
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2pDeviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount, buffer, &offset);
+ primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo = NULL;
+ if (primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount)
+ {
+ primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo = (CsrWifiSmeP2pClientInfoType *)CsrPmemAlloc(sizeof(CsrWifiSmeP2pClientInfoType) * primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount);
+ }
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
+ {
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].p2PClientInterfaceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.configMethods, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.p2PDeviceCap, buffer, &offset);
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount, buffer, &offset);
+ primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = NULL;
+ if (primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount)
+ {
+ primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount);
+ }
+ {
+ CsrUint16 i6;
+ for (i6 = 0; i6 < primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secondaryDeviceTypeCount; i6++)
+ {
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType[i6].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ }
+ }
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.deviceNameLength, buffer, &offset);
+ }
+ }
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_NONE:
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.reservedNone.empty, buffer, &offset);
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceAddress.a, buffer, &offset, ((CsrUint16) (6)));
+ CsrUint16Des((CsrUint16 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.configMethods, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.p2PDeviceCap, buffer, &offset);
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.primDeviceType.deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount, buffer, &offset);
+ primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType = NULL;
+ if (primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount)
+ {
+ primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType = (CsrWifiSmeWpsDeviceType *)CsrPmemAlloc(sizeof(CsrWifiSmeWpsDeviceType) * primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount);
+ }
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.standalonedevInfo.secondaryDeviceTypeCount; i4++)
+ {
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType[i4].deviceDetails, buffer, &offset, ((CsrUint16) (8)));
+ }
+ }
+ CsrMemCpyDes(primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceName, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->scanResults[i1].deviceInfo.standalonedevInfo.deviceNameLength, buffer, &offset);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeScanResultsGetCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeScanResultsGetCfm *primitive = (CsrWifiSmeScanResultsGetCfm *) voidPrimitivePointer;
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < primitive->scanResultsCount; i1++)
+ {
+ CsrPmemFree(primitive->scanResults[i1].informationElements);
+ switch (primitive->scanResults[i1].p2pDeviceRole)
+ {
+ case CSR_WIFI_SME_P2P_ROLE_GO:
+ {
+ CsrUint16 i4;
+ for (i4 = 0; i4 < primitive->scanResults[i1].deviceInfo.groupInfo.p2pClientInfoCount; i4++)
+ {
+ CsrPmemFree(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo[i4].clientDeviceInfo.secDeviceType);
+ }
+ }
+ CsrPmemFree(primitive->scanResults[i1].deviceInfo.groupInfo.p2PClientInfo);
+ break;
+ case CSR_WIFI_SME_P2P_ROLE_STANDALONE:
+ CsrPmemFree(primitive->scanResults[i1].deviceInfo.standalonedevInfo.secDeviceType);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ CsrPmemFree(primitive->scanResults);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualityRssiChangeTrigger */
+ bufferSize += 1; /* CsrUint8 primitive->smeConfig.connectionQualitySnrChangeTrigger */
+ bufferSize += 1; /* CsrWifiSmeWmmModeMask primitive->smeConfig.wmmModeMask */
+ bufferSize += 1; /* CsrWifiSmeRadioIF primitive->smeConfig.ifIndex */
+ bufferSize += 1; /* CsrBool primitive->smeConfig.allowUnicastUseGroupCipher */
+ bufferSize += 1; /* CsrBool primitive->smeConfig.enableOpportunisticKeyCaching */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeSmeStaConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeSmeStaConfigGetCfm *primitive = (CsrWifiSmeSmeStaConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualityRssiChangeTrigger);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.connectionQualitySnrChangeTrigger);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.wmmModeMask);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.ifIndex);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.allowUnicastUseGroupCipher);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->smeConfig.enableOpportunisticKeyCaching);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeSmeStaConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeSmeStaConfigGetCfm *primitive = (CsrWifiSmeSmeStaConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualityRssiChangeTrigger, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.connectionQualitySnrChangeTrigger, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.wmmModeMask, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.ifIndex, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.allowUnicastUseGroupCipher, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->smeConfig.enableOpportunisticKeyCaching, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 7) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeSmeStaConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeSmeStaConfigSetCfm *primitive = (CsrWifiSmeSmeStaConfigSetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeSmeStaConfigSetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeSmeStaConfigSetCfm *primitive = (CsrWifiSmeSmeStaConfigSetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeStaConfigSetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 17) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 2; i1++)
+ {
+ bufferSize += 6; /* CsrUint8 primitive->stationMacAddress[i1].a[6] */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeStationMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeStationMacAddressGetCfm *primitive = (CsrWifiSmeStationMacAddressGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 2; i1++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->stationMacAddress[i1].a, ((CsrUint16) (6)));
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeStationMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeStationMacAddressGetCfm *primitive = (CsrWifiSmeStationMacAddressGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeStationMacAddressGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ {
+ CsrUint16 i1;
+ for (i1 = 0; i1 < 2; i1++)
+ {
+ CsrMemCpyDes(primitive->stationMacAddress[i1].a, buffer, &offset, ((CsrUint16) (6)));
+ }
+ }
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeTspecIndSizeof(void *msg)
+{
+ CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 13) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 4; /* CsrUint32 primitive->transactionId */
+ bufferSize += 1; /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
+ bufferSize += 2; /* CsrUint16 primitive->tspecLength */
+ bufferSize += primitive->tspecLength; /* CsrUint8 primitive->tspec */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeTspecIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->tspecResultCode);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
+ if (primitive->tspecLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((CsrUint16) (primitive->tspecLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeTspecIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->tspecResultCode, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
+ if (primitive->tspecLength)
+ {
+ primitive->tspec = (CsrUint8 *)CsrPmemAlloc(primitive->tspecLength);
+ CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
+ }
+ else
+ {
+ primitive->tspec = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeTspecIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeTspecInd *primitive = (CsrWifiSmeTspecInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->tspec);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeTspecCfmSizeof(void *msg)
+{
+ CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 15) */
+ bufferSize += 2; /* CsrUint16 primitive->interfaceTag */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 4; /* CsrUint32 primitive->transactionId */
+ bufferSize += 1; /* CsrWifiSmeTspecResultCode primitive->tspecResultCode */
+ bufferSize += 2; /* CsrUint16 primitive->tspecLength */
+ bufferSize += primitive->tspecLength; /* CsrUint8 primitive->tspec */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeTspecCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->interfaceTag);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->transactionId);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->tspecResultCode);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->tspecLength);
+ if (primitive->tspecLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->tspec, ((CsrUint16) (primitive->tspecLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeTspecCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeTspecCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->interfaceTag, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->transactionId, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->tspecResultCode, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->tspecLength, buffer, &offset);
+ if (primitive->tspecLength)
+ {
+ primitive->tspec = (CsrUint8 *)CsrPmemAlloc(primitive->tspecLength);
+ CsrMemCpyDes(primitive->tspec, buffer, &offset, ((CsrUint16) (primitive->tspecLength)));
+ }
+ else
+ {
+ primitive->tspec = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeTspecCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeTspecCfm *primitive = (CsrWifiSmeTspecCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->tspec);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeVersionsGetCfmSizeof(void *msg)
+{
+ CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 33) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 4; /* CsrUint32 primitive->versions.chipId */
+ bufferSize += 4; /* CsrUint32 primitive->versions.chipVersion */
+ bufferSize += 4; /* CsrUint32 primitive->versions.firmwareBuild */
+ bufferSize += 4; /* CsrUint32 primitive->versions.firmwarePatch */
+ bufferSize += 4; /* CsrUint32 primitive->versions.firmwareHip */
+ bufferSize += (primitive->versions.routerBuild?CsrStrLen(primitive->versions.routerBuild) : 0) + 1; /* CsrCharString* primitive->versions.routerBuild (0 byte len + 1 for NULL Term) */
+ bufferSize += 4; /* CsrUint32 primitive->versions.routerHip */
+ bufferSize += (primitive->versions.smeBuild?CsrStrLen(primitive->versions.smeBuild) : 0) + 1; /* CsrCharString* primitive->versions.smeBuild (0 byte len + 1 for NULL Term) */
+ bufferSize += 4; /* CsrUint32 primitive->versions.smeHip */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeVersionsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipId);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.chipVersion);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwareBuild);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwarePatch);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.firmwareHip);
+ CsrCharStringSer(ptr, len, primitive->versions.routerBuild);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.routerHip);
+ CsrCharStringSer(ptr, len, primitive->versions.smeBuild);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->versions.smeHip);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeVersionsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeVersionsGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.chipId, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.chipVersion, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.firmwareBuild, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.firmwarePatch, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.firmwareHip, buffer, &offset);
+ CsrCharStringDes(&primitive->versions.routerBuild, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.routerHip, buffer, &offset);
+ CsrCharStringDes(&primitive->versions.smeBuild, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->versions.smeHip, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiSmeVersionsGetCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeVersionsGetCfm *primitive = (CsrWifiSmeVersionsGetCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->versions.routerBuild);
+ CsrPmemFree(primitive->versions.smeBuild);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg)
+{
+ CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 39) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrUint8 primitive->cloakedSsids.cloakedSsidsCount */
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
+ {
+ bufferSize += 32; /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].ssid[32] */
+ bufferSize += 1; /* CsrUint8 primitive->cloakedSsids.cloakedSsids[i2].length */
+ }
+ }
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCloakedSsidsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsidsCount);
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->cloakedSsids.cloakedSsids[i2].ssid, ((CsrUint16) (32)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->cloakedSsids.cloakedSsids[i2].length);
+ }
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCloakedSsidsGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeCloakedSsidsGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsidsCount, buffer, &offset);
+ primitive->cloakedSsids.cloakedSsids = NULL;
+ if (primitive->cloakedSsids.cloakedSsidsCount)
+ {
+ primitive->cloakedSsids.cloakedSsids = (CsrWifiSsid *)CsrPmemAlloc(sizeof(CsrWifiSsid) * primitive->cloakedSsids.cloakedSsidsCount);
+ }
+ {
+ CsrUint16 i2;
+ for (i2 = 0; i2 < primitive->cloakedSsids.cloakedSsidsCount; i2++)
+ {
+ CsrMemCpyDes(primitive->cloakedSsids.cloakedSsids[i2].ssid, buffer, &offset, ((CsrUint16) (32)));
+ CsrUint8Des((CsrUint8 *) &primitive->cloakedSsids.cloakedSsids[i2].length, buffer, &offset);
+ }
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeCloakedSsidsGetCfmSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeCloakedSsidsGetCfm *primitive = (CsrWifiSmeCloakedSsidsGetCfm *) voidPrimitivePointer;
+ CsrPmemFree(primitive->cloakedSsids.cloakedSsids);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeWifiOnIndSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 6; /* CsrUint8 primitive->address.a[6] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeWifiOnInd *primitive = (CsrWifiSmeWifiOnInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrMemCpySer(ptr, len, (const void *) primitive->address.a, ((CsrUint16) (6)));
+ return(ptr);
+}
+
+
+void* CsrWifiSmeWifiOnIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeWifiOnInd *primitive = (CsrWifiSmeWifiOnInd *) CsrPmemAlloc(sizeof(CsrWifiSmeWifiOnInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrMemCpyDes(primitive->address.a, buffer, &offset, ((CsrUint16) (6)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 10) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 1; /* CsrWifiSme80211dTrustLevel primitive->deviceConfig.trustLevel */
+ bufferSize += 2; /* CsrUint8 primitive->deviceConfig.countryCode[2] */
+ bufferSize += 1; /* CsrWifiSmeFirmwareDriverInterface primitive->deviceConfig.firmwareDriverInterface */
+ bufferSize += 1; /* CsrBool primitive->deviceConfig.enableStrictDraftN */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeSmeCommonConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeSmeCommonConfigGetCfm *primitive = (CsrWifiSmeSmeCommonConfigGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.trustLevel);
+ CsrMemCpySer(ptr, len, (const void *) primitive->deviceConfig.countryCode, ((CsrUint16) (2)));
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.firmwareDriverInterface);
+ CsrUint8Ser(ptr, len, (CsrUint8) primitive->deviceConfig.enableStrictDraftN);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeSmeCommonConfigGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeSmeCommonConfigGetCfm *primitive = (CsrWifiSmeSmeCommonConfigGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeSmeCommonConfigGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.trustLevel, buffer, &offset);
+ CsrMemCpyDes(primitive->deviceConfig.countryCode, buffer, &offset, ((CsrUint16) (2)));
+ CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.firmwareDriverInterface, buffer, &offset);
+ CsrUint8Des((CsrUint8 *) &primitive->deviceConfig.enableStrictDraftN, buffer, &offset);
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg)
+{
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 9) */
+ bufferSize += 2; /* CsrResult primitive->status */
+ bufferSize += 2; /* CsrUint16 primitive->numInterfaces */
+ bufferSize += 2; /* CsrUint8 primitive->capBitmap[2] */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeInterfaceCapabilityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeInterfaceCapabilityGetCfm *primitive = (CsrWifiSmeInterfaceCapabilityGetCfm *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->status);
+ CsrUint16Ser(ptr, len, (CsrUint16) primitive->numInterfaces);
+ CsrMemCpySer(ptr, len, (const void *) primitive->capBitmap, ((CsrUint16) (2)));
+ return(ptr);
+}
+
+
+void* CsrWifiSmeInterfaceCapabilityGetCfmDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeInterfaceCapabilityGetCfm *primitive = (CsrWifiSmeInterfaceCapabilityGetCfm *) CsrPmemAlloc(sizeof(CsrWifiSmeInterfaceCapabilityGetCfm));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->status, buffer, &offset);
+ CsrUint16Des((CsrUint16 *) &primitive->numInterfaces, buffer, &offset);
+ CsrMemCpyDes(primitive->capBitmap, buffer, &offset, ((CsrUint16) (2)));
+
+ return primitive;
+}
+
+
+CsrSize CsrWifiSmeErrorIndSizeof(void *msg)
+{
+ CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 3) */
+ bufferSize += (primitive->errorMessage?CsrStrLen(primitive->errorMessage) : 0) + 1; /* CsrCharString* primitive->errorMessage (0 byte len + 1 for NULL Term) */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrCharStringSer(ptr, len, primitive->errorMessage);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeErrorIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *) CsrPmemAlloc(sizeof(CsrWifiSmeErrorInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrCharStringDes(&primitive->errorMessage, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiSmeErrorIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeErrorInd *primitive = (CsrWifiSmeErrorInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->errorMessage);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeInfoIndSizeof(void *msg)
+{
+ CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 3) */
+ bufferSize += (primitive->infoMessage?CsrStrLen(primitive->infoMessage) : 0) + 1; /* CsrCharString* primitive->infoMessage (0 byte len + 1 for NULL Term) */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeInfoIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrCharStringSer(ptr, len, primitive->infoMessage);
+ return(ptr);
+}
+
+
+void* CsrWifiSmeInfoIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *) CsrPmemAlloc(sizeof(CsrWifiSmeInfoInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrCharStringDes(&primitive->infoMessage, buffer, &offset);
+
+ return primitive;
+}
+
+
+void CsrWifiSmeInfoIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeInfoInd *primitive = (CsrWifiSmeInfoInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->infoMessage);
+ CsrPmemFree(primitive);
+}
+
+
+CsrSize CsrWifiSmeCoreDumpIndSizeof(void *msg)
+{
+ CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *) msg;
+ CsrSize bufferSize = 2;
+
+ /* Calculate the Size of the Serialised Data. Could be more efficient (Try 8) */
+ bufferSize += 4; /* CsrUint32 primitive->dataLength */
+ bufferSize += primitive->dataLength; /* CsrUint8 primitive->data */
+ return bufferSize;
+}
+
+
+CsrUint8* CsrWifiSmeCoreDumpIndSer(CsrUint8 *ptr, CsrSize *len, void *msg)
+{
+ CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *)msg;
+ *len = 0;
+ CsrUint16Ser(ptr, len, primitive->common.type);
+ CsrUint32Ser(ptr, len, (CsrUint32) primitive->dataLength);
+ if (primitive->dataLength)
+ {
+ CsrMemCpySer(ptr, len, (const void *) primitive->data, ((CsrUint16) (primitive->dataLength)));
+ }
+ return(ptr);
+}
+
+
+void* CsrWifiSmeCoreDumpIndDes(CsrUint8 *buffer, CsrSize length)
+{
+ CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *) CsrPmemAlloc(sizeof(CsrWifiSmeCoreDumpInd));
+ CsrSize offset;
+ offset = 0;
+
+ CsrUint16Des(&primitive->common.type, buffer, &offset);
+ CsrUint32Des((CsrUint32 *) &primitive->dataLength, buffer, &offset);
+ if (primitive->dataLength)
+ {
+ primitive->data = (CsrUint8 *)CsrPmemAlloc(primitive->dataLength);
+ CsrMemCpyDes(primitive->data, buffer, &offset, ((CsrUint16) (primitive->dataLength)));
+ }
+ else
+ {
+ primitive->data = NULL;
+ }
+
+ return primitive;
+}
+
+
+void CsrWifiSmeCoreDumpIndSerFree(void *voidPrimitivePointer)
+{
+ CsrWifiSmeCoreDumpInd *primitive = (CsrWifiSmeCoreDumpInd *) voidPrimitivePointer;
+ CsrPmemFree(primitive->data);
+ CsrPmemFree(primitive);
+}
+
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2012
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_SME_SERIALIZE_H__
+#define CSR_WIFI_SME_SERIALIZE_H__
+
+#include "csr_types.h"
+#include "csr_pmem.h"
+#include "csr_wifi_msgconv.h"
+
+#include "csr_wifi_sme_prim.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void CsrWifiSmePfree(void *ptr);
+
+#define CsrWifiSmeActivateReqSer CsrWifiEventSer
+#define CsrWifiSmeActivateReqDes CsrWifiEventDes
+#define CsrWifiSmeActivateReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeActivateReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeAdhocConfigGetReqSer CsrWifiEventSer
+#define CsrWifiSmeAdhocConfigGetReqDes CsrWifiEventDes
+#define CsrWifiSmeAdhocConfigGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeAdhocConfigGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeAdhocConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAdhocConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeAdhocConfigSetReqSizeof(void *msg);
+#define CsrWifiSmeAdhocConfigSetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeBlacklistReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeBlacklistReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeBlacklistReqSizeof(void *msg);
+extern void CsrWifiSmeBlacklistReqSerFree(void *msg);
+
+#define CsrWifiSmeCalibrationDataGetReqSer CsrWifiEventSer
+#define CsrWifiSmeCalibrationDataGetReqDes CsrWifiEventDes
+#define CsrWifiSmeCalibrationDataGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeCalibrationDataGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeCalibrationDataSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCalibrationDataSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCalibrationDataSetReqSizeof(void *msg);
+extern void CsrWifiSmeCalibrationDataSetReqSerFree(void *msg);
+
+#define CsrWifiSmeCcxConfigGetReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeCcxConfigGetReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeCcxConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeCcxConfigGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeCcxConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCcxConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCcxConfigSetReqSizeof(void *msg);
+#define CsrWifiSmeCcxConfigSetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeCoexConfigGetReqSer CsrWifiEventSer
+#define CsrWifiSmeCoexConfigGetReqDes CsrWifiEventDes
+#define CsrWifiSmeCoexConfigGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeCoexConfigGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeCoexConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoexConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCoexConfigSetReqSizeof(void *msg);
+#define CsrWifiSmeCoexConfigSetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeCoexInfoGetReqSer CsrWifiEventSer
+#define CsrWifiSmeCoexInfoGetReqDes CsrWifiEventDes
+#define CsrWifiSmeCoexInfoGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeCoexInfoGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeConnectReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeConnectReqSizeof(void *msg);
+extern void CsrWifiSmeConnectReqSerFree(void *msg);
+
+#define CsrWifiSmeConnectionConfigGetReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeConnectionConfigGetReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeConnectionConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeConnectionConfigGetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeConnectionInfoGetReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeConnectionInfoGetReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeConnectionInfoGetReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeConnectionInfoGetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeConnectionStatsGetReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeConnectionStatsGetReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeConnectionStatsGetReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeConnectionStatsGetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeDeactivateReqSer CsrWifiEventSer
+#define CsrWifiSmeDeactivateReqDes CsrWifiEventDes
+#define CsrWifiSmeDeactivateReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeDeactivateReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeDisconnectReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeDisconnectReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeDisconnectReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeDisconnectReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeEventMaskSetReqSer CsrWifiEventCsrUint32Ser
+#define CsrWifiSmeEventMaskSetReqDes CsrWifiEventCsrUint32Des
+#define CsrWifiSmeEventMaskSetReqSizeof CsrWifiEventCsrUint32Sizeof
+#define CsrWifiSmeEventMaskSetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeHostConfigGetReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeHostConfigGetReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeHostConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeHostConfigGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeHostConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeHostConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeHostConfigSetReqSizeof(void *msg);
+#define CsrWifiSmeHostConfigSetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeKeyReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeKeyReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeKeyReqSizeof(void *msg);
+#define CsrWifiSmeKeyReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeLinkQualityGetReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeLinkQualityGetReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeLinkQualityGetReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeLinkQualityGetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeMibConfigGetReqSer CsrWifiEventSer
+#define CsrWifiSmeMibConfigGetReqDes CsrWifiEventDes
+#define CsrWifiSmeMibConfigGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeMibConfigGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeMibConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMibConfigSetReqSizeof(void *msg);
+#define CsrWifiSmeMibConfigSetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeMibGetNextReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetNextReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMibGetNextReqSizeof(void *msg);
+extern void CsrWifiSmeMibGetNextReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeMibGetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMibGetReqSizeof(void *msg);
+extern void CsrWifiSmeMibGetReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeMibSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMibSetReqSizeof(void *msg);
+extern void CsrWifiSmeMibSetReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeMulticastAddressReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMulticastAddressReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMulticastAddressReqSizeof(void *msg);
+extern void CsrWifiSmeMulticastAddressReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmePacketFilterSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePacketFilterSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmePacketFilterSetReqSizeof(void *msg);
+extern void CsrWifiSmePacketFilterSetReqSerFree(void *msg);
+
+#define CsrWifiSmePermanentMacAddressGetReqSer CsrWifiEventSer
+#define CsrWifiSmePermanentMacAddressGetReqDes CsrWifiEventDes
+#define CsrWifiSmePermanentMacAddressGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmePermanentMacAddressGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmePmkidReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePmkidReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmePmkidReqSizeof(void *msg);
+extern void CsrWifiSmePmkidReqSerFree(void *msg);
+
+#define CsrWifiSmePowerConfigGetReqSer CsrWifiEventSer
+#define CsrWifiSmePowerConfigGetReqDes CsrWifiEventDes
+#define CsrWifiSmePowerConfigGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmePowerConfigGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmePowerConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePowerConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmePowerConfigSetReqSizeof(void *msg);
+#define CsrWifiSmePowerConfigSetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeRegulatoryDomainInfoGetReqSer CsrWifiEventSer
+#define CsrWifiSmeRegulatoryDomainInfoGetReqDes CsrWifiEventDes
+#define CsrWifiSmeRegulatoryDomainInfoGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeRegulatoryDomainInfoGetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeRoamingConfigGetReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeRoamingConfigGetReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeRoamingConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeRoamingConfigGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeRoamingConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeRoamingConfigSetReqSizeof(void *msg);
+#define CsrWifiSmeRoamingConfigSetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeScanConfigGetReqSer CsrWifiEventSer
+#define CsrWifiSmeScanConfigGetReqDes CsrWifiEventDes
+#define CsrWifiSmeScanConfigGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeScanConfigGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeScanConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeScanConfigSetReqSizeof(void *msg);
+extern void CsrWifiSmeScanConfigSetReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeScanFullReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanFullReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeScanFullReqSizeof(void *msg);
+extern void CsrWifiSmeScanFullReqSerFree(void *msg);
+
+#define CsrWifiSmeScanResultsFlushReqSer CsrWifiEventSer
+#define CsrWifiSmeScanResultsFlushReqDes CsrWifiEventDes
+#define CsrWifiSmeScanResultsFlushReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeScanResultsFlushReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeScanResultsGetReqSer CsrWifiEventSer
+#define CsrWifiSmeScanResultsGetReqDes CsrWifiEventDes
+#define CsrWifiSmeScanResultsGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeScanResultsGetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeSmeStaConfigGetReqSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeSmeStaConfigGetReqDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeSmeStaConfigGetReqSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeSmeStaConfigGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeSmeStaConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeSmeStaConfigSetReqSizeof(void *msg);
+#define CsrWifiSmeSmeStaConfigSetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeStationMacAddressGetReqSer CsrWifiEventSer
+#define CsrWifiSmeStationMacAddressGetReqDes CsrWifiEventDes
+#define CsrWifiSmeStationMacAddressGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeStationMacAddressGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeTspecReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeTspecReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeTspecReqSizeof(void *msg);
+extern void CsrWifiSmeTspecReqSerFree(void *msg);
+
+#define CsrWifiSmeVersionsGetReqSer CsrWifiEventSer
+#define CsrWifiSmeVersionsGetReqDes CsrWifiEventDes
+#define CsrWifiSmeVersionsGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeVersionsGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeWifiFlightmodeReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWifiFlightmodeReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeWifiFlightmodeReqSizeof(void *msg);
+extern void CsrWifiSmeWifiFlightmodeReqSerFree(void *msg);
+
+#define CsrWifiSmeWifiOffReqSer CsrWifiEventSer
+#define CsrWifiSmeWifiOffReqDes CsrWifiEventDes
+#define CsrWifiSmeWifiOffReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeWifiOffReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeWifiOnReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWifiOnReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeWifiOnReqSizeof(void *msg);
+extern void CsrWifiSmeWifiOnReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeCloakedSsidsSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCloakedSsidsSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCloakedSsidsSetReqSizeof(void *msg);
+extern void CsrWifiSmeCloakedSsidsSetReqSerFree(void *msg);
+
+#define CsrWifiSmeCloakedSsidsGetReqSer CsrWifiEventSer
+#define CsrWifiSmeCloakedSsidsGetReqDes CsrWifiEventDes
+#define CsrWifiSmeCloakedSsidsGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeCloakedSsidsGetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeSmeCommonConfigGetReqSer CsrWifiEventSer
+#define CsrWifiSmeSmeCommonConfigGetReqDes CsrWifiEventDes
+#define CsrWifiSmeSmeCommonConfigGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeSmeCommonConfigGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeSmeCommonConfigSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeCommonConfigSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeSmeCommonConfigSetReqSizeof(void *msg);
+#define CsrWifiSmeSmeCommonConfigSetReqSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeInterfaceCapabilityGetReqSer CsrWifiEventSer
+#define CsrWifiSmeInterfaceCapabilityGetReqDes CsrWifiEventDes
+#define CsrWifiSmeInterfaceCapabilityGetReqSizeof CsrWifiEventSizeof
+#define CsrWifiSmeInterfaceCapabilityGetReqSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeWpsConfigurationReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWpsConfigurationReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeWpsConfigurationReqSizeof(void *msg);
+extern void CsrWifiSmeWpsConfigurationReqSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeSetReqSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSetReqDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeSetReqSizeof(void *msg);
+extern void CsrWifiSmeSetReqSerFree(void *msg);
+
+#define CsrWifiSmeActivateCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeActivateCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeActivateCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeActivateCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeAdhocConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAdhocConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeAdhocConfigGetCfmSizeof(void *msg);
+#define CsrWifiSmeAdhocConfigGetCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeAdhocConfigSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeAdhocConfigSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeAdhocConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeAdhocConfigSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeAssociationCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAssociationCompleteIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeAssociationCompleteIndSizeof(void *msg);
+extern void CsrWifiSmeAssociationCompleteIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeAssociationStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeAssociationStartIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeAssociationStartIndSizeof(void *msg);
+#define CsrWifiSmeAssociationStartIndSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeBlacklistCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeBlacklistCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeBlacklistCfmSizeof(void *msg);
+extern void CsrWifiSmeBlacklistCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeCalibrationDataGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCalibrationDataGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCalibrationDataGetCfmSizeof(void *msg);
+extern void CsrWifiSmeCalibrationDataGetCfmSerFree(void *msg);
+
+#define CsrWifiSmeCalibrationDataSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeCalibrationDataSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeCalibrationDataSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeCalibrationDataSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeCcxConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCcxConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCcxConfigGetCfmSizeof(void *msg);
+#define CsrWifiSmeCcxConfigGetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeCcxConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCcxConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCcxConfigSetCfmSizeof(void *msg);
+#define CsrWifiSmeCcxConfigSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeCoexConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoexConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCoexConfigGetCfmSizeof(void *msg);
+#define CsrWifiSmeCoexConfigGetCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeCoexConfigSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeCoexConfigSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeCoexConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeCoexConfigSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeCoexInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoexInfoGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCoexInfoGetCfmSizeof(void *msg);
+#define CsrWifiSmeCoexInfoGetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeConnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeConnectCfmSizeof(void *msg);
+#define CsrWifiSmeConnectCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeConnectionConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeConnectionConfigGetCfmSizeof(void *msg);
+extern void CsrWifiSmeConnectionConfigGetCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeConnectionInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionInfoGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeConnectionInfoGetCfmSizeof(void *msg);
+extern void CsrWifiSmeConnectionInfoGetCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeConnectionQualityIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionQualityIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeConnectionQualityIndSizeof(void *msg);
+#define CsrWifiSmeConnectionQualityIndSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeConnectionStatsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeConnectionStatsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeConnectionStatsGetCfmSizeof(void *msg);
+#define CsrWifiSmeConnectionStatsGetCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeDeactivateCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeDeactivateCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeDeactivateCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeDeactivateCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeDisconnectCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeDisconnectCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeDisconnectCfmSizeof(void *msg);
+#define CsrWifiSmeDisconnectCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeEventMaskSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeEventMaskSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeEventMaskSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeEventMaskSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeHostConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeHostConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeHostConfigGetCfmSizeof(void *msg);
+#define CsrWifiSmeHostConfigGetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeHostConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeHostConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeHostConfigSetCfmSizeof(void *msg);
+#define CsrWifiSmeHostConfigSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeIbssStationIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeIbssStationIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeIbssStationIndSizeof(void *msg);
+#define CsrWifiSmeIbssStationIndSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeKeyCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeKeyCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeKeyCfmSizeof(void *msg);
+#define CsrWifiSmeKeyCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeLinkQualityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeLinkQualityGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeLinkQualityGetCfmSizeof(void *msg);
+#define CsrWifiSmeLinkQualityGetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeMediaStatusIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMediaStatusIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMediaStatusIndSizeof(void *msg);
+extern void CsrWifiSmeMediaStatusIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeMibConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMibConfigGetCfmSizeof(void *msg);
+#define CsrWifiSmeMibConfigGetCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeMibConfigSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeMibConfigSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeMibConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeMibConfigSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeMibGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMibGetCfmSizeof(void *msg);
+extern void CsrWifiSmeMibGetCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeMibGetNextCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMibGetNextCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMibGetNextCfmSizeof(void *msg);
+extern void CsrWifiSmeMibGetNextCfmSerFree(void *msg);
+
+#define CsrWifiSmeMibSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeMibSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeMibSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeMibSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeMicFailureIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMicFailureIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMicFailureIndSizeof(void *msg);
+#define CsrWifiSmeMicFailureIndSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeMulticastAddressCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeMulticastAddressCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeMulticastAddressCfmSizeof(void *msg);
+extern void CsrWifiSmeMulticastAddressCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmePacketFilterSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePacketFilterSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmePacketFilterSetCfmSizeof(void *msg);
+#define CsrWifiSmePacketFilterSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmePermanentMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePermanentMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmePermanentMacAddressGetCfmSizeof(void *msg);
+#define CsrWifiSmePermanentMacAddressGetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmePmkidCandidateListIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePmkidCandidateListIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmePmkidCandidateListIndSizeof(void *msg);
+extern void CsrWifiSmePmkidCandidateListIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmePmkidCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePmkidCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmePmkidCfmSizeof(void *msg);
+extern void CsrWifiSmePmkidCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmePowerConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmePowerConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmePowerConfigGetCfmSizeof(void *msg);
+#define CsrWifiSmePowerConfigGetCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmePowerConfigSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmePowerConfigSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmePowerConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmePowerConfigSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeRegulatoryDomainInfoGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRegulatoryDomainInfoGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeRegulatoryDomainInfoGetCfmSizeof(void *msg);
+#define CsrWifiSmeRegulatoryDomainInfoGetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeRoamCompleteIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamCompleteIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeRoamCompleteIndSizeof(void *msg);
+#define CsrWifiSmeRoamCompleteIndSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeRoamStartIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamStartIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeRoamStartIndSizeof(void *msg);
+#define CsrWifiSmeRoamStartIndSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeRoamingConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeRoamingConfigGetCfmSizeof(void *msg);
+#define CsrWifiSmeRoamingConfigGetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeRoamingConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeRoamingConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeRoamingConfigSetCfmSizeof(void *msg);
+#define CsrWifiSmeRoamingConfigSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeScanConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeScanConfigGetCfmSizeof(void *msg);
+extern void CsrWifiSmeScanConfigGetCfmSerFree(void *msg);
+
+#define CsrWifiSmeScanConfigSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeScanConfigSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeScanConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeScanConfigSetCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeScanFullCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeScanFullCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeScanFullCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeScanFullCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeScanResultIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanResultIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeScanResultIndSizeof(void *msg);
+extern void CsrWifiSmeScanResultIndSerFree(void *msg);
+
+#define CsrWifiSmeScanResultsFlushCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeScanResultsFlushCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeScanResultsFlushCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeScanResultsFlushCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeScanResultsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeScanResultsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeScanResultsGetCfmSizeof(void *msg);
+extern void CsrWifiSmeScanResultsGetCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeSmeStaConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeSmeStaConfigGetCfmSizeof(void *msg);
+#define CsrWifiSmeSmeStaConfigGetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeSmeStaConfigSetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeStaConfigSetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeSmeStaConfigSetCfmSizeof(void *msg);
+#define CsrWifiSmeSmeStaConfigSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeStationMacAddressGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeStationMacAddressGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeStationMacAddressGetCfmSizeof(void *msg);
+#define CsrWifiSmeStationMacAddressGetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeTspecIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeTspecIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeTspecIndSizeof(void *msg);
+extern void CsrWifiSmeTspecIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeTspecCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeTspecCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeTspecCfmSizeof(void *msg);
+extern void CsrWifiSmeTspecCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeVersionsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeVersionsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeVersionsGetCfmSizeof(void *msg);
+extern void CsrWifiSmeVersionsGetCfmSerFree(void *msg);
+
+#define CsrWifiSmeWifiFlightmodeCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeWifiFlightmodeCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeWifiFlightmodeCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeWifiFlightmodeCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeWifiOffIndSer CsrWifiEventCsrUint8Ser
+#define CsrWifiSmeWifiOffIndDes CsrWifiEventCsrUint8Des
+#define CsrWifiSmeWifiOffIndSizeof CsrWifiEventCsrUint8Sizeof
+#define CsrWifiSmeWifiOffIndSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeWifiOffCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeWifiOffCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeWifiOffCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeWifiOffCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeWifiOnCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeWifiOnCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeWifiOnCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeWifiOnCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeCloakedSsidsSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeCloakedSsidsSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeCloakedSsidsSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeCloakedSsidsSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeCloakedSsidsGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCloakedSsidsGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCloakedSsidsGetCfmSizeof(void *msg);
+extern void CsrWifiSmeCloakedSsidsGetCfmSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeWifiOnIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeWifiOnIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeWifiOnIndSizeof(void *msg);
+#define CsrWifiSmeWifiOnIndSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeSmeCommonConfigGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeSmeCommonConfigGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeSmeCommonConfigGetCfmSizeof(void *msg);
+#define CsrWifiSmeSmeCommonConfigGetCfmSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeSmeCommonConfigSetCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeSmeCommonConfigSetCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeSmeCommonConfigSetCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeSmeCommonConfigSetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeInterfaceCapabilityGetCfmSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeInterfaceCapabilityGetCfmDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeInterfaceCapabilityGetCfmSizeof(void *msg);
+#define CsrWifiSmeInterfaceCapabilityGetCfmSerFree CsrWifiSmePfree
+
+extern CsrUint8* CsrWifiSmeErrorIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeErrorIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeErrorIndSizeof(void *msg);
+extern void CsrWifiSmeErrorIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeInfoIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeInfoIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeInfoIndSizeof(void *msg);
+extern void CsrWifiSmeInfoIndSerFree(void *msg);
+
+extern CsrUint8* CsrWifiSmeCoreDumpIndSer(CsrUint8 *ptr, CsrSize *len, void *msg);
+extern void* CsrWifiSmeCoreDumpIndDes(CsrUint8 *buffer, CsrSize len);
+extern CsrSize CsrWifiSmeCoreDumpIndSizeof(void *msg);
+extern void CsrWifiSmeCoreDumpIndSerFree(void *msg);
+
+#define CsrWifiSmeAmpStatusChangeIndSer CsrWifiEventCsrUint16CsrUint8Ser
+#define CsrWifiSmeAmpStatusChangeIndDes CsrWifiEventCsrUint16CsrUint8Des
+#define CsrWifiSmeAmpStatusChangeIndSizeof CsrWifiEventCsrUint16CsrUint8Sizeof
+#define CsrWifiSmeAmpStatusChangeIndSerFree CsrWifiSmePfree
+
+#define CsrWifiSmeWpsConfigurationCfmSer CsrWifiEventCsrUint16Ser
+#define CsrWifiSmeWpsConfigurationCfmDes CsrWifiEventCsrUint16Des
+#define CsrWifiSmeWpsConfigurationCfmSizeof CsrWifiEventCsrUint16Sizeof
+#define CsrWifiSmeWpsConfigurationCfmSerFree CsrWifiSmePfree
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* CSR_WIFI_SME_SERIALIZE_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+/* Note: this is an auto-generated file. */
+
+#ifndef CSR_WIFI_SME_TASK_H__
+#define CSR_WIFI_SME_TASK_H__
+
+#include "csr_types.h"
+#include "csr_sched.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CSR_WIFI_SME_LOG_ID 0x1202FFFF
+extern CsrSchedQid CSR_WIFI_SME_IFACEQUEUE;
+void CsrWifiSmeInit(void **gash);
+void CsrWifiSmeDeinit(void **gash);
+void CsrWifiSmeHandler(void **gash);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_SME_TASK_H__ */
+
--- /dev/null
+/*****************************************************************************
+
+ (c) Cambridge Silicon Radio Limited 2011
+ All rights reserved and confidential information of CSR
+
+ Refer to LICENSE.txt included with this source for details
+ on the license terms.
+
+*****************************************************************************/
+
+#ifndef CSR_WIFI_VIF_UTILS_H
+#define CSR_WIFI_VIF_UTILS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* STANDARD INCLUDES ********************************************************/
+
+/* PROJECT INCLUDES *********************************************************/
+/* including this file for CsrWifiInterfaceMode*/
+#include "csr_wifi_private_common.h"
+
+/* MACROS *******************************************************************/
+
+/* Common macros for NME and SME to be used temporarily until SoftMAC changes are made */
+#define CSR_WIFI_NUM_INTERFACES (CsrUint8)0x1
+#define CSR_WIFI_INTERFACE_IN_USE (CsrUint16)0x0
+
+/* This is used at places where interface Id isn't available*/
+#define CSR_WIFI_INTERFACE_ZERO 0
+#define CSR_WIFI_INTERFACE_STA 0
+#define CSR_WIFI_INTERFACE_AMP 0
+
+
+#define CSR_WIFI_VIF_UTILS_UNDEFINED_TAG 0xFFFF
+
+/* Extract the Interface Id from the event */
+#define CsrWifiVifUtilsGetVifTagFromEvent(msg) \
+ ((CsrUint16) * ((CsrUint16 *) ((CsrUint8 *) (msg) + sizeof(CsrWifiFsmEvent))))
+
+/* The HPI Vif combines the type and the interface id */
+#define CsrWifiVifUtilsGetVifTagFromHipEvent(msg) \
+ ((msg)->virtualInterfaceIdentifier & 0x00FF)
+
+#define CsrWifiVifUtilsPackHipEventVif(type, interfaceId) \
+ ((CsrUint16)((interfaceId) | ((type) << 8)))
+
+
+/* TYPES DEFINITIONS ********************************************************/
+
+/* GLOBAL VARIABLE DECLARATIONS *********************************************/
+
+/* PUBLIC FUNCTION PROTOTYPES ***********************************************/
+
+/**
+ * @brief
+ * First checks if the mode is supported capability bitmap of the interface.
+ * If this succeeds, then checks if running this mode on this interface is allowed.
+ *
+ * @param[in] CsrUint8 : interface capability bitmap
+ * @param[in] CsrUint8* : pointer to the array of current interface modes
+ * @param[in] CsrUint16 : interfaceTag
+ * @param[in] CsrWifiInterfaceMode : mode
+ *
+ * @return
+ * CsrBool : returns true if the interface is allowed to operate in the mode otherwise false.
+ */
+extern CsrBool CsrWifiVifUtilsCheckCompatibility(CsrUint8 interfaceCapability,
+ CsrUint8 *currentInterfaceModes,
+ CsrUint16 interfaceTag,
+ CsrWifiInterfaceMode mode);
+
+/**
+ * @brief
+ * Checks if the specified interface is supported.
+ * NOTE: Only checks that the interface is supported, no checks are made to
+ * determine whether a supported interface may be made active.
+ *
+ * @param[in] CsrUint16 : interfaceTag
+ *
+ * @return
+ * CsrBool : returns true if the interface is supported, otherwise false.
+ */
+extern CsrBool CsrWifiVifUtilsIsSupported(CsrUint16 interfaceTag);
+
+#ifdef CSR_LOG_ENABLE
+/**
+ * @brief
+ * Registers the virtual interface utils logging details.
+ * Should only be called once at initialisation.
+ *
+ * @param[in/out] None
+ *
+ * @return
+ * None
+ */
+void CsrWifiVifUtilsLogTextRegister(void);
+#else
+#define CsrWifiVifUtilsLogTextRegister()
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CSR_WIFI_VIF_UTILS_H */
+
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: data_tx.c
+ *
+ * PURPOSE:
+ * This file provides functions to send data requests to the UniFi.
+ *
+ * Copyright (C) 2007-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "unifi_priv.h"
+
+int
+uf_verify_m4(unifi_priv_t *priv, const unsigned char *packet, unsigned int length)
+{
+ const unsigned char *p = packet;
+ CsrUint16 keyinfo;
+
+
+ if (length < (4 + 5 + 8 + 32 + 16 + 8 + 8 + 16 + 1 + 8)) {
+ return 1;
+ }
+
+ p += 8;
+ keyinfo = p[5] << 8 | p[6]; /* big-endian */
+ if (
+ (p[0] == 1 || p[0] == 2) /* protocol version 802.1X-2001 (WPA) or -2004 (WPA2) */ &&
+ p[1] == 3 /* EAPOL-Key */ &&
+ /* don't bother checking p[2] p[3] (hh ll, packet body length) */
+ (p[4] == 254 || p[4] == 2) /* descriptor type P802.1i-D3.0 (WPA) or 802.11i-2004 (WPA2) */ &&
+ ((keyinfo & 0x0007) == 1 || (keyinfo & 0x0007) == 2) /* key descriptor version */ &&
+ (keyinfo & ~0x0207U) == 0x0108 && /* key info for 4/4 or 4/2 -- ignore key desc version and sec bit (since varies in WPA 4/4) */
+ (p[4 + 5 + 8 + 32 + 16 + 8 + 8 + 16 + 0] == 0 && /* key data length (2 octets) 0 for 4/4 only */
+ p[4 + 5 + 8 + 32 + 16 + 8 + 8 + 16 + 1] == 0)
+ ) {
+ unifi_trace(priv, UDBG1, "uf_verify_m4: M4 detected \n");
+ return 0;
+ }
+ else
+ {
+ return 1;
+ }
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * Data transport signals.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: drv.c
+ *
+ * PURPOSE:
+ * Conventional device interface for debugging/monitoring of the
+ * driver and h/w using unicli. This interface is also being used
+ * by the SME linux implementation and the helper apps.
+ *
+ * Copyright (C) 2005-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+
+
+/*
+ * Porting Notes:
+ * Part of this file contains an example for how to glue the OS layer
+ * with the HIP core lib, the SDIO glue layer, and the SME.
+ *
+ * When the unifi_sdio.ko modules loads, the linux kernel calls unifi_load().
+ * unifi_load() calls uf_sdio_load() which is exported by the SDIO glue
+ * layer. uf_sdio_load() registers this driver with the underlying SDIO driver.
+ * When a card is detected, the SDIO glue layer calls register_unifi_sdio()
+ * to pass the SDIO function context and ask the OS layer to initialise
+ * the card. register_unifi_sdio() allocates all the private data of the OS
+ * layer and calls uf_run_unifihelper() to start the SME. The SME calls
+ * unifi_sys_wifi_on_req() which uses the HIP core lib to initialise the card.
+ */
+
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/poll.h>
+#include <asm/uaccess.h>
+#include <linux/jiffies.h>
+
+#include "csr_wifi_hip_unifiversion.h"
+#include "unifi_priv.h"
+#include "csr_wifi_hip_conversions.h"
+#include "unifi_native.h"
+
+/* Module parameter variables */
+int buswidth = 0; /* 0 means use default, values 1,4 */
+int sdio_clock = 50000; /* kHz */
+int unifi_debug = 0;
+/* fw_init prevents f/w initialisation on error. */
+int fw_init[MAX_UNIFI_DEVS] = {-1, -1};
+int use_5g = 0;
+int led_mask = 0; /* 0x0c00 for dev-pc-1503c, dev-pc-1528a */
+int disable_hw_reset = 0;
+int disable_power_control = 0;
+int enable_wol = UNIFI_WOL_OFF; /* 0 for none, 1 for SDIO IRQ, 2 for PIO */
+#if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT)
+int tl_80211d = (int)CSR_WIFI_SME_80211D_TRUST_LEVEL_MIB;
+#endif
+int sdio_block_size = -1; /* Override SDIO block size */
+int sdio_byte_mode = 0; /* 0 for block mode + padding, 1 for byte mode */
+int coredump_max = CSR_WIFI_HIP_NUM_COREDUMP_BUFFERS;
+int run_bh_once = -1; /* Set for scheduled interrupt mode, -1 = default */
+int bh_priority = -1;
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+#define UNIFI_LOG_HIP_SIGNALS_FILTER_SIGNAL (1 << 0)
+#define UNIFI_LOG_HIP_SIGNALS_FILTER_BULKDATA (1 << 1)
+#define UNIFI_LOG_HIP_SIGNALS_FILTER_TIMESTAMP (1 << 2)
+int log_hip_signals = 0;
+#endif
+
+MODULE_DESCRIPTION("CSR UniFi (SDIO)");
+
+module_param(buswidth, int, S_IRUGO|S_IWUSR);
+module_param(sdio_clock, int, S_IRUGO|S_IWUSR);
+module_param(unifi_debug, int, S_IRUGO|S_IWUSR);
+module_param_array(fw_init, int, NULL, S_IRUGO|S_IWUSR);
+module_param(use_5g, int, S_IRUGO|S_IWUSR);
+module_param(led_mask, int, S_IRUGO|S_IWUSR);
+module_param(disable_hw_reset, int, S_IRUGO|S_IWUSR);
+module_param(disable_power_control, int, S_IRUGO|S_IWUSR);
+module_param(enable_wol, int, S_IRUGO|S_IWUSR);
+#if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT)
+module_param(tl_80211d, int, S_IRUGO|S_IWUSR);
+#endif
+module_param(sdio_block_size, int, S_IRUGO|S_IWUSR);
+module_param(sdio_byte_mode, int, S_IRUGO|S_IWUSR);
+module_param(coredump_max, int, S_IRUGO|S_IWUSR);
+module_param(run_bh_once, int, S_IRUGO|S_IWUSR);
+module_param(bh_priority, int, S_IRUGO|S_IWUSR);
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+module_param(log_hip_signals, int, S_IRUGO|S_IWUSR);
+#endif
+
+MODULE_PARM_DESC(buswidth, "SDIO bus width (0=default), set 1 for 1-bit or 4 for 4-bit mode");
+MODULE_PARM_DESC(sdio_clock, "SDIO bus frequency in kHz, (default = 50 MHz)");
+MODULE_PARM_DESC(unifi_debug, "Diagnostic reporting level");
+MODULE_PARM_DESC(fw_init, "Set to 0 to prevent f/w initialization on error");
+MODULE_PARM_DESC(use_5g, "Use the 5G (802.11a) radio band");
+MODULE_PARM_DESC(led_mask, "LED mask flags");
+MODULE_PARM_DESC(disable_hw_reset, "Set to 1 to disable hardware reset");
+MODULE_PARM_DESC(disable_power_control, "Set to 1 to disable SDIO power control");
+MODULE_PARM_DESC(enable_wol, "Enable wake-on-wlan function 0=off, 1=SDIO, 2=PIO");
+#if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT)
+MODULE_PARM_DESC(tl_80211d, "802.11d Trust Level (1-6, default = 5)");
+#endif
+MODULE_PARM_DESC(sdio_block_size, "Set to override SDIO block size");
+MODULE_PARM_DESC(sdio_byte_mode, "Set to 1 for byte mode SDIO");
+MODULE_PARM_DESC(coredump_max, "Number of chip mini-coredump buffers to allocate");
+MODULE_PARM_DESC(run_bh_once, "Run BH only when firmware interrupts");
+MODULE_PARM_DESC(bh_priority, "Modify the BH thread priority");
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+MODULE_PARM_DESC(log_hip_signals, "Set to 1 to enable HIP signal offline logging");
+#endif
+
+
+/* Callback for event logging to UDI clients */
+static void udi_log_event(ul_client_t *client,
+ const u8 *signal, int signal_len,
+ const bulk_data_param_t *bulkdata,
+ int dir);
+
+static void udi_set_log_filter(ul_client_t *pcli,
+ unifiio_filter_t *udi_filter);
+
+
+/* Mutex to protect access to priv->sme_cli */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
+DEFINE_SEMAPHORE(udi_mutex);
+#else
+DECLARE_MUTEX(udi_mutex);
+#endif
+
+CsrInt32 CsrHipResultToStatus(CsrResult csrResult)
+{
+ CsrInt32 r = -EIO;
+
+ switch (csrResult)
+ {
+ case CSR_RESULT_SUCCESS:
+ r = 0;
+ break;
+ case CSR_WIFI_HIP_RESULT_RANGE:
+ r = -ERANGE;
+ break;
+ case CSR_WIFI_HIP_RESULT_NO_DEVICE:
+ r = -ENODEV;
+ break;
+ case CSR_WIFI_HIP_RESULT_INVALID_VALUE:
+ r = -EINVAL;
+ break;
+ case CSR_WIFI_HIP_RESULT_NOT_FOUND:
+ r = -ENOENT;
+ break;
+ case CSR_WIFI_HIP_RESULT_NO_SPACE:
+ r = -ENOSPC;
+ break;
+ case CSR_WIFI_HIP_RESULT_NO_MEMORY:
+ r = -ENOMEM;
+ break;
+ case CSR_RESULT_FAILURE:
+ r = -EIO;
+ break;
+ default:
+ /*unifi_warning(card->ospriv, "CsrHipResultToStatus: Unrecognised csrResult error code: %d\n", csrResult);*/
+ r = -EIO;
+ }
+ return r;
+}
+
+
+static const char*
+trace_putest_cmdid(unifi_putest_command_t putest_cmd)
+{
+ switch (putest_cmd)
+ {
+ case UNIFI_PUTEST_START:
+ return "START";
+ case UNIFI_PUTEST_STOP:
+ return "STOP";
+ case UNIFI_PUTEST_SET_SDIO_CLOCK:
+ return "SET CLOCK";
+ case UNIFI_PUTEST_CMD52_READ:
+ return "CMD52R";
+ case UNIFI_PUTEST_CMD52_BLOCK_READ:
+ return "CMD52BR";
+ case UNIFI_PUTEST_CMD52_WRITE:
+ return "CMD52W";
+ case UNIFI_PUTEST_DL_FW:
+ return "D/L FW";
+ case UNIFI_PUTEST_DL_FW_BUFF:
+ return "D/L FW BUFFER";
+ case UNIFI_PUTEST_COREDUMP_PREPARE:
+ return "PREPARE COREDUMP";
+ case UNIFI_PUTEST_GP_READ16:
+ return "GP16R";
+ case UNIFI_PUTEST_GP_WRITE16:
+ return "GP16W";
+ default:
+ return "ERROR: unrecognised command";
+ }
+ }
+
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+int uf_register_hip_offline_debug(unifi_priv_t *priv)
+{
+ ul_client_t *udi_cli;
+ int i;
+
+ udi_cli = ul_register_client(priv, CLI_USING_WIRE_FORMAT, udi_log_event);
+ if (udi_cli == NULL) {
+ /* Too many clients already using this device */
+ unifi_error(priv, "Too many UDI clients already open\n");
+ return -ENOSPC;
+ }
+ unifi_trace(priv, UDBG1, "Offline HIP client is registered\n");
+
+ down(&priv->udi_logging_mutex);
+ udi_cli->event_hook = udi_log_event;
+ unifi_set_udi_hook(priv->card, logging_handler);
+ /* Log all signals by default */
+ for (i = 0; i < SIG_FILTER_SIZE; i++) {
+ udi_cli->signal_filter[i] = 0xFFFF;
+ }
+ priv->logging_client = udi_cli;
+ up(&priv->udi_logging_mutex);
+
+ return 0;
+}
+
+int uf_unregister_hip_offline_debug(unifi_priv_t *priv)
+{
+ ul_client_t *udi_cli = priv->logging_client;
+ if (udi_cli == NULL)
+ {
+ unifi_error(priv, "Unknown HIP client unregister request\n");
+ return -ERANGE;
+ }
+
+ unifi_trace(priv, UDBG1, "Offline HIP client is unregistered\n");
+
+ down(&priv->udi_logging_mutex);
+ priv->logging_client = NULL;
+ udi_cli->event_hook = NULL;
+ up(&priv->udi_logging_mutex);
+
+ ul_deregister_client(udi_cli);
+
+ return 0;
+}
+#endif
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_open
+ * unifi_release
+ *
+ * Open and release entry points for the UniFi debug driver.
+ *
+ * Arguments:
+ * Normal linux driver args.
+ *
+ * Returns:
+ * Linux error code.
+ * ---------------------------------------------------------------------------
+ */
+static int
+unifi_open(struct inode *inode, struct file *file)
+{
+ int devno;
+ unifi_priv_t *priv;
+ ul_client_t *udi_cli;
+
+ func_enter();
+
+ devno = MINOR(inode->i_rdev) >> 1;
+
+ /*
+ * Increase the ref_count for the char device clients.
+ * Make sure you call uf_put_instance() to decreace it if
+ * unifi_open returns an error.
+ */
+ priv = uf_get_instance(devno);
+ if (priv == NULL) {
+ unifi_error(NULL, "unifi_open: No device present\n");
+ func_exit();
+ return -ENODEV;
+ }
+
+ /* Register this instance in the client's list. */
+ /* The minor number determines the nature of the client (Unicli or SME). */
+ if (MINOR(inode->i_rdev) & 0x1) {
+ udi_cli = ul_register_client(priv, CLI_USING_WIRE_FORMAT, udi_log_event);
+ if (udi_cli == NULL) {
+ /* Too many clients already using this device */
+ unifi_error(priv, "Too many clients already open\n");
+ uf_put_instance(devno);
+ func_exit();
+ return -ENOSPC;
+ }
+ unifi_trace(priv, UDBG1, "Client is registered to /dev/unifiudi%d\n", devno);
+ } else {
+ /*
+ * Even-numbered device nodes are the control application.
+ * This is the userspace helper containing SME or
+ * unifi_manager.
+ */
+
+ down(&udi_mutex);
+
+#ifdef CSR_SME_USERSPACE
+ /* Check if a config client is already attached */
+ if (priv->sme_cli) {
+ up(&udi_mutex);
+ uf_put_instance(devno);
+
+ unifi_info(priv, "There is already a configuration client using the character device\n");
+ func_exit();
+ return -EBUSY;
+ }
+#endif /* CSR_SME_USERSPACE */
+
+#ifdef CSR_SUPPORT_SME
+ udi_cli = ul_register_client(priv,
+ CLI_USING_WIRE_FORMAT | CLI_SME_USERSPACE,
+ sme_log_event);
+#else
+ /* Config client for native driver */
+ udi_cli = ul_register_client(priv,
+ 0,
+ sme_native_log_event);
+#endif
+ if (udi_cli == NULL) {
+ /* Too many clients already using this device */
+ up(&udi_mutex);
+ uf_put_instance(devno);
+
+ unifi_error(priv, "Too many clients already open\n");
+ func_exit();
+ return -ENOSPC;
+ }
+
+ /*
+ * Fill-in the pointer to the configuration client.
+ * This is the SME userspace helper or unifi_manager.
+ * Not used in the SME embedded version.
+ */
+ unifi_trace(priv, UDBG1, "SME client (id:%d s:0x%X) is registered\n",
+ udi_cli->client_id, udi_cli->sender_id);
+ /* Store the SME UniFi Linux Client */
+ if (priv->sme_cli == NULL) {
+ priv->sme_cli = udi_cli;
+ }
+
+ up(&udi_mutex);
+ }
+
+
+ /*
+ * Store the pointer to the client.
+ * All char driver's entry points will pass this pointer.
+ */
+ file->private_data = udi_cli;
+
+ func_exit();
+ return 0;
+} /* unifi_open() */
+
+
+static int
+unifi_release(struct inode *inode, struct file *filp)
+{
+ ul_client_t *udi_cli = (void*)filp->private_data;
+ int devno;
+ unifi_priv_t *priv;
+
+ func_enter();
+
+ priv = uf_find_instance(udi_cli->instance);
+ if (!priv) {
+ unifi_error(priv, "unifi_close: instance for device not found\n");
+ return -ENODEV;
+ }
+
+ devno = MINOR(inode->i_rdev) >> 1;
+
+ /* Even device nodes are the config client (i.e. SME or unifi_manager) */
+ if ((MINOR(inode->i_rdev) & 0x1) == 0) {
+
+ if (priv->sme_cli != udi_cli) {
+ unifi_notice(priv, "Surprise closing config device: not the sme client\n");
+ }
+ unifi_notice(priv, "SME client close (unifi%d)\n", devno);
+
+ /*
+ * Clear sme_cli before calling unifi_sys_... so it doesn't try to
+ * queue a reply to the (now gone) SME.
+ */
+ down(&udi_mutex);
+ priv->sme_cli = NULL;
+ up(&udi_mutex);
+
+#ifdef CSR_SME_USERSPACE
+ /* Power-down when config client closes */
+ {
+ CsrWifiRouterCtrlWifiOffReq req = {{CSR_WIFI_ROUTER_CTRL_HIP_REQ, 0, 0, 0, NULL}};
+ CsrWifiRouterCtrlWifiOffReqHandler(priv, &req.common);
+ }
+
+ uf_sme_deinit(priv);
+
+ /* It is possible that a blocking SME request was made from another process
+ * which did not get read by the SME before the WifiOffReq.
+ * So check for a pending request which will go unanswered and cancel
+ * the wait for event. As only one blocking request can be in progress at
+ * a time, up to one event should be completed.
+ */
+ uf_sme_cancel_request(priv, 0);
+
+#endif /* CSR_SME_USERSPACE */
+ } else {
+
+ unifi_trace(priv, UDBG2, "UDI client close (unifiudi%d)\n", devno);
+
+ /* If the pointer matches the logging client, stop logging. */
+ down(&priv->udi_logging_mutex);
+ if (udi_cli == priv->logging_client) {
+ priv->logging_client = NULL;
+ }
+ up(&priv->udi_logging_mutex);
+
+ if (udi_cli == priv->amp_client) {
+ priv->amp_client = NULL;
+ }
+ }
+
+ /* Deregister this instance from the client's list. */
+ ul_deregister_client(udi_cli);
+
+ uf_put_instance(devno);
+
+ return 0;
+} /* unifi_release() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_read
+ *
+ * The read() driver entry point.
+ *
+ * Arguments:
+ * filp The file descriptor returned by unifi_open()
+ * p The user space buffer to copy the read data
+ * len The size of the p buffer
+ * poff
+ *
+ * Returns:
+ * number of bytes read or an error code on failure
+ * ---------------------------------------------------------------------------
+ */
+static ssize_t
+unifi_read(struct file *filp, char *p, size_t len, loff_t *poff)
+{
+ ul_client_t *pcli = (void*)filp->private_data;
+ unifi_priv_t *priv;
+ udi_log_t *logptr = NULL;
+ udi_msg_t *msgptr;
+ struct list_head *l;
+ int msglen;
+
+ func_enter();
+
+ priv = uf_find_instance(pcli->instance);
+ if (!priv) {
+ unifi_error(priv, "invalid priv\n");
+ return -ENODEV;
+ }
+
+ if (!pcli->udi_enabled) {
+ unifi_error(priv, "unifi_read: unknown client.");
+ return -EINVAL;
+ }
+
+ if (list_empty(&pcli->udi_log)) {
+ if (filp->f_flags & O_NONBLOCK) {
+ /* Non-blocking - just return if the udi_log is empty */
+ return 0;
+ } else {
+ /* Blocking - wait on the UDI wait queue */
+ if (wait_event_interruptible(pcli->udi_wq,
+ !list_empty(&pcli->udi_log)))
+ {
+ unifi_error(priv, "unifi_read: wait_event_interruptible failed.");
+ return -ERESTARTSYS;
+ }
+ }
+ }
+
+ /* Read entry from list head and remove it from the list */
+ if (down_interruptible(&pcli->udi_sem)) {
+ return -ERESTARTSYS;
+ }
+ l = pcli->udi_log.next;
+ list_del(l);
+ up(&pcli->udi_sem);
+
+ /* Get a pointer to whole struct */
+ logptr = list_entry(l, udi_log_t, q);
+ if (logptr == NULL) {
+ unifi_error(priv, "unifi_read: failed to get event.\n");
+ return -EINVAL;
+ }
+
+ /* Get the real message */
+ msgptr = &logptr->msg;
+ msglen = msgptr->length;
+ if (msglen > len) {
+ printk(KERN_WARNING "truncated read to %d actual msg len is %lu\n", msglen, (long unsigned int)len);
+ msglen = len;
+ }
+
+ /* and pass it to the client (SME or Unicli). */
+ if (copy_to_user(p, msgptr, msglen))
+ {
+ printk(KERN_ERR "Failed to copy UDI log to user\n");
+ kfree(logptr);
+ return -EFAULT;
+ }
+
+ /* It is our resposibility to free the message buffer. */
+ kfree(logptr);
+
+ func_exit_r(msglen);
+ return msglen;
+
+} /* unifi_read() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * udi_send_signal_unpacked
+ *
+ * Sends an unpacked signal to UniFi.
+ *
+ * Arguments:
+ * priv Pointer to private context struct
+ * data Pointer to request structure and data to send
+ * data_len Length of data in data pointer.
+ *
+ * Returns:
+ * Number of bytes written, error otherwise.
+ *
+ * Notes:
+ * All clients that use this function to send a signal to the unifi
+ * must use the host formatted structures.
+ * ---------------------------------------------------------------------------
+ */
+static int
+udi_send_signal_unpacked(unifi_priv_t *priv, unsigned char* data, uint data_len)
+{
+ CSR_SIGNAL *sigptr = (CSR_SIGNAL*)data;
+ CSR_DATAREF *datarefptr;
+ bulk_data_param_t bulk_data;
+ uint signal_size, i;
+ uint bulk_data_offset = 0;
+ int bytecount, r;
+ CsrResult csrResult;
+
+ /* Number of bytes in the signal */
+ signal_size = SigGetSize(sigptr);
+ if (!signal_size || (signal_size > data_len)) {
+ unifi_error(priv, "unifi_sme_mlme_req - Invalid signal 0x%x size should be %d bytes\n",
+ sigptr->SignalPrimitiveHeader.SignalId,
+ signal_size);
+ return -EINVAL;
+ }
+ bytecount = signal_size;
+
+ /* Get a pointer to the information of the first data reference */
+ datarefptr = (CSR_DATAREF*)&sigptr->u;
+
+ /* Initialize the offset in the data buffer, bulk data is right after the signal. */
+ bulk_data_offset = signal_size;
+
+ /* store the references and the size of the bulk data to the bulkdata structure */
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
+ /* the length of the bulk data is in the signal */
+ if ((datarefptr+i)->DataLength) {
+ void *dest;
+
+ csrResult = unifi_net_data_malloc(priv, &bulk_data.d[i], (datarefptr+i)->DataLength);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "udi_send_signal_unpacked: failed to allocate request_data.\n");
+ return -EIO;
+ }
+
+ dest = (void*)bulk_data.d[i].os_data_ptr;
+ memcpy(dest, data + bulk_data_offset, bulk_data.d[i].data_length);
+ } else {
+ bulk_data.d[i].data_length = 0;
+ }
+
+ bytecount += bulk_data.d[i].data_length;
+ /* advance the offset, to point the next bulk data */
+ bulk_data_offset += bulk_data.d[i].data_length;
+ }
+
+
+ unifi_trace(priv, UDBG3, "SME Send: signal 0x%.4X\n", sigptr->SignalPrimitiveHeader.SignalId);
+
+ /* Send the signal. */
+ r = ul_send_signal_unpacked(priv, sigptr, &bulk_data);
+ if (r < 0) {
+ unifi_error(priv, "udi_send_signal_unpacked: send failed (%d)\n", r);
+ for(i=0;i<UNIFI_MAX_DATA_REFERENCES;i++) {
+ if(bulk_data.d[i].data_length != 0) {
+ unifi_net_data_free(priv, &bulk_data.d[i]);
+ }
+ }
+ func_exit();
+ return -EIO;
+ }
+
+ return bytecount;
+} /* udi_send_signal_unpacked() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * udi_send_signal_raw
+ *
+ * Sends a packed signal to UniFi.
+ *
+ * Arguments:
+ * priv Pointer to private context struct
+ * buf Pointer to request structure and data to send
+ * buflen Length of data in data pointer.
+ *
+ * Returns:
+ * Number of bytes written, error otherwise.
+ *
+ * Notes:
+ * All clients that use this function to send a signal to the unifi
+ * must use the wire formatted structures.
+ * ---------------------------------------------------------------------------
+ */
+static int
+udi_send_signal_raw(unifi_priv_t *priv, unsigned char *buf, int buflen)
+{
+ int signal_size;
+ int sig_id;
+ bulk_data_param_t data_ptrs;
+ int i, r;
+ unsigned int num_data_refs;
+ int bytecount;
+ CsrResult csrResult;
+
+ func_enter();
+
+ /*
+ * The signal is the first thing in buf, the signal id is the
+ * first 16 bits of the signal.
+ */
+ /* Number of bytes in the signal */
+ sig_id = GET_SIGNAL_ID(buf);
+ signal_size = buflen;
+ signal_size -= GET_PACKED_DATAREF_LEN(buf, 0);
+ signal_size -= GET_PACKED_DATAREF_LEN(buf, 1);
+ if ((signal_size <= 0) || (signal_size > buflen)) {
+ unifi_error(priv, "udi_send_signal_raw - Couldn't find length of signal 0x%x\n",
+ sig_id);
+ func_exit();
+ return -EINVAL;
+ }
+ unifi_trace(priv, UDBG2, "udi_send_signal_raw: signal 0x%.4X len:%d\n",
+ sig_id, signal_size);
+ /* Zero the data ref arrays */
+ memset(&data_ptrs, 0, sizeof(data_ptrs));
+
+ /*
+ * Find the number of associated bulk data packets. Scan through
+ * the data refs to check that we have enough data and pick out
+ * pointers to appended bulk data.
+ */
+ num_data_refs = 0;
+ bytecount = signal_size;
+
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; ++i)
+ {
+ unsigned int len = GET_PACKED_DATAREF_LEN(buf, i);
+ unifi_trace(priv, UDBG3, "udi_send_signal_raw: data_ref length = %d\n", len);
+
+ if (len != 0) {
+ void *dest;
+
+ csrResult = unifi_net_data_malloc(priv, &data_ptrs.d[i], len);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "udi_send_signal_raw: failed to allocate request_data.\n");
+ return -EIO;
+ }
+
+ dest = (void*)data_ptrs.d[i].os_data_ptr;
+ memcpy(dest, buf + bytecount, len);
+
+ bytecount += len;
+ num_data_refs++;
+ }
+ data_ptrs.d[i].data_length = len;
+ }
+
+ unifi_trace(priv, UDBG3, "Queueing signal 0x%.4X from UDI with %u data refs\n",
+ sig_id,
+ num_data_refs);
+
+ if (bytecount > buflen) {
+ unifi_error(priv, "udi_send_signal_raw: Not enough data (%d instead of %d)\n", buflen, bytecount);
+ func_exit();
+ return -EINVAL;
+ }
+
+ /* Send the signal calling the function that uses the wire-formatted signals. */
+ r = ul_send_signal_raw(priv, buf, signal_size, &data_ptrs);
+ if (r < 0) {
+ unifi_error(priv, "udi_send_signal_raw: send failed (%d)\n", r);
+ func_exit();
+ return -EIO;
+ }
+
+#ifdef CSR_NATIVE_LINUX
+ if (sig_id == CSR_MLME_POWERMGT_REQUEST_ID) {
+ int power_mode = CSR_GET_UINT16_FROM_LITTLE_ENDIAN((buf +
+ SIZEOF_SIGNAL_HEADER + (UNIFI_MAX_DATA_REFERENCES*SIZEOF_DATAREF)));
+#ifdef CSR_SUPPORT_WEXT
+ /* Overide the wext power mode to the new value */
+ priv->wext_conf.power_mode = power_mode;
+#endif
+ /* Configure deep sleep signaling */
+ if (power_mode || (priv->interfacePriv[0]->connected == UnifiNotConnected)) {
+ csrResult = unifi_configure_low_power_mode(priv->card,
+ UNIFI_LOW_POWER_ENABLED,
+ UNIFI_PERIODIC_WAKE_HOST_DISABLED);
+ } else {
+ csrResult = unifi_configure_low_power_mode(priv->card,
+ UNIFI_LOW_POWER_DISABLED,
+ UNIFI_PERIODIC_WAKE_HOST_DISABLED);
+ }
+ }
+#endif
+
+ func_exit_r(bytecount);
+
+ return bytecount;
+} /* udi_send_signal_raw */
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_write
+ *
+ * The write() driver entry point.
+ * A UniFi Debug Interface client such as unicli can write a signal
+ * plus bulk data to the driver for sending to the UniFi chip.
+ *
+ * Only one signal may be sent per write operation.
+ *
+ * Arguments:
+ * filp The file descriptor returned by unifi_open()
+ * p The user space buffer to get the data from
+ * len The size of the p buffer
+ * poff
+ *
+ * Returns:
+ * number of bytes written or an error code on failure
+ * ---------------------------------------------------------------------------
+ */
+static ssize_t
+unifi_write(struct file *filp, const char *p, size_t len, loff_t *poff)
+{
+ ul_client_t *pcli = (ul_client_t*)filp->private_data;
+ unifi_priv_t *priv;
+ unsigned char *buf;
+ unsigned char *bufptr;
+ int remaining;
+ int bytes_written;
+ int r;
+ bulk_data_param_t bulkdata;
+ CsrResult csrResult;
+
+ func_enter();
+
+ priv = uf_find_instance(pcli->instance);
+ if (!priv) {
+ unifi_error(priv, "invalid priv\n");
+ return -ENODEV;
+ }
+
+ unifi_trace(priv, UDBG5, "unifi_write: len = %d\n", len);
+
+ if (!pcli->udi_enabled) {
+ unifi_error(priv, "udi disabled\n");
+ return -EINVAL;
+ }
+
+ /*
+ * AMP client sends only one signal at a time, so we can use
+ * unifi_net_data_malloc to save the extra copy.
+ */
+ if (pcli == priv->amp_client) {
+ int signal_size;
+ int sig_id;
+ unsigned char *signal_buf;
+ char *user_data_buf;
+
+ csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], len);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "unifi_write: failed to allocate request_data.\n");
+ func_exit();
+ return -ENOMEM;
+ }
+
+ user_data_buf = (char*)bulkdata.d[0].os_data_ptr;
+
+ /* Get the data from the AMP client. */
+ if (copy_from_user((void*)user_data_buf, p, len)) {
+ unifi_error(priv, "unifi_write: copy from user failed\n");
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ func_exit();
+ return -EFAULT;
+ }
+
+ bulkdata.d[1].os_data_ptr = NULL;
+ bulkdata.d[1].data_length = 0;
+
+ /* Number of bytes in the signal */
+ sig_id = GET_SIGNAL_ID(bulkdata.d[0].os_data_ptr);
+ signal_size = len;
+ signal_size -= GET_PACKED_DATAREF_LEN(bulkdata.d[0].os_data_ptr, 0);
+ signal_size -= GET_PACKED_DATAREF_LEN(bulkdata.d[0].os_data_ptr, 1);
+ if ((signal_size <= 0) || (signal_size > len)) {
+ unifi_error(priv, "unifi_write - Couldn't find length of signal 0x%x\n",
+ sig_id);
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ func_exit();
+ return -EINVAL;
+ }
+
+ unifi_trace(priv, UDBG2, "unifi_write: signal 0x%.4X len:%d\n",
+ sig_id, signal_size);
+
+ /* Allocate a buffer for the signal */
+ signal_buf = kmalloc(signal_size, GFP_KERNEL);
+ if (!signal_buf) {
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ func_exit();
+ return -ENOMEM;
+ }
+
+ /* Get the signal from the os_data_ptr */
+ memcpy(signal_buf, bulkdata.d[0].os_data_ptr, signal_size);
+ signal_buf[5] = (pcli->sender_id >> 8) & 0xff;
+
+ if (signal_size < len) {
+ /* Remove the signal from the os_data_ptr */
+ bulkdata.d[0].data_length -= signal_size;
+ bulkdata.d[0].os_data_ptr += signal_size;
+ } else {
+ bulkdata.d[0].data_length = 0;
+ bulkdata.d[0].os_data_ptr = NULL;
+ }
+
+ /* Send the signal calling the function that uses the wire-formatted signals. */
+ r = ul_send_signal_raw(priv, signal_buf, signal_size, &bulkdata);
+ if (r < 0) {
+ unifi_error(priv, "unifi_write: send failed (%d)\n", r);
+ if (bulkdata.d[0].os_data_ptr != NULL) {
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ }
+ }
+
+ /* Free the signal buffer and return */
+ kfree(signal_buf);
+ return len;
+ }
+
+ buf = kmalloc(len, GFP_KERNEL);
+ if (!buf) {
+ return -ENOMEM;
+ }
+
+ /* Get the data from the client (SME or Unicli). */
+ if (copy_from_user((void*)buf, p, len)) {
+ unifi_error(priv, "copy from user failed\n");
+ kfree(buf);
+ return -EFAULT;
+ }
+
+ /*
+ * In SME userspace build read() contains a SYS or MGT message.
+ * Note that even though the SME sends one signal at a time, we can not
+ * use unifi_net_data_malloc because in the early stages, before having
+ * initialised the core, it will fail since the I/O block size is unknown.
+ */
+#ifdef CSR_SME_USERSPACE
+ if (pcli->configuration & CLI_SME_USERSPACE) {
+ CsrWifiRouterTransportRecv(priv, buf, len);
+ kfree(buf);
+ return len;
+ }
+#endif
+
+ /* ul_send_signal_raw will do a sanity check of len against signal content */
+
+ /*
+ * udi_send_signal_raw() and udi_send_signal_unpacked() return the number of bytes consumed.
+ * A write call can pass multiple signal concatenated together.
+ */
+ bytes_written = 0;
+ remaining = len;
+ bufptr = buf;
+ while (remaining > 0)
+ {
+ int r;
+
+ /*
+ * Set the SenderProcessId.
+ * The SignalPrimitiveHeader is the first 3 16-bit words of the signal,
+ * the SenderProcessId is bytes 4,5.
+ * The MSB of the sender ID needs to be set to the client ID.
+ * The LSB is controlled by the SME.
+ */
+ bufptr[5] = (pcli->sender_id >> 8) & 0xff;
+
+ /* use the appropriate interface, depending on the clients' configuration */
+ if (pcli->configuration & CLI_USING_WIRE_FORMAT) {
+ unifi_trace(priv, UDBG1, "unifi_write: call udi_send_signal().\n");
+ r = udi_send_signal_raw(priv, bufptr, remaining);
+ } else {
+ r = udi_send_signal_unpacked(priv, bufptr, remaining);
+ }
+ if (r < 0) {
+ /* Set the return value to the error code */
+ unifi_error(priv, "unifi_write: (udi or sme)_send_signal() returns %d\n", r);
+ bytes_written = r;
+ break;
+ }
+ bufptr += r;
+ remaining -= r;
+ bytes_written += r;
+ }
+
+ kfree(buf);
+
+ func_exit_r(bytes_written);
+
+ return bytes_written;
+} /* unifi_write() */
+
+
+static const char* build_type_to_string(unsigned char build_type)
+{
+ switch (build_type)
+ {
+ case UNIFI_BUILD_NME: return "NME";
+ case UNIFI_BUILD_WEXT: return "WEXT";
+ case UNIFI_BUILD_AP: return "AP";
+ }
+ return "unknown";
+}
+
+
+/*
+ * ----------------------------------------------------------------
+ * unifi_ioctl
+ *
+ * Ioctl handler for unifi driver.
+ *
+ * Arguments:
+ * inodep Pointer to inode structure.
+ * filp Pointer to file structure.
+ * cmd Ioctl cmd passed by user.
+ * arg Ioctl arg passed by user.
+ *
+ * Returns:
+ * 0 on success, -ve error code on error.
+ * ----------------------------------------------------------------
+ */
+static long
+unifi_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+ ul_client_t *pcli = (ul_client_t*)filp->private_data;
+ unifi_priv_t *priv;
+ struct net_device *dev;
+ int r = 0;
+ int int_param, i;
+ u8* buf;
+ CsrResult csrResult;
+#if (defined CSR_SUPPORT_SME)
+ unifi_cfg_command_t cfg_cmd;
+#if (defined CSR_SUPPORT_WEXT)
+ CsrWifiSmeCoexConfig coex_config;
+ unsigned char uchar_param;
+ unsigned char varbind[MAX_VARBIND_LENGTH];
+ int vblen;
+#endif
+#endif
+ unifi_putest_command_t putest_cmd;
+
+ priv = uf_find_instance(pcli->instance);
+ if (!priv) {
+ unifi_error(priv, "ioctl error: unknown instance=%d\n", pcli->instance);
+ r = -ENODEV;
+ goto out;
+ }
+ unifi_trace(priv, UDBG5, "unifi_ioctl: cmd=0x%X, arg=0x%lX\n", cmd, arg);
+
+ switch (cmd) {
+
+ case UNIFI_GET_UDI_ENABLE:
+ unifi_trace(priv, UDBG4, "UniFi Get UDI Enable\n");
+
+ down(&priv->udi_logging_mutex);
+ int_param = (priv->logging_client == NULL) ? 0 : 1;
+ up(&priv->udi_logging_mutex);
+
+ if (put_user(int_param, (int*)arg))
+ {
+ unifi_error(priv, "UNIFI_GET_UDI_ENABLE: Failed to copy to user\n");
+ r = -EFAULT;
+ goto out;
+ }
+ break;
+
+ case UNIFI_SET_UDI_ENABLE:
+ unifi_trace(priv, UDBG4, "UniFi Set UDI Enable\n");
+ if (get_user(int_param, (int*)arg))
+ {
+ unifi_error(priv, "UNIFI_SET_UDI_ENABLE: Failed to copy from user\n");
+ r = -EFAULT;
+ goto out;
+ }
+
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+ if (log_hip_signals) {
+ unifi_error(priv, "omnicli cannot be used when log_hip_signals is used\n");
+ r = -EFAULT;
+ goto out;
+ }
+#endif
+
+ down(&priv->udi_logging_mutex);
+ if (int_param) {
+ pcli->event_hook = udi_log_event;
+ unifi_set_udi_hook(priv->card, logging_handler);
+ /* Log all signals by default */
+ for (i = 0; i < SIG_FILTER_SIZE; i++) {
+ pcli->signal_filter[i] = 0xFFFF;
+ }
+ priv->logging_client = pcli;
+
+ } else {
+ priv->logging_client = NULL;
+ pcli->event_hook = NULL;
+ }
+ up(&priv->udi_logging_mutex);
+
+ break;
+
+ case UNIFI_SET_MIB:
+ unifi_trace(priv, UDBG4, "UniFi Set MIB\n");
+#if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT)
+ /* Read first 2 bytes and check length */
+ if (copy_from_user((void*)varbind, (void*)arg, 2)) {
+ unifi_error(priv,
+ "UNIFI_SET_MIB: Failed to copy in varbind header\n");
+ r = -EFAULT;
+ goto out;
+ }
+ vblen = varbind[1];
+ if ((vblen + 2) > MAX_VARBIND_LENGTH) {
+ unifi_error(priv,
+ "UNIFI_SET_MIB: Varbind too long (%d, limit %d)\n",
+ (vblen+2), MAX_VARBIND_LENGTH);
+ r = -EINVAL;
+ goto out;
+ }
+ /* Read rest of varbind */
+ if (copy_from_user((void*)(varbind+2), (void*)(arg+2), vblen)) {
+ unifi_error(priv, "UNIFI_SET_MIB: Failed to copy in varbind\n");
+ r = -EFAULT;
+ goto out;
+ }
+
+ /* send to SME */
+ vblen += 2;
+ r = sme_mgt_mib_set(priv, varbind, vblen);
+ if (r) {
+ goto out;
+ }
+#else
+ unifi_notice(priv, "UNIFI_SET_MIB: Unsupported.\n");
+#endif /* CSR_SUPPORT_WEXT */
+ break;
+
+ case UNIFI_GET_MIB:
+ unifi_trace(priv, UDBG4, "UniFi Get MIB\n");
+#if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT)
+ /* Read first 2 bytes and check length */
+ if (copy_from_user((void*)varbind, (void*)arg, 2)) {
+ unifi_error(priv, "UNIFI_GET_MIB: Failed to copy in varbind header\n");
+ r = -EFAULT;
+ goto out;
+ }
+ vblen = varbind[1];
+ if ((vblen+2) > MAX_VARBIND_LENGTH) {
+ unifi_error(priv, "UNIFI_GET_MIB: Varbind too long (%d, limit %d)\n",
+ (vblen+2), MAX_VARBIND_LENGTH);
+ r = -EINVAL;
+ goto out;
+ }
+ /* Read rest of varbind */
+ if (copy_from_user((void*)(varbind+2), (void*)(arg+2), vblen)) {
+ unifi_error(priv, "UNIFI_GET_MIB: Failed to copy in varbind\n");
+ r = -EFAULT;
+ goto out;
+ }
+
+ vblen += 2;
+ r = sme_mgt_mib_get(priv, varbind, &vblen);
+ if (r) {
+ goto out;
+ }
+ /* copy out varbind */
+ if (vblen > MAX_VARBIND_LENGTH) {
+ unifi_error(priv,
+ "UNIFI_GET_MIB: Varbind result too long (%d, limit %d)\n",
+ vblen, MAX_VARBIND_LENGTH);
+ r = -EINVAL;
+ goto out;
+ }
+ if (copy_to_user((void*)arg, varbind, vblen)) {
+ r = -EFAULT;
+ goto out;
+ }
+#else
+ unifi_notice(priv, "UNIFI_GET_MIB: Unsupported.\n");
+#endif /* CSR_SUPPORT_WEXT */
+ break;
+
+ case UNIFI_CFG:
+#if (defined CSR_SUPPORT_SME)
+ if (get_user(cfg_cmd, (unifi_cfg_command_t*)arg))
+ {
+ unifi_error(priv, "UNIFI_CFG: Failed to get the command\n");
+ r = -EFAULT;
+ goto out;
+ }
+
+ unifi_trace(priv, UDBG1, "UNIFI_CFG: Command is %d (t=%u) sz=%d\n",
+ cfg_cmd, jiffies_to_msecs(jiffies), sizeof(unifi_cfg_command_t));
+ switch (cfg_cmd) {
+ case UNIFI_CFG_POWER:
+ r = unifi_cfg_power(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_CFG_POWERSAVE:
+ r = unifi_cfg_power_save(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_CFG_POWERSUPPLY:
+ r = unifi_cfg_power_supply(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_CFG_FILTER:
+ r = unifi_cfg_packet_filters(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_CFG_GET:
+ r = unifi_cfg_get_info(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_CFG_WMM_QOSINFO:
+ r = unifi_cfg_wmm_qos_info(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_CFG_WMM_ADDTS:
+ r = unifi_cfg_wmm_addts(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_CFG_WMM_DELTS:
+ r = unifi_cfg_wmm_delts(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_CFG_STRICT_DRAFT_N:
+ r = unifi_cfg_strict_draft_n(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_CFG_ENABLE_OKC:
+ r = unifi_cfg_enable_okc(priv, (unsigned char*)arg);
+ break;
+#ifdef CSR_SUPPORT_SME
+ case UNIFI_CFG_CORE_DUMP:
+ CsrWifiRouterCtrlWifiOffIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,CSR_WIFI_SME_CONTROL_INDICATION_ERROR);
+ unifi_trace(priv, UDBG2, "UNIFI_CFG_CORE_DUMP: sent wifi off indication\n");
+ break;
+#endif
+#ifdef CSR_SUPPORT_WEXT_AP
+ case UNIFI_CFG_SET_AP_CONFIG:
+ r= unifi_cfg_set_ap_config(priv,(unsigned char*)arg);
+ break;
+#endif
+ default:
+ unifi_error(priv, "UNIFI_CFG: Unknown Command (%d)\n", cfg_cmd);
+ r = -EINVAL;
+ goto out;
+ }
+#endif
+
+ break;
+
+ case UNIFI_PUTEST:
+ if (get_user(putest_cmd, (unifi_putest_command_t*)arg))
+ {
+ unifi_error(priv, "UNIFI_PUTEST: Failed to get the command\n");
+ r = -EFAULT;
+ goto out;
+ }
+
+ unifi_trace(priv, UDBG1, "UNIFI_PUTEST: Command is %s\n",
+ trace_putest_cmdid(putest_cmd));
+ switch (putest_cmd) {
+ case UNIFI_PUTEST_START:
+ r = unifi_putest_start(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_PUTEST_STOP:
+ r = unifi_putest_stop(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_PUTEST_SET_SDIO_CLOCK:
+ r = unifi_putest_set_sdio_clock(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_PUTEST_CMD52_READ:
+ r = unifi_putest_cmd52_read(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_PUTEST_CMD52_BLOCK_READ:
+ r = unifi_putest_cmd52_block_read(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_PUTEST_CMD52_WRITE:
+ r = unifi_putest_cmd52_write(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_PUTEST_DL_FW:
+ r = unifi_putest_dl_fw(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_PUTEST_DL_FW_BUFF:
+ r = unifi_putest_dl_fw_buff(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_PUTEST_COREDUMP_PREPARE:
+ r = unifi_putest_coredump_prepare(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_PUTEST_GP_READ16:
+ r = unifi_putest_gp_read16(priv, (unsigned char*)arg);
+ break;
+ case UNIFI_PUTEST_GP_WRITE16:
+ r = unifi_putest_gp_write16(priv, (unsigned char*)arg);
+ break;
+ default:
+ unifi_error(priv, "UNIFI_PUTEST: Unknown Command (%d)\n", putest_cmd);
+ r = -EINVAL;
+ goto out;
+ }
+
+ break;
+ case UNIFI_BUILD_TYPE:
+ unifi_trace(priv, UDBG2, "UNIFI_BUILD_TYPE userspace=%s\n", build_type_to_string(*(unsigned char*)arg));
+#ifndef CSR_SUPPORT_WEXT_AP
+ if (UNIFI_BUILD_AP == *(unsigned char*)arg)
+ {
+ unifi_error(priv, "Userspace has AP support, which is incompatible\n");
+ }
+#endif
+
+#ifndef CSR_SUPPORT_WEXT
+ if (UNIFI_BUILD_WEXT == *(unsigned char*)arg)
+ {
+ unifi_error(priv, "Userspace has WEXT support, which is incompatible\n");
+ }
+#endif
+ break;
+ case UNIFI_INIT_HW:
+ unifi_trace(priv, UDBG2, "UNIFI_INIT_HW.\n");
+ priv->init_progress = UNIFI_INIT_NONE;
+
+#if defined(CSR_SUPPORT_WEXT) || defined (CSR_NATIVE_LINUX)
+ /* At this point we are ready to start the SME. */
+ r = sme_mgt_wifi_on(priv);
+ if (r) {
+ goto out;
+ }
+#endif
+
+ break;
+
+ case UNIFI_INIT_NETDEV:
+ {
+ /* get the proper interfaceTagId */
+ CsrUint16 interfaceTag=0;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ dev = priv->netdev[interfaceTag];
+ unifi_trace(priv, UDBG2, "UNIFI_INIT_NETDEV.\n");
+
+ if (copy_from_user((void*)dev->dev_addr, (void*)arg, 6)) {
+ r = -EFAULT;
+ goto out;
+ }
+
+ /* Attach the network device to the stack */
+ if (!interfacePriv->netdev_registered)
+ {
+ r = uf_register_netdev(priv,interfaceTag);
+ if (r) {
+ unifi_error(priv, "Failed to register the network device.\n");
+ goto out;
+ }
+ }
+
+ /* Apply scheduled interrupt mode, if requested by module param */
+ if (run_bh_once != -1) {
+ unifi_set_interrupt_mode(priv->card, (CsrUint32)run_bh_once);
+ }
+
+ priv->init_progress = UNIFI_INIT_COMPLETED;
+
+ /* Firmware initialisation is complete, so let the SDIO bus
+ * clock be raised when convienent to the core.
+ */
+ unifi_request_max_sdio_clock(priv->card);
+
+#ifdef CSR_SUPPORT_WEXT
+ /* Notify the Android wpa_supplicant that we are ready */
+ wext_send_started_event(priv);
+#endif
+
+ unifi_info(priv, "UniFi ready\n");
+
+#ifdef ANDROID_BUILD
+ /* Release the wakelock */
+ unifi_trace(priv, UDBG1, "netdev_init: release wake lock\n");
+ wake_unlock(&unifi_sdio_wake_lock);
+#endif
+#ifdef CSR_NATIVE_SOFTMAC /* For softmac dev, force-enable the network interface rather than wait for a connected-ind */
+ {
+ struct net_device *dev = priv->netdev[interfaceTag];
+#ifdef CSR_SUPPORT_WEXT
+ interfacePriv->wait_netdev_change = TRUE;
+#endif
+ netif_carrier_on(dev);
+ }
+#endif
+ }
+ break;
+ case UNIFI_GET_INIT_STATUS:
+ unifi_trace(priv, UDBG2, "UNIFI_GET_INIT_STATUS.\n");
+ if (put_user(priv->init_progress, (int*)arg))
+ {
+ printk(KERN_ERR "UNIFI_GET_INIT_STATUS: Failed to copy to user\n");
+ r = -EFAULT;
+ goto out;
+ }
+ break;
+
+ case UNIFI_KICK:
+ unifi_trace(priv, UDBG4, "Kick UniFi\n");
+ unifi_sdio_interrupt_handler(priv->card);
+ break;
+
+ case UNIFI_SET_DEBUG:
+ unifi_debug = arg;
+ unifi_trace(priv, UDBG4, "unifi_debug set to %d\n", unifi_debug);
+ break;
+
+ case UNIFI_SET_TRACE:
+ /* no longer supported */
+ r = -EINVAL;
+ break;
+
+
+ case UNIFI_SET_UDI_LOG_MASK:
+ {
+ unifiio_filter_t udi_filter;
+ uint16_t *sig_ids_addr;
+#define UF_MAX_SIG_IDS 128 /* Impose a sensible limit */
+
+ if (copy_from_user((void*)(&udi_filter), (void*)arg, sizeof(udi_filter))) {
+ r = -EFAULT;
+ goto out;
+ }
+ if ((udi_filter.action < UfSigFil_AllOn) ||
+ (udi_filter.action > UfSigFil_SelectOff))
+ {
+ printk(KERN_WARNING
+ "UNIFI_SET_UDI_LOG_MASK: Bad action value: %d\n",
+ udi_filter.action);
+ r = -EINVAL;
+ goto out;
+ }
+ /* No signal list for "All" actions */
+ if ((udi_filter.action == UfSigFil_AllOn) ||
+ (udi_filter.action == UfSigFil_AllOff))
+ {
+ udi_filter.num_sig_ids = 0;
+ }
+
+ if (udi_filter.num_sig_ids > UF_MAX_SIG_IDS) {
+ printk(KERN_WARNING
+ "UNIFI_SET_UDI_LOG_MASK: too many signal ids (%d, max %d)\n",
+ udi_filter.num_sig_ids, UF_MAX_SIG_IDS);
+ r = -EINVAL;
+ goto out;
+ }
+
+ /* Copy in signal id list if given */
+ if (udi_filter.num_sig_ids > 0) {
+ /* Preserve userspace address of sig_ids array */
+ sig_ids_addr = udi_filter.sig_ids;
+ /* Allocate kernel memory for sig_ids and copy to it */
+ udi_filter.sig_ids =
+ kmalloc(udi_filter.num_sig_ids * sizeof(uint16_t), GFP_KERNEL);
+ if (!udi_filter.sig_ids) {
+ r = -ENOMEM;
+ goto out;
+ }
+ if (copy_from_user((void*)udi_filter.sig_ids,
+ (void*)sig_ids_addr,
+ udi_filter.num_sig_ids * sizeof(uint16_t)))
+ {
+ kfree(udi_filter.sig_ids);
+ r = -EFAULT;
+ goto out;
+ }
+ }
+
+ udi_set_log_filter(pcli, &udi_filter);
+
+ if (udi_filter.num_sig_ids > 0) {
+ kfree(udi_filter.sig_ids);
+ }
+ }
+ break;
+
+ case UNIFI_SET_AMP_ENABLE:
+ unifi_trace(priv, UDBG4, "UniFi Set AMP Enable\n");
+ if (get_user(int_param, (int*)arg))
+ {
+ unifi_error(priv, "UNIFI_SET_AMP_ENABLE: Failed to copy from user\n");
+ r = -EFAULT;
+ goto out;
+ }
+
+ if (int_param) {
+ priv->amp_client = pcli;
+ } else {
+ priv->amp_client = NULL;
+ }
+
+ int_param = 0;
+ buf = (u8*)&int_param;
+ buf[0] = UNIFI_SOFT_COMMAND_Q_LENGTH - 1;
+ buf[1] = UNIFI_SOFT_TRAFFIC_Q_LENGTH - 1;
+ if (copy_to_user((void*)arg, &int_param, sizeof(int))) {
+ r = -EFAULT;
+ goto out;
+ }
+ break;
+
+ case UNIFI_SET_UDI_SNAP_MASK:
+ {
+ unifiio_snap_filter_t snap_filter;
+
+ if (copy_from_user((void*)(&snap_filter), (void*)arg, sizeof(snap_filter))) {
+ r = -EFAULT;
+ goto out;
+ }
+
+ if (pcli->snap_filter.count) {
+ pcli->snap_filter.count = 0;
+ CsrPmemFree(pcli->snap_filter.protocols);
+ }
+
+ if (snap_filter.count == 0) {
+ break;
+ }
+
+ pcli->snap_filter.protocols = CsrPmemAlloc(snap_filter.count * sizeof(CsrUint16));
+ if (!pcli->snap_filter.protocols) {
+ r = -ENOMEM;
+ goto out;
+ }
+ if (copy_from_user((void*)pcli->snap_filter.protocols,
+ (void*)snap_filter.protocols,
+ snap_filter.count * sizeof(CsrUint16)))
+ {
+ CsrPmemFree(pcli->snap_filter.protocols);
+ r = -EFAULT;
+ goto out;
+ }
+
+ pcli->snap_filter.count = snap_filter.count;
+
+ }
+ break;
+
+ case UNIFI_SME_PRESENT:
+ {
+ u8 ind;
+ unifi_trace(priv, UDBG4, "UniFi SME Present IOCTL.\n");
+ if (copy_from_user((void*)(&int_param), (void*)arg, sizeof(int)))
+ {
+ printk(KERN_ERR "UNIFI_SME_PRESENT: Failed to copy from user\n");
+ r = -EFAULT;
+ goto out;
+ }
+
+ priv->sme_is_present = int_param;
+ if (priv->sme_is_present == 1) {
+ ind = CONFIG_SME_PRESENT;
+ } else {
+ ind = CONFIG_SME_NOT_PRESENT;
+ }
+ /* Send an indication to the helper app. */
+ ul_log_config_ind(priv, &ind, sizeof(u8));
+ }
+ break;
+
+ case UNIFI_CFG_PERIOD_TRAFFIC:
+ {
+#if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT)
+ CsrWifiSmeCoexConfig coexConfig;
+#endif /* CSR_SUPPORT_SME && CSR_SUPPORT_WEXT */
+ unifi_trace(priv, UDBG4, "UniFi Configure Periodic Traffic.\n");
+#if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT)
+ if (copy_from_user((void*)(&uchar_param), (void*)arg, sizeof(unsigned char))) {
+ unifi_error(priv, "UNIFI_CFG_PERIOD_TRAFFIC: Failed to copy from user\n");
+ r = -EFAULT;
+ goto out;
+ }
+
+ if (uchar_param == 0) {
+ r = sme_mgt_coex_config_get(priv, &coexConfig);
+ if (r) {
+ unifi_error(priv, "UNIFI_CFG_PERIOD_TRAFFIC: Get unifi_CoexInfoValue failed.\n");
+ goto out;
+ }
+ if (copy_to_user((void*)(arg + 1),
+ (void*)&coexConfig,
+ sizeof(CsrWifiSmeCoexConfig))) {
+ r = -EFAULT;
+ goto out;
+ }
+ goto out;
+ }
+
+ if (copy_from_user((void*)(&coex_config), (void*)(arg + 1), sizeof(CsrWifiSmeCoexConfig)))
+ {
+ unifi_error(priv, "UNIFI_CFG_PERIOD_TRAFFIC: Failed to copy from user\n");
+ r = -EFAULT;
+ goto out;
+ }
+
+ coexConfig = coex_config;
+ r = sme_mgt_coex_config_set(priv, &coexConfig);
+ if (r) {
+ unifi_error(priv, "UNIFI_CFG_PERIOD_TRAFFIC: Set unifi_CoexInfoValue failed.\n");
+ goto out;
+ }
+
+#endif /* CSR_SUPPORT_SME && CSR_SUPPORT_WEXT */
+ break;
+ }
+ case UNIFI_CFG_UAPSD_TRAFFIC:
+ unifi_trace(priv, UDBG4, "UniFi Configure U-APSD Mask.\n");
+#if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT)
+ if (copy_from_user((void*)(&uchar_param), (void*)arg, sizeof(unsigned char))) {
+ unifi_error(priv, "UNIFI_CFG_UAPSD_TRAFFIC: Failed to copy from user\n");
+ r = -EFAULT;
+ goto out;
+ }
+ unifi_trace(priv, UDBG4, "New U-APSD Mask: 0x%x\n", uchar_param);
+#endif /* CSR_SUPPORT_SME && CSR_SUPPORT_WEXT */
+ break;
+
+#ifndef UNIFI_DISABLE_COREDUMP
+ case UNIFI_COREDUMP_GET_REG:
+ unifi_trace(priv, UDBG4, "Mini-coredump data request\n");
+ {
+ unifiio_coredump_req_t dump_req; /* Public OS layer structure */
+ unifi_coredump_req_t priv_req; /* Private HIP structure */
+
+ if (copy_from_user((void*)(&dump_req), (void*)arg, sizeof(dump_req))) {
+ r = -EFAULT;
+ goto out;
+ }
+ memset(&priv_req, 0, sizeof(priv_req));
+ priv_req.index = dump_req.index;
+ priv_req.offset = dump_req.offset;
+
+ /* Convert OS-layer's XAP memory space ID to HIP's ID in case they differ */
+ switch (dump_req.space) {
+ case UNIFIIO_COREDUMP_MAC_REG: priv_req.space = UNIFI_COREDUMP_MAC_REG; break;
+ case UNIFIIO_COREDUMP_PHY_REG: priv_req.space = UNIFI_COREDUMP_PHY_REG; break;
+ case UNIFIIO_COREDUMP_SH_DMEM: priv_req.space = UNIFI_COREDUMP_SH_DMEM; break;
+ case UNIFIIO_COREDUMP_MAC_DMEM: priv_req.space = UNIFI_COREDUMP_MAC_DMEM; break;
+ case UNIFIIO_COREDUMP_PHY_DMEM: priv_req.space = UNIFI_COREDUMP_PHY_DMEM; break;
+ case UNIFIIO_COREDUMP_TRIGGER_MAGIC: priv_req.space = UNIFI_COREDUMP_TRIGGER_MAGIC; break;
+ default:
+ r = -EINVAL;
+ goto out;
+ }
+
+ if (priv_req.space == UNIFI_COREDUMP_TRIGGER_MAGIC) {
+ /* Force a coredump grab now */
+ unifi_trace(priv, UDBG2, "UNIFI_COREDUMP_GET_REG: Force capture\n");
+ csrResult = unifi_coredump_capture(priv->card, &priv_req);
+ r = CsrHipResultToStatus(csrResult);
+ unifi_trace(priv, UDBG5, "UNIFI_COREDUMP_GET_REG: status %d\n", r);
+ } else {
+ /* Retrieve the appropriate register entry */
+ csrResult = unifi_coredump_get_value(priv->card, &priv_req);
+ r = CsrHipResultToStatus(csrResult);
+ if (r) {
+ unifi_trace(priv, UDBG5, "UNIFI_COREDUMP_GET_REG: Status %d\n", r);
+ goto out;
+ }
+ /* Update the OS-layer structure with values returned in the private */
+ dump_req.value = priv_req.value;
+ dump_req.timestamp = priv_req.timestamp;
+ dump_req.requestor = priv_req.requestor;
+ dump_req.serial = priv_req.serial;
+ dump_req.chip_ver = priv_req.chip_ver;
+ dump_req.fw_ver = priv_req.fw_ver;
+ dump_req.drv_build = 0;
+
+ unifi_trace(priv, UDBG6,
+ "Dump: %d (seq %d): V:0x%04x (%d) @0x%02x:%04x = 0x%04x\n",
+ dump_req.index, dump_req.serial,
+ dump_req.chip_ver, dump_req.drv_build,
+ dump_req.space, dump_req.offset, dump_req.value);
+ }
+ if (copy_to_user((void*)arg, (void*)&dump_req, sizeof(dump_req))) {
+ r = -EFAULT;
+ goto out;
+ }
+ }
+ break;
+#endif
+ default:
+ r = -EINVAL;
+ }
+
+out:
+ return (long)r;
+} /* unifi_ioctl() */
+
+
+
+static unsigned int
+unifi_poll(struct file *filp, poll_table *wait)
+{
+ ul_client_t *pcli = (ul_client_t*)filp->private_data;
+ unsigned int mask = 0;
+ int ready;
+
+ func_enter();
+
+ ready = !list_empty(&pcli->udi_log);
+
+ poll_wait(filp, &pcli->udi_wq, wait);
+
+ if (ready) {
+ mask |= POLLIN | POLLRDNORM; /* readable */
+ }
+
+ func_exit();
+
+ return mask;
+} /* unifi_poll() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * udi_set_log_filter
+ *
+ * Configure the bit mask that determines which signal primitives are
+ * passed to the logging process.
+ *
+ * Arguments:
+ * pcli Pointer to the client to configure.
+ * udi_filter Pointer to a unifiio_filter_t containing instructions.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * SigGetFilterPos() returns a 32-bit value that contains an index and a
+ * mask for accessing a signal_filter array. The top 16 bits specify an
+ * index into a signal_filter, the bottom 16 bits specify a mask to
+ * apply.
+ * ---------------------------------------------------------------------------
+ */
+static void
+udi_set_log_filter(ul_client_t *pcli, unifiio_filter_t *udi_filter)
+{
+ CsrUint32 filter_pos;
+ int i;
+
+ if (udi_filter->action == UfSigFil_AllOn)
+ {
+ for (i = 0; i < SIG_FILTER_SIZE; i++) {
+ pcli->signal_filter[i] = 0xFFFF;
+ }
+ }
+ else if (udi_filter->action == UfSigFil_AllOff)
+ {
+ for (i = 0; i < SIG_FILTER_SIZE; i++) {
+ pcli->signal_filter[i] = 0;
+ }
+ }
+ else if (udi_filter->action == UfSigFil_SelectOn)
+ {
+ for (i = 0; i < udi_filter->num_sig_ids; i++) {
+ filter_pos = SigGetFilterPos(udi_filter->sig_ids[i]);
+ if (filter_pos == 0xFFFFFFFF)
+ {
+ printk(KERN_WARNING
+ "Unrecognised signal id (0x%X) specifed in logging filter\n",
+ udi_filter->sig_ids[i]);
+ } else {
+ pcli->signal_filter[filter_pos >> 16] |= (filter_pos & 0xFFFF);
+ }
+ }
+ }
+ else if (udi_filter->action == UfSigFil_SelectOff)
+ {
+ for (i = 0; i < udi_filter->num_sig_ids; i++) {
+ filter_pos = SigGetFilterPos(udi_filter->sig_ids[i]);
+ if (filter_pos == 0xFFFFFFFF)
+ {
+ printk(KERN_WARNING
+ "Unrecognised signal id (0x%X) specifed in logging filter\n",
+ udi_filter->sig_ids[i]);
+ } else {
+ pcli->signal_filter[filter_pos >> 16] &= ~(filter_pos & 0xFFFF);
+ }
+ }
+ }
+
+} /* udi_set_log_filter() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * udi_log_event
+ *
+ * Callback function to be registered as the UDI hook callback.
+ * Copies the signal content into a new udi_log_t struct and adds
+ * it to the read queue for this UDI client.
+ *
+ * Arguments:
+ * pcli A pointer to the client instance.
+ * signal Pointer to the received signal.
+ * signal_len Size of the signal structure in bytes.
+ * bulkdata Pointers to any associated bulk data.
+ * dir Direction of the signal. Zero means from host,
+ * non-zero means to host.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+udi_log_event(ul_client_t *pcli,
+ const u8 *signal, int signal_len,
+ const bulk_data_param_t *bulkdata,
+ int dir)
+{
+ udi_log_t *logptr;
+ u8 *p;
+ int i;
+ int total_len;
+ udi_msg_t *msgptr;
+ CsrUint32 filter_pos;
+#ifdef OMNICLI_LINUX_EXTRA_LOG
+ static volatile unsigned int printk_cpu = UINT_MAX;
+ unsigned long long t;
+ unsigned long nanosec_rem;
+ unsigned long n_1000;
+#endif
+
+ func_enter();
+
+ /* Just a sanity check */
+ if ((signal == NULL) || (signal_len <= 0)) {
+ return;
+ }
+
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+ /* When HIP offline signal logging is enabled, omnicli cannot run */
+ if (log_hip_signals)
+ {
+ /* Add timestamp */
+ if (log_hip_signals & UNIFI_LOG_HIP_SIGNALS_FILTER_TIMESTAMP)
+ {
+ int timestamp = jiffies_to_msecs(jiffies);
+ unifi_debug_log_to_buf("T:");
+ unifi_debug_log_to_buf("%04X%04X ", *(((CsrUint16*)×tamp) + 1),
+ *(CsrUint16*)×tamp);
+ }
+
+ /* Add signal */
+ unifi_debug_log_to_buf("S%s:%04X R:%04X D:%04X ",
+ dir ? "T" : "F",
+ *(CsrUint16*)signal,
+ *(CsrUint16*)(signal + 2),
+ *(CsrUint16*)(signal + 4));
+ unifi_debug_hex_to_buf(signal + 6, signal_len - 6);
+
+ /* Add bulk data (assume 1 bulk data per signal) */
+ if ((log_hip_signals & UNIFI_LOG_HIP_SIGNALS_FILTER_BULKDATA) &&
+ (bulkdata->d[0].data_length > 0))
+ {
+ unifi_debug_log_to_buf("\nD:");
+ unifi_debug_hex_to_buf(bulkdata->d[0].os_data_ptr, bulkdata->d[0].data_length);
+ }
+ unifi_debug_log_to_buf("\n");
+
+ return;
+ }
+#endif
+
+#ifdef CSR_NATIVE_LINUX
+ uf_native_process_udi_signal(pcli, signal, signal_len, bulkdata, dir);
+#endif
+
+ /*
+ * Apply the logging filter - only report signals that have their
+ * bit set in the filter mask.
+ */
+ filter_pos = SigGetFilterPos(GET_SIGNAL_ID(signal));
+
+ if ((filter_pos != 0xFFFFFFFF) &&
+ ((pcli->signal_filter[filter_pos >> 16] & (filter_pos & 0xFFFF)) == 0))
+ {
+ /* Signal is not wanted by client */
+ return;
+ }
+
+
+ /* Calculate the buffer we need to store signal plus bulk data */
+ total_len = signal_len;
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
+ total_len += bulkdata->d[i].data_length;
+ }
+
+ /* Allocate log structure plus actual signal. */
+ logptr = (udi_log_t *)kmalloc(sizeof(udi_log_t) + total_len, GFP_KERNEL);
+
+ if (logptr == NULL) {
+ printk(KERN_ERR
+ "Failed to allocate %lu bytes for a UDI log record\n",
+ (long unsigned int)(sizeof(udi_log_t) + total_len));
+ return;
+ }
+
+ /* Fill in udi_log struct */
+ INIT_LIST_HEAD(&logptr->q);
+ msgptr = &logptr->msg;
+ msgptr->length = sizeof(udi_msg_t) + total_len;
+#ifdef OMNICLI_LINUX_EXTRA_LOG
+ t = cpu_clock(printk_cpu);
+ nanosec_rem = do_div(t, 1000000000);
+ n_1000 = nanosec_rem/1000;
+ msgptr->timestamp = (t <<10 ) | ((unsigned long)(n_1000 >> 10) & 0x3ff);
+#else
+ msgptr->timestamp = jiffies_to_msecs(jiffies);
+#endif
+ msgptr->direction = dir;
+ msgptr->signal_length = signal_len;
+
+ /* Copy signal and bulk data to the log */
+ p = (u8 *)(msgptr + 1);
+ memcpy(p, signal, signal_len);
+ p += signal_len;
+
+ /* Append any bulk data */
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
+ int len = bulkdata->d[i].data_length;
+
+ /*
+ * Len here might not be the same as the length in the bulk data slot.
+ * The slot length will always be even, but len could be odd.
+ */
+ if (len > 0) {
+ if (bulkdata->d[i].os_data_ptr) {
+ memcpy(p, bulkdata->d[i].os_data_ptr, len);
+ } else {
+ memset(p, 0, len);
+ }
+ p += len;
+ }
+ }
+
+ /* Add to tail of log queue */
+ if (down_interruptible(&pcli->udi_sem)) {
+ printk(KERN_WARNING "udi_log_event_q: Failed to get udi sem\n");
+ kfree(logptr);
+ func_exit();
+ return;
+ }
+ list_add_tail(&logptr->q, &pcli->udi_log);
+ up(&pcli->udi_sem);
+
+ /* Wake any waiting user process */
+ wake_up_interruptible(&pcli->udi_wq);
+
+ func_exit();
+} /* udi_log_event() */
+
+#ifdef CSR_SME_USERSPACE
+int
+uf_sme_queue_message(unifi_priv_t *priv, u8 *buffer, int length)
+{
+ udi_log_t *logptr;
+ udi_msg_t *msgptr;
+ u8 *p;
+
+ func_enter();
+
+ /* Just a sanity check */
+ if ((buffer == NULL) || (length <= 0)) {
+ return -EINVAL;
+ }
+
+ /* Allocate log structure plus actual signal. */
+ logptr = (udi_log_t *)kmalloc(sizeof(udi_log_t) + length, GFP_ATOMIC);
+ if (logptr == NULL) {
+ unifi_error(priv, "Failed to allocate %d bytes for an SME message\n",
+ sizeof(udi_log_t) + length);
+ CsrPmemFree(buffer);
+ return -ENOMEM;
+ }
+
+ /* Fill in udi_log struct */
+ INIT_LIST_HEAD(&logptr->q);
+ msgptr = &logptr->msg;
+ msgptr->length = sizeof(udi_msg_t) + length;
+ msgptr->signal_length = length;
+
+ /* Copy signal and bulk data to the log */
+ p = (u8 *)(msgptr + 1);
+ memcpy(p, buffer, length);
+
+ /* Add to tail of log queue */
+ down(&udi_mutex);
+ if (priv->sme_cli == NULL) {
+ kfree(logptr);
+ CsrPmemFree(buffer);
+ up(&udi_mutex);
+ unifi_info(priv, "Message for the SME dropped, SME has gone away\n");
+ return 0;
+ }
+
+ down(&priv->sme_cli->udi_sem);
+ list_add_tail(&logptr->q, &priv->sme_cli->udi_log);
+ up(&priv->sme_cli->udi_sem);
+
+ /* Wake any waiting user process */
+ wake_up_interruptible(&priv->sme_cli->udi_wq);
+ up(&udi_mutex);
+
+ /* It is our responsibility to free the buffer allocated in build_packed_*() */
+ CsrPmemFree(buffer);
+
+ func_exit();
+
+ return 0;
+
+} /* uf_sme_queue_message() */
+#endif
+
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+#define UF_DEVICE_CREATE(_class, _parent, _devno, _priv, _fmt, _args) \
+ device_create(_class, _parent, _devno, _priv, _fmt, _args)
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+#define UF_DEVICE_CREATE(_class, _parent, _devno, _priv, _fmt, _args) \
+ device_create_drvdata(_class, _parent, _devno, _priv, _fmt, _args)
+#else
+#define UF_DEVICE_CREATE(_class, _parent, _devno, _priv, _fmt, _args) \
+ device_create(_class, _parent, _devno, _fmt, _args)
+#endif
+
+/*
+ ****************************************************************************
+ *
+ * Driver instantiation
+ *
+ ****************************************************************************
+ */
+static struct file_operations unifi_fops = {
+ .owner = THIS_MODULE,
+ .open = unifi_open,
+ .release = unifi_release,
+ .read = unifi_read,
+ .write = unifi_write,
+ .unlocked_ioctl = unifi_ioctl,
+ .poll = unifi_poll,
+};
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+#define UF_DEVICE_CREATE(_class, _parent, _devno, _priv, _fmt, _args) \
+ device_create(_class, _parent, _devno, _priv, _fmt, _args)
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+#define UF_DEVICE_CREATE(_class, _parent, _devno, _priv, _fmt, _args) \
+ device_create_drvdata(_class, _parent, _devno, _priv, _fmt, _args)
+#else
+#define UF_DEVICE_CREATE(_class, _parent, _devno, _priv, _fmt, _args) \
+ device_create(_class, _parent, _devno, _fmt, _args)
+#endif
+
+static dev_t unifi_first_devno;
+static struct class *unifi_class;
+
+
+int uf_create_device_nodes(unifi_priv_t *priv, int bus_id)
+{
+ dev_t devno;
+ int r;
+
+ cdev_init(&priv->unifi_cdev, &unifi_fops);
+
+ /* cdev_init() should set the cdev owner, but it does not */
+ priv->unifi_cdev.owner = THIS_MODULE;
+
+ devno = MKDEV(MAJOR(unifi_first_devno),
+ MINOR(unifi_first_devno) + (bus_id * 2));
+ r = cdev_add(&priv->unifi_cdev, devno, 1);
+ if (r) {
+ return r;
+ }
+
+#ifdef SDIO_EXPORTS_STRUCT_DEVICE
+ if (!UF_DEVICE_CREATE(unifi_class, priv->unifi_device,
+ devno, priv, "unifi%d", bus_id)) {
+#else
+ priv->unifi_device = UF_DEVICE_CREATE(unifi_class, NULL,
+ devno, priv, "unifi%d", bus_id);
+ if (priv->unifi_device == NULL) {
+#endif /* SDIO_EXPORTS_STRUCT_DEVICE */
+
+ cdev_del(&priv->unifi_cdev);
+ return -EINVAL;
+ }
+
+ cdev_init(&priv->unifiudi_cdev, &unifi_fops);
+
+ /* cdev_init() should set the cdev owner, but it does not */
+ priv->unifiudi_cdev.owner = THIS_MODULE;
+
+ devno = MKDEV(MAJOR(unifi_first_devno),
+ MINOR(unifi_first_devno) + (bus_id * 2) + 1);
+ r = cdev_add(&priv->unifiudi_cdev, devno, 1);
+ if (r) {
+ device_destroy(unifi_class, priv->unifi_cdev.dev);
+ cdev_del(&priv->unifi_cdev);
+ return r;
+ }
+
+ if (!UF_DEVICE_CREATE(unifi_class,
+#ifdef SDIO_EXPORTS_STRUCT_DEVICE
+ priv->unifi_device,
+#else
+ NULL,
+#endif /* SDIO_EXPORTS_STRUCT_DEVICE */
+ devno, priv, "unifiudi%d", bus_id)) {
+ device_destroy(unifi_class, priv->unifi_cdev.dev);
+ cdev_del(&priv->unifiudi_cdev);
+ cdev_del(&priv->unifi_cdev);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+
+void uf_destroy_device_nodes(unifi_priv_t *priv)
+{
+ device_destroy(unifi_class, priv->unifiudi_cdev.dev);
+ device_destroy(unifi_class, priv->unifi_cdev.dev);
+ cdev_del(&priv->unifiudi_cdev);
+ cdev_del(&priv->unifi_cdev);
+}
+
+
+
+/*
+ * ----------------------------------------------------------------
+ * uf_create_debug_device
+ *
+ * Allocates device numbers for unifi character device nodes
+ * and creates a unifi class in sysfs
+ *
+ * Arguments:
+ * fops Pointer to the char device operations structure.
+ *
+ * Returns:
+ * 0 on success, -ve error code on error.
+ * ----------------------------------------------------------------
+ */
+static int
+uf_create_debug_device(struct file_operations *fops)
+{
+ int ret;
+
+ /* Allocate two device numbers for each device. */
+ ret = alloc_chrdev_region(&unifi_first_devno, 0, MAX_UNIFI_DEVS*2, UNIFI_NAME);
+ if (ret) {
+ unifi_error(NULL, "Failed to add alloc dev numbers: %d\n", ret);
+ return ret;
+ }
+
+ /* Create a UniFi class */
+ unifi_class = class_create(THIS_MODULE, UNIFI_NAME);
+ if (IS_ERR(unifi_class)) {
+ unifi_error(NULL, "Failed to create UniFi class\n");
+
+ /* Release device numbers */
+ unregister_chrdev_region(unifi_first_devno, MAX_UNIFI_DEVS*2);
+ unifi_first_devno = 0;
+ return -EINVAL;
+ }
+
+ return 0;
+} /* uf_create_debug_device() */
+
+
+/*
+ * ----------------------------------------------------------------
+ * uf_remove_debug_device
+ *
+ * Destroys the unifi class and releases the allocated
+ * device numbers for unifi character device nodes.
+ *
+ * Arguments:
+ *
+ * Returns:
+ * ----------------------------------------------------------------
+ */
+static void
+uf_remove_debug_device(void)
+{
+ /* Destroy the UniFi class */
+ class_destroy(unifi_class);
+
+ /* Release device numbers */
+ unregister_chrdev_region(unifi_first_devno, MAX_UNIFI_DEVS*2);
+ unifi_first_devno = 0;
+
+} /* uf_remove_debug_device() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * Module loading.
+ *
+ * ---------------------------------------------------------------------------
+ */
+int __init
+unifi_load(void)
+{
+ int r;
+
+ printk("UniFi SDIO Driver: %s %s %s\n",
+ CSR_WIFI_VERSION,
+ __DATE__, __TIME__);
+
+#ifdef CSR_SME_USERSPACE
+#ifdef CSR_SUPPORT_WEXT
+ printk("CSR SME with WEXT support\n");
+#else
+ printk("CSR SME no WEXT support\n");
+#endif /* CSR_SUPPORT_WEXT */
+#endif /* CSR_SME_USERSPACE */
+
+#ifdef CSR_NATIVE_LINUX
+#ifdef CSR_SUPPORT_WEXT
+#error WEXT unsupported in the native driver
+#endif
+ printk("CSR native no WEXT support\n");
+#endif
+#ifdef CSR_WIFI_SPLIT_PATCH
+ printk("Split patch support\n");
+#endif
+ printk("Kernel %d.%d.%d\n",
+ ((LINUX_VERSION_CODE) >> 16) & 0xff,
+ ((LINUX_VERSION_CODE) >> 8) & 0xff,
+ (LINUX_VERSION_CODE) & 0xff);
+ /*
+ * Instantiate the /dev/unifi* device nodes.
+ * We must do this before registering with the SDIO driver because it
+ * will immediately call the "insert" callback if the card is
+ * already present.
+ */
+ r = uf_create_debug_device(&unifi_fops);
+ if (r) {
+ return r;
+ }
+
+ /* Now register with the SDIO driver */
+ r = uf_sdio_load();
+ if (r) {
+ uf_remove_debug_device();
+ return r;
+ }
+
+ if (sdio_block_size > -1) {
+ unifi_info(NULL, "sdio_block_size %d\n", sdio_block_size);
+ }
+
+ if (sdio_byte_mode) {
+ unifi_info(NULL, "sdio_byte_mode\n");
+ }
+
+ if (disable_power_control) {
+ unifi_info(NULL, "disable_power_control\n");
+ }
+
+ if (disable_hw_reset) {
+ unifi_info(NULL, "disable_hw_reset\n");
+ }
+
+ if (enable_wol) {
+ unifi_info(NULL, "enable_wol %d\n", enable_wol);
+ }
+
+ if (run_bh_once != -1) {
+ unifi_info(NULL, "run_bh_once %d\n", run_bh_once);
+ }
+
+ return 0;
+} /* unifi_load() */
+
+
+void __exit
+unifi_unload(void)
+{
+ /* The SDIO remove hook will call unifi_disconnect(). */
+ uf_sdio_unload();
+
+ uf_remove_debug_device();
+
+} /* unifi_unload() */
+
+module_init(unifi_load);
+module_exit(unifi_unload);
+
+MODULE_DESCRIPTION("UniFi Device driver");
+MODULE_AUTHOR("Cambridge Silicon Radio Ltd.");
+MODULE_LICENSE("GPL and additional rights");
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: firmware.c
+ *
+ * PURPOSE:
+ * Implements the f/w related HIP core lib API.
+ * It is part of the porting exercise in Linux.
+ *
+ * Also, it contains example code for reading the loader and f/w files
+ * from the userspace and starting the SME in Linux.
+ *
+ * Copyright (C) 2005-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include <linux/kmod.h>
+#include <linux/vmalloc.h>
+#include <linux/firmware.h>
+#include <asm/uaccess.h>
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_unifi_udi.h"
+#include "unifiio.h"
+#include "unifi_priv.h"
+
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * F/W download. Part of the HIP core API
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_fw_read_start
+ *
+ * Returns a structure to be passed in unifi_fw_read().
+ * This structure is an OS specific description of the f/w file.
+ * In the linux implementation it is a buffer with the f/w and its' length.
+ * The HIP driver calls this functions to request for the loader or
+ * the firmware file.
+ * The structure pointer can be freed when unifi_fw_read_stop() is called.
+ *
+ * Arguments:
+ * ospriv Pointer to driver context.
+ * is_fw Type of firmware to retrieve
+ * info Versions information. Can be used to determine
+ * the appropriate f/w file to load.
+ *
+ * Returns:
+ * O on success, non-zero otherwise.
+ *
+ * ---------------------------------------------------------------------------
+ */
+void*
+unifi_fw_read_start(void *ospriv, CsrInt8 is_fw, const card_info_t *info)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+ CSR_UNUSED(info);
+
+ func_enter();
+
+ if (is_fw == UNIFI_FW_STA) {
+ /* F/w may have been released after a previous successful download. */
+ if (priv->fw_sta.dl_data == NULL) {
+ unifi_trace(priv, UDBG2, "Attempt reload of sta f/w\n");
+ uf_request_firmware_files(priv, UNIFI_FW_STA);
+ }
+ /* Set up callback struct for readfunc() */
+ if (priv->fw_sta.dl_data != NULL) {
+ func_exit();
+ return &priv->fw_sta;
+ }
+
+ } else {
+ unifi_error(priv, "downloading firmware... unknown request: %d\n", is_fw);
+ }
+
+ func_exit();
+ return NULL;
+} /* unifi_fw_read_start() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_fw_read_stop
+ *
+ * Called when the HIP driver has finished using the loader or
+ * the firmware file.
+ * The firmware buffer may be released now.
+ *
+ * Arguments:
+ * ospriv Pointer to driver context.
+ * dlpriv The pointer returned by unifi_fw_read_start()
+ *
+ * ---------------------------------------------------------------------------
+ */
+void
+unifi_fw_read_stop(void *ospriv, void *dlpriv)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+ struct dlpriv *dl_struct = (struct dlpriv *)dlpriv;
+ func_enter();
+
+ if (dl_struct != NULL) {
+ if (dl_struct->dl_data != NULL) {
+ unifi_trace(priv, UDBG2, "Release f/w buffer %p, %d bytes\n",
+ dl_struct->dl_data, dl_struct->dl_len);
+ }
+ uf_release_firmware(priv, dl_struct);
+ }
+
+ func_exit();
+} /* unifi_fw_read_stop() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_fw_open_buffer
+ *
+ * Returns a handle for a buffer dynamically allocated by the driver,
+ * e.g. into which a firmware file may have been converted from another format
+ * which is the case with some production test images.
+ *
+ * The handle may then be used by unifi_fw_read() to access the contents of
+ * the buffer.
+ *
+ * Arguments:
+ * ospriv Pointer to driver context.
+ * fwbuf Buffer containing firmware image
+ * len Length of buffer in bytes
+ *
+ * Returns
+ * Handle for buffer, or NULL on error
+ * ---------------------------------------------------------------------------
+ */
+void *
+unifi_fw_open_buffer(void *ospriv, void *fwbuf, CsrUint32 len)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+ func_enter();
+
+ if (fwbuf == NULL) {
+ func_exit();
+ return NULL;
+ }
+ priv->fw_conv.dl_data = fwbuf;
+ priv->fw_conv.dl_len = len;
+ priv->fw_conv.fw_desc = NULL; /* No OS f/w resource is associated */
+
+ func_exit();
+ return &priv->fw_conv;
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_fw_close_buffer
+ *
+ * Releases any handle for a buffer dynamically allocated by the driver,
+ * e.g. into which a firmware file may have been converted from another format
+ * which is the case with some production test images.
+ *
+ *
+ * Arguments:
+ * ospriv Pointer to driver context.
+ * fwbuf Buffer containing firmware image
+ *
+ * Returns
+ * Handle for buffer, or NULL on error
+ * ---------------------------------------------------------------------------
+ */
+void unifi_fw_close_buffer(void *ospriv, void *fwbuf)
+{
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_fw_read
+ *
+ * The HIP driver calls this function to ask for a part of the loader or
+ * the firmware file.
+ *
+ * Arguments:
+ * ospriv Pointer to driver context.
+ * arg The pointer returned by unifi_fw_read_start().
+ * offset The offset in the file to return from.
+ * buf A buffer to store the requested data.
+ * len The size of the buf and the size of the requested data.
+ *
+ * Returns
+ * The number of bytes read from the firmware image, or -ve on error
+ * ---------------------------------------------------------------------------
+ */
+CsrInt32
+unifi_fw_read(void *ospriv, void *arg, CsrUint32 offset, void *buf, CsrUint32 len)
+{
+ const struct dlpriv *dlpriv = arg;
+
+ if (offset >= dlpriv->dl_len) {
+ /* at end of file */
+ return 0;
+ }
+
+ if ((offset + len) > dlpriv->dl_len) {
+ /* attempt to read past end of file */
+ return -1;
+ }
+
+ memcpy(buf, dlpriv->dl_data+offset, len);
+
+ return len;
+
+} /* unifi_fw_read() */
+
+
+
+
+#define UNIFIHELPER_INIT_MODE_SMEEMB 0
+#define UNIFIHELPER_INIT_MODE_SMEUSER 2
+#define UNIFIHELPER_INIT_MODE_NATIVE 1
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_run_unifihelper
+ *
+ * Ask userspace to send us firmware for download by running
+ * '/usr/sbin/unififw'.
+ * The same script starts the SME userspace application.
+ * Derived from net_run_sbin_hotplug().
+ *
+ * Arguments:
+ * priv Pointer to OS private struct.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+int
+uf_run_unifihelper(unifi_priv_t *priv)
+{
+#ifdef CONFIG_HOTPLUG
+
+#ifdef ANDROID_BUILD
+ char *prog = "/system/bin/unififw";
+#else
+ char *prog = "/usr/sbin/unififw";
+#endif /* ANDROID_BUILD */
+
+ char *argv[6], *envp[4];
+ char inst_str[8];
+ char init_mode[8];
+ int i, r;
+
+#if (defined CSR_SME_USERSPACE) && (!defined CSR_SUPPORT_WEXT)
+ unifi_trace(priv, UDBG1, "SME userspace build: run unifi_helper manually\n");
+ return 0;
+#endif
+
+ unifi_trace(priv, UDBG1, "starting %s\n", prog);
+
+ snprintf(inst_str, 8, "%d", priv->instance);
+#if (defined CSR_SME_USERSPACE)
+ snprintf(init_mode, 8, "%d", UNIFIHELPER_INIT_MODE_SMEUSER);
+#else
+ snprintf(init_mode, 8, "%d", UNIFIHELPER_INIT_MODE_NATIVE);
+#endif /* CSR_SME_USERSPACE */
+
+ i = 0;
+ argv[i++] = prog;
+ argv[i++] = inst_str;
+ argv[i++] = init_mode;
+ argv[i++] = 0;
+ argv[i] = 0;
+ /* Don't add more args without making argv bigger */
+
+ /* minimal command environment */
+ i = 0;
+ envp[i++] = "HOME=/";
+ envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
+ envp[i] = 0;
+ /* Don't add more without making envp bigger */
+
+ unifi_trace(priv, UDBG2, "running %s %s %s\n", argv[0], argv[1], argv[2]);
+
+ r = call_usermodehelper(argv[0], argv, envp, 0);
+
+ return r;
+#else
+ unifi_trace(priv, UDBG1, "Can't automatically download firmware because kernel does not have HOTPLUG\n");
+ return -1;
+#endif
+} /* uf_run_unifihelper() */
+
+#ifdef CSR_WIFI_SPLIT_PATCH
+static CsrBool is_ap_mode(unifi_priv_t *priv)
+{
+ if (priv == NULL || priv->interfacePriv[0] == NULL)
+ {
+ return FALSE;
+ }
+
+ /* Test for mode requiring AP patch */
+ return(CSR_WIFI_HIP_IS_AP_FW(priv->interfacePriv[0]->interfaceMode));
+}
+#endif
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_request_firmware_files
+ *
+ * Get the firmware files from userspace.
+ *
+ * Arguments:
+ * priv Pointer to OS private struct.
+ * is_fw type of firmware to load (UNIFI_FW_STA/LOADER)
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+int uf_request_firmware_files(unifi_priv_t *priv, int is_fw)
+{
+ /* uses the default method to get the firmware */
+ const struct firmware *fw_entry;
+ int postfix;
+#define UNIFI_MAX_FW_PATH_LEN 32
+ char fw_name[UNIFI_MAX_FW_PATH_LEN];
+ int r;
+
+#if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT)
+ if (priv->mib_data.length) {
+ vfree(priv->mib_data.data);
+ priv->mib_data.data = NULL;
+ priv->mib_data.length = 0;
+ }
+#endif /* CSR_SUPPORT_SME && CSR_SUPPORT_WEXT*/
+
+ postfix = priv->instance;
+
+ if (is_fw == UNIFI_FW_STA) {
+ /* Free kernel buffer and reload */
+ uf_release_firmware(priv, &priv->fw_sta);
+#ifdef CSR_WIFI_SPLIT_PATCH
+ scnprintf(fw_name, UNIFI_MAX_FW_PATH_LEN, "unifi-sdio-%d/%s",
+ postfix, (is_ap_mode(priv) ? "ap.xbv" : "staonly.xbv") );
+#else
+ scnprintf(fw_name, UNIFI_MAX_FW_PATH_LEN, "unifi-sdio-%d/%s",
+ postfix, "sta.xbv" );
+#endif
+ r = request_firmware(&fw_entry, fw_name, priv->unifi_device);
+ if (r == 0) {
+ priv->fw_sta.dl_data = fw_entry->data;
+ priv->fw_sta.dl_len = fw_entry->size;
+ priv->fw_sta.fw_desc = (void *)fw_entry;
+ } else {
+ unifi_trace(priv, UDBG2, "Firmware file not available\n");
+ }
+ }
+
+ return 0;
+
+} /* uf_request_firmware_files() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_release_firmware_files
+ *
+ * Release all buffers used to store firmware files
+ *
+ * Arguments:
+ * priv Pointer to OS private struct.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+int uf_release_firmware_files(unifi_priv_t *priv)
+{
+ uf_release_firmware(priv, &priv->fw_sta);
+
+ return 0;
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_release_firmware
+ *
+ * Release specific buffer used to store firmware
+ *
+ * Arguments:
+ * priv Pointer to OS private struct.
+ * to_free Pointer to specific buffer to release
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+int uf_release_firmware(unifi_priv_t *priv, struct dlpriv *to_free)
+{
+ if (to_free != NULL) {
+ if (to_free->fw_desc != NULL) {
+ release_firmware((const struct firmware *)to_free->fw_desc);
+ }
+ to_free->fw_desc = NULL;
+ to_free->dl_data = NULL;
+ to_free->dl_len = 0;
+ }
+ return 0;
+}
--- /dev/null
+/*
+ * ***************************************************************************
+ * FILE: indications.c
+ *
+ * PURPOSE:
+ * Callbacks to process signals sent to us by the UniFi chip.
+ *
+ * This file is linux-specific.
+ *
+ * Copyright (C) 2005-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ***************************************************************************
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "unifi_priv.h"
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: inet.c
+ *
+ * PURPOSE:
+ * Routines related to IP address changes.
+ * Optional part of the porting exercise. It uses system network
+ * handlers to obtain the UniFi IP address and pass it to the SME
+ * using the unifi_sys_ip_configured_ind().
+ *
+ * Copyright (C) 2008-2009 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include <linux/inetdevice.h>
+#include <linux/notifier.h>
+
+#include "unifi_priv.h"
+#include "csr_wifi_hip_conversions.h"
+
+/*
+ * The inet notifier is global and not per-netdev. To avoid having a
+ * notifier registered when there are no unifi devices present, it's
+ * registered after the first unifi network device is registered, and
+ * unregistered when the last unifi network device is unregistered.
+ */
+
+static atomic_t inet_notif_refs = ATOMIC_INIT(0);
+
+static int uf_inetaddr_event(struct notifier_block *notif, unsigned long event, void *ifa)
+{
+ struct net_device *ndev;
+ unifi_priv_t *priv;
+ struct in_ifaddr *if_addr;
+ netInterface_priv_t *InterfacePriv = (netInterface_priv_t *)NULL;
+
+ if (!ifa || !((struct in_ifaddr *)ifa)->ifa_dev) {
+ unifi_trace(NULL, UDBG1, "uf_inetaddr_event (%lu) ifa=%p\n", event, ifa);
+ return NOTIFY_DONE;
+ }
+
+ ndev = ((struct in_ifaddr *)ifa)->ifa_dev->dev;
+ InterfacePriv = (netInterface_priv_t*) netdev_priv(ndev);
+
+ /* As the notifier is global, the call may be for a non-UniFi netdev.
+ * Therefore check the netdev_priv to make sure it's a known UniFi one.
+ */
+ if (uf_find_netdev_priv(InterfacePriv) == -1) {
+ unifi_trace(NULL, UDBG1, "uf_inetaddr_event (%lu) ndev=%p, other netdev_priv=%p\n",
+ event, ndev, InterfacePriv);
+ return NOTIFY_DONE;
+ }
+
+ if (!InterfacePriv->privPtr) {
+ unifi_error(NULL, "uf_inetaddr_event null priv (%lu) ndev=%p, InterfacePriv=%p\n",
+ event, ndev, InterfacePriv);
+ return NOTIFY_DONE;
+ }
+
+ priv = InterfacePriv->privPtr;
+ if_addr = (struct in_ifaddr *)ifa;
+
+ /* If this event is for a UniFi device, notify the SME that an IP
+ * address has been added or removed. */
+ if (uf_find_priv(priv) != -1) {
+ switch (event) {
+ case NETDEV_UP:
+ unifi_info(priv, "IP address assigned for %s\n", priv->netdev[InterfacePriv->InterfaceTag]->name);
+ priv->sta_ip_address = if_addr->ifa_address;
+#ifdef CSR_SUPPORT_WEXT
+ sme_mgt_packet_filter_set(priv);
+#endif
+ break;
+ case NETDEV_DOWN:
+ unifi_info(priv, "IP address removed for %s\n", priv->netdev[InterfacePriv->InterfaceTag]->name);
+ priv->sta_ip_address = 0xFFFFFFFF;
+#ifdef CSR_SUPPORT_WEXT
+ sme_mgt_packet_filter_set(priv);
+#endif
+ break;
+ }
+ }
+
+ return NOTIFY_DONE;
+}
+
+static struct notifier_block uf_inetaddr_notifier = {
+ .notifier_call = uf_inetaddr_event,
+};
+
+void uf_register_inet_notifier(void)
+{
+ if (atomic_inc_return(&inet_notif_refs) == 1) {
+ register_inetaddr_notifier(&uf_inetaddr_notifier);
+ }
+}
+
+void uf_unregister_inet_notifier(void)
+{
+ if (atomic_dec_return(&inet_notif_refs) == 0) {
+ unregister_inetaddr_notifier(&uf_inetaddr_notifier);
+ }
+}
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: init_hw.c
+ *
+ * PURPOSE:
+ * Use the HIP core lib to initialise the UniFi chip.
+ * It is part of the porting exercise in Linux.
+ *
+ * Copyright (C) 2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "unifi_priv.h"
+
+
+#define MAX_INIT_ATTEMPTS 4
+
+extern int led_mask;
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_init_hw
+ *
+ * Resets hardware, downloads and initialises f/w.
+ * This function demonstrates how to use the HIP core lib API
+ * to implement the SME unifi_sys_wifi_on_req() part of the SYS API.
+ *
+ * In a simple implementation, all this function needs to do is call
+ * unifi_init_card() and then unifi_card_info().
+ * In the Linux implementation, it will retry to initialise UniFi or
+ * try to debug the reasons if unifi_init_card() returns an error.
+ *
+ * Arguments:
+ * ospriv Pointer to OS driver structure for the device.
+ *
+ * Returns:
+ * O on success, non-zero otherwise.
+ *
+ * ---------------------------------------------------------------------------
+ */
+int
+uf_init_hw(unifi_priv_t *priv)
+{
+ int attempts = 0;
+ int priv_instance;
+ CsrResult csrResult = CSR_RESULT_FAILURE;
+
+ priv_instance = uf_find_priv(priv);
+ if (priv_instance == -1) {
+ unifi_warning(priv, "uf_init_hw: Unknown priv instance, will use fw_init[0]\n");
+ priv_instance = 0;
+ }
+
+ while (1) {
+ if (attempts > MAX_INIT_ATTEMPTS) {
+ unifi_error(priv, "Failed to initialise UniFi after %d attempts, "
+ "giving up.\n",
+ attempts);
+ break;
+ }
+ attempts++;
+
+ unifi_info(priv, "Initialising UniFi, attempt %d\n", attempts);
+
+ if (fw_init[priv_instance] > 0) {
+ unifi_notice(priv, "f/w init prevented by module parameter\n");
+ break;
+ } else if (fw_init[priv_instance] == 0) {
+ fw_init[priv_instance] ++;
+ }
+
+ /*
+ * Initialise driver core. This will perform a reset of UniFi
+ * internals, but not the SDIO CCCR.
+ */
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_init_card(priv->card, led_mask);
+ CsrSdioRelease(priv->sdio);
+
+ if (csrResult == CSR_WIFI_HIP_RESULT_NO_DEVICE) {
+ return CsrHipResultToStatus(csrResult);
+ }
+ if (csrResult == CSR_WIFI_HIP_RESULT_NOT_FOUND) {
+ unifi_error(priv, "Firmware file required, but not found.\n");
+ return CsrHipResultToStatus(csrResult);
+ }
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ /* failed. Reset h/w and try again */
+ unifi_error(priv, "Failed to initialise UniFi chip.\n");
+ continue;
+ }
+
+ /* Get the version information from the lib_hip */
+ unifi_card_info(priv->card, &priv->card_info);
+
+ return CsrHipResultToStatus(csrResult);
+ }
+
+ return CsrHipResultToStatus(csrResult);
+
+} /* uf_init_hw */
+
+
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: io.c
+ *
+ * PURPOSE:
+ * This file contains routines that the SDIO driver can call when a
+ * UniFi card is first inserted (or detected) and removed.
+ *
+ * When used with sdioemb, the udev scripts (at least on Ubuntu) don't
+ * recognise a UniFi being added to the system. This is because sdioemb
+ * does not register itself as a device_driver, it uses it's own code
+ * to handle insert and remove.
+ * To have Ubuntu recognise UniFi, edit /etc/udev/rules.d/85-ifupdown.rules
+ * to change this line:
+ * SUBSYSTEM=="net", DRIVERS=="?*", GOTO="net_start"
+ * to these:
+ * #SUBSYSTEM=="net", DRIVERS=="?*", GOTO="net_start"
+ * SUBSYSTEM=="net", GOTO="net_start"
+ *
+ * Then you can add a stanza to /etc/network/interfaces like this:
+ * auto eth1
+ * iface eth1 inet dhcp
+ * wpa-conf /etc/wpa_supplicant.conf
+ * This will then automatically associate when a car dis inserted.
+ *
+ * Copyright (C) 2006-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include <linux/proc_fs.h>
+
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_unifiversion.h"
+#include "csr_wifi_hip_unifi_udi.h" /* for unifi_print_status() */
+#include "unifiio.h"
+#include "unifi_priv.h"
+
+
+/*
+ * Array of pointers to context structs for unifi devices that are present.
+ * The index in the array corresponds to the wlan interface number
+ * (if "wlan*" is used). If "eth*" is used, the eth* numbers are allocated
+ * after any Ethernet cards.
+ *
+ * The Arasan PCI-SDIO controller card supported by this driver has 2 slots,
+ * hence a max of 2 devices.
+ */
+static unifi_priv_t *Unifi_instances[MAX_UNIFI_DEVS];
+
+/* Array of pointers to netdev objects used by the UniFi driver, as there
+ * are now many per instance. This is used to determine which netdev events
+ * are for UniFi as opposed to other net interfaces.
+ */
+static netInterface_priv_t *Unifi_netdev_instances[MAX_UNIFI_DEVS * CSR_WIFI_NUM_INTERFACES];
+
+/*
+ * Array to hold the status of each unifi device in each slot.
+ * We only process an insert event when In_use[] for the slot is
+ * UNIFI_DEV_NOT_IN_USE. Otherwise, it means that the slot is in use or
+ * we are in the middle of a cleanup (the action on unplug).
+ */
+#define UNIFI_DEV_NOT_IN_USE 0
+#define UNIFI_DEV_IN_USE 1
+#define UNIFI_DEV_CLEANUP 2
+static int In_use[MAX_UNIFI_DEVS];
+/*
+ * Mutex to prevent UDI clients to open the character device before the priv
+ * is created and initialised.
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
+DEFINE_SEMAPHORE(Unifi_instance_mutex);
+#else
+DECLARE_MUTEX(Unifi_instance_mutex);
+#endif
+/*
+ * When the device is removed, unregister waits on Unifi_cleanup_wq
+ * until all the UDI clients release the character device.
+ */
+DECLARE_WAIT_QUEUE_HEAD(Unifi_cleanup_wq);
+
+
+static int uf_read_proc(char *page, char **start, off_t offset, int count,
+ int *eof, void *data);
+
+#ifdef CSR_WIFI_RX_PATH_SPLIT
+
+static CsrResult signal_buffer_init(unifi_priv_t * priv, int size)
+{
+ int i;
+ func_enter();
+
+ priv->rxSignalBuffer.writePointer =
+ priv->rxSignalBuffer.readPointer = 0;
+ priv->rxSignalBuffer.size = size;
+ /* Allocating Memory for Signal primitive pointer */
+ for(i=0; i<size; i++)
+ {
+ priv->rxSignalBuffer.rx_buff[i].sig_len=0;
+ priv->rxSignalBuffer.rx_buff[i].bufptr = CsrMemAlloc(UNIFI_PACKED_SIGBUF_SIZE);
+ if (priv->rxSignalBuffer.rx_buff[i].bufptr == NULL)
+ {
+ int j;
+ unifi_error(priv,"signal_buffer_init:Failed to Allocate shared memory for T-H signals \n");
+ for(j=0;j<i;j++)
+ {
+ priv->rxSignalBuffer.rx_buff[j].sig_len=0;
+ CsrMemFree(priv->rxSignalBuffer.rx_buff[j].bufptr);
+ priv->rxSignalBuffer.rx_buff[j].bufptr = NULL;
+ }
+ func_exit();
+ return -1;
+ }
+ }
+ func_exit();
+ return 0;
+}
+
+
+static void signal_buffer_free(unifi_priv_t * priv, int size)
+{
+ int i;
+
+ for(i=0; i<size; i++)
+ {
+ priv->rxSignalBuffer.rx_buff[i].sig_len=0;
+ CsrMemFree(priv->rxSignalBuffer.rx_buff[i].bufptr);
+ priv->rxSignalBuffer.rx_buff[i].bufptr = NULL;
+ }
+}
+#endif
+/*
+ * ---------------------------------------------------------------------------
+ * uf_register_netdev
+ *
+ * Registers the network interface, installes the qdisc,
+ * and registers the inet handler.
+ * In the porting exercise, register the driver to the network
+ * stack if necessary.
+ *
+ * Arguments:
+ * priv Pointer to driver context.
+ *
+ * Returns:
+ * O on success, non-zero otherwise.
+ *
+ * Notes:
+ * We will only unregister when the card is ejected, so we must
+ * only do it once.
+ * ---------------------------------------------------------------------------
+ */
+int
+uf_register_netdev(unifi_priv_t *priv, int interfaceTag)
+{
+ int r;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "uf_register_netdev bad interfaceTag\n");
+ return -EINVAL;
+ }
+
+ /*
+ * Allocates a device number and registers device with the network
+ * stack.
+ */
+ unifi_trace(priv, UDBG5, "uf_register_netdev: netdev %d - 0x%p\n",
+ interfaceTag, priv->netdev[interfaceTag]);
+ r = register_netdev(priv->netdev[interfaceTag]);
+ if (r) {
+ unifi_error(priv, "Failed to register net device\n");
+ return -EINVAL;
+ }
+
+ /* The device is registed */
+ interfacePriv->netdev_registered = 1;
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
+#ifdef CONFIG_NET_SCHED
+ /*
+ * IMPORTANT:
+ * uf_install_qdisc() holds the network device lock, we can not
+ * install the qdisk before the network device is registered.
+ */
+ r = uf_install_qdisc(priv->netdev[interfaceTag]);
+ if (r) {
+ unifi_error(priv, "Failed to install qdisc\n");
+ return r;
+ }
+#endif /* CONFIG_NET_SCHED */
+#endif /* LINUX_VERSION_CODE */
+
+#ifdef CSR_SUPPORT_SME
+ /*
+ * Register the inet handler; it notifies us for changes in the IP address.
+ */
+ uf_register_inet_notifier();
+#endif /* CSR_SUPPORT_SME */
+
+ unifi_notice(priv, "unifi%d is %s\n",
+ priv->instance, priv->netdev[interfaceTag]->name);
+
+ return 0;
+} /* uf_register_netdev */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_unregister_netdev
+ *
+ * Unregisters the network interface and the inet handler.
+ *
+ * Arguments:
+ * priv Pointer to driver context.
+ *
+ * Returns:
+ * None.
+ *
+ * ---------------------------------------------------------------------------
+ */
+void
+uf_unregister_netdev(unifi_priv_t *priv)
+{
+ int i=0;
+
+#ifdef CSR_SUPPORT_SME
+ /* Unregister the inet handler... */
+ uf_unregister_inet_notifier();
+#endif /* CSR_SUPPORT_SME */
+
+ for (i=0; i<CSR_WIFI_NUM_INTERFACES; i++) {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[i];
+ if (interfacePriv->netdev_registered) {
+ unifi_trace(priv, UDBG5,
+ "uf_unregister_netdev: netdev %d - 0x%p\n",
+ i, priv->netdev[i]);
+
+ /* ... and the netdev */
+ unregister_netdev(priv->netdev[i]);
+ interfacePriv->netdev_registered = 0;
+ }
+
+ interfacePriv->interfaceMode = 0;
+
+ /* Enable all queues by default */
+ interfacePriv->queueEnabled[0] = 1;
+ interfacePriv->queueEnabled[1] = 1;
+ interfacePriv->queueEnabled[2] = 1;
+ interfacePriv->queueEnabled[3] = 1;
+ }
+
+ priv->totalInterfaceCount = 0;
+} /* uf_unregister_netdev() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * register_unifi_sdio
+ *
+ * This function is called from the Probe (or equivalent) method of
+ * the SDIO driver when a UniFi card is detected.
+ * We allocate the Linux net_device struct, initialise the HIP core
+ * lib, create the char device nodes and start the userspace helper
+ * to initialise the device.
+ *
+ * Arguments:
+ * sdio_dev Pointer to SDIO context handle to use for all
+ * SDIO ops.
+ * bus_id A small number indicating the SDIO card position on the
+ * bus. Typically this is the slot number, e.g. 0, 1 etc.
+ * Valid values are 0 to MAX_UNIFI_DEVS-1.
+ * dev Pointer to kernel device manager struct.
+ *
+ * Returns:
+ * Pointer to the unifi instance, or NULL on error.
+ * ---------------------------------------------------------------------------
+ */
+static unifi_priv_t *
+register_unifi_sdio(CsrSdioFunction *sdio_dev, int bus_id, struct device *dev)
+{
+ unifi_priv_t *priv = NULL;
+ int r = -1;
+ CsrResult csrResult;
+
+ func_enter();
+
+ if ((bus_id < 0) || (bus_id >= MAX_UNIFI_DEVS)) {
+ unifi_error(priv, "register_unifi_sdio: invalid device %d\n",
+ bus_id);
+ return NULL;
+ }
+
+ down(&Unifi_instance_mutex);
+
+ if (In_use[bus_id] != UNIFI_DEV_NOT_IN_USE) {
+ unifi_error(priv, "register_unifi_sdio: device %d is already in use\n",
+ bus_id);
+ goto failed0;
+ }
+
+
+ /* Allocate device private and net_device structs */
+ priv = uf_alloc_netdevice(sdio_dev, bus_id);
+ if (priv == NULL) {
+ unifi_error(priv, "Failed to allocate driver private\n");
+ goto failed0;
+ }
+
+ priv->unifi_device = dev;
+
+ SET_NETDEV_DEV(priv->netdev[0], dev);
+
+ /* We are not ready to send data yet. */
+ netif_carrier_off(priv->netdev[0]);
+
+ /* Allocate driver context. */
+ priv->card = unifi_alloc_card(priv->sdio, priv);
+ if (priv->card == NULL) {
+ unifi_error(priv, "Failed to allocate UniFi driver card struct.\n");
+ goto failed1;
+ }
+
+ if (Unifi_instances[bus_id]) {
+ unifi_error(priv, "Internal error: instance for slot %d is already taken\n",
+ bus_id);
+ }
+ Unifi_instances[bus_id] = priv;
+ In_use[bus_id] = UNIFI_DEV_IN_USE;
+
+ /* Save the netdev_priv for use by the netdev event callback mechanism */
+ Unifi_netdev_instances[bus_id * CSR_WIFI_NUM_INTERFACES] = netdev_priv(priv->netdev[0]);
+
+ /* Initialise the mini-coredump capture buffers */
+ csrResult = unifi_coredump_init(priv->card, (CsrUint16)coredump_max);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "Couldn't allocate mini-coredump buffers\n");
+ }
+
+ /* Create the character device nodes */
+ r = uf_create_device_nodes(priv, bus_id);
+ if (r) {
+ goto failed1;
+ }
+
+ /*
+ * We use the slot number as unifi device index.
+ */
+ snprintf(priv->proc_entry_name, 64, "driver/unifi%d", priv->instance);
+ /*
+ * The following complex casting is in place in order to eliminate 64-bit compilation warning
+ * "cast to/from pointer from/to integer of different size"
+ */
+ if (!create_proc_read_entry(priv->proc_entry_name, 0, 0,
+ uf_read_proc, (void *)(long)priv->instance))
+ {
+ unifi_error(priv, "unifi: can't create /proc/driver/unifi\n");
+ }
+
+ /* Allocate the net_device for interfaces other than 0. */
+ {
+ int i;
+ priv->totalInterfaceCount =0;
+
+ for(i=1;i<CSR_WIFI_NUM_INTERFACES;i++)
+ {
+ if( !uf_alloc_netdevice_for_other_interfaces(priv,i) )
+ {
+ /* error occured while allocating the net_device for interface[i]. The net_device are
+ * allocated for the interfaces with id<i. Dont worry, all the allocated net_device will
+ * be releasing chen the control goes to the label failed0.
+ */
+ unifi_error(priv, "Failed to allocate driver private for interface[%d]\n",i);
+ goto failed0;
+ }
+ else
+ {
+ SET_NETDEV_DEV(priv->netdev[i], dev);
+
+ /* We are not ready to send data yet. */
+ netif_carrier_off(priv->netdev[i]);
+
+ /* Save the netdev_priv for use by the netdev event callback mechanism */
+ Unifi_netdev_instances[bus_id * CSR_WIFI_NUM_INTERFACES + i] = netdev_priv(priv->netdev[i]);
+ }
+ }
+
+ for(i=0;i<CSR_WIFI_NUM_INTERFACES;i++)
+ {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[i];
+ interfacePriv->netdev_registered=0;
+ }
+ }
+
+#ifdef CSR_WIFI_RX_PATH_SPLIT
+ if (signal_buffer_init(priv, CSR_WIFI_RX_SIGNAL_BUFFER_SIZE))
+ {
+ unifi_error(priv,"Failed to allocate shared memory for T-H signals\n");
+ goto failed2;
+ }
+ priv->rx_workqueue = create_singlethread_workqueue("rx_workq");
+ if (priv->rx_workqueue == NULL) {
+ unifi_error(priv,"create_singlethread_workqueue failed \n");
+ goto failed3;
+ }
+ INIT_WORK(&priv->rx_work_struct, rx_wq_handler);
+#endif
+
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+ if (log_hip_signals)
+ {
+ uf_register_hip_offline_debug(priv);
+ }
+#endif
+
+ /* Initialise the SME related threads and parameters */
+ r = uf_sme_init(priv);
+ if (r) {
+ unifi_error(priv, "SME initialisation failed.\n");
+ goto failed4;
+ }
+
+ /*
+ * Run the userspace helper program (unififw) to perform
+ * the device initialisation.
+ */
+ unifi_trace(priv, UDBG1, "run UniFi helper app...\n");
+ r = uf_run_unifihelper(priv);
+ if (r) {
+ unifi_notice(priv, "unable to run UniFi helper app\n");
+ /* Not a fatal error. */
+ }
+
+ up(&Unifi_instance_mutex);
+
+ func_exit();
+ return priv;
+
+failed4:
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+if (log_hip_signals)
+{
+ uf_unregister_hip_offline_debug(priv);
+}
+#endif
+#ifdef CSR_WIFI_RX_PATH_SPLIT
+ flush_workqueue(priv->rx_workqueue);
+ destroy_workqueue(priv->rx_workqueue);
+failed3:
+ signal_buffer_free(priv,CSR_WIFI_RX_SIGNAL_BUFFER_SIZE);
+failed2:
+#endif
+ /* Remove the device nodes */
+ uf_destroy_device_nodes(priv);
+failed1:
+ /* Deregister priv->netdev_client */
+ ul_deregister_client(priv->netdev_client);
+
+failed0:
+ if (priv && priv->card) {
+ unifi_coredump_free(priv->card);
+ unifi_free_card(priv->card);
+ }
+ if (priv) {
+ uf_free_netdevice(priv);
+ }
+
+ up(&Unifi_instance_mutex);
+
+ func_exit();
+ return NULL;
+} /* register_unifi_sdio() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * ask_unifi_sdio_cleanup
+ *
+ * We can not free our private context, until all the char device
+ * clients have closed the file handles. unregister_unifi_sdio() which
+ * is called when a card is removed, waits on Unifi_cleanup_wq until
+ * the reference count becomes zero. It is time to wake it up now.
+ *
+ * Arguments:
+ * priv Pointer to driver context.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void
+ask_unifi_sdio_cleanup(unifi_priv_t *priv)
+{
+ func_enter();
+
+ /*
+ * Now clear the flag that says the old instance is in use.
+ * This is used to prevent a new instance being started before old
+ * one has finshed closing down, for example if bounce makes the card
+ * appear to be ejected and re-inserted quickly.
+ */
+ In_use[priv->instance] = UNIFI_DEV_CLEANUP;
+
+ unifi_trace(NULL, UDBG5, "ask_unifi_sdio_cleanup: wake up cleanup workqueue.\n");
+ wake_up(&Unifi_cleanup_wq);
+
+ func_exit();
+
+} /* ask_unifi_sdio_cleanup() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * cleanup_unifi_sdio
+ *
+ * Release any resources owned by a unifi instance.
+ *
+ * Arguments:
+ * priv Pointer to the instance to free.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void
+cleanup_unifi_sdio(unifi_priv_t *priv)
+{
+ int priv_instance;
+ int i;
+ static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
+
+ func_enter();
+
+ /* Remove the device nodes */
+ uf_destroy_device_nodes(priv);
+
+ /* Mark this device as gone away by NULLing the entry in Unifi_instances */
+ Unifi_instances[priv->instance] = NULL;
+
+ unifi_trace(priv, UDBG5, "cleanup_unifi_sdio: remove_proc_entry\n");
+ /*
+ * Free the children of priv before unifi_free_netdevice() frees
+ * the priv struct
+ */
+ remove_proc_entry(priv->proc_entry_name, 0);
+
+
+ /* Unregister netdev as a client. */
+ if (priv->netdev_client) {
+ unifi_trace(priv, UDBG2, "Netdev client (id:%d s:0x%X) is unregistered\n",
+ priv->netdev_client->client_id, priv->netdev_client->sender_id);
+ ul_deregister_client(priv->netdev_client);
+ }
+
+ /* Destroy the SME related threads and parameters */
+ uf_sme_deinit(priv);
+
+#ifdef CSR_SME_USERSPACE
+ priv->smepriv = NULL;
+#endif
+
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+ if (log_hip_signals)
+ {
+ uf_unregister_hip_offline_debug(priv);
+ }
+#endif
+
+ /* Free any packets left in the Rx queues */
+ for(i=0;i<CSR_WIFI_NUM_INTERFACES;i++)
+ {
+ uf_free_pending_rx_packets(priv, UF_UNCONTROLLED_PORT_Q, broadcast_address,i);
+ uf_free_pending_rx_packets(priv, UF_CONTROLLED_PORT_Q, broadcast_address,i);
+ }
+ /*
+ * We need to free the resources held by the core, which include tx skbs,
+ * otherwise we can not call unregister_netdev().
+ */
+ if (priv->card) {
+ unifi_trace(priv, UDBG5, "cleanup_unifi_sdio: free card\n");
+ unifi_coredump_free(priv->card);
+ unifi_free_card(priv->card);
+ priv->card = NULL;
+ }
+
+ /*
+ * Unregister the network device.
+ * We can not unregister the netdev before we release
+ * all pending packets in the core.
+ */
+ uf_unregister_netdev(priv);
+ priv->totalInterfaceCount = 0;
+
+ /* Clear the table of registered netdev_priv's */
+ for (i = 0; i < CSR_WIFI_NUM_INTERFACES; i++) {
+ Unifi_netdev_instances[priv->instance * CSR_WIFI_NUM_INTERFACES + i] = NULL;
+ }
+
+ unifi_trace(priv, UDBG5, "cleanup_unifi_sdio: uf_free_netdevice\n");
+ /*
+ * When uf_free_netdevice() returns, the priv is invalid
+ * so we need to remember the instance to clear the global flag later.
+ */
+ priv_instance = priv->instance;
+
+#ifdef CSR_WIFI_RX_PATH_SPLIT
+ flush_workqueue(priv->rx_workqueue);
+ destroy_workqueue(priv->rx_workqueue);
+ signal_buffer_free(priv,CSR_WIFI_RX_SIGNAL_BUFFER_SIZE);
+#endif
+
+ /* Priv is freed as part of the net_device */
+ uf_free_netdevice(priv);
+
+ /*
+ * Now clear the flag that says the old instance is in use.
+ * This is used to prevent a new instance being started before old
+ * one has finshed closing down, for example if bounce makes the card
+ * appear to be ejected and re-inserted quickly.
+ */
+ In_use[priv_instance] = UNIFI_DEV_NOT_IN_USE;
+
+ unifi_trace(NULL, UDBG5, "cleanup_unifi_sdio: DONE.\n");
+
+ func_exit();
+
+} /* cleanup_unifi_sdio() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unregister_unifi_sdio
+ *
+ * Call from SDIO driver when it detects that UniFi has been removed.
+ *
+ * Arguments:
+ * bus_id Number of the card that was ejected.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void
+unregister_unifi_sdio(int bus_id)
+{
+ unifi_priv_t *priv;
+ int interfaceTag=0;
+ u8 reason = CONFIG_IND_EXIT;
+
+ if ((bus_id < 0) || (bus_id >= MAX_UNIFI_DEVS)) {
+ unifi_error(NULL, "unregister_unifi_sdio: invalid device %d\n",
+ bus_id);
+ return;
+ }
+
+ priv = Unifi_instances[bus_id];
+ if (priv == NULL) {
+ unifi_error(priv, "unregister_unifi_sdio: device %d is not registered\n",
+ bus_id);
+ func_exit();
+ return;
+ }
+
+ /* Stop the network traffic before freeing the core. */
+ for(interfaceTag=0;interfaceTag<priv->totalInterfaceCount;interfaceTag++)
+ {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ if(interfacePriv->netdev_registered)
+ {
+ netif_carrier_off(priv->netdev[interfaceTag]);
+ UF_NETIF_TX_STOP_ALL_QUEUES(priv->netdev[interfaceTag]);
+ }
+ }
+
+#ifdef CSR_NATIVE_LINUX
+ /*
+ * If the unifi thread was started, signal it to stop. This
+ * should cause any userspace processes with open unifi device to
+ * close them.
+ */
+ uf_stop_thread(priv, &priv->bh_thread);
+
+ /* Unregister the interrupt handler */
+ if (csr_sdio_linux_remove_irq(priv->sdio)) {
+ unifi_notice(priv,
+ "csr_sdio_linux_remove_irq failed to talk to card.\n");
+ }
+
+ /* Ensure no MLME functions are waiting on a the mlme_event semaphore. */
+ uf_abort_mlme(priv);
+#endif /* CSR_NATIVE_LINUX */
+
+ ul_log_config_ind(priv, &reason, sizeof(u8));
+
+ /* Deregister the UDI hook from the core. */
+ unifi_remove_udi_hook(priv->card, logging_handler);
+
+ uf_put_instance(bus_id);
+
+ /*
+ * Wait until the device is cleaned up. i.e., when all userspace
+ * processes have closed any open unifi devices.
+ */
+ wait_event(Unifi_cleanup_wq, In_use[bus_id] == UNIFI_DEV_CLEANUP);
+ unifi_trace(NULL, UDBG5, "Received clean up event\n");
+
+ /* Now we can free the private context and the char device nodes */
+ cleanup_unifi_sdio(priv);
+
+} /* unregister_unifi_sdio() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_find_instance
+ *
+ * Find the context structure for a given UniFi device instance.
+ *
+ * Arguments:
+ * inst The instance number to look for.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+unifi_priv_t *
+uf_find_instance(int inst)
+{
+ if ((inst < 0) || (inst >= MAX_UNIFI_DEVS)) {
+ return NULL;
+ }
+ return Unifi_instances[inst];
+} /* uf_find_instance() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_find_priv
+ *
+ * Find the device instance for a given context structure.
+ *
+ * Arguments:
+ * priv The context structure pointer to look for.
+ *
+ * Returns:
+ * index of instance, -1 otherwise.
+ * ---------------------------------------------------------------------------
+ */
+int
+uf_find_priv(unifi_priv_t *priv)
+{
+ int inst;
+
+ if (!priv) {
+ return -1;
+ }
+
+ for (inst = 0; inst < MAX_UNIFI_DEVS; inst++) {
+ if (Unifi_instances[inst] == priv) {
+ return inst;
+ }
+ }
+
+ return -1;
+} /* uf_find_priv() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_find_netdev_priv
+ *
+ * Find the device instance for a given netdev context structure.
+ *
+ * Arguments:
+ * priv The context structure pointer to look for.
+ *
+ * Returns:
+ * index of instance, -1 otherwise.
+ * ---------------------------------------------------------------------------
+ */
+int
+uf_find_netdev_priv(netInterface_priv_t *priv)
+{
+ int inst;
+
+ if (!priv) {
+ return -1;
+ }
+
+ for (inst = 0; inst < MAX_UNIFI_DEVS * CSR_WIFI_NUM_INTERFACES; inst++) {
+ if (Unifi_netdev_instances[inst] == priv) {
+ return inst;
+ }
+ }
+
+ return -1;
+} /* uf_find_netdev_priv() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_get_instance
+ *
+ * Find the context structure for a given UniFi device instance
+ * and increment the reference count.
+ *
+ * Arguments:
+ * inst The instance number to look for.
+ *
+ * Returns:
+ * Pointer to the instance or NULL if no instance exists.
+ * ---------------------------------------------------------------------------
+ */
+unifi_priv_t *
+uf_get_instance(int inst)
+{
+ unifi_priv_t *priv;
+
+ down(&Unifi_instance_mutex);
+
+ priv = uf_find_instance(inst);
+ if (priv) {
+ priv->ref_count++;
+ }
+
+ up(&Unifi_instance_mutex);
+
+ return priv;
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_put_instance
+ *
+ * Decrement the context reference count, freeing resources and
+ * shutting down the driver when the count reaches zero.
+ *
+ * Arguments:
+ * inst The instance number to look for.
+ *
+ * Returns:
+ * Pointer to the instance or NULL if no instance exists.
+ * ---------------------------------------------------------------------------
+ */
+void
+uf_put_instance(int inst)
+{
+ unifi_priv_t *priv;
+
+ down(&Unifi_instance_mutex);
+
+ priv = uf_find_instance(inst);
+ if (priv) {
+ priv->ref_count--;
+ if (priv->ref_count == 0) {
+ ask_unifi_sdio_cleanup(priv);
+ }
+ }
+
+ up(&Unifi_instance_mutex);
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_read_proc
+ *
+ * Read method for driver node in /proc/driver/unifi0
+ *
+ * Arguments:
+ * page
+ * start
+ * offset
+ * count
+ * eof
+ * data
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+#ifdef CONFIG_PROC_FS
+static int
+uf_read_proc(char *page, char **start, off_t offset, int count,
+ int *eof, void *data)
+{
+#define UNIFI_DEBUG_TXT_BUFFER 8*1024
+ unifi_priv_t *priv;
+ int actual_amount_to_copy;
+ char *p, *orig_p;
+ CsrInt32 remain = UNIFI_DEBUG_TXT_BUFFER;
+ CsrInt32 written;
+ int i;
+
+ /*
+ * The following complex casting is in place in order to eliminate 64-bit compilation warning
+ * "cast to/from pointer from/to integer of different size"
+ */
+ priv = uf_find_instance((int)(long)data);
+ if (!priv) {
+ return 0;
+ }
+
+ p = kmalloc( UNIFI_DEBUG_TXT_BUFFER, GFP_KERNEL );
+
+ orig_p = p;
+
+ written = CsrSnprintf(p, remain, "UniFi SDIO Driver: %s %s %s\n",
+ CSR_WIFI_VERSION, __DATE__, __TIME__);
+ UNIFI_SNPRINTF_RET(p, remain, written);
+#ifdef CSR_SME_USERSPACE
+ written = CsrSnprintf(p, remain, "SME: CSR userspace ");
+ UNIFI_SNPRINTF_RET(p, remain, written);
+#ifdef CSR_SUPPORT_WEXT
+ written = CsrSnprintf(p, remain, "with WEXT support\n");
+#else
+ written = CsrSnprintf(p, remain, "\n");
+#endif /* CSR_SUPPORT_WEXT */
+ UNIFI_SNPRINTF_RET(p, remain, written);
+#endif /* CSR_SME_USERSPACE */
+#ifdef CSR_NATIVE_LINUX
+ written = CsrSnprintf(p, remain, "SME: native\n");
+ UNIFI_SNPRINTF_RET(p, remain, written);
+#endif
+
+#ifdef CSR_SUPPORT_SME
+ written = CsrSnprintf(p, remain,
+ "Firmware (ROM) build:%lu, Patch:%lu\n",
+ priv->card_info.fw_build,
+ priv->sme_versions.firmwarePatch);
+ UNIFI_SNPRINTF_RET(p, remain, written);
+#endif
+ p += unifi_print_status(priv->card, p, &remain);
+
+ written = CsrSnprintf(p, remain, "Last dbg str: %s\n",
+ priv->last_debug_string);
+ UNIFI_SNPRINTF_RET(p, remain, written);
+
+ written = CsrSnprintf(p, remain, "Last dbg16:");
+ UNIFI_SNPRINTF_RET(p, remain, written);
+ for (i = 0; i < 8; i++) {
+ written = CsrSnprintf(p, remain, " %04X",
+ priv->last_debug_word16[i]);
+ UNIFI_SNPRINTF_RET(p, remain, written);
+ }
+ written = CsrSnprintf(p, remain, "\n");
+ UNIFI_SNPRINTF_RET(p, remain, written);
+ written = CsrSnprintf(p, remain, " ");
+ UNIFI_SNPRINTF_RET(p, remain, written);
+ for (; i < 16; i++) {
+ written = CsrSnprintf(p, remain, " %04X",
+ priv->last_debug_word16[i]);
+ UNIFI_SNPRINTF_RET(p, remain, written);
+ }
+ written = CsrSnprintf(p, remain, "\n");
+ UNIFI_SNPRINTF_RET(p, remain, written);
+ *start = page;
+
+ written = UNIFI_DEBUG_TXT_BUFFER - remain;
+
+ if( offset >= written )
+ {
+ *eof = 1;
+ kfree( orig_p );
+ return(0);
+ }
+
+ if( offset + count > written )
+ {
+ actual_amount_to_copy = written - offset;
+ *eof = 1;
+ }
+ else
+ {
+ actual_amount_to_copy = count;
+ }
+
+ memcpy( page, &(orig_p[offset]), actual_amount_to_copy );
+
+ kfree( orig_p );
+
+ return( actual_amount_to_copy );
+} /* uf_read_proc() */
+#endif
+
+
+
+
+static void
+uf_lx_suspend(CsrSdioFunction *sdio_ctx)
+{
+ unifi_priv_t *priv = sdio_ctx->driverData;
+ unifi_suspend(priv);
+
+ CsrSdioSuspendAcknowledge(sdio_ctx, CSR_RESULT_SUCCESS);
+}
+
+static void
+uf_lx_resume(CsrSdioFunction *sdio_ctx)
+{
+ unifi_priv_t *priv = sdio_ctx->driverData;
+ unifi_resume(priv);
+
+ CsrSdioResumeAcknowledge(sdio_ctx, CSR_RESULT_SUCCESS);
+}
+
+static int active_slot = MAX_UNIFI_DEVS;
+static struct device *os_devices[MAX_UNIFI_DEVS];
+
+void
+uf_add_os_device(int bus_id, struct device *os_device)
+{
+ if ((bus_id < 0) || (bus_id >= MAX_UNIFI_DEVS)) {
+ unifi_error(NULL, "uf_add_os_device: invalid device %d\n",
+ bus_id);
+ return;
+ }
+
+ active_slot = bus_id;
+ os_devices[bus_id] = os_device;
+} /* uf_add_os_device() */
+
+void
+uf_remove_os_device(int bus_id)
+{
+ if ((bus_id < 0) || (bus_id >= MAX_UNIFI_DEVS)) {
+ unifi_error(NULL, "uf_remove_os_device: invalid device %d\n",
+ bus_id);
+ return;
+ }
+
+ active_slot = bus_id;
+ os_devices[bus_id] = NULL;
+} /* uf_remove_os_device() */
+
+static void
+uf_sdio_inserted(CsrSdioFunction *sdio_ctx)
+{
+ unifi_priv_t *priv;
+
+ unifi_trace(NULL, UDBG5, "uf_sdio_inserted(0x%p), slot_id=%d, dev=%p\n",
+ sdio_ctx, active_slot, os_devices[active_slot]);
+
+ priv = register_unifi_sdio(sdio_ctx, active_slot, os_devices[active_slot]);
+ if (priv == NULL) {
+ CsrSdioInsertedAcknowledge(sdio_ctx, CSR_RESULT_FAILURE);
+ return;
+ }
+
+ sdio_ctx->driverData = priv;
+
+ CsrSdioInsertedAcknowledge(sdio_ctx, CSR_RESULT_SUCCESS);
+} /* uf_sdio_inserted() */
+
+
+static void
+uf_sdio_removed(CsrSdioFunction *sdio_ctx)
+{
+ unregister_unifi_sdio(active_slot);
+ CsrSdioRemovedAcknowledge(sdio_ctx);
+} /* uf_sdio_removed() */
+
+
+static void
+uf_sdio_dsr_handler(CsrSdioFunction *sdio_ctx)
+{
+ unifi_priv_t *priv = sdio_ctx->driverData;
+
+ unifi_sdio_interrupt_handler(priv->card);
+} /* uf_sdio_dsr_handler() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_sdio_int_handler
+ *
+ * Interrupt callback function for SDIO interrupts.
+ * This is called in kernel context (i.e. not interrupt context).
+ * We retrieve the unifi context pointer and call the main UniFi
+ * interrupt handler.
+ *
+ * Arguments:
+ * fdev SDIO context pointer
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static CsrSdioInterruptDsrCallback
+uf_sdio_int_handler(CsrSdioFunction *sdio_ctx)
+{
+ return uf_sdio_dsr_handler;
+} /* uf_sdio_int_handler() */
+
+
+
+
+static CsrSdioFunctionId unifi_ids[] =
+{
+ {
+ .manfId = SDIO_MANF_ID_CSR,
+ .cardId = SDIO_CARD_ID_UNIFI_3,
+ .sdioFunction = SDIO_WLAN_FUNC_ID_UNIFI_3,
+ .sdioInterface = CSR_SDIO_ANY_SDIO_INTERFACE,
+ },
+ {
+ .manfId = SDIO_MANF_ID_CSR,
+ .cardId = SDIO_CARD_ID_UNIFI_4,
+ .sdioFunction = SDIO_WLAN_FUNC_ID_UNIFI_4,
+ .sdioInterface = CSR_SDIO_ANY_SDIO_INTERFACE,
+ }
+};
+
+
+/*
+ * Structure to register with the glue layer.
+ */
+static CsrSdioFunctionDriver unifi_sdioFunction_drv =
+{
+ .inserted = uf_sdio_inserted,
+ .removed = uf_sdio_removed,
+ .intr = uf_sdio_int_handler,
+ .suspend = uf_lx_suspend,
+ .resume = uf_lx_resume,
+
+ .ids = unifi_ids,
+ .idsCount = sizeof(unifi_ids) / sizeof(unifi_ids[0])
+};
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_sdio_load
+ * uf_sdio_unload
+ *
+ * These functions are called from the main module load and unload
+ * functions. They perform the appropriate operations for the monolithic
+ * driver.
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+int __init
+uf_sdio_load(void)
+{
+ CsrResult csrResult;
+
+ csrResult = CsrSdioFunctionDriverRegister(&unifi_sdioFunction_drv);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(NULL, "Failed to register UniFi SDIO driver: csrResult=%d\n", csrResult);
+ return -EIO;
+ }
+
+ return 0;
+} /* uf_sdio_load() */
+
+
+
+void __exit
+uf_sdio_unload(void)
+{
+ CsrSdioFunctionDriverUnregister(&unifi_sdioFunction_drv);
+} /* uf_sdio_unload() */
+
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: mlme.c
+ *
+ * PURPOSE:
+ * This file provides functions to send MLME requests to the UniFi.
+ *
+ * Copyright (C) 2007-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "unifi_priv.h"
+
+
+/* The additional time taken by the UniFi to do a scan per channel */
+#define SCAN_STARTUP_TIME 300 /* in millisecs */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_mlme_wait_for_reply
+ *
+ * Wait for a reply after sending a signal.
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * ul_client Pointer to linux client
+ * sig_reply_id ID of the expected reply (defined in sigs.h).
+ * timeout timeout in ms
+ *
+ * Returns:
+ * 0 on success, -ve POSIX code on error.
+ *
+ * Notes:
+ * This function waits for a specific (sig_reply_id) signal from UniFi.
+ * It also match the sequence number of the received (cfm) signal, with
+ * the latest sequence number of the signal (req) we have sent.
+ * These two number match be equal.
+ * Should only be used for waiting xxx.cfm signals and only after
+ * we have sent the matching xxx.req signal to UniFi.
+ * If no response is received within the expected time (timeout), we assume
+ * that the UniFi is busy and return an error.
+ * If the wait is aborted by a kernel signal arriving, we stop waiting.
+ * If a response from UniFi is not what we expected, we discard it and
+ * wait again. This could be a response from an aborted request. If we
+ * see several bad responses we assume we have lost synchronisation with
+ * UniFi.
+ * ---------------------------------------------------------------------------
+ */
+static int
+unifi_mlme_wait_for_reply(unifi_priv_t *priv, ul_client_t *pcli, int sig_reply_id, int timeout)
+{
+ int retries = 0;
+ long r;
+ long t = timeout;
+ unsigned int sent_seq_no;
+
+ /* Convert t in ms to jiffies */
+ t = msecs_to_jiffies(t);
+
+ do {
+ /* Wait for the confirm or timeout. */
+ r = wait_event_interruptible_timeout(pcli->udi_wq,
+ (pcli->wake_up_wq_id) || (priv->io_aborted == 1),
+ t);
+ /* Check for general i/o error */
+ if (priv->io_aborted) {
+ unifi_error(priv, "MLME operation aborted\n");
+ return -EIO;
+ }
+
+ /*
+ * If r=0 the request has timed-out.
+ * If r>0 the request has completed successfully.
+ * If r=-ERESTARTSYS an event (kill signal) has interrupted the wait_event.
+ */
+ if ((r == 0) && (pcli->wake_up_wq_id == 0)) {
+ unifi_error(priv, "mlme_wait: timed-out waiting for 0x%.4X, after %lu msec.\n",
+ sig_reply_id, jiffies_to_msecs(t));
+ pcli->wake_up_wq_id = 0;
+ return -ETIMEDOUT;
+ } else if (r == -ERESTARTSYS) {
+ unifi_error(priv, "mlme_wait: waiting for 0x%.4X was aborted.\n", sig_reply_id);
+ pcli->wake_up_wq_id = 0;
+ return -EINTR;
+ } else {
+ /* Get the sequence number of the signal that we previously set. */
+ if (pcli->seq_no != 0) {
+ sent_seq_no = pcli->seq_no - 1;
+ } else {
+ sent_seq_no = 0x0F;
+ }
+
+ unifi_trace(priv, UDBG5, "Received 0x%.4X, seq: (r:%d, s:%d)\n",
+ pcli->wake_up_wq_id,
+ pcli->wake_seq_no, sent_seq_no);
+
+ /* The two sequence ids must match. */
+ if (pcli->wake_seq_no == sent_seq_no) {
+ /* and the signal ids must match. */
+ if (sig_reply_id == pcli->wake_up_wq_id) {
+ /* Found the expected signal */
+ break;
+ } else {
+ /* This should never happen ... */
+ unifi_error(priv, "mlme_wait: mismatching signal id (0x%.4X - exp 0x%.4X) (seq %d)\n",
+ pcli->wake_up_wq_id,
+ sig_reply_id,
+ pcli->wake_seq_no);
+ pcli->wake_up_wq_id = 0;
+ return -EIO;
+ }
+ }
+ /* Wait for the next signal. */
+ pcli->wake_up_wq_id = 0;
+
+ retries ++;
+ if (retries >= 3) {
+ unifi_error(priv, "mlme_wait: confirm wait retries exhausted (0x%.4X - exp 0x%.4X)\n",
+ pcli->wake_up_wq_id,
+ sig_reply_id);
+ pcli->wake_up_wq_id = 0;
+ return -EIO;
+ }
+ }
+ } while (1);
+
+ pcli->wake_up_wq_id = 0;
+
+ return 0;
+} /* unifi_mlme_wait_for_reply() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_mlme_blocking_request
+ *
+ * Send a MLME request signal to UniFi.
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * pcli Pointer to context of calling process
+ * sig Pointer to the signal to send
+ * data_ptrs Pointer to the bulk data of the signal
+ * timeout The request's timeout.
+ *
+ * Returns:
+ * 0 on success, 802.11 result code on error.
+ * ---------------------------------------------------------------------------
+ */
+int
+unifi_mlme_blocking_request(unifi_priv_t *priv, ul_client_t *pcli,
+ CSR_SIGNAL *sig, bulk_data_param_t *data_ptrs,
+ int timeout)
+{
+ int r;
+
+ func_enter();
+
+ if (sig->SignalPrimitiveHeader.SignalId == 0) {
+ unifi_error(priv, "unifi_mlme_blocking_request: Invalid Signal Id (0x%x)\n",
+ sig->SignalPrimitiveHeader.SignalId);
+ return -EINVAL;
+ }
+
+ down(&priv->mlme_blocking_mutex);
+
+ sig->SignalPrimitiveHeader.ReceiverProcessId = 0;
+ sig->SignalPrimitiveHeader.SenderProcessId = pcli->sender_id | pcli->seq_no;
+
+ unifi_trace(priv, UDBG2, "Send client=%d, S:0x%04X, sig 0x%.4X\n",
+ pcli->client_id,
+ sig->SignalPrimitiveHeader.SenderProcessId,
+ sig->SignalPrimitiveHeader.SignalId);
+ /* Send the signal to UniFi */
+ r = ul_send_signal_unpacked(priv, sig, data_ptrs);
+ if (r) {
+ up(&priv->mlme_blocking_mutex);
+ unifi_error(priv, "Error queueing MLME REQUEST signal\n");
+ return r;
+ }
+
+ unifi_trace(priv, UDBG5, "Send 0x%.4X, seq = %d\n",
+ sig->SignalPrimitiveHeader.SignalId, pcli->seq_no);
+
+ /*
+ * Advance the sequence number of the last sent signal, only
+ * if the signal has been successfully set.
+ */
+ pcli->seq_no++;
+ if (pcli->seq_no > 0x0F) {
+ pcli->seq_no = 0;
+ }
+
+ r = unifi_mlme_wait_for_reply(priv, pcli, (sig->SignalPrimitiveHeader.SignalId + 1), timeout);
+ up(&priv->mlme_blocking_mutex);
+
+ if (r) {
+ unifi_error(priv, "Error waiting for MLME CONFIRM signal\n");
+ return r;
+ }
+
+ func_exit();
+ return 0;
+} /* unifi_mlme_blocking_request() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_mlme_copy_reply_and_wakeup_client
+ *
+ * Copy the reply signal from UniFi to the client's structure
+ * and wake up the waiting client.
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+unifi_mlme_copy_reply_and_wakeup_client(ul_client_t *pcli,
+ CSR_SIGNAL *signal, int signal_len,
+ const bulk_data_param_t *bulkdata)
+{
+ int i;
+
+ /* Copy the signal to the reply */
+ memcpy(pcli->reply_signal, signal, signal_len);
+
+ /* Get the sequence number of the signal that woke us up. */
+ pcli->wake_seq_no = pcli->reply_signal->SignalPrimitiveHeader.ReceiverProcessId & 0x0F;
+
+ /* Append any bulk data */
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
+ if (bulkdata->d[i].data_length > 0) {
+ if (bulkdata->d[i].os_data_ptr) {
+ memcpy(pcli->reply_bulkdata[i]->ptr, bulkdata->d[i].os_data_ptr, bulkdata->d[i].data_length);
+ pcli->reply_bulkdata[i]->length = bulkdata->d[i].data_length;
+ } else {
+ pcli->reply_bulkdata[i]->length = 0;
+ }
+ }
+ }
+
+ /* Wake the requesting MLME function. */
+ pcli->wake_up_wq_id = pcli->reply_signal->SignalPrimitiveHeader.SignalId;
+ wake_up_interruptible(&pcli->udi_wq);
+
+} /* unifi_mlme_copy_reply_and_wakeup_client() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_abort_mlme
+ *
+ * Abort any MLME operation in progress.
+ * This is used in the error recovery mechanism.
+ *
+ * Arguments:
+ * priv Pointer to driver context.
+ *
+ * Returns:
+ * 0 on success.
+ * ---------------------------------------------------------------------------
+ */
+int
+uf_abort_mlme(unifi_priv_t *priv)
+{
+ ul_client_t *ul_cli;
+
+ /* Ensure no MLME functions are waiting on a the mlme_event semaphore. */
+ priv->io_aborted = 1;
+
+ ul_cli = priv->netdev_client;
+ if (ul_cli) {
+ wake_up_interruptible(&ul_cli->udi_wq);
+ }
+
+ ul_cli = priv->wext_client;
+ if (ul_cli) {
+ wake_up_interruptible(&ul_cli->udi_wq);
+ }
+
+ return 0;
+} /* uf_abort_mlme() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * Human-readable decoding of Reason and Result codes.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+struct mlme_code {
+ const char *name;
+ int id;
+};
+
+static const struct mlme_code Result_codes[] = {
+ { "Success", 0x0000 },
+ { "Unspecified Failure", 0x0001 },
+ /* (Reserved) 0x0002 - 0x0009 */
+ { "Refused Capabilities Mismatch", 0x000A },
+ /* (Reserved) 0x000B */
+ { "Refused External Reason", 0x000C },
+ /* (Reserved) 0x000D - 0x0010 */
+ { "Refused AP Out Of Memory", 0x0011 },
+ { "Refused Basic Rates Mismatch", 0x0012 },
+ /* (Reserved) 0x0013 - 0x001F */
+ { "Failure", 0x0020 },
+ /* (Reserved) 0x0021 - 0x0024 */
+ { "Refused Reason Unspecified", 0x0025 },
+ { "Invalid Parameters", 0x0026 },
+ { "Rejected With Suggested Changes", 0x0027 },
+ /* (Reserved) 0x0028 - 0x002E */
+ { "Rejected For Delay Period", 0x002F },
+ { "Not Allowed", 0x0030 },
+ { "Not Present", 0x0031 },
+ { "Not QSTA", 0x0032 },
+ /* (Reserved) 0x0033 - 0x7FFF */
+ { "Timeout", 0x8000 },
+ { "Too Many Simultaneous Requests", 0x8001 },
+ { "BSS Already Started Or Joined", 0x8002 },
+ { "Not Supported", 0x8003 },
+ { "Transmission Failure", 0x8004 },
+ { "Refused Not Authenticated", 0x8005 },
+ { "Reset Required Before Start", 0x8006 },
+ { "LM Info Unavailable", 0x8007 },
+ { NULL, -1 }
+};
+
+static const struct mlme_code Reason_codes[] = {
+ /* (Reserved) 0x0000 */
+ { "Unspecified Reason", 0x0001 },
+ { "Authentication Not Valid", 0x0002 },
+ { "Deauthenticated Leave BSS", 0x0003 },
+ { "Disassociated Inactivity", 0x0004 },
+ { "AP Overload", 0x0005 },
+ { "Class2 Frame Error", 0x0006 },
+ { "Class3 Frame Error", 0x0007 },
+ { "Disassociated Leave BSS", 0x0008 },
+ { "Association Not Authenticated", 0x0009 },
+ { "Disassociated Power Capability", 0x000A },
+ { "Disassociated Supported Channels", 0x000B },
+ /* (Reserved) 0x000C */
+ { "Invalid Information Element", 0x000D },
+ { "Michael MIC Failure", 0x000E },
+ { "Fourway Handshake Timeout", 0x000F },
+ { "Group Key Update Timeout", 0x0010 },
+ { "Handshake Element Different", 0x0011 },
+ { "Invalid Group Cipher", 0x0012 },
+ { "Invalid Pairwise Cipher", 0x0013 },
+ { "Invalid AKMP", 0x0014 },
+ { "Unsupported RSN IE Version", 0x0015 },
+ { "Invalid RSN IE Capabilities", 0x0016 },
+ { "Dot1X Auth Failed", 0x0017 },
+ { "Cipher Rejected By Policy", 0x0018 },
+ /* (Reserved) 0x0019 - 0x001F */
+ { "QoS Unspecified Reason", 0x0020 },
+ { "QoS Insufficient Bandwidth", 0x0021 },
+ { "QoS Excessive Not Ack", 0x0022 },
+ { "QoS TXOP Limit Exceeded", 0x0023 },
+ { "QSTA Leaving", 0x0024 },
+ { "End TS, End DLS, End BA", 0x0025 },
+ { "Unknown TS, Unknown DLS, Unknown BA", 0x0026 },
+ { "Timeout", 0x0027 },
+ /* (Reserved) 0x0028 - 0x002C */
+ { "STAKey Mismatch", 0x002D },
+ { NULL, -1 }
+};
+
+
+static const char *
+lookup_something(const struct mlme_code *n, int id)
+{
+ for (; n->name; n++) {
+ if (n->id == id) {
+ return n->name;
+ }
+ }
+
+ /* not found */
+ return NULL;
+} /* lookup_something() */
+
+
+const char *
+lookup_result_code(int result)
+{
+ static char fallback[16];
+ const char *str;
+
+ str = lookup_something(Result_codes, result);
+
+ if (str == NULL) {
+ snprintf(fallback, 16, "%d", result);
+ str = fallback;
+ }
+
+ return str;
+} /* lookup_result_code() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * lookup_reason
+ *
+ * Return a description string for a WiFi MLME ReasonCode.
+ *
+ * Arguments:
+ * reason The ReasonCode to interpret.
+ *
+ * Returns:
+ * Pointer to description string.
+ * ---------------------------------------------------------------------------
+ */
+const char *
+lookup_reason_code(int reason)
+{
+ static char fallback[16];
+ const char *str;
+
+ str = lookup_something(Reason_codes, reason);
+
+ if (str == NULL) {
+ snprintf(fallback, 16, "%d", reason);
+ str = fallback;
+ }
+
+ return str;
+} /* lookup_reason_code() */
+
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: monitor.c
+ *
+ * Copyright (C) 2006-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+#include "unifi_priv.h"
+
+#ifdef UNIFI_SNIFF_ARPHRD
+
+
+#if (UNIFI_SNIFF_ARPHRD == ARPHRD_IEEE80211_RADIOTAP)
+#include <net/ieee80211_radiotap.h>
+#endif
+
+#ifndef ETH_P_80211_RAW
+#define ETH_P_80211_RAW ETH_P_ALL
+#endif
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_start_sniff
+ *
+ * Start UniFi capture in SNIFF mode, i.e capture everything it hears.
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ *
+ * Returns:
+ * 0 on success or kernel error code
+ * ---------------------------------------------------------------------------
+ */
+int
+uf_start_sniff(unifi_priv_t *priv)
+{
+ ul_client_t *pcli = priv->wext_client;
+ CSR_SIGNAL signal;
+ CSR_MLME_SNIFFJOIN_REQUEST *req = &signal.u.MlmeSniffjoinRequest;
+ int timeout = 1000;
+ int r;
+
+ req->Ifindex = priv->if_index;
+ req->Channel = priv->wext_conf.channel;
+ req->ChannelStartingFactor = 0;
+
+#if 0
+ printk("SniffJoin: Ifindex=%d, Channel=%d, ChannelStartingFactor=%d\n",
+ req->Ifindex,
+ req->Channel,
+ req->ChannelStartingFactor);
+#endif
+
+ signal.SignalPrimitiveHeader.SignalId = CSR_MLME_SNIFFJOIN_REQUEST_ID;
+
+ r = unifi_mlme_blocking_request(priv, pcli, &signal, NULL, timeout);
+ if (r < 0) {
+ unifi_error(priv, "failed to send SNIFFJOIN request, error %d\n", r);
+ return r;
+ }
+
+ r = pcli->reply_signal->u.MlmeSniffjoinConfirm.Resultcode;
+ if (r) {
+ unifi_notice(priv, "SNIFFJOIN request was rejected with result 0x%X (%s)\n",
+ r, lookup_result_code(r));
+ return -EIO;
+ }
+
+ return 0;
+} /* uf_start_sniff() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * netrx_radiotap
+ *
+ * Reformat a UniFi SNIFFDATA signal into a radiotap packet.
+ *
+ * Arguments:
+ * priv OS private context pointer.
+ * ind Pointer to a MA_UNITDATA_INDICATION or
+ * DS_UNITDATA_INDICATION indication structure.
+ *
+ * Notes:
+ * Radiotap header values are all little-endian, UniFi signals will have
+ * been converted to host-endian.
+ * ---------------------------------------------------------------------------
+ */
+#if (UNIFI_SNIFF_ARPHRD == ARPHRD_IEEE80211_RADIOTAP)
+static void
+netrx_radiotap(unifi_priv_t *priv,
+ const CSR_MA_SNIFFDATA_INDICATION *ind,
+ struct sk_buff *skb_orig)
+{
+ struct net_device *dev = priv->netdev;
+ struct sk_buff *skb = NULL;
+ unsigned char *ptr;
+ unsigned char *base;
+ int ind_data_len = skb_orig->len - 2 - ETH_HLEN;
+ struct unifi_rx_radiotap_header {
+ struct ieee80211_radiotap_header rt_hdr;
+ /* IEEE80211_RADIOTAP_TSFT */
+ u64 rt_tsft;
+ /* IEEE80211_RADIOTAP_FLAGS */
+ u8 rt_flags;
+ /* IEEE80211_RADIOTAP_RATE */
+ u8 rt_rate;
+ /* IEEE80211_RADIOTAP_CHANNEL */
+ u16 rt_chan;
+ u16 rt_chan_flags;
+ /* IEEE80211_RADIOTAP_DBM_ANTSIGNAL */
+ u8 rt_dbm_antsignal;
+ /* IEEE80211_RADIOTAP_DBM_ANTNOISE */
+ u8 rt_dbm_antnoise;
+ /* IEEE80211_RADIOTAP_ANTENNA */
+ u8 rt_antenna;
+
+ /* pad to 4-byte boundary */
+ u8 pad[3];
+ } __attribute__((__packed__));
+
+ struct unifi_rx_radiotap_header *unifi_rt;
+ int signal, noise, snr;
+
+ func_enter();
+
+ if (ind_data_len <= 0) {
+ unifi_error(priv, "Invalid length in CSR_MA_SNIFFDATA_INDICATION.\n");
+ return;
+ }
+
+ /*
+ * Allocate a SKB for the received data packet, including radiotap
+ * header.
+ */
+ skb = dev_alloc_skb(ind_data_len + sizeof(struct unifi_rx_radiotap_header) + 4);
+ if (! skb) {
+ unifi_error(priv, "alloc_skb failed.\n");
+ priv->stats.rx_errors++;
+ return;
+ }
+
+ base = skb->data;
+
+ /* Reserve the radiotap header at the front of skb */
+ unifi_rt = (struct unifi_rx_radiotap_header *)
+ skb_put(skb, sizeof(struct unifi_rx_radiotap_header));
+
+ /* Copy in the 802.11 frame */
+ ptr = skb_put(skb, ind_data_len);
+ memcpy(ptr, skb_orig->data, ind_data_len);
+
+ unifi_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
+ unifi_rt->rt_hdr.it_pad = 0; /* always good to zero */
+ unifi_rt->rt_hdr.it_len = sizeof(struct unifi_rx_radiotap_header);
+
+ /* Big bitfield of all the fields we provide in radiotap */
+ unifi_rt->rt_hdr.it_present = 0
+ | (1 << IEEE80211_RADIOTAP_TSFT)
+ | (1 << IEEE80211_RADIOTAP_FLAGS)
+ | (1 << IEEE80211_RADIOTAP_RATE)
+ | (1 << IEEE80211_RADIOTAP_CHANNEL)
+ | (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL)
+ | (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE)
+ | (1 << IEEE80211_RADIOTAP_ANTENNA)
+ ;
+
+
+ /* No flags to set */
+ unifi_rt->rt_tsft = (((u64)ind->Timestamp.x[7]) | (((u64)ind->Timestamp.x[6]) << 8) |
+ (((u64)ind->Timestamp.x[5]) << 16) | (((u64)ind->Timestamp.x[4]) << 24) |
+ (((u64)ind->Timestamp.x[3]) << 32) | (((u64)ind->Timestamp.x[2]) << 40) |
+ (((u64)ind->Timestamp.x[1]) << 48) | (((u64)ind->Timestamp.x[0]) << 56));
+
+ unifi_rt->rt_flags = 0;
+
+ unifi_rt->rt_rate = ind->Rate;
+
+ unifi_rt->rt_chan = cpu_to_le16(ieee80211chan2mhz(priv->wext_conf.channel));
+ unifi_rt->rt_chan_flags = 0;
+
+ /* Convert signal to dBm */
+ signal = (s16)unifi2host_16(ind->Rssi); /* in dBm */
+ snr = (s16)unifi2host_16(ind->Snr); /* in dB */
+ noise = signal - snr;
+
+ unifi_rt->rt_dbm_antsignal = signal;
+ unifi_rt->rt_dbm_antnoise = noise;
+
+ unifi_rt->rt_antenna = ind->AntennaId;
+
+
+#if 0
+ printk("skb datalen=%d\n", skb->len);
+ dump(skb->data, 48);
+#endif
+
+ skb->dev = dev;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
+ skb->mac_header = skb->data;
+#else
+ skb->mac.raw = skb->data;
+#endif
+ skb->pkt_type = PACKET_OTHERHOST;
+ skb->protocol = __constant_htons(ETH_P_80211_RAW);
+ memset(skb->cb, 0, sizeof(skb->cb));
+
+ /* Pass up to Linux network stack */
+ netif_rx_ni(skb);
+
+ dev->last_rx = jiffies;
+
+ /* Bump the rx stats */
+ priv->stats.rx_packets++;
+ priv->stats.rx_bytes += ind_data_len;
+
+ func_exit();
+} /* netrx_radiotap() */
+#endif /* RADIOTAP */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * netrx_prism
+ *
+ * Reformat a UniFi SNIFFDATA signal into a Prism format sniff packet.
+ *
+ * Arguments:
+ * priv OS private context pointer.
+ * ind Pointer to a MA_UNITDATA_INDICATION or
+ * DS_UNITDATA_INDICATION indication structure.
+ *
+ * Notes:
+ * Radiotap header values are all little-endian, UniFi signals will have
+ * been converted to host-endian.
+ * ---------------------------------------------------------------------------
+ */
+#if (UNIFI_SNIFF_ARPHRD == ARPHRD_IEEE80211_PRISM)
+static void
+netrx_prism(unifi_priv_t *priv,
+ const CSR_MA_SNIFFDATA_INDICATION *ind,
+ struct sk_buff *skb_orig)
+{
+ struct net_device *dev = priv->netdev;
+ struct sk_buff *skb = NULL;
+ unsigned char *ptr;
+ unsigned char *base;
+ int ind_data_len = skb_orig->len - 2 - ETH_HLEN;
+#define WLANCAP_MAGIC_COOKIE_BASE 0x80211000
+#define WLANCAP_MAGIC_COOKIE_V1 0x80211001
+#define WLANCAP_MAGIC_COOKIE_V2 0x80211002
+ struct avs_header_v1 {
+ uint32 version;
+ uint32 length;
+ uint64 mactime;
+ uint64 hosttime;
+ uint32 phytype;
+ uint32 channel;
+ uint32 datarate;
+ uint32 antenna;
+ uint32 priority;
+ uint32 ssi_type;
+ int32 ssi_signal;
+ int32 ssi_noise;
+ uint32 preamble;
+ uint32 encoding;
+ } *avs;
+ int signal, noise, snr;
+
+ func_enter();
+
+ if (ind_data_len <= 0) {
+ unifi_error(priv, "Invalid length in CSR_MA_SNIFFDATA_INDICATION.\n");
+ return;
+ }
+
+#if 0
+ printk("MA-SINFFDATA.ind: DataLen=%d bytes, TSF %02X %02X %02X %02X %02X %02X %02X %02X, Rate=%d, Antenna=%d\n",
+ ind->Data.DataLength,
+ ind->Timestamp.x[0],
+ ind->Timestamp.x[1],
+ ind->Timestamp.x[2],
+ ind->Timestamp.x[3],
+ ind->Timestamp.x[4],
+ ind->Timestamp.x[5],
+ ind->Timestamp.x[6],
+ ind->Timestamp.x[7],
+ ind->Rate,
+ ind->Antenna);
+
+ printk("payload, len %d\n", length);
+ dump((unsigned char *)payload, 32);
+#endif
+
+ /*
+ * Allocate a SKB for the received data packet, including radiotap
+ * header.
+ */
+ skb = dev_alloc_skb(ind_data_len + sizeof(struct avs_header_v1) + 4);
+ if (! skb) {
+ unifi_error(priv, "alloc_skb failed.\n");
+ priv->stats.rx_errors++;
+ return;
+ }
+
+ base = skb->data;
+
+ /* Reserve the radiotap header at the front of skb */
+ avs = (struct avs_header_v1 *)skb_put(skb, sizeof(struct avs_header_v1));
+
+ /* Copy in the 802.11 frame */
+ ptr = skb_put(skb, ind_data_len);
+ memcpy(ptr, skb_orig->data, ind_data_len);
+
+ /* Convert signal to dBm */
+ signal = 0x10000 - ((s16)unifi2host_16(ind->Rssi)); /* in dBm */
+ snr = (s16)unifi2host_16(ind->Snr); /* in dB */
+ noise = signal - snr;
+
+ avs->version = htonl(WLANCAP_MAGIC_COOKIE_V1);
+ avs->length = htonl(sizeof(struct avs_header_v1));
+ avs->mactime = __cpu_to_be64(ind->Timestamp);
+ avs->hosttime = __cpu_to_be64(jiffies);
+ avs->phytype = htonl(9); /* dss_ofdm_dot11_g */
+ avs->channel = htonl(priv->wext_conf.channel);
+ avs->datarate = htonl(ind->Rate * 5);
+ avs->antenna = htonl(ind->Antenna);
+ avs->priority = htonl(0); /* unknown */
+ avs->ssi_type = htonl(2); /* dBm */
+ avs->ssi_signal = htonl(signal);
+ avs->ssi_noise = htonl(noise);
+ avs->preamble = htonl(0); /* unknown */
+ avs->encoding = htonl(0); /* unknown */
+
+
+#if 0
+ printk("skb datalen=%d\n", skb->len);
+ dump(skb->data, 48);
+#endif
+
+ skb->dev = dev;
+ skb->mac.raw = skb->data;
+ skb->pkt_type = PACKET_OTHERHOST;
+ skb->protocol = __constant_htons(ETH_P_80211_RAW);
+ memset(skb->cb, 0, sizeof(skb->cb));
+
+ /* Pass up to Linux network stack */
+ netif_rx_ni(skb);
+
+ dev->last_rx = jiffies;
+
+ /* Bump the rx stats */
+ priv->stats.rx_packets++;
+ priv->stats.rx_bytes += ind_data_len;
+
+ func_exit();
+} /* netrx_prism() */
+#endif /* PRISM */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * ma_sniffdata_ind
+ *
+ * Reformat a UniFi SNIFFDATA signal into a network
+ *
+ * Arguments:
+ * ospriv OS private context pointer.
+ * ind Pointer to a MA_UNITDATA_INDICATION or
+ * DS_UNITDATA_INDICATION indication structure.
+ * bulkdata Pointer to a bulk data structure, describing
+ * the data received.
+ *
+ * Notes:
+ * Radiotap header values are all little-endian, UniFi signals will have
+ * been converted to host-endian.
+ * ---------------------------------------------------------------------------
+ */
+void
+ma_sniffdata_ind(void *ospriv,
+ const CSR_MA_SNIFFDATA_INDICATION *ind,
+ const bulk_data_param_t *bulkdata)
+{
+ unifi_priv_t *priv = ospriv;
+ struct net_device *dev = priv->netdev;
+ struct sk_buff *skb = (struct sk_buff*)bulkdata->d[0].os_net_buf_ptr;
+
+ func_enter();
+
+ if (bulkdata->d[0].data_length == 0) {
+ unifi_warning(priv, "rx: MA-SNIFFDATA indication with zero bulk data\n");
+ func_exit();
+ return;
+ }
+
+ skb->len = bulkdata->d[0].data_length;
+#if 0
+ printk("MA-SNIFFDATA.ind: DataLen=%d bytes, TSF %02X %02X %02X %02X %02X %02X %02X %02X, Rate=%d, Antenna=%d\n",
+ ind->Data.DataLength,
+ ind->Timestamp.x[0],
+ ind->Timestamp.x[1],
+ ind->Timestamp.x[2],
+ ind->Timestamp.x[3],
+ ind->Timestamp.x[4],
+ ind->Timestamp.x[5],
+ ind->Timestamp.x[6],
+ ind->Timestamp.x[7],
+ ind->Rate,
+ ind->AntennaId);
+
+ printk("payload, len %lu\n", bulkdata->d[0].data_length);
+ if (bulkdata->d[0].os_data_ptr && (bulkdata->d[0].data_length >= 32)) {
+ dump((unsigned char *)bulkdata->d[0].os_data_ptr, 32);
+ }
+#endif
+
+ /* We only process data packets if the interface is open */
+ if (unlikely(!netif_running(dev))) {
+ priv->stats.rx_dropped++;
+ priv->wext_conf.wireless_stats.discard.misc++;
+#if 0
+ printk("Dropping packet while interface is not up.\n");
+#endif
+ dev_kfree_skb(skb);
+ return;
+ }
+
+ if (ind->ReceptionStatus) {
+ priv->stats.rx_dropped++;
+ priv->wext_conf.wireless_stats.discard.misc++;
+ printk(KERN_INFO "unifi: Dropping corrupt sniff packet\n");
+ dev_kfree_skb(skb);
+ return;
+ }
+
+#if (UNIFI_SNIFF_ARPHRD == ARPHRD_IEEE80211_PRISM)
+ netrx_prism(priv, ind, skb);
+#endif /* PRISM */
+
+#if (UNIFI_SNIFF_ARPHRD == ARPHRD_IEEE80211_RADIOTAP)
+ netrx_radiotap(priv, ind, skb);
+#endif /* RADIOTAP */
+
+ dev_kfree_skb(skb);
+
+} /* ma_sniffdata_ind() */
+
+
+#endif /* UNIFI_SNIFF_ARPHRD */
+
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: netdev.c
+ *
+ * PURPOSE:
+ * This file provides the upper edge interface to the linux netdevice
+ * and wireless extensions.
+ * It is part of the porting exercise.
+ *
+ * Copyright (C) 2005-2010 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+
+/*
+ * Porting Notes:
+ * This file implements the data plane of the UniFi linux driver.
+ *
+ * All the Tx packets are passed to the HIP core lib, using the
+ * unifi_send_signal() API. For EAPOL packets use the MLME-EAPOL.req
+ * signal, for all other use the MLME-UNITDATA.req. The unifi_send_signal()
+ * expects the wire-formatted (packed) signal. For convenience, in the OS
+ * layer we only use the native (unpacked) signal structures. The HIP core lib
+ * provides the write_pack() helper function to convert to the packed signal.
+ * The packet is stored in the bulk data of the signal. We do not need to
+ * allocate new memory to store the packet, because unifi_net_data_malloc()
+ * is implemented to return a skb, which is the format of packet in Linux.
+ * The HIP core lib frees the bulk data buffers, so we do not need to do
+ * this in the OS layer.
+ *
+ * All the Rx packets are MLME-UNITDATA.ind signals, passed by the HIP core lib
+ * in unifi_receive_event(). We do not need to allocate an skb and copy the
+ * received packet because the HIP core lib has stored in memory allocated by
+ * unifi_net_data_malloc(). Also, we can perform the 802.11 to Ethernet
+ * translation in-place because we allocate the extra memory allocated in
+ * unifi_net_data_malloc().
+ *
+ * If possible, the porting exercise should appropriately implement
+ * unifi_net_data_malloc() and unifi_net_data_free() to save copies between
+ * network and driver buffers.
+ */
+
+#include <linux/types.h>
+#include <linux/etherdevice.h>
+#include <linux/mutex.h>
+#include <linux/semaphore.h>
+
+#include <linux/vmalloc.h>
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_conversions.h"
+#include "unifi_priv.h"
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,13)
+#include <net/iw_handler.h>
+#endif
+#include <net/pkt_sched.h>
+
+
+/* ALLOW_Q_PAUSE: Pre 2.6.28 kernels do not support multiple driver queues (required for QoS).
+ * In order to support QoS in these kernels, multiple queues are implemented in the driver. But since
+ * there is only a single queue in the kernel (leading to multiple queues in the driver) there is no possibility
+ * of stopping a particular queue in the kernel. Stopping the single kernel queue leads to undesirable starvation
+ * of driver queues. One of the proposals is to not stop the kernel queue but to prevent dequeuing from the
+ * 'stopped' driver queue. Allow q pause is an experimental implementation of this scheme for pre 2.6.28 kernels.
+ * When NOT defined, queues are paused locally in the driver and packets are dequeued for transmission only from the
+ * unpaused queues. When Allow q pause is defined the kernel queue is stopped whenever any driver queue is paused.
+ */
+#define ALLOW_Q_PAUSE
+
+#define ieee2host16(n) __le16_to_cpu(n)
+#define ieee2host32(n) __le32_to_cpu(n)
+#define host2ieee16(n) __cpu_to_le16(n)
+#define host2ieee32(n) __cpu_to_le32(n)
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+#ifdef UNIFI_NET_NAME
+#define UF_ALLOC_NETDEV(_dev, _size, _name, _setup, _num_of_queues) \
+ do { \
+ static char name[8]; \
+ sprintf(name, "%s%s", UNIFI_NET_NAME, _name); \
+ _dev = alloc_netdev_mq(_size, name, _setup, _num_of_queues); \
+ } while (0);
+#else
+#define UF_ALLOC_NETDEV(_dev, _size, _name, _setup, _num_of_queues) \
+ do { \
+ _dev = alloc_etherdev_mq(_size, _num_of_queues); \
+ } while (0);
+#endif /* UNIFI_NET_NAME */
+#else
+#ifdef UNIFI_NET_NAME
+#define UF_ALLOC_NETDEV(_dev, _size, _name, _setup, _num_of_queues) \
+ do { \
+ static char name[8]; \
+ sprintf(name, "%s%s", UNIFI_NET_NAME, _name); \
+ _dev = alloc_netdev(_size, name, _setup); \
+ } while (0);
+#else
+#define UF_ALLOC_NETDEV(_dev, _size, _name, _setup, _num_of_queues) \
+ do { \
+ _dev = alloc_etherdev(_size); \
+ } while (0);
+#endif /* UNIFI_NET_NAME */
+#endif /* LINUX_VERSION_CODE */
+
+
+/* Wext handler is suported only if CSR_SUPPORT_WEXT is defined */
+#ifdef CSR_SUPPORT_WEXT
+extern struct iw_handler_def unifi_iw_handler_def;
+#endif /* CSR_SUPPORT_WEXT */
+static void check_ba_frame_age_timeout( unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ ba_session_rx_struct *ba_session);
+static void process_ba_frame(unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ ba_session_rx_struct *ba_session,
+ frame_desc_struct *frame_desc);
+static void process_ba_complete(unifi_priv_t *priv, netInterface_priv_t *interfacePriv);
+static void process_ma_packet_error_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata);
+static void process_amsdu(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata);
+static int uf_net_open(struct net_device *dev);
+static int uf_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
+static int uf_net_stop(struct net_device *dev);
+static struct net_device_stats *uf_net_get_stats(struct net_device *dev);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+static u16 uf_net_select_queue(struct net_device *dev, struct sk_buff *skb);
+#endif
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+static netdev_tx_t uf_net_xmit(struct sk_buff *skb, struct net_device *dev);
+#else
+static int uf_net_xmit(struct sk_buff *skb, struct net_device *dev);
+#ifndef NETDEV_TX_OK
+#define NETDEV_TX_OK 0
+#endif
+#ifndef NETDEV_TX_BUSY
+#define NETDEV_TX_BUSY 1
+#endif
+#endif
+static void uf_set_multicast_list(struct net_device *dev);
+
+
+typedef int (*tx_signal_handler)(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr *ehdr, CSR_PRIORITY priority);
+
+#ifdef CONFIG_NET_SCHED
+/*
+ * Queueing Discipline Interface
+ * Only used if kernel is configured with CONFIG_NET_SCHED
+ */
+
+/*
+ * The driver uses the qdisc interface to buffer and control all
+ * outgoing traffic. We create a root qdisc, register our qdisc operations
+ * and later we create two subsiduary pfifo queues for the uncontrolled
+ * and controlled ports.
+ *
+ * The network stack delivers all outgoing packets in our enqueue handler.
+ * There, we classify the packet and decide whether to store it or drop it
+ * (if the controlled port state is set to "discard").
+ * If the packet is enqueued, the network stack call our dequeue handler.
+ * There, we decide whether we can send the packet, delay it or drop it
+ * (the controlled port configuration might have changed meanwhile).
+ * If a packet is dequeued, then the network stack calls our hard_start_xmit
+ * handler where finally we send the packet.
+ *
+ * If the hard_start_xmit handler fails to send the packet, we return
+ * NETDEV_TX_BUSY and the network stack call our requeue handler where
+ * we put the packet back in the same queue in came from.
+ *
+ */
+
+struct uf_sched_data
+{
+ /* Traffic Classifier TBD */
+ struct tcf_proto *filter_list;
+ /* Our two queues */
+ struct Qdisc *queues[UNIFI_TRAFFIC_Q_MAX];
+};
+
+struct uf_tx_packet_data {
+ /* Queue the packet is stored in */
+ unifi_TrafficQueue queue;
+ /* QoS Priority determined when enqueing packet */
+ CSR_PRIORITY priority;
+ /* Debug */
+ unsigned long host_tag;
+};
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
+static int uf_qdiscop_enqueue(struct sk_buff *skb, struct Qdisc* qd);
+static int uf_qdiscop_requeue(struct sk_buff *skb, struct Qdisc* qd);
+static struct sk_buff *uf_qdiscop_dequeue(struct Qdisc* qd);
+static void uf_qdiscop_reset(struct Qdisc* qd);
+static void uf_qdiscop_destroy(struct Qdisc* qd);
+static int uf_qdiscop_dump(struct Qdisc *qd, struct sk_buff *skb);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
+static int uf_qdiscop_tune(struct Qdisc *qd, struct nlattr *opt);
+static int uf_qdiscop_init(struct Qdisc *qd, struct nlattr *opt);
+#else
+static int uf_qdiscop_tune(struct Qdisc *qd, struct rtattr *opt);
+static int uf_qdiscop_init(struct Qdisc *qd, struct rtattr *opt);
+#endif
+#endif
+
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
+/* queueing discipline operations */
+static struct Qdisc_ops uf_qdisc_ops =
+{
+ .next = NULL,
+ .cl_ops = NULL,
+ .id = "UniFi Qdisc",
+ .priv_size = sizeof(struct uf_sched_data),
+
+ .enqueue = uf_qdiscop_enqueue,
+ .dequeue = uf_qdiscop_dequeue,
+ .requeue = uf_qdiscop_requeue,
+ .drop = NULL, /* drop not needed since we are always the root qdisc */
+
+ .init = uf_qdiscop_init,
+ .reset = uf_qdiscop_reset,
+ .destroy = uf_qdiscop_destroy,
+ .change = uf_qdiscop_tune,
+
+ .dump = uf_qdiscop_dump,
+};
+#endif /* LINUX_VERSION_CODE */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+#define UF_QDISC_CREATE_DFLT(_dev, _ops, _root)
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+#define UF_QDISC_CREATE_DFLT(_dev, _ops, _root) \
+ qdisc_create_dflt(dev, netdev_get_tx_queue(_dev, 0), _ops, _root)
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
+#define UF_QDISC_CREATE_DFLT(_dev, _ops, _root) \
+ qdisc_create_dflt(dev, _ops, _root)
+#else
+#define UF_QDISC_CREATE_DFLT(_dev, _ops, _root) \
+ qdisc_create_dflt(dev, _ops)
+#endif /* LINUX_VERSION_CODE */
+
+#endif /* CONFIG_NET_SCHED */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
+static const struct net_device_ops uf_netdev_ops =
+{
+ .ndo_open = uf_net_open,
+ .ndo_stop = uf_net_stop,
+ .ndo_start_xmit = uf_net_xmit,
+ .ndo_do_ioctl = uf_net_ioctl,
+ .ndo_get_stats = uf_net_get_stats, /* called by /proc/net/dev */
+ .ndo_set_rx_mode = uf_set_multicast_list,
+ .ndo_select_queue = uf_net_select_queue,
+};
+#endif
+
+static u8 oui_rfc1042[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
+static u8 oui_8021h[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
+
+
+/* Callback for event logging to blocking clients */
+static void netdev_mlme_event_handler(ul_client_t *client,
+ const u8 *sig_packed, int sig_len,
+ const bulk_data_param_t *bulkdata,
+ int dir);
+
+#ifdef CSR_SUPPORT_WEXT
+/* Declare netdev_notifier block which will contain the state change
+ * handler callback function
+ */
+static struct notifier_block uf_netdev_notifier;
+#endif
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_alloc_netdevice
+ *
+ * Allocate memory for the net_device and device private structs
+ * for this interface.
+ * Fill in the fields, but don't register the interface yet.
+ * We need to configure the UniFi first.
+ *
+ * Arguments:
+ * sdio_dev Pointer to SDIO context handle to use for all
+ * SDIO ops.
+ * bus_id A small number indicating the SDIO card position on the
+ * bus. Typically this is the slot number, e.g. 0, 1 etc.
+ * Valid values are 0 to MAX_UNIFI_DEVS-1.
+ *
+ * Returns:
+ * Pointer to device private struct.
+ *
+ * Notes:
+ * The net_device and device private structs are allocated together
+ * and should be freed by freeing the net_device pointer.
+ * ---------------------------------------------------------------------------
+ */
+unifi_priv_t *
+uf_alloc_netdevice(CsrSdioFunction *sdio_dev, int bus_id)
+{
+ struct net_device *dev;
+ unifi_priv_t *priv;
+ netInterface_priv_t *interfacePriv;
+#ifdef CSR_SUPPORT_WEXT
+ int rc;
+#endif
+ unsigned char i; /* loop index */
+
+ /*
+ * Allocate netdevice struct, assign name template and
+ * setup as an ethernet device.
+ * The net_device and private structs are zeroed. Ether_setup() then
+ * sets up ethernet handlers and values.
+ * The RedHat 9 redhat-config-network tool doesn't recognise wlan* devices,
+ * so use "eth*" (like other wireless extns drivers).
+ */
+ UF_ALLOC_NETDEV(dev, sizeof(unifi_priv_t)+sizeof(netInterface_priv_t), "%d", ether_setup, UNIFI_TRAFFIC_Q_MAX);
+
+ if (dev == NULL) {
+ return NULL;
+ }
+
+ /* Set up back pointer from priv to netdev */
+ interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ priv = (unifi_priv_t *)(interfacePriv + 1);
+ interfacePriv->privPtr = priv;
+ interfacePriv->InterfaceTag = 0;
+
+
+ /* Initialize all supported netdev interface to be NULL */
+ for(i=0; i<CSR_WIFI_NUM_INTERFACES; i++) {
+ priv->netdev[i] = NULL;
+ priv->interfacePriv[i] = NULL;
+ }
+ priv->netdev[0] = dev;
+ priv->interfacePriv[0] = interfacePriv;
+
+ /* Setup / override net_device fields */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
+ dev->netdev_ops = &uf_netdev_ops;
+#else
+ dev->open = uf_net_open;
+ dev->stop = uf_net_stop;
+ dev->hard_start_xmit = uf_net_xmit;
+ dev->do_ioctl = uf_net_ioctl;
+
+ /* called by /proc/net/dev */
+ dev->get_stats = uf_net_get_stats;
+
+ dev->set_multicast_list = uf_set_multicast_list;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+ dev->select_queue = uf_net_select_queue;
+#endif
+#endif
+
+#ifdef CSR_SUPPORT_WEXT
+ dev->wireless_handlers = &unifi_iw_handler_def;
+#if IW_HANDLER_VERSION < 6
+ dev->get_wireless_stats = unifi_get_wireless_stats;
+#endif /* IW_HANDLER_VERSION */
+#endif /* CSR_SUPPORT_WEXT */
+
+ /* This gives us enough headroom to add the 802.11 header */
+ dev->needed_headroom = 32;
+
+ /* Use bus_id as instance number */
+ priv->instance = bus_id;
+ /* Store SDIO pointer to pass in the core */
+ priv->sdio = sdio_dev;
+
+ sdio_dev->driverData = (void*)priv;
+ /* Consider UniFi to be uninitialised */
+ priv->init_progress = UNIFI_INIT_NONE;
+
+ priv->prev_queue = 0;
+
+ /*
+ * Initialise the clients structure array.
+ * We do not need protection around ul_init_clients() because
+ * the character device can not be used until uf_alloc_netdevice()
+ * returns and Unifi_instances[bus_id]=priv is set, since unifi_open()
+ * will return -ENODEV.
+ */
+ ul_init_clients(priv);
+
+ /*
+ * Register a new ul client to send the multicast list signals.
+ * Note: priv->instance must be set before calling this.
+ */
+ priv->netdev_client = ul_register_client(priv,
+ 0,
+ netdev_mlme_event_handler);
+ if (priv->netdev_client == NULL) {
+ unifi_error(priv,
+ "Failed to register a unifi client for background netdev processing\n");
+ free_netdev(priv->netdev[0]);
+ return NULL;
+ }
+ unifi_trace(priv, UDBG2, "Netdev %p client (id:%d s:0x%X) is registered\n",
+ dev, priv->netdev_client->client_id, priv->netdev_client->sender_id);
+
+ priv->sta_wmm_capabilities = 0;
+
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_SUPPORT_SME))
+ priv->wapi_multicast_filter = 0;
+ priv->wapi_unicast_filter = 0;
+ priv->wapi_unicast_queued_pkt_filter = 0;
+#ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
+ priv->isWapiConnection = FALSE;
+#endif
+#endif
+
+ /* Enable all queues by default */
+ interfacePriv->queueEnabled[0] = 1;
+ interfacePriv->queueEnabled[1] = 1;
+ interfacePriv->queueEnabled[2] = 1;
+ interfacePriv->queueEnabled[3] = 1;
+
+#ifdef CSR_SUPPORT_SME
+ priv->allPeerDozing = 0;
+#endif
+ /*
+ * Initialise the OS private struct.
+ */
+ /*
+ * Instead of deciding in advance to use 11bg or 11a, we could do a more
+ * clever scan on both radios.
+ */
+ if (use_5g) {
+ priv->if_index = CSR_INDEX_5G;
+ unifi_info(priv, "Using the 802.11a radio\n");
+ } else {
+ priv->if_index = CSR_INDEX_2G4;
+ }
+
+ /* Initialise bh thread structure */
+ priv->bh_thread.thread_task = NULL;
+ priv->bh_thread.block_thread = 1;
+ init_waitqueue_head(&priv->bh_thread.wakeup_q);
+ priv->bh_thread.wakeup_flag = 0;
+ sprintf(priv->bh_thread.name, "uf_bh_thread");
+
+ /* reset the connected state for the interface */
+ interfacePriv->connected = UnifiConnectedUnknown; /* -1 unknown, 0 no, 1 yes */
+
+#ifdef USE_DRIVER_LOCK
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
+ sema_init(&priv->lock, 1);
+#else
+ init_MUTEX(&priv->lock);
+#endif
+#endif /* USE_DRIVER_LOCK */
+
+ spin_lock_init(&priv->send_signal_lock);
+
+ spin_lock_init(&priv->m4_lock);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
+ sema_init(&priv->ba_mutex, 1);
+#else
+ init_MUTEX(&priv->ba_mutex);
+#endif
+
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
+ spin_lock_init(&priv->wapi_lock);
+#endif
+
+#ifdef CSR_SUPPORT_SME
+ spin_lock_init(&priv->staRecord_lock);
+ spin_lock_init(&priv->tx_q_lock);
+#endif
+
+ /* Create the Traffic Analysis workqueue */
+ priv->unifi_workqueue = create_singlethread_workqueue("unifi_workq");
+ if (priv->unifi_workqueue == NULL) {
+ /* Deregister priv->netdev_client */
+ ul_deregister_client(priv->netdev_client);
+ free_netdev(priv->netdev[0]);
+ return NULL;
+ }
+
+#ifdef CSR_SUPPORT_SME
+ /* Create the Multicast Addresses list work structure */
+ INIT_WORK(&priv->multicast_list_task, uf_multicast_list_wq);
+
+ /* Create m4 buffering work structure */
+ INIT_WORK(&interfacePriv->send_m4_ready_task, uf_send_m4_ready_wq);
+
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
+ /* Create work structure to buffer the WAPI data packets to be sent to SME for encryption */
+ INIT_WORK(&interfacePriv->send_pkt_to_encrypt, uf_send_pkt_to_encrypt);
+#endif
+#endif
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
+#ifdef CONFIG_NET_SCHED
+ /* Register the qdisc operations */
+ register_qdisc(&uf_qdisc_ops);
+#endif /* CONFIG_NET_SCHED */
+#endif /* LINUX_VERSION_CODE */
+
+ priv->ref_count = 1;
+
+
+ priv->amp_client = NULL;
+ priv->coredump_mode = 0;
+ priv->ptest_mode = 0;
+ priv->wol_suspend = FALSE;
+ INIT_LIST_HEAD(&interfacePriv->rx_uncontrolled_list);
+ INIT_LIST_HEAD(&interfacePriv->rx_controlled_list);
+ sema_init(&priv->rx_q_sem, 1);
+
+#ifdef CSR_SUPPORT_WEXT
+ interfacePriv->netdev_callback_registered = FALSE;
+ interfacePriv->wait_netdev_change = FALSE;
+ /* Register callback for netdevice state changes */
+ if ((rc = register_netdevice_notifier(&uf_netdev_notifier)) == 0) {
+ interfacePriv->netdev_callback_registered = TRUE;
+ }
+ else {
+ unifi_warning(priv, "Failed to register netdevice notifier : %d %p\n", rc, dev);
+ }
+#endif /* CSR_SUPPORT_WEXT */
+
+#ifdef CSR_WIFI_SPLIT_PATCH
+ /* set it to some invalid value */
+ priv->pending_mode_set.common.destination = 0xaaaa;
+#endif
+
+ return priv;
+} /* uf_alloc_netdevice() */
+
+/*
+ *---------------------------------------------------------------------------
+ * uf_alloc_netdevice_for_other_interfaces
+ *
+ * Allocate memory for the net_device and device private structs
+ * for this interface.
+ * Fill in the fields, but don't register the interface yet.
+ * We need to configure the UniFi first.
+ *
+ * Arguments:
+ * interfaceTag Interface number.
+ * sdio_dev Pointer to SDIO context handle to use for all
+ * SDIO ops.
+ * bus_id A small number indicating the SDIO card position on the
+ * bus. Typically this is the slot number, e.g. 0, 1 etc.
+ * Valid values are 0 to MAX_UNIFI_DEVS-1.
+ *
+ * Returns:
+ * Pointer to device private struct.
+ *
+ * Notes:
+ * The device private structure contains the interfaceTag and pointer to the unifi_priv
+ * structure created allocated by net_device od interface0.
+ * The net_device and device private structs are allocated together
+ * and should be freed by freeing the net_device pointer.
+ * ---------------------------------------------------------------------------
+ */
+CsrBool
+uf_alloc_netdevice_for_other_interfaces(unifi_priv_t *priv, CsrUint16 interfaceTag)
+{
+ struct net_device *dev;
+ netInterface_priv_t *interfacePriv;
+
+ /*
+ * Allocate netdevice struct, assign name template and
+ * setup as an ethernet device.
+ * The net_device and private structs are zeroed. Ether_setup() then
+ * sets up ethernet handlers and values.
+ * The RedHat 9 redhat-config-network tool doesn't recognise wlan* devices,
+ * so use "eth*" (like other wireless extns drivers).
+ */
+ UF_ALLOC_NETDEV(dev, sizeof(netInterface_priv_t), "%d", ether_setup, 1);
+ if (dev == NULL) {
+ return FALSE;
+ }
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "uf_alloc_netdevice_for_other_interfaces bad interfaceTag\n");
+ return FALSE;
+ }
+
+ /* Set up back pointer from priv to netdev */
+ interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ interfacePriv->privPtr = priv;
+ interfacePriv->InterfaceTag = interfaceTag;
+ priv->netdev[interfaceTag] = dev;
+ priv->interfacePriv[interfacePriv->InterfaceTag] = interfacePriv;
+
+ /* reset the connected state for the interface */
+ interfacePriv->connected = UnifiConnectedUnknown; /* -1 unknown, 0 no, 1 yes */
+ INIT_LIST_HEAD(&interfacePriv->rx_uncontrolled_list);
+ INIT_LIST_HEAD(&interfacePriv->rx_controlled_list);
+
+ /* Setup / override net_device fields */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
+ dev->netdev_ops = &uf_netdev_ops;
+#else
+ dev->open = uf_net_open;
+ dev->stop = uf_net_stop;
+ dev->hard_start_xmit = uf_net_xmit;
+ dev->do_ioctl = uf_net_ioctl;
+
+ /* called by /proc/net/dev */
+ dev->get_stats = uf_net_get_stats;
+
+ dev->set_multicast_list = uf_set_multicast_list;
+#endif
+
+#ifdef CSR_SUPPORT_WEXT
+ dev->wireless_handlers = &unifi_iw_handler_def;
+#if IW_HANDLER_VERSION < 6
+ dev->get_wireless_stats = unifi_get_wireless_stats;
+#endif /* IW_HANDLER_VERSION */
+#endif /* CSR_SUPPORT_WEXT */
+ return TRUE;
+} /* uf_alloc_netdevice() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_free_netdevice
+ *
+ * Unregister the network device and free the memory allocated for it.
+ * NB This includes the memory for the priv struct.
+ *
+ * Arguments:
+ * priv Device private pointer.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+int
+uf_free_netdevice(unifi_priv_t *priv)
+{
+ int i;
+ unsigned long flags;
+
+ func_enter();
+
+ unifi_trace(priv, UDBG1, "uf_free_netdevice\n");
+
+ if (!priv) {
+ return -EINVAL;
+ }
+
+ /*
+ * Free any buffers used for holding firmware
+ */
+ uf_release_firmware_files(priv);
+
+#if (defined CSR_SUPPORT_SME) && (defined CSR_SUPPORT_WEXT)
+ if (priv->connection_config.mlmeAssociateReqInformationElements) {
+ kfree(priv->connection_config.mlmeAssociateReqInformationElements);
+ }
+ priv->connection_config.mlmeAssociateReqInformationElements = NULL;
+ priv->connection_config.mlmeAssociateReqInformationElementsLength = 0;
+
+ if (priv->mib_data.length) {
+ vfree(priv->mib_data.data);
+ }
+ priv->mib_data.data = NULL;
+ priv->mib_data.length = 0;
+
+#endif /* CSR_SUPPORT_SME && CSR_SUPPORT_WEXT*/
+
+ /* Free any bulkdata buffers allocated for M4 caching */
+ spin_lock_irqsave(&priv->m4_lock, flags);
+ for (i = 0; i < CSR_WIFI_NUM_INTERFACES; i++) {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[i];
+ if (interfacePriv->m4_bulk_data.data_length > 0) {
+ unifi_trace(priv, UDBG5, "uf_free_netdevice: free M4 bulkdata %d\n", i);
+ unifi_net_data_free(priv, &interfacePriv->m4_bulk_data);
+ }
+ }
+ spin_unlock_irqrestore(&priv->m4_lock, flags);
+
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
+ /* Free any bulkdata buffers allocated for M4 caching */
+ spin_lock_irqsave(&priv->wapi_lock, flags);
+ for (i = 0; i < CSR_WIFI_NUM_INTERFACES; i++) {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[i];
+ if (interfacePriv->wapi_unicast_bulk_data.data_length > 0) {
+ unifi_trace(priv, UDBG5, "uf_free_netdevice: free WAPI PKT bulk data %d\n", i);
+ unifi_net_data_free(priv, &interfacePriv->wapi_unicast_bulk_data);
+ }
+ }
+ spin_unlock_irqrestore(&priv->wapi_lock, flags);
+#endif
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
+#ifdef CONFIG_NET_SCHED
+ /* Unregister the qdisc operations */
+ unregister_qdisc(&uf_qdisc_ops);
+#endif /* CONFIG_NET_SCHED */
+#endif /* LINUX_VERSION_CODE */
+
+#ifdef CSR_SUPPORT_WEXT
+ /* Unregister callback for netdevice state changes */
+ unregister_netdevice_notifier(&uf_netdev_notifier);
+#endif /* CSR_SUPPORT_WEXT */
+
+#ifdef CSR_SUPPORT_SME
+ /* Cancel work items and destroy the workqueue */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
+ cancel_work_sync(&priv->multicast_list_task);
+#endif
+#endif
+/* Destroy the workqueues. */
+ flush_workqueue(priv->unifi_workqueue);
+ destroy_workqueue(priv->unifi_workqueue);
+
+ /* Free up netdev in reverse order: priv is allocated with netdev[0].
+ * So, netdev[0] should be freed after all other netdevs are freed up
+ */
+ for (i=CSR_WIFI_NUM_INTERFACES-1; i>=0; i--) {
+ /*Free the netdev struct and priv, which are all one lump*/
+ if (priv->netdev[i]) {
+ unifi_error(priv, "uf_free_netdevice: netdev %d %p\n", i, priv->netdev[i]);
+ free_netdev(priv->netdev[i]);
+ }
+ }
+
+ func_exit();
+ return 0;
+} /* uf_free_netdevice() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_net_open
+ *
+ * Called when userland does "ifconfig wlan0 up".
+ *
+ * Arguments:
+ * dev Device pointer.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static int
+uf_net_open(struct net_device *dev)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+
+ func_enter();
+
+ /* If we haven't finished UniFi initialisation, we can't start */
+ if (priv->init_progress != UNIFI_INIT_COMPLETED) {
+ unifi_warning(priv, "%s: unifi not ready, failing net_open\n", __FUNCTION__);
+ return -EINVAL;
+ }
+
+#if (defined CSR_NATIVE_LINUX) && (defined UNIFI_SNIFF_ARPHRD) && defined(CSR_SUPPORT_WEXT)
+ /*
+ * To sniff, the user must do "iwconfig mode monitor", which sets
+ * priv->wext_conf.mode to IW_MODE_MONITOR.
+ * Then he/she must do "ifconfig ethn up", which calls this fn.
+ * There is no point in starting the sniff with SNIFFJOIN until
+ * this point.
+ */
+ if (priv->wext_conf.mode == IW_MODE_MONITOR) {
+ int err;
+ err = uf_start_sniff(priv);
+ if (err) {
+ return err;
+ }
+ netif_carrier_on(dev);
+ }
+#endif
+
+#ifdef CSR_SUPPORT_WEXT
+ if (interfacePriv->wait_netdev_change) {
+ unifi_trace(priv, UDBG1, "%s: Waiting for NETDEV_CHANGE, assume connected\n",
+ __FUNCTION__);
+ interfacePriv->connected = UnifiConnected;
+ interfacePriv->wait_netdev_change = FALSE;
+ }
+#endif
+
+ UF_NETIF_TX_START_ALL_QUEUES(dev);
+
+ func_exit();
+ return 0;
+} /* uf_net_open() */
+
+
+static int
+uf_net_stop(struct net_device *dev)
+{
+#if defined(CSR_NATIVE_LINUX) && defined(UNIFI_SNIFF_ARPHRD) && defined(CSR_SUPPORT_WEXT)
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t*)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+
+ func_enter();
+
+ /* Stop sniffing if in Monitor mode */
+ if (priv->wext_conf.mode == IW_MODE_MONITOR) {
+ if (priv->card) {
+ int err;
+ err = unifi_reset_state(priv, dev->dev_addr, 1);
+ if (err) {
+ return err;
+ }
+ }
+ }
+#else
+ func_enter();
+#endif
+
+ UF_NETIF_TX_STOP_ALL_QUEUES(dev);
+
+ func_exit();
+ return 0;
+} /* uf_net_stop() */
+
+
+/* This is called after the WE handlers */
+static int
+uf_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
+{
+ int rc;
+
+ rc = -EOPNOTSUPP;
+
+ return rc;
+} /* uf_net_ioctl() */
+
+
+
+static struct net_device_stats *
+uf_net_get_stats(struct net_device *dev)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+
+ return &interfacePriv->stats;
+} /* uf_net_get_stats() */
+
+static CSR_PRIORITY uf_get_packet_priority(unifi_priv_t *priv, netInterface_priv_t *interfacePriv, struct sk_buff *skb, const int proto)
+{
+ CSR_PRIORITY priority = CSR_CONTENTION;
+
+ func_enter();
+ priority = (CSR_PRIORITY) (skb->priority >> 5);
+
+ if (priority == CSR_QOS_UP0) { /* 0 */
+
+ unifi_trace(priv, UDBG5, "uf_get_packet_priority: proto = 0x%.4X\n", proto);
+
+ switch (proto) {
+ case 0x0800: /* IPv4 */
+ case 0x814C: /* SNMP */
+ case 0x880C: /* GSMP */
+ priority = (CSR_PRIORITY) (skb->data[1 + ETH_HLEN] >> 5);
+ break;
+
+ case 0x8100: /* VLAN */
+ priority = (CSR_PRIORITY) (skb->data[0 + ETH_HLEN] >> 5);
+ break;
+
+ case 0x86DD: /* IPv6 */
+ priority = (CSR_PRIORITY) ((skb->data[0 + ETH_HLEN] & 0x0E) >> 1);
+ break;
+
+ default:
+ priority = CSR_QOS_UP0;
+ break;
+ }
+ }
+
+ /* Check if we are allowed to transmit on this AC. Because of ACM we may have to downgrade to a lower
+ * priority */
+ if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI) {
+ unifi_TrafficQueue queue;
+
+ /* Keep trying lower priorities until we find a queue
+ * Priority to queue mapping is 1,2 - BK, 0,3 - BE, 4,5 - VI, 6,7 - VO */
+ queue = unifi_frame_priority_to_queue(priority);
+
+ while (queue > UNIFI_TRAFFIC_Q_BK && !interfacePriv->queueEnabled[queue]) {
+ queue--;
+ priority = unifi_get_default_downgrade_priority(queue);
+ }
+ }
+
+ unifi_trace(priv, UDBG5, "Packet priority = %d\n", priority);
+
+ func_exit();
+ return priority;
+}
+
+/*
+ */
+/*
+ * ---------------------------------------------------------------------------
+ * get_packet_priority
+ *
+ * Arguments:
+ * priv private data area of functional driver
+ * skb socket buffer
+ * ehdr ethernet header to fetch protocol
+ * interfacePriv For accessing station record database
+ *
+ *
+ * Returns:
+ * CSR_PRIORITY.
+ * ---------------------------------------------------------------------------
+ */
+CSR_PRIORITY
+get_packet_priority(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr *ehdr, netInterface_priv_t *interfacePriv)
+{
+ CSR_PRIORITY priority = CSR_CONTENTION;
+ const int proto = ntohs(ehdr->h_proto);
+
+ CsrUint8 interfaceMode = interfacePriv->interfaceMode;
+
+ func_enter();
+
+ /* Priority Mapping for all the Modes */
+ switch(interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_STA:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
+ unifi_trace(priv, UDBG4, "mode is STA \n");
+ if ((priv->sta_wmm_capabilities & QOS_CAPABILITY_WMM_ENABLED) == 1) {
+ priority = uf_get_packet_priority(priv, interfacePriv, skb, proto);
+ } else {
+ priority = CSR_CONTENTION;
+ }
+ break;
+#ifdef CSR_SUPPORT_SME
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
+ {
+ CsrWifiRouterCtrlStaInfo_t * dstStaInfo =
+ CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,ehdr->h_dest, interfacePriv->InterfaceTag);
+ unifi_trace(priv, UDBG4, "mode is AP \n");
+ if (!(ehdr->h_dest[0] & 0x01) && dstStaInfo && dstStaInfo->wmmOrQosEnabled) {
+ /* If packet is not Broadcast/multicast */
+ priority = uf_get_packet_priority(priv, interfacePriv, skb, proto);
+ } else {
+ /* Since packet destination is not QSTA, set priority to CSR_CONTENTION */
+ unifi_trace(priv, UDBG4, "Destination is not QSTA or BroadCast/Multicast\n");
+ priority = CSR_CONTENTION;
+ }
+ }
+ break;
+#endif
+ default:
+ unifi_trace(priv, UDBG3, " mode unknown in %s func, mode=%x\n", __FUNCTION__, interfaceMode);
+ }
+ unifi_trace(priv, UDBG5, "priority = %x\n", priority);
+
+ func_exit();
+ return priority;
+}
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+/*
+ * ---------------------------------------------------------------------------
+ * uf_net_select_queue
+ *
+ * Called by the kernel to select which queue to put the packet in
+ *
+ * Arguments:
+ * dev Device pointer
+ * skb Packet
+ *
+ * Returns:
+ * Queue index
+ * ---------------------------------------------------------------------------
+ */
+static u16
+uf_net_select_queue(struct net_device *dev, struct sk_buff *skb)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = (unifi_priv_t *)interfacePriv->privPtr;
+ struct ethhdr ehdr;
+ unifi_TrafficQueue queue;
+ int proto;
+ CSR_PRIORITY priority;
+
+ func_enter();
+
+ memcpy(&ehdr, skb->data, ETH_HLEN);
+ proto = ntohs(ehdr.h_proto);
+
+ /* 802.1x - apply controlled/uncontrolled port rules */
+ if ((proto != ETH_P_PAE)
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ && (proto != ETH_P_WAI)
+#endif
+ ) {
+ /* queues 0 - 3 */
+ priority = get_packet_priority(priv, skb, &ehdr, interfacePriv);
+ queue = unifi_frame_priority_to_queue(priority);
+ } else {
+ /* queue 4 */
+ queue = UNIFI_TRAFFIC_Q_EAPOL;
+ }
+
+
+ func_exit();
+ return (u16)queue;
+} /* uf_net_select_queue() */
+#endif
+
+int
+skb_add_llc_snap(struct net_device *dev, struct sk_buff *skb, int proto)
+{
+ llc_snap_hdr_t *snap;
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int headroom;
+
+ /* get the headroom available in skb */
+ headroom = skb_headroom(skb);
+ /* step 1: classify ether frame, DIX or 802.3? */
+
+ if (proto < 0x600) {
+ /* codes <= 1500 reserved for 802.3 lengths */
+ /* it's 802.3, pass ether payload unchanged, */
+ unifi_trace(priv, UDBG3, "802.3 len: %d\n", skb->len);
+
+ /* leave off any PAD octets. */
+ skb_trim(skb, proto);
+ } else if (proto == ETH_P_8021Q) {
+
+ /* Store the VLAN SNAP (should be 87-65). */
+ u16 vlan_snap = *(u16*)skb->data;
+ /* check for headroom availability before skb_push 14 = (4 + 10) */
+ if (headroom < 14) {
+ unifi_trace(priv, UDBG3, "cant append vlan snap: debug\n");
+ return -1;
+ }
+ /* Add AA-AA-03-00-00-00 */
+ snap = (llc_snap_hdr_t *)skb_push(skb, 4);
+ snap->dsap = snap->ssap = 0xAA;
+ snap->ctrl = 0x03;
+ memcpy(snap->oui, oui_rfc1042, P80211_OUI_LEN);
+
+ /* Add AA-AA-03-00-00-00 */
+ snap = (llc_snap_hdr_t *)skb_push(skb, 10);
+ snap->dsap = snap->ssap = 0xAA;
+ snap->ctrl = 0x03;
+ memcpy(snap->oui, oui_rfc1042, P80211_OUI_LEN);
+
+ /* Add the VLAN specific information */
+ snap->protocol = htons(proto);
+ *(u16*)(snap + 1) = vlan_snap;
+
+ } else
+ {
+ /* it's DIXII, time for some conversion */
+ unifi_trace(priv, UDBG3, "DIXII len: %d\n", skb->len);
+
+ /* check for headroom availability before skb_push */
+ if (headroom < sizeof(llc_snap_hdr_t)) {
+ unifi_trace(priv, UDBG3, "cant append snap: debug\n");
+ return -1;
+ }
+ /* tack on SNAP */
+ snap = (llc_snap_hdr_t *)skb_push(skb, sizeof(llc_snap_hdr_t));
+ snap->dsap = snap->ssap = 0xAA;
+ snap->ctrl = 0x03;
+ /* Use the appropriate OUI. */
+ if ((proto == ETH_P_AARP) || (proto == ETH_P_IPX)) {
+ memcpy(snap->oui, oui_8021h, P80211_OUI_LEN);
+ } else {
+ memcpy(snap->oui, oui_rfc1042, P80211_OUI_LEN);
+ }
+ snap->protocol = htons(proto);
+ }
+
+ return 0;
+} /* skb_add_llc_snap() */
+
+#ifdef CSR_SUPPORT_SME
+static int
+_identify_sme_ma_pkt_ind(unifi_priv_t *priv,
+ const CsrInt8 *oui, CsrUint16 protocol,
+ const CSR_SIGNAL *signal,
+ bulk_data_param_t *bulkdata,
+ const unsigned char *daddr,
+ const unsigned char *saddr)
+{
+ CSR_MA_PACKET_INDICATION *pkt_ind = (CSR_MA_PACKET_INDICATION*)&signal->u.MaPacketIndication;
+ int r;
+ CsrUint8 i;
+
+ unifi_trace(priv, UDBG5,
+ "_identify_sme_ma_pkt_ind -->\n");
+ for (i = 0; i < MAX_MA_UNIDATA_IND_FILTERS; i++) {
+ if (priv->sme_unidata_ind_filters[i].in_use) {
+ if (!memcmp(oui, priv->sme_unidata_ind_filters[i].oui, 3) &&
+ (protocol == priv->sme_unidata_ind_filters[i].protocol)) {
+
+ /* Send to client */
+ if (priv->sme_cli) {
+ /*
+ * Pass the packet to the SME, using unifi_sys_ma_unitdata_ind().
+ * The frame needs to be converted according to the encapsulation.
+ */
+ unifi_trace(priv, UDBG1,
+ "_identify_sme_ma_pkt_ind: handle=%d, encap=%d, proto=%x\n",
+ i, priv->sme_unidata_ind_filters[i].encapsulation,
+ priv->sme_unidata_ind_filters[i].protocol);
+ if (priv->sme_unidata_ind_filters[i].encapsulation == CSR_WIFI_ROUTER_ENCAPSULATION_ETHERNET) {
+ struct sk_buff *skb;
+ /* The translation is performed on skb... */
+ skb = (struct sk_buff*)bulkdata->d[0].os_net_buf_ptr;
+ skb->len = bulkdata->d[0].data_length;
+
+ unifi_trace(priv, UDBG1,
+ "_identify_sme_ma_pkt_ind: skb_80211_to_ether -->\n");
+ r = skb_80211_to_ether(priv, skb, daddr, saddr,
+ signal, bulkdata);
+ unifi_trace(priv, UDBG1,
+ "_identify_sme_ma_pkt_ind: skb_80211_to_ether <--\n");
+ if (r) {
+ return -EINVAL;
+ }
+
+ /* ... but we indicate buffer and length */
+ bulkdata->d[0].os_data_ptr = skb->data;
+ bulkdata->d[0].data_length = skb->len;
+ } else {
+ /* Add the MAC addresses before the SNAP */
+ bulkdata->d[0].os_data_ptr -= 2*ETH_ALEN;
+ bulkdata->d[0].data_length += 2*ETH_ALEN;
+ memcpy((void*)bulkdata->d[0].os_data_ptr, daddr, ETH_ALEN);
+ memcpy((void*)bulkdata->d[0].os_data_ptr + ETH_ALEN, saddr, ETH_ALEN);
+ }
+
+ unifi_trace(priv, UDBG1,
+ "_identify_sme_ma_pkt_ind: unifi_sys_ma_pkt_ind -->\n");
+ CsrWifiRouterMaPacketIndSend(priv->sme_unidata_ind_filters[i].appHandle,
+ (pkt_ind->VirtualInterfaceIdentifier & 0xff),
+ i,
+ pkt_ind->ReceptionStatus,
+ bulkdata->d[0].data_length,
+ (CsrUint8*)bulkdata->d[0].os_data_ptr,
+ NULL,
+ pkt_ind->Rssi,
+ pkt_ind->Snr,
+ pkt_ind->ReceivedRate);
+
+
+ unifi_trace(priv, UDBG1,
+ "_identify_sme_ma_pkt_ind: unifi_sys_ma_pkt_ind <--\n");
+ }
+
+ return 1;
+ }
+ }
+ }
+
+ return -1;
+}
+#endif /* CSR_SUPPORT_SME */
+
+/*
+ * ---------------------------------------------------------------------------
+ * skb_80211_to_ether
+ *
+ * Make sure the received frame is in Ethernet (802.3) form.
+ * De-encapsulates SNAP if necessary, adds a ethernet header.
+ * The source buffer should not contain an 802.11 MAC header
+ *
+ * Arguments:
+ * payload Pointer to packet data received from UniFi.
+ * payload_length Number of bytes of data received from UniFi.
+ * daddr Destination MAC address.
+ * saddr Source MAC address.
+ *
+ * Returns:
+ * 0 on success, -1 if the packet is bad and should be dropped,
+ * 1 if the packet was forwarded to the SME or AMP client.
+ * ---------------------------------------------------------------------------
+ */
+int
+skb_80211_to_ether(unifi_priv_t *priv, struct sk_buff *skb,
+ const unsigned char *daddr, const unsigned char *saddr,
+ const CSR_SIGNAL *signal,
+ bulk_data_param_t *bulkdata)
+{
+ unsigned char *payload;
+ int payload_length;
+ struct ethhdr *eth;
+ llc_snap_hdr_t *snap;
+ int headroom;
+#define UF_VLAN_LLC_HEADER_SIZE 18
+ static const u8 vlan_inner_snap[] = { 0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00 };
+#if defined(CSR_NATIVE_SOFTMAC) && defined(CSR_SUPPORT_SME)
+ const CSR_MA_PACKET_INDICATION *pkt_ind = &signal->u.MaPacketIndication;
+#endif
+
+ if(skb== NULL || daddr == NULL || saddr == NULL){
+ unifi_error(priv,"skb_80211_to_ether: PBC fail\n");
+ return 1;
+ }
+
+ payload = skb->data;
+ payload_length = skb->len;
+
+ snap = (llc_snap_hdr_t *)payload;
+ eth = (struct ethhdr *)payload;
+
+ /* get the skb headroom size */
+ headroom = skb_headroom(skb);
+
+ /*
+ * Test for the various encodings
+ */
+ if ((payload_length >= sizeof(llc_snap_hdr_t)) &&
+ (snap->dsap == 0xAA) &&
+ (snap->ssap == 0xAA) &&
+ (snap->ctrl == 0x03) &&
+ (snap->oui[0] == 0) &&
+ (snap->oui[1] == 0) &&
+ ((snap->oui[2] == 0) || (snap->oui[2] == 0xF8)))
+ {
+ /* AppleTalk AARP (2) or IPX SNAP */
+ if ((snap->oui[2] == 0) &&
+ ((ntohs(snap->protocol) == ETH_P_AARP) || (ntohs(snap->protocol) == ETH_P_IPX)))
+ {
+ u16 len;
+
+ unifi_trace(priv, UDBG3, "%s len: %d\n",
+ (ntohs(snap->protocol) == ETH_P_AARP) ? "ETH_P_AARP" : "ETH_P_IPX",
+ payload_length);
+
+ /* check for headroom availability before skb_push */
+ if (headroom < (2 * ETH_ALEN + 2)) {
+ unifi_warning(priv, "headroom not available to skb_push ether header\n");
+ return -1;
+ }
+
+ /* Add 802.3 header and leave full payload */
+ len = htons(skb->len);
+ memcpy(skb_push(skb, 2), &len, 2);
+ memcpy(skb_push(skb, ETH_ALEN), saddr, ETH_ALEN);
+ memcpy(skb_push(skb, ETH_ALEN), daddr, ETH_ALEN);
+
+ return 0;
+ }
+ /* VLAN-tagged IP */
+ if ((snap->oui[2] == 0) && (ntohs(snap->protocol) == ETH_P_8021Q))
+ {
+ /*
+ * The translation doesn't change the packet length, so is done in-place.
+ *
+ * Example header (from Std 802.11-2007 Annex M):
+ * AA-AA-03-00-00-00-81-00-87-65-AA-AA-03-00-00-00-08-06
+ * -------SNAP-------p1-p1-ll-ll-------SNAP--------p2-p2
+ * dd-dd-dd-dd-dd-dd-aa-aa-aa-aa-aa-aa-p1-p1-ll-ll-p2-p2
+ * dd-dd-dd-dd-dd-dd-aa-aa-aa-aa-aa-aa-81-00-87-65-08-06
+ */
+ u16 vlan_snap;
+
+ if (payload_length < UF_VLAN_LLC_HEADER_SIZE) {
+ unifi_warning(priv, "VLAN SNAP header too short: %d bytes\n", payload_length);
+ return -1;
+ }
+
+ if (memcmp(payload + 10, vlan_inner_snap, 6)) {
+ unifi_warning(priv, "VLAN malformatted SNAP header.\n");
+ return -1;
+ }
+
+ unifi_trace(priv, UDBG3, "VLAN SNAP: %02x-%02x\n", payload[8], payload[9]);
+ unifi_trace(priv, UDBG3, "VLAN len: %d\n", payload_length);
+
+ /* Create the 802.3 header */
+
+ vlan_snap = *((u16*)(payload + 8));
+
+ /* Create LLC header without byte-swapping */
+ eth->h_proto = snap->protocol;
+
+ memcpy(eth->h_dest, daddr, ETH_ALEN);
+ memcpy(eth->h_source, saddr, ETH_ALEN);
+ *(u16*)(eth + 1) = vlan_snap;
+ return 0;
+ }
+
+ /* it's a SNAP + RFC1042 frame */
+ unifi_trace(priv, UDBG3, "SNAP+RFC1042 len: %d\n", payload_length);
+
+ /* chop SNAP+llc header from skb. */
+ skb_pull(skb, sizeof(llc_snap_hdr_t));
+
+ /* Since skb_pull called above to chop snap+llc, no need to check for headroom
+ * availability before skb_push
+ */
+ /* create 802.3 header at beginning of skb. */
+ eth = (struct ethhdr *)skb_push(skb, ETH_HLEN);
+ memcpy(eth->h_dest, daddr, ETH_ALEN);
+ memcpy(eth->h_source, saddr, ETH_ALEN);
+ /* Copy protocol field without byte-swapping */
+ eth->h_proto = snap->protocol;
+ } else {
+ u16 len;
+
+ /* check for headroom availability before skb_push */
+ if (headroom < (2 * ETH_ALEN + 2)) {
+ unifi_warning(priv, "headroom not available to skb_push ether header\n");
+ return -1;
+ }
+ /* Add 802.3 header and leave full payload */
+ len = htons(skb->len);
+ memcpy(skb_push(skb, 2), &len, 2);
+ memcpy(skb_push(skb, ETH_ALEN), saddr, ETH_ALEN);
+ memcpy(skb_push(skb, ETH_ALEN), daddr, ETH_ALEN);
+
+ return 1;
+ }
+
+ return 0;
+} /* skb_80211_to_ether() */
+
+
+static CsrWifiRouterCtrlPortAction verify_port(unifi_priv_t *priv, unsigned char *address, int queue, CsrUint16 interfaceTag)
+{
+#ifdef CSR_NATIVE_LINUX
+#ifdef CSR_SUPPORT_WEXT
+ if (queue == UF_CONTROLLED_PORT_Q) {
+ return priv->wext_conf.block_controlled_port;
+ } else {
+ return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN;
+ }
+#else
+ return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN; /* default to open for softmac dev */
+#endif
+#else
+ return uf_sme_port_state(priv, address, queue, interfaceTag);
+#endif
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * prepare_and_add_macheader
+ *
+ *
+ * These functions adds mac header for packet from netdev
+ * to UniFi for transmission.
+ * EAP protocol packets are also appended with Mac header &
+ * sent using send_ma_pkt_request().
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * skb Socket buffer containing data packet to transmit
+ * newSkb Socket buffer containing data packet + Mac header if no sufficient headroom in skb
+ * serviceClass to append QOS control header in Mac header
+ * bulkdata if newSkb allocated then bulkdata updated to send to unifi
+ * interfaceTag the interfaceID on which activity going on
+ * daddr destination address
+ * saddr source address
+ * protection protection bit set in framce control of mac header
+ *
+ * Returns:
+ * Zero on success or error code.
+ * ---------------------------------------------------------------------------
+ */
+
+int prepare_and_add_macheader(unifi_priv_t *priv, struct sk_buff *skb, struct sk_buff *newSkb,
+ CSR_PRIORITY priority,
+ bulk_data_param_t *bulkdata,
+ CsrUint16 interfaceTag,
+ const CsrUint8 *daddr,
+ const CsrUint8 *saddr,
+ CsrBool protection)
+{
+ CsrUint16 fc = 0;
+ CsrUint8 qc = 0;
+ CsrUint8 macHeaderLengthInBytes = MAC_HEADER_SIZE, *bufPtr = NULL;
+ bulk_data_param_t data_ptrs;
+ CsrResult csrResult;
+ int headroom =0;
+ CsrUint8 direction = 0;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ CsrUint8 *addressOne;
+ CsrBool bQosNull = false;
+
+ if (skb == NULL) {
+ unifi_error(priv,"prepare_and_add_macheader: Invalid SKB reference\n");
+ return -1;
+ }
+
+ /* add a MAC header refer: 7.1.3.1 Frame Control field in P802.11REVmb.book */
+ if (priority != CSR_CONTENTION) {
+ /* EAPOL packets don't go as QOS_DATA */
+ if (priority == CSR_MANAGEMENT) {
+ fc |= cpu_to_le16(IEEE802_11_FC_TYPE_DATA);
+ } else {
+ /* Qos Control Field */
+ macHeaderLengthInBytes += QOS_CONTROL_HEADER_SIZE;
+
+ if (skb->len) {
+
+ fc |= cpu_to_le16(IEEE802_11_FC_TYPE_QOS_DATA);
+ } else {
+ fc |= cpu_to_le16(IEEE802_11_FC_TYPE_QOS_NULL);
+ bQosNull = true;
+ }
+ }
+ } else {
+ if(skb->len == 0) {
+ fc |= cpu_to_le16(IEEE802_11_FC_TYPE_NULL);
+ } else {
+ fc |= cpu_to_le16(IEEE802_11_FC_TYPE_DATA);
+ }
+ }
+
+ switch (interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_STA:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
+ direction = 2;
+ fc |= cpu_to_le16(IEEE802_11_FC_TO_DS_MASK);
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
+ direction = 0;
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ direction = 1;
+ fc |= cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK);
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_AMP:
+ if (priority == CSR_MANAGEMENT ) {
+
+ direction = 2;
+ fc |= cpu_to_le16(IEEE802_11_FC_TO_DS_MASK);
+ } else {
+ /* Data frames have to use WDS 4 address frames */
+ direction = 3;
+ fc |= cpu_to_le16(IEEE802_11_FC_TO_DS_MASK | IEEE802_11_FC_FROM_DS_MASK);
+ macHeaderLengthInBytes += 6;
+ }
+ break;
+ default:
+ unifi_warning(priv, "prepare_and_add_macheader: Unknown mode %d\n",
+ interfacePriv->interfaceMode);
+ }
+
+
+ /* If Sta is QOS & HTC is supported then need to set 'order' bit */
+ /* We don't support HT Control for now */
+
+ if(protection) {
+ fc |= cpu_to_le16(IEEE802_11_FC_PROTECTED_MASK);
+ }
+
+ /* check the skb headroom before pushing mac header */
+ headroom = skb_headroom(skb);
+
+ if (headroom < macHeaderLengthInBytes) {
+ unifi_trace(priv, UDBG5,
+ "prepare_and_add_macheader: Allocate headroom extra %d bytes\n",
+ macHeaderLengthInBytes);
+
+ csrResult = unifi_net_data_malloc(priv, &data_ptrs.d[0], skb->len + macHeaderLengthInBytes);
+
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, " failed to allocate request_data. in %s func\n", __FUNCTION__);
+ return -1;
+ }
+ newSkb = (struct sk_buff *)(data_ptrs.d[0].os_net_buf_ptr);
+ newSkb->len = skb->len + macHeaderLengthInBytes;
+
+ memcpy((void*)data_ptrs.d[0].os_data_ptr + macHeaderLengthInBytes,
+ skb->data, skb->len);
+
+ bulkdata->d[0].os_data_ptr = newSkb->data;
+ bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
+ bulkdata->d[0].data_length = newSkb->len;
+
+ bufPtr = (CsrUint8*)data_ptrs.d[0].os_data_ptr;
+
+ /* The old skb will not be used again */
+ kfree_skb(skb);
+ } else {
+
+ /* headroom has sufficient size, so will get proper pointer */
+ bufPtr = (CsrUint8*)skb_push(skb, macHeaderLengthInBytes);
+ bulkdata->d[0].os_data_ptr = skb->data;
+ bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
+ bulkdata->d[0].data_length = skb->len;
+ }
+
+ /* Frame the actual MAC header */
+
+ memset(bufPtr, 0, macHeaderLengthInBytes);
+
+ /* copy frameControl field */
+ memcpy(bufPtr, &fc, sizeof(fc));
+ bufPtr += sizeof(fc);
+ macHeaderLengthInBytes -= sizeof(fc);
+
+ /* Duration/ID field which is 2 bytes */
+ bufPtr += 2;
+ macHeaderLengthInBytes -= 2;
+
+ switch(direction)
+ {
+ case 0:
+ /* Its an Ad-Hoc no need to route it through AP */
+ /* Address1: MAC address of the destination from eth header */
+ memcpy(bufPtr, daddr, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+
+ /* Address2: MAC address of the source */
+ memcpy(bufPtr, saddr, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+
+ /* Address3: the BSSID (locally generated in AdHoc (creators Bssid)) */
+ memcpy(bufPtr, &interfacePriv->bssid, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+ break;
+ case 1:
+ /* Address1: MAC address of the actual destination */
+ memcpy(bufPtr, daddr, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+ /* Address2: The MAC address of the AP */
+ memcpy(bufPtr, &interfacePriv->bssid, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+
+ /* Address3: MAC address of the source from eth header */
+ memcpy(bufPtr, saddr, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+ break;
+ case 2:
+ /* Address1: To AP is the MAC address of the AP to which its associated */
+ memcpy(bufPtr, &interfacePriv->bssid, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+
+ /* Address2: MAC address of the source from eth header */
+ memcpy(bufPtr, saddr, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+
+ /* Address3: MAC address of the actual destination on the distribution system */
+ memcpy(bufPtr, daddr, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+ break;
+ case 3:
+ memcpy(bufPtr, &interfacePriv->bssid, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+
+ /* Address2: MAC address of the source from eth header */
+ memcpy(bufPtr, saddr, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+
+ /* Address3: MAC address of the actual destination on the distribution system */
+ memcpy(bufPtr, daddr, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+ break;
+ default:
+ unifi_error(priv,"Unknown direction =%d : Not handled now\n",direction);
+ return -1;
+ }
+ /* 2 bytes of frame control field, appended by firmware */
+ bufPtr += 2;
+ macHeaderLengthInBytes -= 2;
+
+ if (3 == direction) {
+ /* Address4: MAC address of the source */
+ memcpy(bufPtr, saddr, ETH_ALEN);
+ bufPtr += ETH_ALEN;
+ macHeaderLengthInBytes -= ETH_ALEN;
+ }
+
+ /* IF Qos Data or Qos Null Data then set QosControl field */
+ if ((priority != CSR_CONTENTION) && (macHeaderLengthInBytes >= QOS_CONTROL_HEADER_SIZE)) {
+
+ if (priority > 7) {
+ unifi_trace(priv, UDBG1, "data packets priority is more than 7, priority = %x\n", priority);
+ qc |= 7;
+ } else {
+ qc |= priority;
+ }
+ /*assigning address1
+ * Address1 offset taken fromm bufPtr(currently bufPtr pointing to Qos contorl) variable in reverse direction
+ * Address4 don't exit
+ */
+
+ addressOne = bufPtr- ADDRESS_ONE_OFFSET;
+
+ if (addressOne[0] & 0x1) {
+ /* multicast/broadcast frames, no acknowledgement needed */
+ qc |= 1 << 5;
+ }
+ /* non-AP mode only for now */
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_IBSS ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI) {
+ /* In case of STA and IBSS case eosp and txop limit is 0. */
+ } else {
+ if(bQosNull) {
+ qc |= 1 << 4;
+ }
+ }
+
+ /* append Qos control field to mac header */
+ bufPtr[0] = qc;
+ /* txop limit is 0 */
+ bufPtr[1] = 0;
+ macHeaderLengthInBytes -= QOS_CONTROL_HEADER_SIZE;
+ }
+ if (macHeaderLengthInBytes) {
+ unifi_warning(priv, " Mac header not appended properly\n");
+ return -1;
+ }
+ return 0;
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * send_ma_pkt_request
+ *
+ * These functions send a data packet to UniFi for transmission.
+ * EAP protocol packets are also sent as send_ma_pkt_request().
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * skb Socket buffer containing data packet to transmit
+ * ehdr Pointer to Ethernet header within skb.
+ *
+ * Returns:
+ * Zero on success or error code.
+ * ---------------------------------------------------------------------------
+ */
+
+static int
+send_ma_pkt_request(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr *ehdr, CSR_PRIORITY priority)
+{
+ int r;
+ CsrUint16 i;
+ CsrBool eapolStore = FALSE;
+ struct sk_buff *newSkb = NULL;
+ bulk_data_param_t bulkdata;
+ const int proto = ntohs(ehdr->h_proto);
+ CsrUint16 interfaceTag;
+ CsrWifiMacAddress peerAddress;
+ CSR_TRANSMISSION_CONTROL transmissionControl = CSR_NO_CONFIRM_REQUIRED;
+ CsrInt8 protection;
+ netInterface_priv_t *interfacePriv = NULL;
+ CSR_RATE TransmitRate = (CSR_RATE)0;
+
+ unifi_trace(priv, UDBG5, "entering send_ma_pkt_request\n");
+
+ /* Get the interface Tag by means of source Mac address */
+ for (i = 0; i < CSR_WIFI_NUM_INTERFACES; i++) {
+ if (!memcmp(priv->netdev[i]->dev_addr, ehdr->h_source, ETH_ALEN)) {
+ interfaceTag = i;
+ interfacePriv = priv->interfacePriv[interfaceTag];
+ break;
+ }
+ }
+
+ if (interfacePriv == NULL) {
+ /* No match found - error */
+ interfaceTag = 0;
+ interfacePriv = priv->interfacePriv[interfaceTag];
+ unifi_warning(priv, "Mac address not matching ... debugging needed\n");
+ interfacePriv->stats.tx_dropped++;
+ kfree_skb(skb);
+ return -1;
+ }
+
+ /* Add a SNAP header if necessary */
+ if (skb_add_llc_snap(priv->netdev[interfaceTag], skb, proto) != 0) {
+ /* convert failed */
+ unifi_error(priv, "skb_add_llc_snap failed.\n");
+ kfree_skb(skb);
+ return -1;
+ }
+
+ bulkdata.d[0].os_data_ptr = skb->data;
+ bulkdata.d[0].os_net_buf_ptr = (unsigned char*)skb;
+ bulkdata.d[0].net_buf_length = bulkdata.d[0].data_length = skb->len;
+ bulkdata.d[1].os_data_ptr = NULL;
+ bulkdata.d[1].os_net_buf_ptr = NULL;
+ bulkdata.d[1].net_buf_length = bulkdata.d[1].data_length = 0;
+
+#ifdef CSR_SUPPORT_SME
+ /* Notify the TA module for the Tx frame for non AP/P2PGO mode*/
+ if ((interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_AP) &&
+ (interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_P2PGO)) {
+ unifi_ta_sample(priv->card, CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX,
+ &bulkdata.d[0], ehdr->h_source,
+ priv->netdev[interfaceTag]->dev_addr,
+ jiffies_to_msecs(jiffies),
+ 0); /* rate is unknown on tx */
+ }
+#endif /* CSR_SUPPORT_SME */
+
+ if ((proto == ETH_P_PAE)
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ || (proto == ETH_P_WAI)
+#endif
+ )
+ {
+ /* check for m4 detection */
+ if (0 == uf_verify_m4(priv, bulkdata.d[0].os_data_ptr, bulkdata.d[0].data_length)) {
+ eapolStore = TRUE;
+ }
+ }
+
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ if (proto == ETH_P_WAI)
+ {
+ protection = 0; /*WAI packets always sent unencrypted*/
+ }
+ else
+ {
+#endif
+#ifdef CSR_SUPPORT_SME
+ if ((protection = uf_get_protection_bit_from_interfacemode(priv, interfaceTag, ehdr->h_dest)) < 0) {
+ unifi_warning(priv, "unicast address, but destination not in station record database\n");
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ return -1;
+ }
+#else
+ protection = 0;
+#endif
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ }
+#endif
+
+ /* append Mac header for Eapol as well as data packet */
+ if (prepare_and_add_macheader(priv, skb, newSkb, priority, &bulkdata, interfaceTag, ehdr->h_dest, ehdr->h_source, protection)) {
+ unifi_error(priv, "failed to create MAC header\n");
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ return -1;
+ }
+
+ /* RA adrress must contain the immediate destination MAC address that is similiar to
+ * the Address 1 field of 802.11 Mac header here 4 is: (sizeof(framecontrol) + sizeof (durationID))
+ * which is address 1 field
+ */
+ memcpy(peerAddress.a, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+
+ unifi_trace(priv, UDBG5, "RA[0]=%x, RA[1]=%x, RA[2]=%x, RA[3]=%x, RA[4]=%x, RA[5]=%x\n",
+ peerAddress.a[0],peerAddress.a[1], peerAddress.a[2], peerAddress.a[3],
+ peerAddress.a[4],peerAddress.a[5]);
+
+
+ if ((proto == ETH_P_PAE)
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ || (proto == ETH_P_WAI)
+#endif
+ )
+ {
+ CSR_SIGNAL signal;
+ CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
+
+ /* initialize signal to zero */
+ memset(&signal, 0, sizeof(CSR_SIGNAL));
+
+ /* Frame MA_PACKET request */
+ signal.SignalPrimitiveHeader.SignalId = CSR_MA_PACKET_REQUEST_ID;
+ signal.SignalPrimitiveHeader.ReceiverProcessId = 0;
+ signal.SignalPrimitiveHeader.SenderProcessId = priv->netdev_client->sender_id;
+
+ transmissionControl = req->TransmissionControl = 0;
+#ifdef CSR_SUPPORT_SME
+ if (eapolStore)
+ {
+ netInterface_priv_t *netpriv = (netInterface_priv_t *)netdev_priv(priv->netdev[interfaceTag]);
+
+ /* Fill the MA-PACKET.req */
+
+ req->Priority = priority;
+ unifi_trace(priv, UDBG3, "Tx Frame with Priority: %x\n", req->Priority);
+
+ /* rate selected by firmware */
+ req->TransmitRate = 0;
+ req->HostTag = CSR_WIFI_EAPOL_M4_HOST_TAG;
+ /* RA address matching with address 1 of Mac header */
+ memcpy(req->Ra.x, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+
+ spin_lock(&priv->m4_lock);
+ /* Store the M4-PACKET.req for later */
+ interfacePriv->m4_signal = signal;
+ interfacePriv->m4_bulk_data.net_buf_length = bulkdata.d[0].net_buf_length;
+ interfacePriv->m4_bulk_data.data_length = bulkdata.d[0].data_length;
+ interfacePriv->m4_bulk_data.os_data_ptr = bulkdata.d[0].os_data_ptr;
+ interfacePriv->m4_bulk_data.os_net_buf_ptr = bulkdata.d[0].os_net_buf_ptr;
+ spin_unlock(&priv->m4_lock);
+
+ /* Signal the workqueue to call CsrWifiRouterCtrlM4ReadyToSendIndSend().
+ * It cannot be called directly from the tx path because it
+ * does a non-atomic kmalloc via the framework's CsrPmemAlloc().
+ */
+ queue_work(priv->unifi_workqueue, &netpriv->send_m4_ready_task);
+
+ return 0;
+ }
+#endif
+ }/*EAPOL or WAI packet*/
+
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
+ if ((CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode) && \
+ (priv->wapi_unicast_filter) && \
+ (proto != ETH_P_PAE) && \
+ (proto != ETH_P_WAI) && \
+ (skb->len > 0))
+ {
+ CSR_SIGNAL signal;
+ CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
+ netInterface_priv_t *netpriv = (netInterface_priv_t *)netdev_priv(priv->netdev[interfaceTag]);
+
+ unifi_trace(priv, UDBG4, "send_ma_pkt_request() - WAPI unicast data packet when USKID = 1 \n");
+
+ /* initialize signal to zero */
+ memset(&signal, 0, sizeof(CSR_SIGNAL));
+ /* Frame MA_PACKET request */
+ signal.SignalPrimitiveHeader.SignalId = CSR_MA_PACKET_REQUEST_ID;
+ signal.SignalPrimitiveHeader.ReceiverProcessId = 0;
+ signal.SignalPrimitiveHeader.SenderProcessId = priv->netdev_client->sender_id;
+
+ /* Fill the MA-PACKET.req */
+ req->TransmissionControl = 0;
+ req->Priority = priority;
+ unifi_trace(priv, UDBG3, "Tx Frame with Priority: %x\n", req->Priority);
+ req->TransmitRate = (CSR_RATE) 0; /* rate selected by firmware */
+ req->HostTag = 0xffffffff; /* Ask for a new HostTag */
+ /* RA address matching with address 1 of Mac header */
+ memcpy(req->Ra.x, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+
+ /* Store the M4-PACKET.req for later */
+ spin_lock(&priv->wapi_lock);
+ interfacePriv->wapi_unicast_ma_pkt_sig = signal;
+ interfacePriv->wapi_unicast_bulk_data.net_buf_length = bulkdata.d[0].net_buf_length;
+ interfacePriv->wapi_unicast_bulk_data.data_length = bulkdata.d[0].data_length;
+ interfacePriv->wapi_unicast_bulk_data.os_data_ptr = bulkdata.d[0].os_data_ptr;
+ interfacePriv->wapi_unicast_bulk_data.os_net_buf_ptr = bulkdata.d[0].os_net_buf_ptr;
+ spin_unlock(&priv->wapi_lock);
+
+ /* Signal the workqueue to call CsrWifiRouterCtrlWapiUnicastTxEncryptIndSend().
+ * It cannot be called directly from the tx path because it
+ * does a non-atomic kmalloc via the framework's CsrPmemAlloc().
+ */
+ queue_work(priv->unifi_workqueue, &netpriv->send_pkt_to_encrypt);
+
+ return 0;
+ }
+#endif
+
+ if(priv->cmanrTestMode)
+ {
+ TransmitRate = priv->cmanrTestModeTransmitRate;
+ unifi_trace(priv, UDBG2, "send_ma_pkt_request: cmanrTestModeTransmitRate = %d TransmitRate=%d\n",
+ priv->cmanrTestModeTransmitRate,
+ TransmitRate
+ );
+ }
+
+ /* Send UniFi msg */
+ /* Here hostTag is been sent as 0xffffffff, its been appended properly while framing MA-Packet request in pdu_processing.c file */
+ r = uf_process_ma_packet_req(priv,
+ peerAddress.a,
+ 0xffffffff, /* Ask for a new HostTag */
+ interfaceTag,
+ transmissionControl,
+ TransmitRate,
+ priority,
+ priv->netdev_client->sender_id,
+ &bulkdata);
+
+ if (r) {
+ unifi_trace(priv, UDBG1, "(HIP validation failure) r = %x\n", r);
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ return -1;
+ }
+
+ unifi_trace(priv, UDBG3, "leaving send_ma_pkt_request, UNITDATA result code = %d\n", r);
+
+ return r;
+} /* send_ma_pkt_request() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_net_xmit
+ *
+ * This function is called by the higher level stack to transmit an
+ * ethernet packet.
+ *
+ * Arguments:
+ * skb Ethernet packet to send.
+ * dev Pointer to the linux net device.
+ *
+ * Returns:
+ * 0 on success (packet was consumed, not necessarily transmitted)
+ * 1 if packet was requeued
+ * -1 on error
+ *
+ *
+ * Notes:
+ * The controlled port is handled in the qdisc dequeue handler.
+ * ---------------------------------------------------------------------------
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+static netdev_tx_t
+#else
+static int
+#endif
+uf_net_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct ethhdr ehdr;
+ int proto, port;
+ int result;
+ static tx_signal_handler tx_handler;
+ CSR_PRIORITY priority;
+#if !defined (CONFIG_NET_SCHED) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28))
+ CsrWifiRouterCtrlPortAction port_action;
+#endif /* CONFIG_NET_SCHED */
+
+ func_enter();
+
+ unifi_trace(priv, UDBG5, "unifi_net_xmit: skb = %x\n", skb);
+
+ memcpy(&ehdr, skb->data, ETH_HLEN);
+ proto = ntohs(ehdr.h_proto);
+ priority = get_packet_priority(priv, skb, &ehdr, interfacePriv);
+
+ /* All frames are sent as MA-PACKET.req (EAPOL also) */
+ tx_handler = send_ma_pkt_request;
+
+ /* 802.1x - apply controlled/uncontrolled port rules */
+ if ((proto != ETH_P_PAE)
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ && (proto != ETH_P_WAI)
+#endif
+ ) {
+ port = UF_CONTROLLED_PORT_Q;
+ } else {
+ /* queue 4 */
+ port = UF_UNCONTROLLED_PORT_Q;
+ }
+
+#if defined (CONFIG_NET_SCHED) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28))
+ /* Remove the ethernet header */
+ skb_pull(skb, ETH_HLEN);
+ result = tx_handler(priv, skb, &ehdr, priority);
+#else
+ /* Uncontrolled port rules apply */
+ port_action = verify_port(priv
+ , (((CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode)||(CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI== interfacePriv->interfaceMode))? interfacePriv->bssid.a: ehdr.h_dest)
+ , port
+ , interfacePriv->InterfaceTag);
+
+ if (port_action == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN) {
+ unifi_trace(priv, UDBG5,
+ "uf_net_xmit: %s controlled port open\n",
+ port ? "" : "un");
+ /* Remove the ethernet header */
+ skb_pull(skb, ETH_HLEN);
+ result = tx_handler(priv, skb, &ehdr, priority);
+ } else {
+
+ /* Discard the packet if necessary */
+ unifi_trace(priv, UDBG2,
+ "uf_net_xmit: %s controlled port %s\n",
+ port ? "" : "un", port_action==CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_BLOCK ? "blocked" : "closed");
+ interfacePriv->stats.tx_dropped++;
+ kfree_skb(skb);
+
+ func_exit();
+ return NETDEV_TX_OK;
+ }
+#endif /* CONFIG_NET_SCHED */
+
+ if (result == NETDEV_TX_OK) {
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
+ /* Don't update the tx stats when the pkt is to be sent for sw encryption*/
+ if (!((CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode) &&
+ (priv->wapi_unicast_filter == 1)))
+ {
+ dev->trans_start = jiffies;
+ /* Should really count tx stats in the UNITDATA.status signal but
+ * that doesn't have the length.
+ */
+ interfacePriv->stats.tx_packets++;
+ /* count only the packet payload */
+ interfacePriv->stats.tx_bytes += skb->len;
+
+ }
+#else
+ dev->trans_start = jiffies;
+
+ /*
+ * Should really count tx stats in the UNITDATA.status signal but
+ * that doesn't have the length.
+ */
+ interfacePriv->stats.tx_packets++;
+ /* count only the packet payload */
+ interfacePriv->stats.tx_bytes += skb->len;
+#endif
+ } else if (result < 0) {
+
+ /* Failed to send: fh queue was full, and the skb was discarded.
+ * Return OK to indicate that the buffer was consumed, to stop the
+ * kernel re-transmitting the freed buffer.
+ */
+ interfacePriv->stats.tx_dropped++;
+ unifi_trace(priv, UDBG1, "unifi_net_xmit: (Packet Drop), dropped count = %x\n", interfacePriv->stats.tx_dropped);
+ result = NETDEV_TX_OK;
+ }
+
+ /* The skb will have been freed by send_XXX_request() */
+
+ func_exit();
+ return result;
+} /* uf_net_xmit() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_pause_xmit
+ * unifi_restart_xmit
+ *
+ * These functions are called from the UniFi core to control the flow
+ * of packets from the upper layers.
+ * unifi_pause_xmit() is called when the internal queue is full and
+ * should take action to stop unifi_ma_unitdata() being called.
+ * When the queue has drained, unifi_restart_xmit() will be called to
+ * re-enable the flow of packets for transmission.
+ *
+ * Arguments:
+ * ospriv OS private context pointer.
+ *
+ * Returns:
+ * unifi_pause_xmit() is called from interrupt context.
+ * ---------------------------------------------------------------------------
+ */
+void
+unifi_pause_xmit(void *ospriv, unifi_TrafficQueue queue)
+{
+ unifi_priv_t *priv = ospriv;
+ int i; /* used as a loop counter */
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "Stopping queue %d\n", queue);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+ for(i=0;i<CSR_WIFI_NUM_INTERFACES;i++)
+ {
+ if (netif_running(priv->netdev[i]))
+ {
+ netif_stop_subqueue(priv->netdev[i], (u16)queue);
+ }
+ }
+#else
+#ifdef ALLOW_Q_PAUSE
+ unifi_trace(priv, UDBG2, "Stopping netif\n");
+ /* stop the traffic from all the interfaces. */
+ for(i=0;i<CSR_WIFI_NUM_INTERFACES;i++)
+ {
+ if (netif_running(priv->netdev[i])) {
+ UF_NETIF_TX_STOP_ALL_QUEUES(priv->netdev[i]);
+ }
+ }
+#else
+ if (net_is_tx_q_paused(priv, queue)) {
+ unifi_trace(priv, UDBG2, "Queue already stopped\n");
+ return;
+ }
+ net_tx_q_pause(priv, queue);
+#endif
+#endif
+
+#ifdef CSR_SUPPORT_SME
+ if(queue<=3) {
+ routerStartBuffering(priv,queue);
+ unifi_trace(priv,UDBG2,"Start buffering %d\n", queue);
+ } else {
+ routerStartBuffering(priv,0);
+ unifi_error(priv, "Start buffering %d defaulting to 0\n", queue);
+ }
+#endif
+ func_exit();
+
+} /* unifi_pause_xmit() */
+
+void
+unifi_restart_xmit(void *ospriv, unifi_TrafficQueue queue)
+{
+ unifi_priv_t *priv = ospriv;
+ int i=0; /* used as a loop counter */
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "Waking queue %d\n", queue);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+ for(i=0;i<CSR_WIFI_NUM_INTERFACES;i++)
+ {
+ if (netif_running(priv->netdev[i]))
+ {
+ netif_wake_subqueue(priv->netdev[i], (u16)queue);
+ }
+ }
+#else
+#ifdef ALLOW_Q_PAUSE
+ /* Need to supply queue number depending on Kernel support */
+ /* Resume the traffic from all the interfaces */
+ for(i=0;i<CSR_WIFI_NUM_INTERFACES;i++)
+ {
+ if (netif_running(priv->netdev[i])) {
+ UF_NETIF_TX_WAKE_ALL_QUEUES(priv->netdev[i]);
+ }
+ }
+#else
+ if (!(net_is_tx_q_paused(priv, queue))) {
+ unifi_trace(priv, UDBG2, "Queue already running\n");
+ func_exit();
+ return;
+ }
+ net_tx_q_unpause(priv, queue);
+#endif
+#endif
+
+#ifdef CSR_SUPPORT_SME
+ if(queue <=3) {
+ routerStopBuffering(priv,queue);
+ uf_send_buffered_frames(priv,queue);
+ } else {
+ routerStopBuffering(priv,0);
+ uf_send_buffered_frames(priv,0);
+ }
+#endif
+ func_exit();
+} /* unifi_restart_xmit() */
+
+
+static void
+indicate_rx_skb(unifi_priv_t *priv, CsrUint16 ifTag, CsrUint8* dst_a, CsrUint8* src_a, struct sk_buff *skb, CSR_SIGNAL *signal,
+ bulk_data_param_t *bulkdata)
+{
+ int r, sr = 0;
+ struct net_device *dev;
+
+#ifdef CSR_SUPPORT_SME
+ llc_snap_hdr_t *snap;
+
+ snap = (llc_snap_hdr_t *)skb->data;
+
+ sr = _identify_sme_ma_pkt_ind(priv,
+ snap->oui, ntohs(snap->protocol),
+ signal,
+ bulkdata,
+ dst_a, src_a );
+#endif
+
+ /*
+ * Decapsulate any SNAP header and
+ * prepend an ethernet header so that the skb manipulation and ARP
+ * stuff works.
+ */
+ r = skb_80211_to_ether(priv, skb, dst_a, src_a,
+ signal, bulkdata);
+ if (r == -1) {
+ /* Drop the packet and return */
+ priv->interfacePriv[ifTag]->stats.rx_errors++;
+ priv->interfacePriv[ifTag]->stats.rx_frame_errors++;
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ unifi_notice(priv, "indicate_rx_skb: Discard unknown frame.\n");
+ func_exit();
+ return;
+ }
+
+ /* Handle the case where packet is sent up through the subscription
+ * API but should not be given to the network stack (AMP PAL case)
+ * LLC header is different from WiFi and the packet has been subscribed for
+ */
+ if (r == 1 && sr == 1) {
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ unifi_trace(priv, UDBG5, "indicate_rx_skb: Data given to subscription"
+ "API, not being given to kernel\n");
+ func_exit();
+ return;
+ }
+
+ dev = priv->netdev[ifTag];
+ /* Now we look like a regular ethernet frame */
+ /* Fill in SKB meta data */
+ skb->dev = dev;
+ skb->protocol = eth_type_trans(skb, dev);
+ skb->ip_summed = CHECKSUM_UNNECESSARY;
+
+ /* Test for an overlength frame */
+ if (skb->len > (dev->mtu + ETH_HLEN)) {
+ /* A bogus length ethfrm has been encap'd. */
+ /* Is someone trying an oflow attack? */
+ unifi_error(priv, "%s: oversize frame (%d > %d)\n",
+ dev->name,
+ skb->len, dev->mtu + ETH_HLEN);
+
+ /* Drop the packet and return */
+ priv->interfacePriv[ifTag]->stats.rx_errors++;
+ priv->interfacePriv[ifTag]->stats.rx_length_errors++;
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+
+ if(priv->cmanrTestMode)
+ {
+ const CSR_MA_PACKET_INDICATION *pkt_ind = &signal->u.MaPacketIndication;
+ priv->cmanrTestModeTransmitRate = pkt_ind->ReceivedRate;
+ unifi_trace(priv, UDBG2, "indicate_rx_skb: cmanrTestModeTransmitRate=%d\n", priv->cmanrTestModeTransmitRate);
+ }
+
+ /* Pass SKB up the stack */
+#ifdef CSR_WIFI_USE_NETIF_RX
+ netif_rx(skb);
+#else
+ netif_rx_ni(skb);
+#endif
+
+ if (dev != NULL) {
+ dev->last_rx = jiffies;
+ }
+
+ /* Bump rx stats */
+ priv->interfacePriv[ifTag]->stats.rx_packets++;
+ priv->interfacePriv[ifTag]->stats.rx_bytes += bulkdata->d[0].data_length;
+
+ func_exit();
+ return;
+}
+
+void
+uf_process_rx_pending_queue(unifi_priv_t *priv, int queue,
+ CsrWifiMacAddress source_address,
+ int indicate, CsrUint16 interfaceTag)
+{
+ rx_buffered_packets_t *rx_q_item;
+ struct list_head *rx_list;
+ struct list_head *n;
+ struct list_head *l_h;
+ static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "uf_process_rx_pending_queue bad interfaceTag\n");
+ return;
+ }
+
+ if (queue == UF_CONTROLLED_PORT_Q) {
+ rx_list = &interfacePriv->rx_controlled_list;
+ } else {
+ rx_list = &interfacePriv->rx_uncontrolled_list;
+ }
+
+ down(&priv->rx_q_sem);
+ list_for_each_safe(l_h, n, rx_list) {
+ rx_q_item = list_entry(l_h, rx_buffered_packets_t, q);
+
+ /* Validate against the source address */
+ if (memcmp(broadcast_address.a, source_address.a, ETH_ALEN) &&
+ memcmp(rx_q_item->sa.a, source_address.a, ETH_ALEN)) {
+
+ unifi_trace(priv, UDBG2,
+ "uf_process_rx_pending_queue: Skipping sa=%02X%02X%02X%02X%02X%02X skb=%p, bulkdata=%p\n",
+ rx_q_item->sa.a[0], rx_q_item->sa.a[1],
+ rx_q_item->sa.a[2], rx_q_item->sa.a[3],
+ rx_q_item->sa.a[4], rx_q_item->sa.a[5],
+ rx_q_item->skb, &rx_q_item->bulkdata.d[0]);
+ continue;
+ }
+
+ list_del(l_h);
+
+
+ unifi_trace(priv, UDBG2,
+ "uf_process_rx_pending_queue: Was Blocked skb=%p, bulkdata=%p\n",
+ rx_q_item->skb, &rx_q_item->bulkdata);
+
+ if (indicate) {
+ indicate_rx_skb(priv, interfaceTag, rx_q_item->da.a, rx_q_item->sa.a, rx_q_item->skb, &rx_q_item->signal, &rx_q_item->bulkdata);
+ } else {
+ interfacePriv->stats.rx_dropped++;
+ unifi_net_data_free(priv, &rx_q_item->bulkdata.d[0]);
+ }
+
+ /* It is our resposibility to free the Rx structure object. */
+ kfree(rx_q_item);
+ }
+ up(&priv->rx_q_sem);
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_resume_data_plane
+ *
+ * Is called when the (un)controlled port is set to open,
+ * to notify the network stack to schedule for transmission
+ * any packets queued in the qdisk while port was closed and
+ * indicated to the stack any packets buffered in the Rx queues.
+ *
+ * Arguments:
+ * priv Pointer to device private struct
+ *
+ * Returns:
+ * ---------------------------------------------------------------------------
+ */
+void
+uf_resume_data_plane(unifi_priv_t *priv, int queue,
+ CsrWifiMacAddress peer_address,
+ CsrUint16 interfaceTag)
+{
+#ifdef CSR_SUPPORT_WEXT
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+#endif
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "uf_resume_data_plane bad interfaceTag\n");
+ return;
+ }
+
+ unifi_trace(priv, UDBG2, "Resuming netif\n");
+
+ /*
+ * If we are waiting for the net device to enter the up state, don't
+ * process the rx queue yet as it will be done by the callback when
+ * the device is ready.
+ */
+#ifdef CSR_SUPPORT_WEXT
+ if (!interfacePriv->wait_netdev_change)
+#endif
+ {
+#ifdef CONFIG_NET_SCHED
+ if (netif_running(priv->netdev[interfaceTag])) {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)
+ netif_tx_schedule_all(priv->netdev[interfaceTag]);
+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+ netif_schedule_queue(netdev_get_tx_queue(priv->netdev[interfaceTag], 0));
+#else
+ netif_schedule(priv->netdev[interfaceTag]);
+#endif /* LINUX_VERSION_CODE */
+ }
+#endif
+ uf_process_rx_pending_queue(priv, queue, peer_address, 1,interfaceTag);
+ }
+} /* uf_resume_data_plane() */
+
+
+void uf_free_pending_rx_packets(unifi_priv_t *priv, int queue, CsrWifiMacAddress peer_address,CsrUint16 interfaceTag)
+{
+ uf_process_rx_pending_queue(priv, queue, peer_address, 0,interfaceTag);
+
+} /* uf_free_pending_rx_packets() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_rx
+ *
+ * Reformat a UniFi data received packet into a p80211 packet and
+ * pass it up the protocol stack.
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void
+unifi_rx(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
+{
+ CsrUint16 interfaceTag;
+ bulk_data_desc_t *pData;
+ const CSR_MA_PACKET_INDICATION *pkt_ind = &signal->u.MaPacketIndication;
+ struct sk_buff *skb;
+ CsrWifiRouterCtrlPortAction port_action;
+ CsrUint8 dataFrameType;
+ int proto;
+ int queue;
+
+ CsrUint8 da[ETH_ALEN], sa[ETH_ALEN];
+ CsrUint8 toDs, fromDs, frameType, macHeaderLengthInBytes = MAC_HEADER_SIZE;
+ CsrUint16 frameControl;
+ netInterface_priv_t *interfacePriv;
+ struct ethhdr ehdr;
+
+ func_enter();
+
+ interfaceTag = (pkt_ind->VirtualInterfaceIdentifier & 0xff);
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ /* Sanity check that the VIF refers to a sensible interface */
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES)
+ {
+ unifi_error(priv, "%s: MA-PACKET indication with bad interfaceTag %d\n", __FUNCTION__, interfaceTag);
+ unifi_net_data_free(priv,&bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+ /* Sanity check that the VIF refers to an allocated netdev */
+ if (!interfacePriv->netdev_registered)
+ {
+ unifi_error(priv, "%s: MA-PACKET indication with unallocated interfaceTag %d\n", __FUNCTION__, interfaceTag);
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+ if (bulkdata->d[0].data_length == 0) {
+ unifi_warning(priv, "%s: MA-PACKET indication with zero bulk data\n", __FUNCTION__);
+ unifi_net_data_free(priv,&bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+
+ skb = (struct sk_buff*)bulkdata->d[0].os_net_buf_ptr;
+ skb->len = bulkdata->d[0].data_length;
+
+ /* Point to the addresses */
+ toDs = (skb->data[1] & 0x01) ? 1 : 0;
+ fromDs = (skb->data[1] & 0x02) ? 1 : 0;
+
+ memcpy(da,(skb->data+4+toDs*12),ETH_ALEN);/* Address1 or 3 */
+ memcpy(sa,(skb->data+10+fromDs*(6+toDs*8)),ETH_ALEN); /* Address2, 3 or 4 */
+
+
+ pData = &bulkdata->d[0];
+ frameControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(pData->os_data_ptr);
+ frameType = ((frameControl & 0x000C) >> 2);
+
+ dataFrameType =((frameControl & 0x00f0) >> 4);
+ unifi_trace(priv, UDBG6,
+ "%s: Receive Data Frame Type %d \n", __FUNCTION__,dataFrameType);
+
+ switch(dataFrameType)
+ {
+ case QOS_DATA:
+ case QOS_DATA_NULL:
+ /* If both are set then the Address4 exists (only for AP) */
+ if (fromDs && toDs)
+ {
+ /* 6 is the size of Address4 field */
+ macHeaderLengthInBytes += (QOS_CONTROL_HEADER_SIZE + 6);
+ }
+ else
+ {
+ macHeaderLengthInBytes += QOS_CONTROL_HEADER_SIZE;
+ }
+
+ /* If order bit set then HT control field is the part of MAC header */
+ if (frameControl & FRAME_CONTROL_ORDER_BIT)
+ macHeaderLengthInBytes += HT_CONTROL_HEADER_SIZE;
+ break;
+ default:
+ if (fromDs && toDs)
+ macHeaderLengthInBytes += 6;
+ }
+
+ /* Prepare the ethernet header from snap header of skb data */
+ switch(dataFrameType)
+ {
+ case DATA_NULL:
+ case QOS_DATA_NULL:
+ /* This is for only queue info fetching, EAPOL wont come as
+ * null data so the proto is initialized as zero
+ */
+ proto = 0x0;
+ break;
+ default:
+ {
+ llc_snap_hdr_t *snap;
+ /* Fetch a snap header to find protocol (for IPV4/IPV6 packets
+ * the snap header fetching offset is same)
+ */
+ snap = (llc_snap_hdr_t *) (skb->data + macHeaderLengthInBytes);
+
+ /* prepare the ethernet header from the snap header & addresses */
+ ehdr.h_proto = snap->protocol;
+ memcpy(ehdr.h_dest, da, ETH_ALEN);
+ memcpy(ehdr.h_source, sa, ETH_ALEN);
+ }
+ proto = ntohs(ehdr.h_proto);
+ }
+ unifi_trace(priv, UDBG3, "in unifi_rx protocol from snap header = 0x%x\n", proto);
+
+ if ((proto != ETH_P_PAE)
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ && (proto != ETH_P_WAI)
+#endif
+ ) {
+ queue = UF_CONTROLLED_PORT_Q;
+ } else {
+ queue = UF_UNCONTROLLED_PORT_Q;
+ }
+
+ port_action = verify_port(priv, (unsigned char*)sa, queue, interfaceTag);
+ unifi_trace(priv, UDBG3, "in unifi_rx port action is = 0x%x & queue = %x\n", port_action, queue);
+
+#ifdef CSR_SUPPORT_SME
+ /* Notify the TA module for the Rx frame for non P2PGO and AP cases*/
+ if((interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_AP) &&
+ (interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_P2PGO))
+ {
+ /* Remove MAC header of length(macHeaderLengthInBytes) before sampling */
+ skb_pull(skb, macHeaderLengthInBytes);
+ pData->os_data_ptr = skb->data;
+ pData->data_length -= macHeaderLengthInBytes;
+
+ if (pData->data_length) {
+ unifi_ta_sample(priv->card, CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_RX,
+ &bulkdata->d[0],
+ sa, priv->netdev[interfaceTag]->dev_addr,
+ jiffies_to_msecs(jiffies),
+ pkt_ind->ReceivedRate);
+ }
+ } else {
+
+ /* AP/P2PGO specific handling here */
+ CsrWifiRouterCtrlStaInfo_t * srcStaInfo =
+ CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,sa,interfaceTag);
+
+ /* Defensive check only; Source address is already checked in
+ process_ma_packet_ind and we should have a valid source address here */
+
+ if(srcStaInfo == NULL) {
+ CsrWifiMacAddress peerMacAddress;
+ /* Unknown data PDU */
+ memcpy(peerMacAddress.a,sa,ETH_ALEN);
+ unifi_trace(priv, UDBG1, "%s: Unexpected frame from peer = %x:%x:%x:%x:%x:%x\n", __FUNCTION__,
+ sa[0], sa[1],sa[2], sa[3], sa[4],sa[5]);
+ CsrWifiRouterCtrlUnexpectedFrameIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,interfaceTag,peerMacAddress);
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+ /* For AP GO mode, don't store the PDUs */
+ if (port_action != CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN) {
+ /* Drop the packet and return */
+ CsrWifiMacAddress peerMacAddress;
+ memcpy(peerMacAddress.a,sa,ETH_ALEN);
+ unifi_trace(priv, UDBG3, "%s: Port is not open: unexpected frame from peer = %x:%x:%x:%x:%x:%x\n",
+ __FUNCTION__, sa[0], sa[1],sa[2], sa[3], sa[4],sa[5]);
+
+ CsrWifiRouterCtrlUnexpectedFrameIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,interfaceTag,peerMacAddress);
+ interfacePriv->stats.rx_dropped++;
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ unifi_notice(priv, "%s: Dropping packet, proto=0x%04x, %s port\n", __FUNCTION__,
+ proto, queue ? "Controlled" : "Un-controlled");
+ func_exit();
+ return;
+ }
+
+ /* Qos NULL/Data NULL are freed here and not processed further */
+ if((dataFrameType == QOS_DATA_NULL) || (dataFrameType == DATA_NULL)){
+ unifi_trace(priv, UDBG5, "%s: Null Frame Received and Freed\n", __FUNCTION__);
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+ /* Now we have done with MAC header so proceed with the real data part*/
+ /* This function takes care of appropriate routing for AP/P2PGO case*/
+ /* the function hadnles following things
+ 2. Routing the PDU to appropriate location
+ 3. Error case handling
+ */
+ if(!(uf_ap_process_data_pdu(priv, skb, &ehdr, srcStaInfo,
+ signal,
+ bulkdata,
+ macHeaderLengthInBytes)))
+ {
+ func_exit();
+ return;
+ }
+ unifi_trace(priv, UDBG5, "unifi_rx: no specific AP handling process as normal frame, MAC Header len %d\n",macHeaderLengthInBytes);
+ /* Remove the MAC header for subsequent conversion */
+ skb_pull(skb, macHeaderLengthInBytes);
+ pData->os_data_ptr = skb->data;
+ pData->data_length -= macHeaderLengthInBytes;
+ pData->os_net_buf_ptr = (unsigned char*)skb;
+ pData->net_buf_length = skb->len;
+ }
+#endif /* CSR_SUPPORT_SME */
+
+
+ /* Now that the MAC header is removed, null-data frames have zero length
+ * and can be dropped
+ */
+ if (pData->data_length == 0) {
+ if (((frameControl & 0x00f0) >> 4) != QOS_DATA_NULL &&
+ ((frameControl & 0x00f0) >> 4) != DATA_NULL) {
+ unifi_trace(priv, UDBG1, "Zero length frame, but not null-data %04x\n", frameControl);
+ }
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+ if (port_action == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD) {
+ /* Drop the packet and return */
+ interfacePriv->stats.rx_dropped++;
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ unifi_notice(priv, "%s: Dropping packet, proto=0x%04x, %s port\n",
+ __FUNCTION__, proto, queue ? "controlled" : "uncontrolled");
+ func_exit();
+ return;
+ } else if ( (port_action == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_BLOCK) ||
+ (interfacePriv->connected != UnifiConnected) ) {
+
+ /* Buffer the packet into the Rx queues */
+ rx_buffered_packets_t *rx_q_item;
+ struct list_head *rx_list;
+
+ rx_q_item = (rx_buffered_packets_t *)kmalloc(sizeof(rx_buffered_packets_t),
+ GFP_KERNEL);
+ if (rx_q_item == NULL) {
+ unifi_error(priv, "%s: Failed to allocate %d bytes for rx packet record\n",
+ __FUNCTION__, sizeof(rx_buffered_packets_t));
+ interfacePriv->stats.rx_dropped++;
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+ INIT_LIST_HEAD(&rx_q_item->q);
+ rx_q_item->bulkdata = *bulkdata;
+ rx_q_item->skb = skb;
+ rx_q_item->signal = *signal;
+ memcpy(rx_q_item->sa.a, sa, ETH_ALEN);
+ memcpy(rx_q_item->da.a, da, ETH_ALEN);
+ unifi_trace(priv, UDBG2, "%s: Blocked skb=%p, bulkdata=%p\n",
+ __FUNCTION__, rx_q_item->skb, &rx_q_item->bulkdata);
+
+ if (queue == UF_CONTROLLED_PORT_Q) {
+ rx_list = &interfacePriv->rx_controlled_list;
+ } else {
+ rx_list = &interfacePriv->rx_uncontrolled_list;
+ }
+
+ /* Add to tail of packets queue */
+ down(&priv->rx_q_sem);
+ list_add_tail(&rx_q_item->q, rx_list);
+ up(&priv->rx_q_sem);
+
+ func_exit();
+ return;
+
+ }
+
+ indicate_rx_skb(priv, interfaceTag, da, sa, skb, signal, bulkdata);
+
+ func_exit();
+
+} /* unifi_rx() */
+
+static void process_ma_packet_cfm(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
+{
+ CsrUint16 interfaceTag;
+ const CSR_MA_PACKET_CONFIRM *pkt_cfm = &signal->u.MaPacketConfirm;
+ netInterface_priv_t *interfacePriv;
+
+ func_enter();
+ interfaceTag = (pkt_cfm->VirtualInterfaceIdentifier & 0xff);
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ /* Sanity check that the VIF refers to a sensible interface */
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES)
+ {
+ unifi_error(priv, "%s: MA-PACKET confirm with bad interfaceTag %d\n", __FUNCTION__, interfaceTag);
+ func_exit();
+ return;
+ }
+#ifdef CSR_SUPPORT_SME
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+
+ uf_process_ma_pkt_cfm_for_ap(priv,interfaceTag,pkt_cfm);
+ } else if (interfacePriv->m4_sent && (pkt_cfm->HostTag == interfacePriv->m4_hostTag)) {
+ /* Check if this is a confirm for EAPOL M4 frame and we need to send transmistted ind*/
+ CsrResult result = pkt_cfm->TransmissionStatus == CSR_TX_SUCCESSFUL?CSR_RESULT_SUCCESS:CSR_RESULT_FAILURE;
+ CsrWifiMacAddress peerMacAddress;
+ memcpy(peerMacAddress.a, interfacePriv->m4_signal.u.MaPacketRequest.Ra.x, ETH_ALEN);
+
+ unifi_trace(priv, UDBG1, "%s: Sending M4 Transmit CFM\n", __FUNCTION__);
+ CsrWifiRouterCtrlM4TransmittedIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0,
+ interfaceTag,
+ peerMacAddress,
+ result);
+ interfacePriv->m4_sent = FALSE;
+ interfacePriv->m4_hostTag = 0xffffffff;
+ }
+#endif
+ func_exit();
+ return;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_rx
+ *
+ * Reformat a UniFi data received packet into a p80211 packet and
+ * pass it up the protocol stack.
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void process_ma_packet_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
+{
+ CsrUint16 interfaceTag;
+ bulk_data_desc_t *pData;
+ CSR_MA_PACKET_INDICATION *pkt_ind = (CSR_MA_PACKET_INDICATION*)&signal->u.MaPacketIndication;
+ struct sk_buff *skb;
+ CsrUint16 frameControl;
+ netInterface_priv_t *interfacePriv;
+ CsrUint8 da[ETH_ALEN], sa[ETH_ALEN];
+ CsrUint8 *bssid = NULL, *ba_addr = NULL;
+ CsrUint8 toDs, fromDs, frameType;
+ CsrUint8 i =0;
+
+#ifdef CSR_SUPPORT_SME
+ CsrUint8 dataFrameType = 0;
+ CsrBool powerSaveChanged = FALSE;
+ CsrUint8 pmBit = 0;
+ CsrWifiRouterCtrlStaInfo_t *srcStaInfo = NULL;
+ CsrUint16 qosControl;
+
+#endif
+
+ func_enter();
+
+ interfaceTag = (pkt_ind->VirtualInterfaceIdentifier & 0xff);
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+
+ /* Sanity check that the VIF refers to a sensible interface */
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES)
+ {
+ unifi_error(priv, "%s: MA-PACKET indication with bad interfaceTag %d\n", __FUNCTION__, interfaceTag);
+ unifi_net_data_free(priv,&bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+ /* Sanity check that the VIF refers to an allocated netdev */
+ if (!interfacePriv->netdev_registered)
+ {
+ unifi_error(priv, "%s: MA-PACKET indication with unallocated interfaceTag %d\n", __FUNCTION__, interfaceTag);
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+ if (bulkdata->d[0].data_length == 0) {
+ unifi_warning(priv, "%s: MA-PACKET indication with zero bulk data\n", __FUNCTION__);
+ unifi_net_data_free(priv,&bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+ /* For monitor mode we need to pass this indication to the registered application
+ handle this seperately*/
+ /* MIC failure is already taken care of so no need to send the PDUs which are not successfully received in non-monitor mode*/
+ if(pkt_ind->ReceptionStatus != CSR_RX_SUCCESS)
+ {
+ unifi_warning(priv, "%s: MA-PACKET indication with status = %d\n",__FUNCTION__, pkt_ind->ReceptionStatus);
+ unifi_net_data_free(priv,&bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+
+ skb = (struct sk_buff*)bulkdata->d[0].os_net_buf_ptr;
+ skb->len = bulkdata->d[0].data_length;
+
+ /* Point to the addresses */
+ toDs = (skb->data[1] & 0x01) ? 1 : 0;
+ fromDs = (skb->data[1] & 0x02) ? 1 : 0;
+
+ memcpy(da,(skb->data+4+toDs*12),ETH_ALEN);/* Address1 or 3 */
+ memcpy(sa,(skb->data+10+fromDs*(6+toDs*8)),ETH_ALEN); /* Address2, 3 or 4 */
+
+ /* Find the BSSID, which will be used to match the BA session */
+ if (toDs && fromDs)
+ {
+ unifi_trace(priv, UDBG6, "4 address frame - don't try to find BSSID\n");
+ bssid = NULL;
+ }
+ else
+ {
+ bssid = (CsrUint8 *) (skb->data + 4 + 12 - (fromDs * 6) - (toDs * 12));
+ }
+
+ pData = &bulkdata->d[0];
+ frameControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(pData->os_data_ptr);
+ frameType = ((frameControl & 0x000C) >> 2);
+
+ unifi_trace(priv, UDBG3, "Rx Frame Type: %d sn: %d\n",frameType,
+ (le16_to_cpu(*((CsrUint16*)(bulkdata->d[0].os_data_ptr + IEEE802_11_SEQUENCE_CONTROL_OFFSET))) >> 4) & 0xfff);
+ if(frameType == IEEE802_11_FRAMETYPE_CONTROL){
+#ifdef CSR_SUPPORT_SME
+ unifi_trace(priv, UDBG6, "%s: Received Control Frame\n", __FUNCTION__);
+
+ if((frameControl & 0x00f0) == 0x00A0){
+ /* This is a PS-POLL request */
+ CsrUint8 pmBit = (frameControl & 0x1000)?0x01:0x00;
+ unifi_trace(priv, UDBG6, "%s: Received PS-POLL Frame\n", __FUNCTION__);
+
+ uf_process_ps_poll(priv,sa,da,pmBit,interfaceTag);
+ }
+ else {
+ unifi_warning(priv, "%s: Non PS-POLL control frame is received\n", __FUNCTION__);
+ }
+#endif
+ unifi_net_data_free(priv,&bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+ if(frameType != IEEE802_11_FRAMETYPE_DATA) {
+ unifi_warning(priv, "%s: Non control Non Data frame is received\n",__FUNCTION__);
+ unifi_net_data_free(priv,&bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+#ifdef CSR_SUPPORT_SME
+ if((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP) ||
+ (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO)){
+
+ srcStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,sa,interfaceTag);
+
+ if(srcStaInfo == NULL) {
+ CsrWifiMacAddress peerMacAddress;
+ /* Unknown data PDU */
+ memcpy(peerMacAddress.a,sa,ETH_ALEN);
+ unifi_trace(priv, UDBG1, "%s: Unexpected frame from peer = %x:%x:%x:%x:%x:%x\n", __FUNCTION__,
+ sa[0], sa[1],sa[2], sa[3], sa[4],sa[5]);
+ CsrWifiRouterCtrlUnexpectedFrameIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,interfaceTag,peerMacAddress);
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ func_exit();
+ return;
+ }
+
+ /*
+ verify power management bit here so as to ensure host and unifi are always
+ in sync with power management status of peer.
+
+ If we do it later, it may so happen we have stored the frame in BA re-ordering
+ buffer and hence host and unifi are out of sync for power management status
+ */
+
+ pmBit = (frameControl & 0x1000)?0x01:0x00;
+ powerSaveChanged = uf_process_pm_bit_for_peer(priv,srcStaInfo,pmBit,interfaceTag);
+
+ /* Update station last activity time */
+ srcStaInfo->activity_flag = TRUE;
+
+ /* For Qos Frame if PM bit is toggled to indicate the change in power save state then it shall not be
+ considered as Trigger Frame. Enter only if WMM STA and peer is in Power save */
+
+ dataFrameType = ((frameControl & 0x00f0) >> 4);
+
+ if((powerSaveChanged == FALSE)&&(srcStaInfo->wmmOrQosEnabled == TRUE)&&
+ (srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)){
+
+ if((dataFrameType == QOS_DATA) || (dataFrameType == QOS_DATA_NULL)){
+
+ /*
+ * QoS control field is offset from frame control by 2 (frame control)
+ * + 2 (duration/ID) + 2 (sequence control) + 3*ETH_ALEN or 4*ETH_ALEN
+ */
+ if((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK)){
+ qosControl= CSR_GET_UINT16_FROM_LITTLE_ENDIAN(pData->os_data_ptr + 30);
+ }
+ else{
+ qosControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(pData->os_data_ptr + 24);
+ }
+ unifi_trace(priv, UDBG5, "%s: Check if U-APSD operations are triggered for qosControl: 0x%x\n",__FUNCTION__,qosControl);
+ uf_process_wmm_deliver_ac_uapsd(priv,srcStaInfo,qosControl,interfaceTag);
+ }
+ }
+ }
+
+#endif
+
+ if( ((frameControl & 0x00f0) >> 4) == QOS_DATA) {
+ CsrUint8 *qos_control_ptr = (CsrUint8*)bulkdata->d[0].os_data_ptr + (((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK))?30: 24);
+ int tID = *qos_control_ptr & IEEE802_11_QC_TID_MASK; /* using ls octet of qos control */
+ ba_session_rx_struct *ba_session;
+ CsrUint8 ba_session_idx = 0;
+ /* Get the BA originator address */
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO){
+ ba_addr = sa;
+ }else{
+ ba_addr = bssid;
+ }
+
+ down(&priv->ba_mutex);
+ for (ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_RX; ba_session_idx++){
+ ba_session = interfacePriv->ba_session_rx[ba_session_idx];
+ if (ba_session){
+ unifi_trace(priv, UDBG6, "found ba_session=0x%x ba_session_idx=%d", ba_session, ba_session_idx);
+ if ((!memcmp(ba_session->macAddress.a, ba_addr, ETH_ALEN)) && (ba_session->tID == tID)){
+ frame_desc_struct frame_desc;
+ frame_desc.bulkdata = *bulkdata;
+ frame_desc.signal = *signal;
+ frame_desc.sn = (le16_to_cpu(*((CsrUint16*)(bulkdata->d[0].os_data_ptr + IEEE802_11_SEQUENCE_CONTROL_OFFSET))) >> 4) & 0xfff;
+ frame_desc.active = TRUE;
+ unifi_trace(priv, UDBG6, "%s: calling process_ba_frame (session=%d)\n", __FUNCTION__, ba_session_idx);
+ process_ba_frame(priv, interfacePriv, ba_session, &frame_desc);
+ up(&priv->ba_mutex);
+ process_ba_complete(priv, interfacePriv);
+ break;
+ }
+ }
+ }
+ if (ba_session_idx == MAX_SUPPORTED_BA_SESSIONS_RX){
+ up(&priv->ba_mutex);
+ unifi_trace(priv, UDBG6, "%s: calling process_amsdu()", __FUNCTION__);
+ process_amsdu(priv, signal, bulkdata);
+ }
+ } else {
+ unifi_trace(priv, UDBG6, "calling unifi_rx()");
+ unifi_rx(priv, signal, bulkdata);
+ }
+
+ /* check if the frames in reorder buffer has aged, the check
+ * is done after receive processing so that if the missing frame
+ * has arrived in this receive process, then it is handled cleanly.
+ *
+ * And also this code here takes care that timeout check is made for all
+ * the receive indications
+ */
+ down(&priv->ba_mutex);
+ for (i=0; i < MAX_SUPPORTED_BA_SESSIONS_RX; i++){
+ ba_session_rx_struct *ba_session;
+ ba_session = interfacePriv->ba_session_rx[i];
+ if (ba_session){
+ check_ba_frame_age_timeout(priv, interfacePriv, ba_session);
+ }
+ }
+ up(&priv->ba_mutex);
+ process_ba_complete(priv, interfacePriv);
+
+ func_exit();
+}
+/*
+ * ---------------------------------------------------------------------------
+ * uf_set_multicast_list
+ *
+ * This function is called by the higher level stack to set
+ * a list of multicast rx addresses.
+ *
+ * Arguments:
+ * dev Network Device pointer.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * ---------------------------------------------------------------------------
+ */
+
+static void
+uf_set_multicast_list(struct net_device *dev)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+
+#ifdef CSR_NATIVE_LINUX
+ unifi_trace(priv, UDBG3, "uf_set_multicast_list unsupported\n");
+ return;
+#else
+
+ u8 *mc_list = interfacePriv->mc_list;
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,34)
+ struct netdev_hw_addr *mc_addr;
+ int mc_addr_count;
+#else
+ struct dev_mc_list *p; /* Pointer to the addresses structure. */
+ int i;
+#endif
+
+ if (priv->init_progress != UNIFI_INIT_COMPLETED) {
+ return;
+ }
+
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,34)
+ mc_addr_count = netdev_mc_count(dev);
+
+ unifi_trace(priv, UDBG3,
+ "uf_set_multicast_list (count=%d)\n", mc_addr_count);
+
+
+ /* Not enough space? */
+ if (mc_addr_count > UNIFI_MAX_MULTICAST_ADDRESSES) {
+ return;
+ }
+
+ /* Store the list to be processed by the work item. */
+ interfacePriv->mc_list_count = mc_addr_count;
+ netdev_hw_addr_list_for_each(mc_addr, &dev->mc) {
+ memcpy(mc_list, mc_addr->addr, ETH_ALEN);
+ mc_list += ETH_ALEN;
+ }
+
+#else
+ unifi_trace(priv, UDBG3,
+ "uf_set_multicast_list (count=%d)\n", dev->mc_count);
+
+ /* Not enough space? */
+ if (dev->mc_count > UNIFI_MAX_MULTICAST_ADDRESSES) {
+ return;
+ }
+
+ /* Store the list to be processed by the work item. */
+ interfacePriv->mc_list_count = dev->mc_count;
+ p = dev->mc_list;
+ for (i = 0; i < dev->mc_count; i++) {
+ memcpy(mc_list, p->dmi_addr, ETH_ALEN);
+ p = p->next;
+ mc_list += ETH_ALEN;
+ }
+#endif
+
+ /* Send a message to the workqueue */
+ queue_work(priv->unifi_workqueue, &priv->multicast_list_task);
+#endif
+
+} /* uf_set_multicast_list() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * netdev_mlme_event_handler
+ *
+ * Callback function to be used as the udi_event_callback when registering
+ * as a netdev client.
+ * To use it, a client specifies this function as the udi_event_callback
+ * to ul_register_client(). The signal dispatcher in
+ * unifi_receive_event() will call this function to deliver a signal.
+ *
+ * Arguments:
+ * pcli Pointer to the client instance.
+ * signal Pointer to the received signal.
+ * signal_len Size of the signal structure in bytes.
+ * bulkdata Pointer to structure containing any associated bulk data.
+ * dir Direction of the signal. Zero means from host,
+ * non-zero means to host.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void
+netdev_mlme_event_handler(ul_client_t *pcli, const u8 *sig_packed, int sig_len,
+ const bulk_data_param_t *bulkdata_o, int dir)
+{
+ CSR_SIGNAL signal;
+ unifi_priv_t *priv = uf_find_instance(pcli->instance);
+ int id, r;
+ bulk_data_param_t bulkdata;
+
+ func_enter();
+
+ /* Just a sanity check */
+ if (sig_packed == NULL) {
+ return;
+ }
+
+ /*
+ * This copy is to silence a compiler warning about discarding the
+ * const qualifier.
+ */
+ bulkdata = *bulkdata_o;
+
+ /* Get the unpacked signal */
+ r = read_unpack_signal(sig_packed, &signal);
+ if (r) {
+ /*
+ * The CSR_MLME_CONNECTED_INDICATION_ID has a receiverID=0 so will
+ * fall through this case. It is safe to ignore this signal.
+ */
+ unifi_trace(priv, UDBG1,
+ "Netdev - Received unknown signal 0x%.4X.\n",
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sig_packed));
+ return;
+ }
+
+ id = signal.SignalPrimitiveHeader.SignalId;
+ unifi_trace(priv, UDBG3, "Netdev - Process signal 0x%.4X\n", id);
+
+ /*
+ * Take the appropriate action for the signal.
+ */
+ switch (id) {
+ case CSR_MA_PACKET_ERROR_INDICATION_ID:
+ process_ma_packet_error_ind(priv, &signal, &bulkdata);
+ break;
+ case CSR_MA_PACKET_INDICATION_ID:
+ process_ma_packet_ind(priv, &signal, &bulkdata);
+ break;
+ case CSR_MA_PACKET_CONFIRM_ID:
+ process_ma_packet_cfm(priv, &signal, &bulkdata);
+ break;
+#ifdef CSR_SUPPORT_SME
+ case CSR_MLME_SET_TIM_CONFIRM_ID:
+ /* Handle TIM confirms from FW & set the station record's TIM state appropriately,
+ * In case of failures, tries with max_retransmit limit
+ */
+ uf_handle_tim_cfm(priv, &signal.u.MlmeSetTimConfirm, signal.SignalPrimitiveHeader.ReceiverProcessId);
+ break;
+#endif
+ case CSR_DEBUG_STRING_INDICATION_ID:
+ debug_string_indication(priv, bulkdata.d[0].os_data_ptr, bulkdata.d[0].data_length);
+ break;
+
+ case CSR_DEBUG_WORD16_INDICATION_ID:
+ debug_word16_indication(priv, &signal);
+ break;
+
+ case CSR_DEBUG_GENERIC_CONFIRM_ID:
+ case CSR_DEBUG_GENERIC_INDICATION_ID:
+ debug_generic_indication(priv, &signal);
+ break;
+ default:
+ break;
+ }
+
+ func_exit();
+} /* netdev_mlme_event_handler() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_net_get_name
+ *
+ * Retrieve the name (e.g. eth1) associated with this network device
+ *
+ * Arguments:
+ * dev Pointer to the network device.
+ * name Buffer to write name
+ * len Size of buffer in bytes
+ *
+ * Returns:
+ * None
+ *
+ * Notes:
+ * ---------------------------------------------------------------------------
+ */
+void uf_net_get_name(struct net_device *dev, char *name, int len)
+{
+ *name = '\0';
+ if (dev) {
+ strlcpy(name, dev->name, (len > IFNAMSIZ) ? IFNAMSIZ : len);
+ }
+
+} /* uf_net_get_name */
+
+
+
+
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
+#ifdef CONFIG_NET_SCHED
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_install_qdisc
+ *
+ * Creates a root qdisc, registers our qdisc handlers and
+ * overrides the device's qdisc_sleeping to prevent the system
+ * from creating a new one for our network device.
+ *
+ * Arguments:
+ * dev Pointer to the network device.
+ *
+ * Returns:
+ * 0 on success, Linux error code otherwise.
+ *
+ * Notes:
+ * This function holds the qdisk lock so it needs to be called
+ * after registering the network device in uf_register_netdev().
+ * Also, the qdisc_create_dflt() API has changed in 2.6.20 to
+ * include the parentid.
+ * ---------------------------------------------------------------------------
+ */
+int uf_install_qdisc(struct net_device *dev)
+{
+ struct Qdisc *qdisc;
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+ struct netdev_queue *queue0;
+#endif /* LINUX_VERSION_CODE */
+
+
+ func_enter();
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
+ /*
+ * check that there is no qdisc currently attached to device
+ * this ensures that we will be the root qdisc. (I can't find a better
+ * way to test this explicitly)
+ */
+ if (dev->qdisc_sleeping != &noop_qdisc) {
+ func_exit_r(-EFAULT);
+ return -EINVAL;
+ }
+#endif /* LINUX_VERSION_CODE */
+
+ qdisc = UF_QDISC_CREATE_DFLT(dev, &uf_qdisc_ops, TC_H_ROOT);
+ if (!qdisc) {
+ unifi_error(NULL, "%s: qdisc installation failed\n", dev->name);
+ func_exit_r(-EFAULT);
+ return -EFAULT;
+ }
+ unifi_trace(NULL, UDBG5, "%s: parent qdisc=0x%p\n",
+ dev->name, qdisc);
+
+ qdisc->handle = 0x80020000;
+ qdisc->flags = 0x0;
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+ queue0 = netdev_get_tx_queue(dev, 0);
+ if (queue0 == NULL) {
+ unifi_error(NULL, "%s: netdev_get_tx_queue returned no queue\n",
+ dev->name);
+ func_exit_r(-EFAULT);
+ return -EFAULT;
+ }
+ queue0->qdisc = qdisc;
+ queue0->qdisc_sleeping = qdisc;
+#else
+ qdisc_lock_tree(dev);
+ list_add_tail(&qdisc->list, &dev->qdisc_list);
+ dev->qdisc_sleeping = qdisc;
+ qdisc_unlock_tree(dev);
+#endif /* LINUX_VERSION_CODE */
+
+ func_exit_r(0);
+ return 0;
+
+} /* uf_install_qdisc() */
+
+static int uf_qdiscop_enqueue(struct sk_buff *skb, struct Qdisc* qd)
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(qd->dev_queue->dev);
+#else
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(qd->dev);
+#endif /* LINUX_VERSION_CODE */
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct uf_sched_data *q = qdisc_priv(qd);
+ struct uf_tx_packet_data *pkt_data = (struct uf_tx_packet_data *) skb->cb;
+ struct ethhdr ehdr;
+ struct Qdisc *qdisc;
+ int r, proto;
+
+ func_enter();
+
+ memcpy(&ehdr, skb->data, ETH_HLEN);
+ proto = ntohs(ehdr.h_proto);
+
+ /* 802.1x - apply controlled/uncontrolled port rules */
+ if ((proto != ETH_P_PAE)
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ && (proto != ETH_P_WAI)
+#endif
+ ) {
+ /* queues 0 - 3 */
+ pkt_data->priority = get_packet_priority(priv, skb, &ehdr, interfacePriv);
+ pkt_data->queue = unifi_frame_priority_to_queue(pkt_data->priority);
+ } else {
+ pkt_data->queue = UNIFI_TRAFFIC_Q_EAPOL;
+ }
+
+ qdisc = q->queues[pkt_data->queue];
+ r = qdisc->enqueue(skb, qdisc);
+ if (r == NET_XMIT_SUCCESS) {
+ qd->q.qlen++;
+ qd->bstats.bytes += skb->len;
+ qd->bstats.packets++;
+ func_exit_r(NET_XMIT_SUCCESS);
+ return NET_XMIT_SUCCESS;
+ }
+
+ unifi_error(priv, "uf_qdiscop_enqueue: dropped\n");
+ qd->qstats.drops++;
+
+ func_exit_r(r);
+ return r;
+
+} /* uf_qdiscop_enqueue() */
+
+
+static int uf_qdiscop_requeue(struct sk_buff *skb, struct Qdisc* qd)
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t*)netdev_priv(qd->dev_queue->dev);
+#else
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t*)netdev_priv(qd->dev);
+#endif /* LINUX_VERSION_CODE */
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct uf_sched_data *q = qdisc_priv(qd);
+ struct uf_tx_packet_data *pkt_data = (struct uf_tx_packet_data *) skb->cb;
+ struct Qdisc *qdisc;
+ int r;
+
+ func_enter();
+
+ unifi_trace(priv, UDBG5, "uf_qdiscop_requeue: (q=%d), tag=%u\n",
+ pkt_data->queue, pkt_data->host_tag);
+
+ /* we recorded which queue to use earlier! */
+ qdisc = q->queues[pkt_data->queue];
+
+ if ((r = qdisc->ops->requeue(skb, qdisc)) == 0) {
+ qd->q.qlen++;
+ func_exit_r(0);
+ return 0;
+ }
+
+ unifi_error(priv, "uf_qdiscop_requeue: dropped\n");
+ qd->qstats.drops++;
+
+ func_exit_r(r);
+ return r;
+} /* uf_qdiscop_requeue() */
+
+static struct sk_buff *uf_qdiscop_dequeue(struct Qdisc* qd)
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(qd->dev_queue->dev);
+#else
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(qd->dev);
+#endif /* LINUX_VERSION_CODE */
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct uf_sched_data *q = qdisc_priv(qd);
+ struct sk_buff *skb;
+ struct Qdisc *qdisc;
+ int queue, i;
+ struct ethhdr ehdr;
+ struct uf_tx_packet_data *pkt_data;
+ CsrWifiRouterCtrlPortAction port_action;
+
+ func_enter();
+
+ /* check all the queues */
+ for (i = UNIFI_TRAFFIC_Q_MAX - 1; i >= 0; i--) {
+
+ if (i != UNIFI_TRAFFIC_Q_EAPOL) {
+ queue = priv->prev_queue;
+ if (++priv->prev_queue >= UNIFI_TRAFFIC_Q_EAPOL) {
+ priv->prev_queue = 0;
+ }
+ } else {
+ queue = i;
+ }
+
+#ifndef ALLOW_Q_PAUSE
+ /* If queue is paused, do not dequeue */
+ if (net_is_tx_q_paused(priv, queue)) {
+ unifi_trace(priv, UDBG5,
+ "uf_qdiscop_dequeue: tx queue paused (q=%d)\n", queue);
+ continue;
+ }
+#endif
+
+ qdisc = q->queues[queue];
+ skb = qdisc->dequeue(qdisc);
+ if (skb) {
+ /* A packet has been dequeued, decrease the queued packets count */
+ qd->q.qlen--;
+
+ pkt_data = (struct uf_tx_packet_data *) skb->cb;
+
+ /* Check the (un)controlled port status */
+ memcpy(&ehdr, skb->data, ETH_HLEN);
+
+ port_action = verify_port(priv
+ , (((CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode) ||(CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI == interfacePriv->interfaceMode))? interfacePriv->bssid.a: ehdr.h_dest)
+ , (UNIFI_TRAFFIC_Q_EAPOL == queue? UF_UNCONTROLLED_PORT_Q: UF_CONTROLLED_PORT_Q)
+ , interfacePriv->InterfaceTag);
+
+ /* Dequeue packet if port is open */
+ if (port_action == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN) {
+ unifi_trace(priv, UDBG5,
+ "uf_qdiscop_dequeue: new (q=%d), tag=%u\n",
+ queue, pkt_data->host_tag);
+
+ func_exit();
+ return skb;
+ }
+
+ /* Discard or block the packet if necessary */
+ if (port_action == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD) {
+ unifi_trace(priv, UDBG5,
+ "uf_qdiscop_dequeue: drop (q=%d), tag=%u\n",
+ queue, pkt_data->host_tag);
+ kfree_skb(skb);
+ break;
+ }
+
+ /* We can not send the packet now, put it back to the queue */
+ if (qdisc->ops->requeue(skb, qdisc) != 0) {
+ unifi_error(priv,
+ "uf_qdiscop_dequeue: requeue (q=%d) failed, tag=%u, drop it\n",
+ queue, pkt_data->host_tag);
+
+ /* Requeue failed, drop the packet */
+ kfree_skb(skb);
+ break;
+ }
+ /* We requeued the packet, increase the queued packets count */
+ qd->q.qlen++;
+
+ unifi_trace(priv, UDBG5,
+ "uf_qdiscop_dequeue: skip (q=%d), tag=%u\n",
+ queue, pkt_data->host_tag);
+ }
+ }
+
+ func_exit();
+ return NULL;
+} /* uf_qdiscop_dequeue() */
+
+
+static void uf_qdiscop_reset(struct Qdisc* qd)
+{
+ struct uf_sched_data *q = qdisc_priv(qd);
+ int queue;
+ func_enter();
+
+ for (queue = 0; queue < UNIFI_TRAFFIC_Q_MAX; queue++) {
+ qdisc_reset(q->queues[queue]);
+ }
+ qd->q.qlen = 0;
+
+ func_exit();
+} /* uf_qdiscop_reset() */
+
+
+static void uf_qdiscop_destroy(struct Qdisc* qd)
+{
+ struct uf_sched_data *q = qdisc_priv(qd);
+ int queue;
+
+ func_enter();
+
+ for (queue=0; queue < UNIFI_TRAFFIC_Q_MAX; queue++) {
+ qdisc_destroy(q->queues[queue]);
+ q->queues[queue] = &noop_qdisc;
+ }
+
+ func_exit();
+} /* uf_qdiscop_destroy() */
+
+
+/* called whenever parameters are updated on existing qdisc */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
+static int uf_qdiscop_tune(struct Qdisc *qd, struct nlattr *opt)
+#else
+static int uf_qdiscop_tune(struct Qdisc *qd, struct rtattr *opt)
+#endif
+{
+ func_enter();
+ func_exit();
+ return 0;
+} /* uf_qdiscop_tune() */
+
+
+/* called during initial creation of qdisc on device */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
+static int uf_qdiscop_init(struct Qdisc *qd, struct nlattr *opt)
+#else
+static int uf_qdiscop_init(struct Qdisc *qd, struct rtattr *opt)
+#endif
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+ struct net_device *dev = qd->dev_queue->dev;
+#else
+ struct net_device *dev = qd->dev;
+#endif /* LINUX_VERSION_CODE */
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct uf_sched_data *q = qdisc_priv(qd);
+ int err = 0, i;
+
+ func_enter();
+
+ /* make sure we do not mess with the ingress qdisc */
+ if (qd->flags & TCQ_F_INGRESS) {
+ func_exit();
+ return -EINVAL;
+ }
+
+ /* if options were passed in, set them */
+ if (opt) {
+ err = uf_qdiscop_tune(qd, opt);
+ }
+
+ /* create child queues */
+ for (i = 0; i < UNIFI_TRAFFIC_Q_MAX; i++) {
+ q->queues[i] = UF_QDISC_CREATE_DFLT(dev, &pfifo_qdisc_ops,
+ qd->handle);
+ if (!q->queues[i]) {
+ q->queues[i] = &noop_qdisc;
+ unifi_error(priv, "%s child qdisc %i creation failed\n");
+ }
+
+ unifi_trace(priv, UDBG5, "%s: child qdisc=0x%p\n",
+ dev->name, q->queues[i]);
+ }
+
+ func_exit_r(err);
+ return err;
+} /* uf_qdiscop_init() */
+
+
+static int uf_qdiscop_dump(struct Qdisc *qd, struct sk_buff *skb)
+{
+ func_enter();
+ func_exit_r(skb->len);
+ return skb->len;
+} /* uf_qdiscop_dump() */
+
+#endif /* CONFIG_NET_SCHED */
+#endif /* LINUX_VERSION_CODE */
+
+#ifdef CSR_SUPPORT_WEXT
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_netdev_event
+ *
+ * Callback function to handle netdev state changes
+ *
+ * Arguments:
+ * notif Pointer to a notifier_block.
+ * event Event prompting notification
+ * ptr net_device pointer
+ *
+ * Returns:
+ * None
+ *
+ * Notes:
+ * The event handler is global, and may occur on non-UniFi netdevs.
+ * ---------------------------------------------------------------------------
+ */
+static int
+uf_netdev_event(struct notifier_block *notif, unsigned long event, void* ptr) {
+ struct net_device *netdev = ptr;
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(netdev);
+ unifi_priv_t *priv = NULL;
+ static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
+
+ /* Check that the event is for a UniFi netdev. If it's not, the netdev_priv
+ * structure is not safe to use.
+ */
+ if (uf_find_netdev_priv(interfacePriv) == -1) {
+ unifi_trace(NULL, UDBG1, "uf_netdev_event: ignore e=%d, ptr=%p, priv=%p %s\n",
+ event, ptr, interfacePriv, netdev->name);
+ return 0;
+ }
+
+ switch(event) {
+ case NETDEV_CHANGE:
+ priv = interfacePriv->privPtr;
+ unifi_trace(priv, UDBG1, "NETDEV_CHANGE: %p %s %s waiting for it\n",
+ ptr,
+ netdev->name,
+ interfacePriv->wait_netdev_change ? "" : "not");
+
+ if (interfacePriv->wait_netdev_change) {
+ UF_NETIF_TX_WAKE_ALL_QUEUES(priv->netdev[interfacePriv->InterfaceTag]);
+ interfacePriv->connected = UnifiConnected;
+ interfacePriv->wait_netdev_change = FALSE;
+ /* Note: passing the broadcast address here will allow anyone to attempt to join our adhoc network */
+ uf_process_rx_pending_queue(priv, UF_UNCONTROLLED_PORT_Q, broadcast_address, 1,interfacePriv->InterfaceTag);
+ uf_process_rx_pending_queue(priv, UF_CONTROLLED_PORT_Q, broadcast_address, 1,interfacePriv->InterfaceTag);
+ }
+ break;
+
+ default:
+ break;
+ }
+ return 0;
+}
+
+static struct notifier_block uf_netdev_notifier = {
+ .notifier_call = uf_netdev_event,
+};
+#endif /* CSR_SUPPORT_WEXT */
+
+
+static void
+ process_amsdu(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
+{
+ CsrUint32 offset;
+ CsrUint32 length = bulkdata->d[0].data_length;
+ CsrUint32 subframe_length, subframe_body_length, dot11_hdr_size;
+ CsrUint8 *ptr;
+ bulk_data_param_t subframe_bulkdata;
+ CsrUint8 *dot11_hdr_ptr = (CsrUint8*)bulkdata->d[0].os_data_ptr;
+ CsrResult csrResult;
+ CsrUint16 frameControl;
+ CsrUint8 *qos_control_ptr;
+
+ frameControl = le16_to_cpu(*((CsrUint16*)dot11_hdr_ptr));
+ qos_control_ptr = dot11_hdr_ptr + (((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK))?30: 24);
+ if(!(*qos_control_ptr & IEEE802_11_QC_A_MSDU_PRESENT)) {
+ unifi_trace(priv, UDBG6, "%s: calling unifi_rx()", __FUNCTION__);
+ unifi_rx(priv, signal, bulkdata);
+ return;
+ }
+ *qos_control_ptr &= ~(IEEE802_11_QC_A_MSDU_PRESENT);
+
+ ptr = qos_control_ptr + 2;
+ offset = dot11_hdr_size = ptr - dot11_hdr_ptr;
+
+ while(length > (offset + sizeof(struct ethhdr) + sizeof(llc_snap_hdr_t))) {
+ subframe_body_length = ntohs(((struct ethhdr*)ptr)->h_proto);
+ if(subframe_body_length > IEEE802_11_MAX_DATA_LEN) {
+ unifi_error(priv, "%s: bad subframe_body_length = %d\n", __FUNCTION__, subframe_body_length);
+ break;
+ }
+ subframe_length = sizeof(struct ethhdr) + subframe_body_length;
+ memset(&subframe_bulkdata, 0, sizeof(bulk_data_param_t));
+
+ csrResult = unifi_net_data_malloc(priv, &subframe_bulkdata.d[0], dot11_hdr_size + subframe_body_length);
+
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "%s: unifi_net_data_malloc failed\n", __FUNCTION__);
+ break;
+ }
+
+ memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr, dot11_hdr_ptr, dot11_hdr_size);
+
+
+ /* When to DS=0 and from DS=0, address 3 will already have BSSID so no need to re-program */
+ if ((frameControl & IEEE802_11_FC_TO_DS_MASK) && !(frameControl & IEEE802_11_FC_FROM_DS_MASK)){
+ memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr + IEEE802_11_ADDR3_OFFSET, ((struct ethhdr*)ptr)->h_dest, ETH_ALEN);
+ }
+ else if (!(frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK)){
+ memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr + IEEE802_11_ADDR3_OFFSET,
+ ((struct ethhdr*)ptr)->h_source,
+ ETH_ALEN);
+ }
+
+ memcpy((CsrUint8*)subframe_bulkdata.d[0].os_data_ptr + dot11_hdr_size,
+ ptr + sizeof(struct ethhdr),
+ subframe_body_length);
+ unifi_trace(priv, UDBG6, "%s: calling unifi_rx. length = %d subframe_length = %d\n", __FUNCTION__, length, subframe_length);
+ unifi_rx(priv, signal, &subframe_bulkdata);
+
+ subframe_length = (subframe_length + 3)&(~0x3);
+ ptr += subframe_length;
+ offset += subframe_length;
+ }
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+}
+
+
+#define SN_TO_INDEX(__ba_session, __sn) (((__sn - __ba_session->start_sn) & 0xFFF) % __ba_session->wind_size)
+
+
+#define ADVANCE_EXPECTED_SN(__ba_session) \
+{ \
+ __ba_session->expected_sn++; \
+ __ba_session->expected_sn &= 0xFFF; \
+}
+
+#define FREE_BUFFER_SLOT(__ba_session, __index) \
+{ \
+ __ba_session->occupied_slots--; \
+ __ba_session->buffer[__index].active = FALSE; \
+ ADVANCE_EXPECTED_SN(__ba_session); \
+}
+
+static void add_frame_to_ba_complete(unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ frame_desc_struct *frame_desc)
+{
+ interfacePriv->ba_complete[interfacePriv->ba_complete_index] = *frame_desc;
+ interfacePriv->ba_complete_index++;
+}
+
+
+static void update_expected_sn(unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ ba_session_rx_struct *ba_session,
+ CsrUint16 sn)
+{
+ int i, j;
+ CsrUint16 gap;
+
+ gap = (sn - ba_session->expected_sn) & 0xFFF;
+ unifi_trace(priv, UDBG6, "%s: proccess the frames up to new_expected_sn = %d gap = %d\n", __FUNCTION__, sn, gap);
+ for(j = 0; j < gap && j < ba_session->wind_size; j++) {
+ i = SN_TO_INDEX(ba_session, ba_session->expected_sn);
+ unifi_trace(priv, UDBG6, "%s: proccess the slot index = %d\n", __FUNCTION__, i);
+ if(ba_session->buffer[i].active) {
+ add_frame_to_ba_complete(priv, interfacePriv, &ba_session->buffer[i]);
+ unifi_trace(priv, UDBG6, "%s: proccess the frame at index = %d expected_sn = %d\n", __FUNCTION__, i, ba_session->expected_sn);
+ FREE_BUFFER_SLOT(ba_session, i);
+ } else {
+ unifi_trace(priv, UDBG6, "%s: empty slot at index = %d\n", __FUNCTION__, i);
+ ADVANCE_EXPECTED_SN(ba_session);
+ }
+ }
+ ba_session->expected_sn = sn;
+}
+
+
+static void complete_ready_sequence(unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ ba_session_rx_struct *ba_session)
+{
+ int i;
+
+ i = SN_TO_INDEX(ba_session, ba_session->expected_sn);
+ while (ba_session->buffer[i].active) {
+ add_frame_to_ba_complete(priv, interfacePriv, &ba_session->buffer[i]);
+ unifi_trace(priv, UDBG6, "%s: completed stored frame(expected_sn=%d) at i = %d\n", __FUNCTION__, ba_session->expected_sn, i);
+ FREE_BUFFER_SLOT(ba_session, i);
+ i = SN_TO_INDEX(ba_session, ba_session->expected_sn);
+ }
+}
+
+
+void scroll_ba_window(unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ ba_session_rx_struct *ba_session,
+ CsrUint16 sn)
+{
+ if(((sn - ba_session->expected_sn) & 0xFFF) <= 2048) {
+ update_expected_sn(priv, interfacePriv, ba_session, sn);
+ complete_ready_sequence(priv, interfacePriv, ba_session);
+ }
+}
+
+
+static int consume_frame_or_get_buffer_index(unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ ba_session_rx_struct *ba_session,
+ CsrUint16 sn,
+ frame_desc_struct *frame_desc) {
+ int i;
+ CsrUint16 sn_temp;
+
+ if(((sn - ba_session->expected_sn) & 0xFFF) <= 2048) {
+
+ /* once we are in BA window, set the flag for BA trigger */
+ if(!ba_session->trigger_ba_after_ssn){
+ ba_session->trigger_ba_after_ssn = TRUE;
+ }
+
+ sn_temp = ba_session->expected_sn + ba_session->wind_size;
+ unifi_trace(priv, UDBG6, "%s: new frame: sn=%d\n", __FUNCTION__, sn);
+ if(!(((sn - sn_temp) & 0xFFF) > 2048)) {
+ CsrUint16 new_expected_sn;
+ unifi_trace(priv, UDBG6, "%s: frame is out of window\n", __FUNCTION__);
+ sn_temp = (sn - ba_session->wind_size) & 0xFFF;
+ new_expected_sn = (sn_temp + 1) & 0xFFF;
+ update_expected_sn(priv, interfacePriv, ba_session, new_expected_sn);
+ }
+ i = -1;
+ if (sn == ba_session->expected_sn) {
+ unifi_trace(priv, UDBG6, "%s: sn = ba_session->expected_sn = %d\n", __FUNCTION__, sn);
+ ADVANCE_EXPECTED_SN(ba_session);
+ add_frame_to_ba_complete(priv, interfacePriv, frame_desc);
+ } else {
+ i = SN_TO_INDEX(ba_session, sn);
+ unifi_trace(priv, UDBG6, "%s: sn(%d) != ba_session->expected_sn(%d), i = %d\n", __FUNCTION__, sn, ba_session->expected_sn, i);
+ if (ba_session->buffer[i].active) {
+ unifi_trace(priv, UDBG6, "%s: free frame at i = %d\n", __FUNCTION__, i);
+ i = -1;
+ unifi_net_data_free(priv, &frame_desc->bulkdata.d[0]);
+ }
+ }
+ } else {
+ i = -1;
+ if(!ba_session->trigger_ba_after_ssn){
+ unifi_trace(priv, UDBG6, "%s: frame before ssn, pass it up: sn=%d\n", __FUNCTION__, sn);
+ add_frame_to_ba_complete(priv, interfacePriv, frame_desc);
+ }else{
+ unifi_trace(priv, UDBG6, "%s: old frame, drop: sn=%d, expected_sn=%d\n", __FUNCTION__, sn, ba_session->expected_sn);
+ unifi_net_data_free(priv, &frame_desc->bulkdata.d[0]);
+ }
+ }
+ return i;
+}
+
+
+
+static void process_ba_frame(unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ ba_session_rx_struct *ba_session,
+ frame_desc_struct *frame_desc)
+{
+ int i;
+ CsrUint16 sn = frame_desc->sn;
+
+ if (ba_session->timeout) {
+ mod_timer(&ba_session->timer, (jiffies + usecs_to_jiffies((ba_session->timeout) * 1024)));
+ }
+ unifi_trace(priv, UDBG6, "%s: got frame(sn=%d)\n", __FUNCTION__, sn);
+
+ i = consume_frame_or_get_buffer_index(priv, interfacePriv, ba_session, sn, frame_desc);
+ if(i >= 0) {
+ unifi_trace(priv, UDBG6, "%s: store frame(sn=%d) at i = %d\n", __FUNCTION__, sn, i);
+ ba_session->buffer[i] = *frame_desc;
+ ba_session->buffer[i].recv_time = CsrTimeGet(NULL);
+ ba_session->occupied_slots++;
+ } else {
+ unifi_trace(priv, UDBG6, "%s: frame consumed - sn = %d\n", __FUNCTION__, sn);
+ }
+ complete_ready_sequence(priv, interfacePriv, ba_session);
+}
+
+
+static void process_ba_complete(unifi_priv_t *priv, netInterface_priv_t *interfacePriv)
+{
+ frame_desc_struct *frame_desc;
+ CsrUint8 i;
+
+ for(i = 0; i < interfacePriv->ba_complete_index; i++) {
+ frame_desc = &interfacePriv->ba_complete[i];
+ unifi_trace(priv, UDBG6, "%s: calling process_amsdu()\n", __FUNCTION__);
+ process_amsdu(priv, &frame_desc->signal, &frame_desc->bulkdata);
+ }
+ interfacePriv->ba_complete_index = 0;
+
+}
+
+
+/* Check if the frames in BA reoder buffer has aged and
+ * if so release the frames to upper processes and move
+ * the window
+ */
+static void check_ba_frame_age_timeout( unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ ba_session_rx_struct *ba_session)
+{
+ CsrTime now;
+ CsrTime age;
+ CsrUint8 i, j;
+ CsrUint16 sn_temp;
+
+ /* gap is started at 1 because we have buffered frames and
+ * hence a minimum gap of 1 exists
+ */
+ CsrUint8 gap=1;
+
+ now = CsrTimeGet(NULL);
+
+ if (ba_session->occupied_slots)
+ {
+ /* expected sequence has not arrived so start searching from next
+ * sequence number until a frame is available and determine the gap.
+ * Check if the frame available has timedout, if so advance the
+ * expected sequence number and release the frames
+ */
+ sn_temp = (ba_session->expected_sn + 1) & 0xFFF;
+
+ for(j = 0; j < ba_session->wind_size; j++)
+ {
+ i = SN_TO_INDEX(ba_session, sn_temp);
+
+ if(ba_session->buffer[i].active)
+ {
+ unifi_trace(priv, UDBG6, "check age at slot index = %d sn = %d recv_time = %u now = %u\n",
+ i,
+ ba_session->buffer[i].sn,
+ ba_session->buffer[i].recv_time,
+ now);
+
+ if (ba_session->buffer[i].recv_time > now)
+ {
+ /* timer wrap */
+ age = CsrTimeAdd((CsrTime)CsrTimeSub(CSR_SCHED_TIME_MAX, ba_session->buffer[i].recv_time), now);
+ }
+ else
+ {
+ age = (CsrTime)CsrTimeSub(now, ba_session->buffer[i].recv_time);
+ }
+
+ if (age >= CSR_WIFI_BA_MPDU_FRAME_AGE_TIMEOUT)
+ {
+ unifi_trace(priv, UDBG2, "release the frame at index = %d gap = %d expected_sn = %d sn = %d\n",
+ i,
+ gap,
+ ba_session->expected_sn,
+ ba_session->buffer[i].sn);
+
+ /* if it has timedout don't wait for missing frames, move the window */
+ while (gap--)
+ {
+ ADVANCE_EXPECTED_SN(ba_session);
+ }
+ add_frame_to_ba_complete(priv, interfacePriv, &ba_session->buffer[i]);
+ FREE_BUFFER_SLOT(ba_session, i);
+ complete_ready_sequence(priv, interfacePriv, ba_session);
+ }
+ break;
+
+ }
+ else
+ {
+ /* advance temp sequence number and frame gap */
+ sn_temp = (sn_temp + 1) & 0xFFF;
+ gap++;
+ }
+ }
+ }
+}
+
+
+static void process_ma_packet_error_ind(unifi_priv_t *priv, CSR_SIGNAL *signal, bulk_data_param_t *bulkdata)
+{
+ CsrUint16 interfaceTag;
+ const CSR_MA_PACKET_ERROR_INDICATION *pkt_err_ind = &signal->u.MaPacketErrorIndication;
+ netInterface_priv_t *interfacePriv;
+ ba_session_rx_struct *ba_session;
+ CsrUint8 ba_session_idx = 0;
+ CSR_PRIORITY UserPriority;
+ CSR_SEQUENCE_NUMBER sn;
+
+ func_enter();
+
+ interfaceTag = (pkt_err_ind->VirtualInterfaceIdentifier & 0xff);
+
+
+ /* Sanity check that the VIF refers to a sensible interface */
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES)
+ {
+ unifi_error(priv, "%s: MaPacketErrorIndication indication with bad interfaceTag %d\n", __FUNCTION__, interfaceTag);
+ func_exit();
+ return;
+ }
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+ UserPriority = pkt_err_ind->UserPriority;
+ if(UserPriority > 15) {
+ unifi_error(priv, "%s: MaPacketErrorIndication indication with bad UserPriority=%d\n", __FUNCTION__, UserPriority);
+ func_exit();
+ }
+ sn = pkt_err_ind->SequenceNumber;
+
+ down(&priv->ba_mutex);
+ /* To find the right ba_session loop through the BA sessions, compare MAC address and tID */
+ for (ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_RX; ba_session_idx++){
+ ba_session = interfacePriv->ba_session_rx[ba_session_idx];
+ if (ba_session){
+ if ((!memcmp(ba_session->macAddress.a, pkt_err_ind->PeerQstaAddress.x, ETH_ALEN)) && (ba_session->tID == UserPriority)){
+ if (ba_session->timeout) {
+ mod_timer(&ba_session->timer, (jiffies + usecs_to_jiffies((ba_session->timeout) * 1024)));
+ }
+ scroll_ba_window(priv, interfacePriv, ba_session, sn);
+ break;
+ }
+ }
+ }
+
+ up(&priv->ba_mutex);
+ process_ba_complete(priv, interfacePriv);
+ func_exit();
+}
+
+
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: os.c
+ *
+ * PURPOSE:
+ * Routines to fulfil the OS-abstraction for the HIP lib.
+ * It is part of the porting exercise.
+ *
+ * Copyright (C) 2005-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+/**
+ * The HIP lib OS abstraction consists of the implementation
+ * of the functions in this file. It is part of the porting exercise.
+ */
+
+#include "unifi_priv.h"
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_net_data_malloc
+ *
+ * Allocate an OS specific net data buffer of "size" bytes.
+ * The bulk_data_slot.os_data_ptr must be initialised to point
+ * to the buffer allocated. The bulk_data_slot.length must be
+ * initialised to the requested size, zero otherwise.
+ * The bulk_data_slot.os_net_buf_ptr can be initialised to
+ * an OS specific pointer to be used in the unifi_net_data_free().
+ *
+ *
+ * Arguments:
+ * ospriv Pointer to device private context struct.
+ * bulk_data_slot Pointer to the bulk data structure to initialise.
+ * size Size of the buffer to be allocated.
+ *
+ * Returns:
+ * CSR_RESULT_SUCCESS on success, CSR_RESULT_FAILURE otherwise.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+unifi_net_data_malloc(void *ospriv, bulk_data_desc_t *bulk_data_slot, unsigned int size)
+{
+ struct sk_buff *skb;
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+ int rounded_length;
+
+ if (priv->card_info.sdio_block_size == 0) {
+ unifi_error(priv, "unifi_net_data_malloc: Invalid SDIO block size\n");
+ return CSR_RESULT_FAILURE;
+ }
+
+ rounded_length = (size + priv->card_info.sdio_block_size - 1) & ~(priv->card_info.sdio_block_size - 1);
+
+ /*
+ * (ETH_HLEN + 2) bytes tailroom for header manipulation
+ * CSR_WIFI_ALIGN_BYTES bytes headroom for alignment manipulation
+ */
+ skb = dev_alloc_skb(rounded_length + 2 + ETH_HLEN + CSR_WIFI_ALIGN_BYTES);
+ if (! skb) {
+ unifi_error(ospriv, "alloc_skb failed.\n");
+ bulk_data_slot->os_net_buf_ptr = NULL;
+ bulk_data_slot->net_buf_length = 0;
+ bulk_data_slot->os_data_ptr = NULL;
+ bulk_data_slot->data_length = 0;
+ return CSR_RESULT_FAILURE;
+ }
+
+ bulk_data_slot->os_net_buf_ptr = (const unsigned char*)skb;
+ bulk_data_slot->net_buf_length = rounded_length + 2 + ETH_HLEN + CSR_WIFI_ALIGN_BYTES;
+ bulk_data_slot->os_data_ptr = (const void*)skb->data;
+ bulk_data_slot->data_length = size;
+
+ return CSR_RESULT_SUCCESS;
+} /* unifi_net_data_malloc() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_net_data_free
+ *
+ * Free an OS specific net data buffer.
+ * The bulk_data_slot.length must be initialised to 0.
+ *
+ *
+ * Arguments:
+ * ospriv Pointer to device private context struct.
+ * bulk_data_slot Pointer to the bulk data structure that
+ * holds the data to be freed.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+unifi_net_data_free(void *ospriv, bulk_data_desc_t *bulk_data_slot)
+{
+ struct sk_buff *skb;
+ CSR_UNUSED(ospriv);
+
+ skb = (struct sk_buff *)bulk_data_slot->os_net_buf_ptr;
+ dev_kfree_skb(skb);
+
+ bulk_data_slot->net_buf_length = 0;
+ bulk_data_slot->data_length = 0;
+ bulk_data_slot->os_data_ptr = bulk_data_slot->os_net_buf_ptr = NULL;
+
+} /* unifi_net_data_free() */
+
+
+/*
+* ---------------------------------------------------------------------------
+* unifi_net_dma_align
+*
+* DMA align an OS specific net data buffer.
+* The buffer must be empty.
+*
+*
+* Arguments:
+* ospriv Pointer to device private context struct.
+* bulk_data_slot Pointer to the bulk data structure that
+* holds the data to be aligned.
+*
+* Returns:
+* None.
+* ---------------------------------------------------------------------------
+*/
+CsrResult
+unifi_net_dma_align(void *ospriv, bulk_data_desc_t *bulk_data_slot)
+{
+ struct sk_buff *skb;
+ unsigned long buf_address;
+ int offset;
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+
+ if ((bulk_data_slot == NULL) || (CSR_WIFI_ALIGN_BYTES == 0)) {
+ return CSR_RESULT_SUCCESS;
+ }
+
+ if ((bulk_data_slot->os_data_ptr == NULL) || (bulk_data_slot->data_length == 0)) {
+ return CSR_RESULT_SUCCESS;
+ }
+
+ buf_address = (unsigned long)(bulk_data_slot->os_data_ptr) & (CSR_WIFI_ALIGN_BYTES - 1);
+
+ unifi_trace(priv, UDBG5,
+ "unifi_net_dma_align: Allign buffer (0x%p) by %d bytes\n",
+ bulk_data_slot->os_data_ptr, buf_address);
+
+ offset = CSR_WIFI_ALIGN_BYTES - buf_address;
+ if (offset < 0) {
+ unifi_error(priv, "unifi_net_dma_align: Failed (offset=%d)\n", offset);
+ return CSR_RESULT_FAILURE;
+ }
+
+ skb = (struct sk_buff*)(bulk_data_slot->os_net_buf_ptr);
+ skb_reserve(skb, offset);
+ bulk_data_slot->os_net_buf_ptr = (const unsigned char*)skb;
+ bulk_data_slot->os_data_ptr = (const void*)(skb->data);
+
+ return CSR_RESULT_SUCCESS;
+
+} /* unifi_net_dma_align() */
+
+#ifdef ANDROID_TIMESTAMP
+static volatile unsigned int printk_cpu = UINT_MAX;
+char tbuf[30];
+
+char* print_time(void )
+{
+ unsigned long long t;
+ unsigned long nanosec_rem;
+
+ t = cpu_clock(printk_cpu);
+ nanosec_rem = do_div(t, 1000000000);
+ sprintf(tbuf, "[%5lu.%06lu] ",
+ (unsigned long) t,
+ nanosec_rem / 1000);
+
+ return tbuf;
+}
+#endif
+
+
+/* Module parameters */
+extern int unifi_debug;
+
+#ifdef UNIFI_DEBUG
+#define DEBUG_BUFFER_SIZE 120
+
+#define FORMAT_TRACE(_s, _len, _args, _fmt) \
+ do { \
+ va_start(_args, _fmt); \
+ _len += vsnprintf(&(_s)[_len], \
+ (DEBUG_BUFFER_SIZE - _len), \
+ _fmt, _args); \
+ va_end(_args); \
+ if (_len >= DEBUG_BUFFER_SIZE) { \
+ (_s)[DEBUG_BUFFER_SIZE - 2] = '\n'; \
+ (_s)[DEBUG_BUFFER_SIZE - 1] = 0; \
+ } \
+ } while (0)
+
+void
+unifi_error(void* ospriv, const char *fmt, ...)
+{
+ unifi_priv_t *priv = (unifi_priv_t*) ospriv;
+ char s[DEBUG_BUFFER_SIZE];
+ va_list args;
+ unsigned int len;
+#ifdef ANDROID_TIMESTAMP
+ if (priv != NULL) {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi%d: ", print_time(), priv->instance);
+ } else {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi: ", print_time());
+ }
+#else
+ if (priv != NULL) {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi%d: ", priv->instance);
+ } else {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi: ");
+ }
+#endif /* ANDROID_TIMESTAMP */
+ FORMAT_TRACE(s, len, args, fmt);
+
+ printk("%s", s);
+}
+
+void
+unifi_warning(void* ospriv, const char *fmt, ...)
+{
+ unifi_priv_t *priv = (unifi_priv_t*) ospriv;
+ char s[DEBUG_BUFFER_SIZE];
+ va_list args;
+ unsigned int len;
+
+#ifdef ANDROID_TIMESTAMP
+ if (priv != NULL) {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "%s unifi%d: ", print_time(), priv->instance);
+ } else {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "%s unifi: ", print_time());
+ }
+#else
+ if (priv != NULL) {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "unifi%d: ", priv->instance);
+ } else {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_WARNING "unifi: ");
+ }
+#endif /* ANDROID_TIMESTAMP */
+
+ FORMAT_TRACE(s, len, args, fmt);
+
+ printk("%s", s);
+}
+
+
+void
+unifi_notice(void* ospriv, const char *fmt, ...)
+{
+ unifi_priv_t *priv = (unifi_priv_t*) ospriv;
+ char s[DEBUG_BUFFER_SIZE];
+ va_list args;
+ unsigned int len;
+
+#ifdef ANDROID_TIMESTAMP
+ if (priv != NULL) {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "%s unifi%d: ", print_time(), priv->instance);
+ } else {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "%s unifi: ", print_time());
+ }
+#else
+ if (priv != NULL) {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "unifi%d: ", priv->instance);
+ } else {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_NOTICE "unifi: ");
+ }
+#endif /* ANDROID_TIMESTAMP */
+
+ FORMAT_TRACE(s, len, args, fmt);
+
+ printk("%s", s);
+}
+
+
+void
+unifi_info(void* ospriv, const char *fmt, ...)
+{
+ unifi_priv_t *priv = (unifi_priv_t*) ospriv;
+ char s[DEBUG_BUFFER_SIZE];
+ va_list args;
+ unsigned int len;
+
+#ifdef ANDROID_TIMESTAMP
+ if (priv != NULL) {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "%s unifi%d: ", print_time(), priv->instance);
+ } else {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "%s unifi: ", print_time());
+ }
+#else
+ if (priv != NULL) {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "unifi%d: ", priv->instance);
+ } else {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_INFO "unifi: ");
+ }
+#endif /* ANDROID_TIMESTAMP */
+
+ FORMAT_TRACE(s, len, args, fmt);
+
+ printk("%s", s);
+}
+
+/* debugging */
+void
+unifi_trace(void* ospriv, int level, const char *fmt, ...)
+{
+ unifi_priv_t *priv = (unifi_priv_t*) ospriv;
+ char s[DEBUG_BUFFER_SIZE];
+ va_list args;
+ unsigned int len;
+
+ if (unifi_debug >= level) {
+#ifdef ANDROID_TIMESTAMP
+ if (priv != NULL) {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi%d: ", print_time(), priv->instance);
+ } else {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "%s unifi: ", print_time());
+ }
+#else
+ if (priv != NULL) {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi%d: ", priv->instance);
+ } else {
+ len = snprintf(s, DEBUG_BUFFER_SIZE, KERN_ERR "unifi: ");
+ }
+#endif /* ANDROID_TIMESTAMP */
+
+ FORMAT_TRACE(s, len, args, fmt);
+
+ printk("%s", s);
+ }
+}
+
+#else
+
+void
+unifi_error_nop(void* ospriv, const char *fmt, ...)
+{
+}
+
+void
+unifi_trace_nop(void* ospriv, int level, const char *fmt, ...)
+{
+}
+
+#endif /* UNIFI_DEBUG */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * Debugging support.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+#ifdef UNIFI_DEBUG
+
+/* Memory dump with level filter controlled by unifi_debug */
+void
+unifi_dump(void *ospriv, int level, const char *msg, void *mem, CsrUint16 len)
+{
+ unifi_priv_t *priv = (unifi_priv_t*) ospriv;
+
+ if (unifi_debug >= level) {
+#ifdef ANDROID_TIMESTAMP
+ if (priv != NULL) {
+ printk(KERN_ERR "%s unifi%d: --- dump: %s ---\n", print_time(), priv->instance, msg ? msg : "");
+ } else {
+ printk(KERN_ERR "%s unifi: --- dump: %s ---\n", print_time(), msg ? msg : "");
+ }
+#else
+ if (priv != NULL) {
+ printk(KERN_ERR "unifi%d: --- dump: %s ---\n", priv->instance, msg ? msg : "");
+ } else {
+ printk(KERN_ERR "unifi: --- dump: %s ---\n", msg ? msg : "");
+ }
+#endif /* ANDROID_TIMESTAMP */
+ dump(mem, len);
+
+ if (priv != NULL) {
+ printk(KERN_ERR "unifi%d: --- end of dump ---\n", priv->instance);
+ } else {
+ printk(KERN_ERR "unifi: --- end of dump ---\n");
+ }
+ }
+}
+
+/* Memory dump that appears all the time, use sparingly */
+void
+dump(void *mem, CsrUint16 len)
+{
+ int i, col = 0;
+ unsigned char *pdata = (unsigned char *)mem;
+#ifdef ANDROID_TIMESTAMP
+ printk("timestamp %s \n", print_time());
+#endif /* ANDROID_TIMESTAMP */
+ if (mem == NULL) {
+ printk("(null dump)\n");
+ return;
+ }
+ for (i = 0; i < len; i++) {
+ if (col == 0) {
+ printk("0x%02X: ", i);
+ }
+
+ printk(" %02X", pdata[i]);
+
+ if (++col == 16) {
+ printk("\n");
+ col = 0;
+ }
+ }
+ if (col) {
+ printk("\n");
+ }
+} /* dump() */
+
+
+void
+dump16(void *mem, CsrUint16 len)
+{
+ int i, col=0;
+ unsigned short *p = (unsigned short *)mem;
+#ifdef ANDROID_TIMESTAMP
+ printk("timestamp %s \n", print_time());
+#endif /* ANDROID_TIMESTAMP */
+ for (i = 0; i < len; i+=2) {
+ if (col == 0) {
+ printk("0x%02X: ", i);
+ }
+
+ printk(" %04X", *p++);
+
+ if (++col == 8) {
+ printk("\n");
+ col = 0;
+ }
+ }
+ if (col) {
+ printk("\n");
+ }
+}
+
+
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+void
+dump_str(void *mem, CsrUint16 len)
+{
+ int i, col = 0;
+ unsigned char *pdata = (unsigned char *)mem;
+#ifdef ANDROID_TIMESTAMP
+ printk("timestamp %s \n", print_time());
+#endif /* ANDROID_TIMESTAMP */
+ for (i = 0; i < len; i++) {
+ printk("%c", pdata[i]);
+ }
+ if (col) {
+ printk("\n");
+ }
+
+} /* dump_str() */
+#endif /* CSR_ONLY_NOTES */
+
+
+#endif /* UNIFI_DEBUG */
+
+
+/* ---------------------------------------------------------------------------
+ * - End -
+ * ------------------------------------------------------------------------- */
--- /dev/null
+obj-$(CONFIG_CSR_WIFI) := csr_oska.o
+
+csr_oska-y := \
+ list.o \
+ refcount.o \
+ compat.o \
+ event.o \
+ oska_module.o \
+ print.o \
+ thread.o \
+ timer.o
+
--- /dev/null
+/*
+ * Operating system kernel abstraction -- all functions
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_ALL_H
+#define __OSKA_ALL_H
+
+/**
+ * @mainpage Operating System Kernel Abstraction
+ *
+ * @section intro Introduction
+ *
+ * The Operating System Kernel Abstraction (oska) is a software
+ * package providing an abstraction for various operating system
+ * kernel facilities for use by device drivers and other OS kernel
+ * software (e.g., SDIO stacks). Oska is modularized and intended to
+ * be a lightweight wrapper around an OSes interfaces.
+ *
+ * @section modules Modules
+ *
+ * Oska is organized into the modules, each of which has it's own
+ * header file providing the interface.
+ *
+ * - \ref alloc "Memory allocation" <oska/alloc.h>
+ * - \ref event "Events" <oska/event.h>
+ * - \ref mutex "Mutexes" <oska/mutex.h>
+ * - \ref print "Console output" <oska/print.h>
+ * - \ref spinlock "Spinlocks" <oska/spinlock.h>
+ * - \ref thread "Threading" <oska/thread.h>
+ * - \ref time "Timing and delays" <oska/time.h>
+ * - \ref timer "Timers" <oska/timer.h>
+ * - \ref types "Standard Types" <oska/types.h>
+ * - \ref util "Miscellaneous utilities" <oska/util.h>
+ *
+ * An <oska/all.h> header is provided which includes all the above
+ * modules.
+ *
+ * There are additional modules that are not included in <oska/all.h>.
+ *
+ * - \ref io "Memory mapped I/O" <oska/io.h>
+ * - \ref refcount "Reference Counting" <oska/refcount.h>
+ * - \ref list "Linked lists" <oska/list.h>
+ * - \ref trace "Tracing messages" <oska/trace.h>
+ */
+
+#include "alloc.h"
+#include "event.h"
+#include "mutex.h"
+#include "print.h"
+#include "spinlock.h"
+#include "thread.h"
+#include "time.h"
+#include "timer.h"
+#include "types.h"
+#include "util.h"
+
+#endif /* __OSKA_ALL_H */
--- /dev/null
+/*
+ * OSKA Linux implementation -- memory allocation
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_ALLOC_H
+#define __OSKA_LINUX_ALLOC_H
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+
+static inline void *os_alloc(size_t size)
+{
+ return kzalloc(size, GFP_ATOMIC);
+}
+
+static inline void *os_alloc_nonzeroed(size_t size)
+{
+ return kmalloc(size, GFP_KERNEL);
+}
+
+static inline void os_free(void *ptr)
+{
+ kfree(ptr);
+}
+
+static inline void *os_alloc_big(size_t size)
+{
+ return vmalloc(size);
+}
+
+static inline void os_free_big(void *ptr)
+{
+ vfree(ptr);
+}
+
+#endif /* #ifndef __OSKA_LINUX_ALLOC_H */
--- /dev/null
+/*
+ * Linux version compatibility functions.
+ *
+ * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#include "kernel-compat.h"
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
+
+int dev_set_name(struct device *dev, const char *fmt, ...)
+{
+ va_list vargs;
+
+ va_start(vargs, fmt);
+ vsnprintf(dev->bus_id, sizeof(dev->bus_id), fmt, vargs);
+ va_end(vargs);
+ return 0;
+}
+EXPORT_SYMBOL_GPL(dev_set_name);
+
+#endif /* Linux kernel < 2.6.26 */
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
+
+struct device *class_find_device(struct class *class, struct device *start,
+ void *data, int (*match)(struct device *, void *))
+{
+ struct device *dev;
+
+ list_for_each_entry(dev, &class->devices, node) {
+ if (match(dev, data)) {
+ get_device(dev);
+ return dev;
+ }
+ }
+ return NULL;
+}
+EXPORT_SYMBOL_GPL(class_find_device);
+
+#endif /* Linux kernel < 2.6.25 */
--- /dev/null
+/*
+ * Linux event functions.
+ *
+ * Copyright (C) 2009 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#include <linux/module.h>
+#include <linux/sched.h>
+
+#include "event.h"
+
+void os_event_init(os_event_t *evt)
+{
+ init_waitqueue_head(&evt->wq);
+ spin_lock_init(&evt->lock);
+ evt->events = 0;
+}
+EXPORT_SYMBOL(os_event_init);
+
+uint16_t os_event_wait(os_event_t *evt)
+{
+ uint16_t e;
+ unsigned long flags;
+
+ wait_event(evt->wq, evt->events != 0);
+
+ spin_lock_irqsave(&evt->lock, flags);
+ e = evt->events;
+ evt->events &= ~e;
+ spin_unlock_irqrestore(&evt->lock, flags);
+
+ return e;
+}
+EXPORT_SYMBOL(os_event_wait);
+
+uint16_t os_event_wait_interruptible(os_event_t *evt)
+{
+ uint16_t e;
+ unsigned long flags;
+
+ wait_event_interruptible(evt->wq, evt->events != 0);
+
+ spin_lock_irqsave(&evt->lock, flags);
+ e = evt->events;
+ evt->events &= ~e;
+ spin_unlock_irqrestore(&evt->lock, flags);
+
+ return e;
+}
+EXPORT_SYMBOL(os_event_wait_interruptible);
+
+uint16_t os_event_wait_timed(os_event_t *evt, unsigned timeout_ms)
+{
+ uint16_t e;
+ unsigned long flags;
+
+ wait_event_interruptible_timeout(evt->wq,
+ evt->events != 0,
+ msecs_to_jiffies(timeout_ms));
+
+ spin_lock_irqsave(&evt->lock, flags);
+ e = evt->events;
+ evt->events &= ~e;
+ spin_unlock_irqrestore(&evt->lock, flags);
+
+ return e;
+}
+EXPORT_SYMBOL(os_event_wait_timed);
+
+void os_event_raise(os_event_t *evt, uint16_t events)
+{
+ unsigned long flags;
+
+ spin_lock_irqsave(&evt->lock, flags);
+ evt->events |= events;
+ spin_unlock_irqrestore(&evt->lock, flags);
+
+ wake_up(&evt->wq);
+}
+EXPORT_SYMBOL(os_event_raise);
--- /dev/null
+/*
+ * OSKA Linux implementation -- events
+ *
+ * Copyright (C) 2009 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_EVENT_H
+#define __OSKA_LINUX_EVENT_H
+
+#include <linux/kernel.h>
+#include <linux/wait.h>
+#include <linux/spinlock.h>
+
+typedef struct {
+ wait_queue_head_t wq;
+ spinlock_t lock;
+ uint16_t events;
+} os_event_t;
+
+void os_event_init(os_event_t *evt);
+
+static inline void os_event_destroy(os_event_t *evt)
+{
+}
+
+uint16_t os_event_wait(os_event_t *evt);
+uint16_t os_event_wait_interruptible(os_event_t *evt);
+uint16_t os_event_wait_timed(os_event_t *evt, unsigned timeout_ms);
+void os_event_raise(os_event_t *evt, uint16_t events);
+
+#endif /* #ifndef __OSKA_LINUX_EVENT_H */
--- /dev/null
+/*
+ * OSKA Linux implementation -- memory mapped I/O.
+ *
+ * Copyright (C) 2009 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_IO_H
+#define __OSKA_LINUX_IO_H
+
+#include <linux/kernel.h>
+#include <linux/io.h>
+#include <linux/kernel-compat.h>
+
+typedef void __iomem *os_io_mem_t;
+
+static inline uint8_t os_io_read8(os_io_mem_t base, unsigned offset)
+{
+ return readb(base + offset);
+}
+
+static inline uint16_t os_io_read16(os_io_mem_t base, unsigned offset)
+{
+ return readw(base + offset);
+}
+
+static inline uint32_t os_io_read32(os_io_mem_t base, unsigned offset)
+{
+ return readl(base + offset);
+}
+
+static inline uint64_t os_io_read64(os_io_mem_t base, unsigned offset)
+{
+ return readq(base + offset);
+}
+
+static inline void os_io_write8(os_io_mem_t base, unsigned offset, uint8_t val)
+{
+ writeb(val, base + offset);
+}
+
+static inline void os_io_write16(os_io_mem_t base, unsigned offset, uint16_t val)
+{
+ writew(val, base + offset);
+}
+
+static inline void os_io_write32(os_io_mem_t base, unsigned offset, uint32_t val)
+{
+ writel(val, base + offset);
+}
+
+static inline void os_io_write64(os_io_mem_t base, unsigned offset, uint64_t val)
+{
+ writeq(val, base + offset);
+}
+
+static inline void os_io_memory_barrier(void)
+{
+ mb();
+}
+
+#endif /* #ifndef __OSKA_LINUX_IO_H */
--- /dev/null
+/*
+ * Kernel version compatibility.
+ *
+ * Copyright (C) 2007-2008 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * Wherever possible compatible implementations of newer APIs are
+ * provided for older kernel versions.
+ */
+#ifndef __LINUX_KERNEL_COMPAT_H
+#define __LINUX_KERNEL_COMPAT_H
+
+#include <linux/version.h>
+#include <linux/device.h>
+#include <linux/workqueue.h>
+
+#include <asm/io.h>
+
+/*
+ * linux/semaphore.h replaces asm/semaphore.h in 2.6.27.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
+# include <asm/semaphore.h>
+#else
+# include <linux/semaphore.h>
+#endif
+
+/*
+ * Workqueue API changes in 2.6.20
+ *
+ * See http://lwn.net/Articles/211279/ for details.
+ *
+ * We deliberately don't provide the non-automatic release (NAR)
+ * variants as a simple compatible implementation is not possible.
+ * This shouldn't be a problem as all usage so far is to embed the
+ * struct work_struct into another struct and the NAR variants aren't
+ * useful in this case (see http://lwn.net/Articles/213149/).
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
+
+#include <linux/workqueue.h>
+
+#undef INIT_WORK
+#define INIT_WORK(_work, _func) \
+ do { \
+ INIT_LIST_HEAD(&(_work)->entry); \
+ (_work)->pending = 0; \
+ PREPARE_WORK((_work), (_func), (_work)); \
+ init_timer(&(_work)->timer); \
+ } while(0)
+
+#undef DECLARE_WORK
+#define DECLARE_WORK(n, f) \
+ struct work_struct n = __WORK_INITIALIZER((n), (f), &(n))
+
+struct delayed_work {
+ struct work_struct work;
+};
+
+#define INIT_DELAYED_WORK(dw, fn) \
+ INIT_WORK(&(dw)->work, (fn))
+
+#define queue_delayed_work(wq, dw, delay) \
+ queue_delayed_work((wq), &(dw)->work, (delay))
+
+#define schedule_delayed_work(dw, delay) \
+ schedule_delayed_work(&(dw)->work, (delay))
+
+#define cancel_delayed_work(dw) \
+ cancel_delayed_work(&(dw)->work)
+
+#endif /* Linux kernel < 2.6.20 */
+
+/*
+ * device_create()/class_device_create()
+ *
+ * device_create() gains a drvdata parameter in 2.6.27. Since all
+ * users of device_create() in CSR code don't use drvdata just ignore
+ * it.
+ *
+ * device_create() replaces class_device_create() in 2.6.21.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
+
+#define device_create(class, parent, devt, drvdata, fmt, args...) \
+ class_device_create((class), (parent), (devt), NULL, (fmt), ## args)
+#define device_destroy(class, devt) \
+ class_device_destroy(class, devt)
+
+#elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
+
+#define device_create(class, parent, devt, drvdata, fmt, args...) \
+ device_create((class), (parent), (devt), (fmt), ## args)
+
+#endif /* Linux kernel < 2.6.26 */
+
+/*
+ * dev_name() and dev_set_name() added in 2.6.26.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
+
+static inline char *dev_name(struct device *dev)
+{
+ return dev->bus_id;
+}
+
+int dev_set_name(struct device *dev, const char *fmt, ...);
+
+#endif /* Linux kernel < 2.6.26 */
+
+/*
+ * class_find_device() in 2.6.25
+ */
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
+
+struct device *class_find_device(struct class *class, struct device *start,
+ void *data, int (*match)(struct device *, void *));
+
+#endif /* Linux kernel < 2.6.25 */
+
+/*
+ * list_first_entry in 2.6.22.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
+
+#define list_first_entry(ptr, type, member) \
+ list_entry((ptr)->next, type, member)
+
+#endif /* Linux kernel < 2.6.22 */
+
+/*
+ * 2.6.19 adds a bool type.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
+
+typedef _Bool bool;
+enum {
+ false = 0,
+ true = 1
+};
+
+#endif /* Linux kernel < 2.6.19 */
+
+/*
+ * Provide readq() and writeq() if unavailable.
+ */
+#ifndef readq
+static inline __u64 readq(const volatile void __iomem *addr)
+{
+ const volatile u32 __iomem *p = addr;
+ u32 low, high;
+
+ low = readl(p);
+ high = readl(p + 1);
+
+ return low + ((u64)high << 32);
+}
+#endif
+
+#ifndef writeq
+static inline void writeq(__u64 val, volatile void __iomem *addr)
+{
+ writel(val, addr);
+ writel(val >> 32, addr+4);
+}
+#endif
+
+/*
+ * get_unaligned_le16() and friends added in 2.6.26.
+ */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
+#include <asm/unaligned.h>
+
+static inline __u16 get_unaligned_le16(const void *p)
+{
+ return le16_to_cpu(get_unaligned((__le16 *)p));
+}
+
+static inline void put_unaligned_le16(__u16 val, const void *p)
+{
+ put_unaligned(cpu_to_le16(val), (__le16 *)p);
+}
+#endif /* Linux kernel < 2.6.26 */
+
+/*
+ * Various device or vendor IDs may not exist.
+ */
+#ifndef PCI_VENDOR_ID_CSR
+# define PCI_VENDOR_ID_CSR 0x18e5
+#endif
+
+#ifndef PCI_DEVICE_ID_JMICRON_JMB38X_SD
+# define PCI_DEVICE_ID_JMICRON_JMB38X_SD 0x2381
+#endif
+
+#endif /* #ifndef __LINUX_KERNEL_COMPAT_H */
--- /dev/null
+/*
+ * Operating system kernel abstraction -- linked lists.
+ *
+ * Copyright (C) 2009-2010 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+
+#include <stddef.h>
+
+#include "list.h"
+#include "util.h"
+
+/**
+ * Initialize an empty list.
+ *
+ * @ingroup list
+ */
+void os_list_init(struct os_list *list)
+{
+ list->head.next = list->head.prev = &list->head;
+}
+
+/**
+ * Is the list empty?
+ *
+ * @return true iff the list contains no nodes.
+ *
+ * @ingroup list
+ */
+int os_list_empty(struct os_list *list)
+{
+ return list->head.next == &list->head;
+}
+
+static void os_list_add(struct os_list_node *prev, struct os_list_node *new,
+ struct os_list_node *next)
+{
+ OS_ASSERT(new->next == NULL && new->prev == NULL);
+
+ next->prev = new;
+ new->next = next;
+ new->prev = prev;
+ prev->next = new;
+}
+
+/**
+ * Add a node to the tail of the list.
+ *
+ * @param list the list.
+ * @param node the list node to add.
+ *
+ * @ingroup list
+ */
+void os_list_add_tail(struct os_list *list, struct os_list_node *node)
+{
+ os_list_add(list->head.prev, node, &list->head);
+}
+
+/**
+ * Remove a node from a list.
+ *
+ * @param node the node to remove.
+ *
+ * @ingroup list
+ */
+void os_list_del(struct os_list_node *node)
+{
+ node->prev->next = node->next;
+ node->next->prev = node->prev;
+
+ node->prev = node->next = NULL;
+}
+
+/**
+ * The node at the head of the list.
+ *
+ * @param list the list.
+ *
+ * @return the node at the head of the list; or os_list_end() if the
+ * list is empty.
+ *
+ * @ingroup list
+ */
+struct os_list_node *os_list_head(struct os_list *list)
+{
+ return list->head.next;
+}
+
+/**
+ * The node marking the end of a list.
+ *
+ * @param list the list.
+ *
+ * @return the node that marks the end of the list.
+ *
+ * @ingroup list
+ */
+struct os_list_node *os_list_end(struct os_list *list)
+{
+ return &list->head;
+}
--- /dev/null
+/*
+ * Operating system kernel abstraction -- linked lists.
+ *
+ * Copyright (C) 2009-2010 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LIST_H
+#define __OSKA_LIST_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup list Linked Lists
+ *
+ * Generic linked list implementations suitable for all platforms.
+ *
+ * - Circular, doubly-linked list (struct os_list).
+ */
+
+/**
+ * A list node.
+ *
+ * This list node structure should be the first field within any
+ * structure that is to be stored in a list.
+ *
+ * @see struct os_list
+ * @ingroup list
+ */
+struct os_list_node {
+ /**
+ * The pointer to the previous node in the list, or os_list_end()
+ * if the end of the list has been reached.
+ */
+ struct os_list_node *prev;
+ /**
+ * The pointer to the next node in the list, or os_list_end() if
+ * the end of the list has been reached.
+ */
+ struct os_list_node *next;
+};
+
+/**
+ * A circular, doubly-linked list of nodes.
+ *
+ * Structures to be stored in a list should contains a struct
+ * os_list_node as the \e first field.
+ * \code
+ * struct foo {
+ * struct os_list_node node;
+ * int bar;
+ * ...
+ * };
+ * \endcode
+ * Going to/from a struct foo to a list node is then simple.
+ * \code
+ * struct os_list_node *node;
+ * struct foo *foo;
+ * [...]
+ * node = &foo->node;
+ * foo = (struct foo *)node
+ * \endcode
+ * Lists must be initialized with os_list_init() before adding nodes
+ * with os_list_add_tail(). The node at the head of the list is
+ * obtained with os_list_head(). Nodes are removed from the list with
+ * os_list_del().
+ *
+ * A list can be interated from the head to the tail using:
+ * \code
+ * struct os_list_node *node;
+ * for (node = os_list_head(list); node != os_list_end(list); node = node->next) {
+ * struct foo *foo = (struct foo *)node;
+ * ...
+ * }
+ * \endcode
+ *
+ * In the above loop, the current list node cannot be removed (with
+ * os_list_del()). If this is required use this form of loop:
+ * \code
+ * struct os_list_node *node, *next;
+ * for (node = os_list_head(list), next = node->next;
+ * node != os_list_end(list);
+ * node = next, next = node->next) {
+ * struct foo *foo = (struct foo *)node;
+ * ...
+ * os_list_del(node);
+ * ...
+ * }
+ * \endcode
+ *
+ * @ingroup list
+ */
+struct os_list {
+ /**
+ * @internal
+ * The dummy node marking the end of the list.
+ */
+ struct os_list_node head;
+};
+
+void os_list_init(struct os_list *list);
+int os_list_empty(struct os_list *list);
+void os_list_add_tail(struct os_list *list, struct os_list_node *node);
+void os_list_del(struct os_list_node *node);
+struct os_list_node *os_list_head(struct os_list *list);
+struct os_list_node *os_list_end(struct os_list *list);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* #ifndef __OSKA_LIST_H */
--- /dev/null
+/*
+ * OSKA Linux implementation -- mutexes
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_MUTEX_H
+#define __OSKA_LINUX_MUTEX_H
+
+#include <linux/kernel.h>
+#include <linux/mutex.h>
+
+#include "kernel-compat.h"
+
+/* Real mutexes were only added to 2.6.16 so use semaphores
+ instead. */
+typedef struct semaphore os_mutex_t;
+
+static inline void os_mutex_init(os_mutex_t *mutex)
+{
+ //init_MUTEX(mutex);
+ sema_init(mutex, 1);
+}
+
+static inline void os_mutex_destroy(os_mutex_t *mutex)
+{
+ /* no op */
+}
+
+static inline void os_mutex_lock(os_mutex_t *mutex)
+{
+ down(mutex);
+}
+
+static inline void os_mutex_unlock(os_mutex_t *mutex)
+{
+ up(mutex);
+}
+
+#endif /* __OSKA_LINUX_MUTEX_H */
--- /dev/null
+/*
+ * Linux kernel module support.
+ *
+ * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#include <linux/module.h>
+
+#include "all.h"
+#include "refcount.h"
+
+EXPORT_SYMBOL(os_refcount_init);
+EXPORT_SYMBOL(os_refcount_destroy);
+EXPORT_SYMBOL(os_refcount_get);
+EXPORT_SYMBOL(os_refcount_put);
+
+MODULE_DESCRIPTION("Operating System Kernel Abstraction");
+MODULE_AUTHOR("Cambridge Silicon Radio Ltd.");
+MODULE_LICENSE("GPL and additional rights");
--- /dev/null
+/*
+ * Linux console printing functions.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#include <linux/module.h>
+
+#include "print.h"
+
+void os_print(enum os_print_level level, const char *prefix, const char *name,
+ const char *format, ...)
+{
+ va_list va_args;
+
+ va_start(va_args, format);
+ os_vprint(level, prefix, name, format, va_args);
+ va_end(va_args);
+}
+EXPORT_SYMBOL(os_print);
+
+void os_vprint(enum os_print_level level, const char *prefix, const char *name,
+ const char *format, va_list args)
+{
+ const char *level_str[] = {
+ [OS_PRINT_ERROR] = KERN_ERR,
+ [OS_PRINT_WARNING] = KERN_WARNING,
+ [OS_PRINT_INFO] = KERN_INFO,
+ [OS_PRINT_DEBUG] = KERN_DEBUG,
+ };
+ char buf[80];
+ int w = 0;
+
+ if (name) {
+ w += snprintf(buf + w, sizeof(buf) - w, "%s%s%s: ", level_str[level], prefix, name);
+ } else {
+ w += snprintf(buf + w, sizeof(buf) - w, "%s%s", level_str[level], prefix);
+ }
+ w += vsnprintf(buf + w, sizeof(buf) - w, format, args);
+ printk("%s\n", buf);
+}
+EXPORT_SYMBOL(os_vprint);
--- /dev/null
+/*
+ * OSKA Linux implementation -- console printing
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_PRINT_H
+#define __OSKA_LINUX_PRINT_H
+
+#include <linux/kernel.h>
+
+/**
+ * Severity of a console or log message.
+ *
+ * @ingroup print
+ */
+enum os_print_level {
+ OS_PRINT_ERROR,
+ OS_PRINT_WARNING,
+ OS_PRINT_INFO,
+ OS_PRINT_DEBUG,
+};
+
+void os_print(enum os_print_level level, const char *prefix, const char *name,
+ const char *format, ...);
+void os_vprint(enum os_print_level level, const char *prefix, const char *name,
+ const char *format, va_list args);
+
+
+#endif /* #ifndef __OSKA_LINUX_PRINT_H */
--- /dev/null
+/*
+ * OSKA generic implementation -- reference counting.
+ *
+ * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#include "refcount.h"
+#include "types.h"
+
+void os_refcount_init(os_refcount_t *refcount, os_refcount_callback_f func, void *arg)
+{
+ os_spinlock_init(&refcount->lock);
+ refcount->count = 1;
+ refcount->func = func;
+ refcount->arg = arg;
+}
+
+void os_refcount_destroy(os_refcount_t *refcount)
+{
+ os_spinlock_destroy(&refcount->lock);
+}
+
+void os_refcount_get(os_refcount_t *refcount)
+{
+ os_int_status_t istate;
+
+ os_spinlock_lock_intsave(&refcount->lock, &istate);
+ refcount->count++;
+ os_spinlock_unlock_intrestore(&refcount->lock, &istate);
+}
+
+void os_refcount_put(os_refcount_t *refcount)
+{
+ bool is_zero;
+ os_int_status_t istate;
+
+ os_spinlock_lock_intsave(&refcount->lock, &istate);
+ refcount->count--;
+ is_zero = refcount->count == 0;
+ os_spinlock_unlock_intrestore(&refcount->lock, &istate);
+
+ if (is_zero) {
+ refcount->func(refcount->arg);
+ }
+}
--- /dev/null
+/*
+ * Operating system kernel abstraction -- reference counting.
+ *
+ * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_REFCOUNT_H
+#define __OSKA_REFCOUNT_H
+
+#include "spinlock.h"
+
+/**
+ * @defgroup refcount Reference Counting
+ *
+ * A reference count is an atomic counter. A callback function is
+ * called whenever the count reaches zero.
+ *
+ * A generic implementation is provided that is suitable for all
+ * platforms that support the spinlock API in <oska/spinlock.h> (see
+ * \ref spinlock).
+ */
+
+typedef void (*os_refcount_callback_f)(void *arg);
+
+struct __os_refcount_impl {
+ unsigned count;
+ os_spinlock_t lock;
+ os_refcount_callback_f func;
+ void *arg;
+};
+
+/**
+ * A reference count object.
+ *
+ * @ingroup refcount
+ */
+typedef struct __os_refcount_impl os_refcount_t;
+
+/**
+ * Initialize a reference count to 1.
+ *
+ * Initialized reference counts must be destroyed by calling
+ * os_refcount_destroy().
+ *
+ * @param refcount the reference count.
+ * @param func the function which will be called when the
+ * reference count reaches 0.
+ * @param arg an argument to pass to func.
+ *
+ * @ingroup refcount
+ */
+void os_refcount_init(os_refcount_t *refcount, os_refcount_callback_f func, void *arg);
+
+/**
+ * Destroy a reference count object.
+ *
+ * @param refcount the reference count.
+ *
+ * @ingroup refcount
+ */
+void os_refcount_destroy(os_refcount_t *refcount);
+
+/**
+ * Atomically increase the reference count by 1.
+ *
+ * @param refcount the reference count.
+ *
+ * @ingroup refcount
+ */
+void os_refcount_get(os_refcount_t *refcount);
+
+/**
+ * Atomically decrease the reference count by 1.
+ *
+ * The callback function passed to the call to os_refcount_init() is
+ * called if the count was decreased to zero.
+ *
+ * @param refcount the reference count.
+ *
+ * @ingroup refcount
+ */
+void os_refcount_put(os_refcount_t *refcount);
+
+#endif /* #ifndef __OSKA_REFCOUNT_H */
--- /dev/null
+/*
+ * OSKA Linux implementation -- semaphores
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_SEMAPHORE_H
+#define __OSKA_LINUX_SEMAPHORE_H
+
+#include <linux/kernel.h>
+
+#include <linux/kernel-compat.h>
+
+typedef struct semaphore os_semaphore_t;
+
+static inline void os_semaphore_init(os_semaphore_t *sem)
+{
+ sema_init(sem, 0);
+}
+
+static inline void os_semaphore_destroy(os_semaphore_t *sem)
+{
+}
+
+static inline void os_semaphore_wait(os_semaphore_t *sem)
+{
+ down(sem);
+}
+
+/*
+ * down_timeout() was added in 2.6.26 with the generic semaphore
+ * implementation. For now, only support it on recent kernels as
+ * semaphores may be replaced by an event API that would be
+ * implemented with wait_event(), and wait_event_timeout().
+ */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+
+static inline int os_semaphore_wait_timed(os_semaphore_t *sem,
+ int time_ms)
+{
+ if (down_timeout(sem, msecs_to_jiffies(time_ms)) < 0) {
+ return -ETIMEDOUT;
+ }
+ return 0;
+}
+
+#else
+
+static inline int os_semaphore_wait_timed(os_semaphore_t *sem, int time_ms)
+{
+ unsigned long now = jiffies;
+ do{
+ if(!down_trylock(sem))
+ return 0;
+ msleep(1);
+ } while(time_before(jiffies, now + msecs_to_jiffies(time_ms)));
+
+ return -ETIMEDOUT;
+}
+
+#endif
+
+static inline void os_semaphore_post(os_semaphore_t *sem)
+{
+ up(sem);
+}
+
+#endif /* __OSKA_LINUX_SEMAPHORE_H */
--- /dev/null
+/*
+ * OSKA Linux implementation -- spinlocks
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_SPINLOCK_H
+#define __OSKA_LINUX_SPINLOCK_H
+
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+
+typedef spinlock_t os_spinlock_t;
+typedef unsigned long os_int_status_t;
+
+static inline void os_spinlock_init(os_spinlock_t *lock)
+{
+ spinlock_t *l = (spinlock_t *)lock;
+ spin_lock_init(l);
+}
+
+static inline void os_spinlock_destroy(os_spinlock_t *lock)
+{
+ /* no op */
+}
+
+static inline void os_spinlock_lock_intsave(os_spinlock_t *lock,
+ os_int_status_t *int_state)
+{
+ spinlock_t *l = (spinlock_t *)lock;
+ spin_lock_irqsave(l, *int_state);
+}
+
+static inline void os_spinlock_unlock_intrestore(os_spinlock_t *lock,
+ os_int_status_t *int_state)
+{
+ spinlock_t *l = (spinlock_t *)lock;
+ spin_unlock_irqrestore(l, *int_state);
+}
+
+#endif /* #ifndef __OSKA_LINUX_SPINLOCK_H */
--- /dev/null
+/*
+ * Linux thread functions.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#include <linux/module.h>
+
+#include "thread.h"
+
+static int thread_func(void *data)
+{
+ os_thread_t *thread = data;
+
+ thread->func(thread->arg);
+
+ /*
+ * kthread_stop() cannot handle the thread exiting while
+ * kthread_should_stop() is false, so sleep until kthread_stop()
+ * wakes us up.
+ */
+ set_current_state(TASK_INTERRUPTIBLE);
+ if (!kthread_should_stop())
+ schedule();
+
+ return 0;
+}
+
+int os_thread_create(os_thread_t *thread, const char *name, void (*func)(void *), void *arg)
+{
+ thread->func = func;
+ thread->arg = arg;
+
+ thread->stop = 0;
+
+ thread->task = kthread_run(thread_func, thread, name);
+ if (IS_ERR(thread->task)) {
+ return PTR_ERR(thread->task);
+ }
+ return 0;
+}
+EXPORT_SYMBOL(os_thread_create);
+
+void os_thread_stop(os_thread_t *thread, os_event_t *evt)
+{
+ /*
+ * Stop flag must be set before the event is raised so
+ * kthread_should_stop() cannot be used.
+ */
+ thread->stop = 1;
+
+ if (evt) {
+ os_event_raise(evt, ~0);
+ }
+
+ kthread_stop(thread->task);
+}
+EXPORT_SYMBOL(os_thread_stop);
+
+int os_thread_should_stop(os_thread_t *thread)
+{
+ return thread->stop;
+}
+EXPORT_SYMBOL(os_thread_should_stop);
--- /dev/null
+/*
+ * OSKA Linux implementation -- threading
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_THREAD_H
+#define __OSKA_LINUX_THREAD_H
+
+#include <linux/version.h>
+#include <linux/kernel.h>
+#include <linux/kthread.h>
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,19)
+#include <linux/freezer.h>
+#endif
+#include "event.h"
+
+struct os_thread_lx {
+ void (*func)(void *);
+ void *arg;
+ struct task_struct *task;
+ int stop;
+};
+
+typedef struct os_thread_lx os_thread_t;
+
+int os_thread_create(os_thread_t *thread, const char *name,
+ void (*func)(void *), void *arg);
+void os_thread_stop(os_thread_t *thread, os_event_t *evt);
+int os_thread_should_stop(os_thread_t *thread);
+
+static inline void os_try_suspend_thread(os_thread_t *thread)
+{
+ try_to_freeze();
+}
+
+#endif /* __OSKA_LINUX_THREAD_H */
--- /dev/null
+/*
+ * OSKA Linux implementation -- timing
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_TIME_H
+#define __OSKA_LINUX_TIME_H
+
+#include <linux/kernel.h>
+#include <linux/time.h>
+#include <linux/delay.h>
+#include <linux/jiffies.h>
+
+static inline unsigned long os_current_time_ms(void)
+{
+ return jiffies_to_msecs(jiffies);
+}
+
+static inline void os_sleep_ms(unsigned ms)
+{
+ msleep_interruptible(ms);
+}
+
+static inline void os_delay_us(unsigned us)
+{
+ udelay(us);
+}
+
+#define os_time_after(a, b) time_after((a), (b))
+
+#endif /* __OSKA_LINUX_TIME_H */
--- /dev/null
+/*
+ * OSKA Linux implementation -- timers.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#include <linux/module.h>
+
+#include "timer.h"
+
+static void timer_func(unsigned long data)
+{
+ os_timer_t *timer = (os_timer_t *)data;
+
+ timer->func(timer->arg);
+}
+
+void os_timer_init(os_timer_t *timer, os_timer_func_t func, void *arg)
+{
+ timer->func = func;
+ timer->arg = arg;
+ timer->timer.function = timer_func;
+ timer->timer.data = (unsigned long)timer;
+ init_timer(&timer->timer);
+}
+EXPORT_SYMBOL(os_timer_init);
--- /dev/null
+/*
+ * OSKA Linux implementation -- timers.
+ *
+ * Copyright (C) 2009 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_TIMER_H
+#define __OSKA_LINUX_TIMER_H
+
+#include <linux/kernel.h>
+#include <linux/timer.h>
+
+typedef void (*os_timer_func_t)(void *arg);
+
+typedef struct {
+ os_timer_func_t func;
+ void *arg;
+ struct timer_list timer;
+} os_timer_t;
+
+void os_timer_init(os_timer_t *timer, os_timer_func_t func, void *arg);
+
+static inline void os_timer_destroy(os_timer_t *timer)
+{
+ del_timer_sync(&timer->timer);
+}
+
+static inline void os_timer_set(os_timer_t *timer, unsigned long expires_ms)
+{
+ mod_timer(&timer->timer, jiffies + msecs_to_jiffies(expires_ms));
+}
+
+static inline void os_timer_cancel(os_timer_t *timer)
+{
+ del_timer(&timer->timer);
+}
+
+#endif /* #ifndef __OSKA_LINUX_TIMER_H */
--- /dev/null
+/*
+ * OSKA Linux implementation -- tracing messages.
+ *
+ * Copyright (C) 2009 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_TRACE_H
+#define __OSKA_LINUX_TRACE_H
+
+#include <linux/kernel.h>
+
+#ifndef OS_TRACE_PREFIX
+# define OS_TRACE_PREFIX ""
+#endif
+
+#define os_trace_err(format, ...) printk(KERN_ERR OS_TRACE_PREFIX format "\n", ## __VA_ARGS__)
+#define os_trace_warn(format, ...) printk(KERN_WARNING OS_TRACE_PREFIX format "\n", ## __VA_ARGS__)
+#define os_trace_info(format, ...) printk(KERN_INFO OS_TRACE_PREFIX format "\n", ## __VA_ARGS__)
+#define os_trace_dbg(format, ...) printk(KERN_DEBUG OS_TRACE_PREFIX format "\n", ## __VA_ARGS__)
+
+#endif /* #ifndef __OSKA_LINUX_TRACE_H */
--- /dev/null
+/*
+ * OSKA Linux implementation -- types
+ *
+ * Copyright (C) 2009 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_TYPES_H
+#define __OSKA_LINUX_TYPES_H
+
+#include <linux/types.h>
+
+#endif /* #ifndef __OSKA_LINUX_TYPES_H */
--- /dev/null
+/*
+ * OSKA Linux implementation -- misc. utility functions
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef __OSKA_LINUX_UTILS_H
+#define __OSKA_LINUX_UTILS_H
+
+#include <linux/kernel.h>
+#include <linux/bug.h>
+#include <asm/byteorder.h>
+
+#define OS_ASSERT(expr) BUG_ON(!(expr))
+
+static inline uint16_t os_le16_to_cpu(uint16_t x)
+{
+ return le16_to_cpu(x);
+}
+
+static inline uint16_t os_cpu_to_le16(uint16_t x)
+{
+ return cpu_to_le16(x);
+}
+
+static inline uint32_t os_le32_to_cpu(uint32_t x)
+{
+ return le32_to_cpu(x);
+}
+
+static inline uint32_t os_cpu_to_le32(uint32_t x)
+{
+ return cpu_to_le32(x);
+}
+
+static inline uint64_t os_le64_to_cpu(uint64_t x)
+{
+ return le64_to_cpu(x);
+}
+
+static inline uint64_t os_cpu_to_le64(uint64_t x)
+{
+ return cpu_to_le64(x);
+}
+
+#endif /* __OSKA_LINUX_UTILS_H */
--- /dev/null
+/*
+ * ***************************************************************************
+ * FILE: putest.c
+ *
+ * PURPOSE: putest related functions.
+ *
+ * Copyright (C) 2008-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ***************************************************************************
+ */
+
+#include <linux/vmalloc.h>
+#include <linux/firmware.h>
+
+#include "unifi_priv.h"
+#include "csr_wifi_hip_chiphelper.h"
+
+#define UNIFI_PROC_BOTH 3
+
+
+int unifi_putest_cmd52_read(unifi_priv_t *priv, unsigned char *arg)
+{
+ struct unifi_putest_cmd52 cmd52_params;
+ CsrUint8 *arg_pos;
+ unsigned int cmd_param_size;
+ int r;
+ CsrResult csrResult;
+ unsigned char ret_buffer[32];
+ CsrUint8 *ret_buffer_pos;
+ CsrUint8 retries;
+
+ arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+ if (get_user(cmd_param_size, (int*)arg_pos)) {
+ unifi_error(priv,
+ "unifi_putest_cmd52_read: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ if (cmd_param_size != sizeof(struct unifi_putest_cmd52)) {
+ unifi_error(priv,
+ "unifi_putest_cmd52_read: cmd52 struct mismatch\n");
+ return -EINVAL;
+ }
+
+ arg_pos += sizeof(unsigned int);
+ if (copy_from_user(&cmd52_params,
+ (void*)arg_pos,
+ sizeof(struct unifi_putest_cmd52))) {
+ unifi_error(priv,
+ "unifi_putest_cmd52_read: Failed to get the cmd52 params\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG2, "cmd52r: func=%d addr=0x%x ",
+ cmd52_params.funcnum, cmd52_params.addr);
+
+ retries = 3;
+ CsrSdioClaim(priv->sdio);
+ do {
+ if (cmd52_params.funcnum == 0) {
+ csrResult = CsrSdioF0Read8(priv->sdio, cmd52_params.addr, &cmd52_params.data);
+ } else {
+ csrResult = CsrSdioRead8(priv->sdio, cmd52_params.addr, &cmd52_params.data);
+ }
+ } while (--retries && ((csrResult == CSR_SDIO_RESULT_CRC_ERROR) || (csrResult == CSR_SDIO_RESULT_TIMEOUT)));
+ CsrSdioRelease(priv->sdio);
+
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv,
+ "\nunifi_putest_cmd52_read: Read8() failed (csrResult=0x%x)\n", csrResult);
+ return -EFAULT;
+ }
+ unifi_trace(priv, UDBG2, "data=%d\n", cmd52_params.data);
+
+ /* Copy the info to the out buffer */
+ *(unifi_putest_command_t*)ret_buffer = UNIFI_PUTEST_CMD52_READ;
+ ret_buffer_pos = (CsrUint8*)(((unifi_putest_command_t*)ret_buffer) + 1);
+ *(unsigned int*)ret_buffer_pos = sizeof(struct unifi_putest_cmd52);
+ ret_buffer_pos += sizeof(unsigned int);
+ memcpy(ret_buffer_pos, &cmd52_params, sizeof(struct unifi_putest_cmd52));
+ ret_buffer_pos += sizeof(struct unifi_putest_cmd52);
+
+ r = copy_to_user((void*)arg,
+ ret_buffer,
+ ret_buffer_pos - ret_buffer);
+ if (r) {
+ unifi_error(priv,
+ "unifi_putest_cmd52_read: Failed to return the data\n");
+ return -EFAULT;
+ }
+
+ return 0;
+}
+
+
+int unifi_putest_cmd52_write(unifi_priv_t *priv, unsigned char *arg)
+{
+ struct unifi_putest_cmd52 cmd52_params;
+ CsrUint8 *arg_pos;
+ unsigned int cmd_param_size;
+ CsrResult csrResult;
+ CsrUint8 retries;
+
+ arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+ if (get_user(cmd_param_size, (int*)arg_pos)) {
+ unifi_error(priv,
+ "unifi_putest_cmd52_write: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ if (cmd_param_size != sizeof(struct unifi_putest_cmd52)) {
+ unifi_error(priv,
+ "unifi_putest_cmd52_write: cmd52 struct mismatch\n");
+ return -EINVAL;
+ }
+
+ arg_pos += sizeof(unsigned int);
+ if (copy_from_user(&cmd52_params,
+ (void*)(arg_pos),
+ sizeof(struct unifi_putest_cmd52))) {
+ unifi_error(priv,
+ "unifi_putest_cmd52_write: Failed to get the cmd52 params\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG2, "cmd52w: func=%d addr=0x%x data=%d\n",
+ cmd52_params.funcnum, cmd52_params.addr, cmd52_params.data);
+
+ retries = 3;
+ CsrSdioClaim(priv->sdio);
+ do {
+ if (cmd52_params.funcnum == 0) {
+ csrResult = CsrSdioF0Write8(priv->sdio, cmd52_params.addr, cmd52_params.data);
+ } else {
+ csrResult = CsrSdioWrite8(priv->sdio, cmd52_params.addr, cmd52_params.data);
+ }
+ } while (--retries && ((csrResult == CSR_SDIO_RESULT_CRC_ERROR) || (csrResult == CSR_SDIO_RESULT_TIMEOUT)));
+ CsrSdioRelease(priv->sdio);
+
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv,
+ "unifi_putest_cmd52_write: Write8() failed (csrResult=0x%x)\n", csrResult);
+ return -EFAULT;
+ }
+
+ return 0;
+}
+
+int unifi_putest_gp_read16(unifi_priv_t *priv, unsigned char *arg)
+{
+ struct unifi_putest_gp_rw16 gp_r16_params;
+ CsrUint8 *arg_pos;
+ unsigned int cmd_param_size;
+ int r;
+ CsrResult csrResult;
+ unsigned char ret_buffer[32];
+ CsrUint8 *ret_buffer_pos;
+
+ arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+ if (get_user(cmd_param_size, (int*)arg_pos)) {
+ unifi_error(priv,
+ "unifi_putest_gp_read16: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ if (cmd_param_size != sizeof(struct unifi_putest_gp_rw16)) {
+ unifi_error(priv,
+ "unifi_putest_gp_read16: struct mismatch\n");
+ return -EINVAL;
+ }
+
+ arg_pos += sizeof(unsigned int);
+ if (copy_from_user(&gp_r16_params,
+ (void*)arg_pos,
+ sizeof(struct unifi_putest_gp_rw16))) {
+ unifi_error(priv,
+ "unifi_putest_gp_read16: Failed to get the params\n");
+ return -EFAULT;
+ }
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_card_read16(priv->card, gp_r16_params.addr, &gp_r16_params.data);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv,
+ "unifi_putest_gp_read16: unifi_card_read16() GP=0x%x failed (csrResult=0x%x)\n", gp_r16_params.addr, csrResult);
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG2, "gp_r16: GP=0x%08x, data=0x%04x\n", gp_r16_params.addr, gp_r16_params.data);
+
+ /* Copy the info to the out buffer */
+ *(unifi_putest_command_t*)ret_buffer = UNIFI_PUTEST_GP_READ16;
+ ret_buffer_pos = (CsrUint8*)(((unifi_putest_command_t*)ret_buffer) + 1);
+ *(unsigned int*)ret_buffer_pos = sizeof(struct unifi_putest_gp_rw16);
+ ret_buffer_pos += sizeof(unsigned int);
+ memcpy(ret_buffer_pos, &gp_r16_params, sizeof(struct unifi_putest_gp_rw16));
+ ret_buffer_pos += sizeof(struct unifi_putest_gp_rw16);
+
+ r = copy_to_user((void*)arg,
+ ret_buffer,
+ ret_buffer_pos - ret_buffer);
+ if (r) {
+ unifi_error(priv,
+ "unifi_putest_gp_read16: Failed to return the data\n");
+ return -EFAULT;
+ }
+
+ return 0;
+}
+
+int unifi_putest_gp_write16(unifi_priv_t *priv, unsigned char *arg)
+{
+ struct unifi_putest_gp_rw16 gp_w16_params;
+ CsrUint8 *arg_pos;
+ unsigned int cmd_param_size;
+ CsrResult csrResult;
+
+ arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+ if (get_user(cmd_param_size, (int*)arg_pos)) {
+ unifi_error(priv,
+ "unifi_putest_gp_write16: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ if (cmd_param_size != sizeof(struct unifi_putest_gp_rw16)) {
+ unifi_error(priv,
+ "unifi_putest_gp_write16: struct mismatch\n");
+ return -EINVAL;
+ }
+
+ arg_pos += sizeof(unsigned int);
+ if (copy_from_user(&gp_w16_params,
+ (void*)(arg_pos),
+ sizeof(struct unifi_putest_gp_rw16))) {
+ unifi_error(priv,
+ "unifi_putest_gp_write16: Failed to get the params\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG2, "gp_w16: GP=0x%08x, data=0x%04x\n", gp_w16_params.addr, gp_w16_params.data);
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_card_write16(priv->card, gp_w16_params.addr, gp_w16_params.data);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv,
+ "unifi_putest_gp_write16: unifi_card_write16() GP=%x failed (csrResult=0x%x)\n", gp_w16_params.addr, csrResult);
+ return -EFAULT;
+ }
+
+ return 0;
+}
+
+int unifi_putest_set_sdio_clock(unifi_priv_t *priv, unsigned char *arg)
+{
+ int sdio_clock_speed;
+ CsrResult csrResult;
+
+ if (get_user(sdio_clock_speed, (int*)(((unifi_putest_command_t*)arg) + 1))) {
+ unifi_error(priv,
+ "unifi_putest_set_sdio_clock: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG2, "set sdio clock: %d KHz\n", sdio_clock_speed);
+
+ CsrSdioClaim(priv->sdio);
+ csrResult = CsrSdioMaxBusClockFrequencySet(priv->sdio, sdio_clock_speed * 1000);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv,
+ "unifi_putest_set_sdio_clock: Set clock failed (csrResult=0x%x)\n", csrResult);
+ return -EFAULT;
+ }
+
+ return 0;
+}
+
+
+int unifi_putest_start(unifi_priv_t *priv, unsigned char *arg)
+{
+ int r;
+ CsrResult csrResult;
+ int already_in_test = priv->ptest_mode;
+
+ /* Ensure that sme_sys_suspend() doesn't power down the chip because:
+ * 1) Power is needed anyway for ptest.
+ * 2) The app code uses the START ioctl as a reset, so it gets called
+ * multiple times. If the app stops the XAPs, but the power_down/up
+ * sequence doesn't actually power down the chip, there can be problems
+ * resetting, because part of the power_up sequence disables function 1
+ */
+ priv->ptest_mode = 1;
+
+ /* Suspend the SME and UniFi */
+ if (priv->sme_cli) {
+ r = sme_sys_suspend(priv);
+ if (r) {
+ unifi_error(priv,
+ "unifi_putest_start: failed to suspend UniFi\n");
+ return r;
+ }
+ }
+
+ /* Application may have stopped the XAPs, but they are needed for reset */
+ if (already_in_test) {
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_start_processors(priv->card);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "Failed to start XAPs. Hard reset required.\n");
+ }
+ } else {
+ /* Ensure chip is powered for the case where there's no unifi_helper */
+ CsrSdioClaim(priv->sdio);
+ csrResult = CsrSdioPowerOn(priv->sdio);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "CsrSdioPowerOn csrResult = %d\n", csrResult);
+ }
+ }
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_init(priv->card);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv,
+ "unifi_putest_start: failed to init UniFi\n");
+ return CsrHipResultToStatus(csrResult);
+ }
+
+ return 0;
+}
+
+
+int unifi_putest_stop(unifi_priv_t *priv, unsigned char *arg)
+{
+ int r = 0;
+ CsrResult csrResult;
+
+ /* Application may have stopped the XAPs, but they are needed for reset */
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_start_processors(priv->card);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "Failed to start XAPs. Hard reset required.\n");
+ }
+
+ /* PUTEST_STOP is also used to resume the XAPs after SME coredump.
+ * Don't power off the chip, leave that to the normal wifi-off which is
+ * about to carry on. No need to resume the SME either, as it wasn't suspended.
+ */
+ if (priv->coredump_mode) {
+ priv->coredump_mode = 0;
+ return 0;
+ }
+
+ /* At this point function 1 is enabled and the XAPs are running, so it is
+ * safe to let the card power down. Power is restored later, asynchronously,
+ * during the wifi_on requested by the SME.
+ */
+ CsrSdioClaim(priv->sdio);
+ CsrSdioPowerOff(priv->sdio);
+ CsrSdioRelease(priv->sdio);
+
+ /* Resume the SME and UniFi */
+ if (priv->sme_cli) {
+ r = sme_sys_resume(priv);
+ if (r) {
+ unifi_error(priv,
+ "unifi_putest_stop: failed to resume SME\n");
+ }
+ }
+ priv->ptest_mode = 0;
+
+ return r;
+}
+
+
+int unifi_putest_dl_fw(unifi_priv_t *priv, unsigned char *arg)
+{
+#define UF_PUTEST_MAX_FW_FILE_NAME 16
+#define UNIFI_MAX_FW_PATH_LEN 32
+ unsigned int fw_name_length;
+ unsigned char fw_name[UF_PUTEST_MAX_FW_FILE_NAME+1];
+ unsigned char *name_buffer;
+ int postfix;
+ char fw_path[UNIFI_MAX_FW_PATH_LEN];
+ const struct firmware *fw_entry;
+ struct dlpriv temp_fw_sta;
+ int r;
+ CsrResult csrResult;
+
+ /* Get the f/w file name length */
+ if (get_user(fw_name_length, (unsigned int*)(((unifi_putest_command_t*)arg) + 1))) {
+ unifi_error(priv,
+ "unifi_putest_dl_fw: Failed to get the length argument\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG2, "unifi_putest_dl_fw: file name size = %d\n", fw_name_length);
+
+ /* Sanity check for the f/w file name length */
+ if (fw_name_length > UF_PUTEST_MAX_FW_FILE_NAME) {
+ unifi_error(priv,
+ "unifi_putest_dl_fw: F/W file name is too long\n");
+ return -EINVAL;
+ }
+
+ /* Get the f/w file name */
+ name_buffer = ((unsigned char*)arg) + sizeof(unifi_putest_command_t) + sizeof(unsigned int);
+ if (copy_from_user(fw_name, (void*)name_buffer, fw_name_length)) {
+ unifi_error(priv, "unifi_putest_dl_fw: Failed to get the file name\n");
+ return -EFAULT;
+ }
+ fw_name[fw_name_length] = '\0';
+ unifi_trace(priv, UDBG2, "unifi_putest_dl_fw: file = %s\n", fw_name);
+
+ /* Keep the existing f/w to a temp, we need to restore it later */
+ temp_fw_sta = priv->fw_sta;
+
+ /* Get the putest f/w */
+ postfix = priv->instance;
+ scnprintf(fw_path, UNIFI_MAX_FW_PATH_LEN, "unifi-sdio-%d/%s",
+ postfix, fw_name);
+ r = request_firmware(&fw_entry, fw_path, priv->unifi_device);
+ if (r == 0) {
+ priv->fw_sta.fw_desc = (void *)fw_entry;
+ priv->fw_sta.dl_data = fw_entry->data;
+ priv->fw_sta.dl_len = fw_entry->size;
+ } else {
+ unifi_error(priv, "Firmware file not available\n");
+ return -EINVAL;
+ }
+
+ /* Application may have stopped the XAPs, but they are needed for reset */
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_start_processors(priv->card);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "Failed to start XAPs. Hard reset required.\n");
+ }
+
+ /* Download the f/w. On UF6xxx this will cause the f/w file to convert
+ * into patch format and download via the ROM boot loader
+ */
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_download(priv->card, 0x0c00);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv,
+ "unifi_putest_dl_fw: failed to download the f/w\n");
+ goto free_fw;
+ }
+
+ /* Free the putest f/w... */
+free_fw:
+ uf_release_firmware(priv, &priv->fw_sta);
+ /* ... and restore the original f/w */
+ priv->fw_sta = temp_fw_sta;
+
+ return CsrHipResultToStatus(csrResult);
+}
+
+
+int unifi_putest_dl_fw_buff(unifi_priv_t *priv, unsigned char *arg)
+{
+ unsigned int fw_length;
+ unsigned char *fw_buf = NULL;
+ unsigned char *fw_user_ptr;
+ struct dlpriv temp_fw_sta;
+ CsrResult csrResult;
+
+ /* Get the f/w buffer length */
+ if (get_user(fw_length, (unsigned int*)(((unifi_putest_command_t*)arg) + 1))) {
+ unifi_error(priv,
+ "unifi_putest_dl_fw_buff: Failed to get the length arg\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG2, "unifi_putest_dl_fw_buff: size = %d\n", fw_length);
+
+ /* Sanity check for the buffer length */
+ if (fw_length == 0 || fw_length > 0xfffffff) {
+ unifi_error(priv,
+ "unifi_putest_dl_fw_buff: buffer length bad %u\n", fw_length);
+ return -EINVAL;
+ }
+
+ /* Buffer for kernel copy of the f/w image */
+ fw_buf = CsrPmemAlloc(fw_length);
+ if (!fw_buf) {
+ unifi_error(priv, "unifi_putest_dl_fw_buff: malloc fail\n");
+ return -ENOMEM;
+ }
+
+ /* Get the f/w image */
+ fw_user_ptr = ((unsigned char*)arg) + sizeof(unifi_putest_command_t) + sizeof(unsigned int);
+ if (copy_from_user(fw_buf, (void*)fw_user_ptr, fw_length)) {
+ unifi_error(priv, "unifi_putest_dl_fw_buff: Failed to get the buffer\n");
+ CsrPmemFree(fw_buf);
+ return -EFAULT;
+ }
+
+ /* Save the existing f/w to a temp, we need to restore it later */
+ temp_fw_sta = priv->fw_sta;
+
+ /* Setting fw_desc NULL indicates to the core that no f/w file was loaded
+ * via the kernel request_firmware() mechanism. This indicates to the core
+ * that it shouldn't call release_firmware() after the download is done.
+ */
+ priv->fw_sta.fw_desc = NULL; /* No OS f/w resource */
+ priv->fw_sta.dl_data = fw_buf;
+ priv->fw_sta.dl_len = fw_length;
+
+ /* Application may have stopped the XAPs, but they are needed for reset */
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_start_processors(priv->card);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "Failed to start XAPs. Hard reset required.\n");
+ }
+
+ /* Download the f/w. On UF6xxx this will cause the f/w file to convert
+ * into patch format and download via the ROM boot loader
+ */
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_download(priv->card, 0x0c00);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv,
+ "unifi_putest_dl_fw_buff: failed to download the f/w\n");
+ goto free_fw;
+ }
+
+free_fw:
+ /* Finished with the putest f/w, so restore the station f/w */
+ priv->fw_sta = temp_fw_sta;
+ CsrPmemFree(fw_buf);
+
+ return CsrHipResultToStatus(csrResult);
+}
+
+
+int unifi_putest_coredump_prepare(unifi_priv_t *priv, unsigned char *arg)
+{
+ CsrUint16 data_u16;
+ CsrInt32 i;
+ CsrResult r;
+
+ unifi_info(priv, "Preparing for SDIO coredump\n");
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE)
+ unifi_debug_buf_dump();
+#endif
+
+ /* Sanity check that userspace hasn't called a PUTEST_START, because that
+ * would have reset UniFi, potentially power cycling it and losing context
+ */
+ if (priv->ptest_mode) {
+ unifi_error(priv, "PUTEST_START shouldn't be used before a coredump\n");
+ }
+
+ /* Flag that the userspace has requested coredump. Even if this preparation
+ * fails, the SME will call PUTEST_STOP to tidy up.
+ */
+ priv->coredump_mode = 1;
+
+ for (i = 0; i < 3; i++) {
+ CsrSdioClaim(priv->sdio);
+ r = CsrSdioRead16(priv->sdio, CHIP_HELPER_UNIFI_GBL_CHIP_VERSION*2, &data_u16);
+ CsrSdioRelease(priv->sdio);
+ if (r != CSR_RESULT_SUCCESS) {
+ unifi_info(priv, "Failed to read chip version! Try %d\n", i);
+
+ /* First try, re-enable function which may have been disabled by f/w panic */
+ if (i == 0) {
+ unifi_info(priv, "Try function enable\n");
+ CsrSdioClaim(priv->sdio);
+ r = CsrSdioFunctionEnable(priv->sdio);
+ CsrSdioRelease(priv->sdio);
+ if (r != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "CsrSdioFunctionEnable failed %d\n", r);
+ }
+ continue;
+ }
+
+ /* Subsequent tries, reset */
+
+ /* Set clock speed low */
+ CsrSdioClaim(priv->sdio);
+ r = CsrSdioMaxBusClockFrequencySet(priv->sdio, UNIFI_SDIO_CLOCK_SAFE_HZ);
+ CsrSdioRelease(priv->sdio);
+ if (r != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "CsrSdioMaxBusClockFrequencySet() failed %d\n", r);
+ }
+
+ /* Card software reset */
+ CsrSdioClaim(priv->sdio);
+ r = unifi_card_hard_reset(priv->card);
+ CsrSdioRelease(priv->sdio);
+ if (r != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "unifi_card_hard_reset() failed %d\n", r);
+ }
+ } else {
+ unifi_info(priv, "Read chip version of 0x%04x\n", data_u16);
+ break;
+ }
+ }
+
+ if (r != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "Failed to prepare chip\n");
+ return -EIO;
+ }
+
+ /* Stop the XAPs for coredump. The PUTEST_STOP must be called, e.g. at
+ * Raw SDIO deinit, to resume them.
+ */
+ CsrSdioClaim(priv->sdio);
+ r = unifi_card_stop_processor(priv->card, UNIFI_PROC_BOTH);
+ CsrSdioRelease(priv->sdio);
+ if (r != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "Failed to stop processors\n");
+ }
+
+ return 0;
+}
+
+int unifi_putest_cmd52_block_read(unifi_priv_t *priv, unsigned char *arg)
+{
+ struct unifi_putest_block_cmd52_r block_cmd52;
+ CsrUint8 *arg_pos;
+ unsigned int cmd_param_size;
+ CsrResult r;
+ CsrUint8 *block_local_buffer;
+
+ arg_pos = (CsrUint8*)(((unifi_putest_command_t*)arg) + 1);
+ if (get_user(cmd_param_size, (int*)arg_pos)) {
+ unifi_error(priv,
+ "cmd52r_block: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ if (cmd_param_size != sizeof(struct unifi_putest_block_cmd52_r)) {
+ unifi_error(priv,
+ "cmd52r_block: cmd52 struct mismatch\n");
+ return -EINVAL;
+ }
+
+ arg_pos += sizeof(unsigned int);
+ if (copy_from_user(&block_cmd52,
+ (void*)arg_pos,
+ sizeof(struct unifi_putest_block_cmd52_r))) {
+ unifi_error(priv,
+ "cmd52r_block: Failed to get the cmd52 params\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG2, "cmd52r_block: func=%d addr=0x%x len=0x%x ",
+ block_cmd52.funcnum, block_cmd52.addr, block_cmd52.length);
+
+ block_local_buffer = vmalloc(block_cmd52.length);
+ if (block_local_buffer == NULL) {
+ unifi_error(priv, "cmd52r_block: Failed to allocate buffer\n");
+ return -ENOMEM;
+ }
+
+ CsrSdioClaim(priv->sdio);
+ r = unifi_card_readn(priv->card, block_cmd52.addr, block_local_buffer, block_cmd52.length);
+ CsrSdioRelease(priv->sdio);
+ if (r != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "cmd52r_block: unifi_readn failed\n");
+ return -EIO;
+ }
+
+ if (copy_to_user((void*)block_cmd52.data,
+ block_local_buffer,
+ block_cmd52.length)) {
+ unifi_error(priv,
+ "cmd52r_block: Failed to return the data\n");
+ return -EFAULT;
+ }
+
+ return 0;
+}
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * FILE: sdio_emb.c
+ *
+ * PURPOSE: Driver instantiation and deletion for SDIO on Linux.
+ *
+ * This file brings together the SDIO bus interface, the UniFi
+ * driver core and the Linux net_device stack.
+ *
+ * Copyright (C) 2007-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include <linux/kmod.h>
+#include <linux/init.h>
+#include <linux/suspend.h>
+#include "csr_wifi_hip_unifi.h"
+#include "unifi_priv.h"
+
+#include "sdioemb/sdio_api.h"
+
+/* The function driver context, i.e the UniFi Driver */
+static CsrSdioFunctionDriver *sdio_func_drv;
+
+#ifdef CONFIG_PM
+static int uf_sdio_emb_power_event(struct notifier_block *this, unsigned long event, void *ptr);
+#endif
+
+/* The Android wakelock is here for completeness. Typically the MMC driver is used
+ * instead of sdioemb, but sdioemb may be used for CSPI.
+ */
+#ifdef ANDROID_BUILD
+struct wake_lock unifi_sdio_wake_lock; /* wakelock to prevent suspend while resuming */
+#endif
+
+/* sdioemb driver uses POSIX error codes */
+static CsrResult
+ConvertSdioToCsrSdioResult(int r)
+{
+ CsrResult csrResult = CSR_RESULT_FAILURE;
+
+ switch (r) {
+ case 0:
+ csrResult = CSR_RESULT_SUCCESS;
+ break;
+ case -EIO:
+ csrResult = CSR_SDIO_RESULT_CRC_ERROR;
+ break;
+ /* Timeout errors */
+ case -ETIMEDOUT:
+ case -EBUSY:
+ csrResult = CSR_SDIO_RESULT_TIMEOUT;
+ break;
+ case -ENODEV:
+ case -ENOMEDIUM:
+ csrResult = CSR_SDIO_RESULT_NO_DEVICE;
+ break;
+ case -EINVAL:
+ csrResult = CSR_SDIO_RESULT_INVALID_VALUE;
+ break;
+ case -ENOMEM:
+ case -ENOSYS:
+ case -EILSEQ:
+ case -ERANGE:
+ case -ENXIO:
+ csrResult = CSR_RESULT_FAILURE;
+ break;
+ default:
+ unifi_warning(NULL, "Unrecognised SDIO error code: %d\n", r);
+ break;
+ }
+
+ return csrResult;
+}
+
+
+CsrResult
+CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int err;
+ err = sdioemb_read8(fdev, address, data);
+ if (err) {
+ return ConvertSdioToCsrSdioResult(err);
+ }
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioRead8() */
+
+CsrResult
+CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int err;
+ err = sdioemb_write8(fdev, address, data);
+ if (err) {
+ return ConvertSdioToCsrSdioResult(err);
+ }
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioWrite8() */
+
+CsrResult
+CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int r;
+
+ r = sdioemb_read16(fdev, address, data);
+ if (r) {
+ return ConvertSdioToCsrSdioResult(r);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioRead16() */
+
+CsrResult
+CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int r;
+
+ r = sdioemb_write16(fdev, address, data);
+ if (r) {
+ return ConvertSdioToCsrSdioResult(r);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioWrite16() */
+
+
+CsrResult
+CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int err;
+ err = sdioemb_f0_read8(fdev, address, data);
+ if (err) {
+ return ConvertSdioToCsrSdioResult(err);
+ }
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioF0Read8() */
+
+
+CsrResult
+CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int err;
+ err = sdioemb_f0_write8(fdev, address, data);
+ if (err) {
+ return ConvertSdioToCsrSdioResult(err);
+ }
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioF0Write8() */
+
+CsrResult
+CsrSdioRead(CsrSdioFunction *function, CsrUint32 address, void *data, CsrUint32 length)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int err;
+ err = sdioemb_read(fdev, address, data, length);
+ if (err) {
+ return ConvertSdioToCsrSdioResult(err);
+ }
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioRead() */
+
+CsrResult
+CsrSdioWrite(CsrSdioFunction *function, CsrUint32 address, const void *data, CsrUint32 length)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int err;
+ err = sdioemb_write(fdev, address, data, length);
+ if (err) {
+ return ConvertSdioToCsrSdioResult(err);
+ }
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioWrite() */
+
+
+CsrResult
+CsrSdioBlockSizeSet(CsrSdioFunction *function, CsrUint16 blockSize)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int r = 0;
+
+ /* Module parameter overrides */
+ if (sdio_block_size > -1) {
+ blockSize = sdio_block_size;
+ }
+
+ unifi_trace(NULL, UDBG1, "Set SDIO function block size to %d\n",
+ blockSize);
+
+ r = sdioemb_set_block_size(fdev, blockSize);
+ if (r) {
+ unifi_error(NULL, "Error %d setting block size\n", r);
+ }
+
+ /* Determine the achieved block size to report to the core */
+ function->blockSize = fdev->blocksize;
+
+ return ConvertSdioToCsrSdioResult(r);
+} /* CsrSdioBlockSizeSet() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioMaxBusClockFrequencySet
+ *
+ * Set the maximum SDIO bus clock speed to use.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ * maxFrequency maximum clock speed in Hz
+ *
+ * Returns:
+ * an error code.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioMaxBusClockFrequencySet(CsrSdioFunction *function, CsrUint32 maxFrequency)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ CsrUint32 max_khz = maxFrequency/1000;
+
+ if (!max_khz || max_khz > sdio_clock) {
+ max_khz = sdio_clock;
+ }
+ unifi_trace(NULL, UDBG1, "Setting SDIO bus clock to %d kHz\n", max_khz);
+ sdioemb_set_max_bus_freq(fdev, 1000 * max_khz);
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioMaxBusClockFrequencySet() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioInterruptEnable
+ * CsrSdioInterruptDisable
+ *
+ * Enable or disable the SDIO interrupt.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ *
+ * Returns:
+ * Zero on success or a UniFi driver error code.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioInterruptEnable(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int r;
+
+ r = sdioemb_interrupt_enable(fdev);
+ if (r) {
+ return ConvertSdioToCsrSdioResult(r);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioInterruptEnable() */
+
+CsrResult
+CsrSdioInterruptDisable(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int r;
+
+ r = sdioemb_interrupt_disable(fdev);
+ if (r) {
+ return ConvertSdioToCsrSdioResult(r);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioInterruptDisable() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioInterruptAcknowledge
+ *
+ * Acknowledge an SDIO interrupt.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ *
+ * Returns:
+ * Zero on success or a UniFi driver error code.
+ * ---------------------------------------------------------------------------
+ */
+void CsrSdioInterruptAcknowledge(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+
+ sdioemb_interrupt_acknowledge(fdev);
+} /* CsrSdioInterruptAcknowledge() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioFunctionEnable
+ *
+ * Enable i/o on this function.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ *
+ * Returns:
+ * UniFi driver error code.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioFunctionEnable(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int r;
+
+ /* Enable UniFi function (the 802.11 part). */
+ r = sdioemb_enable_function(fdev);
+ if (r) {
+ unifi_error(NULL, "Failed to enable SDIO function %d\n", fdev->function);
+ return ConvertSdioToCsrSdioResult(r);
+ }
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioFunctionEnable() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioFunctionDisable
+ *
+ * Disable i/o on this function.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ *
+ * Returns:
+ * UniFi driver error code.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioFunctionDisable(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int r;
+
+ /* Disable UniFi function (the 802.11 part). */
+ r = sdioemb_disable_function(fdev);
+ if (r) {
+ unifi_error(NULL, "Failed to disable SDIO function %d\n", fdev->function);
+ return ConvertSdioToCsrSdioResult(r);
+ }
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioFunctionDisable() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioFunctionActive
+ *
+ * No-op as the bus goes to an active state at the start of every
+ * command.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ * ---------------------------------------------------------------------------
+ */
+void
+CsrSdioFunctionActive(CsrSdioFunction *function)
+{
+} /* CsrSdioFunctionActive() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioFunctionIdle
+ *
+ * Set the function as idle.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ * ---------------------------------------------------------------------------
+ */
+void
+CsrSdioFunctionIdle(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+
+ sdioemb_idle_function(fdev);
+} /* CsrSdioFunctionIdle() */
+
+
+CsrResult
+CsrSdioPowerOn(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+
+ if (disable_power_control != 1) {
+ sdioemb_power_on(fdev);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioPowerOn() */
+
+void
+CsrSdioPowerOff(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ if (disable_power_control != 1) {
+ sdioemb_power_off(fdev);
+ }
+} /* CsrSdioPowerOff() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioHardReset
+ *
+ * Hard Resets UniFi is possible.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ *
+ * Returns:
+ * 1 if the SDIO driver is not capable of doing a hard reset.
+ * 0 if a hard reset was successfully performed.
+ * -CSR_EIO if an I/O error occured while re-initializing the card.
+ * This is a fatal, non-recoverable error.
+ * -CSR_ENODEV if the card is no longer present.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioHardReset(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+ int r;
+
+ /* Hard reset can be disabled by a module parameter */
+ r = 1;
+ if (disable_hw_reset != 1) {
+ r = sdioemb_hard_reset(fdev); /* may return 1 if can't reset */
+ if (r < 0) {
+ return ConvertSdioToCsrSdioResult(r); /* fatal error */
+ }
+ }
+
+ /* Set the SDIO bus width after a hard reset */
+ if (buswidth == 1) {
+ unifi_info(NULL, "Setting SDIO bus width to 1\n");
+ sdioemb_set_bus_width(fdev, buswidth);
+ } else if (buswidth == 4) {
+ unifi_info(NULL, "Setting SDIO bus width to 4\n");
+ sdioemb_set_bus_width(fdev, buswidth);
+ }
+
+ if(r == 1)
+ {
+ return CSR_SDIO_RESULT_NOT_RESET;
+ }
+
+ return ConvertSdioToCsrSdioResult(r);
+
+} /* CsrSdioHardReset() */
+
+
+int csr_sdio_linux_remove_irq(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+
+ return sdioemb_interrupt_disable(fdev);
+}
+
+int csr_sdio_linux_install_irq(CsrSdioFunction *function)
+{
+ struct sdioemb_dev *fdev = (struct sdioemb_dev *)function->priv;
+
+ return sdioemb_interrupt_enable(fdev);
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_glue_sdio_int_handler
+ * Card interrupt callback.
+ *
+ * Arguments:
+ * fdev SDIO context pointer
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void
+uf_glue_sdio_int_handler(struct sdioemb_dev *fdev)
+{
+ CsrSdioFunction *sdio_ctx = fdev->drv_data;
+ CsrSdioInterruptDsrCallback func_dsr_callback;
+
+ /* If the function driver has registered a handler, call it */
+ if (sdio_func_drv && sdio_func_drv->intr) {
+ /* The function driver may return a DSR. */
+ func_dsr_callback = sdio_func_drv->intr(sdio_ctx);
+ /* If it did return a DSR handle, call it */
+ if (func_dsr_callback) {
+ func_dsr_callback(sdio_ctx);
+ }
+ }
+}
+
+#ifdef CONFIG_PM
+
+/*
+ * Power Management notifier
+ */
+struct uf_sdio_emb_pm_notifier
+{
+ struct list_head list;
+
+ CsrSdioFunction *sdio_ctx;
+ struct notifier_block pm_notifier;
+};
+
+/* PM notifier list head */
+static struct uf_sdio_emb_pm_notifier uf_sdio_emb_pm_notifiers = {
+ .sdio_ctx = NULL,
+};
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_sdio_emb_register_pm_notifier
+ * uf_sdio_emb_unregister_pm_notifier
+ *
+ * Register/unregister for power management events. A list is used to
+ * allow multiple card instances to be supported.
+ *
+ * Arguments:
+ * sdio_ctx - CSR SDIO context to associate PM notifier to
+ *
+ * Returns:
+ * Register function returns NULL on error
+ * ---------------------------------------------------------------------------
+ */
+static struct uf_sdio_emb_pm_notifier *
+uf_sdio_emb_register_pm_notifier(CsrSdioFunction *sdio_ctx)
+{
+ /* Allocate notifier context for this card instance */
+ struct uf_sdio_emb_pm_notifier *notifier_ctx = kmalloc(sizeof(struct uf_sdio_emb_pm_notifier), GFP_KERNEL);
+
+ if (notifier_ctx)
+ {
+ notifier_ctx->sdio_ctx = sdio_ctx;
+ notifier_ctx->pm_notifier.notifier_call = uf_sdio_emb_power_event;
+
+ list_add(¬ifier_ctx->list, &uf_sdio_emb_pm_notifiers.list);
+
+ if (register_pm_notifier(¬ifier_ctx->pm_notifier)) {
+ printk(KERN_ERR "unifi: register_pm_notifier failed\n");
+ }
+ }
+
+ return notifier_ctx;
+}
+
+static void
+uf_sdio_emb_unregister_pm_notifier(CsrSdioFunction *sdio_ctx)
+{
+ struct uf_sdio_emb_pm_notifier *notifier_ctx;
+ struct list_head *node, *q;
+
+ list_for_each_safe(node, q, &uf_sdio_emb_pm_notifiers.list) {
+ notifier_ctx = list_entry(node, struct uf_sdio_emb_pm_notifier, list);
+
+ /* If it matches, unregister and free the notifier context */
+ if (notifier_ctx && notifier_ctx->sdio_ctx == sdio_ctx)
+ {
+ if (unregister_pm_notifier(¬ifier_ctx->pm_notifier)) {
+ printk(KERN_ERR "unifi: unregister_pm_notifier failed\n");
+ }
+
+ /* Remove from list */
+ notifier_ctx->sdio_ctx = NULL;
+ list_del(node);
+ kfree(notifier_ctx);
+ }
+ }
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_sdio_emb_power_event
+ *
+ * Handler for power management events.
+ *
+ * We need to handle suspend/resume events while the userspace is unsuspended
+ * to allow the SME to run its suspend/resume state machines.
+ *
+ * Arguments:
+ * event event ID
+ *
+ * Returns:
+ * Status of the event handling
+ * ---------------------------------------------------------------------------
+ */
+static int
+uf_sdio_emb_power_event(struct notifier_block *this, unsigned long event, void *ptr)
+{
+ struct uf_sdio_emb_pm_notifier *notifier_ctx = container_of(this,
+ struct uf_sdio_emb_pm_notifier,
+ pm_notifier);
+
+ /* Call the CSR SDIO function driver's suspend/resume method
+ * while the userspace is unsuspended.
+ */
+ switch (event) {
+ case PM_POST_HIBERNATION:
+ case PM_POST_SUSPEND:
+ printk(KERN_INFO "%s:%d resume\n", __FUNCTION__, __LINE__ );
+ if (sdio_func_drv && sdio_func_drv->resume) {
+ sdio_func_drv->resume(notifier_ctx->sdio_ctx);
+ }
+ break;
+
+ case PM_HIBERNATION_PREPARE:
+ case PM_SUSPEND_PREPARE:
+ printk(KERN_INFO "%s:%d suspend\n", __FUNCTION__, __LINE__ );
+ if (sdio_func_drv && sdio_func_drv->suspend) {
+ sdio_func_drv->suspend(notifier_ctx->sdio_ctx);
+ }
+ break;
+ }
+ return NOTIFY_DONE;
+}
+
+#endif /* CONFIG_PM */
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_glue_sdio_probe
+ *
+ * Card insert callback.
+ *
+ * Arguments:
+ * fdev SDIO context pointer
+ *
+ * Returns:
+ * UniFi driver error code.
+ * ---------------------------------------------------------------------------
+ */
+static int
+uf_glue_sdio_probe(struct sdioemb_dev *fdev)
+{
+ CsrSdioFunction *sdio_ctx;
+
+ unifi_info(NULL, "UniFi card inserted\n");
+
+ /* Allocate context and private in one lump */
+ sdio_ctx = (CsrSdioFunction *)kmalloc(sizeof(CsrSdioFunction),
+ GFP_KERNEL);
+ if (sdio_ctx == NULL) {
+ return -ENOMEM;
+ }
+
+
+ sdio_ctx->sdioId.manfId = fdev->vendor_id;
+ sdio_ctx->sdioId.cardId = fdev->device_id;
+ sdio_ctx->sdioId.sdioFunction = fdev->function;
+ sdio_ctx->sdioId.sdioInterface = 0;
+ sdio_ctx->blockSize = fdev->blocksize;
+ sdio_ctx->priv = (void *)fdev;
+ sdio_ctx->features = 0;
+
+ /* Module parameter enables byte mode */
+ if (sdio_byte_mode) {
+ sdio_ctx->features |= CSR_SDIO_FEATURE_BYTE_MODE;
+ }
+
+ /* Set up pointer to func_priv in middle of lump */
+ fdev->drv_data = sdio_ctx;
+
+ /* Always override default SDIO bus clock */
+ unifi_trace(NULL, UDBG1, "Setting SDIO bus clock to %d kHz\n", sdio_clock);
+ sdioemb_set_max_bus_freq(fdev, 1000 * sdio_clock);
+
+#ifdef CONFIG_PM
+ /* Register to get PM events */
+ if (uf_sdio_emb_register_pm_notifier(sdio_ctx) == NULL) {
+ unifi_error(NULL, "%s: Failed to register for PM events\n", __FUNCTION__);
+ }
+#endif
+
+ /* Call the main UniFi driver inserted handler */
+ if (sdio_func_drv && sdio_func_drv->inserted) {
+ uf_add_os_device(fdev->slot_id, fdev->os_device);
+ sdio_func_drv->inserted(sdio_ctx);
+ }
+
+#ifdef ANDROID_BUILD
+ /* Take the wakelock */
+ unifi_trace(NULL, UDBG1, "emb probe: take wake lock\n");
+ wake_lock(&unifi_sdio_wake_lock);
+#endif
+
+ return 0;
+} /* uf_glue_sdio_probe() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_sdio_remove
+ *
+ * Card removal callback.
+ *
+ * Arguments:
+ * fdev SDIO device
+ *
+ * Returns:
+ * UniFi driver error code.
+ * ---------------------------------------------------------------------------
+ */
+static void
+uf_sdio_remove(struct sdioemb_dev *fdev)
+{
+ CsrSdioFunction *sdio_ctx = fdev->drv_data;
+
+ unifi_info(NULL, "UniFi card removed\n");
+
+ /* Clean up the SDIO function driver */
+ if (sdio_func_drv && sdio_func_drv->removed) {
+ sdio_func_drv->removed(sdio_ctx);
+ }
+
+#ifdef CONFIG_PM
+ /* Unregister for PM events */
+ uf_sdio_emb_unregister_pm_notifier(sdio_ctx);
+#endif
+
+ kfree(sdio_ctx);
+
+} /* uf_sdio_remove */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_glue_sdio_suspend
+ *
+ * System suspend callback.
+ *
+ * Arguments:
+ * fdev SDIO device
+ *
+ * Returns:
+ *
+ * ---------------------------------------------------------------------------
+ */
+static void
+uf_glue_sdio_suspend(struct sdioemb_dev *fdev)
+{
+ unifi_info(NULL, "Suspending...\n");
+
+} /* uf_glue_sdio_suspend() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_glue_sdio_resume
+ *
+ * System resume callback.
+ *
+ * Arguments:
+ * fdev SDIO device
+ *
+ * Returns:
+ *
+ * ---------------------------------------------------------------------------
+ */
+static void
+uf_glue_sdio_resume(struct sdioemb_dev *fdev)
+{
+ unifi_info(NULL, "Resuming...\n");
+
+#ifdef ANDROID_BUILD
+ unifi_trace(NULL, UDBG1, "emb resume: take wakelock\n");
+ wake_lock(&unifi_sdio_wake_lock);
+#endif
+
+} /* uf_glue_sdio_resume() */
+
+
+
+
+static struct sdioemb_func_driver unifi_sdioemb = {
+ .name = "unifi",
+ .id_table = NULL, /* Filled in when main driver registers */
+
+ .probe = uf_glue_sdio_probe,
+ .remove = uf_sdio_remove,
+ .card_int_handler = uf_glue_sdio_int_handler,
+ .suspend = uf_glue_sdio_suspend,
+ .resume = uf_glue_sdio_resume,
+};
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioFunctionDriverRegister
+ * CsrSdioFunctionDriverUnregister
+ *
+ * These functions are called from the main module load and unload
+ * functions. They perform the appropriate operations for the
+ * SDIOemb driver.
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioFunctionDriverRegister(CsrSdioFunctionDriver *sdio_drv)
+{
+ int r;
+ int i;
+
+ printk("Unifi: Using CSR embedded SDIO driver\n");
+
+ if (sdio_func_drv) {
+ unifi_error(NULL, "sdio_emb: UniFi driver already registered\n");
+ return CSR_SDIO_RESULT_INVALID_VALUE;
+ }
+
+ /* Build ID table to pass to sdioemb */
+ unifi_sdioemb.id_table = CsrPmemAlloc(sizeof(struct sdioemb_id_table) * (sdio_drv->idsCount + 1));
+ if (unifi_sdioemb.id_table == NULL) {
+ unifi_error(NULL, "sdio_emb: Failed to allocate memory for ID table (%d IDs)\n", sdio_drv->idsCount);
+ return CSR_RESULT_FAILURE;
+ }
+ for (i = 0; i < sdio_drv->idsCount; i++) {
+ unifi_sdioemb.id_table[i].vendor_id = sdio_drv->ids[i].manfId;
+ unifi_sdioemb.id_table[i].device_id = sdio_drv->ids[i].cardId;
+ unifi_sdioemb.id_table[i].function = sdio_drv->ids[i].sdioFunction;
+ unifi_sdioemb.id_table[i].interface = sdio_drv->ids[i].sdioInterface;
+ }
+ unifi_sdioemb.id_table[i].vendor_id = 0;
+ unifi_sdioemb.id_table[i].device_id = 0;
+ unifi_sdioemb.id_table[i].function = 0;
+ unifi_sdioemb.id_table[i].interface = 0;
+
+ /* Save the registered driver description */
+ sdio_func_drv = sdio_drv;
+
+#ifdef CONFIG_PM
+ /* Initialise PM notifier list */
+ INIT_LIST_HEAD(&uf_sdio_emb_pm_notifiers.list);
+#endif
+
+#ifdef ANDROID_BUILD
+ wake_lock_init(&unifi_sdio_wake_lock, WAKE_LOCK_SUSPEND, "unifi_sdio_work");
+#endif
+
+ /* Register ourself with sdioemb */
+ r = sdioemb_driver_register(&unifi_sdioemb);
+ if (r) {
+ unifi_error(NULL, "Failed to register UniFi SDIO driver: %d\n", r);
+ return ConvertSdioToCsrSdioResult(r);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioFunctionDriverRegister() */
+
+
+void
+CsrSdioFunctionDriverUnregister(CsrSdioFunctionDriver *sdio_drv)
+{
+ sdioemb_driver_unregister(&unifi_sdioemb);
+
+#ifdef ANDROID_BUILD
+ wake_lock_destroy(&unifi_sdio_wake_lock);
+#endif
+
+ sdio_func_drv = NULL;
+
+ CsrPmemFree(unifi_sdioemb.id_table);
+ unifi_sdioemb.id_table = NULL;
+} /* CsrSdioFunctionDriverUnregister() */
+
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: sdio_events.c
+ *
+ * PURPOSE:
+ * Process the events received by the SDIO glue layer.
+ * Optional part of the porting exercise.
+ *
+ * Copyright (C) 2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include "unifi_priv.h"
+
+
+/*
+ * Porting Notes:
+ * There are two ways to support the suspend/resume system events in a driver.
+ * In some operating systems these events are delivered to the OS driver
+ * directly from the system. In this case, the OS driver needs to pass these
+ * events to the API described in the CSR SDIO Abstration API document.
+ * In Linux, and other embedded operating systems, the suspend/resume events
+ * come from the SDIO driver. In this case, simply get these events in the
+ * SDIO glue layer and notify the OS layer.
+ *
+ * In either case, typically, the events are processed by the SME.
+ * Use the unifi_sys_suspend_ind() and unifi_sys_resume_ind() to pass
+ * the events to the SME.
+ */
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_suspend
+ *
+ * Handles a suspend request from the SDIO driver.
+ *
+ * Arguments:
+ * ospriv Pointer to OS driver context.
+ *
+ * ---------------------------------------------------------------------------
+ */
+void unifi_suspend(void *ospriv)
+{
+ unifi_priv_t *priv = ospriv;
+ int interfaceTag=0;
+
+ /* For powered suspend, tell the resume's wifi_on() not to reinit UniFi */
+ priv->wol_suspend = (enable_wol == UNIFI_WOL_OFF) ? FALSE : TRUE;
+
+ unifi_trace(priv, UDBG1, "unifi_suspend: wol_suspend %d, enable_wol %d",
+ priv->wol_suspend, enable_wol );
+
+ /* Stop network traffic. */
+ /* need to stop all the netdevices*/
+ for( interfaceTag=0;interfaceTag<CSR_WIFI_NUM_INTERFACES;interfaceTag++)
+ {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ if (interfacePriv->netdev_registered == 1)
+ {
+ if( priv->wol_suspend ) {
+ unifi_trace(priv, UDBG1, "unifi_suspend: Don't netif_carrier_off");
+ } else {
+ unifi_trace(priv, UDBG1, "unifi_suspend: netif_carrier_off");
+ netif_carrier_off(priv->netdev[interfaceTag]);
+ }
+ UF_NETIF_TX_STOP_ALL_QUEUES(priv->netdev[interfaceTag]);
+ }
+ }
+
+ unifi_trace(priv, UDBG1, "unifi_suspend: suspend SME");
+
+ sme_sys_suspend(priv);
+
+} /* unifi_suspend() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_resume
+ *
+ * Handles a resume request from the SDIO driver.
+ *
+ * Arguments:
+ * ospriv Pointer to OS driver context.
+ *
+ * ---------------------------------------------------------------------------
+ */
+void unifi_resume(void *ospriv)
+{
+ unifi_priv_t *priv = ospriv;
+ int interfaceTag=0;
+ int r;
+ int wol = priv->wol_suspend;
+
+ unifi_trace(priv, UDBG1, "unifi_resume: resume SME, enable_wol=%d", enable_wol);
+
+ /* The resume causes wifi-on which will re-enable the BH and reinstall the ISR */
+ r = sme_sys_resume(priv);
+ if (r) {
+ unifi_error(priv, "Failed to resume UniFi\n");
+ }
+
+ /* Resume the network interfaces. For the cold resume case, this will
+ * happen upon reconnection.
+ */
+ if (wol) {
+ unifi_trace(priv, UDBG1, "unifi_resume: try to enable carrier");
+
+ /* need to start all the netdevices*/
+ for( interfaceTag=0;interfaceTag<CSR_WIFI_NUM_INTERFACES;interfaceTag++) {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ unifi_trace(priv, UDBG1, "unifi_resume: interfaceTag %d netdev_registered %d mode %d\n",
+ interfaceTag, interfacePriv->netdev_registered, interfacePriv->interfaceMode);
+
+ if (interfacePriv->netdev_registered == 1)
+ {
+ netif_carrier_on(priv->netdev[interfaceTag]);
+ UF_NETIF_TX_START_ALL_QUEUES(priv->netdev[interfaceTag]);
+ }
+ }
+
+ /* Kick the BH thread (with reason=host) to poll for data that may have
+ * arrived during a powered suspend. This caters for the case where the SME
+ * doesn't interact with the chip (e.g install autonomous scans) during resume.
+ */
+ unifi_send_signal(priv->card, NULL, 0, NULL);
+ }
+
+} /* unifi_resume() */
+
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * FILE: sdio_mmc.c
+ *
+ * PURPOSE: SDIO driver interface for generic MMC stack.
+ *
+ * Copyright (C) 2008-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/mutex.h>
+#include <linux/gfp.h>
+
+#include <linux/mmc/core.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/sdio_func.h>
+#include <linux/mmc/sdio_ids.h>
+#include <linux/mmc/sdio.h>
+#include <linux/suspend.h>
+
+#include "unifi_priv.h"
+
+#ifdef ANDROID_BUILD
+struct wake_lock unifi_sdio_wake_lock; /* wakelock to prevent suspend while resuming */
+#endif
+
+static CsrSdioFunctionDriver *sdio_func_drv;
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+#ifdef CONFIG_PM
+static int uf_sdio_mmc_power_event(struct notifier_block *this, unsigned long event, void *ptr);
+#endif
+
+/*
+ * We need to keep track of the power on/off because we can not call
+ * mmc_power_restore_host() when the card is already powered.
+ * Even then, we need to patch the MMC driver to add a power_restore handler
+ * in the mmc_sdio_ops structure. If the MMC driver before 2.6.37 is not patched,
+ * mmc_power_save_host() and mmc_power_restore_host() are no-ops in the kernel,
+ * returning immediately (at least on x86).
+ */
+static int card_is_powered = 1;
+#endif /* 2.6.32 */
+
+/* MMC uses ENOMEDIUM to indicate card gone away */
+
+static CsrResult
+ConvertSdioToCsrSdioResult(int r)
+{
+ CsrResult csrResult = CSR_RESULT_FAILURE;
+
+ switch (r) {
+ case 0:
+ csrResult = CSR_RESULT_SUCCESS;
+ break;
+ case -EIO:
+ case -EILSEQ:
+ csrResult = CSR_SDIO_RESULT_CRC_ERROR;
+ break;
+ /* Timeout errors */
+ case -ETIMEDOUT:
+ case -EBUSY:
+ csrResult = CSR_SDIO_RESULT_TIMEOUT;
+ break;
+ case -ENODEV:
+ case -ENOMEDIUM:
+ csrResult = CSR_SDIO_RESULT_NO_DEVICE;
+ break;
+ case -EINVAL:
+ csrResult = CSR_SDIO_RESULT_INVALID_VALUE;
+ break;
+ case -ENOMEM:
+ case -ENOSYS:
+ case -ERANGE:
+ case -ENXIO:
+ csrResult = CSR_RESULT_FAILURE;
+ break;
+ default:
+ unifi_warning(NULL, "Unrecognised SDIO error code: %d\n", r);
+ break;
+ }
+
+ return csrResult;
+}
+
+
+static int
+csr_io_rw_direct(struct mmc_card *card, int write, uint8_t fn,
+ uint32_t addr, uint8_t in, uint8_t* out)
+{
+ struct mmc_command cmd;
+ int err;
+
+ BUG_ON(!card);
+ BUG_ON(fn > 7);
+
+ memset(&cmd, 0, sizeof(struct mmc_command));
+
+ cmd.opcode = SD_IO_RW_DIRECT;
+ cmd.arg = write ? 0x80000000 : 0x00000000;
+ cmd.arg |= fn << 28;
+ cmd.arg |= (write && out) ? 0x08000000 : 0x00000000;
+ cmd.arg |= addr << 9;
+ cmd.arg |= in;
+ cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_AC;
+
+ err = mmc_wait_for_cmd(card->host, &cmd, 0);
+ if (err)
+ return err;
+
+ /* this function is not exported, so we will need to sort it out here
+ * for now, lets hard code it to sdio */
+ if (0) {
+ /* old arg (mmc_host_is_spi(card->host)) { */
+ /* host driver already reported errors */
+ } else {
+ if (cmd.resp[0] & R5_ERROR) {
+ printk(KERN_ERR "%s: r5 error 0x%02x\n",
+ __FUNCTION__, cmd.resp[0]);
+ return -EIO;
+ }
+ if (cmd.resp[0] & R5_FUNCTION_NUMBER)
+ return -EINVAL;
+ if (cmd.resp[0] & R5_OUT_OF_RANGE)
+ return -ERANGE;
+ }
+
+ if (out) {
+ if (0) { /* old argument (mmc_host_is_spi(card->host)) */
+ *out = (cmd.resp[0] >> 8) & 0xFF;
+ }
+ else {
+ *out = cmd.resp[0] & 0xFF;
+ }
+ }
+
+ return CSR_RESULT_SUCCESS;
+}
+
+
+CsrResult
+CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err = 0;
+
+ _sdio_claim_host(func);
+ *data = sdio_readb(func, address, &err);
+ _sdio_release_host(func);
+
+ if (err) {
+ func_exit_r(err);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioRead8() */
+
+CsrResult
+CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err = 0;
+
+ _sdio_claim_host(func);
+ sdio_writeb(func, data, address, &err);
+ _sdio_release_host(func);
+
+ if (err) {
+ func_exit_r(err);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioWrite8() */
+
+CsrResult
+CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err;
+ uint8_t b0, b1;
+
+ _sdio_claim_host(func);
+ b0 = sdio_readb(func, address, &err);
+ if (err) {
+ _sdio_release_host(func);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+
+ b1 = sdio_readb(func, address+1, &err);
+ if (err) {
+ _sdio_release_host(func);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+ _sdio_release_host(func);
+
+ *data = ((uint16_t)b1 << 8) | b0;
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioRead16() */
+
+
+CsrResult
+CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err;
+ uint8_t b0, b1;
+
+ _sdio_claim_host(func);
+ b1 = (data >> 8) & 0xFF;
+ sdio_writeb(func, b1, address+1, &err);
+ if (err) {
+ _sdio_release_host(func);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+
+ b0 = data & 0xFF;
+ sdio_writeb(func, b0, address, &err);
+ if (err) {
+ _sdio_release_host(func);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+
+ _sdio_release_host(func);
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioWrite16() */
+
+
+CsrResult
+CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err = 0;
+
+ _sdio_claim_host(func);
+#ifdef MMC_QUIRK_LENIENT_FN0
+ *data = sdio_f0_readb(func, address, &err);
+#else
+ err = csr_io_rw_direct(func->card, 0, 0, address, 0, data);
+#endif
+ _sdio_release_host(func);
+
+ if (err) {
+ func_exit_r(err);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioF0Read8() */
+
+CsrResult
+CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err = 0;
+
+ _sdio_claim_host(func);
+#ifdef MMC_QUIRK_LENIENT_FN0
+ sdio_f0_writeb(func, data, address, &err);
+#else
+ err = csr_io_rw_direct(func->card, 1, 0, address, data, NULL);
+#endif
+ _sdio_release_host(func);
+
+ if (err) {
+ func_exit_r(err);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioF0Write8() */
+
+
+CsrResult
+CsrSdioRead(CsrSdioFunction *function, CsrUint32 address, void *data, CsrUint32 length)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err;
+
+ _sdio_claim_host(func);
+ err = sdio_readsb(func, data, address, length);
+ _sdio_release_host(func);
+
+ if (err) {
+ func_exit_r(err);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioRead() */
+
+CsrResult
+CsrSdioWrite(CsrSdioFunction *function, CsrUint32 address, const void *data, CsrUint32 length)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err;
+
+ _sdio_claim_host(func);
+ err = sdio_writesb(func, address, (void*)data, length);
+ _sdio_release_host(func);
+
+ if (err) {
+ func_exit_r(err);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioWrite() */
+
+
+static int
+csr_sdio_enable_hs(struct mmc_card *card)
+{
+ int ret;
+ u8 speed;
+
+ if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED)) {
+ /* We've asked for HS clock rates, but controller doesn't
+ * claim to support it. We should limit the clock
+ * to 25MHz via module parameter.
+ */
+ printk(KERN_INFO "unifi: request HS but not MMC_CAP_SD_HIGHSPEED");
+ return 0;
+ }
+
+ if (!card->cccr.high_speed)
+ return 0;
+
+#if 1
+ ret = csr_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
+ if (ret)
+ return ret;
+
+ speed |= SDIO_SPEED_EHS;
+#else
+ /* Optimisation: Eliminate read by always assuming SHS and that reserved bits can be zero */
+ speed = SDIO_SPEED_EHS | SDIO_SPEED_SHS;
+#endif
+
+ ret = csr_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
+ if (ret)
+ return ret;
+
+ mmc_card_set_highspeed(card);
+ card->host->ios.timing = MMC_TIMING_SD_HS;
+ card->host->ops->set_ios(card->host, &card->host->ios);
+
+ return 0;
+}
+
+static int
+csr_sdio_disable_hs(struct mmc_card *card)
+{
+ int ret;
+ u8 speed;
+
+ if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
+ return 0;
+
+ if (!card->cccr.high_speed)
+ return 0;
+#if 1
+ ret = csr_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
+ if (ret)
+ return ret;
+
+ speed &= ~SDIO_SPEED_EHS;
+#else
+ /* Optimisation: Eliminate read by always assuming SHS and that reserved bits can be zero */
+ speed = SDIO_SPEED_SHS; /* clear SDIO_SPEED_EHS */
+#endif
+
+ ret = csr_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
+ if (ret)
+ return ret;
+
+ card->state &= ~MMC_STATE_HIGHSPEED;
+ card->host->ios.timing = MMC_TIMING_LEGACY;
+ card->host->ops->set_ios(card->host, &card->host->ios);
+
+ return 0;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioMaxBusClockFrequencySet
+ *
+ * Set the maximum SDIO bus clock speed to use.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ * maxFrequency maximum clock speed in Hz
+ *
+ * Returns:
+ * an error code.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioMaxBusClockFrequencySet(CsrSdioFunction *function, CsrUint32 maxFrequency)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ struct mmc_host *host = func->card->host;
+ struct mmc_ios *ios = &host->ios;
+ unsigned int max_hz;
+ int err;
+ CsrUint32 max_khz = maxFrequency/1000;
+
+ if (!max_khz || max_khz > sdio_clock) {
+ max_khz = sdio_clock;
+ }
+
+ _sdio_claim_host(func);
+ max_hz = 1000 * max_khz;
+ if (max_hz > host->f_max) {
+ max_hz = host->f_max;
+ }
+
+ if (max_hz > 25000000) {
+ err = csr_sdio_enable_hs(func->card);
+ } else {
+ err = csr_sdio_disable_hs(func->card);
+ }
+ if (err) {
+ printk(KERN_ERR "SDIO warning: Failed to configure SDIO clock mode\n");
+ _sdio_release_host(func);
+ return CSR_RESULT_SUCCESS;
+ }
+
+ ios->clock = max_hz;
+ host->ops->set_ios(host, ios);
+
+ _sdio_release_host(func);
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioMaxBusClockFrequencySet() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioInterruptEnable
+ * CsrSdioInterruptDisable
+ *
+ * Enable or disable the SDIO interrupt.
+ * The driver disables the SDIO interrupt until the i/o thread can
+ * process it.
+ * The SDIO interrupt can be disabled by modifying the SDIO_INT_ENABLE
+ * register in the Card Common Control Register block, but this requires
+ * two CMD52 operations. A better solution is to mask the interrupt at
+ * the host controller.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ *
+ * Returns:
+ * Zero on success or a UniFi driver error code.
+ *
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioInterruptEnable(CsrSdioFunction *function)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err = 0;
+
+#ifdef CSR_CONFIG_MMC_INT_BYPASS_KSOFTIRQD
+ sdio_unblock_card_irq(func);
+#else
+ _sdio_claim_host(func);
+ /* Write the Int Enable in CCCR block */
+#ifdef MMC_QUIRK_LENIENT_FN0
+ sdio_f0_writeb(func, 0x3, SDIO_CCCR_IENx, &err);
+#else
+ err = csr_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, 0x03, NULL);
+#endif
+ _sdio_release_host(func);
+
+ func_exit();
+ if (err) {
+ printk(KERN_ERR "unifi: %s: error %d writing IENx\n", __FUNCTION__, err);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+#endif
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioInterruptEnable() */
+
+CsrResult
+CsrSdioInterruptDisable(CsrSdioFunction *function)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err = 0;
+
+#ifdef CSR_CONFIG_MMC_INT_BYPASS_KSOFTIRQD
+ sdio_block_card_irq(func);
+#else
+ _sdio_claim_host(func);
+ /* Write the Int Enable in CCCR block */
+#ifdef MMC_QUIRK_LENIENT_FN0
+ sdio_f0_writeb(func, 0, SDIO_CCCR_IENx, &err);
+#else
+ err = csr_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, 0x00, NULL);
+#endif
+ _sdio_release_host(func);
+
+ func_exit();
+ if (err) {
+ printk(KERN_ERR "unifi: %s: error %d writing IENx\n", __FUNCTION__, err);
+ return ConvertSdioToCsrSdioResult(err);
+ }
+#endif
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioInterruptDisable() */
+
+
+void CsrSdioInterruptAcknowledge(CsrSdioFunction *function)
+{
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioFunctionEnable
+ *
+ * Enable i/o on function 1.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ *
+ * Returns:
+ * UniFi driver error code.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioFunctionEnable(CsrSdioFunction *function)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err;
+
+ func_enter();
+
+ /* Enable UniFi function 1 (the 802.11 part). */
+ _sdio_claim_host(func);
+ err = sdio_enable_func(func);
+ _sdio_release_host(func);
+ if (err) {
+ unifi_error(NULL, "Failed to enable SDIO function %d\n", func->num);
+ }
+
+ func_exit();
+ return ConvertSdioToCsrSdioResult(err);
+} /* CsrSdioFunctionEnable() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioFunctionDisable
+ *
+ * Enable i/o on function 1.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ *
+ * Returns:
+ * UniFi driver error code.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioFunctionDisable(CsrSdioFunction *function)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int err;
+
+ func_enter();
+
+ /* Disable UniFi function 1 (the 802.11 part). */
+ _sdio_claim_host(func);
+ err = sdio_disable_func(func);
+ _sdio_release_host(func);
+ if (err) {
+ unifi_error(NULL, "Failed to disable SDIO function %d\n", func->num);
+ }
+
+ func_exit();
+ return ConvertSdioToCsrSdioResult(err);
+} /* CsrSdioFunctionDisable() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioFunctionActive
+ *
+ * No-op as the bus goes to an active state at the start of every
+ * command.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ * ---------------------------------------------------------------------------
+ */
+void
+CsrSdioFunctionActive(CsrSdioFunction *function)
+{
+} /* CsrSdioFunctionActive() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioFunctionIdle
+ *
+ * Set the function as idle.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ * ---------------------------------------------------------------------------
+ */
+void
+CsrSdioFunctionIdle(CsrSdioFunction *function)
+{
+} /* CsrSdioFunctionIdle() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioPowerOn
+ *
+ * Power on UniFi.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioPowerOn(CsrSdioFunction *function)
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ struct mmc_host *host = func->card->host;
+
+ _sdio_claim_host(func);
+ if (!card_is_powered) {
+ mmc_power_restore_host(host);
+ card_is_powered = 1;
+ } else {
+ printk(KERN_INFO "SDIO: Skip power on; card is already powered.\n");
+ }
+ _sdio_release_host(func);
+#endif /* 2.6.32 */
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioPowerOn() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioPowerOff
+ *
+ * Power off UniFi.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ * ---------------------------------------------------------------------------
+ */
+void
+CsrSdioPowerOff(CsrSdioFunction *function)
+{
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ struct mmc_host *host = func->card->host;
+
+ _sdio_claim_host(func);
+ if (card_is_powered) {
+ mmc_power_save_host(host);
+ card_is_powered = 0;
+ } else {
+ printk(KERN_INFO "SDIO: Skip power off; card is already powered off.\n");
+ }
+ _sdio_release_host(func);
+#endif /* 2.6.32 */
+} /* CsrSdioPowerOff() */
+
+
+static int
+sdio_set_block_size_ignore_first_error(struct sdio_func *func, unsigned blksz)
+{
+ int ret;
+
+ if (blksz > func->card->host->max_blk_size)
+ return -EINVAL;
+
+ if (blksz == 0) {
+ blksz = min(func->max_blksize, func->card->host->max_blk_size);
+ blksz = min(blksz, 512u);
+ }
+
+ /*
+ * Ignore -ERANGE (OUT_OF_RANGE in R5) on the first byte as
+ * the block size may be invalid until both bytes are written.
+ */
+ ret = csr_io_rw_direct(func->card, 1, 0,
+ SDIO_FBR_BASE(func->num) + SDIO_FBR_BLKSIZE,
+ blksz & 0xff, NULL);
+ if (ret && ret != -ERANGE)
+ return ret;
+ ret = csr_io_rw_direct(func->card, 1, 0,
+ SDIO_FBR_BASE(func->num) + SDIO_FBR_BLKSIZE + 1,
+ (blksz >> 8) & 0xff, NULL);
+ if (ret)
+ return ret;
+ func->cur_blksize = blksz;
+
+ return 0;
+}
+
+CsrResult
+CsrSdioBlockSizeSet(CsrSdioFunction *function, CsrUint16 blockSize)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int r = 0;
+
+ /* Module parameter overrides */
+ if (sdio_block_size > -1) {
+ blockSize = sdio_block_size;
+ }
+
+ unifi_trace(NULL, UDBG1, "Set SDIO function block size to %d\n",
+ blockSize);
+
+ _sdio_claim_host(func);
+ r = sdio_set_block_size(func, blockSize);
+ _sdio_release_host(func);
+
+ /*
+ * The MMC driver for kernels prior to 2.6.32 may fail this request
+ * with -ERANGE. In this case use our workaround.
+ */
+ if (r == -ERANGE) {
+ _sdio_claim_host(func);
+ r = sdio_set_block_size_ignore_first_error(func, blockSize);
+ _sdio_release_host(func);
+ }
+ if (r) {
+ unifi_error(NULL, "Error %d setting block size\n", r);
+ }
+
+ /* Determine the achieved block size to pass to the core */
+ function->blockSize = func->cur_blksize;
+
+ return ConvertSdioToCsrSdioResult(r);
+} /* CsrSdioBlockSizeSet() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioHardReset
+ *
+ * Hard Resets UniFi is possible.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioHardReset(CsrSdioFunction *function)
+{
+ return CSR_RESULT_FAILURE;
+} /* CsrSdioHardReset() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_glue_sdio_int_handler
+ *
+ * Interrupt callback function for SDIO interrupts.
+ * This is called in kernel context (i.e. not interrupt context).
+ *
+ * Arguments:
+ * func SDIO context pointer
+ *
+ * Returns:
+ * None.
+ *
+ * Note: Called with host already claimed.
+ * ---------------------------------------------------------------------------
+ */
+static void
+uf_glue_sdio_int_handler(struct sdio_func *func)
+{
+ CsrSdioFunction *sdio_ctx;
+ CsrSdioInterruptDsrCallback func_dsr_callback;
+ int r;
+
+ sdio_ctx = sdio_get_drvdata(func);
+ if (!sdio_ctx) {
+ return;
+ }
+
+#ifndef CSR_CONFIG_MMC_INT_BYPASS_KSOFTIRQD
+ /*
+ * Normally, we are not allowed to do any SDIO commands here.
+ * However, this is called in a thread context and with the SDIO lock
+ * so we disable the interrupts here instead of trying to do complicated
+ * things with the SDIO lock.
+ */
+#ifdef MMC_QUIRK_LENIENT_FN0
+ sdio_f0_writeb(func, 0, SDIO_CCCR_IENx, &r);
+#else
+ r = csr_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IENx, 0x00, NULL);
+#endif
+ if (r) {
+ printk(KERN_ERR "UniFi MMC Int handler: Failed to disable interrupts %d\n", r);
+ }
+#endif
+
+ /* If the function driver has registered a handler, call it */
+ if (sdio_func_drv && sdio_func_drv->intr) {
+
+ func_dsr_callback = sdio_func_drv->intr(sdio_ctx);
+
+ /* If interrupt handle returns a DSR handle, call it */
+ if (func_dsr_callback) {
+ func_dsr_callback(sdio_ctx);
+ }
+ }
+
+} /* uf_glue_sdio_int_handler() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * csr_sdio_linux_remove_irq
+ *
+ * Unregister the interrupt handler.
+ * This means that the linux layer can not process interrupts any more.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ *
+ * Returns:
+ * Status of the removal.
+ * ---------------------------------------------------------------------------
+ */
+int
+csr_sdio_linux_remove_irq(CsrSdioFunction *function)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int r;
+
+ unifi_trace(NULL, UDBG1, "csr_sdio_linux_remove_irq\n");
+
+ sdio_claim_host(func);
+ r = sdio_release_irq(func);
+ sdio_release_host(func);
+
+ return r;
+
+} /* csr_sdio_linux_remove_irq() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * csr_sdio_linux_install_irq
+ *
+ * Register the interrupt handler.
+ * This means that the linux layer can process interrupts.
+ *
+ * Arguments:
+ * sdio SDIO context pointer
+ *
+ * Returns:
+ * Status of the removal.
+ * ---------------------------------------------------------------------------
+ */
+int
+csr_sdio_linux_install_irq(CsrSdioFunction *function)
+{
+ struct sdio_func *func = (struct sdio_func *)function->priv;
+ int r;
+
+ unifi_trace(NULL, UDBG1, "csr_sdio_linux_install_irq\n");
+
+ /* Register our interrupt handle */
+ sdio_claim_host(func);
+ r = sdio_claim_irq(func, uf_glue_sdio_int_handler);
+ sdio_release_host(func);
+
+ /* If the interrupt was installed earlier, is fine */
+ if (r == -EBUSY) {
+ r = 0;
+ }
+
+ return r;
+} /* csr_sdio_linux_install_irq() */
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+#ifdef CONFIG_PM
+
+/*
+ * Power Management notifier
+ */
+struct uf_sdio_mmc_pm_notifier
+{
+ struct list_head list;
+
+ CsrSdioFunction *sdio_ctx;
+ struct notifier_block pm_notifier;
+};
+
+/* PM notifier list head */
+static struct uf_sdio_mmc_pm_notifier uf_sdio_mmc_pm_notifiers = {
+ .sdio_ctx = NULL,
+};
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_sdio_mmc_register_pm_notifier
+ * uf_sdio_mmc_unregister_pm_notifier
+ *
+ * Register/unregister for power management events. A list is used to
+ * allow multiple card instances to be supported.
+ *
+ * Arguments:
+ * sdio_ctx - CSR SDIO context to associate PM notifier to
+ *
+ * Returns:
+ * Register function returns NULL on error
+ * ---------------------------------------------------------------------------
+ */
+static struct uf_sdio_mmc_pm_notifier *
+uf_sdio_mmc_register_pm_notifier(CsrSdioFunction *sdio_ctx)
+{
+ /* Allocate notifier context for this card instance */
+ struct uf_sdio_mmc_pm_notifier *notifier_ctx = kmalloc(sizeof(struct uf_sdio_mmc_pm_notifier), GFP_KERNEL);
+
+ if (notifier_ctx)
+ {
+ notifier_ctx->sdio_ctx = sdio_ctx;
+ notifier_ctx->pm_notifier.notifier_call = uf_sdio_mmc_power_event;
+
+ list_add(¬ifier_ctx->list, &uf_sdio_mmc_pm_notifiers.list);
+
+ if (register_pm_notifier(¬ifier_ctx->pm_notifier)) {
+ printk(KERN_ERR "unifi: register_pm_notifier failed\n");
+ }
+ }
+
+ return notifier_ctx;
+}
+
+static void
+uf_sdio_mmc_unregister_pm_notifier(CsrSdioFunction *sdio_ctx)
+{
+ struct uf_sdio_mmc_pm_notifier *notifier_ctx;
+ struct list_head *node, *q;
+
+ list_for_each_safe(node, q, &uf_sdio_mmc_pm_notifiers.list) {
+ notifier_ctx = list_entry(node, struct uf_sdio_mmc_pm_notifier, list);
+
+ /* If it matches, unregister and free the notifier context */
+ if (notifier_ctx && notifier_ctx->sdio_ctx == sdio_ctx)
+ {
+ if (unregister_pm_notifier(¬ifier_ctx->pm_notifier)) {
+ printk(KERN_ERR "unifi: unregister_pm_notifier failed\n");
+ }
+
+ /* Remove from list */
+ notifier_ctx->sdio_ctx = NULL;
+ list_del(node);
+ kfree(notifier_ctx);
+ }
+ }
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_sdio_mmc_power_event
+ *
+ * Handler for power management events.
+ *
+ * We need to handle suspend/resume events while the userspace is unsuspended
+ * to allow the SME to run its suspend/resume state machines.
+ *
+ * Arguments:
+ * event event ID
+ *
+ * Returns:
+ * Status of the event handling
+ * ---------------------------------------------------------------------------
+ */
+static int
+uf_sdio_mmc_power_event(struct notifier_block *this, unsigned long event, void *ptr)
+{
+ struct uf_sdio_mmc_pm_notifier *notifier_ctx = container_of(this,
+ struct uf_sdio_mmc_pm_notifier,
+ pm_notifier);
+
+ /* Call the CSR SDIO function driver's suspend/resume method
+ * while the userspace is unsuspended.
+ */
+ switch (event) {
+ case PM_POST_HIBERNATION:
+ case PM_POST_SUSPEND:
+ printk(KERN_INFO "%s:%d resume\n", __FUNCTION__, __LINE__ );
+ if (sdio_func_drv && sdio_func_drv->resume) {
+ sdio_func_drv->resume(notifier_ctx->sdio_ctx);
+ }
+ break;
+
+ case PM_HIBERNATION_PREPARE:
+ case PM_SUSPEND_PREPARE:
+ printk(KERN_INFO "%s:%d suspend\n", __FUNCTION__, __LINE__ );
+ if (sdio_func_drv && sdio_func_drv->suspend) {
+ sdio_func_drv->suspend(notifier_ctx->sdio_ctx);
+ }
+ break;
+ }
+ return NOTIFY_DONE;
+}
+
+#endif /* CONFIG_PM */
+#endif /* 2.6.32 */
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_glue_sdio_probe
+ *
+ * Card insert callback.
+ *
+ * Arguments:
+ * func Our (glue layer) context pointer.
+ *
+ * Returns:
+ * UniFi driver error code.
+ * ---------------------------------------------------------------------------
+ */
+static int
+uf_glue_sdio_probe(struct sdio_func *func,
+ const struct sdio_device_id *id)
+{
+ int instance;
+ CsrSdioFunction *sdio_ctx;
+
+ func_enter();
+
+ /* First of all claim the SDIO driver */
+ sdio_claim_host(func);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+ /* Assume that the card is already powered */
+ card_is_powered = 1;
+#endif
+
+ /* Assumes one card per host, which is true for SDIO */
+ instance = func->card->host->index;
+ printk("sdio bus_id: %16s - UniFi card 0x%X inserted\n",
+ sdio_func_id(func), instance);
+
+ /* Allocate context */
+ sdio_ctx = (CsrSdioFunction *)kmalloc(sizeof(CsrSdioFunction),
+ GFP_KERNEL);
+ if (sdio_ctx == NULL) {
+ sdio_release_host(func);
+ return -ENOMEM;
+ }
+
+ /* Initialise the context */
+ sdio_ctx->sdioId.manfId = func->vendor;
+ sdio_ctx->sdioId.cardId = func->device;
+ sdio_ctx->sdioId.sdioFunction = func->num;
+ sdio_ctx->sdioId.sdioInterface = func->class;
+ sdio_ctx->blockSize = func->cur_blksize;
+ sdio_ctx->priv = (void *)func;
+ sdio_ctx->features = 0;
+
+ /* Module parameter enables byte mode */
+ if (sdio_byte_mode) {
+ sdio_ctx->features |= CSR_SDIO_FEATURE_BYTE_MODE;
+ }
+
+ if (func->card->host->caps & MMC_CAP_SD_HIGHSPEED) {
+ unifi_trace(NULL, UDBG1, "MMC_CAP_SD_HIGHSPEED is available\n");
+ }
+
+#ifdef MMC_QUIRK_LENIENT_FN0
+ func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
+#endif
+
+ /* Pass context to the SDIO driver */
+ sdio_set_drvdata(func, sdio_ctx);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+#ifdef CONFIG_PM
+ /* Register to get PM events */
+ if (uf_sdio_mmc_register_pm_notifier(sdio_ctx) == NULL) {
+ unifi_error(NULL, "%s: Failed to register for PM events\n", __FUNCTION__);
+ }
+#endif
+#endif
+
+ /* Register this device with the SDIO function driver */
+ /* Call the main UniFi driver inserted handler */
+ if (sdio_func_drv && sdio_func_drv->inserted) {
+ uf_add_os_device(instance, &func->dev);
+ sdio_func_drv->inserted(sdio_ctx);
+ }
+
+ /* We have finished, so release the SDIO driver */
+ sdio_release_host(func);
+
+#ifdef ANDROID_BUILD
+ /* Take the wakelock */
+ unifi_trace(NULL, UDBG1, "probe: take wake lock\n");
+ wake_lock(&unifi_sdio_wake_lock);
+#endif
+
+ func_exit();
+ return 0;
+} /* uf_glue_sdio_probe() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_glue_sdio_remove
+ *
+ * Card removal callback.
+ *
+ * Arguments:
+ * func Our (glue layer) context pointer.
+ *
+ * Returns:
+ * UniFi driver error code.
+ * ---------------------------------------------------------------------------
+ */
+static void
+uf_glue_sdio_remove(struct sdio_func *func)
+{
+ CsrSdioFunction *sdio_ctx;
+
+ sdio_ctx = sdio_get_drvdata(func);
+ if (!sdio_ctx) {
+ return;
+ }
+
+ func_enter();
+
+ unifi_info(NULL, "UniFi card removed\n");
+
+ /* Clean up the SDIO function driver */
+ if (sdio_func_drv && sdio_func_drv->removed) {
+ uf_remove_os_device(func->card->host->index);
+ sdio_func_drv->removed(sdio_ctx);
+ }
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+#ifdef CONFIG_PM
+ /* Unregister for PM events */
+ uf_sdio_mmc_unregister_pm_notifier(sdio_ctx);
+#endif
+#endif
+
+ kfree(sdio_ctx);
+
+ func_exit();
+
+} /* uf_glue_sdio_remove */
+
+
+/*
+ * SDIO ids *must* be statically declared, so we can't take
+ * them from the list passed in csr_sdio_register_driver().
+ */
+static const struct sdio_device_id unifi_ids[] = {
+ { SDIO_DEVICE(SDIO_MANF_ID_CSR,SDIO_CARD_ID_UNIFI_3) },
+ { SDIO_DEVICE(SDIO_MANF_ID_CSR,SDIO_CARD_ID_UNIFI_4) },
+ { /* end: all zeroes */ },
+};
+
+MODULE_DEVICE_TABLE(sdio, unifi_ids);
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+#ifdef CONFIG_PM
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_glue_sdio_suspend
+ *
+ * Card suspend callback. The userspace will already be suspended.
+ *
+ * Arguments:
+ * dev The struct device owned by the MMC driver
+ *
+ * Returns:
+ * None
+ * ---------------------------------------------------------------------------
+ */
+static int
+uf_glue_sdio_suspend(struct device *dev)
+{
+ func_enter();
+
+ unifi_trace(NULL, UDBG1, "uf_glue_sdio_suspend");
+
+ func_exit();
+ return 0;
+} /* uf_glue_sdio_suspend */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_glue_sdio_resume
+ *
+ * Card resume callback. The userspace will still be suspended.
+ *
+ * Arguments:
+ * dev The struct device owned by the MMC driver
+ *
+ * Returns:
+ * None
+ * ---------------------------------------------------------------------------
+ */
+static int
+uf_glue_sdio_resume(struct device *dev)
+{
+ func_enter();
+
+ unifi_trace(NULL, UDBG1, "uf_glue_sdio_resume");
+
+#ifdef ANDROID_BUILD
+ unifi_trace(NULL, UDBG1, "resume: take wakelock\n");
+ wake_lock(&unifi_sdio_wake_lock);
+#endif
+
+ func_exit();
+ return 0;
+
+} /* uf_glue_sdio_resume */
+
+static struct dev_pm_ops unifi_pm_ops = {
+ .suspend = uf_glue_sdio_suspend,
+ .resume = uf_glue_sdio_resume,
+};
+
+#define UNIFI_PM_OPS (&unifi_pm_ops)
+
+#else
+
+#define UNIFI_PM_OPS NULL
+
+#endif /* CONFIG_PM */
+#endif /* 2.6.32 */
+
+static struct sdio_driver unifi_driver = {
+ .probe = uf_glue_sdio_probe,
+ .remove = uf_glue_sdio_remove,
+ .name = "unifi",
+ .id_table = unifi_ids,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+ .drv.pm = UNIFI_PM_OPS,
+#endif /* 2.6.32 */
+};
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * CsrSdioFunctionDriverRegister
+ * CsrSdioFunctionDriverUnregister
+ *
+ * These functions are called from the main module load and unload
+ * functions. They perform the appropriate operations for the
+ * linux MMC/SDIO driver.
+ *
+ * Arguments:
+ * sdio_drv Pointer to the function driver's SDIO structure.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+CsrResult
+CsrSdioFunctionDriverRegister(CsrSdioFunctionDriver *sdio_drv)
+{
+ int r;
+
+ printk("UniFi: Using native Linux MMC driver for SDIO.\n");
+
+ if (sdio_func_drv) {
+ unifi_error(NULL, "sdio_mmc: UniFi driver already registered\n");
+ return CSR_SDIO_RESULT_INVALID_VALUE;
+ }
+
+#ifdef ANDROID_BUILD
+ wake_lock_init(&unifi_sdio_wake_lock, WAKE_LOCK_SUSPEND, "unifi_sdio_work");
+#endif
+
+ /* Save the registered driver description */
+ /*
+ * FIXME:
+ * Need a table here to handle a call to register for just one function.
+ * mmc only allows us to register for the whole device
+ */
+ sdio_func_drv = sdio_drv;
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
+#ifdef CONFIG_PM
+ /* Initialise PM notifier list */
+ INIT_LIST_HEAD(&uf_sdio_mmc_pm_notifiers.list);
+#endif
+#endif
+
+ /* Register ourself with mmc_core */
+ r = sdio_register_driver(&unifi_driver);
+ if (r) {
+ printk(KERN_ERR "unifi_sdio: Failed to register UniFi SDIO driver: %d\n", r);
+ return ConvertSdioToCsrSdioResult(r);
+ }
+
+ return CSR_RESULT_SUCCESS;
+} /* CsrSdioFunctionDriverRegister() */
+
+
+
+void
+CsrSdioFunctionDriverUnregister(CsrSdioFunctionDriver *sdio_drv)
+{
+ printk(KERN_INFO "UniFi: unregister from MMC sdio\n");
+
+#ifdef ANDROID_BUILD
+ wake_lock_destroy(&unifi_sdio_wake_lock);
+#endif
+ sdio_unregister_driver(&unifi_driver);
+
+ sdio_func_drv = NULL;
+
+} /* CsrSdioFunctionDriverUnregister() */
+
--- /dev/null
+/*
+ * Stubs for some of the bottom edge functions.
+ *
+ * These stubs are optional functions in the bottom edge (SDIO driver
+ * interface) API that not all platforms or SDIO drivers may support.
+ *
+ * They're declared as weak symbols so they can be overridden by
+ * simply providing a non-weak declaration.
+ *
+ * Copyright (C) 2007-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ */
+#include "csr_wifi_hip_unifi.h"
+
+void __attribute__((weak)) CsrSdioFunctionIdle(CsrSdioFunction *function)
+{
+}
+
+void __attribute__((weak)) CsrSdioFunctionActive(CsrSdioFunction *function)
+{
+}
+
+CsrResult __attribute__((weak)) CsrSdioPowerOn(CsrSdioFunction *function)
+{
+ return CSR_RESULT_SUCCESS;
+}
+
+void __attribute__((weak)) CsrSdioPowerOff(CsrSdioFunction *function)
+{
+}
+
+CsrResult __attribute__((weak)) CsrSdioHardReset(CsrSdioFunction *function)
+{
+ return CSR_SDIO_RESULT_NOT_RESET;
+}
+
+CsrResult __attribute__((weak)) CsrSdioBlockSizeSet(CsrSdioFunction *function,
+ CsrUint16 blockSize)
+{
+ return CSR_RESULT_SUCCESS;
+}
+
+CsrResult __attribute__((weak)) CsrSdioSuspend(CsrSdioFunction *function)
+{
+ return CSR_RESULT_SUCCESS;
+}
+
+CsrResult __attribute__((weak)) CsrSdioResume(CsrSdioFunction *function)
+{
+ return CSR_RESULT_SUCCESS;
+}
+
+int __attribute__((weak)) csr_sdio_linux_install_irq(CsrSdioFunction *function)
+{
+ return 0;
+}
+
+int __attribute__((weak)) csr_sdio_linux_remove_irq(CsrSdioFunction *function)
+{
+ return 0;
+}
+
+void __attribute__((weak)) CsrSdioInsertedAcknowledge(CsrSdioFunction *function, CsrResult result)
+{
+}
+
+void __attribute__((weak)) CsrSdioRemovedAcknowledge(CsrSdioFunction *function)
+{
+}
+
+void __attribute__((weak)) CsrSdioSuspendAcknowledge(CsrSdioFunction *function, CsrResult result)
+{
+}
+
+void __attribute__((weak)) CsrSdioResumeAcknowledge(CsrSdioFunction *function, CsrResult result)
+{
+}
+
+
--- /dev/null
+/*
+ * CSPI definitions.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef SDIOEMB_CSPI_H
+#define SDIOEMB_CSPI_H
+
+/**
+ * @addtogroup sdriver
+ *@{*/
+
+#define CSPI_FUNC(f) (f)
+#define CSPI_READ 0x10
+#define CSPI_WRITE 0x20
+#define CSPI_BURST 0x40
+#define CSPI_TYPE_MASK 0x70
+
+/**
+ * CSPI_MODE function 0 register.
+ *
+ * Various CSPI mode settings.
+ *
+ * @see CSPI specification (CS-110124-SP)
+ */
+#define CSPI_MODE 0xf7
+# define CSPI_MODE_PADDED_WRITE_HDRS (1 << 7)
+# define CSPI_MODE_PADDED_READ_HDRS (1 << 6)
+/**
+ * BigEndianRegisters bit of \ref CSPI_MODE -- enable big-endian CSPI
+ * register reads and writes.
+ *
+ * @warning This bit should never be set as it's not possible to use
+ * this mode without knowledge of which registers are 8 bit and which
+ * are 16 bit.
+ */
+# define CSPI_MODE_BE_REG (1 << 5)
+# define CSPI_MODE_BE_BURST (1 << 4)
+# define CSPI_MODE_INT_ACTIVE_HIGH (1 << 3)
+# define CSPI_MODE_INT_ON_ERR (1 << 2)
+# define CSPI_MODE_LEN_FIELD_PRESENT (1 << 1)
+# define CSPI_MODE_DRV_MISO_ON_RISING_CLK (1 << 0)
+
+#define CSPI_STATUS 0xf8
+
+#define CSPI_PADDING 0xf9
+# define CSPI_PADDING_REG(p) ((p) << 0)
+# define CSPI_PADDING_BURST(p) ((p) << 4)
+
+#define CSPI_PADDING_MAX 15
+#define CSPI_PADDING_REG_DFLT 0
+#define CSPI_PADDING_BURST_DFLT 2
+
+/* cmd byte, 3 byte addr, padding, error byte, data word */
+#define CSPI_REG_TRANSFER_LEN (1 + 3 + CSPI_PADDING_MAX + 1 + 2)
+
+/*@}*/
+
+#endif /* #ifndef SDIOEMB_CSPI_H */
--- /dev/null
+/*
+ * Synergy compatible API -- common result codes.
+ *
+ * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef CSR_RESULT_H__
+#define CSR_RESULT_H__
+
+typedef CsrUint16 CsrResult;
+#define CSR_RESULT_SUCCESS ((CsrResult) 0x0000)
+#define CSR_RESULT_FAILURE ((CsrResult) 0xffff)
+
+#endif
--- /dev/null
+/*
+ * Synergy compatible API -- SDIO.
+ *
+ * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef CSR_SDIO_H__
+#define CSR_SDIO_H__
+
+#include "csr_types.h"
+#include "csr_result.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Result Codes */
+#define CSR_SDIO_RESULT_INVALID_VALUE ((CsrResult) 1) /* Invalid argument value */
+#define CSR_SDIO_RESULT_NO_DEVICE ((CsrResult) 2) /* The specified device is no longer present */
+#define CSR_SDIO_RESULT_CRC_ERROR ((CsrResult) 3) /* The transmitted/received data or command response contained a CRC error */
+#define CSR_SDIO_RESULT_TIMEOUT ((CsrResult) 4) /* No command response or data received from device, or function enable/disable did not succeed within timeout period */
+#define CSR_SDIO_RESULT_NOT_RESET ((CsrResult) 5) /* The device was not reset */
+
+/* Features (for use in features member of CsrSdioFunction) */
+#define CSR_SDIO_FEATURE_BYTE_MODE 0x00000001 /* Transfer sizes do not have to be a multiple of block size */
+#define CSR_SDIO_FEATURE_DMA_CAPABLE_MEM_REQUIRED 0x00000002 /* Bulk operations require DMA friendly memory */
+
+/* CsrSdioFunctionId wildcards (for use in CsrSdioFunctionId members) */
+#define CSR_SDIO_ANY_MANF_ID 0xFFFF
+#define CSR_SDIO_ANY_CARD_ID 0xFFFF
+#define CSR_SDIO_ANY_SDIO_FUNCTION 0xFF
+#define CSR_SDIO_ANY_SDIO_INTERFACE 0xFF
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionId
+ *
+ * DESCRIPTION
+ * This structure describes one or more functions of a device, based on
+ * four qualitative measures. The CsrSdioFunctionId wildcard defines can be
+ * used for making the CsrSdioFunctionId match more than one function.
+ *
+ * MEMBERS
+ * manfId - Vendor ID (or CSR_SDIO_ANY_MANF_ID).
+ * cardId - Device ID (or CSR_SDIO_ANY_CARD_ID).
+ * sdioFunction - SDIO Function number (or CSR_SDIO_ANY_SDIO_FUNCTION).
+ * sdioInterface - SDIO Standard Interface Code (or CSR_SDIO_ANY_SDIO_INTERFACE)
+ *
+ *----------------------------------------------------------------------------*/
+typedef struct
+{
+ CsrUint16 manfId; /* Vendor ID to match or CSR_SDIO_ANY_MANF_ID */
+ CsrUint16 cardId; /* Device ID to match or CSR_SDIO_ANY_CARD_ID */
+ CsrUint8 sdioFunction; /* SDIO Function number to match or CSR_SDIO_ANY_SDIO_FUNCTION */
+ CsrUint8 sdioInterface; /* SDIO Standard Interface Code to match or CSR_SDIO_ANY_SDIO_INTERFACE */
+} CsrSdioFunctionId;
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunction
+ *
+ * DESCRIPTION
+ * This structure represents a single function on a device.
+ *
+ * MEMBERS
+ * sdioId - A CsrSdioFunctionId describing this particular function. The
+ * subfield shall not contain any CsrSdioFunctionId wildcards. The
+ * subfields shall describe the specific single function
+ * represented by this structure.
+ * blockSize - Actual configured block size, or 0 if unconfigured.
+ * features - Bit mask with any of CSR_SDIO_FEATURE_* set.
+ * driverData - For use by the Function Driver. The SDIO Driver shall not
+ * attempt to dereference the pointer.
+ * priv - For use by the SDIO Driver. The Function Driver shall not attempt
+ * to dereference the pointer.
+ *
+ *----------------------------------------------------------------------------*/
+typedef struct
+{
+ CsrSdioFunctionId sdioId;
+ CsrUint16 blockSize; /* Actual configured block size, or 0 if unconfigured */
+ CsrUint32 features; /* Bit mask with any of CSR_SDIO_FEATURE_* set */
+ void *cardHandle; /* An opaque handle for this function's card. */
+ void *osDevice;
+ void *driverData; /* For use by the Function Driver */
+ void *priv; /* For use by the SDIO Driver */
+} CsrSdioFunction;
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioInsertedCallback, CsrSdioRemovedCallback
+ *
+ * DESCRIPTION
+ * CsrSdioInsertedCallback is called when a function becomes available to
+ * a registered Function Driver that supports the function.
+ * CsrSdioRemovedCallback is called when a function is no longer available
+ * to a Function Driver, either because the device has been removed, or the
+ * Function Driver has been unregistered.
+ *
+ * NOTE: These functions are implemented by the Function Driver, and are
+ * passed as function pointers in the CsrSdioFunctionDriver struct.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ *----------------------------------------------------------------------------*/
+typedef void (*CsrSdioInsertedCallback)(CsrSdioFunction *function);
+typedef void (*CsrSdioRemovedCallback)(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioInterruptDsrCallback, CsrSdioInterruptCallback
+ *
+ * DESCRIPTION
+ * CsrSdioInterruptCallback is called when an interrupt occurs on the
+ * the device associated with the specified function.
+ *
+ * NOTE: These functions are implemented by the Function Driver, and are
+ * passed as function pointers in the CsrSdioFunctionDriver struct.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ * RETURNS (only CsrSdioInterruptCallback)
+ * A pointer to a CsrSdioInterruptDsrCallback function.
+ *
+ *----------------------------------------------------------------------------*/
+typedef void (*CsrSdioInterruptDsrCallback)(CsrSdioFunction *function);
+typedef CsrSdioInterruptDsrCallback (*CsrSdioInterruptCallback)(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioSuspendCallback, CsrSdioResumeCallback
+ *
+ * DESCRIPTION
+ * CsrSdioSuspendCallback is called when the system is preparing to go
+ * into a suspended state. CsrSdioResumeCallback is called when the system
+ * has entered an active state again.
+ *
+ * NOTE: These functions are implemented by the Function Driver, and are
+ * passed as function pointers in the CsrSdioFunctionDriver struct.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ *----------------------------------------------------------------------------*/
+typedef void (*CsrSdioSuspendCallback)(CsrSdioFunction *function);
+typedef void (*CsrSdioResumeCallback)(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioAsyncCallback, CsrSdioAsyncDsrCallback
+ *
+ * DESCRIPTION
+ * CsrSdioAsyncCallback is called when an asynchronous operation completes.
+ *
+ * NOTE: These functions are implemented by the Function Driver, and are
+ * passed as function pointers in the function calls that initiate
+ * the operation.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * result - The result of the operation that completed. See the description
+ * of the initiating function for possible result values.
+ *
+ * RETURNS (only CsrSdioAsyncCallback)
+ * A pointer to a CsrSdioAsyncDsrCallback function.
+ *
+ *----------------------------------------------------------------------------*/
+typedef void (*CsrSdioAsyncDsrCallback)(CsrSdioFunction *function, CsrResult result);
+typedef CsrSdioAsyncDsrCallback (*CsrSdioAsyncCallback)(CsrSdioFunction *function, CsrResult result);
+
+typedef struct
+{
+ CsrSdioInsertedCallback inserted;
+ CsrSdioRemovedCallback removed;
+ CsrSdioInterruptCallback intr;
+ CsrSdioSuspendCallback suspend;
+ CsrSdioResumeCallback resume;
+ CsrSdioFunctionId *ids;
+ CsrUint8 idsCount;
+ void *priv;
+} CsrSdioFunctionDriver;
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionDriverRegister
+ *
+ * DESCRIPTION
+ * Register a Function Driver.
+ *
+ * PARAMETERS
+ * functionDriver - Pointer to struct describing the Function Driver.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The Function Driver was successfully
+ * registered.
+ * CSR_RESULT_FAILURE - Unable to register the function driver,
+ * because of an unspecified/unknown error. The
+ * Function Driver has not been registered.
+ * CSR_SDIO_RESULT_INVALID_VALUE - The specified Function Driver pointer
+ * does not point at a valid Function
+ * Driver structure, or some of the members
+ * contain invalid entries.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioFunctionDriverRegister(CsrSdioFunctionDriver *functionDriver);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionDriverUnregister
+ *
+ * DESCRIPTION
+ * Unregister a previously registered Function Driver.
+ *
+ * PARAMETERS
+ * functionDriver - pointer to struct describing the Function Driver.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSdioFunctionDriverUnregister(CsrSdioFunctionDriver *functionDriver);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionEnable, CsrSdioFunctionDisable
+ *
+ * DESCRIPTION
+ * Enable/disable the specified function by setting/clearing the
+ * corresponding bit in the I/O Enable register in function 0, and then
+ * periodically reading the related bit in the I/O Ready register until it
+ * is set/clear, limited by an implementation defined timeout.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The specified function was enabled/disabled.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. The state of the
+ * related bit in the I/O Enable register is
+ * undefined.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device, or the related
+ * bit in the I/O ready register was not
+ * set/cleared within the timeout period.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioFunctionEnable(CsrSdioFunction *function);
+CsrResult CsrSdioFunctionDisable(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioInterruptEnable, CsrSdioInterruptDisable
+ *
+ * DESCRIPTION
+ * Enable/disable the interrupt for the specified function by
+ * setting/clearing the corresponding bit in the INT Enable register in
+ * function 0.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The specified function was enabled/disabled.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. The state of the
+ * related bit in the INT Enable register is
+ * unchanged.
+ * CSR_SDIO_RESULT_INVALID_VALUE - The specified function cannot be
+ * enabled/disabled, because it either
+ * does not exist or it is not possible to
+ * individually enable/disable functions.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioInterruptEnable(CsrSdioFunction *function);
+CsrResult CsrSdioInterruptDisable(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioInterruptAcknowledge
+ *
+ * DESCRIPTION
+ * Acknowledge that a signalled interrupt has been handled. Shall only
+ * be called once, and exactly once for each signalled interrupt to the
+ * corresponding function.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function to which the
+ * event was signalled.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSdioInterruptAcknowledge(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioInsertedAcknowledge, CsrSdioRemovedAcknowledge
+ *
+ * DESCRIPTION
+ * Acknowledge that a signalled inserted/removed event has been handled.
+ * Shall only be called once, and exactly once for each signalled event to
+ * the corresponding function.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function to which the
+ * inserted was signalled.
+ * result (CsrSdioInsertedAcknowledge only)
+ * CSR_RESULT_SUCCESS - The Function Driver has accepted the
+ * function, and the function is attached to
+ * the Function Driver until the
+ * CsrSdioRemovedCallback is called and
+ * acknowledged.
+ * CSR_RESULT_FAILURE - Unable to accept the function. The
+ * function is not attached to the Function
+ * Driver, and it may be passed to another
+ * Function Driver which supports the
+ * function.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSdioInsertedAcknowledge(CsrSdioFunction *function, CsrResult result);
+void CsrSdioRemovedAcknowledge(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioSuspendAcknowledge, CsrSdioResumeAcknowledge
+ *
+ * DESCRIPTION
+ * Acknowledge that a signalled suspend event has been handled. Shall only
+ * be called once, and exactly once for each signalled event to the
+ * corresponding function.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function to which the
+ * event was signalled.
+ * result
+ * CSR_RESULT_SUCCESS - Successfully suspended/resumed.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSdioSuspendAcknowledge(CsrSdioFunction *function, CsrResult result);
+void CsrSdioResumeAcknowledge(CsrSdioFunction *function, CsrResult result);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioBlockSizeSet
+ *
+ * DESCRIPTION
+ * Set the block size to use for the function. The actual configured block
+ * size shall be the minimum of:
+ * 1) Maximum block size supported by the function.
+ * 2) Maximum block size supported by the host controller.
+ * 3) The block size specified by the blockSize argument.
+ *
+ * When this function returns, the actual configured block size is
+ * available in the blockSize member of the function struct.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * blockSize - Block size to use for the function. Valid range is 1 to
+ * 2048.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The block size register on the chip
+ * was updated.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. The configured block
+ * size is undefined.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and the FUNCTION_NUMBER
+ * bits is set, CSR_SDIO_RESULT_INVALID_VALUE shall be returned.
+ * If the ERROR bit is set (but not FUNCTION_NUMBER),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ * NOTE: Setting the block size requires two individual operations. The
+ * implementation shall ignore the OUT_OF_RANGE bit of the SDIO R5
+ * response for the first operation, as the partially configured
+ * block size may be out of range, even if the final block size
+ * (after the second operation) is in the valid range.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioBlockSizeSet(CsrSdioFunction *function, CsrUint16 blockSize);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioMaxBusClockFrequencySet
+ *
+ * DESCRIPTION
+ * Set the maximum clock frequency to use for the device associated with
+ * the specified function. The actual configured clock frequency for the
+ * device shall be the minimum of:
+ * 1) Maximum clock frequency supported by the device.
+ * 2) Maximum clock frequency supported by the host controller.
+ * 3) Maximum clock frequency specified for any function on the same
+ * device.
+ *
+ * If the clock frequency exceeds 25MHz, it is the responsibility of the
+ * SDIO driver to enable high speed mode on the device, using the standard
+ * defined procedure, before increasing the frequency beyond the limit.
+ *
+ * Note that the clock frequency configured affects all functions on the
+ * same device.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * maxFrequency - The maximum clock frequency for the function in Hertz.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The maximum clock frequency was succesfully
+ * set for the function.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ *
+ * NOTE: If the SDIO R5 response is available, and the FUNCTION_NUMBER
+ * bits is set, CSR_SDIO_RESULT_INVALID_VALUE shall be returned.
+ * If the ERROR bit is set (but not FUNCTION_NUMBER),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioMaxBusClockFrequencySet(CsrSdioFunction *function, CsrUint32 maxFrequency);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioRead8, CsrSdioWrite8, CsrSdioRead8Async, CsrSdioWrite8Async
+ *
+ * DESCRIPTION
+ * Read/write an 8bit value from/to the specified register address.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * address - Register address within the function.
+ * data - The data to read/write.
+ * callback - The function to call on operation completion.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The data was successfully read/written.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. No data read/written.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ * NOTE: The CsrSdioRead8Async and CsrSdioWrite8Async functions return
+ * immediately, and the supplied callback function is called when the
+ * operation is complete. The result value is given as an argument to
+ * the callback function.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioRead8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data);
+CsrResult CsrSdioWrite8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data);
+void CsrSdioRead8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data, CsrSdioAsyncCallback callback);
+void CsrSdioWrite8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data, CsrSdioAsyncCallback callback);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioRead16, CsrSdioWrite16, CsrSdioRead16Async, CsrSdioWrite16Async
+ *
+ * DESCRIPTION
+ * Read/write a 16bit value from/to the specified register address.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * address - Register address within the function.
+ * data - The data to read/write.
+ * callback - The function to call on operation completion.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The data was successfully read/written.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. Data may have been
+ * partially read/written.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ * NOTE: The CsrSdioRead16Async and CsrSdioWrite16Async functions return
+ * immediately, and the supplied callback function is called when the
+ * operation is complete. The result value is given as an argument to
+ * the callback function.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioRead16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data);
+CsrResult CsrSdioWrite16(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data);
+void CsrSdioRead16Async(CsrSdioFunction *function, CsrUint32 address, CsrUint16 *data, CsrSdioAsyncCallback callback);
+void CsrSdioWrite16Async(CsrSdioFunction *function, CsrUint32 address, CsrUint16 data, CsrSdioAsyncCallback callback);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioF0Read8, CsrSdioF0Write8, CsrSdioF0Read8Async,
+ * CsrSdioF0Write8Async
+ *
+ * DESCRIPTION
+ * Read/write an 8bit value from/to the specified register address in
+ * function 0.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * address - Register address within the function.
+ * data - The data to read/write.
+ * callback - The function to call on operation completion.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The data was successfully read/written.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. No data read/written.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ * NOTE: The CsrSdioF0Read8Async and CsrSdioF0Write8Async functions return
+ * immediately, and the supplied callback function is called when the
+ * operation is complete. The result value is given as an argument to
+ * the callback function.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioF0Read8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data);
+CsrResult CsrSdioF0Write8(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data);
+void CsrSdioF0Read8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 *data, CsrSdioAsyncCallback callback);
+void CsrSdioF0Write8Async(CsrSdioFunction *function, CsrUint32 address, CsrUint8 data, CsrSdioAsyncCallback callback);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioRead, CsrSdioWrite, CsrSdioReadAsync, CsrSdioWriteAsync
+ *
+ * DESCRIPTION
+ * Read/write a specified number of bytes from/to the specified register
+ * address.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ * address - Register address within the function.
+ * data - The data to read/write.
+ * length - Number of byte to read/write.
+ * callback - The function to call on operation completion.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - The data was successfully read/written.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_INVALID_VALUE - One or more arguments were invalid.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured. Data may have been
+ * partially read/written.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device.
+ *
+ * NOTE: If the SDIO R5 response is available, and either of the
+ * FUNCTION_NUMBER or OUT_OF_RANGE bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE shall be returned. If the ERROR bit
+ * is set (but none of FUNCTION_NUMBER or OUT_OF_RANGE),
+ * CSR_RESULT_FAILURE shall be returned. The ILLEGAL_COMMAND and
+ * COM_CRC_ERROR bits shall be ignored.
+ *
+ * If the CSPI response is available, and any of the
+ * FUNCTION_DISABLED or CLOCK_DISABLED bits are set,
+ * CSR_SDIO_RESULT_INVALID_VALUE will be returned.
+ *
+ * NOTE: The CsrSdioF0Read8Async and CsrSdioF0Write8Async functions return
+ * immediately, and the supplied callback function is called when the
+ * operation is complete. The result value is given as an argument to
+ * the callback function.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioRead(CsrSdioFunction *function, CsrUint32 address, void *data, CsrUint32 length);
+CsrResult CsrSdioWrite(CsrSdioFunction *function, CsrUint32 address, const void *data, CsrUint32 length);
+void CsrSdioReadAsync(CsrSdioFunction *function, CsrUint32 address, void *data, CsrUint32 length, CsrSdioAsyncCallback callback);
+void CsrSdioWriteAsync(CsrSdioFunction *function, CsrUint32 address, const void *data, CsrUint32 length, CsrSdioAsyncCallback callback);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioPowerOn, CsrSdioPowerOff
+ *
+ * DESCRIPTION
+ * Power on/off the device.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function that resides on
+ * the device to power on/off.
+ *
+ * RETURNS (only CsrSdioPowerOn)
+ * CSR_RESULT_SUCCESS - Power was succesfully reapplied and the device
+ * has been reinitialised.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured during reinitialisation.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device during
+ * reinitialisation.
+ * CSR_SDIO_RESULT_NOT_RESET - The power was not removed by the
+ * CsrSdioPowerOff call. The state of the
+ * device is unchanged.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioPowerOn(CsrSdioFunction *function);
+void CsrSdioPowerOff(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioHardReset
+ *
+ * DESCRIPTION
+ * Perform a hardware reset of the device.
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function that resides on
+ * the device to hard reset.
+ *
+ * RETURNS
+ * CSR_RESULT_SUCCESS - Reset was succesfully performed and the device
+ * has been reinitialised.
+ * CSR_RESULT_FAILURE - Unspecified/unknown error.
+ * CSR_SDIO_RESULT_NO_DEVICE - The device does not exist anymore.
+ * CSR_SDIO_RESULT_CRC_ERROR - A CRC error occured during reinitialisation.
+ * CSR_SDIO_RESULT_TIMEOUT - No response from the device during
+ * reinitialisation.
+ * CSR_SDIO_RESULT_NOT_RESET - The reset was not applied because it is not
+ * supported. The state of the device is
+ * unchanged.
+ *
+ *----------------------------------------------------------------------------*/
+CsrResult CsrSdioHardReset(CsrSdioFunction *function);
+
+/*----------------------------------------------------------------------------*
+ * NAME
+ * CsrSdioFunctionActive, CsrSdioFunctionIdle
+ *
+ * DESCRIPTION
+ *
+ * PARAMETERS
+ * function - Pointer to struct representing the function.
+ *
+ *----------------------------------------------------------------------------*/
+void CsrSdioFunctionActive(CsrSdioFunction *function);
+void CsrSdioFunctionIdle(CsrSdioFunction *function);
+
+void CsrSdioCallbackInhibitEnter(CsrSdioFunction *function);
+void CsrSdioCallbackInhibitLeave(CsrSdioFunction *function);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+/*
+ * Synergy compatible API -- SDIO utility library.
+ *
+ * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef CSR_SDIO_LIB_H__
+#define CSR_SDIO_LIB_H__
+
+#include <csr_sdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+CsrResult CsrSdioFunctionReenable(CsrSdioFunction *function);
+
+typedef int CsrStatus; /* platform specific */
+#define CSR_STATUS_FAILURE(status) ((status) < 0) /* platform specific */
+
+CsrResult CsrSdioStatusToResult(CsrStatus status);
+CsrStatus CsrSdioResultToStatus(CsrResult result);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* #ifndef CSR_SDIO_LIB_H__ */
--- /dev/null
+/*
+ * Synergy compatible API -- helpers for Windows Driver Framework drivers.
+ *
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef CSR_SDIO_WDF_H__
+#define CSR_SDIO_WDF_H__
+
+#include <wdf.h>
+
+NTSTATUS CsrSdioWdfDeviceInit(WDFDEVICE device);
+void CsrSdioWdfDeviceCleanup(WDFDEVICE device);
+
+NTSTATUS CsrSdioWdfDeviceAdd(WDFDEVICE device);
+void CsrSdioWdfDeviceDel(WDFDEVICE device);
+
+NTSTATUS CsrSdioWdfDeviceSuspend(WDFDEVICE device);
+NTSTATUS CsrSdioWdfDeviceResume(WDFDEVICE device);
+
+#endif /* #ifndef CSR_SDIO_WDF_H__ */
--- /dev/null
+/*
+ * Synergy compatible API -- basic types.
+ *
+ * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef CSR_TYPES_H__
+#define CSR_TYPES_H__
+
+#include <oska/types.h>
+
+#ifndef FALSE
+#define FALSE false
+#endif
+
+#ifndef TRUE
+#define TRUE true
+#endif
+
+/* Data types */
+
+typedef size_t CsrSize;
+
+typedef uint8_t CsrUint8;
+typedef uint16_t CsrUint16;
+typedef uint32_t CsrUint32;
+
+typedef int8_t CsrInt8;
+typedef int16_t CsrInt16;
+typedef int32_t CsrInt32;
+
+typedef bool CsrBool;
+
+typedef char CsrCharString;
+typedef unsigned char CsrUtf8String;
+typedef CsrUint16 CsrUtf16String; /* 16-bit UTF16 strings */
+typedef CsrUint32 CsrUint24;
+
+/*
+ * 64-bit integers
+ *
+ * Note: If a given compiler does not support 64-bit types, it is
+ * OK to omit these definitions; 32-bit versions of the code using
+ * these types may be available. Consult the relevant documentation
+ * or the customer support group for information on this.
+ */
+#define CSR_HAVE_64_BIT_INTEGERS
+typedef uint64_t CsrUint64;
+typedef int64_t CsrInt64;
+
+#endif
--- /dev/null
+/*
+ * SDIO Userspace Interface library.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef SDIOEMB_LIBSDIO_H
+#define SDIOEMB_LIBSDIO_H
+
+/**
+ * \defgroup libsdio Userspace SDIO library (libsdio)
+ *
+ * \brief \e libsdio is a Linux C library for accessing SDIO cards.
+ *
+ * Use of this library requires several \e sdioemb kernel modules to be
+ * loaded:
+ * - \c sdio.
+ * - \c An SDIO slot driver (e.g., \c slot_shc for a standard PCI
+ * SDIO Host Controller).
+ * - \c sdio_uif which provides the required character devices
+ * (/dev/sdio_uif0 for the card in SDIO slot 0 etc.).
+ */
+/*@{*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef WIN32
+# define LIBSDIOAPI __stdcall
+#else
+# define LIBSDIOAPI
+#endif
+
+struct sdio_uif;
+
+/**
+ * Handle to an opened SDIO Userspace Interface device.
+ */
+typedef struct sdio_uif *sdio_uif_t;
+
+enum sdio_status {
+ SDIO_SUCCESS = 0,
+ SDIO_EAGAIN = -1,
+ SDIO_EINVAL = -2,
+ SDIO_EIO = -3,
+ SDIO_ENODEV = -4,
+ SDIO_ENOMEM = -5,
+ SDIO_ENOTSUPP = -6,
+ SDIO_ENXIO = -7,
+ SDIO_ETIMEDOUT = -8,
+};
+
+/**
+ * Card interrupt handler function.
+ *
+ * @param uif handle to the interrupting device.
+ * @param arg data supplied by the caller of sdio_open().
+ */
+typedef void (LIBSDIOAPI *sdio_int_handler_t)(sdio_uif_t uif, void *arg);
+
+/**
+ * Asynchronous IO completion callback function.
+ *
+ * @param uif handle to the device that completed the IO operation.
+ * @param arg data supplied by the caller of the asynchronous IO operation.
+ * @param status status of the IO operation. 0 is success; -EIO,
+ * -EINVAL, -ETIMEDOUT etc. on an error.
+ */
+typedef void (LIBSDIOAPI *sdio_io_callback_t)(sdio_uif_t uif, void *arg, int status);
+
+/**
+ * Open a SDIO Userspace Interface device and (optionally) register a
+ * card interrupt handler and enable card interrupts.
+ *
+ * Card interrupts are masked before calling int_handler and are
+ * unmasked when int_handler returns (unless sdio_interrupt_mask() is
+ * called).
+ *
+ * @param dev_filename filename of the device to open.
+ * @param int_handler card interrupt handler; or NULL if no
+ * interrupt handler is required.
+ * @param arg argument to be passed to the interrupt handler.
+ *
+ * @return handle to the opened device; or NULL on error with errno
+ * set.
+ */
+sdio_uif_t LIBSDIOAPI sdio_open(const char *dev_filename,
+ sdio_int_handler_t int_handler, void *arg);
+
+/**
+ * Mask the SDIO interrupt.
+ *
+ * Call this in an interrupt handler to allow the processing of
+ * interrupts to be deferred until after the interrupt handler has
+ * returned.
+ *
+ * @note \e Must only be called from within the interrupt handler
+ * registered with sdio_open().
+ *
+ * @param uif device handle.
+ */
+void LIBSDIOAPI sdio_interrupt_mask(sdio_uif_t uif);
+
+/**
+ * Unmask the SDIO interrupt.
+ *
+ * Unmasks the SDIO interrupt if it had previously been masked with
+ * sdio_interrupt_mask().
+ *
+ * @param uif device handle.
+ */
+void LIBSDIOAPI sdio_interrupt_unmask(sdio_uif_t uif);
+
+/**
+ * Close an opened SDIO Userspace Interface device, freeing all
+ * associated resources.
+ *
+ * @param uif handle to the device.
+ */
+void LIBSDIOAPI sdio_close(sdio_uif_t uif);
+
+/**
+ * Return the number of functions the card has.
+ *
+ * @param uif device handle.
+ *
+ * @return number of card functions.
+ */
+int LIBSDIOAPI sdio_num_functions(sdio_uif_t uif);
+
+/**
+ * Set an SDIO bus to 1 bit or 4 bit wide mode.
+ *
+ * The CCCR bus interface control register will be read and rewritten
+ * with the new bus width.
+ *
+ * @param uif device handle.
+ * @param bus_width bus width (1 or 4).
+ *
+ * @return 0 on success; -ve on error with errno set.
+ *
+ * @note The card capabilities are \e not checked. The user should
+ * ensure 4 bit mode is not enabled on a card that does not support
+ * it.
+ */
+int LIBSDIOAPI sdio_set_bus_width(sdio_uif_t uif, int bus_width);
+
+/**
+ * Limit the frequency of (or stop) the SD bus clock.
+ *
+ * The frequency cannot be set greater than that supported by the card
+ * or the controller.
+ *
+ * @note Stopping the bus clock while other device drivers are
+ * executing commands may result in those commands not completing
+ * until the bus clock is restarted.
+ *
+ * @param uif device handle.
+ * @param max_freq maximum frequency (Hz) or 0 to stop the bus clock
+ * until the start of the next command.
+ */
+void LIBSDIOAPI sdio_set_max_bus_freq(sdio_uif_t uif, int max_freq);
+
+/**
+ * Return the card's manufacturer (vendor) ID.
+ *
+ * @param uif device handle.
+ *
+ * @return manufacturer ID.
+ */
+uint16_t LIBSDIOAPI sdio_manf_id(sdio_uif_t uif);
+
+/**
+ * Return the card's card (device) ID.
+ *
+ * @param uif device handle.
+ *
+ * @return card ID.
+ */
+uint16_t LIBSDIOAPI sdio_card_id(sdio_uif_t uif);
+
+/**
+ * Return the standard interface code for a function.
+ *
+ * @param uif device handle.
+ * @param func card function to query.
+ *
+ * @return the standard interface.
+ */
+uint8_t LIBSDIOAPI sdio_std_if(sdio_uif_t uif, int func);
+
+/**
+ * Return a function's maximum supported block size.
+ *
+ * @param uif device handle.
+ * @param func card function to query.
+ *
+ * @return maximum block size.
+ */
+int LIBSDIOAPI sdio_max_block_size(sdio_uif_t uif, int func);
+
+/**
+ * Return a function's current block size.
+ *
+ * @note This returns the driver's view of the block size and not the
+ * value in the function's block size register.
+ *
+ * @param uif device handle.
+ * @param func card function to query.
+ *
+ * @return the current block size.
+ */
+int LIBSDIOAPI sdio_block_size(sdio_uif_t uif, int func);
+
+/**
+ * Set a function's block size.
+ *
+ * The function's block size registers will be written if necessary.
+ *
+ * @param uif device handle.
+ * @param func function to modify.
+ * @param blksz the new block size; or 0 for the default size.
+ *
+ * @return 0 on success; or -ve on error with errno set.
+ */
+int LIBSDIOAPI sdio_set_block_size(sdio_uif_t uif, int func, int blksz);
+
+/**
+ * Read an 8 bit register.
+ *
+ * @param uif device handle.
+ * @param func card function.
+ * @param addr register address.
+ * @param data the data read.
+ *
+ * @return 0 on success; or -ve on error with errno set.
+ */
+int LIBSDIOAPI sdio_read8(sdio_uif_t uif, int func, uint32_t addr, uint8_t *data);
+
+/**
+ * Write an 8 bit register.
+ *
+ * @param uif device handle.
+ * @param func card function.
+ * @param addr register address.
+ * @param data the data to write.
+ *
+ * @return 0 on success; or -ve on error with errno set.
+ */
+int LIBSDIOAPI sdio_write8(sdio_uif_t uif, int func, uint32_t addr, uint8_t data);
+
+/**
+ * Read a buffer from a 8 bit wide register/FIFO.
+ *
+ * The buffer read uses a fixed (not incrementing) address.
+ *
+ * \a block_size \e must be set to the value writted into \a func's
+ * I/O block size FBR register.
+ *
+ * If \a len % \a block_size == 0, a block mode transfer is used; a
+ * byte mode transfer is used if \a len < \a block_size.
+ *
+ * @param uif device handle.
+ * @param func card function.
+ * @param addr register/FIFO address.
+ * @param data buffer to store the data read.
+ * @param len length of data to read.
+ * @param block_size block size to use for this transfer.
+ *
+ * @return 0 on success; or -ve on error with errno set.
+ */
+int LIBSDIOAPI sdio_read(sdio_uif_t uif, int func, uint32_t addr, uint8_t *data,
+ size_t len, int block_size);
+
+/**
+ * Write a buffer to an 8 bit wide register/FIFO.
+ *
+ * The buffer write uses a fixed (not incrementing) address.
+ *
+ * \a block_size \e must be set to the value writted into \a func's
+ * I/O block size FBR register.
+ *
+ * If \a len % \a block_size == 0, a block mode transfer is used; a
+ * byte mode transfer is used if \a len < \a block_size.
+ *
+ * @param uif device handle.
+ * @param func card function.
+ * @param addr register/FIFO address.
+ * @param data buffer of data to write.
+ * @param len length of the data to write.
+ * @param block_size block size to use for this transfer.
+ *
+ * @return 0 on success; or -ve on error with errno set.
+ */
+int LIBSDIOAPI sdio_write(sdio_uif_t uif, int func, uint32_t addr, const uint8_t *data,
+ size_t len, int block_size);
+
+/**
+ * Read an 8 bit register, without waiting for completion.
+ *
+ * @param uif device handle.
+ * @param func card function.
+ * @param addr register address.
+ * @param data the data read.
+ * @param callback function to be called when the read completes.
+ * @param arg argument to be passed to callback.
+ *
+ * @return 0 on success; or -ve on error with errno set.
+ */
+int LIBSDIOAPI sdio_read8_async(sdio_uif_t uif, int func, uint32_t addr, uint8_t *data,
+ sdio_io_callback_t callback, void *arg);
+
+/**
+ * Write an 8 bit register, without waiting for completion.
+ *
+ * @param uif device handle.
+ * @param func card function.
+ * @param addr register address.
+ * @param data the data to write.
+ * @param callback function to be called when the write completes.
+ * @param arg argument to be passed to callback.
+ *
+ * @return 0 on success; or -ve on error with errno set.
+ */
+int LIBSDIOAPI sdio_write8_async(sdio_uif_t uif, int func, uint32_t addr, uint8_t data,
+ sdio_io_callback_t callback, void *arg);
+
+/**
+ * Read a buffer from a 8 bit wide register/FIFO, without waiting for
+ * completion.
+ *
+ * The buffer read uses a fixed (not incrementing) address.
+ *
+ * \a block_size \e must be set to the value writted into \a func's
+ * I/O block size FBR register.
+ *
+ * If \a len % \a block_size == 0, a block mode transfer is used; a
+ * byte mode transfer is used if \a len < \a block_size.
+ *
+ * @param uif device handle.
+ * @param func card function.
+ * @param addr register/FIFO address.
+ * @param data buffer to store the data read.
+ * @param len length of data to read.
+ * @param block_size block size to use for this transfer.
+ * @param callback function to be called when the read completes.
+ * @param arg argument to be passed to callback.
+ *
+ * @return 0 on success; or -ve on error with errno set.
+ */
+int LIBSDIOAPI sdio_read_async(sdio_uif_t uif, int func, uint32_t addr, uint8_t *data,
+ size_t len, int block_size,
+ sdio_io_callback_t callback, void *arg);
+
+/**
+ * Write a buffer to an 8 bit wide register/FIFO, without waiting for
+ * completion.
+ *
+ * The buffer write uses a fixed (not incrementing) address.
+ *
+ * \a block_size \e must be set to the value writted into \a func's
+ * I/O block size FBR register.
+ *
+ * If \a len % \a block_size == 0, a block mode transfer is used; a
+ * byte mode transfer is used if \a len < \a block_size.
+ *
+ * @param uif device handle.
+ * @param func card function.
+ * @param addr register/FIFO address.
+ * @param data buffer of data to write.
+ * @param len length of the data to write.
+ * @param block_size block size to use for this transfer.
+ * @param callback function to be called when the write completes.
+ * @param arg argument to be passed to callback.
+ *
+ * @return 0 on success; or -ve on error with errno set.
+ */
+int LIBSDIOAPI sdio_write_async(sdio_uif_t uif, int func, uint32_t addr, const uint8_t *data,
+ size_t len, int block_size,
+ sdio_io_callback_t callback, void *arg);
+/**
+ * Force a card removal and reinsertion.
+ *
+ * This will power cycle the card if the slot hardware supports power
+ * control.
+ *
+ * @note The device handle will no longer be valid.
+ *
+ * @param uif device handle.
+ *
+ * @return 0 on success; or -ve on error with errno set.
+ */
+int LIBSDIOAPI sdio_reinsert_card(sdio_uif_t uif);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+/*@}*/
+
+#endif /* #ifndef SDIOEMB_LIBSDIO_H */
--- /dev/null
+/*
+ * Linux helpers for slot drivers.
+ *
+ * Copyright (C) 2009 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef SDIOEMB_LINUX_H
+#define SDIOEMB_LINUX_H
+
+#include <sdioemb/slot_api.h>
+
+int sdioemb_linux_slot_register(struct sdioemb_slot *slot);
+
+#endif /* #ifndef SDIOEMB_LINUX_H */
--- /dev/null
+/*
+ * Standard SDIO definitions.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef SDIOEMB_SDIO_H
+#define SDIOEMB_SDIO_H
+
+/* Maximum time for VDD to rise to VDD min. */
+#define SDIO_POWER_UP_TIME_MS 250
+
+/* Minimum SD bus clock a card must support (Hz). */
+#define SDIO_CLOCK_FREQ_MIN 400000
+
+/* Maximum clock frequency for normal mode (Hz).
+ *
+ * Although high speed mode should be suitable for all speeds not all
+ * controller/card combinations are capable of meeting the higher
+ * tolerances for (e.g.) clock rise/fall times. Therefore, default
+ * mode is used where possible for improved compatibility. */
+#define SDIO_CLOCK_FREQ_NORMAL_SPD 25000000
+
+/* Maximum clock frequency for high speed mode (Hz). */
+#define SDIO_CLOCK_FREQ_HIGH_SPD 50000000
+
+#define SDIO_MAX_FUNCTIONS 8 /* incl. F0 */
+
+/* Command argument format. */
+
+#define SDIO_CMD52_ARG_WRITE 0x80000000
+#define SDIO_CMD52_ARG_FUNC(f) ((f) << 28)
+#define SDIO_CMD52_ARG_ADDR(a) ((a) << 9)
+#define SDIO_CMD52_ARG_DATA(d) ((d) << 0)
+
+#define SDIO_CMD53_ARG_WRITE 0x80000000
+#define SDIO_CMD53_ARG_FUNC(f) ((f) << 28)
+#define SDIO_CMD53_ARG_BLK_MODE 0x08000000
+#define SDIO_CMD53_ARG_ADDR(a) ((a) << 9)
+#define SDIO_CMD53_ARG_CNT(c) ((c) << 0)
+
+/* Response format. */
+
+#define SDIO_R5_DATA(r) (((r) >> 0) & 0xff)
+#define SDIO_R5_OUT_OF_RANGE (1 << 8)
+#define SDIO_R5_FUNCTION_NUMBER (1 << 9)
+#define SDIO_R5_ERROR (1 << 11)
+
+/* Register offsets and bits. */
+
+#define SDIO_OCR_CARD_READY 0x80000000
+#define SDIO_OCR_NUM_FUNCS_MASK 0x70000000
+#define SDIO_OCR_NUM_FUNCS_OFFSET 28
+#define SDIO_OCR_VOLTAGE_3V3 0x00300000 /* 3.2-3.3V & 3.3-3.4V */
+
+#define SDIO_CCCR_SDIO_REV 0x00
+#define SDIO_CCCR_SD_REV 0x01
+#define SDIO_CCCR_IO_EN 0x02
+#define SDIO_CCCR_IO_READY 0x03
+#define SDIO_CCCR_INT_EN 0x04
+# define SDIO_CCCR_INT_EN_MIE 0x01
+#define SDIO_CCCR_INT_PENDING 0x05
+#define SDIO_CCCR_IO_ABORT 0x06
+#define SDIO_CCCR_BUS_IFACE_CNTL 0x07
+# define SDIO_CCCR_BUS_IFACE_CNTL_CD_R_DISABLE 0x80
+# define SDIO_CCCR_BUS_IFACE_CNTL_ECSI 0x20
+# define SDIO_CCCR_BUS_IFACE_CNTL_4BIT_BUS 0x02
+#define SDIO_CCCR_CARD_CAPS 0x08
+# define SDIO_CCCR_CARD_CAPS_LSC 0x40
+# define SDIO_CCCR_CARD_CAPS_4BLS 0x80
+#define SDIO_CCCR_CIS_PTR 0x09
+#define SDIO_CCCR_BUS_SUSPEND 0x0c
+#define SDIO_CCCR_FUNC_SEL 0x0d
+#define SDIO_CCCR_EXEC_FLAGS 0x0e
+#define SDIO_CCCR_READY_FLAGS 0x0f
+#define SDIO_CCCR_F0_BLK_SIZE 0x10
+#define SDIO_CCCR_PWR_CNTL 0x12
+#define SDIO_CCCR_HIGH_SPEED 0x13
+# define SDIO_CCCR_HIGH_SPEED_SHS 0x01
+# define SDIO_CCCR_HIGH_SPEED_EHS 0x02
+
+#define SDIO_FBR_REG(f, r) (0x100*(f) + (r))
+
+#define SDIO_FBR_STD_IFACE(f) SDIO_FBR_REG(f, 0x00)
+#define SDIO_FBR_STD_IFACE_EXT(f) SDIO_FBR_REG(f, 0x01)
+#define SDIO_FBR_CIS_PTR(f) SDIO_FBR_REG(f, 0x09)
+#define SDIO_FBR_CSA_PTR(f) SDIO_FBR_REG(f, 0x0c)
+#define SDIO_FBR_CSA_DATA(f) SDIO_FBR_REG(f, 0x0f)
+#define SDIO_FBR_BLK_SIZE(f) SDIO_FBR_REG(f, 0x10)
+
+#define SDIO_STD_IFACE_UART 0x01
+#define SDIO_STD_IFACE_BT_TYPE_A 0x02
+#define SDIO_STD_IFACE_BT_TYPE_B 0x03
+#define SDIO_STD_IFACE_GPS 0x04
+#define SDIO_STD_IFACE_CAMERA 0x05
+#define SDIO_STD_IFACE_PHS 0x06
+#define SDIO_STD_IFACE_WLAN 0x07
+#define SDIO_STD_IFACE_BT_TYPE_A_AMP 0x09
+
+/*
+ * Manufacturer and card IDs.
+ */
+#define SDIO_MANF_ID_CSR 0x032a
+
+#define SDIO_CARD_ID_CSR_UNIFI_1 0x0001
+#define SDIO_CARD_ID_CSR_UNIFI_2 0x0002
+#define SDIO_CARD_ID_CSR_BC6 0x0004
+#define SDIO_CARD_ID_CSR_DASH_D00 0x0005
+#define SDIO_CARD_ID_CSR_BC7 0x0006
+#define SDIO_CARD_ID_CSR_CINDERELLA 0x0007
+#define SDIO_CARD_ID_CSR_UNIFI_3 0x0007
+#define SDIO_CARD_ID_CSR_UNIFI_4 0x0008
+#define SDIO_CARD_ID_CSR_DASH 0x0010
+
+#endif /* #ifndef SDIOEMB_SDIO_H */
--- /dev/null
+/*
+ * SDIO device driver API.
+ *
+ * Copyright (C) 2007-2008 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef _SDIO_API_H
+#define _SDIO_API_H
+
+/**
+ * @defgroup fdriver SDIO function driver API
+ *
+ * @brief The SDIO function driver API is used to implement drivers
+ * for SDIO card functions.
+ *
+ * Function drivers register with the SDIO driver core
+ * (sdio_register_driver()), listing which functions it supports and
+ * providing callback functions for card inserts, removes and
+ * interrupts.
+ *
+ * @par \anchor card_io_ops Card I/O operations:
+ *
+ * - \link sdioemb_read8(struct sdioemb_dev *, uint32_t, uint8_t *) sdioemb_read8()\endlink
+ * - \link sdioemb_read16(struct sdioemb_dev *, uint32_t, uint16_t *) sdioemb_read16()\endlink
+ * - \link sdioemb_write8(struct sdioemb_dev *, uint32_t, uint8_t) sdioemb_write8()\endlink
+ * - \link sdioemb_write16(struct sdioemb_dev *, uint32_t, uint16_t) sdioemb_write16()\endlink
+ * - \link sdioemb_f0_read8(struct sdioemb_dev *, uint32_t, uint8_t *) sdioemb_f0_read8()\endlink
+ * - \link sdioemb_f0_write8(struct sdioemb_dev *, uint32_t, uint8_t) sdioemb_f0_write8()\endlink
+ * - \link sdioemb_read(struct sdioemb_dev *, uint32_t, void *, size_t) sdioemb_read()\endlink
+ * - \link sdioemb_write(struct sdioemb_dev *, uint32_t, const void *, size_t) sdioemb_write()\endlink
+ */
+
+struct sdioemb_func_driver;
+struct sdioemb_dev;
+struct sdioemb_dev_priv;
+
+/**
+ * An SDIO device.
+ *
+ * Each SDIO card will have an sdio_dev for each function.
+ *
+ * None of the fields (except for drv_data) should be written.
+ *
+ * @ingroup fdriver
+ */
+struct sdioemb_dev {
+ struct sdioemb_func_driver *driver; /**< Function driver for this device. */
+ uint16_t vendor_id; /**< Vendor ID of the card. */
+ uint16_t device_id; /**< Device ID of the card. */
+ int function; /**< Function number of this device. */
+ uint8_t interface; /**< SDIO standard interface number. */
+ uint16_t max_blocksize; /**< Maximum block size supported. */
+ uint16_t blocksize; /**< Blocksize in use. */
+ int slot_id; /**< ID of the slot this card is inserted into. */
+ void * os_device; /**< Pointer to an OS-specific device structure. */
+ struct sdioemb_dev_priv *priv; /**< Data private to the SDIO core. */
+ void * drv_data; /**< Data private to the function driver. */
+};
+
+#define SDIOEMB_ANY_ID 0xffff
+#define SDIOEMB_UIF_FUNC 0
+#define SDIOEMB_ANY_FUNC 0xff
+#define SDIOEMB_ANY_IFACE 0xff
+
+/**
+ * An entry for an SDIO device ID table.
+ *
+ * Functions are matched to drivers using any combination of vendor
+ * ID, device ID, function number or standard interface.
+ *
+ * Matching on #function == SDIOEMB_UIF_FUNC is reserved for the SDIO
+ * Userspace Interface driver. Card management drivers can match on
+ * #function == 0, these will be probed before any function drivers.
+ *
+ * @ingroup fdriver
+ */
+struct sdioemb_id_table {
+ uint16_t vendor_id; /**< Vendor ID to match or SDIOEMB_ANY_ID */
+ uint16_t device_id; /**< Device ID to match or SDIOEMB_ANY_ID */
+ int function; /**< Function number to match or SDIOEMB_ANY_FUNC */
+ uint8_t interface; /**< SDIO standard interface to match or SDIOEMB_ANY_IFACE */
+};
+
+/**
+ * A driver for an SDIO function.
+ *
+ * @ingroup fdriver
+ */
+struct sdioemb_func_driver {
+ /**
+ * Driver name used in diagnostics.
+ */
+ const char *name;
+
+ /**
+ * 0 terminated array of functions supported by this device.
+ *
+ * The driver may (for example) match on a number of vendor
+ * ID/device ID/function number triplets or on an SDIO standard
+ * interface.
+ */
+ struct sdioemb_id_table *id_table;
+
+ /**
+ * Called by the core when an inserted card has functions which
+ * match those listed in id_table.
+ *
+ * The driver's implementation should (if required):
+ *
+ * - perform any additional probing
+ * - do function specific initialization
+ * - allocate and register any function/OS specific devices or interfaces.
+ *
+ * Called in: thread context.
+ *
+ * @param fdev the newly inserted device.
+ *
+ * @return 0 on success; -ve on error.
+ */
+ int (*probe)(struct sdioemb_dev *fdev);
+
+ /**
+ * Called by the core when a card is removed. This is only called
+ * if the probe() call succeeded.
+ *
+ * The driver's implementation should (if required);
+ *
+ * - do any function specific shutdown.
+ * - cleanup any data structures created/registers during probe().
+ *
+ * Called in: thread context.
+ *
+ * @param fdev the device being removed.
+ */
+ void (*remove)(struct sdioemb_dev *fdev);
+
+ /**
+ * Called by the core to signal an SDIO interrupt for this card
+ * occurs, if interrupts have been enabled with
+ * sdioemb_interrupt_enable().
+ *
+ * The driver's implementation should signal a thread (or similar)
+ * to actually handle the interrupt as no card I/O may be
+ * performed whilst in interrupt context. When the interrupt is
+ * handled, the driver should call sdioemb_interrupt_acknowledge() to
+ * enable further interrupts to be signalled.
+ *
+ * Called in: interrupt context.
+ *
+ * @param fdev the device which may have raised the interrupt.
+ */
+ void (*card_int_handler)(struct sdioemb_dev *fdev);
+
+ /**
+ * Called by the core to signal a suspend power management
+ * event occured.
+ *
+ * The driver's implementation should (if required)
+ * set the card to a low power mode and return as soon
+ * as possible. After this function returns, the
+ * driver should not start any SDIO commands.
+ *
+ * Called in: thread context.
+ *
+ * @param fdev the device handler.
+ */
+ void (*suspend)(struct sdioemb_dev *fdev);
+
+ /**
+ * Called by the core to signal a resume power management
+ * event occured.
+ *
+ * The driver's implementation should (if required)
+ * initialise the card to an operational mode and return
+ * as soon as possible. If the card has been powered off
+ * during suspend, the driver would have to initialise
+ * the card from scratch (f/w download, h/w initialisation, etc.).
+ *
+ * Called in: thread context.
+ *
+ * @param fdev the device handler.
+ */
+ void (*resume)(struct sdioemb_dev *fdev);
+};
+
+int sdioemb_driver_register(struct sdioemb_func_driver *fdriver);
+void sdioemb_driver_unregister(struct sdioemb_func_driver *fdriver);
+
+int sdioemb_driver_probe(struct sdioemb_func_driver *fdriver, struct sdioemb_dev *fdev);
+void sdioemb_driver_remove(struct sdioemb_func_driver *fdriver, struct sdioemb_dev *fdev);
+
+/* For backward compatibility. */
+#define sdio_register_driver sdioemb_driver_register
+#define sdio_unregister_driver sdioemb_driver_unregister
+
+int sdioemb_set_block_size(struct sdioemb_dev *fdev, uint16_t blksz);
+void sdioemb_set_max_bus_freq(struct sdioemb_dev *fdev, int max_freq);
+int sdioemb_set_bus_width(struct sdioemb_dev *fdev, int bus_width);
+
+int sdioemb_enable_function(struct sdioemb_dev *fdev);
+int sdioemb_disable_function(struct sdioemb_dev *fdev);
+int sdioemb_reenable_csr_function(struct sdioemb_dev *dev);
+void sdioemb_idle_function(struct sdioemb_dev *fdev);
+
+int sdioemb_read8(struct sdioemb_dev *fdev, uint32_t addr, uint8_t *val);
+int sdioemb_read16(struct sdioemb_dev *fdev, uint32_t addr, uint16_t *val);
+int sdioemb_write8(struct sdioemb_dev *fdev, uint32_t addr, uint8_t val);
+int sdioemb_write16(struct sdioemb_dev *fdev, uint32_t addr, uint16_t val);
+int sdioemb_f0_read8(struct sdioemb_dev *fdev, uint32_t addr, uint8_t *val);
+int sdioemb_f0_write8(struct sdioemb_dev *fdev, uint32_t addr, uint8_t val);
+int sdioemb_read(struct sdioemb_dev *fdev, uint32_t addr, void *data, size_t len);
+int sdioemb_write(struct sdioemb_dev *fdev, uint32_t addr, const void *data, size_t len);
+
+int sdioemb_hard_reset(struct sdioemb_dev *fdev);
+
+void sdioemb_power_on(struct sdioemb_dev *fdev);
+void sdioemb_power_off(struct sdioemb_dev *fdev);
+
+int sdioemb_interrupt_enable(struct sdioemb_dev *fdev);
+int sdioemb_interrupt_disable(struct sdioemb_dev *fdev);
+void sdioemb_interrupt_acknowledge(struct sdioemb_dev *fdev);
+
+int sdioemb_cis_get_tuple(struct sdioemb_dev *fdev, uint8_t tuple,
+ void *buf, size_t len);
+
+void sdioemb_suspend_function(struct sdioemb_dev *fdev);
+void sdioemb_resume_function(struct sdioemb_dev *fdev);
+
+/**
+ * SDIO command status.
+ *
+ * @ingroup fdriver
+ */
+enum sdioemb_cmd_status {
+ SDIOEMB_CMD_OK = 0x00, /**< Command successful. */
+
+ SDIOEMB_CMD_ERR_CMD = 0x01,
+ SDIOEMB_CMD_ERR_DAT = 0x02,
+
+ SDIOEMB_CMD_ERR_CRC = 0x10,
+ SDIOEMB_CMD_ERR_TIMEOUT = 0x20,
+ SDIOEMB_CMD_ERR_OTHER = 0x40,
+
+ SDIOEMB_CMD_ERR_CMD_CRC = SDIOEMB_CMD_ERR_CMD | SDIOEMB_CMD_ERR_CRC, /**< Response CRC error. */
+ SDIOEMB_CMD_ERR_CMD_TIMEOUT = SDIOEMB_CMD_ERR_CMD | SDIOEMB_CMD_ERR_TIMEOUT, /**< Response time out. */
+ SDIOEMB_CMD_ERR_CMD_OTHER = SDIOEMB_CMD_ERR_CMD | SDIOEMB_CMD_ERR_OTHER, /**< Other response error. */
+ SDIOEMB_CMD_ERR_DAT_CRC = SDIOEMB_CMD_ERR_DAT | SDIOEMB_CMD_ERR_CRC, /**< Data CRC error. */
+ SDIOEMB_CMD_ERR_DAT_TIMEOUT = SDIOEMB_CMD_ERR_DAT | SDIOEMB_CMD_ERR_TIMEOUT, /**< Data receive time out. */
+ SDIOEMB_CMD_ERR_DAT_OTHER = SDIOEMB_CMD_ERR_DAT | SDIOEMB_CMD_ERR_OTHER, /**< Other data error. */
+
+ SDIOEMB_CMD_ERR_NO_CARD = 0x04, /**< No card present. */
+
+ SDIOEMB_CMD_IN_PROGRESS = 0xff, /**< Command still in progress. */
+};
+
+/**
+ * A response to an SDIO command.
+ *
+ * For R1, R4, R5, and R6 responses only the middle 32 bits of the
+ * response are stored, the leading octet (start and direction bits
+ * and command index) and trailing octet (CRC and stop bit) are
+ * discarded.
+ *
+ * @bug R2 and R3 responses are not used by SDIO and are not
+ * supported.
+ *
+ * @ingroup fdriver
+ */
+union sdioemb_response {
+ uint32_t r1;
+ uint32_t r4;
+ uint32_t r5;
+ uint32_t r6;
+};
+
+/**
+ * SDIO command parameters and response.
+ */
+struct sdioemb_cmd_resp {
+ uint8_t cmd; /**< Command index (0 to 63). */
+ uint32_t arg; /**< Command argument. */
+ union sdioemb_response response; /**< Response to the command. Valid
+ iff the command has completed and
+ (sdio_cmd::status & SDIOEMB_CMD_ERR_CMD) == 0.*/
+};
+
+/**
+ * CSPI command parameters and response.
+ */
+struct cspi_cmd_resp {
+ unsigned cmd : 8; /**< Command octet (type, and function). */
+ unsigned addr: 24; /**< 24 bit address. */
+ uint16_t val; /**< Word to write or read from the card (for non-burst commands). */
+ uint8_t response; /**< Response octet. Valid iff the command has completed and
+ (sdio_cmd::status & SDIOEMB_CMD_ERR_CMD) == 0. */
+};
+
+
+/**
+ * An SDIO command, its status and response.
+ *
+ * sdio_cmd is used to submit SDIO commands to a device and return its
+ * status and any response or data.
+ *
+ * @ingroup fdriver
+ */
+struct sdioemb_cmd {
+ /**
+ * The SDIO device which submitted the command. Set by the
+ * core.
+ */
+ struct sdioemb_dev *owner;
+
+ /**
+ * Called by the core when the command has been completed.
+ *
+ * Called in: interrupt context.
+ *
+ * @param cmd the completed command.
+ */
+ void (*callback)(struct sdioemb_cmd *cmd);
+
+ /**
+ * Set of flags specifying the response type, data transfer
+ * direction and other parameters.
+ *
+ * For SDIO commands set at least one of the response types:
+ * - #SDIOEMB_CMD_FLAG_RESP_NONE
+ * - #SDIOEMB_CMD_FLAG_RESP_R1
+ * - #SDIOEMB_CMD_FLAG_RESP_R1B
+ * - #SDIOEMB_CMD_FLAG_RESP_R2
+ * - #SDIOEMB_CMD_FLAG_RESP_R3
+ * - #SDIOEMB_CMD_FLAG_RESP_R4
+ * - #SDIOEMB_CMD_FLAG_RESP_R5
+ * - #SDIOEMB_CMD_FLAG_RESP_R5B
+ * - #SDIOEMB_CMD_FLAG_RESP_R6
+ *
+ * and any of the additional flags:
+ * - #SDIOEMB_CMD_FLAG_READ
+ *
+ * For CSPI commands set:
+ * - #SDIOEMB_CMD_FLAG_CSPI
+ */
+ unsigned flags;
+
+ /**
+ * SDIO command parameters and response.
+ *
+ * Valid only if #SDIOEMB_CMD_FLAG_CSPI is \e not set in #flags.
+ */
+ struct sdioemb_cmd_resp sdio;
+
+ /**
+ * CSPI command parameters and response.
+ *
+ * Valid only if #SDIOEMB_CMD_FLAG_CSPI is set in #flags.
+ */
+ struct cspi_cmd_resp cspi;
+
+ /**
+ * Buffer of data to read or write.
+ *
+ * Must be set to NULL if the command is not a data transfer.
+ */
+ uint8_t *data;
+
+ /**
+ * Length of #data in octets.
+ *
+ * len must be either: less than the device's sdio_dev::blocksize;
+ * or a multiple of the device's sdio_dev::blocksize.
+ */
+ size_t len;
+
+ /**
+ * Status of the command after it has completed.
+ */
+ enum sdioemb_cmd_status status;
+
+ /**
+ * Data private to caller of sdioemb_start_cmd().
+ */
+ void *priv;
+};
+
+/** @addtogroup fdriver
+ *@{*/
+#define SDIOEMB_CMD_FLAG_RESP_NONE 0x00 /**< No response. */
+#define SDIOEMB_CMD_FLAG_RESP_R1 0x01 /**< R1 response. */
+#define SDIOEMB_CMD_FLAG_RESP_R1B 0x02 /**< R1b response. */
+#define SDIOEMB_CMD_FLAG_RESP_R2 0x03 /**< R2 response. */
+#define SDIOEMB_CMD_FLAG_RESP_R3 0x04 /**< R3 response. */
+#define SDIOEMB_CMD_FLAG_RESP_R4 0x05 /**< R4 response. */
+#define SDIOEMB_CMD_FLAG_RESP_R5 0x06 /**< R5 response. */
+#define SDIOEMB_CMD_FLAG_RESP_R5B 0x07 /**< R5b response. */
+#define SDIOEMB_CMD_FLAG_RESP_R6 0x08 /**< R6 response. */
+#define SDIOEMB_CMD_FLAG_RESP_MASK 0xff /**< Mask for response type. */
+#define SDIOEMB_CMD_FLAG_RAW 0x0100 /**< @internal Bypass the command queues. */
+#define SDIOEMB_CMD_FLAG_READ 0x0200 /**< Data transfer is a read, not a write. */
+#define SDIOEMB_CMD_FLAG_CSPI 0x0400 /**< CSPI transfer, not SDIO or SDIO-SPI. */
+#define SDIOEMB_CMD_FLAG_ABORT 0x0800 /**< Data transfer abort command. */
+/*@}*/
+
+int sdioemb_start_cmd(struct sdioemb_dev *fdev, struct sdioemb_cmd *cmd);
+
+#endif /* #ifndef _SDIO_API_H */
--- /dev/null
+/*
+ * SDIO Bluetooth Type-A interface definitions.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef SDIOEMB_SDIO_BT_A_H
+#define SDIOEMB_SDIO_BT_A_H
+
+#include <sdioemb/sdio_csr.h>
+#include <csr_sdio.h>
+
+/*
+ * Standard SDIO function registers for a Bluetooth Type-A interface.
+ */
+#define SDIO_BT_A_RD 0x00
+#define SDIO_BT_A_TD 0x00
+
+#define SDIO_BT_A_RX_PKT_CTRL 0x10
+# define PC_RRT 0x01
+
+#define SDIO_BT_A_TX_PKT_CTRL 0x11
+# define PC_WRT 0x01
+
+#define SDIO_BT_A_RETRY_CTRL 0x12
+# define RTC_STAT 0x01
+# define RTC_SET 0x01
+
+#define SDIO_BT_A_INTRD 0x13
+# define INTRD 0x01
+# define CL_INTRD 0x01
+
+#define SDIO_BT_A_INT_EN 0x14
+# define EN_INTRD 0x01
+
+#define SDIO_BT_A_BT_MODE 0x20
+# define MD_STAT 0x01
+
+/*
+ * Length of the Type-A header.
+ *
+ * Packet length (3 octets) plus Service ID (1 octet).
+ */
+#define SDIO_BT_A_HEADER_LEN 4
+
+/*
+ * Maximum length of a Type-A transport packet.
+ *
+ * Type-A header length and maximum length of a HCI packet (65535
+ * octets).
+ */
+#define SDIO_BT_A_PACKET_LEN_MAX 65543
+
+enum sdioemb_bt_a_service_id {
+ SDIO_BT_A_SID_CMD = 0x01,
+ SDIO_BT_A_SID_ACL = 0x02,
+ SDIO_BT_A_SID_SCO = 0x03,
+ SDIO_BT_A_SID_EVT = 0x04,
+ SDIO_BT_A_SID_VENDOR = 0xfe,
+};
+
+static __inline int sdioemb_bt_a_packet_len(const char *p)
+{
+ return (p[0] & 0xff) | ((p[1] & 0xff) << 8) | ((p[2] & 0xff) << 16);
+}
+
+static __inline int sdioemb_bt_a_service_id(const char *p)
+{
+ return p[3];
+}
+
+/*
+ * Minimum amount to read (including the Type-A header). This allows
+ * short packets (e.g., flow control packets) to be read with a single
+ * command.
+ */
+#define SDIO_BT_A_MIN_READ 32
+
+#define SDIO_BT_A_NAME_LEN 16
+
+struct sdioemb_bt_a_dev {
+ CsrSdioFunction *func;
+ char name[SDIO_BT_A_NAME_LEN];
+ void *drv_data;
+
+ /**
+ * Get a buffer to receive a packet into.
+ *
+ * @param bt the BT device.
+ * @param header a buffer of length #SDIO_BT_A_MIN_READ containing
+ * (part of) the packet the buffer is for. It will contain
+ * the Type-A header and as much of the payload that will
+ * fit.
+ * @param buffer_min_len the minimum length of buffer required to
+ * receive the whole packet. This includes space for padding
+ * the read to a whole number of blocks (if more than 512
+ * octets is still to be read).
+ * @param buffer returns the buffer. The packet (including the
+ * Type-A header will be placed at the beginning of this
+ * buffer.
+ * @param buffer_handle returns a buffer handle passed to the
+ * subsequent call of the receive() callback.
+ *
+ * @return 0 if a buffer was provided.
+ * @return -ENOMEM if no buffer could be provided.
+ */
+ int (*get_rx_buffer)(struct sdioemb_bt_a_dev *bt, const uint8_t *header,
+ size_t buffer_min_len, uint8_t **buffer, void **buffer_handle);
+ void (*receive)(struct sdioemb_bt_a_dev *bt, void *buffer_handle, int status);
+ void (*sleep_state_changed)(struct sdioemb_bt_a_dev *bt);
+
+ enum sdio_sleep_state sleep_state;
+
+ uint8_t max_tx_retries;
+ uint8_t max_rx_retries;
+ unsigned needs_read_ack:1;
+ unsigned wait_for_firmware:1;
+
+ unsigned rx_off:1;
+
+ /**
+ * A buffer to read the packet header into before the real buffer
+ * is requested with the get_rx_buffer() callback.
+ *
+ * @internal
+ */
+ uint8_t *header;
+};
+
+int sdioemb_bt_a_setup(struct sdioemb_bt_a_dev *bt, CsrSdioFunction *func);
+void sdioemb_bt_a_cleanup(struct sdioemb_bt_a_dev *bt);
+int sdioemb_bt_a_send(struct sdioemb_bt_a_dev *bt, const uint8_t *packet, size_t len);
+void sdioemb_bt_a_handle_interrupt(struct sdioemb_bt_a_dev *bt);
+void sdioemb_bt_a_set_sleep_state(struct sdioemb_bt_a_dev *bt, enum sdio_sleep_state state);
+int sdioemb_bt_a_check_for_reset(struct sdioemb_bt_a_dev *bt);
+void sdioemb_bt_a_start(struct sdioemb_bt_a_dev *bt);
+void sdioemb_bt_a_stop(struct sdioemb_bt_a_dev *bt);
+void sdioemb_bt_a_rx_on(struct sdioemb_bt_a_dev *bt);
+void sdioemb_bt_a_rx_off(struct sdioemb_bt_a_dev *bt);
+
+#endif /* #ifndef SDIOEMB_SDIO_BT_A_H */
--- /dev/null
+/*
+ * SDIO CIS definitions.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef _SDIO_CIS_H
+#define _SDIO_CIS_H
+
+#define CISTPL_NULL 0x00
+#define CISTPL_CHECKSUM 0x10
+#define CISTPL_VERS_1 0x15
+#define CISTPL_ALTSTR 0x16
+#define CISTPL_MANFID 0x20
+# define CISTPL_MANFID_SIZE 0x04
+#define CISTPL_FUNCID 0x21
+#define CISTPL_FUNCE 0x22
+#define CISTPL_SDIO_STD 0x91
+#define CISTPL_SDIO_EXT 0x92
+#define CISTPL_END 0xff
+#define CISTPL_FUNCE 0x22
+# define CISTPL_FUNCE_00_SIZE 0x04
+# define CISTPL_FUNCE_01_SIZE 0x2a
+
+#endif /* #ifndef _SDIO_CIS_H */
--- /dev/null
+/*
+ * CSR specific SDIO registers.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef SDIOEMB_SDIO_CSR_H
+#define SDIOEMB_SDIO_CSR_H
+
+/**
+ * @defgroup registers CSR specific SDIO registers
+ *
+ * Registers at 0xF0 - 0xFF in the CCCR are reserved for vendor
+ * specific registers. The registers documented here are specific to
+ * following CSR chips:
+ *
+ * - BlueCore (6 and later)
+ * - UltraCore
+ *@{
+ */
+
+/**
+ * Interrupt status/host wakeup register.
+ *
+ * This controls a function's deep sleep state.
+ *
+ * @see enum sdio_sleep_state
+ */
+#define SDIO_CSR_SLEEP_STATE 0xf0
+# define SDIO_CSR_SLEEP_STATE_FUNC(f) ((f) << 4)
+# define SDIO_CSR_SLEEP_STATE_RDY_INT_EN 0x02
+# define SDIO_CSR_SLEEP_STATE_WAKE_REQ 0x01
+
+/**
+ * Host interrupt clear register.
+ *
+ * Writing a 1 to bit 0 clears an SDIO interrupt raised by a generic
+ * function.
+ */
+#define SDIO_CSR_HOST_INT 0xf1
+# define SDIO_CSR_HOST_INT_CL 0x01
+
+/**
+ * From host scratch register 0.
+ *
+ * A read/write register that can be used for signalling between the
+ * host and the chip.
+ *
+ * The usage of this register depends on the version of the chip or
+ * firmware.
+ */
+#define SDIO_CSR_FROM_HOST_SCRATCH0 0xf2
+
+/**
+ * From host scratch register 1.
+ *
+ * @see SDIO_CSR_FROM_HOST_SCRATCH0
+ */
+#define SDIO_CSR_FROM_HOST_SCRATCH1 0xf3
+
+/**
+ * To host scratch register 0.
+ *
+ * A read only register that may be used for signalling between the
+ * chip and the host.
+ *
+ * The usage of this register depends on the version of the chip or
+ * firmware.
+ */
+#define SDIO_CSR_TO_HOST_SCRATCH0 0xf4
+
+/**
+ * To host scratch register 1.
+ *
+ * @see SDIO_CSR_TO_HOST_SCRATCH0
+ */
+#define SDIO_CSR_TO_HOST_SCRATCH1 0xf5
+
+/**
+ * Extended I/O enable.
+ *
+ * Similar to the standard CCCR I/O Enable register, this is used to
+ * detect if an internal reset of a function has occured and
+ * (optionally) reenable it.
+ *
+ * An internal reset is detected by CCCR I/O Enable bit being set and
+ * the corresponding EXT_IO_EN bit being clear.
+ */
+#define SDIO_CSR_EXT_IO_EN 0xf6
+
+/**
+ * Deep sleep states as set via the sleep state register.
+ *
+ * These states are used to control when the chip may go into a deep
+ * sleep (a low power mode).
+ *
+ * Since a chip in deep sleep may not respond to SDIO commands, the
+ * host should ensure that the chip is not in deep sleep before
+ * attempting SDIO commands to functions 1 to 7.
+ *
+ * The available states are:
+ *
+ * AWAKE - chip must not enter deep sleep and should exit deep sleep
+ * if it's currently sleeping.
+ *
+ * TORPID - chip may enter deep sleep.
+ *
+ * DROWSY - a transition state between TORPID and AWAKE. This is
+ * AWAKE plus the chip asserts an interrupt when the chip is awake.
+ *
+ * @see SDIO_CSR_SLEEP_STATE
+ */
+enum sdio_sleep_state {
+ SLEEP_STATE_AWAKE = SDIO_CSR_SLEEP_STATE_WAKE_REQ,
+ SLEEP_STATE_DROWSY = SDIO_CSR_SLEEP_STATE_WAKE_REQ | SDIO_CSR_SLEEP_STATE_RDY_INT_EN,
+ SLEEP_STATE_TORPID = 0x00,
+};
+
+/*@}*/
+
+/*
+ * Generic function registers (with byte addresses).
+ */
+
+/*
+ * SDIO_MODE is chip dependant, see the sdio_mode table in sdio_cspi.c
+ * to add support for new chips.
+ */
+#define SDIO_MODE /* chip dependant */
+# define SDIO_MODE_CSPI_EN 0x40
+
+#endif /* SDIOEMB_SDIO_CSR_H */
--- /dev/null
+/*
+ * Slot driver API.
+ *
+ * Copyright (C) 2007-2009 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef _SLOT_API_H
+#define _SLOT_API_H
+
+#include <sdioemb/sdio_api.h>
+
+struct sdioemb_slot;
+
+/**
+ * @defgroup sdriver SDIO slot driver API
+ *
+ * @brief The SDIO slot driver API provides an interface for the SDIO
+ * layer to driver an SDIO slot (socket).
+ *
+ * Slot drivers register with the SDIO layer (sdioemb_slot_register()),
+ * providing functions to starting commands, enabling/disable card
+ * interrupts, card detection and bus power control.
+ *
+ * Functions are provided to notify the SDIO layer when a command has
+ * completed (sdioemb_cmd_complete()) and when an SDIO card interrupt has
+ * occurred (sdioemb_interrupt()).
+ */
+
+#define SDIOEMB_BUS_FREQ_OFF 0
+#define SDIOEMB_BUS_FREQ_DEFAULT -1
+#define SDIOEMB_BUS_FREQ_IDLE -2
+
+/**
+ * Valid SDIO bus voltage levels.
+ *
+ * @ingroup sdriver
+ */
+enum sdioemb_power {
+ SDIOEMB_POWER_OFF = 0, /**< Power switched off. */
+ SDIOEMB_POWER_3V3 = 33, /**< Voltage set to 3.3V. */
+};
+
+/**
+ * SDIO slot capabilities.
+ *
+ * @ingroup sdriver
+ */
+struct slot_caps {
+ int max_bus_freq; /**< Maximum bus frequency (Hz). */
+ int max_bus_width; /**< Maximum bus width supported (1 or 4 data lines). */
+ uint8_t cspi_mode; /**< CSPI_MODE register value (for CSPI capable slots). */
+};
+
+/**
+ * Controller hardware type.
+ *
+ * @ingroup sdriver
+ */
+enum slot_controller_type {
+ SDIOEMB_SLOT_TYPE_SD = 0, /**< SD/SDIO controller. */
+ SDIOEMB_SLOT_TYPE_SPI, /**< SPI controller. */
+ SDIOEMB_SLOT_TYPE_SPI_CSPI, /**< SPI controller capable of CSPI. */
+};
+
+/**
+ * Return values from the add_function() notifier.
+ *
+ * @ingroup sdriver
+ */
+enum sdioemb_add_func_status {
+ /**
+ * The core will call sdioemb_add_function().
+ */
+ SDIOEMB_ADD_FUNC_NOW = 0,
+ /**
+ * The slot driver will call sdioemb_add_function() or the
+ * function driver will call sdioemb_driver_probe() directly.
+ */
+ SDIOEMB_ADD_FUNC_DEFERRED = 1,
+};
+
+/**
+ * Slot/card event notifiers.
+ *
+ * A slot driver may be notified when certain slot or card events
+ * occur.
+ *
+ * @ingroup sdriver
+ */
+struct sdioemb_slot_notifiers {
+ /**
+ * This is called when a card function has been enumerated
+ * and initialized but before can be bound to a function driver.
+ *
+ * A slot driver may use this to create an OS-specific object for
+ * the function. The slot driver must either (a) return
+ * SDIOEMB_ADD_FUNC_NOW; (b) return SDIOEMB_ADD_FUNC_DEFERRED and
+ * call sdioemb_add_function() later on; (c) return
+ * SDIOEMB_ADD_FUNC_DEFERRED and pass the fdev to the function
+ * driver for it to call sdioemb_driver_probe() directly; or (d)
+ * return an error.
+ *
+ * The slot driver may need to get a reference to the fdev with
+ * sdioemb_get_function() if the lifetime of the OS-specific
+ * object extends beyond the subsequent return of the
+ * del_function() callback.
+ *
+ * If this is non-NULL the slot driver must also provide
+ * del_function().
+ *
+ * @param slot the SDIO slot producing the notification.
+ * @param fdev the SDIO function being added.
+ *
+ * @return SDIOEMB_ADD_FUNC_NOW if the function is ready for use.
+ * @return SDIOEMB_ADD_FUNC_DEFERRED if sdioemb_add_function() or
+ * sdioemb_driver_probe() will be called later.
+ * @return -ve on a error.
+ */
+ int (*add_function)(struct sdioemb_slot *slot, struct sdioemb_dev *fdev);
+
+ /**
+ * This is called when a card function is being removed and after
+ * any function driver has been unbound.
+ *
+ * A slot driver may use this to delete any OS-specific object
+ * created by the add_function() notifier.
+ *
+ * @param slot the SDIO slot producing the notification.
+ * @param fdev the SDIO function being deleted.
+ */
+ void (*del_function)(struct sdioemb_slot *slot, struct sdioemb_dev *fdev);
+};
+
+struct sdioemb_slot_priv;
+
+/**
+ * An SDIO slot driver.
+ *
+ * Allocate and free with sdioemb_slot_alloc() and sdioemb_slot_free().
+ *
+ * @ingroup sdriver
+ */
+struct sdioemb_slot {
+ /**
+ * Name of the slot used in diagnostic messages.
+ *
+ * This would typically include the name of the SDIO controller
+ * and the slot number if the controller has multiple slots.
+ *
+ * This will be set by sdioemb_slot_register() if it is left as an
+ * empty string.
+ */
+ char name[64];
+
+ /**
+ * Controller hardware type.
+ */
+ enum slot_controller_type type;
+
+ /**
+ * Set the SD bus clock frequency.
+ *
+ * The driver's implementation should set the SD bus clock to not
+ * more than \a clk Hz (unless \a clk is equal to
+ * #SDIOEMB_BUS_FREQ_OFF or #SDIOEMB_BUS_FREQ_IDLE).
+ *
+ * If \a clk == SDIOEMB_BUS_FREQ_OFF the clock should be stopped.
+ *
+ * \a clk == SDIOEMB_BUS_FREQ_IDLE indicates that the bus is idle
+ * (currently unused) and the host controller may slow (or stop)
+ * the SD bus clock to save power on the card. During this idle
+ * state the host controller must be capable of receiving SDIO
+ * interrupts (for certain host controllers this may require
+ * leaving the clock running).
+ *
+ * If \a clk is greater than #SDIO_CLOCK_FREQ_NORMAL_SPD (25 MHz)
+ * subsequent commands should be done with the controller in high
+ * speed mode.
+ *
+ * Called from: interrupt context.
+ *
+ * @param slot the slot to configure.
+ * @param clk new SD bus clock frequency in Hz, SDIOEMB_BUS_FREQ_OFF
+ * or SDIOEMB_BUS_FREQ_IDLE.
+ *
+ * @return The bus frequency actually configured in Hz.
+ */
+ int (*set_bus_freq)(struct sdioemb_slot *slot, int clk);
+
+ /**
+ * Set the SD bus width.
+ *
+ * The driver's implementation should set the width of the SD bus
+ * for all subsequent data transfers to the specified value.
+ *
+ * This may be NULL if the driver sets the bus width when starting
+ * a command, or the driver is for an SDIO-SPI or CSPI controller.
+ *
+ * Called from: thread context.
+ *
+ * @param slot the slot to configure.
+ * @param bus_width new SD bus width (either 1 or 4).
+ *
+ * @return 0 on success.
+ * @return -ve if a low-level error occured when setting the bus width.
+ */
+ int (*set_bus_width)(struct sdioemb_slot *slot, int bus_width);
+
+ /**
+ * Start an SDIO command.
+ *
+ * The driver's implementation should:
+ *
+ * - set the controller's bus width to #bus_width,
+ * - program the controller to start the command.
+ *
+ * Called from: interrupt context.
+ *
+ * @param slot slot to perform the command.
+ * @param cmd SDIO command to start.
+ */
+ int (*start_cmd)(struct sdioemb_slot *slot, struct sdioemb_cmd *cmd);
+
+ /**
+ * Detect if a card is inserted into the slot.
+ *
+ * Called from: thread context.
+ *
+ * @param slot slot to check.
+ *
+ * @return non-zero if a card is inserted; 0 otherwise.
+ */
+ int (*card_present)(struct sdioemb_slot *slot);
+
+ /**
+ * Switch on/off the SDIO bus power and set the SDIO bus voltage.
+ *
+ * Called from: thread context.
+ *
+ * @param slot the slot.
+ * @param power the requested voltage.
+ *
+ * @return 0 on success; -ve on error: -EINVAL - requested voltage
+ * is not supported.
+ */
+ int (*card_power)(struct sdioemb_slot *slot, enum sdioemb_power power);
+
+ /**
+ * Enable (unmask) the SDIO card interrupt on the controller.
+ *
+ * Called from: interrupt context.
+ *
+ * @param slot the slot to enable the interrupt on..
+ */
+ void (*enable_card_int)(struct sdioemb_slot *slot);
+
+ /**
+ * Disable (mask) the SDIO card interrupt on the controller.
+ *
+ * Called from: thread context.
+ *
+ * @param slot the slot to disable the interrupt on.
+ */
+ void (*disable_card_int)(struct sdioemb_slot *slot);
+
+ /**
+ * Perform a hard reset of the card.
+ *
+ * Hard resets can be achieved in two ways:
+ *
+ * -# Power cycle (if the slot has power control).
+ * -# Platform-specific assertion of a card/chip reset line.
+ *
+ * If hard resets are not supported, either return 0 or set
+ * hard_reset to NULL.
+ *
+ * @param slot the slot for the card to reset.
+ *
+ * @return 0 if a hard reset was performed.
+ * @return 1 if hard resets are not supported.
+ */
+ int (*hard_reset)(struct sdioemb_slot *slot);
+
+ struct slot_caps caps; /**< Slot capabilities. */
+ int clock_freq; /**< SD bus frequency requested by the SDIO layer. */
+ int bus_width; /**< Bus width requested by the SDIO layer. */
+ struct sdioemb_slot_notifiers notifs; /**< Slot event notifiers. */
+ int cspi_reg_pad; /**< Padding for CSPI register reads. */
+ int cspi_burst_pad; /**< Padding for CSPI burst reads. */
+ struct sdioemb_slot_priv *priv; /**< Data private to the SDIO layer. */
+ void * drv_data; /**< Data private to the slot driver. */
+};
+
+struct sdioemb_slot *sdioemb_slot_alloc(size_t drv_data_size);
+void sdioemb_slot_free(struct sdioemb_slot *slot);
+int sdioemb_slot_register(struct sdioemb_slot *slot);
+void sdioemb_slot_unregister(struct sdioemb_slot *slot);
+int sdioemb_card_inserted(struct sdioemb_slot *slot);
+void sdioemb_card_removed(struct sdioemb_slot *slot);
+void sdioemb_interrupt(struct sdioemb_slot *slot);
+void sdioemb_cmd_complete(struct sdioemb_slot *slot, struct sdioemb_cmd *cmd);
+
+void sdioemb_suspend(struct sdioemb_slot *slot);
+void sdioemb_resume(struct sdioemb_slot *slot);
+
+void sdioemb_add_function(struct sdioemb_dev *fdev);
+void sdioemb_del_function(struct sdioemb_dev *fdev);
+void sdioemb_get_function(struct sdioemb_dev *fdev);
+void sdioemb_put_function(struct sdioemb_dev *fdev);
+
+#endif /* #ifndef _SLOT_API_H */
--- /dev/null
+/*
+ * i.MX27 SDHC definitions.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef _SLOT_IMX27_H
+#define _SLOT_IMX27_H
+
+/*
+ * i.MX27 SDHC registers.
+ */
+
+#define SDHC_STR_STP_CLK 0x00
+# define STR_STP_CLK_MMCSD_RESET 0x0008
+# define STR_STP_CLK_START_CLK 0x0002
+# define STR_STP_CLK_STOP_CLK 0x0001
+
+#define SDHC_STATUS 0x04
+# define STATUS_CARD_PRESENCE 0x8000
+# define STATUS_SDIO_INT_ACTIVE 0x4000
+# define STATUS_END_CMD_RESP 0x2000
+# define STATUS_WRITE_OP_DONE 0x1000
+# define STATUS_READ_OP_DONE 0x0800
+# define STATUS_CARD_BUS_CLK_RUN 0x0100
+# define STATUS_APPL_BUFF_FF 0x0080
+# define STATUS_APPL_BUFF_FE 0x0040
+# define STATUS_RESP_CRC_ERR 0x0020
+# define STATUS_CRC_READ_ERR 0x0008
+# define STATUS_CRC_WRITE_ERR 0x0004
+# define STATUS_TIME_OUT_RESP 0x0002
+# define STATUS_TIME_OUT_READ 0x0001
+# define STATUS_ERR_CMD_MASK (STATUS_RESP_CRC_ERR | STATUS_TIME_OUT_RESP)
+# define STATUS_ERR_DATA_MASK (STATUS_CRC_READ_ERR | STATUS_CRC_WRITE_ERR | STATUS_TIME_OUT_READ)
+# define STATUS_ERR_MASK (STATUS_ERR_CMD_MASK | STATUS_ERR_DATA_MASK)
+
+#define SDHC_CLK_RATE 0x08
+
+#define SDHC_CMD_DAT_CTRL 0x0c /* CMD_DAT_CONT */
+# define CMD_DAT_CTRL_CMD_RESUME 0x8000
+# define CMD_DAT_CTRL_CMD_RESP_LONG_OFF 0x1000
+# define CMD_DAT_CTRL_STOP_READ_WAIT 0x0800
+# define CMD_DAT_CTRL_START_READ_WAIT 0x0400
+# define CMD_DAT_CTRL_BUS_WIDTH_4 0x0200
+# define CMD_DAT_CTRL_INIT 0x0080
+# define CMD_DAT_CTRL_WRITE 0x0010
+# define CMD_DAT_CTRL_DATA_ENABLE 0x0008
+# define CMD_DAT_CTRL_RESP_NONE 0x0000
+# define CMD_DAT_CTRL_RESP_R1_R5_R6 0x0001
+# define CMD_DAT_CTRL_RESP_R2 0x0002
+# define CMD_DAT_CTRL_RESP_R3_R4 0x0003
+
+#define SDHC_RES_TO 0x10
+
+#define SDHC_READ_TO 0x14
+# define READ_TO_RECOMMENDED 0x2db4
+
+#define SDHC_BLK_LEN 0x18
+
+#define SDHC_NOB 0x1c
+
+#define SDHC_REV_NO 0x20
+
+#define SDHC_INT_CTRL 0x24 /* INT_CNTR */
+# define INT_CTRL_CARD_INSERTION_EN 0x8000
+# define INT_CTRL_SDIO_REMOVAL_EN 0x4000
+# define INT_CTRL_SDIO_IRQ_EN 0x2000
+# define INT_CTRL_DAT0_EN 0x1000
+# define INT_CTRL_BUF_READ_EN 0x0010
+# define INT_CTRL_BUF_WRITE_EN 0x0008
+# define INT_CTRL_END_CMD_RES 0x0004
+# define INT_CTRL_WRITE_OP_DONE 0x0002
+# define INT_CTRL_READ_OP_DONE 0x0001
+# define INT_CTRL_INT_EN_MASK 0xe01f
+
+#define SDHC_CMD 0x28
+
+#define SDHC_ARG 0x2c
+
+#define SDHC_RES_FIFO 0x34
+
+#define SDHC_BUFFER_ACCESS 0x38
+
+#endif /* #ifndef _SLOT_IMX27_H */
--- /dev/null
+/*
+ * i.MX31 SDHC definitions.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef _SLOT_IMX31_H
+#define _SLOT_IMX31_H
+
+/*
+ * i.MX31 SDHC registers.
+ */
+
+#define SDHC_STR_STP_CLK 0x00
+# define STR_STP_CLK_MMCSD_RESET 0x0008
+# define STR_STP_CLK_START_CLK 0x0002
+# define STR_STP_CLK_STOP_CLK 0x0001
+
+#define SDHC_STATUS 0x04
+# define STATUS_CARD_PRESENCE 0x8000
+# define STATUS_SDIO_INT_ACTIVE 0x4000
+# define STATUS_END_CMD_RESP 0x2000
+# define STATUS_WRITE_OP_DONE 0x1000
+# define STATUS_READ_OP_DONE 0x0800
+# define STATUS_CARD_BUS_CLK_RUN 0x0100
+# define STATUS_APPL_BUFF_FF 0x0080
+# define STATUS_APPL_BUFF_FE 0x0040
+# define STATUS_RESP_CRC_ERR 0x0020
+# define STATUS_CRC_READ_ERR 0x0008
+# define STATUS_CRC_WRITE_ERR 0x0004
+# define STATUS_TIME_OUT_RESP 0x0002
+# define STATUS_TIME_OUT_READ 0x0001
+# define STATUS_ERR_CMD_MASK (STATUS_RESP_CRC_ERR | STATUS_TIME_OUT_RESP)
+# define STATUS_ERR_DATA_MASK (STATUS_CRC_READ_ERR | STATUS_CRC_WRITE_ERR | STATUS_TIME_OUT_READ)
+# define STATUS_ERR_MASK (STATUS_ERR_CMD_MASK | STATUS_ERR_DATA_MASK)
+
+#define SDHC_CLK_RATE 0x08
+
+#define SDHC_CMD_DAT_CTRL 0x0c /* CMD_DAT_CONT */
+# define CMD_DAT_CTRL_CMD_RESUME 0x8000
+# define CMD_DAT_CTRL_CMD_RESP_LONG_OFF 0x1000
+# define CMD_DAT_CTRL_STOP_READ_WAIT 0x0800
+# define CMD_DAT_CTRL_START_READ_WAIT 0x0400
+# define CMD_DAT_CTRL_BUS_WIDTH_4 0x0200
+# define CMD_DAT_CTRL_INIT 0x0080
+# define CMD_DAT_CTRL_WRITE 0x0010
+# define CMD_DAT_CTRL_DATA_ENABLE 0x0008
+# define CMD_DAT_CTRL_RESP_NONE 0x0000
+# define CMD_DAT_CTRL_RESP_R1_R5_R6 0x0001
+# define CMD_DAT_CTRL_RESP_R2 0x0002
+# define CMD_DAT_CTRL_RESP_R3_R4 0x0003
+
+#define SDHC_RES_TO 0x10
+
+#define SDHC_READ_TO 0x14
+# define READ_TO_RECOMMENDED 0x2db4
+
+#define SDHC_BLK_LEN 0x18
+
+#define SDHC_NOB 0x1c
+
+#define SDHC_REV_NO 0x20
+
+#define SDHC_INT_CTRL 0x24 /* INT_CNTR */
+# define INT_CTRL_CARD_INSERTION_EN 0x8000
+# define INT_CTRL_SDIO_REMOVAL_EN 0x4000
+# define INT_CTRL_SDIO_IRQ_EN 0x2000
+# define INT_CTRL_DAT0_EN 0x1000
+# define INT_CTRL_BUF_READ_EN 0x0010
+# define INT_CTRL_BUF_WRITE_EN 0x0008
+# define INT_CTRL_END_CMD_RES 0x0004
+# define INT_CTRL_WRITE_OP_DONE 0x0002
+# define INT_CTRL_READ_OP_DONE 0x0001
+# define INT_CTRL_INT_EN_MASK 0xe01f
+
+#define SDHC_CMD 0x28
+
+#define SDHC_ARG 0x2c
+
+#define SDHC_RES_FIFO 0x34
+
+#define SDHC_BUFFER_ACCESS 0x38
+
+#endif /* #ifndef _SLOT_IMX31_H */
--- /dev/null
+/*
+ * PXA27x MMC/SD controller definitions.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef _SLOT_PXA27X_H
+#define _SLOT_PXA27X_H
+
+#define PXA27X_MMC_MMCLK_BASE_FREQ 19500000
+#define PXA27X_MMC_FIFO_SIZE 32
+
+#define STOP_CLOCK (1 << 0)
+#define START_CLOCK (2 << 0)
+
+#define STAT_END_CMD_RES (1 << 13)
+#define STAT_PRG_DONE (1 << 12)
+#define STAT_DATA_TRAN_DONE (1 << 11)
+#define STAT_CLK_EN (1 << 8)
+#define STAT_RECV_FIFO_FULL (1 << 7)
+#define STAT_XMIT_FIFO_EMPTY (1 << 6)
+#define STAT_RES_CRC_ERR (1 << 5)
+#define STAT_SPI_READ_ERROR_TOKEN (1 << 4)
+#define STAT_CRC_READ_ERROR (1 << 3)
+#define STAT_CRC_WRITE_ERROR (1 << 2)
+#define STAT_TIME_OUT_RESPONSE (1 << 1)
+#define STAT_READ_TIME_OUT (1 << 0)
+
+#define SPI_CS_ADDRESS (1 << 3)
+#define SPI_CS_EN (1 << 2)
+#define CRC_ON (1 << 1)
+#define SPI_EN (1 << 0)
+
+#define CMDAT_SDIO_INT_EN (1 << 11)
+#define CMDAT_STOP_TRAN (1 << 10)
+#define CMDAT_SD_4DAT (1 << 8)
+#define CMDAT_DMAEN (1 << 7)
+#define CMDAT_INIT (1 << 6)
+#define CMDAT_BUSY (1 << 5)
+#define CMDAT_STREAM (1 << 4) /* 1 = stream */
+#define CMDAT_WRITE (1 << 3) /* 1 = write */
+#define CMDAT_DATAEN (1 << 2)
+#define CMDAT_RESP_NONE (0 << 0)
+#define CMDAT_RESP_SHORT (1 << 0)
+#define CMDAT_RESP_R2 (2 << 0)
+#define CMDAT_RESP_R3 (3 << 0)
+
+#define RDTO_MAX 0xffff
+
+#define BUF_PART_FULL (1 << 0)
+
+#define SDIO_SUSPEND_ACK (1 << 12)
+#define SDIO_INT (1 << 11)
+#define RD_STALLED (1 << 10)
+#define RES_ERR (1 << 9)
+#define DAT_ERR (1 << 8)
+#define TINT (1 << 7)
+#define TXFIFO_WR_REQ (1 << 6)
+#define RXFIFO_RD_REQ (1 << 5)
+#define CLK_IS_OFF (1 << 4)
+#define STOP_CMD (1 << 3)
+#define END_CMD_RES (1 << 2)
+#define PRG_DONE (1 << 1)
+#define DATA_TRAN_DONE (1 << 0)
+
+#define MMC_I_MASK_ALL 0x00001fff
+
+#endif /* #ifndef _SLOT_PXA27X_H */
--- /dev/null
+/*
+ * Standard Host Controller definitions.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef _SLOT_SHC_H
+#define _SLOT_SHC_H
+
+#include <oska/io.h>
+
+/* SHC registers */
+#define SHC_SYSTEM_ADDRESS 0x00
+
+#define SHC_BLOCK_SIZE 0x04
+# define SHC_BLOCK_SIZE_DMA_BOUNDARY_4K (0x0 << 12)
+# define SHC_BLOCK_SIZE_DMA_BOUNDARY_512K (0x7 << 12)
+
+#define SHC_BLOCK_COUNT 0x06
+#define SHC_ARG 0x08
+
+#define SHC_TRANSFER_MODE 0x0c
+# define SHC_TRANSFER_MODE_DMA_EN 0x0001
+# define SHC_TRANSFER_MODE_BLK_CNT_EN 0x0002
+# define SHC_TRANSFER_MODE_AUTO_CMD12_EN 0x0004
+# define SHC_TRANSFER_MODE_DATA_READ 0x0010
+# define SHC_TRANSFER_MODE_MULTI_BLK 0x0020
+
+#define SHC_CMD 0x0e
+# define SHC_CMD_RESP_NONE 0x0000
+# define SHC_CMD_RESP_136 0x0001
+# define SHC_CMD_RESP_48 0x0002
+# define SHC_CMD_RESP_48B 0x0003
+# define SHC_CMD_RESP_CRC_CHK 0x0008
+# define SHC_CMD_RESP_IDX_CHK 0x0010
+# define SHC_CMD_DATA_PRESENT 0x0020
+# define SHC_CMD_TYPE_ABORT (0x3 << 6)
+# define SHC_CMD_IDX(c) ((c) << 8)
+
+#define SHC_RESPONSE_0_31 0x10
+
+#define SHC_BUFFER_DATA_PORT 0x20
+
+#define SHC_PRESENT_STATE 0x24
+# define SHC_PRESENT_STATE_CMD_INHIBIT 0x00000001
+# define SHC_PRESENT_STATE_DAT_INHIBIT 0x00000002
+# define SHC_PRESENT_STATE_CARD_PRESENT 0x00010000
+
+#define SHC_HOST_CTRL 0x28
+# define SHC_HOST_CTRL_LED_ON 0x01
+# define SHC_HOST_CTRL_4BIT 0x02
+# define SHC_HOST_CTRL_HIGH_SPD_EN 0x04
+
+
+#define SHC_PWR_CTRL 0x29
+# define SHC_PWR_CTRL_3V3 0x0e
+# define SHC_PWR_CTRL_ON 0x01
+
+#define SHC_BLOCK_GAP_CTRL 0x2a
+#define SHC_WAKEUP_CTRL 0x2b
+
+#define SHC_CLOCK_CTRL 0x2c
+# define SHC_CLOCK_CTRL_INT_CLK_EN 0x01
+# define SHC_CLOCK_CTRL_INT_CLK_STABLE 0x02
+# define SHC_CLOCK_CTRL_SD_CLK_EN 0x04
+# define SHC_CLOCK_CTRL_DIV(d) (((d) >> 1) << 8) /* divisor must be power of 2 */
+
+#define SHC_TIMEOUT_CTRL 0x2e
+# define SHC_TIMEOUT_CTRL_MAX 0x0e
+
+#define SHC_SOFTWARE_RST 0x2f
+# define SHC_SOFTWARE_RST_ALL 0x01
+# define SHC_SOFTWARE_RST_CMD 0x02
+# define SHC_SOFTWARE_RST_DAT 0x04
+
+#define SHC_INT_STATUS 0x30
+#define SHC_INT_STATUS_EN 0x34
+#define SHC_INT_SIGNAL_EN 0x38
+# define SHC_INT_CMD_COMPLETE 0x00000001
+# define SHC_INT_TRANSFER_COMPLETE 0x00000002
+# define SHC_INT_BLOCK_GAP 0x00000004
+# define SHC_INT_DMA 0x00000008
+# define SHC_INT_WR_BUF_RDY 0x00000010
+# define SHC_INT_RD_BUF_RDY 0x00000020
+# define SHC_INT_CARD_INSERTED 0x00000040
+# define SHC_INT_CARD_REMOVED 0x00000080
+# define SHC_INT_CARD_INT 0x00000100
+# define SHC_INT_ERR_ANY 0x00008000
+# define SHC_INT_ERR_CMD_TIMEOUT 0x00010000
+# define SHC_INT_ERR_CMD_CRC 0x00020000
+# define SHC_INT_ERR_CMD_ENDBIT 0x00040000
+# define SHC_INT_ERR_CMD_INDEX 0x00080000
+# define SHC_INT_ERR_CMD_ALL 0x000f0000
+# define SHC_INT_ERR_DAT_TIMEOUT 0x00100000
+# define SHC_INT_ERR_DAT_CRC 0x00200000
+# define SHC_INT_ERR_DAT_ENDBIT 0x00400000
+# define SHC_INT_ERR_DAT_ALL 0x00700000
+# define SHC_INT_ERR_CURRENT_LIMIT 0x00800000
+# define SHC_INT_ERR_AUTO_CMD12 0x01000000
+# define SHC_INT_ERR_ALL 0x01ff0000
+# define SHC_INT_ALL 0x01ff81ff
+
+#define SHC_AUTO_CMD12_STATUS 0x3c
+
+#define SHC_CAPS 0x40
+# define SHC_CAPS_TO_BASE_CLK_FREQ(c) (((c) & 0x00003f00) >> 8)
+# define SHC_CAPS_PWR_3V3 (1 << 24)
+
+#define SHC_MAX_CURRENT_CAPS 0x4c
+
+/* PCI configuration registers. */
+#define PCI_SHC_SLOT_INFO 0x40
+
+/* Maximum time to wait for a software reset. */
+#define SHC_RESET_TIMEOUT_MS 100 /* ms */
+
+/* Maximum time to wait for internal clock to stabilize */
+#define SHC_INT_CLK_STABLE_TIMEOUT_MS 100
+
+/*
+ * No supported voltages in the capabilities register.
+ *
+ * Workaround: Assume 3.3V is supported.
+ */
+#define SLOT_SHC_QUIRK_NO_VOLTAGE_CAPS (1 << 0)
+
+/*
+ * Commands with an R5B (busy) response do not complete.
+ *
+ * Workaround: Use R5 instead. This will only work if the busy signal
+ * is cleared sufficiently quickly before the next command is started.
+ */
+#define SLOT_SHC_QUIRK_R5B_BROKEN (1 << 1)
+
+/*
+ * High speed mode doesn't work.
+ *
+ * Workaround: limit maximum bus frequency to 25 MHz.
+ */
+#define SLOT_SHC_QUIRK_HIGH_SPD_BROKEN (1 << 2)
+
+/*
+ * Data timeout (TIMEOUT_CTRL) uses SDCLK and not TMCLK.
+ *
+ * Workaround: set TIMEOUT_CTRL using SDCLK.
+ */
+#define SLOT_SHC_QUIRK_DATA_TIMEOUT_USES_SDCLK (1 << 3)
+
+/*
+ * Controller can only start DMA on dword (32 bit) aligned addresses.
+ *
+ * Workaround: PIO is used on data transfers with a non-dword aligned
+ * address.
+ */
+#define SHC_QUIRK_DMA_NEEDS_DWORD_ALIGNED_ADDR (1 << 4)
+
+/*
+ * Controller is unreliable following multiple transfers
+ *
+ * Workaround: The controller is reset following every command, not just
+ * erroneous ones
+ */
+#define SHC_QUIRK_RESET_EVERY_CMD_COMPLETE (1 << 5)
+
+/*
+ * JMicron JMB381 to JMB385 controllers require some non-standard PCI
+ * config space writes.
+ */
+#define SHC_QUIRK_JMICRON_JMB38X (1 << 6)
+
+/*
+ * Controller can only do DMA if the length is a whole number of
+ * dwords.
+ *
+ * Controller with this quirk probably also need
+ * SHC_QUIRK_DMA_NEEDS_DWORD_ALIGNED_ADDR.
+ *
+ * Workaround: PIO is used on data transfers that don't end on an
+ * aligned address.
+ */
+#define SHC_QUIRK_DMA_NEEDS_DWORD_ALIGNED_LEN (1 << 7)
+
+struct sdioemb_shc {
+ struct sdioemb_slot *slot;
+ void (*enable_int)(struct sdioemb_slot *slot, uint32_t ints);
+ void (*disable_int)(struct sdioemb_slot *slot, uint32_t ints);
+ void (*cmd_complete)(struct sdioemb_slot *slot, struct sdioemb_cmd *cmd);
+ uint32_t quirks;
+ os_io_mem_t addr;
+
+ os_spinlock_t lock;
+ os_timer_t lockup_timer;
+ uint32_t base_clk;
+ struct sdioemb_cmd *current_cmd;
+ uint8_t *data;
+ size_t remaining;
+ size_t block_size;
+};
+
+void sdioemb_shc_init(struct sdioemb_shc *shc);
+void sdioemb_shc_clean_up(struct sdioemb_shc *shc);
+
+int sdioemb_shc_start(struct sdioemb_shc *shc);
+void sdioemb_shc_stop(struct sdioemb_shc *shc);
+
+bool sdioemb_shc_isr(struct sdioemb_shc *shc, uint32_t *int_stat);
+void sdioemb_shc_dsr(struct sdioemb_shc *shc, uint32_t int_stat);
+
+int sdioemb_shc_set_bus_freq(struct sdioemb_shc *shc, int clk);
+int sdioemb_shc_set_bus_width(struct sdioemb_shc *shc, int bus_width);
+int sdioemb_shc_start_cmd(struct sdioemb_shc *shc, struct sdioemb_cmd *cmd,
+ bool use_dma, uint64_t dma_addr);
+int sdioemb_shc_card_present(struct sdioemb_shc *shc);
+int sdioemb_shc_card_power(struct sdioemb_shc *shc, enum sdioemb_power power);
+void sdioemb_shc_enable_card_int(struct sdioemb_shc *shc);
+void sdioemb_shc_disable_card_int(struct sdioemb_shc *shc);
+int sdioemb_shc_hard_reset(struct sdioemb_shc *shc);
+
+void sdioemb_shc_show_quirks(struct sdioemb_shc *shc);
+
+#endif /* #ifndef _SLOT_SHC_H */
--- /dev/null
+/*
+ * USB Standard Host Controller definitions.
+ *
+ * Copyright (C) 2010 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef _SLOT_USHC_H
+#define _SLOT_USHC_H
+
+#include <oska/io.h>
+
+enum ushc_request
+{
+ USHC_GET_CAPS = 0x00,
+ USHC_HOST_CTRL = 0x01,
+ USHC_PWR_CTRL = 0x02,
+ USHC_CLK_FREQ = 0x03,
+ USHC_EXEC_CMD = 0x04,
+ USHC_READ_RESP = 0x05,
+ USHC_RESET = 0x06
+};
+
+enum ushc_request_recipient
+{
+ USHC_RECIPIENT_DEVICE = 0x00,
+ USHC_RECIPIENT_INTERFACE = 0x01,
+ USHC_RECIPIENT_ENDPOINT = 0x02,
+ USHC_RECIPIENT_OTHER = 0x03
+};
+
+enum ushc_request_direction
+{
+ USHC_HOST_TO_DEVICE = 0x00,
+ USHC_DEVICE_TO_HOST = 0x01
+};
+
+struct sdioemb_ushc
+{
+ struct sdioemb_slot *slot;
+
+ void (*enable_int)(struct sdioemb_slot *slot, uint32_t ints);
+ void (*disable_int)(struct sdioemb_slot *slot, uint32_t ints);
+ void (*cmd_complete)(struct sdioemb_slot *slot, struct sdioemb_cmd *cmd);
+ int (*set_host_ctrl)(struct sdioemb_slot *slot, uint16_t controler_state);
+ int (*submit_vendor_request)(struct sdioemb_slot *slot,
+ enum ushc_request request,
+ enum ushc_request_direction direction,
+ enum ushc_request_recipient recipient,
+ uint16_t value,
+ uint16_t index,
+ void* io_buffer,
+ uint32_t io_buffer_length);
+ int (*submit_cbw_request)(struct sdioemb_slot *slot, uint8_t cmd_index, uint16_t block_size, uint32_t cmd_arg);
+ int (*submit_data_request)(struct sdioemb_slot *slot,
+ enum ushc_request_direction direction,
+ void* request_buffer,
+ uint32_t request_buffer_length);
+ int (*submit_csw_request)(struct sdioemb_slot *slot);
+
+ os_spinlock_t lock;
+
+ uint32_t base_clock;
+ uint32_t controler_capabilities;
+ uint16_t controler_state;
+ struct sdioemb_cmd* current_cmd;
+
+#define DISCONNECTED 0
+#define INT_EN 1
+#define IGNORE_NEXT_INT 2
+#define STOP 4
+ uint32_t flags;
+
+#define USHC_INT_STATUS_SDIO_INT (1 << 1)
+#define USHC_INT_STATUS_CARD_PRESENT (1 << 0)
+ uint8_t interrupt_status;
+
+ size_t block_size;
+};
+
+#define USHC_GET_CAPS_VERSION_MASK 0xff
+#define USHC_GET_CAPS_3V3 (1 << 8)
+#define USHC_GET_CAPS_3V0 (1 << 9)
+#define USHC_GET_CAPS_1V8 (1 << 10)
+#define USHC_GET_CAPS_HIGH_SPD (1 << 16)
+
+#define USHC_PWR_CTRL_OFF 0x00
+#define USHC_PWR_CTRL_3V3 0x01
+#define USHC_PWR_CTRL_3V0 0x02
+#define USHC_PWR_CTRL_1V8 0x03
+
+#define USHC_HOST_CTRL_4BIT (1 << 1)
+#define USHC_HOST_CTRL_HIGH_SPD (1 << 0)
+
+#define USHC_READ_RESP_BUSY (1 << 4)
+#define USHC_READ_RESP_ERR_TIMEOUT (1 << 3)
+#define USHC_READ_RESP_ERR_CRC (1 << 2)
+#define USHC_READ_RESP_ERR_DAT (1 << 1)
+#define USHC_READ_RESP_ERR_CMD (1 << 0)
+#define USHC_READ_RESP_ERR_MASK 0x0f
+
+void sdioemb_ushc_init(struct sdioemb_ushc* ushc);
+void sdioemb_ushc_clean_up(struct sdioemb_ushc* ushc);
+
+int sdioemb_ushc_start(struct sdioemb_ushc* ushc);
+void sdioemb_ushc_stop(struct sdioemb_ushc* ushc);
+
+bool sdioemb_ushc_isr(struct sdioemb_ushc* ushc, uint8_t int_stat);
+
+int sdioemb_ushc_set_bus_freq(struct sdioemb_ushc* ushc, int clk);
+int sdioemb_ushc_set_bus_width(struct sdioemb_ushc* ushc, int bus_width);
+int sdioemb_ushc_start_cmd(struct sdioemb_ushc* ushc, struct sdioemb_cmd *cmd);
+int sdioemb_ushc_card_present(struct sdioemb_ushc* ushc);
+int sdioemb_ushc_card_power(struct sdioemb_ushc* ushc, enum sdioemb_power power);
+void sdioemb_ushc_enable_card_int(struct sdioemb_ushc* ushc);
+void sdioemb_ushc_disable_card_int(struct sdioemb_ushc* ushc);
+int sdioemb_ushc_hard_reset(struct sdioemb_ushc* ushc);
+
+void sdioemb_ushc_command_complete(struct sdioemb_ushc* ushc, uint8_t status, uint32_t respones);
+
+int ushc_hw_get_caps(struct sdioemb_ushc* ushc);
+static int ushc_hw_set_host_ctrl(struct sdioemb_ushc* ushc, uint16_t mask, uint16_t val);
+static int ushc_hw_submit_vendor_request(struct sdioemb_ushc* ushc,
+ enum ushc_request request,
+ enum ushc_request_recipient recipient,
+ enum ushc_request_direction direction,
+ uint16_t value,
+ uint16_t index,
+ void* io_buffer,
+ uint32_t io_buffer_length);
+
+#endif
--- /dev/null
+/*
+ * Sdioemb trace messages.
+ *
+ * Copyright (C) 2009 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+
+#ifndef SDIOEMB_TRACE_H
+#define SDIOEMB_TRACE_H
+
+#if defined(__linux__)
+# define OS_TRACE_PREFIX "sdioemb: "
+#endif
+
+#include <oska/trace.h>
+
+#endif /* #ifndef SDIOEMB_TRACE_H */
--- /dev/null
+/*
+ * Userspace interface to the SDIO Userspace Interface driver.
+ *
+ * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ */
+#ifndef LINUX_SDIOEMB_UIF_H
+#define LINUX_SDIOEMB_UIF_H
+
+enum sdioemb_uif_cmd_type {
+ SDIOEMB_UIF_CMD52_READ, SDIOEMB_UIF_CMD52_WRITE,
+ SDIOEMB_UIF_CMD53_READ, SDIOEMB_UIF_CMD53_WRITE,
+};
+
+struct sdioemb_uif_cmd {
+ enum sdioemb_uif_cmd_type type;
+ int function;
+ uint32_t address;
+ uint8_t * data;
+ size_t len;
+ int block_size;
+};
+
+#define SDIOEMB_UIF_IOC_MAGIC 's'
+
+#define SDIOEMB_UIF_IOCQNUMFUNCS _IO(SDIOEMB_UIF_IOC_MAGIC, 0)
+#define SDIOEMB_UIF_IOCCMD _IOWR(SDIOEMB_UIF_IOC_MAGIC, 1, struct sdioemb_uif_cmd)
+#define SDIOEMB_UIF_IOCWAITFORINT _IO(SDIOEMB_UIF_IOC_MAGIC, 2)
+#define SDIOEMB_UIF_IOCTBUSWIDTH _IO(SDIOEMB_UIF_IOC_MAGIC, 3)
+#define SDIOEMB_UIF_IOCREINSERT _IO(SDIOEMB_UIF_IOC_MAGIC, 4)
+#define SDIOEMB_UIF_IOCTBUSFREQ _IO(SDIOEMB_UIF_IOC_MAGIC, 5)
+#define SDIOEMB_UIF_IOCQMANFID _IO(SDIOEMB_UIF_IOC_MAGIC, 6)
+#define SDIOEMB_UIF_IOCQCARDID _IO(SDIOEMB_UIF_IOC_MAGIC, 7)
+#define SDIOEMB_UIF_IOCQSTDIF _IO(SDIOEMB_UIF_IOC_MAGIC, 8)
+#define SDIOEMB_UIF_IOCQMAXBLKSZ _IO(SDIOEMB_UIF_IOC_MAGIC, 9)
+#define SDIOEMB_UIF_IOCQBLKSZ _IO(SDIOEMB_UIF_IOC_MAGIC, 10)
+#define SDIOEMB_UIF_IOCTBLKSZ _IO(SDIOEMB_UIF_IOC_MAGIC, 11)
+
+#endif /* #ifndef LINUX_SDIOEMB_UIF_H */
--- /dev/null
+/* Autogenerated by the sdioemb release procedure. */
+#ifndef SDIOEMB_VERSION_H
+#define SDIOEMB_VERSION_H
+
+#define SDIOEMB_RELEASE 31
+
+#ifndef SDIOEMB_RELEASE_EXTRA
+#define SDIOEMB_RELEASE_EXTRA ""
+#endif
+
+#endif /* #ifndef SDIOEMB_VERSION_H */
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: sme_mgt_blocking.c
+ *
+ * PURPOSE:
+ * This file contains the driver specific implementation of
+ * the WEXT <==> SME MGT interface for all SME builds that support WEXT.
+ *
+ * Copyright (C) 2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+#include "unifi_priv.h"
+
+
+/*
+ * This file also contains the implementation of the asyncronous
+ * requests to the SME.
+ *
+ * Before calling an asyncronous SME function, we call sme_init_request()
+ * which gets hold of the SME semaphore and updates the request status.
+ * The semaphore makes sure that there is only one pending request to
+ * the SME at a time.
+ *
+ * Now we are ready to call the SME function, but only if
+ * sme_init_request() has returned 0.
+ *
+ * When the SME function returns, we need to wait
+ * for the reply. This is done in sme_wait_for_reply().
+ * If the request times-out, the request status is set to SME_REQUEST_TIMEDOUT
+ * and the sme_wait_for_reply() returns.
+ *
+ * If the SME replies in time, we call sme_complete_request().
+ * There we change the request status to SME_REQUEST_RECEIVED. This will
+ * wake up the process waiting on sme_wait_for_reply().
+ * It is important that we copy the reply data in priv->sme_reply
+ * before calling sme_complete_request().
+ *
+ * Handling the wext requests, we need to block
+ * until the SME sends the response to our request.
+ * We use the sme_init_request() and sme_wait_for_reply()
+ * to implement this behavior in the following functions:
+ * sme_mgt_wifi_on()
+ * sme_mgt_wifi_off()
+ * sme_mgt_scan_full()
+ * sme_mgt_scan_results_get_async()
+ * sme_mgt_connect()
+ * unifi_mgt_media_status_ind()
+ * sme_mgt_disconnect()
+ * sme_mgt_pmkid()
+ * sme_mgt_key()
+ * sme_mgt_mib_get()
+ * sme_mgt_mib_set()
+ * sme_mgt_versions_get()
+ * sme_mgt_set_value()
+ * sme_mgt_get_value()
+ * sme_mgt_set_value_async()
+ * sme_mgt_get_value_async()
+ * sme_mgt_packet_filter_set()
+ * sme_mgt_tspec()
+ */
+
+
+/*
+ * Handling the suspend and resume system events, we need to block
+ * until the SME sends the response to our indication.
+ * We use the sme_init_request() and sme_wait_for_reply()
+ * to implement this behavior in the following functions:
+ * sme_sys_suspend()
+ * sme_sys_resume()
+ */
+
+#define UNIFI_SME_MGT_SHORT_TIMEOUT 10000
+#define UNIFI_SME_MGT_LONG_TIMEOUT 19000
+#define UNIFI_SME_SYS_LONG_TIMEOUT 10000
+
+#ifdef UNIFI_DEBUG
+# define sme_wait_for_reply(priv, t) _sme_wait_for_reply(priv, t, __func__)
+#else
+# define sme_wait_for_reply(priv, t) _sme_wait_for_reply(priv, t, NULL)
+#endif
+
+static int
+sme_init_request(unifi_priv_t *priv)
+{
+ if (priv == NULL) {
+ unifi_error(priv, "sme_init_request: Invalid priv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG5, "sme_init_request: wait sem\n");
+
+ /* Grab the SME semaphore until the reply comes, or timeout */
+ if (down_interruptible(&priv->sme_sem)) {
+ unifi_error(priv, "sme_init_request: Failed to get SME semaphore\n");
+ return -EIO;
+ }
+ unifi_trace(priv, UDBG5, "sme_init_request: got sem: pending\n");
+
+ priv->sme_reply.request_status = SME_REQUEST_PENDING;
+
+ return 0;
+
+} /* sme_init_request() */
+
+
+void
+uf_sme_complete_request(unifi_priv_t *priv, CsrResult reply_status, const char *func)
+{
+ if (priv == NULL) {
+ unifi_error(priv, "sme_complete_request: Invalid priv\n");
+ return;
+ }
+
+ if (priv->sme_reply.request_status != SME_REQUEST_PENDING) {
+ unifi_notice(priv,
+ "sme_complete_request: request not pending %s (s:%d)\n",
+ (func ? func : ""), priv->sme_reply.request_status);
+ return;
+ }
+ unifi_trace(priv, UDBG5,
+ "sme_complete_request: completed %s (s:%d)\n",
+ (func ? func : ""), priv->sme_reply.request_status);
+
+ priv->sme_reply.request_status = SME_REQUEST_RECEIVED;
+ priv->sme_reply.reply_status = reply_status;
+
+ wake_up_interruptible(&priv->sme_request_wq);
+
+ return;
+}
+
+
+void
+uf_sme_cancel_request(unifi_priv_t *priv, CsrResult reply_status)
+{
+ /* Check for a blocking SME request in progress, and cancel the wait.
+ * This should be used when the character device is closed.
+ */
+
+ if (priv == NULL) {
+ unifi_error(priv, "sme_cancel_request: Invalid priv\n");
+ return;
+ }
+
+ /* If no request is pending, nothing to wake up */
+ if (priv->sme_reply.request_status != SME_REQUEST_PENDING) {
+ unifi_trace(priv, UDBG5,
+ "sme_cancel_request: no request was pending (s:%d)\n",
+ priv->sme_reply.request_status);
+ /* Nothing to do */
+ return;
+ }
+ unifi_trace(priv, UDBG5,
+ "sme_cancel_request: request cancelled (s:%d)\n",
+ priv->sme_reply.request_status);
+
+ /* Wake up the wait with an error status */
+ priv->sme_reply.request_status = SME_REQUEST_CANCELLED;
+ priv->sme_reply.reply_status = reply_status; /* unimportant since the CANCELLED state will fail the ioctl */
+
+ wake_up_interruptible(&priv->sme_request_wq);
+
+ return;
+}
+
+
+static int
+_sme_wait_for_reply(unifi_priv_t *priv,
+ unsigned long timeout, const char *func)
+{
+ long r;
+
+ unifi_trace(priv, UDBG5, "sme_wait_for_reply: %s sleep\n", func ? func : "");
+ r = wait_event_interruptible_timeout(priv->sme_request_wq,
+ (priv->sme_reply.request_status != SME_REQUEST_PENDING),
+ msecs_to_jiffies(timeout));
+ unifi_trace(priv, UDBG5, "sme_wait_for_reply: %s awake (%d)\n", func ? func : "", r);
+
+ if (r == -ERESTARTSYS) {
+ /* The thread was killed */
+ unifi_info(priv, "ERESTARTSYS in _sme_wait_for_reply\n");
+ up(&priv->sme_sem);
+ return r;
+ }
+ if (priv->sme_reply.request_status == SME_REQUEST_CANCELLED) {
+ unifi_trace(priv, UDBG5, "Cancelled waiting for SME to reply (%s s:%d, t:%d, r:%d)\n",
+ (func ? func : ""), priv->sme_reply.request_status, timeout, r);
+
+ /* Release the SME semaphore that was downed in sme_init_request() */
+ up(&priv->sme_sem);
+ return -EIO; /* fail the ioctl */
+ }
+ if ((r == 0) && (priv->sme_reply.request_status != SME_REQUEST_RECEIVED)) {
+ unifi_notice(priv, "Timeout waiting for SME to reply (%s s:%d, t:%d)\n",
+ (func ? func : ""), priv->sme_reply.request_status, timeout);
+
+ priv->sme_reply.request_status = SME_REQUEST_TIMEDOUT;
+
+ /* Release the SME semaphore that was downed in sme_init_request() */
+ up(&priv->sme_sem);
+
+ return -ETIMEDOUT;
+ }
+
+ unifi_trace(priv, UDBG5, "sme_wait_for_reply: %s received (%d)\n",
+ func ? func : "", r);
+
+ /* Release the SME semaphore that was downed in sme_init_request() */
+ up(&priv->sme_sem);
+
+ return 0;
+} /* sme_wait_for_reply() */
+
+
+
+
+#ifdef CSR_SUPPORT_WEXT
+int sme_mgt_wifi_on(unifi_priv_t *priv)
+{
+ CsrUint16 numElements;
+ CsrWifiSmeDataBlock* dataList;
+#ifdef CSR_SUPPORT_WEXT_AP
+ int r;
+#endif
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_wifi_on: invalid smepriv\n");
+ return -EIO;
+ }
+
+ if (priv->mib_data.length) {
+ numElements = 1;
+ dataList = &priv->mib_data;
+ } else {
+ numElements = 0;
+ dataList = NULL;
+ }
+ /* Start the SME */
+#ifdef CSR_SUPPORT_WEXT_AP
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+#endif
+ CsrWifiSmeWifiOnReqSend(0, priv->sta_mac_address, numElements, dataList);
+#ifdef CSR_SUPPORT_WEXT_AP
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_LONG_TIMEOUT);
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_wifi_on: unifi_mgt_wifi_oo_req <-- (r=%d, status=%d)\n",
+ r, priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ return 0;
+#endif
+} /* sme_mgt_wifi_on() */
+
+
+int sme_mgt_wifi_off(unifi_priv_t *priv)
+{
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_wifi_off: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ /* Stop the SME */
+ CsrWifiSmeWifiOffReqSend(0);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_LONG_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_wifi_off: unifi_mgt_wifi_off_req <-- (r=%d, status=%d)\n",
+ r, priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+
+} /* sme_mgt_wifi_off */
+
+int sme_mgt_key(unifi_priv_t *priv, CsrWifiSmeKey *sme_key,
+ CsrWifiSmeListAction action)
+{
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_key: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeKeyReqSend(0, CSR_WIFI_INTERFACE_IN_USE, action, *sme_key);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+}
+
+
+int sme_mgt_scan_full(unifi_priv_t *priv,
+ CsrWifiSsid *specific_ssid,
+ int num_channels,
+ unsigned char *channel_list)
+{
+ CsrWifiMacAddress bcastAddress = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }};
+ CsrBool is_active = (num_channels > 0) ? TRUE : FALSE;
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_scan_full: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_scan_full: -->\n");
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ /* If a channel list is provided, do an active scan */
+ if (is_active) {
+ unifi_trace(priv, UDBG1,
+ "channel list - num_channels: %d, active scan\n",
+ num_channels);
+ }
+
+ CsrWifiSmeScanFullReqSend(0,
+ specific_ssid->length?1:0, /* 0 or 1 SSIDS */
+ specific_ssid,
+ bcastAddress,
+ is_active,
+ CSR_WIFI_SME_BSS_TYPE_ANY_BSS,
+ CSR_WIFI_SME_SCAN_TYPE_ALL,
+ (CsrUint16)num_channels, channel_list,
+ 0, NULL);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_LONG_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_scan_full: <-- (status=%d)\n", priv->sme_reply.reply_status);
+ if (priv->sme_reply.reply_status == CSR_WIFI_RESULT_UNAVAILABLE) {
+ return 0; /* initial scan already underway */
+ } else {
+ return convert_sme_error(priv->sme_reply.reply_status);
+ }
+}
+
+
+int sme_mgt_scan_results_get_async(unifi_priv_t *priv,
+ struct iw_request_info *info,
+ char *scan_results,
+ long scan_results_len)
+{
+ CsrUint16 scan_result_list_count;
+ CsrWifiSmeScanResult *scan_result_list;
+ CsrWifiSmeScanResult *scan_result;
+ int r;
+ int i;
+ char *current_ev = scan_results;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_scan_results_get_async: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeScanResultsGetReqSend(0);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_LONG_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ scan_result_list_count = priv->sme_reply.reply_scan_results_count;
+ scan_result_list = priv->sme_reply.reply_scan_results;
+ unifi_trace(priv, UDBG2,
+ "scan_results: Scan returned %d, numElements=%d\n",
+ r, scan_result_list_count);
+
+ /* OK, now we have the scan results */
+ for (i = 0; i < scan_result_list_count; ++i) {
+ scan_result = &scan_result_list[i];
+
+ unifi_trace(priv, UDBG2, "Scan Result: %.*s\n",
+ scan_result->ssid.length,
+ scan_result->ssid.ssid);
+
+ r = unifi_translate_scan(priv->netdev[0], info,
+ current_ev,
+ scan_results + scan_results_len,
+ scan_result, i+1);
+
+ if (r < 0) {
+ CsrPmemFree(scan_result_list);
+ priv->sme_reply.reply_scan_results_count = 0;
+ priv->sme_reply.reply_scan_results = NULL;
+ return r;
+ }
+
+ current_ev += r;
+ }
+
+ /*
+ * Free the scan results allocated in unifi_mgt_scan_results_get_cfm()
+ * and invalidate the reply_scan_results to avoid re-using
+ * the freed pointers.
+ */
+ CsrPmemFree(scan_result_list);
+ priv->sme_reply.reply_scan_results_count = 0;
+ priv->sme_reply.reply_scan_results = NULL;
+
+ unifi_trace(priv, UDBG2,
+ "scan_results: Scan translated to %d bytes\n",
+ current_ev - scan_results);
+ return (current_ev - scan_results);
+}
+
+
+int sme_mgt_connect(unifi_priv_t *priv)
+{
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_connect: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG2, "sme_mgt_connect: %.*s\n",
+ priv->connection_config.ssid.length,
+ priv->connection_config.ssid.ssid);
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeConnectReqSend(0, CSR_WIFI_INTERFACE_IN_USE, priv->connection_config);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ if (priv->sme_reply.reply_status) {
+ unifi_trace(priv, UDBG1, "sme_mgt_connect: failed with SME status %d\n",
+ priv->sme_reply.reply_status);
+ }
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+}
+
+
+int sme_mgt_disconnect(unifi_priv_t *priv)
+{
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_disconnect: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeDisconnectReqSend(0, CSR_WIFI_INTERFACE_IN_USE);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_disconnect: <-- (status=%d)\n", priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+}
+
+
+int sme_mgt_pmkid(unifi_priv_t *priv,
+ CsrWifiSmeListAction action,
+ CsrWifiSmePmkidList *pmkid_list)
+{
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_pmkid: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmePmkidReqSend(0, CSR_WIFI_INTERFACE_IN_USE, action,
+ pmkid_list->pmkidsCount, pmkid_list->pmkids);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_pmkid: <-- (status=%d)\n", priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+}
+
+
+int sme_mgt_mib_get(unifi_priv_t *priv,
+ unsigned char *varbind, int *length)
+{
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_mib_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ priv->mib_cfm_buffer = varbind;
+ priv->mib_cfm_buffer_length = MAX_VARBIND_LENGTH;
+
+ CsrWifiSmeMibGetReqSend(0, *length, varbind);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ priv->mib_cfm_buffer_length = 0;
+ priv->mib_cfm_buffer = NULL;
+ return r;
+ }
+
+ *length = priv->mib_cfm_buffer_length;
+
+ priv->mib_cfm_buffer_length = 0;
+ priv->mib_cfm_buffer = NULL;
+ unifi_trace(priv, UDBG4, "sme_mgt_mib_get: <-- (status=%d)\n", priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+}
+
+int sme_mgt_mib_set(unifi_priv_t *priv,
+ unsigned char *varbind, int length)
+{
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_mib_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeMibSetReqSend(0, length, varbind);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_mib_set: <-- (status=%d)\n", priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+}
+
+#endif /* CSR_SUPPORT_WEXT */
+
+int sme_mgt_power_config_set(unifi_priv_t *priv, CsrWifiSmePowerConfig *powerConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_set_value_async: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmePowerConfigSetReqSend(0, *powerConfig);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_set_value_async: unifi_mgt_set_value_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_set_value: invalid smepriv\n");
+ return -EIO;
+ }
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtPowerConfigSetReq(priv->smepriv, *powerConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+int sme_mgt_sme_config_set(unifi_priv_t *priv, CsrWifiSmeStaConfig *staConfig, CsrWifiSmeDeviceConfig *deviceConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_sme_config_set: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeSmeStaConfigSetReqSend(0, CSR_WIFI_INTERFACE_IN_USE, *staConfig);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_sme_config_set: CsrWifiSmeSmeStaConfigSetReq <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeSmeCommonConfigSetReqSend(0, *deviceConfig);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_sme_config_set: CsrWifiSmeSmeCommonConfigSetReq <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_sme_config_set: invalid smepriv\n");
+ return -EIO;
+ }
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtSmeConfigSetReq(priv->smepriv, *staConfig);
+ status = CsrWifiSmeMgtDeviceConfigSetReq(priv->smepriv, *deviceConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+#ifdef CSR_SUPPORT_WEXT
+
+int sme_mgt_mib_config_set(unifi_priv_t *priv, CsrWifiSmeMibConfig *mibConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_mib_config_set: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeMibConfigSetReqSend(0, *mibConfig);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_mib_config_set: unifi_mgt_set_mib_config_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_mib_config_set: invalid smepriv\n");
+ return -EIO;
+ }
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtMibConfigSetReq(priv->smepriv, *mibConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+int sme_mgt_coex_config_set(unifi_priv_t *priv, CsrWifiSmeCoexConfig *coexConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_coex_config_set: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeCoexConfigSetReqSend(0, *coexConfig);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_coex_config_set: unifi_mgt_set_mib_config_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_coex_config_set: invalid smepriv\n");
+ return -EIO;
+ }
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtCoexConfigSetReq(priv->smepriv, *coexConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+#endif /* CSR_SUPPORT_WEXT */
+
+int sme_mgt_host_config_set(unifi_priv_t *priv, CsrWifiSmeHostConfig *hostConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_host_config_set: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeHostConfigSetReqSend(0, CSR_WIFI_INTERFACE_IN_USE, *hostConfig);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_host_config_set: unifi_mgt_set_host_config_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_host_config_set: invalid smepriv\n");
+ return -EIO;
+ }
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtHostConfigSetReq(priv->smepriv, *hostConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+#ifdef CSR_SUPPORT_WEXT
+
+int sme_mgt_versions_get(unifi_priv_t *priv, CsrWifiSmeVersions *versions)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_versions_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_versions_get: unifi_mgt_versions_get_req -->\n");
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeVersionsGetReqSend(0);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (versions != NULL) {
+ memcpy((unsigned char*)versions,
+ (unsigned char*)&priv->sme_reply.versions,
+ sizeof(CsrWifiSmeVersions));
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_versions_get: unifi_mgt_versions_get_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtVersionsGetReq(priv->smepriv, versions);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+#endif /* CSR_SUPPORT_WEXT */
+
+int sme_mgt_power_config_get(unifi_priv_t *priv, CsrWifiSmePowerConfig *powerConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_power_config_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_power_config_get: unifi_mgt_power_config_req -->\n");
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmePowerConfigGetReqSend(0);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (powerConfig != NULL) {
+ memcpy((unsigned char*)powerConfig,
+ (unsigned char*)&priv->sme_reply.powerConfig,
+ sizeof(CsrWifiSmePowerConfig));
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_get_versions: unifi_mgt_power_config_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtPowerConfigGetReq(priv->smepriv, powerConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+int sme_mgt_host_config_get(unifi_priv_t *priv, CsrWifiSmeHostConfig *hostConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_host_config_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_host_config_get: unifi_mgt_host_config_get_req -->\n");
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeHostConfigGetReqSend(0, CSR_WIFI_INTERFACE_IN_USE);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (hostConfig != NULL) {
+ memcpy((unsigned char*)hostConfig,
+ (unsigned char*)&priv->sme_reply.hostConfig,
+ sizeof(CsrWifiSmeHostConfig));
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_host_config_get: unifi_mgt_host_config_get_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtHostConfigGetReq(priv->smepriv, hostConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+int sme_mgt_sme_config_get(unifi_priv_t *priv, CsrWifiSmeStaConfig *staConfig, CsrWifiSmeDeviceConfig *deviceConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_sme_config_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_sme_config_get: unifi_mgt_sme_config_get_req -->\n");
+
+ /* Common device config */
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeSmeCommonConfigGetReqSend(0);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (deviceConfig != NULL) {
+ memcpy((unsigned char*)deviceConfig,
+ (unsigned char*)&priv->sme_reply.deviceConfig,
+ sizeof(CsrWifiSmeDeviceConfig));
+ }
+
+ /* STA config */
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeSmeStaConfigGetReqSend(0, CSR_WIFI_INTERFACE_IN_USE);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (staConfig != NULL) {
+ memcpy((unsigned char*)staConfig,
+ (unsigned char*)&priv->sme_reply.staConfig,
+ sizeof(CsrWifiSmeStaConfig));
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_sme_config_get: unifi_mgt_sme_config_get_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtSmeConfigGetReq(priv->smepriv, staConfig);
+ status = CsrWifiSmeMgtDeviceConfigGetReq(priv->smepriv, deviceConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+int sme_mgt_coex_info_get(unifi_priv_t *priv, CsrWifiSmeCoexInfo *coexInfo)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_coex_info_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_coex_info_get: unifi_mgt_coex_info_get_req -->\n");
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeCoexInfoGetReqSend(0);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (coexInfo != NULL) {
+ memcpy((unsigned char*)coexInfo,
+ (unsigned char*)&priv->sme_reply.coexInfo,
+ sizeof(CsrWifiSmeCoexInfo));
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_coex_info_get: unifi_mgt_coex_info_get_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtCoexInfoGetReq(priv->smepriv, coexInfo);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+#ifdef CSR_SUPPORT_WEXT
+
+int sme_mgt_coex_config_get(unifi_priv_t *priv, CsrWifiSmeCoexConfig *coexConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_coex_config_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_coex_config_get: unifi_mgt_coex_config_get_req -->\n");
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeCoexConfigGetReqSend(0);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (coexConfig != NULL) {
+ memcpy((unsigned char*)coexConfig,
+ (unsigned char*)&priv->sme_reply.coexConfig,
+ sizeof(CsrWifiSmeCoexConfig));
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_coex_config_get: unifi_mgt_coex_config_get_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtCoexConfigGetReq(priv->smepriv, coexConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+int sme_mgt_mib_config_get(unifi_priv_t *priv, CsrWifiSmeMibConfig *mibConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_mib_config_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_mib_config_get: unifi_mgt_mib_config_get_req -->\n");
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeMibConfigGetReqSend(0);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (mibConfig != NULL) {
+ memcpy((unsigned char*)mibConfig,
+ (unsigned char*)&priv->sme_reply.mibConfig,
+ sizeof(CsrWifiSmeMibConfig));
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_mib_config_get: unifi_mgt_mib_config_get_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtMibConfigGetReq(priv->smepriv, mibConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+int sme_mgt_connection_info_get(unifi_priv_t *priv, CsrWifiSmeConnectionInfo *connectionInfo)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_connection_info_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_connection_info_get: unifi_mgt_connection_info_get_req -->\n");
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeConnectionInfoGetReqSend(0, CSR_WIFI_INTERFACE_IN_USE);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (connectionInfo != NULL) {
+ memcpy((unsigned char*)connectionInfo,
+ (unsigned char*)&priv->sme_reply.connectionInfo,
+ sizeof(CsrWifiSmeConnectionInfo));
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_connection_info_get: unifi_mgt_connection_info_get_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtConnectionInfoGetReq(priv->smepriv, connectionInfo);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+int sme_mgt_connection_config_get(unifi_priv_t *priv, CsrWifiSmeConnectionConfig *connectionConfig)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_connection_config_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_connection_config_get: unifi_mgt_connection_config_get_req -->\n");
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeConnectionConfigGetReqSend(0, CSR_WIFI_INTERFACE_IN_USE);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (connectionConfig != NULL) {
+ memcpy((unsigned char*)connectionConfig,
+ (unsigned char*)&priv->sme_reply.connectionConfig,
+ sizeof(CsrWifiSmeConnectionConfig));
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_connection_config_get: unifi_mgt_connection_config_get_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtConnectionConfigGetReq(priv->smepriv, connectionConfig);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+int sme_mgt_connection_stats_get(unifi_priv_t *priv, CsrWifiSmeConnectionStats *connectionStats)
+{
+#ifdef CSR_SME_USERSPACE
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_connection_stats_get: invalid smepriv\n");
+ return -EIO;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_connection_stats_get: unifi_mgt_connection_stats_get_req -->\n");
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeConnectionStatsGetReqSend(0, CSR_WIFI_INTERFACE_IN_USE);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ /* store the reply */
+ if (connectionStats != NULL) {
+ memcpy((unsigned char*)connectionStats,
+ (unsigned char*)&priv->sme_reply.connectionStats,
+ sizeof(CsrWifiSmeConnectionStats));
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_mgt_connection_stats_get: unifi_mgt_connection_stats_get_req <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+
+ return convert_sme_error(priv->sme_reply.reply_status);
+#else
+ CsrResult status;
+ CsrWifiSmeMgtClaimSyncAccess(priv->smepriv);
+ status = CsrWifiSmeMgtConnectionStatsGetReq(priv->smepriv, connectionStats);
+ CsrWifiSmeMgtReleaseSyncAccess(priv->smepriv);
+ return convert_sme_error(status);
+#endif
+}
+
+#endif /* CSR_SUPPORT_WEXT */
+
+int sme_mgt_packet_filter_set(unifi_priv_t *priv)
+{
+ CsrWifiIp4Address ipAddress = {{0xFF, 0xFF, 0xFF, 0xFF }};
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_packet_filter_set: invalid smepriv\n");
+ return -EIO;
+ }
+ if (priv->packet_filters.arp_filter) {
+ ipAddress.a[0] = (priv->sta_ip_address ) & 0xFF;
+ ipAddress.a[1] = (priv->sta_ip_address >> 8) & 0xFF;
+ ipAddress.a[2] = (priv->sta_ip_address >> 16) & 0xFF;
+ ipAddress.a[3] = (priv->sta_ip_address >> 24) & 0xFF;
+ }
+
+ unifi_trace(priv, UDBG5,
+ "sme_mgt_packet_filter_set: IP address %d.%d.%d.%d\n",
+ ipAddress.a[0], ipAddress.a[1],
+ ipAddress.a[2], ipAddress.a[3]);
+
+ /* Doesn't block for a confirm */
+ CsrWifiSmePacketFilterSetReqSend(0, CSR_WIFI_INTERFACE_IN_USE,
+ priv->packet_filters.tclas_ies_length,
+ priv->filter_tclas_ies,
+ priv->packet_filters.filter_mode,
+ ipAddress);
+ return 0;
+}
+
+int sme_mgt_tspec(unifi_priv_t *priv, CsrWifiSmeListAction action,
+ CsrUint32 tid, CsrWifiSmeDataBlock *tspec, CsrWifiSmeDataBlock *tclas)
+{
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_mgt_tspec: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiSmeTspecReqSend(0, CSR_WIFI_INTERFACE_IN_USE,
+ action, tid, TRUE, 0,
+ tspec->length, tspec->data,
+ tclas->length, tclas->data);
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4, "sme_mgt_tspec: <-- (status=%d)\n", priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+}
+
+
+
+int sme_sys_suspend(unifi_priv_t *priv)
+{
+ int r;
+ CsrResult csrResult;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_sys_suspend: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ /* Suspend the SME, which MAY cause it to power down UniFi */
+ CsrWifiRouterCtrlSuspendIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, 0, priv->wol_suspend);
+ r = sme_wait_for_reply(priv, UNIFI_SME_SYS_LONG_TIMEOUT);
+ if (r) {
+ /* No reply - forcibly power down in case the request wasn't processed */
+ unifi_notice(priv,
+ "suspend: SME did not reply %s, ",
+ (priv->ptest_mode | priv->wol_suspend) ? "leave powered" : "power off UniFi anyway\n");
+
+ /* Leave power on for production test, though */
+ if (!priv->ptest_mode) {
+ /* Put UniFi to deep sleep, in case we can not power it off */
+ CsrSdioClaim(priv->sdio);
+ unifi_trace(priv, UDBG1, "Force deep sleep");
+ csrResult = unifi_force_low_power_mode(priv->card);
+
+ /* For WOL, the UniFi must stay powered */
+ if (!priv->wol_suspend) {
+ unifi_trace(priv, UDBG1, "Power off\n");
+ CsrSdioPowerOff(priv->sdio);
+ }
+ CsrSdioRelease(priv->sdio);
+ }
+ }
+
+ if (priv->wol_suspend) {
+ unifi_trace(priv, UDBG1, "UniFi left powered for WOL\n");
+
+ /* Remove the IRQ, which also disables the card SDIO interrupt.
+ * Disabling the card SDIO interrupt enables the PIO WOL source.
+ * Removal of the of the handler ensures that in both SDIO and PIO cases
+ * the card interrupt only wakes the host. The card will be polled
+ * after resume to handle any pending data.
+ */
+ if (csr_sdio_linux_remove_irq(priv->sdio)) {
+ unifi_notice(priv, "WOL csr_sdio_linux_remove_irq failed\n");
+ }
+
+ if (enable_wol == UNIFI_WOL_SDIO) {
+ /* Because csr_sdio_linux_remove_irq() disabled the card SDIO interrupt,
+ * it must be left enabled to wake-on-SDIO.
+ */
+ unifi_trace(priv, UDBG1, "Enable card SDIO interrupt for SDIO WOL\n");
+
+ CsrSdioClaim(priv->sdio);
+ csrResult = CsrSdioInterruptEnable(priv->sdio);
+ CsrSdioRelease(priv->sdio);
+
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "WOL CsrSdioInterruptEnable failed %d\n", csrResult);
+ }
+ } else {
+ unifi_trace(priv, UDBG1, "Disabled card SDIO interrupt for PIO WOL\n");
+ }
+
+ /* Prevent the BH thread from running during the suspend.
+ * Upon resume, sme_sys_resume() will trigger a wifi-on, this will cause
+ * the BH thread to be re-enabled and reinstall the ISR.
+ */
+ priv->bh_thread.block_thread = 1;
+
+ unifi_trace(priv, UDBG1, "unifi_suspend: suspended BH");
+ }
+
+ /* Consider UniFi to be uninitialised */
+ priv->init_progress = UNIFI_INIT_NONE;
+
+ unifi_trace(priv, UDBG1, "sme_sys_suspend: <-- (r=%d status=%d)\n", r, priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+}
+
+
+int sme_sys_resume(unifi_priv_t *priv)
+{
+ int r;
+
+ unifi_trace(priv, UDBG1, "sme_sys_resume %s\n", priv->wol_suspend ? "warm" : "");
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_sys_resume: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiRouterCtrlResumeIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, priv->wol_suspend);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_SYS_LONG_TIMEOUT);
+ if (r) {
+ unifi_notice(priv,
+ "resume: SME did not reply, return success anyway\n");
+ }
+
+ return 0;
+}
+
+#ifdef CSR_SUPPORT_WEXT_AP
+int sme_ap_stop(unifi_priv_t *priv,CsrUint16 interface_tag)
+{
+ int r;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_ap_stop: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiNmeApStopReqSend(0,interface_tag);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_ap_stop <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+
+}
+
+int sme_ap_start(unifi_priv_t *priv,CsrUint16 interface_tag,
+ CsrWifiSmeApConfig_t * ap_config)
+{
+ int r;
+ CsrWifiSmeApP2pGoConfig p2p_go_param;
+ memset(&p2p_go_param,0,sizeof(CsrWifiSmeApP2pGoConfig));
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_ap_start: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiNmeApStartReqSend(0,interface_tag,CSR_WIFI_AP_TYPE_LEGACY,FALSE,
+ ap_config->ssid,1,ap_config->channel,
+ ap_config->credentials,ap_config->max_connections,
+ p2p_go_param,FALSE);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+ if (r) {
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4,
+ "sme_ap_start <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+}
+
+int sme_ap_config(unifi_priv_t *priv,
+ CsrWifiSmeApMacConfig *ap_mac_config,
+ CsrWifiNmeApConfig *group_security_config)
+{
+ int r;
+ CsrWifiSmeApP2pGoConfig p2p_go_param;
+ memset(&p2p_go_param,0,sizeof(CsrWifiSmeApP2pGoConfig));
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_ap_config: invalid smepriv\n");
+ return -EIO;
+ }
+
+ r = sme_init_request(priv);
+ if (r) {
+ return -EIO;
+ }
+
+ CsrWifiNmeApConfigSetReqSend(0,*group_security_config,
+ *ap_mac_config);
+
+ r = sme_wait_for_reply(priv, UNIFI_SME_MGT_SHORT_TIMEOUT);
+
+ unifi_trace(priv, UDBG4,
+ "sme_ap_config <-- (r=%d status=%d)\n",
+ r, priv->sme_reply.reply_status);
+ return convert_sme_error(priv->sme_reply.reply_status);
+}
+#endif
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: sme_mgt.c
+ *
+ * PURPOSE:
+ * This file contains the driver specific implementation of
+ * the SME MGT SAP.
+ * It is part of the porting exercise.
+ *
+ * Copyright (C) 2008-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+#include "csr_wifi_hip_unifiversion.h"
+#include "unifi_priv.h"
+#include "csr_wifi_hip_conversions.h"
+/*
+ * This file implements the SME MGT API. It contains the following functions:
+ * CsrWifiSmeWifiFlightmodeCfmSend()
+ * CsrWifiSmeWifiOnCfmSend()
+ * CsrWifiSmeWifiOffCfmSend()
+ * CsrWifiSmeWifiOffIndSend()
+ * CsrWifiSmeScanFullCfmSend()
+ * CsrWifiSmeScanResultsGetCfmSend()
+ * CsrWifiSmeScanResultIndSend()
+ * CsrWifiSmeScanResultsFlushCfmSend()
+ * CsrWifiSmeConnectCfmSend()
+ * CsrWifiSmeMediaStatusIndSend()
+ * CsrWifiSmeDisconnectCfmSend()
+ * CsrWifiSmeKeyCfmSend()
+ * CsrWifiSmeMulticastAddressCfmSend()
+ * CsrWifiSmeSetValueCfmSend()
+ * CsrWifiSmeGetValueCfmSend()
+ * CsrWifiSmeMicFailureIndSend()
+ * CsrWifiSmePmkidCfmSend()
+ * CsrWifiSmePmkidCandidateListIndSend()
+ * CsrWifiSmeMibSetCfmSend()
+ * CsrWifiSmeMibGetCfmSend()
+ * CsrWifiSmeMibGetNextCfmSend()
+ * CsrWifiSmeConnectionQualityIndSend()
+ * CsrWifiSmePacketFilterSetCfmSend()
+ * CsrWifiSmeTspecCfmSend()
+ * CsrWifiSmeTspecIndSend()
+ * CsrWifiSmeBlacklistCfmSend()
+ * CsrWifiSmeEventMaskSetCfmSend()
+ * CsrWifiSmeRoamStartIndSend()
+ * CsrWifiSmeRoamCompleteIndSend()
+ * CsrWifiSmeAssociationStartIndSend()
+ * CsrWifiSmeAssociationCompleteIndSend()
+ * CsrWifiSmeIbssStationIndSend()
+ */
+
+
+void CsrWifiSmeMicFailureIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeMicFailureInd* ind = (CsrWifiSmeMicFailureInd*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeMicFailureIndSend: invalid priv\n");
+ return;
+ }
+
+ unifi_trace(priv, UDBG1,
+ "CsrWifiSmeMicFailureIndSend: count=%d, KeyType=%d\n",
+ ind->count, ind->keyType);
+
+ wext_send_michaelmicfailure_event(priv, ind->count, ind->address, ind->keyType, ind->interfaceTag);
+#endif
+}
+
+
+void CsrWifiSmePmkidCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmePmkidCfm* cfm = (CsrWifiSmePmkidCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmePmkidCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ /*
+ * WEXT never does a GET operation the PMKIDs, so we don't need
+ * handle data returned in pmkids.
+ */
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+
+void CsrWifiSmePmkidCandidateListIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmePmkidCandidateListInd* ind = (CsrWifiSmePmkidCandidateListInd*)msg;
+ int i;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "CsrWifiSmePmkidCandidateListIndSend: invalid smepriv\n");
+ return;
+ }
+
+ for (i = 0; i < ind->pmkidCandidatesCount; i++)
+ {
+ wext_send_pmkid_candidate_event(priv, ind->pmkidCandidates[i].bssid, ind->pmkidCandidates[i].preAuthAllowed, ind->interfaceTag);
+ }
+#endif
+}
+
+void CsrWifiSmeScanResultsFlushCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeScanResultsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeScanResultsGetCfm* cfm = (CsrWifiSmeScanResultsGetCfm*)msg;
+ int bytesRequired = cfm->scanResultsCount * sizeof(CsrWifiSmeScanResult);
+ int i;
+ CsrUint8* current_buff;
+ CsrWifiSmeScanResult* scanCopy;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeScanResultsGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ /* Calc the size of the buffer reuired */
+ for (i = 0; i < cfm->scanResultsCount; ++i) {
+ const CsrWifiSmeScanResult *scan_result = &cfm->scanResults[i];
+ bytesRequired += scan_result->informationElementsLength;
+ }
+
+ /* Take a Copy of the scan Results :-) */
+ scanCopy = CsrPmemAlloc(bytesRequired);
+ memcpy(scanCopy, cfm->scanResults, sizeof(CsrWifiSmeScanResult) * cfm->scanResultsCount);
+
+ /* Take a Copy of the Info Elements AND update the scan result pointers */
+ current_buff = (CsrUint8*)&scanCopy[cfm->scanResultsCount];
+ for (i = 0; i < cfm->scanResultsCount; ++i)
+ {
+ CsrWifiSmeScanResult *scan_result = &scanCopy[i];
+ CsrMemCpy(current_buff, scan_result->informationElements, scan_result->informationElementsLength);
+ scan_result->informationElements = current_buff;
+ current_buff += scan_result->informationElementsLength;
+ }
+
+ priv->sme_reply.reply_scan_results_count = cfm->scanResultsCount;
+ priv->sme_reply.reply_scan_results = scanCopy;
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+
+void CsrWifiSmeScanFullCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeScanFullCfm* cfm = (CsrWifiSmeScanFullCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeScanFullCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+
+void CsrWifiSmeScanResultIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+
+}
+
+
+void CsrWifiSmeConnectCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeConnectCfm* cfm = (CsrWifiSmeConnectCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeConnectCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+
+void CsrWifiSmeDisconnectCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeDisconnectCfm* cfm = (CsrWifiSmeDisconnectCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeDisconnectCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+
+void CsrWifiSmeKeyCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeKeyCfm* cfm = (CsrWifiSmeKeyCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeKeyCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+
+void CsrWifiSmeMulticastAddressCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeMulticastAddressCfm* cfm = (CsrWifiSmeMulticastAddressCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeMulticastAddressCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeWifiFlightmodeCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeWifiFlightmodeCfm* cfm = (CsrWifiSmeWifiFlightmodeCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeWifiFlightmodeCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeWifiOnCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeWifiOnCfm* cfm = (CsrWifiSmeWifiOnCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeWifiOnCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ unifi_trace(priv, UDBG4,
+ "CsrWifiSmeWifiOnCfmSend: wake up status %d\n", cfm->status);
+#ifdef CSR_SUPPORT_WEXT_AP
+ sme_complete_request(priv, cfm->status);
+#endif
+
+#endif
+}
+
+void CsrWifiSmeWifiOffCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeWifiOffCfm* cfm = (CsrWifiSmeWifiOffCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeWifiOffCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+
+void CsrWifiSmeWifiOffIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeWifiOffInd* ind = (CsrWifiSmeWifiOffInd*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiRouterCtrlStoppedReqSend: Invalid ospriv.\n");
+ return;
+ }
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlStoppedReqSend: invalid smepriv\n");
+ return;
+ }
+
+ /*
+ * If the status indicates an error, the SME is in a stopped state.
+ * We need to start it again in order to reinitialise UniFi.
+ */
+ switch (ind->reason) {
+ case CSR_WIFI_SME_CONTROL_INDICATION_ERROR:
+ unifi_trace(priv, UDBG1,
+ "CsrWifiRouterCtrlStoppedReqSend: Restarting SME (ind:%d)\n",
+ ind->reason);
+
+ /* On error, restart the SME */
+ sme_mgt_wifi_on(priv);
+ break;
+ case CSR_WIFI_SME_CONTROL_INDICATION_EXIT:
+#ifdef CSR_SUPPORT_WEXT_AP
+ sme_complete_request(priv, 0);
+#endif
+ break;
+ default:
+ break;
+ }
+
+#endif
+}
+
+void CsrWifiSmeVersionsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeVersionsGetCfm* cfm = (CsrWifiSmeVersionsGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeVersionsGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.versions = cfm->versions;
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmePowerConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmePowerConfigGetCfm* cfm = (CsrWifiSmePowerConfigGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmePowerConfigGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.powerConfig = cfm->powerConfig;
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeHostConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeHostConfigGetCfm* cfm = (CsrWifiSmeHostConfigGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeHostConfigGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.hostConfig = cfm->hostConfig;
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeCoexInfoGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeCoexInfoGetCfm* cfm = (CsrWifiSmeCoexInfoGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeCoexInfoGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.coexInfo = cfm->coexInfo;
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeCoexConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeCoexConfigGetCfm* cfm = (CsrWifiSmeCoexConfigGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeCoexConfigGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.coexConfig = cfm->coexConfig;
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeMibConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeMibConfigGetCfm* cfm = (CsrWifiSmeMibConfigGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeMibConfigGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.mibConfig = cfm->mibConfig;
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeConnectionInfoGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeConnectionInfoGetCfm* cfm = (CsrWifiSmeConnectionInfoGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeConnectionInfoGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.connectionInfo = cfm->connectionInfo;
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeConnectionConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeConnectionConfigGetCfm* cfm = (CsrWifiSmeConnectionConfigGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeConnectionConfigGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.connectionConfig = cfm->connectionConfig;
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeConnectionStatsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeConnectionStatsGetCfm* cfm = (CsrWifiSmeConnectionStatsGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeConnectionStatsGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.connectionStats = cfm->connectionStats;
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeMibSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeMibSetCfm* cfm = (CsrWifiSmeMibSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeMibSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeMibGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeMibGetCfm* cfm = (CsrWifiSmeMibGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeMibGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ if (cfm->mibAttribute == NULL) {
+ unifi_error(priv, "CsrWifiSmeMibGetCfmSend: Empty reply.\n");
+ sme_complete_request(priv, cfm->status);
+ return;
+ }
+
+ if ((priv->mib_cfm_buffer != NULL) &&
+ (priv->mib_cfm_buffer_length >= cfm->mibAttributeLength)) {
+ memcpy(priv->mib_cfm_buffer, cfm->mibAttribute, cfm->mibAttributeLength);
+ priv->mib_cfm_buffer_length = cfm->mibAttributeLength;
+ } else {
+ unifi_error(priv,
+ "CsrWifiSmeMibGetCfmSend: No room to store MIB data (have=%d need=%d).\n",
+ priv->mib_cfm_buffer_length, cfm->mibAttributeLength);
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeMibGetNextCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeMibGetNextCfm* cfm = (CsrWifiSmeMibGetNextCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeMibGetNextCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ /* Need to copy MIB data */
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeConnectionQualityIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeConnectionQualityInd* ind = (CsrWifiSmeConnectionQualityInd*)msg;
+ int signal, noise, snr;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeConnectionQualityIndSend: Invalid ospriv.\n");
+ return;
+ }
+
+ /*
+ * level and noise below are mapped into an unsigned 8 bit number,
+ * ranging from [-192; 63]. The way this is achieved is simply to
+ * add 0x100 onto the number if it is negative,
+ * once clipped to the correct range.
+ */
+ signal = ind->linkQuality.unifiRssi;
+ /* Clip range of snr */
+ snr = (ind->linkQuality.unifiSnr > 0) ? ind->linkQuality.unifiSnr : 0; /* In dB relative, from 0 - 255 */
+ snr = (snr < 255) ? snr : 255;
+ noise = signal - snr;
+
+ /* Clip range of signal */
+ signal = (signal < 63) ? signal : 63;
+ signal = (signal > -192) ? signal : -192;
+
+ /* Clip range of noise */
+ noise = (noise < 63) ? noise : 63;
+ noise = (noise > -192) ? noise : -192;
+
+ /* Make u8 */
+ signal = ( signal < 0 ) ? signal + 0x100 : signal;
+ noise = ( noise < 0 ) ? noise + 0x100 : noise;
+
+ priv->wext_wireless_stats.qual.level = (u8)signal; /* -192 : 63 */
+ priv->wext_wireless_stats.qual.noise = (u8)noise; /* -192 : 63 */
+ priv->wext_wireless_stats.qual.qual = snr; /* 0 : 255 */
+ priv->wext_wireless_stats.qual.updated = 0;
+
+#if WIRELESS_EXT > 16
+ priv->wext_wireless_stats.qual.updated |= IW_QUAL_LEVEL_UPDATED |
+ IW_QUAL_NOISE_UPDATED |
+ IW_QUAL_QUAL_UPDATED;
+#if WIRELESS_EXT > 18
+ priv->wext_wireless_stats.qual.updated |= IW_QUAL_DBM;
+#endif
+#endif
+#endif
+}
+
+void CsrWifiSmePacketFilterSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmePacketFilterSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ /* The packet filter set request does not block for a reply */
+}
+
+void CsrWifiSmeTspecCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeTspecCfm* cfm = (CsrWifiSmeTspecCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeTspecCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeTspecIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeBlacklistCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeEventMaskSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+
+void CsrWifiSmeRoamStartIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeRoamCompleteIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ /* This is called when the association completes, before any 802.1x authentication */
+}
+
+void CsrWifiSmeAssociationStartIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeAssociationCompleteIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeIbssStationIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeWifiOnIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeRestrictedAccessEnableCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeRestrictedAccessDisableCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+
+void CsrWifiSmeAdhocConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeAdhocConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeAdhocConfigSetCfm* cfm = (CsrWifiSmeAdhocConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeCalibrationDataGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeCalibrationDataSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeCalibrationDataSetCfm* cfm = (CsrWifiSmeCalibrationDataSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeCcxConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeCcxConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeCcxConfigSetCfm* cfm = (CsrWifiSmeCcxConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeCloakedSsidsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeCloakedSsidsSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeCloakedSsidsSetCfm* cfm = (CsrWifiSmeCloakedSsidsSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+
+void CsrWifiSmeCoexConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeCoexConfigSetCfm* cfm = (CsrWifiSmeCoexConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeHostConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeHostConfigSetCfm* cfm = (CsrWifiSmeHostConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeLinkQualityGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+
+void CsrWifiSmeMibConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeMibConfigSetCfm* cfm = (CsrWifiSmeMibConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmePermanentMacAddressGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmePowerConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmePowerConfigSetCfm* cfm = (CsrWifiSmePowerConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeRegulatoryDomainInfoGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeRoamingConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeMediaStatusIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeMediaStatusInd* ind = (CsrWifiSmeMediaStatusInd*)msg;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "CsrWifiSmeMediaStatusIndSend: invalid smepriv\n");
+ return;
+ }
+
+ if (ind->mediaStatus == CSR_WIFI_SME_MEDIA_STATUS_CONNECTED) {
+ /*
+ * Send wireless-extension event up to userland to announce
+ * connection.
+ */
+ wext_send_assoc_event(priv,
+ (unsigned char *)ind->connectionInfo.bssid.a,
+ (unsigned char *)ind->connectionInfo.assocReqInfoElements,
+ ind->connectionInfo.assocReqInfoElementsLength,
+ (unsigned char *)ind->connectionInfo.assocRspInfoElements,
+ ind->connectionInfo.assocRspInfoElementsLength,
+ (unsigned char *)ind->connectionInfo.assocScanInfoElements,
+ ind->connectionInfo.assocScanInfoElementsLength);
+
+ unifi_trace(priv, UDBG2,
+ "CsrWifiSmeMediaStatusIndSend: IBSS=%02X:%02X:%02X:%02X:%02X:%02X\n",
+ ind->connectionInfo.bssid.a[0],
+ ind->connectionInfo.bssid.a[1],
+ ind->connectionInfo.bssid.a[2],
+ ind->connectionInfo.bssid.a[3],
+ ind->connectionInfo.bssid.a[4],
+ ind->connectionInfo.bssid.a[5]);
+
+ sme_mgt_packet_filter_set(priv);
+
+ } else {
+ /*
+ * Send wireless-extension event up to userland to announce
+ * connection lost to a BSS.
+ */
+ wext_send_disassoc_event(priv);
+ }
+#endif
+}
+
+void CsrWifiSmeRoamingConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeRoamingConfigSetCfm* cfm = (CsrWifiSmeRoamingConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeRoamingConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeScanConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeScanConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_SUPPORT_WEXT
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeScanConfigSetCfm* cfm = (CsrWifiSmeScanConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+#endif
+}
+
+void CsrWifiSmeStationMacAddressGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeSmeCommonConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeSmeCommonConfigGetCfm* cfm = (CsrWifiSmeSmeCommonConfigGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeCommonConfigGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.deviceConfig = cfm->deviceConfig;
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeSmeStaConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeSmeStaConfigGetCfm* cfm = (CsrWifiSmeSmeStaConfigGetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeStaConfigGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ priv->sme_reply.staConfig = cfm->smeConfig;
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeSmeCommonConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeSmeCommonConfigSetCfm* cfm = (CsrWifiSmeSmeCommonConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeCommonConfigGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeSmeStaConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiSmeSmeStaConfigSetCfm* cfm = (CsrWifiSmeSmeStaConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiSmeSmeStaConfigGetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiSmeGetInterfaceCapabilityCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeErrorIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeInfoIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeCoreDumpIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+void CsrWifiSmeAmpStatusChangeIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiSmeActivateCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+void CsrWifiSmeDeactivateCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+#ifdef CSR_SUPPORT_WEXT
+#ifdef CSR_SUPPORT_WEXT_AP
+void CsrWifiNmeApStartCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiNmeApStartCfm* cfm = (CsrWifiNmeApStartCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiNmeApStartCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiNmeApStopCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiNmeApStopCfm* cfm = (CsrWifiNmeApStopCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiNmeApStopCfmSend: Invalid ospriv.\n");
+ return;
+ }
+
+ sme_complete_request(priv, cfm->status);
+}
+
+void CsrWifiNmeApConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiNmeApConfigSetCfm* cfm = (CsrWifiNmeApConfigSetCfm*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiNmeApConfigSetCfmSend: Invalid ospriv.\n");
+ return;
+ }
+ sme_complete_request(priv, cfm->status);
+}
+#endif
+#endif
--- /dev/null
+/*
+ * ***************************************************************************
+ *
+ * FILE: sme_native.c
+ *
+ * Copyright (C) 2005-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ***************************************************************************
+ */
+
+#include <linux/netdevice.h>
+
+#include "unifi_priv.h"
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_conversions.h"
+
+static const unsigned char wildcard_address[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+int
+uf_sme_init(unifi_priv_t *priv)
+{
+ func_enter();
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
+ sema_init(&priv->mlme_blocking_mutex, 1);
+#else
+ init_MUTEX(&priv->mlme_blocking_mutex);
+#endif
+
+#ifdef CSR_SUPPORT_WEXT
+ {
+ int r = uf_init_wext_interface(priv);
+ if (r != 0) {
+ func_exit();
+ return r;
+ }
+ }
+#endif
+
+
+
+ func_exit();
+ return 0;
+} /* uf_sme_init() */
+
+
+void
+uf_sme_deinit(unifi_priv_t *priv)
+{
+
+ func_enter();
+
+ /* Free memory allocated for the scan table */
+/* unifi_clear_scan_table(priv); */
+
+ /* Cancel any pending workqueue tasks */
+ flush_workqueue(priv->unifi_workqueue);
+
+#ifdef CSR_SUPPORT_WEXT
+ uf_deinit_wext_interface(priv);
+#endif
+
+
+ func_exit();
+} /* uf_sme_deinit() */
+
+
+int sme_mgt_wifi_on(unifi_priv_t *priv)
+{
+ int r,i;
+ CsrInt32 csrResult;
+
+ if (priv == NULL) {
+ return -EINVAL;
+ }
+ /* Initialize the interface mode to None */
+ for (i=0; i<CSR_WIFI_NUM_INTERFACES; i++) {
+ priv->interfacePriv[i]->interfaceMode = 0;
+ }
+
+ /* Set up interface mode so that get_packet_priority() can
+ * select the right QOS priority when WMM is enabled.
+ */
+ priv->interfacePriv[0]->interfaceMode = CSR_WIFI_ROUTER_CTRL_MODE_STA;
+
+ r = uf_request_firmware_files(priv, UNIFI_FW_STA);
+ if (r) {
+ unifi_error(priv, "sme_mgt_wifi_on: Failed to get f/w\n");
+ return r;
+ }
+
+ /*
+ * The request to initialise UniFi might come while UniFi is running.
+ * We need to block all I/O activity until the reset completes, otherwise
+ * an SDIO error might occur resulting an indication to the SME which
+ * makes it think that the initialisation has failed.
+ */
+ priv->bh_thread.block_thread = 1;
+
+ /* Power on UniFi */
+ CsrSdioClaim(priv->sdio);
+ csrResult = CsrSdioPowerOn(priv->sdio);
+ CsrSdioRelease(priv->sdio);
+ if(csrResult != CSR_RESULT_SUCCESS && csrResult != CSR_SDIO_RESULT_NOT_RESET) {
+ return -EIO;
+ }
+
+ if (csrResult == CSR_RESULT_SUCCESS) {
+ /* Initialise UniFi hardware */
+ r = uf_init_hw(priv);
+ if (r) {
+ return r;
+ }
+ }
+
+ /* Re-enable the I/O thread */
+ priv->bh_thread.block_thread = 0;
+
+ /* Disable deep sleep signalling during the firmware initialisation, to
+ * prevent the wakeup mechanism raising the SDIO clock beyond INIT before
+ * the first MLME-RESET.ind. It gets re-enabled at the CONNECTED.ind,
+ * immediately after the MLME-RESET.ind
+ */
+ csrResult = unifi_configure_low_power_mode(priv->card,
+ UNIFI_LOW_POWER_DISABLED,
+ UNIFI_PERIODIC_WAKE_HOST_DISABLED);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_warning(priv,
+ "sme_mgt_wifi_on: unifi_configure_low_power_mode() returned an error\n");
+ }
+
+
+ /* Start the I/O thread */
+ CsrSdioClaim(priv->sdio);
+ r = uf_init_bh(priv);
+ if (r) {
+ CsrSdioPowerOff(priv->sdio);
+ CsrSdioRelease(priv->sdio);
+ return r;
+ }
+ CsrSdioRelease(priv->sdio);
+
+ priv->init_progress = UNIFI_INIT_FW_DOWNLOADED;
+
+ return 0;
+}
+
+int
+sme_sys_suspend(unifi_priv_t *priv)
+{
+ const int interfaceNum = 0; /* FIXME */
+ CsrResult csrResult;
+
+ /* Abort any pending requests. */
+ uf_abort_mlme(priv);
+
+ /* Allow our mlme request to go through. */
+ priv->io_aborted = 0;
+
+ /* Send MLME-RESET.req to UniFi. */
+ unifi_reset_state(priv, priv->netdev[interfaceNum]->dev_addr, 0);
+
+ /* Stop the network traffic */
+ netif_carrier_off(priv->netdev[interfaceNum]);
+
+ /* Put UniFi to deep sleep */
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_force_low_power_mode(priv->card);
+ CsrSdioRelease(priv->sdio);
+
+ return 0;
+} /* sme_sys_suspend() */
+
+
+int
+sme_sys_resume(unifi_priv_t *priv)
+{
+#ifdef CSR_SUPPORT_WEXT
+ /* Send disconnect event so clients will re-initialise connection. */
+ memset(priv->wext_conf.current_ssid, 0, UNIFI_MAX_SSID_LEN);
+ memset((void*)priv->wext_conf.current_bssid, 0, ETH_ALEN);
+ priv->wext_conf.capability = 0;
+ wext_send_disassoc_event(priv);
+#endif
+ return 0;
+} /* sme_sys_resume() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * sme_native_log_event
+ *
+ * Callback function to be registered as the SME event callback.
+ * Copies the signal content into a new udi_log_t struct and adds
+ * it to the read queue for the SME client.
+ *
+ * Arguments:
+ * arg This is the value given to unifi_add_udi_hook, in
+ * this case a pointer to the client instance.
+ * signal Pointer to the received signal.
+ * signal_len Size of the signal structure in bytes.
+ * bulkdata Pointers to any associated bulk data.
+ * dir Direction of the signal. Zero means from host,
+ * non-zero means to host.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+sme_native_log_event(ul_client_t *pcli,
+ const u8 *sig_packed, int sig_len,
+ const bulk_data_param_t *bulkdata,
+ int dir)
+{
+ unifi_priv_t *priv;
+ udi_log_t *logptr;
+ u8 *p;
+ int i, r;
+ int signal_len;
+ int total_len;
+ udi_msg_t *msgptr;
+ CSR_SIGNAL signal;
+ ul_client_t *client = pcli;
+
+ func_enter();
+
+ if (client == NULL) {
+ unifi_error(NULL, "sme_native_log_event: client has exited\n");
+ return;
+ }
+
+ priv = uf_find_instance(client->instance);
+ if (!priv) {
+ unifi_error(priv, "invalid priv\n");
+ return;
+ }
+
+ /* Just a sanity check */
+ if ((sig_packed == NULL) || (sig_len <= 0)) {
+ return;
+ }
+
+ /* Get the unpacked signal */
+ r = read_unpack_signal(sig_packed, &signal);
+ if (r == 0) {
+ signal_len = SigGetSize(&signal);
+ } else {
+ CsrUint16 receiver_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sig_packed) + sizeof(CsrUint16)) & 0xFF00;
+
+ /* The control indications are 1 byte, pass them to client. */
+ if (sig_len == 1) {
+ unifi_trace(priv, UDBG5,
+ "Control indication (0x%x) for native SME.\n",
+ *sig_packed);
+
+ *(u8*)&signal = *sig_packed;
+ signal_len = sig_len;
+ } else if (receiver_id == 0) {
+ /*
+ * Also "unknown" signals with a ReceiverId of 0 are passed to the client
+ * without unpacking. (This is a code size optimisation to allow signals
+ * that the driver not interested in to be dropped from the unpack code).
+ */
+ unifi_trace(priv, UDBG5,
+ "Signal 0x%.4X with ReceiverId 0 for native SME.\n",
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sig_packed));
+
+ *(u8*)&signal = *sig_packed;
+ signal_len = sig_len;
+ } else {
+ unifi_error(priv,
+ "sme_native_log_event - Received unknown signal 0x%.4X.\n",
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sig_packed));
+ return;
+ }
+ }
+
+ unifi_trace(priv, UDBG3, "sme_native_log_event: signal 0x%.4X for %d\n",
+ signal.SignalPrimitiveHeader.SignalId,
+ client->client_id);
+
+ total_len = signal_len;
+ /* Calculate the buffer we need to store signal plus bulk data */
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
+ total_len += bulkdata->d[i].data_length;
+ }
+
+ /* Allocate log structure plus actual signal. */
+ logptr = (udi_log_t *)kmalloc(sizeof(udi_log_t) + total_len, GFP_KERNEL);
+
+ if (logptr == NULL) {
+ unifi_error(priv,
+ "Failed to allocate %d bytes for a UDI log record\n",
+ sizeof(udi_log_t) + total_len);
+ return;
+ }
+
+ /* Fill in udi_log struct */
+ INIT_LIST_HEAD(&logptr->q);
+ msgptr = &logptr->msg;
+ msgptr->length = sizeof(udi_msg_t) + total_len;
+ msgptr->timestamp = jiffies_to_msecs(jiffies);
+ msgptr->direction = dir;
+ msgptr->signal_length = signal_len;
+
+ /* Copy signal and bulk data to the log */
+ p = (u8 *)(msgptr + 1);
+ memcpy(p, &signal, signal_len);
+ p += signal_len;
+
+ /* Append any bulk data */
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
+ int len = bulkdata->d[i].data_length;
+
+ /*
+ * Len here might not be the same as the length in the bulk data slot.
+ * The slot length will always be even, but len could be odd.
+ */
+ if (len > 0) {
+ if (bulkdata->d[i].os_data_ptr) {
+ memcpy(p, bulkdata->d[i].os_data_ptr, len);
+ } else {
+ memset(p, 0, len);
+ }
+ p += len;
+ }
+ }
+
+ /* Add to tail of log queue */
+ down(&client->udi_sem);
+ list_add_tail(&logptr->q, &client->udi_log);
+ up(&client->udi_sem);
+
+ /* Wake any waiting user process */
+ wake_up_interruptible(&client->udi_wq);
+
+ func_exit();
+
+} /* sme_native_log_event() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_ta_indicate_protocol
+ *
+ * Report that a packet of a particular type has been seen
+ *
+ * Arguments:
+ * drv_priv The device context pointer passed to ta_init.
+ * protocol The protocol type enum value.
+ * direction Whether the packet was a tx or rx.
+ * src_addr The source MAC address from the data packet.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * We defer the actual sending to a background workqueue,
+ * see uf_ta_ind_wq().
+ * ---------------------------------------------------------------------------
+ */
+void
+unifi_ta_indicate_protocol(void *ospriv,
+ CsrWifiRouterCtrlTrafficPacketType packet_type,
+ CsrWifiRouterCtrlProtocolDirection direction,
+ const CsrWifiMacAddress *src_addr)
+{
+
+} /* unifi_ta_indicate_protocol */
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_ta_indicate_sampling
+ *
+ * Send the TA sampling information to the SME.
+ *
+ * Arguments:
+ * drv_priv The device context pointer passed to ta_init.
+ * stats The TA sampling data to send.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+unifi_ta_indicate_sampling(void *ospriv, CsrWifiRouterCtrlTrafficStats *stats)
+{
+
+} /* unifi_ta_indicate_sampling() */
+
+
+void
+unifi_ta_indicate_l4stats(void *ospriv,
+ CsrUint32 rxTcpThroughput,
+ CsrUint32 txTcpThroughput,
+ CsrUint32 rxUdpThroughput,
+ CsrUint32 txUdpThroughput)
+{
+
+} /* unifi_ta_indicate_l4stats() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_native_process_udi_signal
+ *
+ * Process interesting signals from the UDI interface.
+ *
+ * Arguments:
+ * pcli A pointer to the client instance.
+ * signal Pointer to the received signal.
+ * signal_len Size of the signal structure in bytes.
+ * bulkdata Pointers to any associated bulk data.
+ * dir Direction of the signal. Zero means from host,
+ * non-zero means to host.
+ *
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+uf_native_process_udi_signal(ul_client_t *pcli,
+ const u8 *packed_signal, int packed_signal_len,
+ const bulk_data_param_t *bulkdata, int dir)
+{
+
+} /* uf_native_process_udi_signal() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * sme_native_mlme_event_handler
+ *
+ * Callback function to be used as the udi_event_callback when registering
+ * as a client.
+ * This function implements a blocking request-reply interface for WEXT.
+ * To use it, a client specifies this function as the udi_event_callback
+ * to ul_register_client(). The signal dispatcher in
+ * unifi_receive_event() will call this function to deliver a signal.
+ *
+ * Arguments:
+ * pcli Pointer to the client instance.
+ * signal Pointer to the received signal.
+ * signal_len Size of the signal structure in bytes.
+ * bulkdata Pointer to structure containing any associated bulk data.
+ * dir Direction of the signal. Zero means from host,
+ * non-zero means to host.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+sme_native_mlme_event_handler(ul_client_t *pcli,
+ const u8 *sig_packed, int sig_len,
+ const bulk_data_param_t *bulkdata,
+ int dir)
+{
+ CSR_SIGNAL signal;
+ int signal_len;
+ unifi_priv_t *priv = uf_find_instance(pcli->instance);
+ int id, r;
+
+ func_enter();
+
+ /* Just a sanity check */
+ if ((sig_packed == NULL) || (sig_len <= 0)) {
+ return;
+ }
+
+ /* Get the unpacked signal */
+ r = read_unpack_signal(sig_packed, &signal);
+ if (r == 0) {
+ signal_len = SigGetSize(&signal);
+ } else {
+ unifi_error(priv,
+ "sme_native_mlme_event_handler - Received unknown signal 0x%.4X.\n",
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sig_packed));
+ return;
+ }
+
+ id = signal.SignalPrimitiveHeader.SignalId;
+ unifi_trace(priv, UDBG4, "wext - Process signal 0x%.4X\n", id);
+
+ /*
+ * Take the appropriate action for the signal.
+ */
+ switch (id) {
+ /*
+ * Confirm replies from UniFi.
+ * These all have zero or one CSR_DATAREF member. (FIXME: check this is still true for softmac)
+ */
+ case CSR_MA_PACKET_CONFIRM_ID:
+ case CSR_MLME_RESET_CONFIRM_ID:
+ case CSR_MLME_GET_CONFIRM_ID:
+ case CSR_MLME_SET_CONFIRM_ID:
+ case CSR_MLME_GET_NEXT_CONFIRM_ID:
+ case CSR_MLME_POWERMGT_CONFIRM_ID:
+ case CSR_MLME_SCAN_CONFIRM_ID:
+ case CSR_MLME_HL_SYNC_CONFIRM_ID:
+ case CSR_MLME_MEASURE_CONFIRM_ID:
+ case CSR_MLME_SETKEYS_CONFIRM_ID:
+ case CSR_MLME_DELETEKEYS_CONFIRM_ID:
+ case CSR_MLME_HL_SYNC_CANCEL_CONFIRM_ID:
+ case CSR_MLME_ADD_PERIODIC_CONFIRM_ID:
+ case CSR_MLME_DEL_PERIODIC_CONFIRM_ID:
+ case CSR_MLME_ADD_AUTONOMOUS_SCAN_CONFIRM_ID:
+ case CSR_MLME_DEL_AUTONOMOUS_SCAN_CONFIRM_ID:
+ case CSR_MLME_SET_PACKET_FILTER_CONFIRM_ID:
+ case CSR_MLME_STOP_MEASURE_CONFIRM_ID:
+ case CSR_MLME_PAUSE_AUTONOMOUS_SCAN_CONFIRM_ID:
+ case CSR_MLME_ADD_TRIGGERED_GET_CONFIRM_ID:
+ case CSR_MLME_DEL_TRIGGERED_GET_CONFIRM_ID:
+ case CSR_MLME_ADD_BLACKOUT_CONFIRM_ID:
+ case CSR_MLME_DEL_BLACKOUT_CONFIRM_ID:
+ case CSR_MLME_ADD_RX_TRIGGER_CONFIRM_ID:
+ case CSR_MLME_DEL_RX_TRIGGER_CONFIRM_ID:
+ case CSR_MLME_CONNECT_STATUS_CONFIRM_ID:
+ case CSR_MLME_MODIFY_BSS_PARAMETER_CONFIRM_ID:
+ case CSR_MLME_ADD_TEMPLATE_CONFIRM_ID:
+ case CSR_MLME_CONFIG_QUEUE_CONFIRM_ID:
+ case CSR_MLME_ADD_TSPEC_CONFIRM_ID:
+ case CSR_MLME_DEL_TSPEC_CONFIRM_ID:
+ case CSR_MLME_START_AGGREGATION_CONFIRM_ID:
+ case CSR_MLME_STOP_AGGREGATION_CONFIRM_ID:
+ case CSR_MLME_SM_START_CONFIRM_ID:
+ case CSR_MLME_LEAVE_CONFIRM_ID:
+ case CSR_MLME_SET_TIM_CONFIRM_ID:
+ case CSR_MLME_GET_KEY_SEQUENCE_CONFIRM_ID:
+ case CSR_MLME_SET_CHANNEL_CONFIRM_ID:
+ case CSR_MLME_ADD_MULTICAST_ADDRESS_CONFIRM_ID:
+ case CSR_DEBUG_GENERIC_CONFIRM_ID:
+ unifi_mlme_copy_reply_and_wakeup_client(pcli, &signal, signal_len, bulkdata);
+ break;
+
+ case CSR_MLME_CONNECTED_INDICATION_ID:
+ /* We currently ignore the connected-ind for softmac f/w development */
+ unifi_info(priv, "CSR_MLME_CONNECTED_INDICATION_ID ignored\n");
+ break;
+
+ default:
+ break;
+ }
+
+ func_exit();
+} /* sme_native_mlme_event_handler() */
+
+
+
+/*
+ * -------------------------------------------------------------------------
+ * unifi_reset_state
+ *
+ * Ensure that a MAC address has been set.
+ * Send the MLME-RESET signal.
+ * This must be called at least once before starting to do any
+ * network activities (e.g. scan, join etc).
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * macaddr Pointer to chip MAC address.
+ * If this is FF:FF:FF:FF:FF:FF it will be replaced
+ * with the MAC address from the chip.
+ * set_default_mib 1 if the f/w must reset the MIB to the default values
+ * 0 otherwise
+ *
+ * Returns:
+ * 0 on success, an error code otherwise.
+ * -------------------------------------------------------------------------
+ */
+int
+unifi_reset_state(unifi_priv_t *priv, unsigned char *macaddr,
+ unsigned char set_default_mib)
+{
+ int r = 0;
+
+ func_enter();
+
+#ifdef CSR_SUPPORT_WEXT
+ /* The reset clears any 802.11 association. */
+ priv->wext_conf.flag_associated = 0;
+#endif
+
+ func_exit();
+ return r;
+} /* unifi_reset_state() */
+
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: sme_sys.c
+ *
+ * PURPOSE:
+ * Driver specific implementation of the SME SYS SAP.
+ * It is part of the porting exercise.
+ *
+ * Copyright (C) 2008-2011 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+#include "csr_wifi_hip_unifiversion.h"
+#include "unifi_priv.h"
+#include "csr_wifi_hip_conversions.h"
+#ifdef CSR_SUPPORT_WEXT_AP
+#include "csr_wifi_sme_sef.h"
+#endif
+
+
+/*
+ * This file implements the SME SYS API and contains the following functions:
+ * CsrWifiRouterCtrlMediaStatusReqHandler()
+ * CsrWifiRouterCtrlHipReqHandler()
+ * CsrWifiRouterCtrlPortConfigureReqHandler()
+ * CsrWifiRouterCtrlWifiOnReqHandler()
+ * CsrWifiRouterCtrlWifiOffReqHandler()
+ * CsrWifiRouterCtrlSuspendResHandler()
+ * CsrWifiRouterCtrlResumeResHandler()
+ * CsrWifiRouterCtrlQosControlReqHandler()
+ * CsrWifiRouterCtrlConfigurePowerModeReqHandler()
+ * CsrWifiRouterCtrlWifiOnResHandler()
+ * CsrWifiRouterCtrlWifiOffRspHandler()
+ * CsrWifiRouterCtrlMulticastAddressResHandler()
+ * CsrWifiRouterCtrlTrafficConfigReqHandler()
+ * CsrWifiRouterCtrlTrafficClassificationReqHandler()
+ * CsrWifiRouterCtrlTclasAddReqHandler()
+ * CsrWifiRouterCtrlTclasDelReqHandler()
+ * CsrWifiRouterCtrlSetModeReqHandler()
+ * CsrWifiRouterCtrlWapiMulticastFilterReqHandler()
+ * CsrWifiRouterCtrlWapiUnicastFilterReqHandler()
+ * CsrWifiRouterCtrlWapiUnicastTxPktReqHandler()
+ * CsrWifiRouterCtrlWapiRxPktReqHandler()
+ * CsrWifiRouterCtrlWapiFilterReqHandler()
+ */
+
+#ifdef CSR_SUPPORT_SME
+static void check_inactivity_timer_expire_func(unsigned long data);
+void uf_send_disconnected_ind_wq(struct work_struct *work);
+#endif
+
+void send_auto_ma_packet_confirm(unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ struct list_head *buffered_frames_list)
+{
+ tx_buffered_packets_t *buffered_frame_item = NULL;
+ struct list_head *listHead;
+ struct list_head *placeHolder;
+ int client_id;
+
+ CSR_SIGNAL unpacked_signal;
+ CsrUint8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
+ CsrUint16 packed_siglen;
+
+
+ list_for_each_safe(listHead, placeHolder, buffered_frames_list)
+ {
+ buffered_frame_item = list_entry(listHead, tx_buffered_packets_t, q);
+
+ if(!buffered_frame_item) {
+ unifi_error(priv, "Entry should exist, otherwise it is a (BUG)\n");
+ continue;
+ }
+
+ if ((interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_NONE) &&
+ (priv->wifi_on_state == wifi_on_done))
+ {
+
+ unifi_warning(priv, "Send MA_PACKET_CONFIRM to SenderProcessId = %x for (HostTag = %x TransmissionControl = %x)\n",
+ (buffered_frame_item->leSenderProcessId),
+ buffered_frame_item->hostTag,
+ buffered_frame_item->transmissionControl);
+
+ client_id = buffered_frame_item->leSenderProcessId & 0xFF00;
+
+ if (client_id == priv->sme_cli->sender_id)
+ {
+ /* construct a MA-PACKET.confirm message for SME */
+ memset(&unpacked_signal, 0, sizeof(unpacked_signal));
+ unpacked_signal.SignalPrimitiveHeader.SignalId = CSR_MA_PACKET_CONFIRM_ID;
+ unpacked_signal.SignalPrimitiveHeader.ReceiverProcessId = buffered_frame_item->leSenderProcessId;
+ unpacked_signal.SignalPrimitiveHeader.SenderProcessId = CSR_WIFI_ROUTER_IFACEQUEUE;
+
+ unpacked_signal.u.MaPacketConfirm.VirtualInterfaceIdentifier = uf_get_vif_identifier(interfacePriv->interfaceMode,
+ interfacePriv->InterfaceTag);
+ unpacked_signal.u.MaPacketConfirm.TransmissionStatus = CSR_RESULT_FAILURE;
+ unpacked_signal.u.MaPacketConfirm.RetryCount = 0;
+ unpacked_signal.u.MaPacketConfirm.Rate = buffered_frame_item->rate;
+ unpacked_signal.u.MaPacketConfirm.HostTag = buffered_frame_item->hostTag;
+
+ write_pack(&unpacked_signal, sigbuf, &packed_siglen);
+ unifi_warning(priv, "MA_PACKET_CONFIRM for SME (0x%x, 0x%x, 0x%x, 0x%x)\n",
+ unpacked_signal.SignalPrimitiveHeader.ReceiverProcessId,
+ unpacked_signal.SignalPrimitiveHeader.SenderProcessId,
+ unpacked_signal.u.MaPacketConfirm.VirtualInterfaceIdentifier,
+ unpacked_signal.u.MaPacketConfirm.HostTag);
+
+ CsrWifiRouterCtrlHipIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,
+ packed_siglen,
+ (CsrUint8 *)sigbuf,
+ 0, NULL,
+ 0, NULL);
+ }
+ else if((buffered_frame_item->hostTag & 0x80000000))
+ {
+ /* construct a MA-PACKET.confirm message for NME */
+ unifi_warning(priv, "MA_PACKET_CONFIRM for NME (0x%x, 0x%x, 0x%x, 0x%x)\n",
+ buffered_frame_item->leSenderProcessId,
+ buffered_frame_item->interfaceTag,
+ buffered_frame_item->transmissionControl,
+ (buffered_frame_item->hostTag & 0x3FFFFFFF));
+
+ CsrWifiRouterMaPacketCfmSend((buffered_frame_item->leSenderProcessId & 0xFF),
+ buffered_frame_item->interfaceTag,
+ CSR_RESULT_FAILURE,
+ (buffered_frame_item->hostTag & 0x3FFFFFFF),
+ buffered_frame_item->rate);
+
+ }
+ else
+ {
+ unifi_warning(priv, "Buffered packet dropped without sending a confirm\n");
+ }
+
+ }
+
+ list_del(listHead);
+ kfree(buffered_frame_item);
+ buffered_frame_item = NULL;
+ }
+}
+
+void CsrWifiRouterCtrlMediaStatusReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlMediaStatusReq* req = (CsrWifiRouterCtrlMediaStatusReq*)msg;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+ unsigned long flags;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlMediaStatusReqHandler: invalid smepriv\n");
+ return;
+ }
+ if (req->interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "CsrWifiRouterCtrlMediaStatusReqHandler: invalid interfaceTag\n");
+ return;
+ }
+ unifi_trace(priv, UDBG3, "CsrWifiRouterCtrlMediaStatusReqHandler: Mode = %d req->mediaStatus = %d\n",interfacePriv->interfaceMode,req->mediaStatus);
+ if (interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_AMP) {
+ bulk_data_desc_t bulk_data;
+
+ bulk_data.data_length = 0;
+
+ spin_lock_irqsave(&priv->m4_lock, flags);
+ if (interfacePriv->m4_bulk_data.data_length > 0) {
+ bulk_data = interfacePriv->m4_bulk_data;
+ interfacePriv->m4_bulk_data.net_buf_length = 0;
+ interfacePriv->m4_bulk_data.data_length = 0;
+ interfacePriv->m4_bulk_data.os_data_ptr = interfacePriv->m4_bulk_data.os_net_buf_ptr = NULL;
+ }
+ spin_unlock_irqrestore(&priv->m4_lock, flags);
+
+ if (bulk_data.data_length != 0) {
+ unifi_trace(priv, UDBG5, "CsrWifiRouterCtrlMediaStatusReqHandler: free M4\n");
+ unifi_net_data_free(priv, &bulk_data);
+ }
+
+ if ((req->mediaStatus == CSR_WIFI_SME_MEDIA_STATUS_CONNECTED) &&
+ (interfacePriv->connected != UnifiConnected)) {
+
+ switch(interfacePriv->interfaceMode){
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ interfacePriv->connected = UnifiConnected;
+ netif_carrier_on(priv->netdev[req->interfaceTag]);
+#ifdef CSR_SUPPORT_WEXT
+ wext_send_started_event(priv);
+#endif
+ unifi_trace(priv, UDBG1,
+ "CsrWifiRouterCtrlMediaStatusReqHandler: AP/P2PGO setting netif_carrier_on\n");
+ UF_NETIF_TX_WAKE_ALL_QUEUES(priv->netdev[req->interfaceTag]);
+ break;
+
+ default:
+#ifdef CSR_SUPPORT_WEXT
+ /* In the WEXT builds (sme and native), the userspace is not ready
+ * to process any EAPOL or WAPI packets, until it has been informed
+ * of the NETDEV_CHANGE.
+ */
+ if (interfacePriv->netdev_callback_registered && (interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI)) {
+ interfacePriv->wait_netdev_change = TRUE;
+ unifi_trace(priv, UDBG1,
+ "CsrWifiRouterCtrlMediaStatusReqHandler: waiting for NETDEV_CHANGE\n");
+ /*
+ * Carrier can go to on, only after wait_netdev_change is set to TRUE.
+ * Otherwise there can be a race in uf_netdev_event().
+ */
+ netif_carrier_on(priv->netdev[req->interfaceTag]);
+ unifi_trace(priv, UDBG1,
+ "CsrWifiRouterCtrlMediaStatusReqHandler: STA/P2PCLI setting netif_carrier_on\n");
+ }
+ else
+#endif
+ {
+ /* In the NME build, the userspace does not wait for the NETDEV_CHANGE
+ * so it is ready to process all the EAPOL or WAPI packets.
+ * At this point, we enable all the Tx queues, and we indicate any packets
+ * that are queued (and the respective port is opened).
+ */
+ static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
+ interfacePriv->connected = UnifiConnected;
+ unifi_trace(priv, UDBG1,
+ "CsrWifiRouterMediaStatusReqHandler: UnifiConnected && netif_carrier_on\n");
+ netif_carrier_on(priv->netdev[req->interfaceTag]);
+ UF_NETIF_TX_WAKE_ALL_QUEUES(priv->netdev[req->interfaceTag]);
+ uf_process_rx_pending_queue(priv, UF_UNCONTROLLED_PORT_Q, broadcast_address, 1, interfacePriv->InterfaceTag);
+ uf_process_rx_pending_queue(priv, UF_CONTROLLED_PORT_Q, broadcast_address, 1, interfacePriv->InterfaceTag);
+ }
+ break;
+ }
+ }
+
+ if (req->mediaStatus == CSR_WIFI_SME_MEDIA_STATUS_DISCONNECTED) {
+#ifdef CSR_SUPPORT_WEXT
+ unifi_trace(priv, UDBG1,
+ "CsrWifiRouterMediaStatusReqHandler: cancel waiting for NETDEV_CHANGE\n");
+ interfacePriv->wait_netdev_change = FALSE;
+#endif
+ unifi_trace(priv, UDBG1,
+ "CsrWifiRouterMediaStatusReqHandler: setting netif_carrier_off\n");
+ netif_carrier_off(priv->netdev[req->interfaceTag]);
+#ifdef CSR_SUPPORT_WEXT
+ switch(interfacePriv->interfaceMode){
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ wext_send_started_event(priv);
+ break;
+ default:
+ break;
+ }
+#endif
+ interfacePriv->connected = UnifiNotConnected;
+ }
+ } else {
+ /* For AMP, just update the L2 connected flag */
+ if (req->mediaStatus == CSR_WIFI_SME_MEDIA_STATUS_CONNECTED) {
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlMediaStatusReqHandler: AMP connected\n");
+ interfacePriv->connected = UnifiConnected;
+ } else {
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlMediaStatusReqHandler: AMP disconnected\n");
+ interfacePriv->connected = UnifiNotConnected;
+ }
+ }
+}
+
+
+void CsrWifiRouterCtrlHipReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlHipReq* hipreq = (CsrWifiRouterCtrlHipReq*)msg;
+ bulk_data_param_t bulkdata;
+ u8 *signal_ptr;
+ int signal_length;
+ int r=0;
+ void *dest;
+ CsrResult csrResult;
+ CSR_SIGNAL *signal;
+ CsrUint16 interfaceTag = 0;
+ CSR_MA_PACKET_REQUEST *req;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if (priv == NULL) {
+ return;
+ }
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlHipReqHandler: invalid smepriv\n");
+ return;
+ }
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "CsrWifiRouterCtrlHipReqHandler: invalid interfaceTag\n");
+ return;
+ }
+
+ /* Initialize bulkdata to avoid os_net_buf is garbage */
+ memset(&bulkdata, 0, sizeof(bulk_data_param_t));
+
+ signal = (CSR_SIGNAL *)hipreq->mlmeCommand;
+
+ unifi_trace(priv, UDBG4, "CsrWifiRouterCtrlHipReqHandler: 0x04%X ---->\n",
+ *((CsrUint16*)hipreq->mlmeCommand));
+
+ /* Construct the signal. */
+ signal_ptr = (u8*)hipreq->mlmeCommand;
+ signal_length = hipreq->mlmeCommandLength;
+
+ /*
+ * The MSB of the sender ID needs to be set to the client ID.
+ * The LSB is controlled by the SME.
+ */
+ signal_ptr[5] = (priv->sme_cli->sender_id >> 8) & 0xff;
+
+ /* Allocate buffers for the bulk data. */
+ if (hipreq->dataRef1Length) {
+ csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], hipreq->dataRef1Length);
+ if (csrResult == CSR_RESULT_SUCCESS) {
+ dest = (void*)bulkdata.d[0].os_data_ptr;
+ memcpy(dest, hipreq->dataRef1, hipreq->dataRef1Length);
+ bulkdata.d[0].data_length = hipreq->dataRef1Length;
+ } else {
+ unifi_warning(priv, "signal not sent down, allocation failed in CsrWifiRouterCtrlHipReqHandler\n");
+ return;
+ }
+ } else {
+ bulkdata.d[0].os_data_ptr = NULL;
+ bulkdata.d[0].data_length = 0;
+ }
+ if (hipreq->dataRef2Length) {
+ csrResult = unifi_net_data_malloc(priv, &bulkdata.d[1], hipreq->dataRef2Length);
+ if (csrResult == CSR_RESULT_SUCCESS) {
+ dest = (void*)bulkdata.d[1].os_data_ptr;
+ memcpy(dest, hipreq->dataRef2, hipreq->dataRef2Length);
+ bulkdata.d[1].data_length = hipreq->dataRef2Length;
+ } else {
+ if (bulkdata.d[0].data_length)
+ {
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ }
+ unifi_warning(priv, "signal not sent down, allocation failed in CsrWifiRouterCtrlHipReqHandler\n");
+ return;
+ }
+ } else {
+ bulkdata.d[1].os_data_ptr = NULL;
+ bulkdata.d[1].data_length = 0;
+ }
+
+ unifi_trace(priv, UDBG3, "SME SEND: Signal 0x%.4X \n",
+ *((CsrUint16*)signal_ptr));
+ if (signal->SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_REQUEST_ID)
+ {
+ CSR_SIGNAL unpacked_signal;
+ read_unpack_signal((u8 *) signal, &unpacked_signal);
+ req = &unpacked_signal.u.MaPacketRequest;
+ interfaceTag = req->VirtualInterfaceIdentifier & 0xff;
+ switch(interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_NONE:
+ unifi_error(priv, "CsrWifiRouterCtrlHipReqHandler: invalid mode: NONE \n");
+ break;
+ default:
+ unifi_trace(priv, UDBG5, "mode is %x\n", interfacePriv->interfaceMode);
+ }
+ /* While sending ensure that first 2 bits b31 and b30 are 00. These are used for local routing*/
+ r = uf_process_ma_packet_req(priv, req->Ra.x, (req->HostTag & 0x3FFFFFFF), interfaceTag,
+ req->TransmissionControl, req->TransmitRate,
+ req->Priority, signal->SignalPrimitiveHeader.SenderProcessId,
+ &bulkdata);
+ if (r)
+ {
+ if (bulkdata.d[0].data_length)
+ {
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ }
+ if (bulkdata.d[1].data_length)
+ {
+ unifi_net_data_free(priv, &bulkdata.d[1]);
+ }
+ }
+ } else {
+ /* ul_send_signal_raw frees the bulk data if it fails */
+ r = ul_send_signal_raw(priv, signal_ptr, signal_length, &bulkdata);
+ }
+
+ if (r) {
+ unifi_error(priv,
+ "CsrWifiRouterCtrlHipReqHandler: Failed to send signal (0x%.4X - %u)\n",
+ *((CsrUint16*)signal_ptr), r);
+ CsrWifiRouterCtrlWifiOffIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,CSR_WIFI_SME_CONTROL_INDICATION_ERROR);
+ }
+
+ unifi_trace(priv, UDBG4, "CsrWifiRouterCtrlHipReqHandler: <----\n");
+}
+
+#ifdef CSR_WIFI_SEND_GRATUITOUS_ARP
+static void
+uf_send_gratuitous_arp(unifi_priv_t *priv, CsrUint16 interfaceTag)
+{
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ CSR_PRIORITY priority;
+ CSR_SIGNAL signal;
+ bulk_data_param_t bulkdata;
+ CsrResult csrResult;
+ struct sk_buff *skb, *newSkb = NULL;
+ CsrInt8 protection;
+ int r;
+ static const CsrUint8 arp_req[36] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00,
+ 0x08, 0x06, 0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01,
+ 0x00, 0x02, 0x5f, 0x20, 0x2f, 0x02,
+ 0xc0, 0xa8, 0x00, 0x02,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xc0, 0xa8, 0x00, 0x02};
+
+ func_enter();
+
+ csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], sizeof(arp_req));
+ if (csrResult != CSR_RESULT_SUCCESS)
+ {
+ unifi_error(priv, "Failed to allocate bulk data in CsrWifiSmeRoamCompleteIndHandler()\n");
+ return;
+ }
+ skb = (struct sk_buff *)(bulkdata.d[0].os_net_buf_ptr);
+ skb->len = bulkdata.d[0].data_length;
+
+ memcpy(skb->data, arp_req, sizeof(arp_req));
+ /* add MAC and IP address */
+ memcpy(skb->data + 16, priv->netdev[interfaceTag]->dev_addr, ETH_ALEN);
+ skb->data[22] = (priv->sta_ip_address ) & 0xFF;
+ skb->data[23] = (priv->sta_ip_address >> 8) & 0xFF;
+ skb->data[24] = (priv->sta_ip_address >> 16) & 0xFF;
+ skb->data[25] = (priv->sta_ip_address >> 24) & 0xFF;
+ skb->data[32] = (priv->sta_ip_address ) & 0xFF;
+ skb->data[33] = (priv->sta_ip_address >> 8) & 0xFF;
+ skb->data[34] = (priv->sta_ip_address >> 16) & 0xFF;
+ skb->data[35] = (priv->sta_ip_address >> 24) & 0xFF;
+
+ bulkdata.d[1].os_data_ptr = NULL;
+ bulkdata.d[1].os_net_buf_ptr = NULL;
+ bulkdata.d[1].net_buf_length = bulkdata.d[1].data_length = 0;
+
+ if ((protection = uf_get_protection_bit_from_interfacemode(priv, interfaceTag, &arp_req[26])) < 0)
+ {
+ unifi_error(priv, "CsrWifiSmeRoamCompleteIndHandler: Failed to determine protection mode\n");
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ return;
+ }
+
+ if ((priv->sta_wmm_capabilities & QOS_CAPABILITY_WMM_ENABLED) == 1)
+ {
+ priority = CSR_QOS_UP0;
+ }
+ else
+ {
+ priority = CSR_CONTENTION;
+ }
+
+ if (prepare_and_add_macheader(priv, skb, newSkb, priority, &bulkdata,
+ interfaceTag, &arp_req[26],
+ priv->netdev[interfaceTag]->dev_addr, protection))
+ {
+ unifi_error(priv, "CsrWifiSmeRoamCompleteIndHandler: failed to create MAC header\n");
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ return;
+ }
+ bulkdata.d[0].os_data_ptr = skb->data;
+ bulkdata.d[0].os_net_buf_ptr = skb;
+ bulkdata.d[0].data_length = skb->len;
+
+ unifi_frame_ma_packet_req(priv, priority, 0, 0xffffffff, interfaceTag,
+ CSR_NO_CONFIRM_REQUIRED, priv->netdev_client->sender_id,
+ interfacePriv->bssid.a, &signal);
+
+ r = ul_send_signal_unpacked(priv, &signal, &bulkdata);
+ if (r)
+ {
+ unifi_error(priv, "CsrWifiSmeRoamCompleteIndHandler: failed to send QOS data null packet result: %d\n",r);
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ return;
+ }
+
+ func_exit();
+
+}
+#endif /* CSR_WIFI_SEND_GRATUITOUS_ARP */
+
+/*
+ * ---------------------------------------------------------------------------
+ * configure_data_port
+ *
+ * Store the new controlled port configuration.
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * port_cfg Pointer to the port configuration
+ *
+ * Returns:
+ * An unifi_ControlledPortAction value.
+ * ---------------------------------------------------------------------------
+ */
+static int
+configure_data_port(unifi_priv_t *priv,
+ CsrWifiRouterCtrlPortAction port_action,
+ const CsrWifiMacAddress *macAddress,
+ const int queue,
+ CsrUint16 interfaceTag)
+{
+ const CsrUint8 broadcast_mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+ unifi_port_config_t *port;
+ netInterface_priv_t *interfacePriv;
+ int i;
+ const char* controlled_string; /* cosmetic "controlled"/"uncontrolled" for trace */
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "configure_data_port: bad interfaceTag\n");
+ return -EFAULT;
+ }
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if (queue == UF_CONTROLLED_PORT_Q) {
+ port = &interfacePriv->controlled_data_port;
+ controlled_string = "controlled";
+ } else {
+ port = &interfacePriv->uncontrolled_data_port;
+ controlled_string = "uncontrolled";
+ }
+
+ unifi_trace(priv, UDBG2, "port config request %02x:%02x:%02x:%02x:%02x:%02x %s with port_action %d.\n",
+ macAddress->a[0], macAddress->a[1], macAddress->a[2],
+ macAddress->a[3], macAddress->a[4], macAddress->a[5],
+ controlled_string, port_action);
+
+
+ /* If the new configuration has the broadcast MAC address or if we are in infrastructure mode then clear the list first and set port overide mode */
+ if ((CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI) ||
+ !memcmp(macAddress->a, broadcast_mac_address, ETH_ALEN)) {
+
+ port->port_cfg[0].port_action = port_action;
+ port->port_cfg[0].mac_address = *macAddress;
+ port->port_cfg[0].in_use = TRUE;
+ port->entries_in_use = 1;
+ port->overide_action = UF_DATA_PORT_OVERIDE;
+
+ unifi_trace(priv, UDBG2, "%s port override on\n",
+ (queue == UF_CONTROLLED_PORT_Q) ? "Controlled" : "Uncontrolled");
+
+ /* Discard the remaining entries in the port config table */
+ for (i = 1; i < UNIFI_MAX_CONNECTIONS; i++) {
+ port->port_cfg[i].in_use = FALSE;
+ }
+
+ if (port_action == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN) {
+ unifi_trace(priv, UDBG1, "%s port broadcast set to open.\n",
+ (queue == UF_CONTROLLED_PORT_Q) ? "Controlled" : "Uncontrolled");
+
+ /*
+ * Ask stack to schedule for transmission any packets queued
+ * while controlled port was not open.
+ * Use netif_schedule() instead of netif_wake_queue() because
+ * transmission should be already enabled at this point. If it
+ * is not, probably the interface is down and should remain as is.
+ */
+ uf_resume_data_plane(priv, queue, *macAddress, interfaceTag);
+
+#ifdef CSR_WIFI_SEND_GRATUITOUS_ARP
+ if ((CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode) &&
+ (queue == UF_CONTROLLED_PORT_Q) && (priv->sta_ip_address != 0xFFFFFFFF))
+ {
+ uf_send_gratuitous_arp(priv, interfaceTag);
+ }
+#endif
+ } else {
+ unifi_trace(priv, UDBG1, "%s port broadcast set to %s.\n",
+ (queue == UF_CONTROLLED_PORT_Q) ? "Controlled" : "Uncontrolled",
+ (port_action == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD) ? "discard": "closed");
+
+ /* If port is closed, discard all the pending Rx packets */
+ if (port_action == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD) {
+ uf_free_pending_rx_packets(priv, queue, *macAddress,interfaceTag);
+ }
+ }
+ } else {
+ /* store the new configuration, either in the entry with matching mac address (if already present),
+ * otherwise in a new entry
+ */
+
+ int found_entry_flag;
+ int first_free_slot = -1;
+
+ /* If leaving override mode, free the port entry used for override */
+ if (port->overide_action == UF_DATA_PORT_OVERIDE) {
+ port->port_cfg[0].in_use = FALSE;
+ port->entries_in_use = 0;
+ port->overide_action = UF_DATA_PORT_NOT_OVERIDE;
+
+ unifi_trace(priv, UDBG2, "%s port override off\n",
+ (queue == UF_CONTROLLED_PORT_Q) ? "Controlled" : "Uncontrolled");
+ }
+
+ found_entry_flag = 0;
+ for (i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ if (port->port_cfg[i].in_use) {
+ if (!memcmp(&port->port_cfg[i].mac_address.a, macAddress->a, ETH_ALEN)) {
+ /* We've seen this address before, reconfigure it */
+ port->port_cfg[i].port_action = port_action;
+ found_entry_flag = 1;
+ break;
+ }
+ } else if (first_free_slot == -1) {
+ /* Remember the first free slot on the way past so it can be claimed
+ * if this turns out to be a new MAC address (to save walking the list again).
+ */
+ first_free_slot = i;
+ }
+ }
+
+ /* At this point we found an existing entry and have updated it, or need to
+ * add a new entry. If all slots are allocated, give up and return an error.
+ */
+ if (!found_entry_flag) {
+ if (first_free_slot == -1) {
+ unifi_error(priv, "no free slot found in port config array (%d used)\n", port->entries_in_use);
+ return -EFAULT;
+ } else {
+ port->entries_in_use++;
+ }
+
+ unifi_trace(priv, UDBG3, "port config index assigned in config_data_port = %d\n", first_free_slot);
+ port->port_cfg[first_free_slot].in_use = TRUE;
+ port->port_cfg[first_free_slot].port_action = port_action;
+ port->port_cfg[first_free_slot].mac_address = *macAddress;
+ }
+
+ if (port_action == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN) {
+ /*
+ * Ask stack to schedule for transmission any packets queued
+ * while controlled port was not open.
+ * Use netif_schedule() instead of netif_wake_queue() because
+ * transmission should be already enabled at this point. If it
+ * is not, probably the interface is down and should remain as is.
+ */
+ uf_resume_data_plane(priv, queue, *macAddress, interfaceTag);
+ }
+
+ /*
+ * If port is closed, discard all the pending Rx packets
+ * coming from the peer station.
+ */
+ if (port_action == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD) {
+ uf_free_pending_rx_packets(priv, queue, *macAddress,interfaceTag);
+ }
+
+ unifi_trace(priv, UDBG2, "port config %02x:%02x:%02x:%02x:%02x:%02x with port_action %d.\n",
+ *(macAddress->a+0), *(macAddress->a+1), *(macAddress->a+2),
+ *(macAddress->a+3), *(macAddress->a+4), *(macAddress->a+5),
+ port_action);
+ }
+ return 0;
+} /* configure_data_port() */
+
+
+void CsrWifiRouterCtrlPortConfigureReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlPortConfigureReq* req = (CsrWifiRouterCtrlPortConfigureReq*)msg;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+
+ unifi_trace(priv, UDBG3, "entering CsrWifiRouterCtrlPortConfigureReqHandler\n");
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlPortConfigureReqHandler: invalid smepriv\n");
+ return;
+ }
+
+ /* To update the protection status of the peer/station */
+ switch(interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_STA:
+ case CSR_WIFI_ROUTER_CTRL_MODE_AMP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
+ /* Since for Unifi as a station, the station record not maintained & interfaceID is
+ * only needed to update the peer protection status
+ */
+ interfacePriv->protect = req->setProtection;
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ {
+ CsrUint8 i;
+ CsrWifiRouterCtrlStaInfo_t *staRecord;
+ /* Ifscontrolled port is open means, The peer has been added to station record
+ * so that the protection corresponding to the peer is valid in this req
+ */
+ if (req->controlledPortAction == CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN) {
+ for(i =0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ staRecord = (CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[i]);
+ if (staRecord) {
+ /* Find the matching station record & set the protection type */
+ if (!memcmp(req->macAddress.a, staRecord->peerMacAddress.a, ETH_ALEN)) {
+ staRecord->protection = req->setProtection;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ default:
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlPortConfigureReqHandler(0x%.4X) Uncaught mode %d\n",
+ msg->source, interfacePriv->interfaceMode);
+ }
+
+ configure_data_port(priv, req->uncontrolledPortAction, (const CsrWifiMacAddress *)&req->macAddress,
+ UF_UNCONTROLLED_PORT_Q, req->interfaceTag);
+ configure_data_port(priv, req->controlledPortAction, (const CsrWifiMacAddress *)&req->macAddress,
+ UF_CONTROLLED_PORT_Q, req->interfaceTag);
+
+ CsrWifiRouterCtrlPortConfigureCfmSend(msg->source,req->clientData,req->interfaceTag,
+ CSR_RESULT_SUCCESS, req->macAddress);
+ unifi_trace(priv, UDBG3, "leaving CsrWifiRouterCtrlPortConfigureReqHandler\n");
+}
+
+
+void CsrWifiRouterCtrlWifiOnReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlVersions versions;
+ CsrWifiRouterCtrlWifiOnReq* req = (CsrWifiRouterCtrlWifiOnReq*)msg;
+ int r,i;
+ CsrResult csrResult;
+
+ if (priv == NULL) {
+ return;
+ }
+ if( priv->wol_suspend ) {
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWifiOnReqHandler: Don't reset mode\n");
+ } else {
+#ifdef ANDROID_BUILD
+ /* Take the wakelock while Wi-Fi On is in progress */
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWifiOnReqHandler: take wake lock\n");
+ wake_lock(&unifi_sdio_wake_lock);
+#endif
+ for (i=0; i<CSR_WIFI_NUM_INTERFACES; i++) {
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWifiOnReqHandler: Setting interface %d to NONE\n", i );
+
+ priv->interfacePriv[i]->interfaceMode = 0;
+ }
+ }
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWifiOnReqHandler(0x%.4X) req->dataLength=%d req->data=0x%x\n", msg->source, req->dataLength, req->data);
+
+ if(req->dataLength==3 && req->data && req->data[0]==0 && req->data[1]==1 && req->data[2]==1)
+ {
+ priv->cmanrTestMode = TRUE;
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWifiOnReqHandler: cmanrTestMode=%d\n", priv->cmanrTestMode);
+ }
+ else
+ {
+ priv->cmanrTestMode = FALSE;
+ }
+
+ /*
+ * The request to initialise UniFi might come while UniFi is running.
+ * We need to block all I/O activity until the reset completes, otherwise
+ * an SDIO error might occur resulting an indication to the SME which
+ * makes it think that the initialisation has failed.
+ */
+ priv->bh_thread.block_thread = 1;
+
+ /* Update the wifi_on state */
+ priv->wifi_on_state = wifi_on_in_progress;
+
+ /* If UniFi was unpowered, acquire the firmware for download to chip */
+ if (!priv->wol_suspend) {
+ r = uf_request_firmware_files(priv, UNIFI_FW_STA);
+ if (r) {
+ unifi_error(priv, "CsrWifiRouterCtrlWifiOnReqHandler: Failed to get f/w\n");
+ CsrWifiRouterCtrlWifiOnCfmSend(msg->source, req->clientData, CSR_RESULT_FAILURE);
+ return;
+ }
+ } else {
+ unifi_trace(priv, UDBG1, "Don't need firmware\n");
+ }
+
+ /* Power on UniFi (which may not necessarily have been off) */
+ CsrSdioClaim(priv->sdio);
+ csrResult = CsrSdioPowerOn(priv->sdio);
+ CsrSdioRelease(priv->sdio);
+ if (csrResult != CSR_RESULT_SUCCESS && csrResult != CSR_SDIO_RESULT_NOT_RESET) {
+ unifi_error(priv, "CsrWifiRouterCtrlWifiOnReqHandler: Failed to power on UniFi\n");
+ CsrWifiRouterCtrlWifiOnCfmSend(msg->source, req->clientData, CSR_RESULT_FAILURE);
+ return;
+ }
+
+ /* If CsrSdioPowerOn() returns CSR_RESULT_SUCCESS, it means that we need to initialise UniFi */
+ if (csrResult == CSR_RESULT_SUCCESS && !priv->wol_suspend) {
+ /* Initialise UniFi hardware */
+ r = uf_init_hw(priv);
+ if (r) {
+ unifi_error(priv, "CsrWifiRouterCtrlWifiOnReqHandler: Failed to initialise h/w, error %d\n", r);
+ CsrWifiRouterCtrlWifiOnCfmSend(msg->source, req->clientData, CSR_RESULT_FAILURE);
+ return;
+ }
+ } else {
+ unifi_trace(priv, UDBG1, "UniFi already initialised\n");
+ }
+
+ /* Completed handling of wake up from suspend with UniFi powered */
+ priv->wol_suspend = FALSE;
+
+ /* Re-enable the I/O thread */
+ priv->bh_thread.block_thread = 0;
+
+ /*
+ * Start the I/O thread. The thread might be already running.
+ * This fine, just carry on with the request.
+ */
+ r = uf_init_bh(priv);
+ if (r) {
+ CsrSdioClaim(priv->sdio);
+ CsrSdioPowerOff(priv->sdio);
+ CsrSdioRelease(priv->sdio);
+ CsrWifiRouterCtrlWifiOnCfmSend(msg->source, req->clientData, CSR_RESULT_FAILURE);
+ return;
+ }
+
+ /* Get the version information from the core */
+ unifi_card_info(priv->card, &priv->card_info);
+
+ /* Set the sme queue id */
+ priv->CSR_WIFI_SME_IFACEQUEUE = msg->source;
+ CSR_WIFI_SME_IFACEQUEUE = msg->source;
+
+
+ /* Copy to the unifiio_card_info structure. */
+ versions.chipId = priv->card_info.chip_id;
+ versions.chipVersion = priv->card_info.chip_version;
+ versions.firmwareBuild = priv->card_info.fw_build;
+ versions.firmwareHip = priv->card_info.fw_hip_version;
+ versions.routerBuild = (CsrCharString*)CSR_WIFI_VERSION;
+ versions.routerHip = (UNIFI_HIP_MAJOR_VERSION << 8) | UNIFI_HIP_MINOR_VERSION;
+
+ CsrWifiRouterCtrlWifiOnIndSend(msg->source, 0, CSR_RESULT_SUCCESS, versions);
+
+ /* Update the wifi_on state */
+ priv->wifi_on_state = wifi_on_done;
+}
+
+
+/*
+ * wifi_off:
+ * Common code for CsrWifiRouterCtrlWifiOffReqHandler() and
+ * CsrWifiRouterCtrlWifiOffRspHandler().
+ */
+static void
+wifi_off(unifi_priv_t *priv)
+{
+ int power_off;
+ int priv_instance;
+ int i;
+ CsrResult csrResult;
+
+
+ /* Already off? */
+ if (priv->wifi_on_state == wifi_on_unspecified) {
+ unifi_trace(priv, UDBG1, "wifi_off already\n");
+ return;
+ }
+
+ unifi_trace(priv, UDBG1, "wifi_off\n");
+
+ /* Destroy the Traffic Analysis Module */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
+ cancel_work_sync(&priv->ta_ind_work.task);
+ cancel_work_sync(&priv->ta_sample_ind_work.task);
+#ifdef CSR_SUPPORT_WEXT
+ cancel_work_sync(&priv->sme_config_task);
+ wext_send_disassoc_event(priv);
+#endif
+
+ /* Cancel pending M4 stuff */
+ for (i = 0; i < CSR_WIFI_NUM_INTERFACES; i++) {
+ if (priv->netdev[i]) {
+ netInterface_priv_t *netpriv = (netInterface_priv_t *) netdev_priv(priv->netdev[i]);
+ cancel_work_sync(&netpriv->send_m4_ready_task);
+ }
+ }
+#endif
+ flush_workqueue(priv->unifi_workqueue);
+
+ /* fw_init parameter can prevent power off UniFi, for debugging */
+ priv_instance = uf_find_priv(priv);
+ if (priv_instance == -1) {
+ unifi_warning(priv,
+ "CsrWifiRouterCtrlStopReqHandler: Unknown priv instance, will power off card.\n");
+ power_off = 1;
+ } else {
+ power_off = (fw_init[priv_instance] > 0) ? 0 : 1;
+ }
+
+ /* Production test mode requires power to the chip, too */
+ if (priv->ptest_mode) {
+ power_off = 0;
+ }
+
+ /* Stop the bh_thread */
+ uf_stop_thread(priv, &priv->bh_thread);
+
+ /* Read the f/w panic codes, if any. Protect against second wifi_off() call,
+ * which may happen if SME requests a wifi_off and closes the char device */
+ if (priv->init_progress != UNIFI_INIT_NONE) {
+ CsrSdioClaim(priv->sdio);
+ unifi_capture_panic(priv->card);
+ CsrSdioRelease(priv->sdio);
+ }
+
+ /* Unregister the interrupt handler */
+ if (csr_sdio_linux_remove_irq(priv->sdio)) {
+ unifi_notice(priv,
+ "csr_sdio_linux_remove_irq failed to talk to card.\n");
+ }
+
+ if (power_off) {
+ unifi_trace(priv, UDBG2,
+ "Force low power and try to power off\n");
+ /* Put UniFi to deep sleep, in case we can not power it off */
+ CsrSdioClaim(priv->sdio);
+ csrResult = unifi_force_low_power_mode(priv->card);
+ CsrSdioRelease(priv->sdio);
+
+ CsrSdioPowerOff(priv->sdio);
+ }
+
+ /* Consider UniFi to be uninitialised */
+ priv->init_progress = UNIFI_INIT_NONE;
+ priv->wifi_on_state = wifi_on_unspecified;
+
+
+} /* wifi_off() */
+
+
+void CsrWifiRouterCtrlWifiOffReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlWifiOffReq* req = (CsrWifiRouterCtrlWifiOffReq*)msg;
+ int i = 0;
+
+ if (priv == NULL) {
+ return;
+ }
+
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWifiOffReqHandler(0x%.4X)\n", msg->source);
+
+ /* Stop the network traffic on all interfaces before freeing the core. */
+ for (i=0; i<CSR_WIFI_NUM_INTERFACES; i++) {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[i];
+ if (interfacePriv->netdev_registered == 1) {
+ netif_carrier_off(priv->netdev[i]);
+ UF_NETIF_TX_STOP_ALL_QUEUES(priv->netdev[i]);
+ interfacePriv->connected = UnifiConnectedUnknown;
+ }
+ interfacePriv->interfaceMode = 0;
+
+ /* Enable all queues by default */
+ interfacePriv->queueEnabled[0] = 1;
+ interfacePriv->queueEnabled[1] = 1;
+ interfacePriv->queueEnabled[2] = 1;
+ interfacePriv->queueEnabled[3] = 1;
+ }
+ wifi_off(priv);
+
+ CsrWifiRouterCtrlWifiOffCfmSend(msg->source,req->clientData);
+
+ /* If this is called in response to closing the character device, the
+ * caller must use uf_sme_cancel_request() to terminate any pending SME
+ * blocking request or there will be a delay while the operation times out.
+ */
+}
+
+
+void CsrWifiRouterCtrlQosControlReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlQosControlReq* req = (CsrWifiRouterCtrlQosControlReq*)msg;
+ netInterface_priv_t *interfacePriv;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlQosControlReqHandler: invalid smepriv\n");
+ return;
+ }
+
+ unifi_trace(priv, UDBG4, "CsrWifiRouterCtrlQosControlReqHandler:scontrol = %d", req->control);
+
+ if (req->interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "CsrWifiRouterCtrlQosControlReqHandler: interfaceID >= CSR_WIFI_NUM_INTERFACES.\n");
+ return;
+ }
+ interfacePriv = priv->interfacePriv[req->interfaceTag];
+
+ if (req->control == CSR_WIFI_ROUTER_CTRL_QOS_CONTROL_WMM_ON) {
+ priv->sta_wmm_capabilities |= QOS_CAPABILITY_WMM_ENABLED;
+ unifi_trace(priv, UDBG1, "WMM enabled\n");
+
+ unifi_trace(priv, UDBG1, "Queue Config %x\n", req->queueConfig);
+
+ interfacePriv->queueEnabled[UNIFI_TRAFFIC_Q_BK] = (req->queueConfig & CSR_WIFI_ROUTER_CTRL_QUEUE_BK_ENABLE)?1:0;
+ interfacePriv->queueEnabled[UNIFI_TRAFFIC_Q_BE] = (req->queueConfig & CSR_WIFI_ROUTER_CTRL_QUEUE_BE_ENABLE)?1:0;
+ interfacePriv->queueEnabled[UNIFI_TRAFFIC_Q_VI] = (req->queueConfig & CSR_WIFI_ROUTER_CTRL_QUEUE_VI_ENABLE)?1:0;
+ interfacePriv->queueEnabled[UNIFI_TRAFFIC_Q_VO] = (req->queueConfig & CSR_WIFI_ROUTER_CTRL_QUEUE_VO_ENABLE)?1:0;
+
+ } else {
+ priv->sta_wmm_capabilities = 0;
+ unifi_trace(priv, UDBG1, "WMM disabled\n");
+ }
+}
+
+
+void CsrWifiRouterCtrlTclasAddReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlTclasAddReq* req = (CsrWifiRouterCtrlTclasAddReq*)msg;
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlTclasAddReqHandler: invalid smepriv\n");
+ return;
+ }
+
+ CsrWifiRouterCtrlTclasAddCfmSend(msg->source, req->clientData, req->interfaceTag , CSR_RESULT_SUCCESS);
+}
+
+void CsrWifiRouterCtrlTclasDelReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlTclasDelReq* req = (CsrWifiRouterCtrlTclasDelReq*)msg;
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlTclasDelReqHandler: invalid smepriv\n");
+ return;
+ }
+
+ CsrWifiRouterCtrlTclasDelCfmSend(msg->source, req->clientData, req->interfaceTag, CSR_RESULT_SUCCESS);
+}
+
+
+void CsrWifiRouterCtrlConfigurePowerModeReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlConfigurePowerModeReq* req = (CsrWifiRouterCtrlConfigurePowerModeReq*)msg;
+ enum unifi_low_power_mode pm;
+ CsrResult csrResult;
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlConfigurePowerModeReqHandler: invalid smepriv\n");
+ return;
+ }
+
+ if (req->mode == CSR_WIFI_ROUTER_CTRL_LOW_POWER_MODE_DISABLED) {
+ pm = UNIFI_LOW_POWER_DISABLED;
+ } else {
+ pm = UNIFI_LOW_POWER_ENABLED;
+ }
+
+ unifi_trace(priv, UDBG2,
+ "CsrWifiRouterCtrlConfigurePowerModeReqHandler (mode=%d, wake=%d)\n",
+ req->mode, req->wakeHost);
+ csrResult = unifi_configure_low_power_mode(priv->card, pm,
+ (req->wakeHost ? UNIFI_PERIODIC_WAKE_HOST_ENABLED : UNIFI_PERIODIC_WAKE_HOST_DISABLED));
+}
+
+
+void CsrWifiRouterCtrlWifiOnResHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlWifiOnRes* res = (CsrWifiRouterCtrlWifiOnRes*)msg;
+
+ if (priv == NULL) {
+ unifi_error(NULL, "CsrWifiRouterCtrlWifiOnResHandler: Invalid ospriv.\n");
+ return;
+ }
+
+ unifi_trace(priv, UDBG1,
+ "CsrWifiRouterCtrlWifiOnResHandler: status %d (patch %u)\n", res->status, res->smeVersions.firmwarePatch);
+
+ if (res->smeVersions.firmwarePatch != 0) {
+ unifi_info(priv, "Firmware patch %d\n", res->smeVersions.firmwarePatch);
+ }
+
+ if (res->numInterfaceAddress > CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "WifiOnResHandler bad numInterfaceAddress %d\n", res->numInterfaceAddress);
+ return;
+ }
+
+ /* UniFi is now initialised, complete the init. */
+ if (res->status == CSR_RESULT_SUCCESS)
+ {
+ int i; /* used as a loop counter */
+ CsrUint32 intmode = CSR_WIFI_INTMODE_DEFAULT;
+#ifdef CSR_WIFI_SPLIT_PATCH
+ CsrBool switching_ap_fw = FALSE;
+#endif
+ /* Register the UniFi device with the OS network manager */
+ unifi_trace(priv, UDBG3, "Card Init Completed Successfully\n");
+
+ /* Store the MAC address in the netdev */
+ for(i=0;i<res->numInterfaceAddress;i++)
+ {
+ memcpy(priv->netdev[i]->dev_addr, res->stationMacAddress[i].a, ETH_ALEN);
+ }
+
+ /* Copy version structure into the private versions field */
+ priv->sme_versions = res->smeVersions;
+
+ unifi_trace(priv, UDBG2, "network interfaces count = %d\n",
+ res->numInterfaceAddress);
+
+ /* Register the netdevs for each interface. */
+ for(i=0;i<res->numInterfaceAddress;i++)
+ {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[i];
+ if(!interfacePriv->netdev_registered)
+ {
+ int r;
+ unifi_trace(priv, UDBG3, "registering net device %d\n", i);
+ r = uf_register_netdev(priv, i);
+ if (r)
+ {
+ /* unregister the net_device that are registered in the previous iterations */
+ uf_unregister_netdev(priv);
+ unifi_error(priv, "Failed to register the network device.\n");
+ CsrWifiRouterCtrlWifiOnCfmSend(msg->source, res->clientData, CSR_RESULT_FAILURE);
+ return;
+ }
+ }
+#ifdef CSR_WIFI_SPLIT_PATCH
+ else
+ {
+ /* If a netdev is already registered, we have received this WifiOnRes
+ * in response to switching AP/STA firmware in a ModeSetReq.
+ * Rememeber this in order to send a ModeSetCfm once
+ */
+ switching_ap_fw = TRUE;
+ }
+#endif
+ }
+ priv->totalInterfaceCount = res->numInterfaceAddress;
+
+ /* If the MIB has selected f/w scheduled interrupt mode, apply it now
+ * but let module param override.
+ */
+ if (run_bh_once != -1) {
+ intmode = (CsrUint32)run_bh_once;
+ } else if (res->scheduledInterrupt) {
+ intmode = CSR_WIFI_INTMODE_RUN_BH_ONCE;
+ }
+ unifi_set_interrupt_mode(priv->card, intmode);
+
+ priv->init_progress = UNIFI_INIT_COMPLETED;
+
+ /* Acknowledge the CsrWifiRouterCtrlWifiOnReq now */
+ CsrWifiRouterCtrlWifiOnCfmSend(msg->source, res->clientData, CSR_RESULT_SUCCESS);
+
+#ifdef CSR_WIFI_SPLIT_PATCH
+ if (switching_ap_fw && (priv->pending_mode_set.common.destination != 0xaaaa)) {
+ unifi_info(priv, "Completed firmware reload with %s patch\n",
+ CSR_WIFI_HIP_IS_AP_FW(priv->interfacePriv[0]->interfaceMode) ? "AP" : "STA");
+
+ /* Confirm the ModeSetReq that requested the AP/STA patch switch */
+ CsrWifiRouterCtrlModeSetCfmSend(priv->pending_mode_set.common.source,
+ priv->pending_mode_set.clientData,
+ priv->pending_mode_set.interfaceTag,
+ priv->pending_mode_set.mode,
+ CSR_RESULT_SUCCESS);
+ priv->pending_mode_set.common.destination = 0xaaaa;
+ }
+#endif
+ unifi_info(priv, "UniFi ready\n");
+
+#ifdef ANDROID_BUILD
+ /* Release the wakelock */
+ unifi_trace(priv, UDBG1, "ready: release wake lock\n");
+ wake_unlock(&unifi_sdio_wake_lock);
+#endif
+ /* Firmware initialisation is complete, so let the SDIO bus
+ * clock be raised when convienent to the core.
+ */
+ unifi_request_max_sdio_clock(priv->card);
+
+#ifdef CSR_SUPPORT_WEXT
+ /* Notify the Android wpa_supplicant that we are ready */
+ wext_send_started_event(priv);
+
+ queue_work(priv->unifi_workqueue, &priv->sme_config_task);
+#endif
+
+ } else {
+ /* Acknowledge the CsrWifiRouterCtrlWifiOnReq now */
+ CsrWifiRouterCtrlWifiOnCfmSend(msg->source, res->clientData, CSR_RESULT_FAILURE);
+ }
+}
+
+
+void CsrWifiRouterCtrlWifiOffResHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+
+void CsrWifiRouterCtrlMulticastAddressResHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+
+void CsrWifiRouterMaPacketSubscribeReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterMaPacketSubscribeReq* req = (CsrWifiRouterMaPacketSubscribeReq*)msg;
+ CsrUint8 i;
+ CsrResult result;
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterMaPacketSubscribeReqHandler: invalid priv\n");
+ return;
+ }
+
+ /* Look for an unused filter */
+
+ result = CSR_WIFI_RESULT_NO_ROOM;
+ for (i = 0; i < MAX_MA_UNIDATA_IND_FILTERS; i++) {
+
+ if (!priv->sme_unidata_ind_filters[i].in_use) {
+
+ priv->sme_unidata_ind_filters[i].in_use = 1;
+ priv->sme_unidata_ind_filters[i].appHandle = msg->source;
+ priv->sme_unidata_ind_filters[i].encapsulation = req->encapsulation;
+ priv->sme_unidata_ind_filters[i].protocol = req->protocol;
+
+ priv->sme_unidata_ind_filters[i].oui[2] = (CsrUint8) (req->oui & 0xFF);
+ priv->sme_unidata_ind_filters[i].oui[1] = (CsrUint8) ((req->oui >> 8) & 0xFF);
+ priv->sme_unidata_ind_filters[i].oui[0] = (CsrUint8) ((req->oui >> 16) & 0xFF);
+
+ result = CSR_RESULT_SUCCESS;
+ break;
+ }
+ }
+
+ unifi_trace(priv, UDBG1,
+ "subscribe_req: encap=%d, handle=%d, result=%d\n",
+ req->encapsulation, i, result);
+ CsrWifiRouterMaPacketSubscribeCfmSend(msg->source,req->interfaceTag, i, result, 0);
+}
+
+
+void CsrWifiRouterMaPacketUnsubscribeReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterMaPacketUnsubscribeReq* req = (CsrWifiRouterMaPacketUnsubscribeReq*)msg;
+ CsrResult result;
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterMaPacketUnsubscribeReqHandler: invalid priv\n");
+ return;
+ }
+
+ result = CSR_WIFI_RESULT_NOT_FOUND;
+
+ if (req->subscriptionHandle < MAX_MA_UNIDATA_IND_FILTERS) {
+ if (priv->sme_unidata_ind_filters[req->subscriptionHandle].in_use) {
+ priv->sme_unidata_ind_filters[req->subscriptionHandle].in_use = 0;
+ result = CSR_RESULT_SUCCESS;
+ } else {
+ result = CSR_WIFI_RESULT_NOT_FOUND;
+ }
+ }
+
+ unifi_trace(priv, UDBG1,
+ "unsubscribe_req: handle=%d, result=%d\n",
+ req->subscriptionHandle, result);
+ CsrWifiRouterMaPacketUnsubscribeCfmSend(msg->source,req->interfaceTag, result);
+}
+
+
+void CsrWifiRouterCtrlCapabilitiesReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlCapabilitiesReq* req = (CsrWifiRouterCtrlCapabilitiesReq*)msg;
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlCapabilitiesReqHandler: invalid priv\n");
+ return;
+ }
+
+ CsrWifiRouterCtrlCapabilitiesCfmSend(msg->source,req->clientData,
+ UNIFI_SOFT_COMMAND_Q_LENGTH - 1,
+ UNIFI_SOFT_TRAFFIC_Q_LENGTH - 1);
+}
+
+
+void CsrWifiRouterCtrlSuspendResHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlSuspendRes* res = (CsrWifiRouterCtrlSuspendRes*)msg;
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlSuspendResHandler: invalid priv\n");
+ return;
+ }
+
+ sme_complete_request(priv, res->status);
+}
+
+
+void CsrWifiRouterCtrlResumeResHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlResumeRes* res = (CsrWifiRouterCtrlResumeRes*)msg;
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlResumeResHandler: invalid priv\n");
+ return;
+ }
+
+ sme_complete_request(priv, res->status);
+}
+
+
+void CsrWifiRouterCtrlTrafficConfigReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlTrafficConfigReq* req = (CsrWifiRouterCtrlTrafficConfigReq*)msg;
+ CsrResult csrResult;
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlTrafficConfigReqHandler: invalid smepriv\n");
+ return;
+ }
+ if (req->trafficConfigType == CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_FILTER)
+ {
+ req->config.packetFilter |= CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM;
+ }
+ csrResult = unifi_ta_configure(priv->card, req->trafficConfigType, (const CsrWifiRouterCtrlTrafficConfig *)&req->config);
+}
+
+void CsrWifiRouterCtrlTrafficClassificationReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlTrafficClassificationReq* req = (CsrWifiRouterCtrlTrafficClassificationReq*)msg;
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlTrafficClassificationReqHandler: invalid smepriv\n");
+ return;
+ }
+
+ unifi_ta_classification(priv->card, req->trafficType, req->period);
+}
+
+static int
+_sys_packet_req(unifi_priv_t *priv, const CSR_SIGNAL *signal,
+ CsrUint8 subscriptionHandle,
+ CsrUint16 frameLength, CsrUint8 *frame,
+ int proto)
+{
+ int r;
+ const sme_ma_unidata_ind_filter_t *subs;
+ bulk_data_param_t bulkdata;
+ CSR_MA_PACKET_REQUEST req = signal->u.MaPacketRequest;
+ struct sk_buff *skb, *newSkb = NULL;
+ CsrWifiMacAddress peerMacAddress;
+ CsrResult csrResult;
+ CsrUint16 interfaceTag = req.VirtualInterfaceIdentifier & 0xff;
+ CsrBool eapolStore = FALSE;
+ CsrInt8 protection = 0;
+ netInterface_priv_t *interfacePriv;
+ unsigned long flags;
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "_sys_packet_req: interfaceID >= CSR_WIFI_NUM_INTERFACES.\n");
+ return -EINVAL;
+ }
+ interfacePriv = priv->interfacePriv[interfaceTag];
+ if (!priv->sme_unidata_ind_filters[subscriptionHandle].in_use) {
+ unifi_error(priv, "_sys_packet_req: unknown subscription.\n");
+ return -EINVAL;
+ }
+
+ subs = &priv->sme_unidata_ind_filters[subscriptionHandle];
+ unifi_trace(priv, UDBG1,
+ "_sys_packet_req: handle=%d, subs=%p, encap=%d\n",
+ subscriptionHandle, subs, subs->encapsulation);
+
+ csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], frameLength);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "_sys_packet_req: failed to allocate bulkdata.\n");
+ return (int)CsrHipResultToStatus(csrResult);
+ }
+
+ /* get the peer Mac address */
+ memcpy(&peerMacAddress, frame, ETH_ALEN);
+
+ /* Determine if we need to add encapsulation header */
+ if (subs->encapsulation == CSR_WIFI_ROUTER_ENCAPSULATION_ETHERNET) {
+ memcpy((void*)bulkdata.d[0].os_data_ptr, frame, frameLength);
+
+ /* The translation is performed on the skb */
+ skb = (struct sk_buff*)bulkdata.d[0].os_net_buf_ptr;
+
+ unifi_trace(priv, UDBG1,
+ "_sys_packet_req: skb_add_llc_snap -->\n");
+ r = skb_add_llc_snap(priv->netdev[interfaceTag], skb, proto);
+ unifi_trace(priv, UDBG1,
+ "_sys_packet_req: skb_add_llc_snap <--\n");
+ if (r) {
+ unifi_error(priv,
+ "_sys_packet_req: failed to translate eth frame.\n");
+ unifi_net_data_free(priv,&bulkdata.d[0]);
+ return r;
+ }
+
+ bulkdata.d[0].data_length = skb->len;
+ } else {
+ /* Crop the MAC addresses from the packet */
+ memcpy((void*)bulkdata.d[0].os_data_ptr, frame + 2*ETH_ALEN, frameLength - 2*ETH_ALEN);
+ bulkdata.d[0].data_length = frameLength - 2*ETH_ALEN;
+ skb = (struct sk_buff*)bulkdata.d[0].os_net_buf_ptr;
+ skb->len = bulkdata.d[0].data_length;
+
+ }
+
+ bulkdata.d[1].os_data_ptr = NULL;
+ bulkdata.d[1].os_net_buf_ptr = NULL;
+ bulkdata.d[1].data_length = 0;
+
+ /* check for m4 detection */
+ if (0 == uf_verify_m4(priv, bulkdata.d[0].os_data_ptr, bulkdata.d[0].data_length)) {
+ eapolStore = TRUE;
+ }
+
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ if (proto == ETH_P_WAI)
+ {
+ protection = 0; /*WAI packets always sent unencrypted*/
+ }
+ else
+ {
+#endif
+
+#ifdef CSR_SUPPORT_SME
+ if ((protection = uf_get_protection_bit_from_interfacemode(priv, interfaceTag, peerMacAddress.a)) < 0) {
+ unifi_error(priv, "unicast address, but destination not in station record database\n");
+ unifi_net_data_free(priv,&bulkdata.d[0]);
+ return -1;
+ }
+#else
+ protection = 0;
+#endif
+
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ }
+#endif
+
+ /* add Mac header */
+ if (prepare_and_add_macheader(priv, skb, newSkb, req.Priority, &bulkdata, interfaceTag, frame, frame + ETH_ALEN, protection)) {
+ unifi_error(priv, "failed to create MAC header\n");
+ unifi_net_data_free(priv,&bulkdata.d[0]);
+ return -1;
+ }
+
+ if (eapolStore) {
+ spin_lock_irqsave(&priv->m4_lock, flags);
+ /* Store the EAPOL M4 packet for later */
+ interfacePriv->m4_signal = *signal;
+ interfacePriv->m4_bulk_data.net_buf_length = bulkdata.d[0].net_buf_length;
+ interfacePriv->m4_bulk_data.data_length = bulkdata.d[0].data_length;
+ interfacePriv->m4_bulk_data.os_data_ptr = bulkdata.d[0].os_data_ptr;
+ interfacePriv->m4_bulk_data.os_net_buf_ptr = bulkdata.d[0].os_net_buf_ptr;
+ spin_unlock_irqrestore(&priv->m4_lock, flags);
+ /* Send a signal to SME */
+ unifi_trace(priv, UDBG1, "_sys_packet_req: Sending CsrWifiRouterCtrlM4ReadyToSendInd\n");
+ CsrWifiRouterCtrlM4ReadyToSendIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, peerMacAddress);
+ return 0;
+ }
+
+ /* Send the signal to UniFi */
+ /* Set the B31 to 1 for local routing*/
+ r= uf_process_ma_packet_req(priv, peerMacAddress.a, (req.HostTag | 0x80000000), interfaceTag, 0,
+ (CSR_RATE)0, req.Priority, signal->SignalPrimitiveHeader.SenderProcessId, &bulkdata);
+ if (r) {
+ unifi_error(priv,
+ "_sys_packet_req: failed to send signal.\n");
+ unifi_net_data_free(priv,&bulkdata.d[0]);
+ return r;
+ }
+ /* The final CsrWifiRouterMaPacketCfmSend() will called when the actual MA-PACKET.cfm is received from the chip */
+
+ return 0;
+}
+
+void CsrWifiRouterMaPacketReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ int r;
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterMaPacketReq* mareq = (CsrWifiRouterMaPacketReq*)msg;
+ llc_snap_hdr_t *snap;
+ CsrUint16 snap_protocol;
+ CSR_SIGNAL signal;
+ CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
+ CsrWifiRouterCtrlPortAction controlPortaction;
+ CsrUint8 *daddr, *saddr;
+ CsrUint16 interfaceTag = mareq->interfaceTag & 0x00ff;
+ int queue;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if (!mareq->frame || !priv || !priv->smepriv)
+ {
+ unifi_error(priv, "CsrWifiRouterMaPacketReqHandler: invalid frame/priv/priv->smepriv\n");
+ return;
+ }
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "CsrWifiRouterMaPacketReqHandler: interfaceID >= CSR_WIFI_NUM_INTERFACES.\n");
+ return;
+ }
+ /* get a pointer to dest & source Mac address */
+ daddr = mareq->frame;
+ saddr = (mareq->frame + ETH_ALEN);
+ /* point to the proper position of frame, since frame has MAC header */
+ snap = (llc_snap_hdr_t *) (mareq->frame + 2 * ETH_ALEN);
+ snap_protocol = ntohs(snap->protocol);
+ if((snap_protocol == ETH_P_PAE)
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ || (snap_protocol == ETH_P_WAI)
+#endif
+ )
+ {
+ queue = UF_UNCONTROLLED_PORT_Q;
+ }
+ else
+ {
+ queue = UF_CONTROLLED_PORT_Q;
+ }
+
+ /* Controlled port restrictions apply to the packets */
+ controlPortaction = uf_sme_port_state(priv, daddr, queue, interfaceTag);
+ if (controlPortaction != CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN)
+ {
+ unifi_warning(priv, "CsrWifiRouterMaPacketReqHandler: (%s)controlled port is closed.\n", (queue == UF_CONTROLLED_PORT_Q)?"":"un");
+ if(mareq->cfmRequested)
+ {
+ CsrWifiRouterMaPacketCfmSend(msg->source,
+ interfaceTag,
+ CSR_RESULT_FAILURE,
+ mareq->hostTag, 0);
+ }
+ return;
+ }
+
+ signal.SignalPrimitiveHeader.SignalId = CSR_MA_PACKET_REQUEST_ID;
+ /* Store the appHandle in the LSB of the SenderId. */
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(((priv->sme_cli->sender_id & 0xff00) | (unsigned int)msg->source),
+ (u8*)&signal.SignalPrimitiveHeader.SenderProcessId);
+ signal.SignalPrimitiveHeader.ReceiverProcessId = 0;
+
+ /* Fill in the MA-PACKET.req signal */
+ memcpy(req->Ra.x, daddr, ETH_ALEN);
+ req->Priority = mareq->priority;
+ req->TransmitRate = 0; /* Let firmware select the rate*/
+ req->VirtualInterfaceIdentifier = uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag);
+ req->HostTag = mareq->hostTag;
+
+ if(mareq->cfmRequested)
+ req->TransmissionControl = 0;
+ else
+ req->TransmissionControl = CSR_NO_CONFIRM_REQUIRED;
+
+ r = _sys_packet_req(priv, &signal, mareq->subscriptionHandle,
+ mareq->frameLength, mareq->frame, snap_protocol);
+
+#define MAX_RETRY 2
+ if (r && mareq->cfmRequested)
+ {
+ CsrWifiRouterMaPacketCfmSend(msg->source,interfaceTag,
+ CSR_RESULT_FAILURE,
+ mareq->hostTag, 0);
+ }
+ return;
+}
+
+void CsrWifiRouterMaPacketCancelReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+void CsrWifiRouterCtrlM4TransmitReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlM4TransmitReq* req = (CsrWifiRouterCtrlM4TransmitReq*)msg;
+ int r;
+ bulk_data_param_t bulkdata;
+ netInterface_priv_t *interfacePriv;
+ CSR_SIGNAL m4_signal;
+ unsigned long flags;
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlM4TransmitReqHandler: invalid smepriv\n");
+ return;
+ }
+ if (req->interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "M4TransmitReqHandler: interfaceTag >= CSR_WIFI_NUM_INTERFACES\n");
+ return;
+ }
+
+ interfacePriv = priv->interfacePriv[req->interfaceTag];
+ spin_lock_irqsave(&priv->m4_lock, flags);
+ if (interfacePriv->m4_bulk_data.data_length == 0) {
+ spin_unlock_irqrestore(&priv->m4_lock, flags);
+ unifi_error(priv, "CsrWifiRouterCtrlM4TransmitReqHandler: invalid buffer\n");
+ return;
+ }
+
+ memcpy(&bulkdata.d[0], &interfacePriv->m4_bulk_data, sizeof(bulk_data_desc_t));
+
+ interfacePriv->m4_bulk_data.net_buf_length = 0;
+ interfacePriv->m4_bulk_data.data_length = 0;
+ interfacePriv->m4_bulk_data.os_data_ptr = interfacePriv->m4_bulk_data.os_net_buf_ptr = NULL;
+ m4_signal = interfacePriv->m4_signal;
+ spin_unlock_irqrestore(&priv->m4_lock, flags);
+
+ bulkdata.d[1].os_data_ptr = NULL;
+ bulkdata.d[1].data_length = 0;
+
+ interfacePriv->m4_sent = TRUE;
+ m4_signal.u.MaPacketRequest.HostTag |= 0x80000000;
+ /* Store the hostTag for later varification */
+ interfacePriv->m4_hostTag = m4_signal.u.MaPacketRequest.HostTag;
+ r = ul_send_signal_unpacked(priv, &m4_signal, &bulkdata);
+ unifi_trace(priv, UDBG1,
+ "CsrWifiRouterCtrlM4TransmitReqHandler: sent\n");
+ if (r) {
+ unifi_error(priv,
+ "CsrWifiRouterCtrlM4TransmitReqHandler: failed to send signal.\n");
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ }
+}
+
+/* reset the station records when the mode is set as CSR_WIFI_ROUTER_CTRL_MODE_NONE */
+static void CsrWifiRouterCtrlResetStationRecordList(unifi_priv_t *priv, CsrUint16 interfaceTag)
+{
+ CsrUint8 i,j;
+ CsrWifiRouterCtrlStaInfo_t *staInfo=NULL;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ unsigned long lock_flags;
+
+ /* create a list for sending confirms of un-delivered packets */
+ struct list_head send_cfm_list;
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "CsrWifiRouterCtrlResetStationRecordList: bad interfaceTag\n");
+ return;
+ }
+
+ INIT_LIST_HEAD(&send_cfm_list);
+
+ /* Reset the station record to NULL if mode is NONE */
+ for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ if ((staInfo=interfacePriv->staInfo[i]) != NULL) {
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(staInfo->mgtFrames));
+ uf_flush_list(priv,&(staInfo->mgtFrames));
+ for(j=0;j<MAX_ACCESS_CATOGORY;j++){
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(staInfo->dataPdu[j]));
+ uf_flush_list(priv,&(staInfo->dataPdu[j]));
+ }
+
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ /* Removing station record information from port config array */
+ memset(staInfo->peerControlledPort, 0, sizeof(unifi_port_cfg_t));
+ staInfo->peerControlledPort->port_action = CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
+ staInfo->peerControlledPort->in_use = FALSE;
+ interfacePriv->controlled_data_port.entries_in_use--;
+
+ memset(staInfo->peerUnControlledPort, 0, sizeof(unifi_port_cfg_t));
+ staInfo->peerUnControlledPort->port_action = CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
+ staInfo->peerUnControlledPort->in_use = FALSE;
+ interfacePriv->uncontrolled_data_port.entries_in_use--;
+
+ kfree(interfacePriv->staInfo[i]);
+ interfacePriv->staInfo[i] = NULL;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ }
+ }
+ /* after the critical region process the list of frames that requested cfm
+ * and send cfm to requestor one by one
+ */
+ send_auto_ma_packet_confirm(priv, interfacePriv, &send_cfm_list);
+
+#ifdef CSR_SUPPORT_SME
+ /* Interface Independent, no of packet queued, incase of mode is None or AP set to 0 */
+ switch(interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ case CSR_WIFI_ROUTER_CTRL_MODE_NONE:
+ if (priv->noOfPktQueuedInDriver) {
+ unifi_warning(priv, "After reset the noOfPktQueuedInDriver = %x\n", priv->noOfPktQueuedInDriver);
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ priv->noOfPktQueuedInDriver = 0;
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ }
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
+ break;
+ default:
+ unifi_error(priv, "interfacemode is not correct in CsrWifiRouterCtrlResetStationRecordList: debug\n");
+ }
+#endif
+
+ if (((interfacePriv->controlled_data_port.entries_in_use != 0) || (interfacePriv->uncontrolled_data_port.entries_in_use != 0))
+ && (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_NONE)) {
+ /* Print in case if the value of entries goes to -ve/+ve (apart from 0)
+ * we expect the entries should be zero here if mode is set as NONE
+ */
+ unifi_trace(priv, UDBG3, "In %s controlled port entries = %d, uncontrolled port entries = %d\n",
+ __FUNCTION__, interfacePriv->controlled_data_port.entries_in_use,
+ interfacePriv->uncontrolled_data_port.entries_in_use);
+ }
+}
+
+void CsrWifiRouterCtrlInterfaceReset(unifi_priv_t *priv, CsrUint16 interfaceTag)
+{
+ netInterface_priv_t *interfacePriv;
+
+ /* create a list for sending confirms of un-delivered packets */
+ struct list_head send_cfm_list;
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "CsrWifiRouterCtrlInterfaceReset: bad interfaceTag\n");
+ return;
+ }
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ INIT_LIST_HEAD(&send_cfm_list);
+
+ /* Enable all queues by default */
+ interfacePriv->queueEnabled[0] = 1;
+ interfacePriv->queueEnabled[1] = 1;
+ interfacePriv->queueEnabled[2] = 1;
+ interfacePriv->queueEnabled[3] = 1;
+
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(interfacePriv->genericMgtFrames));
+ uf_flush_list(priv,&(interfacePriv->genericMgtFrames));
+
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(interfacePriv->genericMulticastOrBroadCastMgtFrames));
+ uf_flush_list(priv,&(interfacePriv->genericMulticastOrBroadCastMgtFrames));
+
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(interfacePriv->genericMulticastOrBroadCastFrames));
+
+ uf_flush_list(priv,&(interfacePriv->genericMulticastOrBroadCastFrames));
+
+ /* process the list of frames that requested cfm
+ and send cfm to requestor one by one */
+ send_auto_ma_packet_confirm(priv, interfacePriv, &send_cfm_list);
+
+ /* Reset the station record to NULL if mode is tried to set as NONE */
+ switch(interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_STA:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
+ case CSR_WIFI_ROUTER_CTRL_MODE_MONITOR:
+ case CSR_WIFI_ROUTER_CTRL_MODE_AMP:
+ /* station records not available in these modes */
+ break;
+ default:
+ CsrWifiRouterCtrlResetStationRecordList(priv,interfaceTag);
+ }
+
+ interfacePriv->num_stations_joined = 0;
+ interfacePriv->sta_activity_check_enabled = FALSE;
+}
+
+
+void CsrWifiRouterCtrlModeSetReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlModeSetReq* req = (CsrWifiRouterCtrlModeSetReq*)msg;
+
+ if (priv == NULL)
+ {
+ unifi_error(priv, "CsrWifiRouterCtrlModeSetReqHandler: invalid smepriv\n");
+ return;
+ }
+
+ if (req->interfaceTag < CSR_WIFI_NUM_INTERFACES)
+ {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+#ifdef CSR_WIFI_SPLIT_PATCH
+ CsrUint8 old_mode = interfacePriv->interfaceMode;
+#endif
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlModeSetReqHandler: interfacePriv->interfaceMode = %d\n",
+ interfacePriv->interfaceMode);
+
+ interfacePriv->interfaceMode = req->mode;
+
+#ifdef CSR_WIFI_SPLIT_PATCH
+ /* Detect a change in mode that requires a switch to/from the AP firmware patch.
+ * This should only happen when transitioning in/out of AP modes.
+ */
+ if (CSR_WIFI_HIP_IS_AP_FW(req->mode) != CSR_WIFI_HIP_IS_AP_FW(old_mode))
+ {
+ CsrWifiRouterCtrlVersions versions;
+ int r;
+
+#ifdef ANDROID_BUILD
+ /* Take the wakelock while switching patch */
+ unifi_trace(priv, UDBG1, "patch switch: take wake lock\n");
+ wake_lock(&unifi_sdio_wake_lock);
+#endif
+ unifi_info(priv, "Resetting UniFi with %s patch\n", CSR_WIFI_HIP_IS_AP_FW(req->mode) ? "AP" : "STA");
+
+ r = uf_request_firmware_files(priv, UNIFI_FW_STA);
+ if (r) {
+ unifi_error(priv, "CsrWifiRouterCtrlModeSetReqHandler: Failed to get f/w\n");
+ CsrWifiRouterCtrlModeSetCfmSend(msg->source, req->clientData, req->interfaceTag,
+ req->mode, CSR_RESULT_FAILURE);
+ return;
+ }
+
+ /* Block the I/O thread */
+ priv->bh_thread.block_thread = 1;
+
+ /* Reset and download the new patch */
+ r = uf_init_hw(priv);
+ if (r) {
+ unifi_error(priv, "CsrWifiRouterCtrlWifiOnReqHandler: Failed to initialise h/w, error %d\n", r);
+ CsrWifiRouterCtrlModeSetCfmSend(msg->source, req->clientData, req->interfaceTag,
+ req->mode, CSR_RESULT_FAILURE);
+ return;
+ }
+
+ /* Re-enable the I/O thread */
+ priv->bh_thread.block_thread = 0;
+
+ /* Get the version information from the core */
+ unifi_card_info(priv->card, &priv->card_info);
+
+ /* Copy to the unifiio_card_info structure. */
+ versions.chipId = priv->card_info.chip_id;
+ versions.chipVersion = priv->card_info.chip_version;
+ versions.firmwareBuild = priv->card_info.fw_build;
+ versions.firmwareHip = priv->card_info.fw_hip_version;
+ versions.routerBuild = (CsrCharString*)CSR_WIFI_VERSION;
+ versions.routerHip = (UNIFI_HIP_MAJOR_VERSION << 8) | UNIFI_HIP_MINOR_VERSION;
+
+ /* Now that new firmware is running, send a WifiOnInd to the NME. This will
+ * cause it to retransfer the MIB.
+ */
+ CsrWifiRouterCtrlWifiOnIndSend(msg->source, 0, CSR_RESULT_SUCCESS, versions);
+
+ /* Store the request so we know where to send the ModeSetCfm */
+ priv->pending_mode_set = *req;
+ }
+ else
+#endif
+ {
+ /* No patch switch, confirm straightaway */
+ CsrWifiRouterCtrlModeSetCfmSend(msg->source, req->clientData, req->interfaceTag,
+ req->mode, CSR_RESULT_SUCCESS);
+ }
+
+ interfacePriv->bssid = req->bssid;
+ /* For modes other than AP/P2PGO, set below member FALSE */
+ interfacePriv->intraBssEnabled = FALSE;
+ /* Initialise the variable bcTimSet with a value
+ * other then CSR_WIFI_TIM_SET or CSR_WIFI_TIM_RESET value
+ */
+ interfacePriv->bcTimSet = 0xFF;
+ interfacePriv->bcTimSetReqPendingFlag = FALSE;
+ /* Initialise the variable bcTimSetReqQueued with a value
+ * other then CSR_WIFI_TIM_SET or CSR_WIFI_TIM_RESET value
+ */
+ interfacePriv->bcTimSetReqQueued =0xFF;
+ CsrWifiRouterCtrlInterfaceReset(priv,req->interfaceTag);
+
+ if(req->mode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ req->mode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ interfacePriv->protect = req->protection;
+ interfacePriv->dtimActive=FALSE;
+ interfacePriv->multicastPduHostTag = 0xffffffff;
+ /* For AP/P2PGO mode SME sending intraBssDistEnabled
+ * i.e. for AP: intraBssDistEnabled = TRUE, for P2PGO
+ * intraBssDistEnabled = TRUE/FALSE on requirement
+ */
+ interfacePriv->intraBssEnabled = req->intraBssDistEnabled;
+ unifi_trace(priv, UDBG3, "CsrWifiRouterCtrlModeSetReqHandler: IntraBssDisEnabled = %d\n",
+ req->intraBssDistEnabled);
+ } else if (req->mode == CSR_WIFI_ROUTER_CTRL_MODE_NONE) {
+ netif_carrier_off(priv->netdev[req->interfaceTag]);
+ interfacePriv->connected = UnifiConnectedUnknown;
+ }
+ }
+ else {
+ unifi_error(priv, "CsrWifiRouterCtrlModeSetReqHandler: invalid interfaceTag :%d\n",req->interfaceTag);
+ }
+}
+
+void CsrWifiRouterMaPacketResHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+}
+
+/* delete the station record from the station record data base */
+static int peer_delete_record(unifi_priv_t *priv, CsrWifiRouterCtrlPeerDelReq *req)
+{
+ CsrUint8 j;
+ CsrWifiRouterCtrlStaInfo_t *staInfo = NULL;
+ unifi_port_config_t *controlledPort;
+ unifi_port_config_t *unControlledPort;
+ netInterface_priv_t *interfacePriv;
+
+ CsrUint8 ba_session_idx = 0;
+ ba_session_rx_struct *ba_session_rx = NULL;
+ ba_session_tx_struct *ba_session_tx = NULL;
+
+ /* create a list for sending confirms of un-delivered packets */
+ struct list_head send_cfm_list;
+
+ unsigned long lock_flags;
+
+ if ((req->peerRecordHandle >= UNIFI_MAX_CONNECTIONS) || (req->interfaceTag >= CSR_WIFI_NUM_INTERFACES)) {
+ unifi_error(priv, "handle/interfaceTag is not proper, handle = %d, interfaceTag = %d\n", req->peerRecordHandle, req->interfaceTag);
+ return CSR_RESULT_FAILURE;
+ }
+
+ INIT_LIST_HEAD(&send_cfm_list);
+
+ interfacePriv = priv->interfacePriv[req->interfaceTag];
+ /* remove the station record & make it NULL */
+ if ((staInfo=interfacePriv->staInfo[req->peerRecordHandle])!=NULL) {
+
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(staInfo->mgtFrames));
+
+ uf_flush_list(priv,&(staInfo->mgtFrames));
+ for(j=0;j<MAX_ACCESS_CATOGORY;j++){
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(staInfo->dataPdu[j]));
+ uf_flush_list(priv,&(staInfo->dataPdu[j]));
+ }
+
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ /* clear the port configure array info, for the corresponding peer entry */
+ controlledPort = &interfacePriv->controlled_data_port;
+ unControlledPort = &interfacePriv->uncontrolled_data_port;
+
+ unifi_trace(priv, UDBG1, "peer_delete_record: Peer found handle = %d, port in use: cont(%d), unCont(%d)\n",
+ req->peerRecordHandle, controlledPort->entries_in_use, unControlledPort->entries_in_use);
+
+ memset(staInfo->peerControlledPort, 0, sizeof(unifi_port_cfg_t));
+ staInfo->peerControlledPort->port_action = CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
+ staInfo->peerControlledPort->in_use = FALSE;
+ if (controlledPort->entries_in_use) {
+ controlledPort->entries_in_use--;
+ } else {
+ unifi_warning(priv, "number of controlled port entries is zero, trying to decrement: debug\n");
+ }
+
+ memset(staInfo->peerUnControlledPort, 0, sizeof(unifi_port_cfg_t));
+ staInfo->peerUnControlledPort->port_action = CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
+ staInfo->peerUnControlledPort->in_use = FALSE;
+ if (unControlledPort->entries_in_use) {
+ unControlledPort->entries_in_use--;
+ } else {
+ unifi_warning(priv, "number of uncontrolled port entries is zero, trying to decrement: debug\n");
+ }
+
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ /* update the TIM with zero */
+ if (interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_IBSS &&
+ staInfo->timSet == CSR_WIFI_TIM_SET) {
+ unifi_trace(priv, UDBG3, "peer is deleted so TIM updated to 0, in firmware\n");
+ update_tim(priv,staInfo->aid,0,req->interfaceTag, req->peerRecordHandle);
+ }
+
+
+ /* Stop BA session if it is active, for this peer address all BA sessions
+ (per tID per role) are closed */
+
+ down(&priv->ba_mutex);
+ for(ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_RX; ba_session_idx++){
+ ba_session_rx = priv->interfacePriv[req->interfaceTag]->ba_session_rx[ba_session_idx];
+ if(ba_session_rx) {
+ if(!memcmp(ba_session_rx->macAddress.a, staInfo->peerMacAddress.a, ETH_ALEN)){
+ blockack_session_stop(priv,
+ req->interfaceTag,
+ CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_RECIPIENT,
+ ba_session_rx->tID,
+ ba_session_rx->macAddress);
+ }
+ }
+ }
+
+ for(ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_TX; ba_session_idx++){
+ ba_session_tx = priv->interfacePriv[req->interfaceTag]->ba_session_tx[ba_session_idx];
+ if(ba_session_tx) {
+ if(!memcmp(ba_session_tx->macAddress.a, staInfo->peerMacAddress.a, ETH_ALEN)){
+ blockack_session_stop(priv,
+ req->interfaceTag,
+ CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ORIGINATOR,
+ ba_session_tx->tID,
+ ba_session_tx->macAddress);
+ }
+ }
+ }
+
+ up(&priv->ba_mutex);
+
+#ifdef CSR_SUPPORT_SME
+ unifi_trace(priv, UDBG1, "Canceling work queue for STA with AID: %d\n", staInfo->aid);
+ cancel_work_sync(&staInfo->send_disconnected_ind_task);
+#endif
+
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+#ifdef CSR_SUPPORT_SME
+ interfacePriv->num_stations_joined--;
+
+ staInfo->nullDataHostTag = INVALID_HOST_TAG;
+
+ if ((interfacePriv->sta_activity_check_enabled) &&
+ (interfacePriv->num_stations_joined < STA_INACTIVE_DETECTION_TRIGGER_THRESHOLD))
+ {
+ unifi_trace(priv, UDBG1, "STOPPING the Inactivity Timer (num of stations = %d)\n", interfacePriv->num_stations_joined);
+ interfacePriv->sta_activity_check_enabled = FALSE;
+ del_timer_sync(&interfacePriv->sta_activity_check_timer);
+ }
+#endif
+
+ /* Free the station record for corresponding peer */
+ kfree(interfacePriv->staInfo[req->peerRecordHandle]);
+ interfacePriv->staInfo[req->peerRecordHandle] = NULL;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+
+ /* after the critical region process the list of frames that requested cfm
+ and send cfm to requestor one by one */
+ send_auto_ma_packet_confirm(priv, interfacePriv, &send_cfm_list);
+
+
+ }
+ else
+ {
+ unifi_trace(priv, UDBG3, " peer not found: Delete request Peer handle[%d]\n", req->peerRecordHandle);
+ }
+
+ return CSR_RESULT_SUCCESS;
+}
+
+void CsrWifiRouterCtrlPeerDelReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ CsrWifiRouterCtrlPeerDelReq* req = (CsrWifiRouterCtrlPeerDelReq*)msg;
+ CsrResult status = CSR_RESULT_SUCCESS;
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+
+ unifi_trace(priv, UDBG2, "entering CsrWifiRouterCtrlPeerDelReqHandler \n");
+ if (priv == NULL)
+ {
+ unifi_error(priv, "CsrWifiRouterCtrlPeerDelReqHandler: invalid smepriv\n");
+ return;
+ }
+
+ if (req->interfaceTag >= CSR_WIFI_NUM_INTERFACES)
+ {
+ unifi_error(priv, "CsrWifiRouterCtrlPeerDelReqHandler: bad interfaceTag\n");
+ return;
+ }
+
+ switch(interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ /* remove the station from station record data base */
+ status = peer_delete_record(priv, req);
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_STA:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
+ default:
+ /* No station record to maintain in these modes */
+ break;
+ }
+
+ CsrWifiRouterCtrlPeerDelCfmSend(msg->source,req->clientData,req->interfaceTag,status);
+ unifi_trace(priv, UDBG2, "leaving CsrWifiRouterCtrlPeerDelReqHandler \n");
+}
+
+/* Add the new station to the station record data base */
+static int peer_add_new_record(unifi_priv_t *priv,CsrWifiRouterCtrlPeerAddReq *req,CsrUint32 *handle)
+{
+ CsrUint8 i, powerModeTemp = 0;
+ CsrBool freeSlotFound = FALSE;
+ CsrWifiRouterCtrlStaInfo_t *newRecord = NULL;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+ CsrTime currentTime, currentTimeHi;
+ unsigned long lock_flags;
+
+ if (req->interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "peer_add_new_record: bad interfaceTag\n");
+ return CSR_RESULT_FAILURE;
+ }
+
+ currentTime = CsrTimeGet(¤tTimeHi);
+
+ for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ if(interfacePriv->staInfo[i] == NULL) {
+ /* Slot is empty, so can be used for station record */
+ freeSlotFound = TRUE;
+ *handle = i;
+
+ /* Allocate for the new station record , to avoid race condition would happen between ADD_PEER &
+ * DEL_PEER the allocation made atomic memory rather than kernel memory
+ */
+ newRecord = (CsrWifiRouterCtrlStaInfo_t *) kmalloc(sizeof(CsrWifiRouterCtrlStaInfo_t), GFP_ATOMIC);
+ if (!newRecord) {
+ unifi_error(priv, "failed to allocate the %d bytes of mem for station record\n",
+ sizeof(CsrWifiRouterCtrlStaInfo_t));
+ return CSR_RESULT_FAILURE;
+ }
+
+ unifi_trace(priv, UDBG1, "peer_add_new_record: handle = %d AID = %d addr = %x:%x:%x:%x:%x:%x LI=%u\n",
+ *handle, req->associationId, req->peerMacAddress.a[0], req->peerMacAddress.a[1], req->peerMacAddress.a[2],
+ req->peerMacAddress.a[3], req->peerMacAddress.a[4], req->peerMacAddress.a[5],
+ req->staInfo.listenIntervalInTus);
+
+ /* disable the preemption until station record updated */
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+
+ interfacePriv->staInfo[i] = newRecord;
+ /* Initialize the record*/
+ memset(newRecord,0,sizeof(CsrWifiRouterCtrlStaInfo_t));
+ /* update the station record */
+ memcpy(newRecord->peerMacAddress.a, req->peerMacAddress.a, ETH_ALEN);
+ newRecord->wmmOrQosEnabled = req->staInfo.wmmOrQosEnabled;
+
+ /* maxSpLength is bit map in qosInfo field, so converting accordingly */
+ newRecord->maxSpLength = req->staInfo.maxSpLength * 2;
+
+ /*Max SP 0 mean any number of packets. since we buffer only 512
+ packets we are hard coding this to zero for the moment */
+
+ if(newRecord->maxSpLength == 0)
+ newRecord->maxSpLength=512;
+
+ newRecord->assignedHandle = i;
+
+ /* copy power save mode of all access catagory (Trigger/Delivery/both enabled/disabled) */
+ powerModeTemp = (CsrUint8) ((req->staInfo.powersaveMode >> 4) & 0xff);
+
+ if(!(req->staInfo.powersaveMode & 0x0001))
+ newRecord->powersaveMode[UNIFI_TRAFFIC_Q_BK]= CSR_WIFI_AC_LEGACY_POWER_SAVE;
+ else
+ newRecord->powersaveMode[UNIFI_TRAFFIC_Q_BK]= powerModeTemp & 0x03;
+
+ if(!(req->staInfo.powersaveMode & 0x0002))
+ newRecord->powersaveMode[UNIFI_TRAFFIC_Q_BE]= CSR_WIFI_AC_LEGACY_POWER_SAVE;
+ else
+ newRecord->powersaveMode[UNIFI_TRAFFIC_Q_BE]= ((powerModeTemp & 0x0C)>> 2);
+
+ if(!(req->staInfo.powersaveMode & 0x0004))
+ newRecord->powersaveMode[UNIFI_TRAFFIC_Q_VI]= CSR_WIFI_AC_LEGACY_POWER_SAVE;
+ else
+ newRecord->powersaveMode[UNIFI_TRAFFIC_Q_VI]= ((powerModeTemp & 0x30)>> 4);
+
+ if(!(req->staInfo.powersaveMode & 0x0008))
+ newRecord->powersaveMode[UNIFI_TRAFFIC_Q_VO]= CSR_WIFI_AC_LEGACY_POWER_SAVE;
+ else
+ newRecord->powersaveMode[UNIFI_TRAFFIC_Q_VO]= ((powerModeTemp & 0xC0)>> 6);
+
+ {
+ CsrUint8 k;
+ for(k=0; k< MAX_ACCESS_CATOGORY ;k++)
+ unifi_trace(priv, UDBG2, "peer_add_new_record: WMM : %d ,AC %d, powersaveMode %x \n",
+ req->staInfo.wmmOrQosEnabled,k,newRecord->powersaveMode[k]);
+ }
+
+ unifi_trace(priv, UDBG3, "newRecord->wmmOrQosEnabled : %d , MAX SP : %d\n",
+ newRecord->wmmOrQosEnabled,newRecord->maxSpLength);
+
+ /* Initialize the mgtFrames & data Pdu list */
+ {
+ CsrUint8 j;
+ INIT_LIST_HEAD(&newRecord->mgtFrames);
+ for(j = 0; j < MAX_ACCESS_CATOGORY; j++) {
+ INIT_LIST_HEAD(&newRecord->dataPdu[j]);
+ }
+ }
+
+ newRecord->lastActivity = currentTime;
+ newRecord->activity_flag = TRUE;
+
+ /* enable the preemption as station record updated */
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+
+ /* First time port actions are set for the peer with below information */
+ configure_data_port(priv, CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN, &newRecord->peerMacAddress,
+ UF_UNCONTROLLED_PORT_Q, req->interfaceTag);
+
+ if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_IBSS) {
+ configure_data_port(priv, CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN, &newRecord->peerMacAddress,
+ UF_CONTROLLED_PORT_Q, req->interfaceTag);
+ } else {
+ configure_data_port(priv, CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD, &newRecord->peerMacAddress,
+ UF_CONTROLLED_PORT_Q, req->interfaceTag);
+ }
+
+
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ /* Port status must be already set before calling the Add Peer request */
+ newRecord->peerControlledPort = uf_sme_port_config_handle(priv, newRecord->peerMacAddress.a,
+ UF_CONTROLLED_PORT_Q, req->interfaceTag);
+ newRecord->peerUnControlledPort = uf_sme_port_config_handle(priv, newRecord->peerMacAddress.a,
+ UF_UNCONTROLLED_PORT_Q, req->interfaceTag);
+
+ if (!newRecord->peerControlledPort || !newRecord->peerUnControlledPort) {
+ /* enable the preemption as station record failed to update */
+ unifi_warning(priv, "Un/ControlledPort record not found in port configuration array index = %d\n", i);
+ kfree(interfacePriv->staInfo[i]);
+ interfacePriv->staInfo[i] = NULL;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ return CSR_RESULT_FAILURE;
+ }
+
+ newRecord->currentPeerState = CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE;
+
+ /* changes done during block ack handling */
+ newRecord->txSuspend = FALSE;
+
+ /*U-APSD related data structure*/
+ newRecord->timRequestPendingFlag = FALSE;
+
+ /* Initialise the variable updateTimReqQueued with a value
+ * other then CSR_WIFI_TIM_SET or CSR_WIFI_TIM_RESET value
+ */
+ newRecord->updateTimReqQueued = 0xFF;
+ newRecord->timSet = CSR_WIFI_TIM_RESET;
+ newRecord->uapsdActive = FALSE;
+ newRecord->noOfSpFramesSent =0;
+ newRecord->triggerFramePriority = CSR_QOS_UP0;
+
+ /* The protection bit is updated once the port opens for corresponding peer in
+ * routerPortConfigure request */
+
+ /* update the association ID */
+ newRecord->aid = req->associationId;
+
+#ifdef CSR_SUPPORT_SME
+ interfacePriv->num_stations_joined++;
+ newRecord->interfacePriv = interfacePriv;
+ newRecord->listenIntervalInTus = req->staInfo.listenIntervalInTus;
+ newRecord->nullDataHostTag = INVALID_HOST_TAG;
+
+ INIT_WORK(&newRecord->send_disconnected_ind_task, uf_send_disconnected_ind_wq);
+
+ if(!(interfacePriv->sta_activity_check_enabled) &&
+ (interfacePriv->num_stations_joined >= STA_INACTIVE_DETECTION_TRIGGER_THRESHOLD)){
+ unifi_trace(priv, UDBG1,
+ "peer_add_new_record: STARTING the Inactivity Timer (num of stations = %d)",
+ interfacePriv->num_stations_joined);
+
+ interfacePriv->sta_activity_check_enabled = TRUE;
+ interfacePriv->sta_activity_check_timer.function = check_inactivity_timer_expire_func;
+ interfacePriv->sta_activity_check_timer.data = (unsigned long)interfacePriv;
+
+ init_timer(&interfacePriv->sta_activity_check_timer);
+ mod_timer(&interfacePriv->sta_activity_check_timer,
+ (jiffies + usecs_to_jiffies(STA_INACTIVE_DETECTION_TIMER_INTERVAL * 1000 * 1000)));
+
+ }
+#endif
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ break;
+ }
+ }
+
+ if(!freeSlotFound) {
+ unifi_error(priv, "Limited connectivity, Free slot not found for station record addition\n");
+ return CSR_RESULT_FAILURE;
+ }
+ return CSR_RESULT_SUCCESS;
+}
+
+#ifdef CSR_SUPPORT_SME
+static void check_inactivity_timer_expire_func(unsigned long data)
+{
+ struct unifi_priv *priv;
+ CsrWifiRouterCtrlStaInfo_t *sta_record = NULL;
+ CsrUint8 i = 0;
+ CsrTime now;
+ CsrTime inactive_time;
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *) data;
+
+ if (!interfacePriv)
+ {
+ return;
+ }
+
+ priv = interfacePriv->privPtr;
+
+ if (interfacePriv->InterfaceTag >= CSR_WIFI_NUM_INTERFACES)
+ {
+ unifi_error(priv, "check_inactivity_timer_expire_func: Invalid interfaceTag\n");
+ return;
+ }
+
+ /* RUN Algorithm to check inactivity for each connected station */
+ now = CsrTimeGet(NULL);
+
+ for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ if(interfacePriv->staInfo[i] != NULL) {
+ sta_record = interfacePriv->staInfo[i];
+
+ if (sta_record->activity_flag == TRUE){
+ sta_record->activity_flag = FALSE;
+ sta_record->lastActivity = now;
+ continue;
+ }
+
+ if (sta_record->lastActivity > now)
+ {
+ /* simple timer wrap (for 1 wrap) */
+ inactive_time = CsrTimeAdd((CsrTime)CsrTimeSub(CSR_SCHED_TIME_MAX, sta_record->lastActivity), now);
+ }
+ else
+ {
+ inactive_time = (CsrTime)CsrTimeSub(now, sta_record->lastActivity);
+ }
+
+ if (inactive_time >= STA_INACTIVE_TIMEOUT_VAL)
+ {
+ unifi_trace(priv, UDBG1, "STA is Inactive - AID = %d inactive_time = %d\n",
+ sta_record->aid,
+ inactive_time);
+
+ /* station is in-active, if it is in active mode send a null frame
+ * and the station should acknowledge the null frame, if acknowledgement
+ * is not received throw out the station.
+ * If the station is in Power Save, update TIM for the station so
+ * that it wakes up and register some activity through PS-Poll or
+ * trigger frame.
+ */
+ if (sta_record->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)
+ {
+ unifi_trace(priv, UDBG1, "STA power save state - Active, send a NULL frame to check if it is ALIVE\n");
+ uf_send_nulldata ( priv,
+ sta_record->interfacePriv->InterfaceTag,
+ sta_record->peerMacAddress.a,
+ CSR_CONTENTION,
+ sta_record);
+ }
+ else if (sta_record->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)
+ {
+ if((sta_record->timSet == CSR_WIFI_TIM_SET) ||
+ (sta_record->timSet == CSR_WIFI_TIM_SETTING))
+ {
+ unifi_trace(priv, UDBG1, "STA power save state - PS, TIM is already SET\n");
+
+ /* If TIM is set and we do not have any activity for
+ * more than 3 listen intervals then send a disconnected
+ * indication to SME, to delete the station from station
+ * record list.
+ * The inactivity is already more than STA_INACTIVE_TIMEOUT_VAL
+ * and this check ensures if the listen interval is a larger
+ * value than STA_INACTIVE_TIMEOUT_VAL.
+ */
+ if (inactive_time > (3 * (sta_record->listenIntervalInTus * 1024)))
+ {
+ unifi_trace(priv, UDBG1, "STA is inactive for more than 3 listen intervals\n");
+ queue_work( priv->unifi_workqueue,
+ &sta_record->send_disconnected_ind_task);
+ }
+
+ }
+ else
+ {
+ unifi_trace(priv, UDBG1, "STA power save state - PS, update TIM to see if it is ALIVE\n");
+ update_tim(priv,
+ sta_record->aid,
+ CSR_WIFI_TIM_SET,
+ interfacePriv->InterfaceTag,
+ sta_record->assignedHandle);
+ }
+ }
+ }
+ }
+ }
+
+ /* re-run the timer interrupt */
+ mod_timer(&interfacePriv->sta_activity_check_timer,
+ (jiffies + usecs_to_jiffies(STA_INACTIVE_DETECTION_TIMER_INTERVAL * 1000 * 1000)));
+
+}
+
+
+void uf_send_disconnected_ind_wq(struct work_struct *work)
+{
+
+ CsrWifiRouterCtrlStaInfo_t *staInfo = container_of(work, CsrWifiRouterCtrlStaInfo_t, send_disconnected_ind_task);
+ unifi_priv_t *priv;
+ CsrUint16 interfaceTag;
+ struct list_head send_cfm_list;
+ CsrUint8 j;
+
+ func_enter();
+
+ if(!staInfo) {
+ return;
+ }
+
+ if(!staInfo->interfacePriv) {
+ return;
+ }
+
+ priv = staInfo->interfacePriv->privPtr;
+ interfaceTag = staInfo->interfacePriv->InterfaceTag;
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "uf_send_disconnected_ind_wq: invalid interfaceTag\n");
+ return;
+ }
+
+ /* The SME/NME may be waiting for confirmation for requested frames to this station.
+ * So loop through buffered frames for this station and if confirmation is
+ * requested, send auto confirmation with failure status. Also flush the frames so
+ * that these are not processed again in PEER_DEL_REQ handler.
+ */
+ INIT_LIST_HEAD(&send_cfm_list);
+
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(staInfo->mgtFrames));
+
+ uf_flush_list(priv, &(staInfo->mgtFrames));
+
+ for(j = 0; j < MAX_ACCESS_CATOGORY; j++){
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(staInfo->dataPdu[j]));
+
+ uf_flush_list(priv,&(staInfo->dataPdu[j]));
+ }
+
+ send_auto_ma_packet_confirm(priv, staInfo->interfacePriv, &send_cfm_list);
+
+ unifi_warning(priv, "uf_send_disconnected_ind_wq: Router Disconnected IND Peer (%x-%x-%x-%x-%x-%x)\n",
+ staInfo->peerMacAddress.a[0],
+ staInfo->peerMacAddress.a[1],
+ staInfo->peerMacAddress.a[2],
+ staInfo->peerMacAddress.a[3],
+ staInfo->peerMacAddress.a[4],
+ staInfo->peerMacAddress.a[5]);
+
+ CsrWifiRouterCtrlConnectedIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,
+ 0,
+ staInfo->interfacePriv->InterfaceTag,
+ staInfo->peerMacAddress,
+ CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED);
+
+
+ return;
+}
+
+
+#endif
+void CsrWifiRouterCtrlPeerAddReqHandler(void* drvpriv,CsrWifiFsmEvent* msg)
+{
+ CsrWifiRouterCtrlPeerAddReq* req = (CsrWifiRouterCtrlPeerAddReq*)msg;
+ CsrResult status = CSR_RESULT_SUCCESS;
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrUint32 handle = 0;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+
+ unifi_trace(priv, UDBG2, "entering CsrWifiRouterCtrlPeerAddReqHandler \n");
+ if (priv == NULL)
+ {
+ unifi_error(priv, "CsrWifiRouterCtrlPeerAddReqHandler: invalid smepriv\n");
+ return;
+ }
+
+ if (req->interfaceTag >= CSR_WIFI_NUM_INTERFACES)
+ {
+ unifi_error(priv, "CsrWifiRouterCtrlPeerAddReqHandler: bad interfaceTag\n");
+ return;
+ }
+
+ switch(interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ /* Add station record */
+ status = peer_add_new_record(priv,req,&handle);
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_STA:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
+ default:
+ /* No station record to maintain in these modes */
+ break;
+ }
+
+ CsrWifiRouterCtrlPeerAddCfmSend(msg->source,req->clientData,req->interfaceTag,req->peerMacAddress,handle,status);
+ unifi_trace(priv, UDBG2, "leaving CsrWifiRouterCtrlPeerAddReqHandler \n");
+}
+
+void CsrWifiRouterCtrlPeerUpdateReqHandler(void* drvpriv,CsrWifiFsmEvent* msg)
+{
+ CsrWifiRouterCtrlPeerUpdateReq* req = (CsrWifiRouterCtrlPeerUpdateReq*)msg;
+ CsrResult status = CSR_RESULT_SUCCESS;
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+
+ unifi_trace(priv, UDBG2, "entering CsrWifiRouterCtrlPeerUpdateReqHandler \n");
+ if (priv == NULL)
+ {
+ unifi_error(priv, "CsrWifiRouterCtrlPeerUpdateReqHandler: invalid smepriv\n");
+ return;
+ }
+
+ CsrWifiRouterCtrlPeerUpdateCfmSend(msg->source,req->clientData,req->interfaceTag,status);
+ unifi_trace(priv, UDBG2, "leaving CsrWifiRouterCtrlPeerUpdateReqHandler \n");
+}
+
+
+ void CsrWifiRouterCtrlRawSdioDeinitialiseReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ /* This will never be called as it is intercepted in the Userspace */
+}
+
+void CsrWifiRouterCtrlRawSdioInitialiseReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ /* This will never be called as it is intercepted in the Userspace */
+}
+
+void
+uf_send_ba_err_wq(struct work_struct *work)
+{
+ ba_session_rx_struct *ba_session = container_of(work, ba_session_rx_struct, send_ba_err_task);
+ unifi_priv_t *priv;
+
+ if(!ba_session) {
+ return;
+ }
+
+ if(!ba_session->interfacePriv) {
+ return;
+ }
+
+ priv = ba_session->interfacePriv->privPtr;
+
+ if (ba_session->interfacePriv->InterfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "%s: invalid interfaceTag\n", __FUNCTION__);
+ return;
+ }
+
+ unifi_warning(priv, "%s: Calling CsrWifiRouterCtrlBlockAckErrorIndSend(%d, %d, %d, %d, %x:%x:%x:%x:%x:%x, %d)\n",
+ __FUNCTION__,
+ priv->CSR_WIFI_SME_IFACEQUEUE,
+ 0,
+ ba_session->interfacePriv->InterfaceTag,
+ ba_session->tID,
+ ba_session->macAddress.a[0],
+ ba_session->macAddress.a[1],
+ ba_session->macAddress.a[2],
+ ba_session->macAddress.a[3],
+ ba_session->macAddress.a[4],
+ ba_session->macAddress.a[5],
+ CSR_RESULT_SUCCESS
+ );
+ CsrWifiRouterCtrlBlockAckErrorIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,
+ 0,
+ ba_session->interfacePriv->InterfaceTag,
+ ba_session->tID,
+ ba_session->macAddress,
+ CSR_RESULT_SUCCESS);
+}
+
+
+static void ba_session_terminate_timer_func(unsigned long data)
+{
+ ba_session_rx_struct *ba_session = (ba_session_rx_struct*)data;
+ struct unifi_priv *priv;
+
+ if(!ba_session) {
+ return;
+ }
+
+ if(!ba_session->interfacePriv) {
+ return;
+ }
+
+ priv = ba_session->interfacePriv->privPtr;
+
+ if (ba_session->interfacePriv->InterfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "%s: invalid interfaceTag\n", __FUNCTION__);
+ return;
+ }
+
+ queue_work(priv->unifi_workqueue, &ba_session->send_ba_err_task);
+}
+
+
+CsrBool blockack_session_stop(unifi_priv_t *priv,
+ CsrUint16 interfaceTag,
+ CsrWifiRouterCtrlBlockAckRole role,
+ CsrUint16 tID,
+ CsrWifiMacAddress macAddress)
+{
+ netInterface_priv_t *interfacePriv;
+ ba_session_rx_struct *ba_session_rx = NULL;
+ ba_session_tx_struct *ba_session_tx = NULL;
+ CsrUint8 ba_session_idx = 0;
+ int i;
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "%s: bad interfaceTag = %d\n", __FUNCTION__, interfaceTag);
+ return FALSE;
+ }
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if(!interfacePriv) {
+ unifi_error(priv, "%s: bad interfacePriv\n", __FUNCTION__);
+ return FALSE;
+ }
+
+ if(tID > 15) {
+ unifi_error(priv, "%s: bad tID = %d\n", __FUNCTION__, tID);
+ return FALSE;
+ }
+
+ if((role != CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ORIGINATOR) &&
+ (role != CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_RECIPIENT)) {
+ unifi_error(priv, "%s: bad role = %d\n", __FUNCTION__, role);
+ return FALSE;
+ }
+
+ unifi_warning(priv, "%s: stopping ba_session for peer = %02x:%02x:%02x:%02x:%02x:%02x role = %d tID = %d\n", __FUNCTION__,
+ macAddress.a[0], macAddress.a[1], macAddress.a[2],
+ macAddress.a[3], macAddress.a[4], macAddress.a[5],
+ role,
+ tID);
+
+ /* find out the appropriate ba session (/station /tid /role) for which stop is requested */
+ if (role == CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_RECIPIENT){
+ for (ba_session_idx =0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_RX; ba_session_idx++){
+
+ ba_session_rx = interfacePriv->ba_session_rx[ba_session_idx];
+
+ if(ba_session_rx){
+ if ((!memcmp(ba_session_rx->macAddress.a, macAddress.a, ETH_ALEN)) && (ba_session_rx->tID == tID)){
+ break;
+ }
+ }
+ }
+
+ if (!ba_session_rx || (ba_session_idx == MAX_SUPPORTED_BA_SESSIONS_RX)) {
+ unifi_error(priv, "%s: bad ba_session for Rx [tID=%d]\n", __FUNCTION__, tID);
+ return FALSE;
+ }
+
+
+ if(ba_session_rx->timeout) {
+ del_timer_sync(&ba_session_rx->timer);
+ }
+ cancel_work_sync(&ba_session_rx->send_ba_err_task);
+ for (i = 0; i < ba_session_rx->wind_size; i++) {
+ if(ba_session_rx->buffer[i].active) {
+ frame_desc_struct *frame_desc = &ba_session_rx->buffer[i];
+ unifi_net_data_free(priv, &frame_desc->bulkdata.d[0]);
+ }
+ }
+ kfree(ba_session_rx->buffer);
+
+ interfacePriv->ba_session_rx[ba_session_idx] = NULL;
+ kfree(ba_session_rx);
+ }else if (role == CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ORIGINATOR){
+ for (ba_session_idx =0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_TX; ba_session_idx++){
+ ba_session_tx = interfacePriv->ba_session_tx[ba_session_idx];
+ if(ba_session_tx){
+ if ((!memcmp(ba_session_tx->macAddress.a, macAddress.a, ETH_ALEN)) && (ba_session_tx->tID == tID)){
+ break;
+ }
+ }
+ }
+
+ if (!ba_session_tx || (ba_session_idx == MAX_SUPPORTED_BA_SESSIONS_TX)) {
+ unifi_error(priv, "%s: bad ba_session for Tx [tID=%d]\n", __FUNCTION__, tID);
+ return FALSE;
+ }
+ interfacePriv->ba_session_tx[ba_session_idx] = NULL;
+ kfree(ba_session_tx);
+
+ }
+
+ return TRUE;
+}
+
+
+void CsrWifiRouterCtrlBlockAckDisableReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ CsrWifiRouterCtrlBlockAckDisableReq* req = (CsrWifiRouterCtrlBlockAckDisableReq*)msg;
+ CsrBool r;
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+
+ unifi_trace(priv, UDBG6, "%s: in ok\n", __FUNCTION__);
+
+ down(&priv->ba_mutex);
+ r = blockack_session_stop(priv,
+ req->interfaceTag,
+ req->role,
+ req->trafficStreamID,
+ req->macAddress);
+ up(&priv->ba_mutex);
+
+ CsrWifiRouterCtrlBlockAckDisableCfmSend(msg->source,
+ req->clientData,
+ req->interfaceTag,
+ r?CSR_RESULT_SUCCESS:CSR_RESULT_FAILURE);
+
+ unifi_trace(priv, UDBG6, "%s: out ok\n", __FUNCTION__);
+}
+
+
+CsrBool blockack_session_start(unifi_priv_t *priv,
+ CsrUint16 interfaceTag,
+ CsrUint16 tID,
+ CsrUint16 timeout,
+ CsrWifiRouterCtrlBlockAckRole role,
+ CsrUint16 wind_size,
+ CsrUint16 start_sn,
+ CsrWifiMacAddress macAddress
+ )
+{
+ netInterface_priv_t *interfacePriv;
+ ba_session_rx_struct *ba_session_rx = NULL;
+ ba_session_tx_struct *ba_session_tx = NULL;
+ CsrUint8 ba_session_idx = 0;
+
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "%s: bad interfaceTag = %d\n", __FUNCTION__, interfaceTag);
+ return FALSE;
+ }
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if(!interfacePriv) {
+ unifi_error(priv, "%s: bad interfacePriv\n", __FUNCTION__);
+ return FALSE;
+ }
+
+ if(tID > 15)
+ {
+ unifi_error(priv, "%s: bad tID=%d\n", __FUNCTION__, tID);
+ return FALSE;
+ }
+
+ if(wind_size > MAX_BA_WIND_SIZE) {
+ unifi_error(priv, "%s: bad wind_size = %d\n", __FUNCTION__, wind_size);
+ return FALSE;
+ }
+
+ if(role != CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ORIGINATOR &&
+ role != CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_RECIPIENT) {
+ unifi_error(priv, "%s: bad role = %d\n", __FUNCTION__, role);
+ return FALSE;
+ }
+
+ unifi_warning(priv, "%s: ba session with peer= (%02x:%02x:%02x:%02x:%02x:%02x)\n", __FUNCTION__,
+ macAddress.a[0], macAddress.a[1], macAddress.a[2],
+ macAddress.a[3], macAddress.a[4], macAddress.a[5]);
+
+ unifi_warning(priv, "%s: ba session for tID=%d timeout=%d role=%d wind_size=%d start_sn=%d\n", __FUNCTION__,
+ tID,
+ timeout,
+ role,
+ wind_size,
+ start_sn);
+
+ /* Check if BA session exists for per station, per TID, per role or not.
+ if BA session exists update parameters and if it does not exist
+ create a new BA session */
+ if (role == CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ORIGINATOR){
+ for (ba_session_idx =0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_TX; ba_session_idx++){
+ ba_session_tx = interfacePriv->ba_session_tx[ba_session_idx];
+ if (ba_session_tx) {
+ if ((!memcmp(ba_session_tx->macAddress.a, macAddress.a, ETH_ALEN)) && (ba_session_tx->tID == tID)){
+ unifi_warning(priv, "%s: ba_session for Tx already exists\n", __FUNCTION__);
+ return TRUE;
+ }
+ }
+ }
+
+ /* we have to create new ba_session_tx struct */
+ ba_session_tx = NULL;
+
+ /* loop through until an empty BA session slot is there and save the session there */
+ for (ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_TX ; ba_session_idx++){
+ if (!(interfacePriv->ba_session_tx[ba_session_idx])){
+ break;
+ }
+ }
+ if (ba_session_idx == MAX_SUPPORTED_BA_SESSIONS_TX){
+ unifi_error(priv, "%s: All ba_session used for Tx, NO free session available\n", __FUNCTION__);
+ return FALSE;
+ }
+
+ /* create and populate the new BA session structure */
+ ba_session_tx = kmalloc(sizeof(ba_session_tx_struct), GFP_KERNEL);
+ if (!ba_session_tx) {
+ unifi_error(priv, "%s: kmalloc failed for ba_session_tx\n", __FUNCTION__);
+ return FALSE;
+ }
+ memset(ba_session_tx, 0, sizeof(ba_session_tx_struct));
+
+ ba_session_tx->interfacePriv = interfacePriv;
+ ba_session_tx->tID = tID;
+ ba_session_tx->macAddress = macAddress;
+
+ interfacePriv->ba_session_tx[ba_session_idx] = ba_session_tx;
+
+ } else if (role == CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_RECIPIENT){
+
+ for (ba_session_idx =0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_RX; ba_session_idx++){
+ ba_session_rx = interfacePriv->ba_session_rx[ba_session_idx];
+ if (ba_session_rx) {
+ if ((!memcmp(ba_session_rx->macAddress.a, macAddress.a, ETH_ALEN)) && (ba_session_rx->tID == tID)){
+ unifi_warning(priv, "%s: ba_session for Rx[tID = %d] already exists\n", __FUNCTION__, tID);
+
+ if(ba_session_rx->wind_size == wind_size &&
+ ba_session_rx->timeout == timeout &&
+ ba_session_rx->expected_sn == start_sn) {
+ return TRUE;
+ }
+
+ if(ba_session_rx->timeout) {
+ del_timer_sync(&ba_session_rx->timer);
+ ba_session_rx->timeout = 0;
+ }
+
+ if(ba_session_rx->wind_size != wind_size) {
+ blockack_session_stop(priv, interfaceTag, role, tID, macAddress);
+ } else {
+ if (timeout) {
+ ba_session_rx->timeout = timeout;
+ ba_session_rx->timer.function = ba_session_terminate_timer_func;
+ ba_session_rx->timer.data = (unsigned long)ba_session_rx;
+ init_timer(&ba_session_rx->timer);
+ mod_timer(&ba_session_rx->timer, (jiffies + usecs_to_jiffies((ba_session_rx->timeout) * 1024)));
+ }
+ /*
+ * The starting sequence number shall remain same if the BA
+ * enable request is issued to update BA parameters only. If
+ * it is not same, then we scroll our window to the new starting
+ * sequence number. This could happen if the DELBA frame from
+ * originator is lost and then we receive ADDBA frame with new SSN.
+ */
+ if(ba_session_rx->start_sn != start_sn) {
+ scroll_ba_window(priv, interfacePriv, ba_session_rx, start_sn);
+ }
+ return TRUE;
+ }
+ }
+ }
+ }
+
+ /* we could have a valid BA session pointer here or un-initialized
+ ba session pointer. but in any case we have to create a new session.
+ so re-initialize the ba_session pointer */
+ ba_session_rx = NULL;
+
+ /* loop through until an empty BA session slot is there and save the session there */
+ for (ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_RX ; ba_session_idx++){
+ if (!(interfacePriv->ba_session_rx[ba_session_idx])){
+ break;
+ }
+ }
+ if (ba_session_idx == MAX_SUPPORTED_BA_SESSIONS_RX){
+ unifi_error(priv, "%s: All ba_session used for Rx, NO free session available\n", __FUNCTION__);
+ return FALSE;
+ }
+
+ /* It is observed that with some devices there is a race between
+ * EAPOL exchanges and BA session establishment. This results in
+ * some EAPOL authentication packets getting stuck in BA reorder
+ * buffer and hence the conection cannot be established. To avoid
+ * this we check here if the EAPOL authentication is complete and
+ * if so then only allow the BA session to establish.
+ *
+ * It is verified that the peers normally re-establish
+ * the BA session after the initial rejection.
+ */
+ if (CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN != uf_sme_port_state(priv, macAddress.a, UF_CONTROLLED_PORT_Q, interfacePriv->InterfaceTag))
+ {
+ unifi_warning(priv, "blockack_session_start: Controlled port not opened, Reject BA request\n");
+ return FALSE;
+ }
+
+ ba_session_rx = kmalloc(sizeof(ba_session_rx_struct), GFP_KERNEL);
+ if (!ba_session_rx) {
+ unifi_error(priv, "%s: kmalloc failed for ba_session_rx\n", __FUNCTION__);
+ return FALSE;
+ }
+ memset(ba_session_rx, 0, sizeof(ba_session_rx_struct));
+
+ ba_session_rx->wind_size = wind_size;
+ ba_session_rx->start_sn = ba_session_rx->expected_sn = start_sn;
+ ba_session_rx->trigger_ba_after_ssn = FALSE;
+
+ ba_session_rx->buffer = kmalloc(ba_session_rx->wind_size*sizeof(frame_desc_struct), GFP_KERNEL);
+ if (!ba_session_rx->buffer) {
+ kfree(ba_session_rx);
+ unifi_error(priv, "%s: kmalloc failed for buffer\n", __FUNCTION__);
+ return FALSE;
+ }
+
+ memset(ba_session_rx->buffer, 0, ba_session_rx->wind_size*sizeof(frame_desc_struct));
+
+ INIT_WORK(&ba_session_rx->send_ba_err_task, uf_send_ba_err_wq);
+ if (timeout) {
+ ba_session_rx->timeout = timeout;
+ ba_session_rx->timer.function = ba_session_terminate_timer_func;
+ ba_session_rx->timer.data = (unsigned long)ba_session_rx;
+ init_timer(&ba_session_rx->timer);
+ mod_timer(&ba_session_rx->timer, (jiffies + usecs_to_jiffies((ba_session_rx->timeout) * 1024)));
+ }
+
+ ba_session_rx->interfacePriv = interfacePriv;
+ ba_session_rx->tID = tID;
+ ba_session_rx->macAddress = macAddress;
+
+ interfacePriv->ba_session_rx[ba_session_idx] = ba_session_rx;
+ }
+ return TRUE;
+}
+
+void CsrWifiRouterCtrlBlockAckEnableReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+ CsrWifiRouterCtrlBlockAckEnableReq* req = (CsrWifiRouterCtrlBlockAckEnableReq*)msg;
+ CsrBool r;
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+
+ unifi_trace(priv, UDBG6, ">>%s\n", __FUNCTION__);
+ down(&priv->ba_mutex);
+ r = blockack_session_start(priv,
+ req->interfaceTag,
+ req->trafficStreamID,
+ req->timeout,
+ req->role,
+ req->bufferSize,
+ req->ssn,
+ req->macAddress
+ );
+ up(&priv->ba_mutex);
+
+ CsrWifiRouterCtrlBlockAckEnableCfmSend(msg->source,
+ req->clientData,
+ req->interfaceTag,
+ r?CSR_RESULT_SUCCESS:CSR_RESULT_FAILURE);
+ unifi_trace(priv, UDBG6, "<<%s: r=%d\n", __FUNCTION__, r);
+
+}
+
+void CsrWifiRouterCtrlWapiMulticastFilterReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlWapiMulticastFilterReq* req = (CsrWifiRouterCtrlWapiMulticastFilterReq*)msg;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+
+ if (CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode) {
+
+ unifi_trace(priv, UDBG6, ">>%s\n", __FUNCTION__);
+
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWapiMulticastFilterReq: req->status = %d\n", req->status);
+
+ /* status 1 - Filter on
+ * status 0 - Filter off */
+ priv->wapi_multicast_filter = req->status;
+
+ unifi_trace(priv, UDBG6, "<<%s\n", __FUNCTION__);
+ } else {
+
+ unifi_warning(priv, "%s is NOT applicable for interface mode - %d\n", __FUNCTION__,interfacePriv->interfaceMode);
+
+ }
+#elif defined(UNIFI_DEBUG)
+ /*WAPI Disabled*/
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ unifi_error(priv,"CsrWifiRouterCtrlWapiMulticastFilterReqHandler: called when WAPI isn't enabled\n");
+#endif
+}
+
+void CsrWifiRouterCtrlWapiUnicastFilterReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlWapiUnicastFilterReq* req = (CsrWifiRouterCtrlWapiUnicastFilterReq*)msg;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+
+ if (CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode) {
+
+ unifi_trace(priv, UDBG6, ">>%s\n", __FUNCTION__);
+
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWapiUnicastFilterReq: req->status= %d\n", req->status);
+
+ if ((priv->wapi_unicast_filter == 1) && (req->status == 0)) {
+ /* When we have successfully re-associated and obtained a new unicast key with keyid = 0 */
+ priv->wapi_unicast_queued_pkt_filter = 1;
+ }
+
+ /* status 1 - Filter ON
+ * status 0 - Filter OFF */
+ priv->wapi_unicast_filter = req->status;
+
+ unifi_trace(priv, UDBG6, "<<%s\n", __FUNCTION__);
+ } else {
+
+ unifi_warning(priv, "%s is NOT applicable for interface mode - %d\n", __FUNCTION__,interfacePriv->interfaceMode);
+
+ }
+#elif defined(UNIFI_DEBUG)
+ /*WAPI Disabled*/
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ unifi_error(priv,"CsrWifiRouterCtrlWapiUnicastFilterReqHandler: called when WAPI isn't enabled\n");
+#endif
+}
+
+void CsrWifiRouterCtrlWapiRxPktReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlWapiRxPktReq* req = (CsrWifiRouterCtrlWapiRxPktReq*)msg;
+ int client_id, receiver_id;
+ bulk_data_param_t bulkdata;
+ CsrResult res;
+ ul_client_t *client;
+ CSR_SIGNAL signal;
+ CSR_MA_PACKET_INDICATION *pkt_ind;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+
+ if (CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode) {
+
+ unifi_trace(priv, UDBG6, ">>%s\n", __FUNCTION__);
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlWapiRxPktReq : invalid priv\n",__FUNCTION__);
+ return;
+ }
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlWapiRxPktReq : invalid sme priv\n",__FUNCTION__);
+ return;
+ }
+
+ if (req->dataLength == 0 || req->data == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlWapiRxPktReq: invalid request\n",__FUNCTION__);
+ return;
+ }
+
+ res = unifi_net_data_malloc(priv, &bulkdata.d[0], req->dataLength);
+ if (res != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "CsrWifiRouterCtrlWapiRxPktReq: Could not allocate net data\n",__FUNCTION__);
+ return;
+ }
+
+ /* This function is expected to be called only when the MIC has been verified by SME to be correct
+ * So reset the reception status to rx_success */
+ res = read_unpack_signal(req->signal, &signal);
+ if (res) {
+ unifi_error(priv,"CsrWifiRouterCtrlWapiRxPktReqHandler: Received unknown or corrupted signal.\n");
+ return;
+ }
+ pkt_ind = (CSR_MA_PACKET_INDICATION*) (&((&signal)->u).MaPacketIndication);
+ if (pkt_ind->ReceptionStatus != CSR_MICHAEL_MIC_ERROR) {
+ unifi_error(priv,"CsrWifiRouterCtrlWapiRxPktReqHandler: Unknown signal with reception status = %d\n",pkt_ind->ReceptionStatus);
+ return;
+ } else {
+ unifi_trace(priv, UDBG4,"CsrWifiRouterCtrlWapiRxPktReqHandler: MIC verified , RX_SUCCESS \n",__FUNCTION__);
+ pkt_ind->ReceptionStatus = CSR_RX_SUCCESS;
+ write_pack(&signal, req->signal, &(req->signalLength));
+ }
+
+ memcpy((void*)bulkdata.d[0].os_data_ptr, req->data, req->dataLength);
+
+ receiver_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN((req->signal) + sizeof(CsrInt16)) & 0xFFF0;
+ client_id = (receiver_id & 0x0F00) >> UDI_SENDER_ID_SHIFT;
+
+ client = &priv->ul_clients[client_id];
+
+ if (client && client->event_hook) {
+ unifi_trace(priv, UDBG3,
+ "CsrWifiRouterCtrlWapiRxPktReq: "
+ "Sending signal to client %d, (s:0x%X, r:0x%X) - Signal 0x%X \n",
+ client->client_id, client->sender_id, receiver_id,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(req->signal));
+
+ client->event_hook(client, req->signal, req->signalLength, &bulkdata, UDI_TO_HOST);
+ } else {
+ unifi_trace(priv, UDBG4, "No client to give the packet to\n");
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ }
+
+ unifi_trace(priv, UDBG6, "<<%s\n", __FUNCTION__);
+ } else {
+ unifi_warning(priv, "%s is NOT applicable for interface mode - %d\n", __FUNCTION__,interfacePriv->interfaceMode);
+ }
+#elif defined(UNIFI_DEBUG)
+ /*WAPI Disabled*/
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ unifi_error(priv,"CsrWifiRouterCtrlWapiRxPktReqHandler: called when WAPI isn't enabled\n");
+#endif
+}
+
+void CsrWifiRouterCtrlWapiUnicastTxPktReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
+
+ unifi_priv_t *priv = (unifi_priv_t*) drvpriv;
+ CsrWifiRouterCtrlWapiUnicastTxPktReq *req = (CsrWifiRouterCtrlWapiUnicastTxPktReq*) msg;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+ bulk_data_param_t bulkdata;
+ CsrUint8 macHeaderLengthInBytes = MAC_HEADER_SIZE;
+ /*KeyID, Reserved, PN, MIC*/
+ CsrUint8 appendedCryptoFields = 1 + 1 + 16 + 16;
+ CsrResult result;
+ /* Retrieve the MA PACKET REQ fields from the Signal retained from send_ma_pkt_request() */
+ CSR_MA_PACKET_REQUEST *storedSignalMAPktReq = &interfacePriv->wapi_unicast_ma_pkt_sig.u.MaPacketRequest;
+
+ if (CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode) {
+
+ unifi_trace(priv, UDBG6, ">>%s\n", __FUNCTION__);
+
+ if (priv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlWapiUnicastTxPktReqHandler : invalid priv\n",__FUNCTION__);
+ return;
+ }
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlWapiUnicastTxPktReqHandler : invalid sme priv\n",__FUNCTION__);
+ return;
+ }
+ if (req->data == NULL) {
+ unifi_error(priv, "CsrWifiRouterCtrlWapiUnicastTxPktReqHandler: invalid request\n",__FUNCTION__);
+ return;
+ } else {
+ /* If it is QoS data (type = data subtype = QoS), frame header contains QoS control field */
+ if ((req->data[0] & 0x88) == 0x88) {
+ macHeaderLengthInBytes = macHeaderLengthInBytes + QOS_CONTROL_HEADER_SIZE;
+ }
+ }
+ if ( !(req->dataLength>(macHeaderLengthInBytes+appendedCryptoFields)) ) {
+ unifi_error(priv, "CsrWifiRouterCtrlWapiUnicastTxPktReqHandler: invalid dataLength\n",__FUNCTION__);
+ return;
+ }
+
+ /* Encrypted DATA Packet contained in (req->data)
+ * -------------------------------------------------------------------
+ * |MAC Header| KeyId | Reserved | PN | xxDataxx | xxMICxxx |
+ * -------------------------------------------------------------------
+ * (<-----Encrypted----->)
+ * -------------------------------------------------------------------
+ * |24/26(QoS)| 1 | 1 | 16 | x | 16 |
+ * -------------------------------------------------------------------
+ */
+ result = unifi_net_data_malloc(priv, &bulkdata.d[0], req->dataLength);
+ if (result != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "CsrWifiRouterCtrlWapiUnicastTxPktReqHandler: Could not allocate net data\n",__FUNCTION__);
+ return;
+ }
+ memcpy((void*)bulkdata.d[0].os_data_ptr, req->data, req->dataLength);
+ bulkdata.d[0].data_length = req->dataLength;
+ bulkdata.d[1].os_data_ptr = NULL;
+ bulkdata.d[1].data_length = 0;
+
+ /* Send UniFi msg */
+ /* Here hostTag is been sent as 0xffffffff, its been appended properly while framing MA-Packet request in pdu_processing.c file */
+ result = uf_process_ma_packet_req(priv,
+ storedSignalMAPktReq->Ra.x,
+ storedSignalMAPktReq->HostTag,/* Ask for a new HostTag */
+ req->interfaceTag,
+ storedSignalMAPktReq->TransmissionControl,
+ storedSignalMAPktReq->TransmitRate,
+ storedSignalMAPktReq->Priority, /* Retained value */
+ interfacePriv->wapi_unicast_ma_pkt_sig.SignalPrimitiveHeader.SenderProcessId, /*FIXME AP: VALIDATE ???*/
+ &bulkdata);
+
+ if (result == NETDEV_TX_OK) {
+ (priv->netdev[req->interfaceTag])->trans_start = jiffies;
+ /* Should really count tx stats in the UNITDATA.status signal but
+ * that doesn't have the length.
+ */
+ interfacePriv->stats.tx_packets++;
+
+ /* count only the packet payload */
+ interfacePriv->stats.tx_bytes += req->dataLength - macHeaderLengthInBytes - appendedCryptoFields;
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWapiUnicastTxPktReqHandler: (Packet Sent), sent count = %x\n", interfacePriv->stats.tx_packets);
+ } else {
+ /* Failed to send: fh queue was full, and the skb was discarded*/
+ unifi_trace(priv, UDBG1, "(HIP validation failure) Result = %d\n", result);
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+
+ interfacePriv->stats.tx_dropped++;
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWapiUnicastTxPktReqHandler: (Packet Drop), dropped count = %x\n", interfacePriv->stats.tx_dropped);
+ }
+
+ unifi_trace(priv, UDBG6, "<<%s\n", __FUNCTION__);
+
+ } else {
+
+ unifi_warning(priv, "%s is NOT applicable for interface mode - %d\n", __FUNCTION__,interfacePriv->interfaceMode);
+
+ }
+#elif defined(UNIFI_DEBUG)
+ /*WAPI Disabled*/
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ unifi_error(priv,"CsrWifiRouterCtrlWapiUnicastTxPktReqHandler: called when WAPI SW ENCRYPTION isn't enabled\n");
+#endif
+}
+
+void CsrWifiRouterCtrlWapiFilterReqHandler(void* drvpriv, CsrWifiFsmEvent* msg)
+{
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+
+#ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ CsrWifiRouterCtrlWapiFilterReq* req = (CsrWifiRouterCtrlWapiFilterReq*)msg;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[req->interfaceTag];
+
+ if (CSR_WIFI_ROUTER_CTRL_MODE_STA == interfacePriv->interfaceMode) {
+
+ unifi_trace(priv, UDBG6, ">>%s\n", __FUNCTION__);
+
+ unifi_trace(priv, UDBG1, "CsrWifiRouterCtrlWapiFilterReq: req->isWapiConnected [0/1] = %d \n",req->isWapiConnected);
+
+ priv->isWapiConnection = req->isWapiConnected;
+
+ unifi_trace(priv, UDBG6, "<<%s\n", __FUNCTION__);
+ } else {
+
+ unifi_warning(priv, "%s is NOT applicable for interface mode - %d\n", __FUNCTION__,interfacePriv->interfaceMode);
+
+ }
+#endif
+
+#elif defined(UNIFI_DEBUG)
+ /*WAPI Disabled*/
+ unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
+ unifi_error(priv,"CsrWifiRouterCtrlWapiFilterReq: called when WAPI isn't enabled\n");
+#endif
+}
--- /dev/null
+/*
+ *****************************************************************************
+ *
+ * FILE : sme_userspace.c
+ *
+ * PURPOSE : Support functions for userspace SME helper application.
+ *
+ *
+ * Copyright (C) 2008-2011 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ *****************************************************************************
+ */
+
+#include "unifi_priv.h"
+
+/*
+ * Fix Me..... These need to be the correct values...
+ * Dynamic from the user space.
+ */
+CsrSchedQid CSR_WIFI_ROUTER_IFACEQUEUE = 0xFFFF;
+CsrSchedQid CSR_WIFI_SME_IFACEQUEUE = 0xFFFF;
+#ifdef CSR_SUPPORT_WEXT_AP
+CsrSchedQid CSR_WIFI_NME_IFACEQUEUE = 0xFFFF;
+#endif
+int
+uf_sme_init(unifi_priv_t *priv)
+{
+ int i, j;
+
+ CsrWifiRouterTransportInit(priv);
+
+ priv->smepriv = priv;
+
+ init_waitqueue_head(&priv->sme_request_wq);
+
+ priv->filter_tclas_ies = NULL;
+ memset(&priv->packet_filters, 0, sizeof(uf_cfg_bcast_packet_filter_t));
+
+#ifdef CSR_SUPPORT_WEXT
+ priv->ignore_bssid_join = FALSE;
+ priv->mib_data.length = 0;
+
+ uf_sme_wext_set_defaults(priv);
+#endif /* CSR_SUPPORT_WEXT*/
+
+ priv->sta_ip_address = 0xFFFFFFFF;
+
+ priv->wifi_on_state = wifi_on_unspecified;
+
+ sema_init(&priv->sme_sem, 1);
+ memset(&priv->sme_reply, 0, sizeof(sme_reply_t));
+
+ priv->ta_ind_work.in_use = 0;
+ priv->ta_sample_ind_work.in_use = 0;
+
+ priv->CSR_WIFI_SME_IFACEQUEUE = 0xFFFF;
+
+ for (i = 0; i < MAX_MA_UNIDATA_IND_FILTERS; i++) {
+ priv->sme_unidata_ind_filters[i].in_use = 0;
+ }
+
+ /* Create a work queue item for Traffic Analysis indications to SME */
+ INIT_WORK(&priv->ta_ind_work.task, uf_ta_ind_wq);
+ INIT_WORK(&priv->ta_sample_ind_work.task, uf_ta_sample_ind_wq);
+#ifdef CSR_SUPPORT_WEXT
+ INIT_WORK(&priv->sme_config_task, uf_sme_config_wq);
+#endif
+
+ for (i = 0; i < CSR_WIFI_NUM_INTERFACES; i++) {
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[i];
+ interfacePriv->m4_sent = FALSE;
+ interfacePriv->m4_bulk_data.net_buf_length = 0;
+ interfacePriv->m4_bulk_data.data_length = 0;
+ interfacePriv->m4_bulk_data.os_data_ptr = interfacePriv->m4_bulk_data.os_net_buf_ptr = NULL;
+
+ memset(&interfacePriv->controlled_data_port, 0, sizeof(unifi_port_config_t));
+ interfacePriv->controlled_data_port.entries_in_use = 1;
+ interfacePriv->controlled_data_port.port_cfg[0].in_use = TRUE;
+ interfacePriv->controlled_data_port.port_cfg[0].port_action = CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
+ interfacePriv->controlled_data_port.overide_action = UF_DATA_PORT_OVERIDE;
+
+ memset(&interfacePriv->uncontrolled_data_port, 0, sizeof(unifi_port_config_t));
+ interfacePriv->uncontrolled_data_port.entries_in_use = 1;
+ interfacePriv->uncontrolled_data_port.port_cfg[0].in_use = TRUE;
+ interfacePriv->uncontrolled_data_port.port_cfg[0].port_action = CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
+ interfacePriv->uncontrolled_data_port.overide_action = UF_DATA_PORT_OVERIDE;
+
+ /* Mark the remainder of the port config table as unallocated */
+ for(j = 1; j < UNIFI_MAX_CONNECTIONS; j++) {
+ interfacePriv->controlled_data_port.port_cfg[j].in_use = FALSE;
+ interfacePriv->controlled_data_port.port_cfg[j].port_action = CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
+
+ interfacePriv->uncontrolled_data_port.port_cfg[j].in_use = FALSE;
+ interfacePriv->uncontrolled_data_port.port_cfg[j].port_action = CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
+ }
+
+ /* intializing the lists */
+ INIT_LIST_HEAD(&interfacePriv->genericMgtFrames);
+ INIT_LIST_HEAD(&interfacePriv->genericMulticastOrBroadCastMgtFrames);
+ INIT_LIST_HEAD(&interfacePriv->genericMulticastOrBroadCastFrames);
+
+ for(j = 0; j < UNIFI_MAX_CONNECTIONS; j++) {
+ interfacePriv->staInfo[j] = NULL;
+ }
+
+ interfacePriv->num_stations_joined = 0;
+ interfacePriv->sta_activity_check_enabled = FALSE;
+ }
+
+
+ return 0;
+} /* uf_sme_init() */
+
+
+void
+uf_sme_deinit(unifi_priv_t *priv)
+{
+ int i,j;
+ CsrUint8 ba_session_idx;
+ ba_session_rx_struct *ba_session_rx = NULL;
+ ba_session_tx_struct *ba_session_tx = NULL;
+ CsrWifiRouterCtrlStaInfo_t *staInfo = NULL;
+ netInterface_priv_t *interfacePriv = NULL;
+
+ /* Free any TCLASs previously allocated */
+ if (priv->packet_filters.tclas_ies_length) {
+ priv->packet_filters.tclas_ies_length = 0;
+ CsrPmemFree(priv->filter_tclas_ies);
+ priv->filter_tclas_ies = NULL;
+ }
+
+ for (i = 0; i < MAX_MA_UNIDATA_IND_FILTERS; i++) {
+ priv->sme_unidata_ind_filters[i].in_use = 0;
+ }
+
+ /* Remove all the Peer database, before going down */
+ for (i = 0; i < CSR_WIFI_NUM_INTERFACES; i++) {
+ down(&priv->ba_mutex);
+ for(ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_RX; ba_session_idx++){
+ ba_session_rx = priv->interfacePriv[i]->ba_session_rx[ba_session_idx];
+ if(ba_session_rx) {
+ blockack_session_stop(priv,
+ i,
+ CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_RECIPIENT,
+ ba_session_rx->tID,
+ ba_session_rx->macAddress);
+ }
+ }
+ for(ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_TX; ba_session_idx++){
+ ba_session_tx = priv->interfacePriv[i]->ba_session_tx[ba_session_idx];
+ if(ba_session_tx) {
+ blockack_session_stop(priv,
+ i,
+ CSR_WIFI_ROUTER_CTRL_BLOCK_ACK_ORIGINATOR,
+ ba_session_tx->tID,
+ ba_session_tx->macAddress);
+ }
+ }
+
+ up(&priv->ba_mutex);
+ interfacePriv = priv->interfacePriv[i];
+ if(interfacePriv){
+ for(j = 0; j < UNIFI_MAX_CONNECTIONS; j++) {
+ if ((staInfo=interfacePriv->staInfo[j]) != NULL) {
+ /* Clear the STA activity parameters before freeing station Record */
+ unifi_trace(priv, UDBG1, "uf_sme_deinit: Canceling work queue for STA with AID: %d\n", staInfo->aid);
+ cancel_work_sync(&staInfo->send_disconnected_ind_task);
+ staInfo->nullDataHostTag = INVALID_HOST_TAG;
+ }
+ }
+ if (interfacePriv->sta_activity_check_enabled){
+ interfacePriv->sta_activity_check_enabled = FALSE;
+ del_timer_sync(&interfacePriv->sta_activity_check_timer);
+ }
+ }
+ CsrWifiRouterCtrlInterfaceReset(priv, i);
+ priv->interfacePriv[i]->interfaceMode = CSR_WIFI_ROUTER_CTRL_MODE_NONE;
+ }
+
+
+} /* uf_sme_deinit() */
+
+
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_ta_indicate_protocol
+ *
+ * Report that a packet of a particular type has been seen
+ *
+ * Arguments:
+ * drv_priv The device context pointer passed to ta_init.
+ * protocol The protocol type enum value.
+ * direction Whether the packet was a tx or rx.
+ * src_addr The source MAC address from the data packet.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * We defer the actual sending to a background workqueue,
+ * see uf_ta_ind_wq().
+ * ---------------------------------------------------------------------------
+ */
+void
+unifi_ta_indicate_protocol(void *ospriv,
+ CsrWifiRouterCtrlTrafficPacketType packet_type,
+ CsrWifiRouterCtrlProtocolDirection direction,
+ const CsrWifiMacAddress *src_addr)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+
+ if (priv->ta_ind_work.in_use) {
+ unifi_warning(priv,
+ "unifi_ta_indicate_protocol: workqueue item still in use, not sending\n");
+ return;
+ }
+
+ if (CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_RX == direction)
+ {
+ CsrUint16 interfaceTag = 0;
+ CsrWifiRouterCtrlTrafficProtocolIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,
+ interfaceTag,
+ packet_type,
+ direction,
+ *src_addr);
+ }
+ else
+ {
+ priv->ta_ind_work.packet_type = packet_type;
+ priv->ta_ind_work.direction = direction;
+ priv->ta_ind_work.src_addr = *src_addr;
+
+ queue_work(priv->unifi_workqueue, &priv->ta_ind_work.task);
+ }
+
+} /* unifi_ta_indicate_protocol() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_ta_indicate_sampling
+ *
+ * Send the TA sampling information to the SME.
+ *
+ * Arguments:
+ * drv_priv The device context pointer passed to ta_init.
+ * stats The TA sampling data to send.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+unifi_ta_indicate_sampling(void *ospriv, CsrWifiRouterCtrlTrafficStats *stats)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+
+ if (!priv) {
+ return;
+ }
+
+ if (priv->ta_sample_ind_work.in_use) {
+ unifi_warning(priv,
+ "unifi_ta_indicate_sampling: workqueue item still in use, not sending\n");
+ return;
+ }
+
+ priv->ta_sample_ind_work.stats = *stats;
+
+ queue_work(priv->unifi_workqueue, &priv->ta_sample_ind_work.task);
+
+} /* unifi_ta_indicate_sampling() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_ta_indicate_l4stats
+ *
+ * Send the TA TCP/UDP throughput information to the driver.
+ *
+ * Arguments:
+ * drv_priv The device context pointer passed to ta_init.
+ * rxTcpThroughput TCP RX throughput in KiloBytes
+ * txTcpThroughput TCP TX throughput in KiloBytes
+ * rxUdpThroughput UDP RX throughput in KiloBytes
+ * txUdpThroughput UDP TX throughput in KiloBytes
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+unifi_ta_indicate_l4stats(void *ospriv,
+ CsrUint32 rxTcpThroughput,
+ CsrUint32 txTcpThroughput,
+ CsrUint32 rxUdpThroughput,
+ CsrUint32 txUdpThroughput)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+
+ if (!priv) {
+ return;
+ }
+ /* Save the info. The actual action will be taken in unifi_ta_indicate_sampling() */
+ priv->rxTcpThroughput = rxTcpThroughput;
+ priv->txTcpThroughput = txTcpThroughput;
+ priv->rxUdpThroughput = rxUdpThroughput;
+ priv->txUdpThroughput = txUdpThroughput;
+} /* unifi_ta_indicate_l4stats() */
--- /dev/null
+/*
+ * ***************************************************************************
+ * FILE: sme_userspace.h
+ *
+ * PURPOSE: SME related definitions.
+ *
+ * Copyright (C) 2007-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ***************************************************************************
+ */
+#ifndef __LINUX_SME_USERSPACE_H__
+#define __LINUX_SME_USERSPACE_H__ 1
+
+#include <linux/kernel.h>
+
+int uf_sme_init(unifi_priv_t *priv);
+void uf_sme_deinit(unifi_priv_t *priv);
+int uf_sme_queue_message(unifi_priv_t *priv, u8 *buffer, int length);
+
+
+#include "csr_wifi_router_lib.h"
+#include "csr_wifi_router_sef.h"
+#include "csr_wifi_router_ctrl_lib.h"
+#include "csr_wifi_router_ctrl_sef.h"
+#include "csr_wifi_sme_task.h"
+#ifdef CSR_SUPPORT_WEXT_AP
+#include "csr_wifi_nme_ap_lib.h"
+#endif
+#include "csr_wifi_sme_lib.h"
+
+void CsrWifiRouterTransportInit(unifi_priv_t *priv);
+void CsrWifiRouterTransportRecv(unifi_priv_t *priv, CsrUint8* buffer, CsrSize bufferLength);
+void CsrWifiRouterTransportDeInit(unifi_priv_t *priv);
+
+#endif /* __LINUX_SME_USERSPACE_H__ */
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: sme_wext.c
+ *
+ * PURPOSE:
+ * Handlers for ioctls from iwconfig.
+ * These provide the control plane operations.
+ *
+ * Copyright (C) 2007-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include <linux/types.h>
+#include <linux/etherdevice.h>
+#include <linux/if_arp.h>
+#include <asm/uaccess.h>
+#include <linux/ctype.h>
+#include "unifi_priv.h"
+#include <linux/rtnetlink.h>
+
+#define CHECK_INITED(_priv) \
+ do { \
+ if (_priv->init_progress != UNIFI_INIT_COMPLETED) { \
+ unifi_trace(_priv, UDBG2, "%s unifi not ready, failing wext call\n", __FUNCTION__); \
+ return -ENODEV; \
+ } \
+ } while (0)
+
+/* Workaround for the wpa_supplicant hanging issue - disabled on Android */
+#ifndef ANDROID_BUILD
+#define CSR_WIFI_WEXT_HANG_WORKAROUND
+#endif
+
+#ifdef CSR_WIFI_WEXT_HANG_WORKAROUND
+# define UF_RTNL_LOCK() rtnl_lock()
+# define UF_RTNL_UNLOCK() rtnl_unlock()
+#else
+# define UF_RTNL_LOCK()
+# define UF_RTNL_UNLOCK()
+#endif
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * Helper functions
+ * ---------------------------------------------------------------------------
+ */
+
+/*
+ * ---------------------------------------------------------------------------
+ * wext_freq_to_channel
+ * channel_to_mhz
+ *
+ * These functions convert between channel number and frequency.
+ *
+ * Arguments:
+ * ch Channel number, as defined in 802.11 specs
+ * m, e Mantissa and exponent as provided by wireless extension.
+ *
+ * Returns:
+ * channel or frequency (in MHz) value
+ * ---------------------------------------------------------------------------
+ */
+static int
+wext_freq_to_channel(int m, int e)
+{
+ int mhz;
+
+ mhz = m;
+ while (e < 6) {
+ mhz /= 10;
+ e++;
+ }
+ while (e > 6) {
+ mhz *= 10;
+ e--;
+ }
+
+ if (mhz >= 5000) {
+ return ((mhz - 5000) / 5);
+ }
+
+ if (mhz == 2482) {
+ return 14;
+ }
+
+ if (mhz >= 2407) {
+ return ((mhz - 2407) / 5);
+ }
+
+ return 0;
+} /* wext_freq_to_channel() */
+
+static int
+channel_to_mhz(int ch, int dot11a)
+{
+
+ if (ch == 0) return 0;
+ if (ch > 200) return 0;
+
+ /* 5G */
+ if (dot11a) {
+ return (5000 + (5 * ch));
+ }
+
+ /* 2.4G */
+ if (ch == 14) {
+ return 2484;
+ }
+
+ if ((ch < 14) && (ch > 0)) {
+ return (2407 + (5 * ch));
+ }
+
+ return 0;
+}
+#ifdef CSR_SUPPORT_WEXT_AP
+void uf_sme_wext_ap_set_defaults(unifi_priv_t *priv)
+{
+ memcpy(priv->ap_config.ssid.ssid,"defaultssid",sizeof("defaultssid"));
+
+ priv->ap_config.ssid.length = 8;
+ priv->ap_config.channel = 6;
+ priv->ap_config.if_index = 1;
+ priv->ap_config.credentials.authType = 0;
+ priv->ap_config.max_connections=8;
+
+ priv->group_sec_config.apGroupkeyTimeout = 0;
+ priv->group_sec_config.apStrictGtkRekey = 0;
+ priv->group_sec_config.apGmkTimeout = 0;
+ priv->group_sec_config.apResponseTimeout = 100; /* Default*/
+ priv->group_sec_config.apRetransLimit = 3; /* Default*/
+ /* Set default params even if they may not be used*/
+ /* Until Here*/
+
+ priv->ap_mac_config.preamble = CSR_WIFI_SME_USE_LONG_PREAMBLE;
+ priv->ap_mac_config.shortSlotTimeEnabled = FALSE;
+ priv->ap_mac_config.ctsProtectionType=CSR_WIFI_SME_CTS_PROTECTION_AUTOMATIC;
+
+ priv->ap_mac_config.wmmEnabled = TRUE;
+ priv->ap_mac_config.wmmApParams[0].cwMin=4;
+ priv->ap_mac_config.wmmApParams[0].cwMax=10;
+ priv->ap_mac_config.wmmApParams[0].aifs=3;
+ priv->ap_mac_config.wmmApParams[0].txopLimit=0;
+ priv->ap_mac_config.wmmApParams[0].admissionControlMandatory=FALSE;
+ priv->ap_mac_config.wmmApParams[1].cwMin=4;
+ priv->ap_mac_config.wmmApParams[1].cwMax=10;
+ priv->ap_mac_config.wmmApParams[1].aifs=7;
+ priv->ap_mac_config.wmmApParams[1].txopLimit=0;
+ priv->ap_mac_config.wmmApParams[1].admissionControlMandatory=FALSE;
+ priv->ap_mac_config.wmmApParams[2].cwMin=3;
+ priv->ap_mac_config.wmmApParams[2].cwMax=4;
+ priv->ap_mac_config.wmmApParams[2].aifs=1;
+ priv->ap_mac_config.wmmApParams[2].txopLimit=94;
+ priv->ap_mac_config.wmmApParams[2].admissionControlMandatory=FALSE;
+ priv->ap_mac_config.wmmApParams[3].cwMin=2;
+ priv->ap_mac_config.wmmApParams[3].cwMax=3;
+ priv->ap_mac_config.wmmApParams[3].aifs=1;
+ priv->ap_mac_config.wmmApParams[3].txopLimit=47;
+ priv->ap_mac_config.wmmApParams[3].admissionControlMandatory=FALSE;
+
+ priv->ap_mac_config.wmmApBcParams[0].cwMin=4;
+ priv->ap_mac_config.wmmApBcParams[0].cwMax=10;
+ priv->ap_mac_config.wmmApBcParams[0].aifs=3;
+ priv->ap_mac_config.wmmApBcParams[0].txopLimit=0;
+ priv->ap_mac_config.wmmApBcParams[0].admissionControlMandatory=FALSE;
+ priv->ap_mac_config.wmmApBcParams[1].cwMin=4;
+ priv->ap_mac_config.wmmApBcParams[1].cwMax=10;
+ priv->ap_mac_config.wmmApBcParams[1].aifs=7;
+ priv->ap_mac_config.wmmApBcParams[1].txopLimit=0;
+ priv->ap_mac_config.wmmApBcParams[1].admissionControlMandatory=FALSE;
+ priv->ap_mac_config.wmmApBcParams[2].cwMin=3;
+ priv->ap_mac_config.wmmApBcParams[2].cwMax=4;
+ priv->ap_mac_config.wmmApBcParams[2].aifs=2;
+ priv->ap_mac_config.wmmApBcParams[2].txopLimit=94;
+ priv->ap_mac_config.wmmApBcParams[2].admissionControlMandatory=FALSE;
+ priv->ap_mac_config.wmmApBcParams[3].cwMin=2;
+ priv->ap_mac_config.wmmApBcParams[3].cwMax=3;
+ priv->ap_mac_config.wmmApBcParams[3].aifs=2;
+ priv->ap_mac_config.wmmApBcParams[3].txopLimit=47;
+ priv->ap_mac_config.wmmApBcParams[3].admissionControlMandatory=FALSE;
+
+ priv->ap_mac_config.accessType=CSR_WIFI_AP_ACCESS_TYPE_NONE;
+ priv->ap_mac_config.macAddressListCount=0;
+ priv->ap_mac_config.macAddressList=NULL;
+
+ priv->ap_mac_config.apHtParams.rxStbc=1;
+ priv->ap_mac_config.apHtParams.rifsModeAllowed=TRUE;
+ priv->ap_mac_config.apHtParams.greenfieldSupported=FALSE;
+ priv->ap_mac_config.apHtParams.shortGi20MHz=TRUE;
+ priv->ap_mac_config.apHtParams.htProtection=0;
+ priv->ap_mac_config.apHtParams.dualCtsProtection=FALSE;
+
+ priv->ap_mac_config.phySupportedBitmap =
+ (CSR_WIFI_SME_AP_PHY_SUPPORT_B|CSR_WIFI_SME_AP_PHY_SUPPORT_G|CSR_WIFI_SME_AP_PHY_SUPPORT_N);
+ priv->ap_mac_config.beaconInterval= 100;
+ priv->ap_mac_config.dtimPeriod=3;
+ priv->ap_mac_config.maxListenInterval=0x00ff;/* Set it to a large value
+ to enable different types of
+ devices to join us */
+ priv->ap_mac_config.supportedRatesCount =
+ uf_configure_supported_rates(priv->ap_mac_config.supportedRates,priv->ap_mac_config.phySupportedBitmap);
+}
+#endif
+/*
+ * ---------------------------------------------------------------------------
+ * uf_sme_wext_set_defaults
+ *
+ * Set up power-on defaults for driver config.
+ *
+ * Note: The SME Management API *cannot* be used in this function.
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+uf_sme_wext_set_defaults(unifi_priv_t *priv)
+{
+ memset(&priv->connection_config, 0, sizeof(CsrWifiSmeConnectionConfig));
+
+ priv->connection_config.bssType = CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE;
+ priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
+ priv->connection_config.encryptionModeMask = CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE;
+ priv->connection_config.privacyMode = CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED;
+ priv->connection_config.wmmQosInfo = 0xFF;
+ priv->connection_config.ifIndex = CSR_WIFI_SME_RADIO_IF_BOTH;
+ priv->connection_config.adhocJoinOnly = FALSE;
+ priv->connection_config.adhocChannel = 6;
+
+ priv->wep_tx_key_index = 0;
+
+ priv->wext_wireless_stats.qual.qual = 0;
+ priv->wext_wireless_stats.qual.level = 0;
+ priv->wext_wireless_stats.qual.noise = 0;
+ priv->wext_wireless_stats.qual.updated = 0x70;
+#ifdef CSR_SUPPORT_WEXT_AP
+ /* Initialize the default configuration for AP */
+ uf_sme_wext_ap_set_defaults(priv);
+#endif
+
+
+} /* uf_sme_wext_set_defaults() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * WEXT methods
+ * ---------------------------------------------------------------------------
+ */
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_giwname - handler for SIOCGIWNAME
+ * unifi_siwfreq - handler for SIOCSIWFREQ
+ * unifi_giwfreq - handler for SIOCGIWFREQ
+ * unifi_siwmode - handler for SIOCSIWMODE
+ * unifi_giwmode - handler for SIOCGIWMODE
+ * unifi_giwrange - handler for SIOCGIWRANGE
+ * unifi_siwap - handler for SIOCSIWAP
+ * unifi_giwap - handler for SIOCGIWAP
+ * unifi_siwscan - handler for SIOCSIWSCAN
+ * unifi_giwscan - handler for SIOCGIWSCAN
+ * unifi_siwessid - handler for SIOCSIWESSID
+ * unifi_giwessid - handler for SIOCGIWESSID
+ * unifi_siwencode - handler for SIOCSIWENCODE
+ * unifi_giwencode - handler for SIOCGIWENCODE
+ *
+ * Handler functions for IW extensions.
+ * These are registered via the unifi_iw_handler_def struct below
+ * and called by the generic IW driver support code.
+ * See include/net/iw_handler.h.
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static int
+iwprivsdefs(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ int r;
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ CsrWifiSmeMibConfig mibConfig;
+ CsrWifiSmePowerConfig powerConfig;
+
+ unifi_trace(priv, UDBG1, "iwprivs80211defaults: reload defaults\n");
+
+ uf_sme_wext_set_defaults(priv);
+
+ /* Get, modify and set the MIB data */
+ r = sme_mgt_mib_config_get(priv, &mibConfig);
+ if (r) {
+ unifi_error(priv, "iwprivs80211defaults: Get CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+ mibConfig.dot11RtsThreshold = 2347;
+ mibConfig.dot11FragmentationThreshold = 2346;
+ r = sme_mgt_mib_config_set(priv, &mibConfig);
+ if (r) {
+ unifi_error(priv, "iwprivs80211defaults: Set CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW;
+ powerConfig.listenIntervalTu = 100;
+ powerConfig.rxDtims = 1;
+
+ r = sme_mgt_power_config_set(priv, &powerConfig);
+ if (r) {
+ unifi_error(priv, "iwprivs80211defaults: Set unifi_PowerConfigValue failed.\n");
+ return r;
+ }
+
+ return 0;
+} /* iwprivsdefs() */
+
+static int
+iwprivs80211ps(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ int r = 0;
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+
+ int ps_mode = (int)(*extra);
+ CsrWifiSmePowerConfig powerConfig;
+
+ unifi_trace(priv, UDBG1, "iwprivs80211ps: power save mode = %d\n", ps_mode);
+
+ r = sme_mgt_power_config_get(priv, &powerConfig);
+ if (r) {
+ unifi_error(priv, "iwprivs80211ps: Get unifi_PowerConfigValue failed.\n");
+ return r;
+ }
+
+ switch (ps_mode) {
+ case CSR_PMM_ACTIVE_MODE:
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW;
+ break;
+ case CSR_PMM_POWER_SAVE:
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH;
+ break;
+ case CSR_PMM_FAST_POWER_SAVE:
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_MED;
+ break;
+ default:
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_AUTO;
+ break;
+ }
+
+ r = sme_mgt_power_config_set(priv, &powerConfig);
+ if (r) {
+ unifi_error(priv, "iwprivs80211ps: Set unifi_PowerConfigValue failed.\n");
+ }
+
+ return r;
+}
+
+static int
+iwprivg80211ps(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+
+ CsrWifiSmePowerConfig powerConfig;
+ int r;
+
+ r = sme_mgt_power_config_get(priv, &powerConfig);
+ if (r) {
+ unifi_error(priv, "iwprivg80211ps: Get 802.11 power mode failed.\n");
+ return r;
+ }
+
+ switch (powerConfig.powerSaveLevel) {
+ case CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW:
+ snprintf(extra, IWPRIV_POWER_SAVE_MAX_STRING,
+ "Power save mode: %d (Active)",
+ powerConfig.powerSaveLevel);
+ break;
+ case CSR_WIFI_SME_POWER_SAVE_LEVEL_MED:
+ snprintf(extra, IWPRIV_POWER_SAVE_MAX_STRING,
+ "Power save mode: %d (Fast)",
+ powerConfig.powerSaveLevel);
+ break;
+ case CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH:
+ snprintf(extra, IWPRIV_POWER_SAVE_MAX_STRING,
+ "Power save mode: %d (Full)",
+ powerConfig.powerSaveLevel);
+ break;
+ case CSR_WIFI_SME_POWER_SAVE_LEVEL_AUTO:
+ snprintf(extra, IWPRIV_POWER_SAVE_MAX_STRING,
+ "Power save mode: %d (Auto)",
+ powerConfig.powerSaveLevel);
+ break;
+ default:
+ snprintf(extra, IWPRIV_POWER_SAVE_MAX_STRING,
+ "Power save mode: %d (Unknown)",
+ powerConfig.powerSaveLevel);
+ break;
+ }
+
+ wrqu->data.length = strlen(extra) + 1;
+
+ return 0;
+}
+
+static int
+iwprivssmedebug(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ /* No longer supported on the API */
+#if defined (CSR_WIFI_HIP_DEBUG_OFFLINE)
+ unifi_debug_buf_dump();
+#endif
+
+ return 0;
+}
+
+#ifdef CSR_SUPPORT_WEXT_AP
+#define PARAM_TYPE_INT 0
+#define PARAM_TYPE_STRING 1
+#define CSR_WIFI_MAX_SSID_LEN 32
+#define CSR_WIFI_MAX_SEC_LEN 16
+#define CSR_WIFI_MAX_KEY_LEN 65
+
+static int hex_look_up(char x)
+{
+ if(x>='0' && x<='9')
+ return (x-48);
+ if(x>= 'a' && x <= 'f')
+ return (x-87);
+ return -1;
+}
+
+static int power (int a, int b)
+{
+ int i;
+ int num =1;
+ for(i=0;i<b;i++)
+ num *=a;
+ return num;
+}
+
+static int decode_parameter_from_string(unifi_priv_t* priv, char **str_ptr,
+ const char *token, int param_type,
+ void *dst, int param_max_len)
+{
+ CsrUint8 int_str[7] = "0";
+ CsrUint32 param_str_len;
+ CsrUint8 *param_str_begin,*param_str_end;
+ CsrUint8 *orig_str = *str_ptr;
+
+ if (!strncmp(*str_ptr, token, strlen(token))) {
+ strsep(str_ptr, "=,");
+ param_str_begin = *str_ptr;
+ strsep(str_ptr, "=,");
+ if (*str_ptr == NULL) {
+ param_str_len = strlen(param_str_begin);
+ } else {
+ param_str_end = *str_ptr-1;
+ param_str_len = param_str_end - param_str_begin;
+ }
+ unifi_trace(priv,UDBG2,"'token:%s', len:%d, ", token, param_str_len);
+ if (param_str_len > param_max_len) {
+ unifi_notice(priv,"extracted param len:%d is > MAX:%d\n",param_str_len, param_max_len);
+ param_str_len = param_max_len;
+ }
+ switch (param_type) {
+ case PARAM_TYPE_INT:
+ {
+ CsrUint32 *pdst_int = dst,num =0;
+ int i,j=0;
+ if (param_str_len > sizeof(int_str)) {
+ param_str_len = sizeof(int_str);
+ }
+ memcpy(int_str, param_str_begin, param_str_len);
+ for(i = param_str_len; i>0;i--) {
+ if(int_str[i-1] >= '0' && int_str[i-1] <='9') {
+ num += ((int_str[i-1]-'0')*power(10,j));
+ j++;
+ } else {
+ unifi_error(priv,"decode_parameter_from_string:not a number %c\n",(int_str[i-1]));
+ return -1;
+ }
+ }
+ *pdst_int = num;
+ unifi_trace(priv,UDBG2,"decode_parameter_from_string:decoded int = %d\n",*pdst_int);
+ }
+ break;
+ default:
+ memcpy(dst, param_str_begin, param_str_len);
+ *((char *)dst + param_str_len) = 0;
+ unifi_trace(priv,UDBG2,"decode_parameter_from_string:decoded string = %s\n",(char *)dst);
+ break;
+ }
+ } else {
+ unifi_error(priv,"decode_parameter_from_string: Token:%s not found in %s \n",token,orig_str);
+ return -1;
+ }
+ return 0;
+}
+static int store_ap_advanced_config_from_string(unifi_priv_t *priv, char *param_str)
+{
+ char * str_ptr=param_str;
+ int ret = 0,tmp_var;
+ char phy_mode[6];
+ CsrWifiSmeApMacConfig * ap_mac_config = &priv->ap_mac_config;
+
+ /* Check for BI */
+ ret = decode_parameter_from_string(priv, &str_ptr, "BI=",
+ PARAM_TYPE_INT, &tmp_var, 5);
+ if(ret) {
+ unifi_error(priv,"store_ap_advanced_config_from_string: BI not found\n");
+ return -1;
+ }
+ ap_mac_config->beaconInterval = tmp_var;
+ ret = decode_parameter_from_string(priv, &str_ptr, "DTIM_PER=",
+ PARAM_TYPE_INT, &tmp_var, 5);
+ if(ret) {
+ unifi_error(priv,"store_ap_advanced_config_from_string: DTIM_PER not found\n");
+ return -1;
+ }
+ ap_mac_config->dtimPeriod = tmp_var;
+ ret = decode_parameter_from_string(priv, &str_ptr, "WMM=",
+ PARAM_TYPE_INT, &tmp_var, 5);
+ if(ret) {
+ unifi_error(priv,"store_ap_advanced_config_from_string: WMM not found\n");
+ return -1;
+ }
+ ap_mac_config->wmmEnabled = tmp_var;
+ ret = decode_parameter_from_string(priv, &str_ptr, "PHY=",
+ PARAM_TYPE_STRING, phy_mode, 5);
+ if(ret) {
+ unifi_error(priv,"store_ap_advanced_config_from_string: PHY not found\n");
+ } else {
+ if(strstr(phy_mode,"b")){
+ ap_mac_config->phySupportedBitmap = CSR_WIFI_SME_AP_PHY_SUPPORT_B;
+ }
+ if(strstr(phy_mode,"g")) {
+ ap_mac_config->phySupportedBitmap |= CSR_WIFI_SME_AP_PHY_SUPPORT_G;
+ }
+ if(strstr(phy_mode,"n")) {
+ ap_mac_config->phySupportedBitmap |= CSR_WIFI_SME_AP_PHY_SUPPORT_N;
+ }
+ ap_mac_config->supportedRatesCount =
+ uf_configure_supported_rates(ap_mac_config->supportedRates, ap_mac_config->phySupportedBitmap);
+ }
+ return ret;
+}
+
+static int store_ap_config_from_string( unifi_priv_t * priv,char *param_str)
+
+{
+ char *str_ptr = param_str;
+ char sub_cmd[16];
+ char sec[CSR_WIFI_MAX_SEC_LEN];
+ char key[CSR_WIFI_MAX_KEY_LEN];
+ int ret = 0,tmp_var;
+ CsrWifiSmeApConfig_t *ap_config = &priv->ap_config;
+ CsrWifiSmeApMacConfig * ap_mac_config = &priv->ap_mac_config;
+ memset(sub_cmd, 0, sizeof(sub_cmd));
+ if(!strstr(param_str,"END")) {
+ unifi_error(priv,"store_ap_config_from_string:Invalid config string:%s\n",param_str);
+ return -1;
+ }
+ if (decode_parameter_from_string(priv,&str_ptr, "ASCII_CMD=",
+ PARAM_TYPE_STRING, sub_cmd, 6) != 0) {
+ return -1;
+ }
+ if (strncmp(sub_cmd, "AP_CFG", 6)) {
+
+ if(!strncmp(sub_cmd ,"ADVCFG", 6)) {
+ return store_ap_advanced_config_from_string(priv, str_ptr);
+ }
+ unifi_error(priv,"store_ap_config_from_string: sub_cmd:%s != 'AP_CFG or ADVCFG'!\n", sub_cmd);
+ return -1;
+ }
+ memset(ap_config, 0, sizeof(CsrWifiSmeApConfig_t));
+ ret = decode_parameter_from_string(priv,&str_ptr, "SSID=",
+ PARAM_TYPE_STRING, ap_config->ssid.ssid,
+ CSR_WIFI_MAX_SSID_LEN);
+ if(ret) {
+ unifi_error(priv,"store_ap_config_from_string: SSID not found\n");
+ return -1;
+ }
+ ap_config->ssid.length = strlen(ap_config->ssid.ssid);
+
+ ret = decode_parameter_from_string(priv, &str_ptr, "SEC=",
+ PARAM_TYPE_STRING, sec, CSR_WIFI_MAX_SEC_LEN);
+ if(ret) {
+ unifi_error(priv,"store_ap_config_from_string: SEC not found\n");
+ return -1;
+ }
+ ret = decode_parameter_from_string(priv,&str_ptr, "KEY=",
+ PARAM_TYPE_STRING, key, CSR_WIFI_MAX_KEY_LEN);
+ if(!strcasecmp(sec,"open")) {
+ unifi_trace(priv,UDBG2,"store_ap_config_from_string: security open");
+ ap_config->credentials.authType = CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM;
+ if(ret) {
+ unifi_notice(priv,"store_ap_config_from_string: KEY not found:fine with Open\n");
+ }
+ }
+ else if(!strcasecmp(sec,"wpa2-psk")) {
+ int i,j=0;
+ CsrWifiNmeApAuthPers *pers =
+ ((CsrWifiNmeApAuthPers *)&(ap_config->credentials.nmeAuthType.authTypePersonal));
+ CsrUint8 *psk = pers->authPers_credentials.psk.psk;
+
+ unifi_trace(priv,UDBG2,"store_ap_config_from_string: security WPA2");
+ if(ret) {
+ unifi_error(priv,"store_ap_config_from_string: KEY not found for WPA2\n");
+ return -1;
+ }
+ ap_config->credentials.authType = CSR_WIFI_SME_AP_AUTH_TYPE_PERSONAL;
+ pers->authSupport = CSR_WIFI_SME_RSN_AUTH_WPA2PSK;
+ pers->rsnCapabilities =0;
+ pers->wapiCapabilities =0;
+ pers->pskOrPassphrase=CSR_WIFI_NME_AP_CREDENTIAL_TYPE_PSK;
+ pers->authPers_credentials.psk.encryptionMode =
+ (CSR_WIFI_NME_ENCRYPTION_CIPHER_PAIRWISE_CCMP |CSR_WIFI_NME_ENCRYPTION_CIPHER_GROUP_CCMP) ;
+ for(i=0;i<32;i++){
+ psk[i] = (16*hex_look_up(key[j]))+hex_look_up(key[j+1]);
+ j+=2;
+ }
+
+ } else {
+ unifi_notice(priv,"store_ap_config_from_string: Unknown security: Assuming Open");
+ ap_config->credentials.authType = CSR_WIFI_SME_AP_AUTH_TYPE_OPEN_SYSTEM;
+ return -1;
+ }
+ /* Get the decoded value in a temp int variable to ensure that other fields within the struct
+ which are of type other than int are not over written */
+ ret = decode_parameter_from_string(priv,&str_ptr, "CHANNEL=", PARAM_TYPE_INT, &tmp_var, 5);
+ if(ret)
+ return -1;
+ ap_config->channel = tmp_var;
+ ret = decode_parameter_from_string(priv,&str_ptr, "PREAMBLE=", PARAM_TYPE_INT, &tmp_var, 5);
+ if(ret)
+ return -1;
+ ap_mac_config->preamble = tmp_var;
+ ret = decode_parameter_from_string(priv,&str_ptr, "MAX_SCB=", PARAM_TYPE_INT, &tmp_var, 5);
+ ap_config->max_connections = tmp_var;
+ return ret;
+}
+
+static int
+iwprivsapstart(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int r;
+
+ unifi_trace(priv, UDBG1, "iwprivsapstart\n" );
+ r = sme_ap_start(priv,interfacePriv->InterfaceTag,&priv->ap_config);
+ if(r) {
+ unifi_error(priv,"iwprivsapstart AP START failed : %d\n",-r);
+ }
+ return r;
+}
+
+static int
+iwprivsapconfig(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ char *cfg_str = NULL;
+ int r;
+
+ unifi_trace(priv, UDBG1, "iwprivsapconfig\n" );
+ if (wrqu->data.length != 0) {
+ char *str;
+ if (!(cfg_str = kmalloc(wrqu->data.length+1, GFP_KERNEL)))
+ {
+ return -ENOMEM;
+ }
+ if (copy_from_user(cfg_str, wrqu->data.pointer, wrqu->data.length)) {
+ kfree(cfg_str);
+ return -EFAULT;
+ }
+ cfg_str[wrqu->data.length] = 0;
+ unifi_trace(priv,UDBG2,"length:%d\n",wrqu->data.length);
+ unifi_trace(priv,UDBG2,"AP configuration string:%s\n",cfg_str);
+ str = cfg_str;
+ if ((r = store_ap_config_from_string(priv,str))) {
+ unifi_error(priv, "iwprivsapconfig:Failed to decode the string %d\n",r);
+ kfree(cfg_str);
+ return -EIO;
+
+ }
+ } else {
+ unifi_error(priv,"iwprivsapconfig argument length = 0 \n");
+ return -EIO;
+ }
+ r = sme_ap_config(priv, &priv->ap_mac_config, &priv->group_sec_config);
+ if(r) {
+ unifi_error(priv,"iwprivsapstop AP Config failed : %d\n",-r);
+ } else if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_trace(priv, UDBG1, "iwprivsapconfig: Starting the AP");
+ r = sme_ap_start(priv,interfacePriv->InterfaceTag,&priv->ap_config);
+ if(r) {
+ unifi_error(priv,"iwprivsapstart AP START failed : %d\n",-r);
+ }
+ }
+ kfree(cfg_str);
+ return r;
+}
+
+static int
+iwprivsapstop(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int r;
+ CsrUint16 interface_tag = interfacePriv->InterfaceTag;
+
+ unifi_trace(priv, UDBG1, "iwprivsapstop\n" );
+ r = sme_ap_stop(priv,interface_tag);
+ if(r) {
+ unifi_error(priv,"iwprivsapstop AP STOP failed : %d\n",-r);
+ }
+ return r;
+}
+
+#ifdef ANDROID_BUILD
+static int
+iwprivsapfwreload(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+
+ unifi_trace(priv, UDBG1, "iwprivsapfwreload\n" );
+ return 0;
+}
+
+static int
+iwprivsstackstart(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ unifi_trace(priv, UDBG1, "iwprivsstackstart\n" );
+ return 0;
+}
+
+static int
+iwprivsstackstop(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int r = 0;
+ CsrUint16 interface_tag = interfacePriv->InterfaceTag;
+
+ unifi_trace(priv, UDBG1, "iwprivsstackstop\n" );
+
+ switch(interfacePriv->interfaceMode) {
+ case CSR_WIFI_ROUTER_CTRL_MODE_STA:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
+ case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
+ r = sme_mgt_disconnect(priv);
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ r = sme_ap_stop(priv,interface_tag);
+ break;
+ default :
+ break;
+ }
+
+ if(r) {
+ unifi_error(priv,"iwprivsstackstop Stack stop failed : %d\n",-r);
+ }
+ return 0;
+}
+#endif /* ANDROID_BUILD */
+#endif /* CSR_SUPPORT_WEXT_AP */
+
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+static int
+iwprivsconfwapi(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ CsrUint8 enable;
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ func_enter();
+
+ unifi_trace(priv, UDBG1, "iwprivsconfwapi\n" );
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "iwprivsconfwapi: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+ enable = *(CsrUint8*)(extra);
+
+ if (enable) {
+ priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
+ priv->connection_config.authModeMask |= (CSR_WIFI_SME_AUTH_MODE_WAPI_WAIPSK | CSR_WIFI_SME_AUTH_MODE_WAPI_WAI);
+ priv->connection_config.encryptionModeMask |=
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_SMS4 | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_SMS4;
+ } else {
+ priv->connection_config.authModeMask &= ~(CSR_WIFI_SME_AUTH_MODE_WAPI_WAIPSK | CSR_WIFI_SME_AUTH_MODE_WAPI_WAI);
+ priv->connection_config.encryptionModeMask &=
+ ~(CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_SMS4 | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_SMS4);
+ }
+
+ func_exit();
+ return 0;
+}
+
+static int
+iwprivswpikey(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ int r = 0, i;
+ CsrWifiSmeKey key;
+ unifiio_wapi_key_t inKey;
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ func_enter();
+
+ unifi_trace(priv, UDBG1, "iwprivswpikey\n" );
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "iwprivswpikey: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+ inKey = *(unifiio_wapi_key_t*)(extra);
+
+ if (inKey.unicastKey) {
+ key.keyType = CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
+ } else {
+ key.keyType = CSR_WIFI_SME_KEY_TYPE_GROUP;
+ }
+
+ key.keyIndex = inKey.keyIndex;
+
+ /* memcpy(key.keyRsc, inKey.keyRsc, 16); */
+ for (i = 0; i < 16; i+= 2)
+ {
+ key.keyRsc[i/2] = inKey.keyRsc[i+1] << 8 | inKey.keyRsc[i];
+ }
+
+ memcpy(key.address.a, inKey.address, 6);
+ key.keyLength = 32;
+ memcpy(key.key, inKey.key, 32);
+ key.authenticator = 0;
+ key.wepTxKey = 0;
+
+ unifi_trace(priv, UDBG1, "keyType = %d, keyIndex = %d, wepTxKey = %d, keyRsc = %x:%x, auth = %d, address = %x:%x, "
+ "keylength = %d, key = %x:%x\n", key.keyType, key.keyIndex, key.wepTxKey,
+ key.keyRsc[0], key.keyRsc[7], key.authenticator,
+ key.address.a[0], key.address.a[5], key.keyLength, key.key[0],
+ key.key[15]);
+
+ r = sme_mgt_key(priv, &key, CSR_WIFI_SME_LIST_ACTION_ADD);
+ if (r) {
+ unifi_error(priv, "SETKEYS request was rejected with result %d\n", r);
+ return convert_sme_error(r);
+ }
+
+ func_exit();
+ return r;
+}
+#endif
+
+
+static int
+unifi_giwname(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ char *name = wrqu->name;
+ unifi_trace(priv, UDBG2, "unifi_giwname\n");
+
+ if (priv->if_index == CSR_INDEX_5G) {
+ strcpy(name, "IEEE 802.11-a");
+ } else {
+ strcpy(name, "IEEE 802.11-bgn");
+ }
+ return 0;
+} /* unifi_giwname() */
+
+
+static int
+unifi_siwfreq(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_freq *freq = (struct iw_freq *)wrqu;
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "unifi_siwfreq\n");
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwfreq: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ /*
+ * Channel is stored in the connection configuration,
+ * and set later when ask for a connection.
+ */
+ if ((freq->e == 0) && (freq->m <= 1000)) {
+ priv->connection_config.adhocChannel = freq->m;
+ } else {
+ priv->connection_config.adhocChannel = wext_freq_to_channel(freq->m, freq->e);
+ }
+
+ func_exit();
+ return 0;
+} /* unifi_siwfreq() */
+
+
+static int
+unifi_giwfreq(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_freq *freq = (struct iw_freq *)wrqu;
+ int err = 0;
+ CsrWifiSmeConnectionInfo connectionInfo;
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "unifi_giwfreq\n");
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_giwfreq: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ UF_RTNL_UNLOCK();
+ err = sme_mgt_connection_info_get(priv, &connectionInfo);
+ UF_RTNL_LOCK();
+
+ freq->m = channel_to_mhz(connectionInfo.channelNumber,
+ (connectionInfo.networkType80211 == CSR_WIFI_SME_RADIO_IF_GHZ_5_0));
+ freq->e = 6;
+
+ func_exit();
+ return convert_sme_error(err);
+} /* unifi_giwfreq() */
+
+
+static int
+unifi_siwmode(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "unifi_siwmode\n");
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwmode: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ switch(wrqu->mode) {
+ case IW_MODE_ADHOC:
+ priv->connection_config.bssType = CSR_WIFI_SME_BSS_TYPE_ADHOC;
+ break;
+ case IW_MODE_INFRA:
+ priv->connection_config.bssType = CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE;
+ break;
+ case IW_MODE_AUTO:
+ priv->connection_config.bssType = CSR_WIFI_SME_BSS_TYPE_ANY_BSS;
+ break;
+ default:
+ unifi_notice(priv, "Unknown IW MODE value.\n");
+ }
+
+ /* Clear the SSID and BSSID configuration */
+ priv->connection_config.ssid.length = 0;
+ memset(priv->connection_config.bssid.a, 0xFF, ETH_ALEN);
+
+ func_exit();
+ return 0;
+} /* unifi_siwmode() */
+
+
+
+static int
+unifi_giwmode(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ int r = 0;
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ CsrWifiSmeConnectionConfig connectionConfig;
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "unifi_giwmode\n");
+ CHECK_INITED(priv);
+
+ unifi_trace(priv, UDBG2, "unifi_giwmode: Exisitng mode = 0x%x\n",
+ interfacePriv->interfaceMode);
+ switch(interfacePriv->interfaceMode) {
+ case CSR_WIFI_ROUTER_CTRL_MODE_STA:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
+ wrqu->mode = IW_MODE_INFRA;
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ wrqu->mode = IW_MODE_MASTER;
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
+ wrqu->mode = IW_MODE_ADHOC;
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2P:
+ case CSR_WIFI_ROUTER_CTRL_MODE_NONE:
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_connection_config_get(priv, &connectionConfig);
+ UF_RTNL_LOCK();
+ if (r == 0) {
+ switch(connectionConfig.bssType) {
+ case CSR_WIFI_SME_BSS_TYPE_ADHOC:
+ wrqu->mode = IW_MODE_ADHOC;
+ break;
+ case CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE:
+ wrqu->mode = IW_MODE_INFRA;
+ break;
+ default:
+ wrqu->mode = IW_MODE_AUTO;
+ unifi_notice(priv, "Unknown IW MODE value.\n");
+ }
+ }
+ break;
+ default:
+ wrqu->mode = IW_MODE_AUTO;
+ unifi_notice(priv, "Unknown IW MODE value.\n");
+
+ }
+ unifi_trace(priv, UDBG4, "unifi_giwmode: mode = 0x%x\n", wrqu->mode);
+ func_exit();
+ return r;
+} /* unifi_giwmode() */
+
+
+
+static int
+unifi_giwrange(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ struct iw_point *dwrq = &wrqu->data;
+ struct iw_range *range = (struct iw_range *) extra;
+ int i;
+
+ unifi_trace(NULL, UDBG2, "unifi_giwrange\n");
+
+ dwrq->length = sizeof(struct iw_range);
+ memset(range, 0, sizeof(*range));
+ range->min_nwid = 0x0000;
+ range->max_nwid = 0x0000;
+
+ /*
+ * Don't report the frequency/channel table, then the channel
+ * number returned elsewhere will be printed as a channel number.
+ */
+
+ /* Ranges of values reported in quality structs */
+ range->max_qual.qual = 40; /* Max expected qual value */
+ range->max_qual.level = -120; /* Noise floor in dBm */
+ range->max_qual.noise = -120; /* Noise floor in dBm */
+
+
+ /* space for IW_MAX_BITRATES (8 up to WE15, 32 later) */
+ i = 0;
+#if WIRELESS_EXT > 15
+ range->bitrate[i++] = 2 * 500000;
+ range->bitrate[i++] = 4 * 500000;
+ range->bitrate[i++] = 11 * 500000;
+ range->bitrate[i++] = 22 * 500000;
+ range->bitrate[i++] = 12 * 500000;
+ range->bitrate[i++] = 18 * 500000;
+ range->bitrate[i++] = 24 * 500000;
+ range->bitrate[i++] = 36 * 500000;
+ range->bitrate[i++] = 48 * 500000;
+ range->bitrate[i++] = 72 * 500000;
+ range->bitrate[i++] = 96 * 500000;
+ range->bitrate[i++] = 108 * 500000;
+#else
+ range->bitrate[i++] = 2 * 500000;
+ range->bitrate[i++] = 4 * 500000;
+ range->bitrate[i++] = 11 * 500000;
+ range->bitrate[i++] = 22 * 500000;
+ range->bitrate[i++] = 24 * 500000;
+ range->bitrate[i++] = 48 * 500000;
+ range->bitrate[i++] = 96 * 500000;
+ range->bitrate[i++] = 108 * 500000;
+#endif /* WIRELESS_EXT < 16 */
+ range->num_bitrates = i;
+
+ range->max_encoding_tokens = NUM_WEPKEYS;
+ range->num_encoding_sizes = 2;
+ range->encoding_size[0] = 5;
+ range->encoding_size[1] = 13;
+
+ range->we_version_source = 20;
+ range->we_version_compiled = WIRELESS_EXT;
+
+ /* Number of channels available in h/w */
+ range->num_channels = 14;
+ /* Number of entries in freq[] array */
+ range->num_frequency = 14;
+ for (i = 0; (i < range->num_frequency) && (i < IW_MAX_FREQUENCIES); i++) {
+ int chan = i + 1;
+ range->freq[i].i = chan;
+ range->freq[i].m = channel_to_mhz(chan, 0);
+ range->freq[i].e = 6;
+ }
+ if ((i+3) < IW_MAX_FREQUENCIES) {
+ range->freq[i].i = 36;
+ range->freq[i].m = channel_to_mhz(36, 1);
+ range->freq[i].e = 6;
+ range->freq[i+1].i = 40;
+ range->freq[i+1].m = channel_to_mhz(40, 1);
+ range->freq[i+1].e = 6;
+ range->freq[i+2].i = 44;
+ range->freq[i+2].m = channel_to_mhz(44, 1);
+ range->freq[i+2].e = 6;
+ range->freq[i+3].i = 48;
+ range->freq[i+3].m = channel_to_mhz(48, 1);
+ range->freq[i+3].e = 6;
+ }
+
+#if WIRELESS_EXT > 16
+ /* Event capability (kernel + driver) */
+ range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
+ IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
+ IW_EVENT_CAPA_MASK(SIOCGIWAP) |
+ IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
+ range->event_capa[1] = IW_EVENT_CAPA_K_1;
+ range->event_capa[4] = (IW_EVENT_CAPA_MASK(IWEVTXDROP) |
+ IW_EVENT_CAPA_MASK(IWEVCUSTOM) |
+ IW_EVENT_CAPA_MASK(IWEVREGISTERED) |
+ IW_EVENT_CAPA_MASK(IWEVEXPIRED));
+#endif /* WIRELESS_EXT > 16 */
+
+#if WIRELESS_EXT > 17
+ range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
+ IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
+#endif /* WIRELESS_EXT > 17 */
+
+
+ return 0;
+} /* unifi_giwrange() */
+
+
+static int
+unifi_siwap(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int err = 0;
+ const unsigned char zero_bssid[ETH_ALEN] = {0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00};
+
+ func_enter();
+
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwap: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ if (wrqu->ap_addr.sa_family != ARPHRD_ETHER) {
+ return -EINVAL;
+ }
+
+ unifi_trace(priv, UDBG1, "unifi_siwap: asked for %02X:%02X:%02X:%02X:%02X:%02X\n",
+ (u8)wrqu->ap_addr.sa_data[0],
+ (u8)wrqu->ap_addr.sa_data[1],
+ (u8)wrqu->ap_addr.sa_data[2],
+ (u8)wrqu->ap_addr.sa_data[3],
+ (u8)wrqu->ap_addr.sa_data[4],
+ (u8)wrqu->ap_addr.sa_data[5]);
+
+ if (!memcmp(wrqu->ap_addr.sa_data, zero_bssid, ETH_ALEN)) {
+ priv->ignore_bssid_join = FALSE;
+ err = sme_mgt_disconnect(priv);
+ if (err) {
+ unifi_trace(priv, UDBG4, "unifi_siwap: Disconnect failed, status %d\n", err);
+ }
+ return 0;
+ }
+
+ if (priv->ignore_bssid_join) {
+ unifi_trace(priv, UDBG4, "unifi_siwap: ignoring second join\n");
+ priv->ignore_bssid_join = FALSE;
+ } else {
+ memcpy(priv->connection_config.bssid.a, wrqu->ap_addr.sa_data, ETH_ALEN);
+ unifi_trace(priv, UDBG1, "unifi_siwap: Joining %X:%X:%X:%X:%X:%X\n",
+ priv->connection_config.bssid.a[0],
+ priv->connection_config.bssid.a[1],
+ priv->connection_config.bssid.a[2],
+ priv->connection_config.bssid.a[3],
+ priv->connection_config.bssid.a[4],
+ priv->connection_config.bssid.a[5]);
+ err = sme_mgt_connect(priv);
+ if (err) {
+ unifi_error(priv, "unifi_siwap: Join failed, status %d\n", err);
+ func_exit();
+ return convert_sme_error(err);
+ }
+ }
+ func_exit();
+
+ return 0;
+} /* unifi_siwap() */
+
+
+static int
+unifi_giwap(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ CsrWifiSmeConnectionInfo connectionInfo;
+ int r = 0;
+ CsrUint8 *bssid;
+
+ func_enter();
+
+ CHECK_INITED(priv);
+ unifi_trace(priv, UDBG2, "unifi_giwap\n");
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "iwprivswpikey: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_connection_info_get(priv, &connectionInfo);
+ UF_RTNL_LOCK();
+
+ if (r == 0) {
+ bssid = connectionInfo.bssid.a;
+ wrqu->ap_addr.sa_family = ARPHRD_ETHER;
+ unifi_trace(priv, UDBG4,
+ "unifi_giwap: BSSID = %02X:%02X:%02X:%02X:%02X:%02X\n",
+ bssid[0], bssid[1], bssid[2],
+ bssid[3], bssid[4], bssid[5]);
+
+ memcpy(wrqu->ap_addr.sa_data, bssid, ETH_ALEN);
+ } else {
+ memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
+ }
+
+ func_exit();
+ return 0;
+} /* unifi_giwap() */
+
+
+static int
+unifi_siwscan(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int scantype;
+ int r;
+ CsrWifiSsid scan_ssid;
+ unsigned char *channel_list = NULL;
+ int chans_good = 0;
+#if WIRELESS_EXT > 17
+ struct iw_point *data = &wrqu->data;
+ struct iw_scan_req *req = (struct iw_scan_req *) extra;
+#endif
+
+ func_enter();
+
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwscan: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ scantype = UNIFI_SCAN_ACTIVE;
+
+#if WIRELESS_EXT > 17
+ /* Providing a valid channel list will force an active scan */
+ if (req) {
+ if ((req->num_channels > 0) && (req->num_channels < IW_MAX_FREQUENCIES)) {
+ channel_list = kmalloc(req->num_channels, GFP_KERNEL);
+ if (channel_list) {
+ int i;
+ for (i = 0; i < req->num_channels; i++) {
+ /* Convert frequency to channel number */
+ int ch = wext_freq_to_channel(req->channel_list[i].m,
+ req->channel_list[i].e);
+ if (ch) {
+ channel_list[chans_good++] = ch;
+ }
+ }
+ unifi_trace(priv, UDBG1,
+ "SIWSCAN: Scanning %d channels\n", chans_good);
+ } else {
+ /* Fall back to scanning all */
+ unifi_error(priv, "SIWSCAN: Can't alloc channel_list (%d)\n",
+ req->num_channels);
+ }
+ }
+ }
+
+ if (req && (data->flags & IW_SCAN_THIS_ESSID)) {
+ memcpy(scan_ssid.ssid, req->essid, req->essid_len);
+ scan_ssid.length = req->essid_len;
+ unifi_trace(priv, UDBG1,
+ "SIWSCAN: Scanning for %.*s\n",
+ scan_ssid.length, scan_ssid.ssid);
+ } else
+#endif
+ {
+ unifi_trace(priv, UDBG1, "SIWSCAN: Scanning for all APs\n");
+ scan_ssid.length = 0;
+ }
+
+ r = sme_mgt_scan_full(priv, &scan_ssid, chans_good, channel_list);
+ if (r) {
+ unifi_error(priv, "SIWSCAN: Scan returned error %d\n", r);
+ } else {
+ unifi_trace(priv, UDBG1, "SIWSCAN: Scan done\n");
+ wext_send_scan_results_event(priv);
+ }
+
+ if (channel_list) {
+ kfree(channel_list);
+ }
+
+ func_exit();
+ return r;
+
+} /* unifi_siwscan() */
+
+
+static const unsigned char *
+unifi_find_info_element(int id, const unsigned char *info, int len)
+{
+ const unsigned char *ie = info;
+
+ while (len > 1)
+ {
+ int e_id, e_len;
+ e_id = ie[0];
+ e_len = ie[1];
+
+ /* Return if we find a match */
+ if (e_id == id)
+ {
+ return ie;
+ }
+
+ len -= (e_len + 2);
+ ie += (e_len + 2);
+ }
+
+ return NULL;
+} /* unifi_find_info_element() */
+
+
+/*
+ * Translate scan data returned from the card to a card independent
+ * format that the Wireless Tools will understand - Jean II
+ */
+int
+unifi_translate_scan(struct net_device *dev,
+ struct iw_request_info *info,
+ char *current_ev, char *end_buf,
+ CsrWifiSmeScanResult *scan_data,
+ int scan_index)
+{
+ struct iw_event iwe; /* Temporary buffer */
+ unsigned char *info_elems;
+ int info_elem_len;
+ const unsigned char *elem;
+ u16 capabilities;
+ int signal, noise, snr;
+ char *start_buf = current_ev;
+ char *current_val; /* For rates */
+ int i, r;
+
+ info_elems = scan_data->informationElements;
+ info_elem_len = scan_data->informationElementsLength;
+
+ if (!scan_data->informationElementsLength || !scan_data->informationElements) {
+ unifi_error(NULL, "*** NULL SCAN IEs ***\n");
+ return -EIO;
+ }
+
+ /* get capinfo bits */
+ capabilities = scan_data->capabilityInformation;
+
+ unifi_trace(NULL, UDBG5, "Capabilities: 0x%x\n", capabilities);
+
+ /* First entry *MUST* be the AP MAC address */
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = SIOCGIWAP;
+ iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
+ memcpy(iwe.u.ap_addr.sa_data, scan_data->bssid.a, ETH_ALEN);
+ iwe.len = IW_EV_ADDR_LEN;
+ r = uf_iwe_stream_add_event(info, start_buf, end_buf, &iwe, IW_EV_ADDR_LEN);
+ if (r < 0) {
+ return r;
+ }
+ start_buf += r;
+
+ /* Other entries will be displayed in the order we give them */
+
+ /* Add the ESSID */
+ /* find SSID in Info Elems */
+ elem = unifi_find_info_element(IE_SSID_ID, info_elems, info_elem_len);
+ if (elem) {
+ int e_len = elem[1];
+ const unsigned char *e_ptr = elem + 2;
+ unsigned char buf[33];
+
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = SIOCGIWESSID;
+ iwe.u.essid.length = e_len;
+ if (iwe.u.essid.length > 32) {
+ iwe.u.essid.length = 32;
+ }
+ iwe.u.essid.flags = scan_index;
+ memcpy(buf, e_ptr, iwe.u.essid.length);
+ buf[iwe.u.essid.length] = '\0';
+ r = uf_iwe_stream_add_point(info, start_buf, end_buf, &iwe, buf);
+ if (r < 0) {
+ return r;
+ }
+ start_buf += r;
+
+ }
+
+ /* Add mode */
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = SIOCGIWMODE;
+ if (scan_data->bssType == CSR_WIFI_SME_BSS_TYPE_INFRASTRUCTURE) {
+ iwe.u.mode = IW_MODE_INFRA;
+ } else {
+ iwe.u.mode = IW_MODE_ADHOC;
+ }
+ iwe.len = IW_EV_UINT_LEN;
+ r = uf_iwe_stream_add_event(info, start_buf, end_buf, &iwe, IW_EV_UINT_LEN);
+ if (r < 0) {
+ return r;
+ }
+ start_buf += r;
+
+ /* Add frequency. iwlist will convert to channel using table given in giwrange */
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = SIOCGIWFREQ;
+ iwe.u.freq.m = scan_data->channelFrequency;
+ iwe.u.freq.e = 6;
+ r = uf_iwe_stream_add_event(info, start_buf, end_buf, &iwe, IW_EV_FREQ_LEN);
+ if (r < 0) {
+ return r;
+ }
+ start_buf += r;
+
+
+ /* Add quality statistics */
+ iwe.cmd = IWEVQUAL;
+ /*
+ * level and noise below are mapped into an unsigned 8 bit number,
+ * ranging from [-192; 63]. The way this is achieved is simply to
+ * add 0x100 onto the number if it is negative,
+ * once clipped to the correct range.
+ */
+ signal = scan_data->rssi; /* This value is in dBm */
+ /* Clip range of snr */
+ snr = (scan_data->snr > 0) ? scan_data->snr : 0; /* In dB relative, from 0 - 255 */
+ snr = (snr < 255) ? snr : 255;
+ noise = signal - snr;
+
+ /* Clip range of signal */
+ signal = (signal < 63) ? signal : 63;
+ signal = (signal > -192) ? signal : -192;
+
+ /* Clip range of noise */
+ noise = (noise < 63) ? noise : 63;
+ noise = (noise > -192) ? noise : -192;
+
+ /* Make u8 */
+ signal = ( signal < 0 ) ? signal + 0x100 : signal;
+ noise = ( noise < 0 ) ? noise + 0x100 : noise;
+
+ iwe.u.qual.level = (u8)signal; /* -192 : 63 */
+ iwe.u.qual.noise = (u8)noise; /* -192 : 63 */
+ iwe.u.qual.qual = snr; /* 0 : 255 */
+ iwe.u.qual.updated = 0;
+#if WIRELESS_EXT > 16
+ iwe.u.qual.updated |= IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_UPDATED |
+ IW_QUAL_QUAL_UPDATED;
+#if WIRELESS_EXT > 18
+ iwe.u.qual.updated |= IW_QUAL_DBM;
+#endif
+#endif
+ r = uf_iwe_stream_add_event(info, start_buf, end_buf, &iwe, IW_EV_QUAL_LEN);
+ if (r < 0) {
+ return r;
+ }
+ start_buf += r;
+
+ /* Add encryption capability */
+ iwe.cmd = SIOCGIWENCODE;
+ if (capabilities & SIG_CAP_PRIVACY) {
+ iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
+ } else {
+ iwe.u.data.flags = IW_ENCODE_DISABLED;
+ }
+ iwe.u.data.length = 0;
+ iwe.len = IW_EV_POINT_LEN + iwe.u.data.length;
+ r = uf_iwe_stream_add_point(info, start_buf, end_buf, &iwe, "");
+ if (r < 0) {
+ return r;
+ }
+ start_buf += r;
+
+
+ /*
+ * Rate : stuffing multiple values in a single event require a bit
+ * more of magic - Jean II
+ */
+ current_val = start_buf + IW_EV_LCP_LEN;
+
+ iwe.cmd = SIOCGIWRATE;
+ /* Those two flags are ignored... */
+ iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
+
+ elem = unifi_find_info_element(IE_SUPPORTED_RATES_ID,
+ info_elems, info_elem_len);
+ if (elem) {
+ int e_len = elem[1];
+ const unsigned char *e_ptr = elem + 2;
+
+ /*
+ * Count how many rates we have.
+ * Zero marks the end of the list, if the list is not truncated.
+ */
+ /* Max 8 values */
+ for (i = 0; i < e_len; i++) {
+ if (e_ptr[i] == 0) {
+ break;
+ }
+ /* Bit rate given in 500 kb/s units (+ 0x80) */
+ iwe.u.bitrate.value = ((e_ptr[i] & 0x7f) * 500000);
+ /* Add new value to event */
+ r = uf_iwe_stream_add_value(info, start_buf, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
+ if (r < 0) {
+ return r;
+ }
+ current_val +=r;
+
+ }
+ }
+ elem = unifi_find_info_element(IE_EXTENDED_SUPPORTED_RATES_ID,
+ info_elems, info_elem_len);
+ if (elem) {
+ int e_len = elem[1];
+ const unsigned char *e_ptr = elem + 2;
+
+ /*
+ * Count how many rates we have.
+ * Zero marks the end of the list, if the list is not truncated.
+ */
+ /* Max 8 values */
+ for (i = 0; i < e_len; i++) {
+ if (e_ptr[i] == 0) {
+ break;
+ }
+ /* Bit rate given in 500 kb/s units (+ 0x80) */
+ iwe.u.bitrate.value = ((e_ptr[i] & 0x7f) * 500000);
+ /* Add new value to event */
+ r = uf_iwe_stream_add_value(info, start_buf, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
+ if (r < 0) {
+ return r;
+ }
+ current_val +=r;
+ }
+ }
+ /* Check if we added any rates event */
+ if ((current_val - start_buf) > IW_EV_LCP_LEN) {
+ start_buf = current_val;
+ }
+
+
+#if WIRELESS_EXT > 17
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = IWEVGENIE;
+ iwe.u.data.length = info_elem_len;
+
+ r = uf_iwe_stream_add_point(info, start_buf, end_buf, &iwe, info_elems);
+ if (r < 0) {
+ return r;
+ }
+
+ start_buf += r;
+#endif /* WE > 17 */
+
+ return (start_buf - current_ev);
+} /* unifi_translate_scan() */
+
+
+
+static int
+unifi_giwscan(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_point *dwrq = &wrqu->data;
+ int r;
+
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_giwscan: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ unifi_trace(priv, UDBG1,
+ "unifi_giwscan: buffer (%d bytes) \n",
+ dwrq->length);
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_scan_results_get_async(priv, info, extra, dwrq->length);
+ UF_RTNL_LOCK();
+ if (r < 0) {
+ unifi_trace(priv, UDBG1,
+ "unifi_giwscan: buffer (%d bytes) not big enough.\n",
+ dwrq->length);
+ return r;
+ }
+
+ dwrq->length = r;
+ dwrq->flags = 0;
+
+ return 0;
+} /* unifi_giwscan() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_siwessid
+ *
+ * Request to join a network or start and AdHoc.
+ *
+ * Arguments:
+ * dev Pointer to network device struct.
+ * info Pointer to broken-out ioctl request.
+ * data Pointer to argument data.
+ * essid Pointer to string giving name of network to join
+ * or start
+ *
+ * Returns:
+ * 0 on success and everything complete
+ * -EINPROGRESS to have the higher level call the commit method.
+ * ---------------------------------------------------------------------------
+ */
+static int
+unifi_siwessid(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *data, char *essid)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int len;
+ int err = 0;
+
+ func_enter();
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwessid: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ len = 0;
+ if (data->flags & 1) {
+ /* Limit length */
+ len = data->length;
+ if (len > UNIFI_MAX_SSID_LEN) {
+ len = UNIFI_MAX_SSID_LEN;
+ }
+ }
+
+#ifdef UNIFI_DEBUG
+ {
+ char essid_str[UNIFI_MAX_SSID_LEN+1];
+ int i;
+
+ for (i = 0; i < len; i++) {
+ essid_str[i] = (isprint(essid[i]) ? essid[i] : '?');
+ }
+ essid_str[i] = '\0';
+
+ unifi_trace(priv, UDBG1, "unifi_siwessid: asked for '%*s' (%d)\n", len, essid_str, len);
+ unifi_trace(priv, UDBG2, " with authModeMask = %d", priv->connection_config.authModeMask);
+ }
+#endif
+
+ memset(priv->connection_config.bssid.a, 0xFF, ETH_ALEN);
+ if (len) {
+ if (essid[len - 1] == 0) {
+ len --;
+ }
+
+ memcpy(priv->connection_config.ssid.ssid, essid, len);
+ priv->connection_config.ssid.length = len;
+
+ } else {
+ priv->connection_config.ssid.length = 0;
+ }
+
+ UF_RTNL_UNLOCK();
+ err = sme_mgt_connect(priv);
+ UF_RTNL_LOCK();
+ if (err) {
+ unifi_error(priv, "unifi_siwessid: Join failed, status %d\n", err);
+ func_exit();
+ return convert_sme_error(err);
+ }
+
+ func_exit();
+ return 0;
+} /* unifi_siwessid() */
+
+
+static int
+unifi_giwessid(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *essid)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_point *data = &wrqu->essid;
+ CsrWifiSmeConnectionInfo connectionInfo;
+ int r = 0;
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "unifi_giwessid\n");
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_giwessid: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_connection_info_get(priv, &connectionInfo);
+ UF_RTNL_LOCK();
+
+ if (r == 0) {
+ data->length = connectionInfo.ssid.length;
+ strncpy(essid,
+ connectionInfo.ssid.ssid,
+ data->length);
+ data->flags = 1; /* active */
+
+ unifi_trace(priv, UDBG2, "unifi_giwessid: %.*s\n",
+ data->length, essid);
+ }
+
+ func_exit();
+
+ return 0;
+} /* unifi_giwessid() */
+
+
+static int
+unifi_siwrate(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_param *args = &wrqu->bitrate;
+ CsrWifiSmeMibConfig mibConfig;
+ int r;
+
+ func_enter();
+
+ CHECK_INITED(priv);
+ unifi_trace(priv, UDBG2, "unifi_siwrate\n");
+
+ /*
+ * If args->fixed == 0, value is max rate or -1 for best
+ * If args->fixed == 1, value is rate to set or -1 for best
+ * args->disabled and args->flags are not used in SIOCSIWRATE
+ */
+
+ /* Get, modify and set the MIB data */
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_mib_config_get(priv, &mibConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_siwrate: Get CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+
+ /* Default to auto rate algorithm */
+ /* in 500Kbit/s, 0 means auto */
+ mibConfig.unifiFixTxDataRate = 0;
+
+ if (args->value != -1) {
+ mibConfig.unifiFixTxDataRate = args->value / 500000;
+ }
+
+ /* 1 means rate is a maximum, 2 means rate is a set value */
+ if (args->fixed == 1) {
+ mibConfig.unifiFixMaxTxDataRate = 0;
+ } else {
+ mibConfig.unifiFixMaxTxDataRate = 1;
+ }
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_mib_config_set(priv, &mibConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_siwrate: Set CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+
+ func_exit();
+
+ return 0;
+} /* unifi_siwrate() */
+
+
+
+static int
+unifi_giwrate(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_param *args = &wrqu->bitrate;
+ int r;
+ int bitrate, flag;
+ CsrWifiSmeMibConfig mibConfig;
+ CsrWifiSmeConnectionStats connectionStats;
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "unifi_giwrate\n");
+ CHECK_INITED(priv);
+
+ flag = 0;
+ bitrate = 0;
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_mib_config_get(priv, &mibConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_giwrate: Get CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+
+ bitrate = mibConfig.unifiFixTxDataRate;
+ flag = mibConfig.unifiFixMaxTxDataRate;
+
+ /* Used the value returned by the SME if MIB returns 0 */
+ if (bitrate == 0) {
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_connection_stats_get(priv, &connectionStats);
+ UF_RTNL_LOCK();
+ /* Ignore errors, we may be disconnected */
+ if (r == 0) {
+ bitrate = connectionStats.unifiTxDataRate;
+ }
+ }
+
+ args->value = bitrate * 500000;
+ args->fixed = !flag;
+
+ func_exit();
+
+ return 0;
+} /* unifi_giwrate() */
+
+
+static int
+unifi_siwrts(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int val = wrqu->rts.value;
+ int r = 0;
+ CsrWifiSmeMibConfig mibConfig;
+
+ unifi_trace(priv, UDBG2, "unifi_siwrts\n");
+ CHECK_INITED(priv);
+
+ if (wrqu->rts.disabled) {
+ val = 2347;
+ }
+
+ if ( (val < 0) || (val > 2347) )
+ {
+ return -EINVAL;
+ }
+
+ /* Get, modify and set the MIB data */
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_mib_config_get(priv, &mibConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_siwrts: Get CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+ mibConfig.dot11RtsThreshold = val;
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_mib_config_set(priv, &mibConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_siwrts: Set CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+
+ return 0;
+}
+
+
+static int
+unifi_giwrts(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int r;
+ int rts_thresh;
+ CsrWifiSmeMibConfig mibConfig;
+
+ unifi_trace(priv, UDBG2, "unifi_giwrts\n");
+ CHECK_INITED(priv);
+
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_mib_config_get(priv, &mibConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_giwrts: Get CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+
+ rts_thresh = mibConfig.dot11RtsThreshold;
+ if (rts_thresh > 2347) {
+ rts_thresh = 2347;
+ }
+
+ wrqu->rts.value = rts_thresh;
+ wrqu->rts.disabled = (rts_thresh == 2347);
+ wrqu->rts.fixed = 1;
+
+ return 0;
+}
+
+
+static int
+unifi_siwfrag(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int val = wrqu->frag.value;
+ int r = 0;
+ CsrWifiSmeMibConfig mibConfig;
+
+ unifi_trace(priv, UDBG2, "unifi_siwfrag\n");
+ CHECK_INITED(priv);
+
+ if (wrqu->frag.disabled)
+ val = 2346;
+
+ if ( (val < 256) || (val > 2347) )
+ return -EINVAL;
+
+ /* Get, modify and set the MIB data */
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_mib_config_get(priv, &mibConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_siwfrag: Get CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+ /* Fragmentation Threashold must be even */
+ mibConfig.dot11FragmentationThreshold = (val & ~0x1);
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_mib_config_set(priv, &mibConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_siwfrag: Set CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+
+ return 0;
+}
+
+
+static int
+unifi_giwfrag(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int r;
+ int frag_thresh;
+ CsrWifiSmeMibConfig mibConfig;
+
+ unifi_trace(priv, UDBG2, "unifi_giwfrag\n");
+ CHECK_INITED(priv);
+
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_mib_config_get(priv, &mibConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_giwfrag: Get CsrWifiSmeMibConfigValue failed.\n");
+ return r;
+ }
+
+ frag_thresh = mibConfig.dot11FragmentationThreshold;
+
+ /* Build the return structure */
+ wrqu->frag.value = frag_thresh;
+ wrqu->frag.disabled = (frag_thresh >= 2346);
+ wrqu->frag.fixed = 1;
+
+ return 0;
+}
+
+
+static int
+unifi_siwencode(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_point *erq = &wrqu->encoding;
+ int index;
+ int rc = 0;
+ int privacy = -1;
+ CsrWifiSmeKey sme_key;
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "unifi_siwencode\n");
+
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwencode: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ /*
+ * Key index is encoded in the flags.
+ * 0 - use current default,
+ * 1-4 - if a key value is given set that key
+ * if not use that key
+ */
+ index = (erq->flags & IW_ENCODE_INDEX); /* key number, 1-4 */
+ if ((index < 0) || (index > 4)) {
+ unifi_error(priv, "unifi_siwencode: Request to set an invalid key (index:%d)", index);
+ return -EINVAL;
+ }
+
+ /*
+ * Basic checking: do we have a key to set ?
+ * The IW_ENCODE_NOKEY flag is set when no key is present (only change flags),
+ * but older versions rely on sending a key id 1-4.
+ */
+ if (erq->length > 0) {
+
+ /* Check the size of the key */
+ if ((erq->length > LARGE_KEY_SIZE) || (erq->length < SMALL_KEY_SIZE)) {
+ unifi_error(priv, "unifi_siwencode: Request to set an invalid key (length:%d)",
+ erq->length);
+ return -EINVAL;
+ }
+
+ /* Check the index (none (i.e. 0) means use current) */
+ if ((index < 1) || (index > 4)) {
+ /* If we do not have a previous key, use 1 as default */
+ if (!priv->wep_tx_key_index) {
+ priv->wep_tx_key_index = 1;
+ }
+ index = priv->wep_tx_key_index;
+ }
+
+ /* If we didn't have a key and a valid index is set, we want to remember it*/
+ if (!priv->wep_tx_key_index) {
+ priv->wep_tx_key_index = index;
+ }
+
+ unifi_trace(priv, UDBG1, "Tx key Index is %d\n", priv->wep_tx_key_index);
+
+ privacy = 1;
+
+ /* Check if the key is not marked as invalid */
+ if ((erq->flags & IW_ENCODE_NOKEY) == 0) {
+
+ unifi_trace(priv, UDBG1, "New %s key (len=%d, index=%d)\n",
+ (priv->wep_tx_key_index == index) ? "tx" : "",
+ erq->length, index);
+
+ sme_key.wepTxKey = (priv->wep_tx_key_index == index);
+ if (priv->wep_tx_key_index == index) {
+ sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
+ } else {
+ sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_GROUP;
+ }
+ /* Key index is zero based in SME but 1 based in wext */
+ sme_key.keyIndex = (index - 1);
+ sme_key.keyLength = erq->length;
+ sme_key.authenticator = 0;
+ memset(sme_key.address.a, 0xFF, ETH_ALEN);
+ memcpy(sme_key.key, extra, erq->length);
+
+ UF_RTNL_UNLOCK();
+ rc = sme_mgt_key(priv, &sme_key, CSR_WIFI_SME_LIST_ACTION_ADD);
+ UF_RTNL_LOCK();
+ if (rc) {
+ unifi_error(priv, "unifi_siwencode: Set key failed (%d)", rc);
+ return convert_sme_error(rc);
+ }
+
+ /* Store the key to be reported by the SIOCGIWENCODE handler */
+ priv->wep_keys[index - 1].len = erq->length;
+ memcpy(priv->wep_keys[index - 1].key, extra, erq->length);
+ }
+ } else {
+ /*
+ * No additional key data, so it must be a request to change the
+ * active key.
+ */
+ if (index != 0) {
+ unifi_trace(priv, UDBG1, "Tx key Index is %d\n", index - 1);
+
+ /* Store the index to be reported by the SIOCGIWENCODE handler */
+ priv->wep_tx_key_index = index;
+
+ sme_key.wepTxKey = 1;
+ sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
+
+ /* Key index is zero based in SME but 1 based in wext */
+ sme_key.keyIndex = (index - 1);
+ sme_key.keyLength = 0;
+ sme_key.authenticator = 0;
+ UF_RTNL_UNLOCK();
+ rc = sme_mgt_key(priv, &sme_key, CSR_WIFI_SME_LIST_ACTION_ADD);
+ UF_RTNL_LOCK();
+ if (rc) {
+ unifi_error(priv, "unifi_siwencode: Set key failed (%d)", rc);
+ return convert_sme_error(rc);
+ }
+
+ /* Turn on encryption */
+ privacy = 1;
+ }
+ }
+
+ /* Read the flags */
+ if (erq->flags & IW_ENCODE_DISABLED) {
+ /* disable encryption */
+ unifi_trace(priv, UDBG1, "disable WEP encryption\n");
+ privacy = 0;
+
+ priv->wep_tx_key_index = 0;
+
+ unifi_trace(priv, UDBG1, "IW_ENCODE_DISABLED: CSR_WIFI_SME_AUTH_MODE_80211_OPEN\n");
+ priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
+ }
+
+ if (erq->flags & IW_ENCODE_RESTRICTED) {
+ /* Use shared key auth */
+ unifi_trace(priv, UDBG1, "IW_ENCODE_RESTRICTED: CSR_WIFI_SME_AUTH_MODE_80211_SHARED\n");
+ priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_SHARED;
+
+ /* Turn on encryption */
+ privacy = 1;
+ }
+ if (erq->flags & IW_ENCODE_OPEN) {
+ unifi_trace(priv, UDBG1, "IW_ENCODE_OPEN: CSR_WIFI_SME_AUTH_MODE_80211_OPEN\n");
+ priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
+ }
+
+ /* Commit the changes to flags if needed */
+ if (privacy != -1) {
+ priv->connection_config.privacyMode = privacy ? CSR_WIFI_SME_80211_PRIVACY_MODE_ENABLED : CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED;
+ priv->connection_config.encryptionModeMask = privacy ? (CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP40 |
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP104 |
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP40 |
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP104) :
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE;
+ }
+
+ func_exit_r(rc);
+ return convert_sme_error(rc);
+
+} /* unifi_siwencode() */
+
+
+
+static int
+unifi_giwencode(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_point *erq = &wrqu->encoding;
+
+ unifi_trace(priv, UDBG2, "unifi_giwencode\n");
+
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_giwencode: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ if (priv->connection_config.authModeMask == CSR_WIFI_SME_AUTH_MODE_80211_SHARED) {
+ erq->flags = IW_ENCODE_RESTRICTED;
+ }
+ else {
+ if (priv->connection_config.privacyMode == CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED) {
+ erq->flags = IW_ENCODE_DISABLED;
+ } else {
+ erq->flags = IW_ENCODE_OPEN;
+ }
+ }
+
+ erq->length = 0;
+
+ if (erq->flags != IW_ENCODE_DISABLED) {
+ int index = priv->wep_tx_key_index;
+
+ if ((index > 0) && (index <= NUM_WEPKEYS)) {
+ erq->flags |= (index & IW_ENCODE_INDEX);
+ erq->length = priv->wep_keys[index - 1].len;
+ memcpy(extra, priv->wep_keys[index - 1].key, erq->length);
+ } else {
+ unifi_notice(priv, "unifi_giwencode: Surprise, do not have a valid key index (%d)\n",
+ index);
+ }
+ }
+
+ return 0;
+} /* unifi_giwencode() */
+
+
+static int
+unifi_siwpower(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ struct iw_param *args = &wrqu->power;
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int listen_interval, wake_for_dtim;
+ int r = 0;
+ CsrWifiSmePowerConfig powerConfig;
+
+ unifi_trace(priv, UDBG2, "unifi_siwpower\n");
+
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwpower: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_power_config_get(priv, &powerConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_siwpower: Get unifi_PowerConfigValue failed.\n");
+ return r;
+ }
+
+ listen_interval = -1;
+ wake_for_dtim = -1;
+ if (args->disabled) {
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW;
+ }
+ else
+ {
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH;
+
+ switch (args->flags & IW_POWER_TYPE) {
+ case 0:
+ /* not specified */
+ break;
+ case IW_POWER_PERIOD:
+ listen_interval = args->value / 1000;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ switch (args->flags & IW_POWER_MODE) {
+ case 0:
+ /* not specified */
+ break;
+ case IW_POWER_UNICAST_R:
+ /* not interested in broadcast packets */
+ wake_for_dtim = 0;
+ break;
+ case IW_POWER_ALL_R:
+ /* yes, we are interested in broadcast packets */
+ wake_for_dtim = 1;
+ break;
+ default:
+ return -EINVAL;
+ }
+ }
+
+ if (listen_interval > 0) {
+ powerConfig.listenIntervalTu = listen_interval;
+ unifi_trace(priv, UDBG4, "unifi_siwpower: new Listen Interval = %d.\n",
+ powerConfig.listenIntervalTu);
+ }
+
+ if (wake_for_dtim >= 0) {
+ powerConfig.rxDtims = wake_for_dtim;
+ }
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_power_config_set(priv, &powerConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_siwpower: Set unifi_PowerConfigValue failed.\n");
+ return r;
+ }
+
+ return 0;
+} /* unifi_siwpower() */
+
+
+static int
+unifi_giwpower(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ struct iw_param *args = &wrqu->power;
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ CsrWifiSmePowerConfig powerConfig;
+ int r;
+
+ unifi_trace(priv, UDBG2, "unifi_giwpower\n");
+
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_giwpower: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ args->flags = 0;
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_power_config_get(priv, &powerConfig);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "unifi_giwpower: Get unifi_PowerConfigValue failed.\n");
+ return r;
+ }
+
+ unifi_trace(priv, UDBG4, "unifi_giwpower: mode=%d\n",
+ powerConfig.powerSaveLevel);
+
+ args->disabled = (powerConfig.powerSaveLevel == CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW);
+ if (args->disabled) {
+ args->flags = 0;
+ return 0;
+ }
+
+ args->value = powerConfig.listenIntervalTu * 1000;
+ args->flags |= IW_POWER_PERIOD;
+
+ if (powerConfig.rxDtims) {
+ args->flags |= IW_POWER_ALL_R;
+ } else {
+ args->flags |= IW_POWER_UNICAST_R;
+ }
+
+ return 0;
+} /* unifi_giwpower() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_siwcommit - handler for SIOCSIWCOMMIT
+ *
+ * Apply all the parameters that have been set.
+ * In practice this means:
+ * - do a scan
+ * - join a network or start an AdHoc
+ * - authenticate and associate.
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static int
+unifi_siwcommit(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ return 0;
+} /* unifi_siwcommit() */
+
+
+
+static int
+unifi_siwmlme(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_mlme *mlme = (struct iw_mlme *)extra;
+ func_enter();
+
+ unifi_trace(priv, UDBG2, "unifi_siwmlme\n");
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwmlme: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ switch (mlme->cmd) {
+ case IW_MLME_DEAUTH:
+ case IW_MLME_DISASSOC:
+ UF_RTNL_UNLOCK();
+ sme_mgt_disconnect(priv);
+ UF_RTNL_LOCK();
+ break;
+ default:
+ func_exit_r(-EOPNOTSUPP);
+ return -EOPNOTSUPP;
+ }
+
+ func_exit();
+ return 0;
+} /* unifi_siwmlme() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_siwgenie
+ * unifi_giwgenie
+ *
+ * WPA : Generic IEEE 802.11 information element (e.g., for WPA/RSN/WMM).
+ * Handlers for SIOCSIWGENIE, SIOCGIWGENIE - set/get generic IE
+ *
+ * The host program (e.g. wpa_supplicant) uses this call to set the
+ * additional IEs to accompany the next (Associate?) request.
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ * Notes:
+ * From wireless.h:
+ * This ioctl uses struct iw_point and data buffer that includes IE id
+ * and len fields. More than one IE may be included in the
+ * request. Setting the generic IE to empty buffer (len=0) removes the
+ * generic IE from the driver.
+ * ---------------------------------------------------------------------------
+ */
+static int
+unifi_siwgenie(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int len;
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "unifi_siwgenie\n");
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwgenie: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ if ( priv->connection_config.mlmeAssociateReqInformationElements) {
+ kfree( priv->connection_config.mlmeAssociateReqInformationElements);
+ }
+ priv->connection_config.mlmeAssociateReqInformationElementsLength = 0;
+ priv->connection_config.mlmeAssociateReqInformationElements = NULL;
+
+ len = wrqu->data.length;
+ if (len == 0) {
+ func_exit();
+ return 0;
+ }
+
+ priv->connection_config.mlmeAssociateReqInformationElements = kmalloc(len, GFP_KERNEL);
+ if (priv->connection_config.mlmeAssociateReqInformationElements == NULL) {
+ func_exit();
+ return -ENOMEM;
+ }
+
+ priv->connection_config.mlmeAssociateReqInformationElementsLength = len;
+ memcpy( priv->connection_config.mlmeAssociateReqInformationElements, extra, len);
+
+ func_exit();
+ return 0;
+} /* unifi_siwgenie() */
+
+
+static int
+unifi_giwgenie(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ int len;
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "unifi_giwgenie\n");
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_giwgenie: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ len = priv->connection_config.mlmeAssociateReqInformationElementsLength;
+
+ if (len == 0) {
+ wrqu->data.length = 0;
+ return 0;
+ }
+
+ if (wrqu->data.length < len) {
+ return -E2BIG;
+ }
+
+ wrqu->data.length = len;
+ memcpy(extra, priv->connection_config.mlmeAssociateReqInformationElements, len);
+
+ func_exit();
+ return 0;
+} /* unifi_giwgenie() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_siwauth
+ * unifi_giwauth
+ *
+ * Handlers for SIOCSIWAUTH, SIOCGIWAUTH
+ * Set/get various authentication parameters.
+ *
+ * Arguments:
+ *
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static int
+_unifi_siwauth(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ CsrWifiSmeAuthModeMask new_auth;
+
+ func_enter();
+ unifi_trace(priv, UDBG2, "unifi_siwauth\n");
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwauth: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ /*
+ * This ioctl is safe to call even when UniFi is powered off.
+ * wpa_supplicant calls it to test whether we support WPA.
+ */
+
+ switch (wrqu->param.flags & IW_AUTH_INDEX) {
+
+ case IW_AUTH_WPA_ENABLED:
+ unifi_trace(priv, UDBG1, "IW_AUTH_WPA_ENABLED: %d\n", wrqu->param.value);
+
+ if (wrqu->param.value == 0) {
+ unifi_trace(priv, UDBG5, "IW_AUTH_WPA_ENABLED: CSR_WIFI_SME_AUTH_MODE_80211_OPEN\n");
+ priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
+ }
+ break;
+
+ case IW_AUTH_PRIVACY_INVOKED:
+ unifi_trace(priv, UDBG1, "IW_AUTH_PRIVACY_INVOKED: %d\n", wrqu->param.value);
+
+ priv->connection_config.privacyMode = wrqu->param.value ? CSR_WIFI_SME_80211_PRIVACY_MODE_ENABLED : CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED;
+ if (wrqu->param.value == CSR_WIFI_SME_80211_PRIVACY_MODE_DISABLED)
+ {
+ priv->connection_config.encryptionModeMask = CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE;
+ }
+ break;
+
+ case IW_AUTH_80211_AUTH_ALG:
+ /*
+ IW_AUTH_ALG_OPEN_SYSTEM 0x00000001
+ IW_AUTH_ALG_SHARED_KEY 0x00000002
+ IW_AUTH_ALG_LEAP 0x00000004
+ */
+ new_auth = 0;
+ if (wrqu->param.value & IW_AUTH_ALG_OPEN_SYSTEM) {
+ unifi_trace(priv, UDBG1, "IW_AUTH_80211_AUTH_ALG: %d (IW_AUTH_ALG_OPEN_SYSTEM)\n", wrqu->param.value);
+ new_auth |= CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
+ }
+ if (wrqu->param.value & IW_AUTH_ALG_SHARED_KEY) {
+ unifi_trace(priv, UDBG1, "IW_AUTH_80211_AUTH_ALG: %d (IW_AUTH_ALG_SHARED_KEY)\n", wrqu->param.value);
+ new_auth |= CSR_WIFI_SME_AUTH_MODE_80211_SHARED;
+ }
+ if (wrqu->param.value & IW_AUTH_ALG_LEAP) {
+ /* Initial exchanges using open-system to set EAP */
+ unifi_trace(priv, UDBG1, "IW_AUTH_80211_AUTH_ALG: %d (IW_AUTH_ALG_LEAP)\n", wrqu->param.value);
+ new_auth |= CSR_WIFI_SME_AUTH_MODE_8021X_OTHER1X;
+ }
+ if (new_auth == 0) {
+ unifi_trace(priv, UDBG1, "IW_AUTH_80211_AUTH_ALG: invalid value %d\n",
+ wrqu->param.value);
+ return -EINVAL;
+ } else {
+ priv->connection_config.authModeMask = new_auth;
+ }
+ break;
+
+ case IW_AUTH_WPA_VERSION:
+ unifi_trace(priv, UDBG1, "IW_AUTH_WPA_VERSION: %d\n", wrqu->param.value);
+ priv->ignore_bssid_join = TRUE;
+ /*
+ IW_AUTH_WPA_VERSION_DISABLED 0x00000001
+ IW_AUTH_WPA_VERSION_WPA 0x00000002
+ IW_AUTH_WPA_VERSION_WPA2 0x00000004
+ */
+
+ if (!(wrqu->param.value & IW_AUTH_WPA_VERSION_DISABLED)) {
+
+ priv->connection_config.authModeMask = CSR_WIFI_SME_AUTH_MODE_80211_OPEN;
+
+ if (wrqu->param.value & IW_AUTH_WPA_VERSION_WPA) {
+ unifi_trace(priv, UDBG4, "IW_AUTH_WPA_VERSION: WPA, WPA-PSK\n");
+ priv->connection_config.authModeMask |= (CSR_WIFI_SME_AUTH_MODE_8021X_WPA | CSR_WIFI_SME_AUTH_MODE_8021X_WPAPSK);
+ }
+ if (wrqu->param.value & IW_AUTH_WPA_VERSION_WPA2) {
+ unifi_trace(priv, UDBG4, "IW_AUTH_WPA_VERSION: WPA2, WPA2-PSK\n");
+ priv->connection_config.authModeMask |= (CSR_WIFI_SME_AUTH_MODE_8021X_WPA2 | CSR_WIFI_SME_AUTH_MODE_8021X_WPA2PSK);
+ }
+ }
+ break;
+
+ case IW_AUTH_CIPHER_PAIRWISE:
+ unifi_trace(priv, UDBG1, "IW_AUTH_CIPHER_PAIRWISE: %d\n", wrqu->param.value);
+ /*
+ * one of:
+ IW_AUTH_CIPHER_NONE 0x00000001
+ IW_AUTH_CIPHER_WEP40 0x00000002
+ IW_AUTH_CIPHER_TKIP 0x00000004
+ IW_AUTH_CIPHER_CCMP 0x00000008
+ IW_AUTH_CIPHER_WEP104 0x00000010
+ */
+
+ priv->connection_config.encryptionModeMask = CSR_WIFI_SME_ENCRYPTION_CIPHER_NONE;
+
+ if (wrqu->param.value & IW_AUTH_CIPHER_WEP40) {
+ priv->connection_config.encryptionModeMask |=
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP40 | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP40;
+ }
+ if (wrqu->param.value & IW_AUTH_CIPHER_WEP104) {
+ priv->connection_config.encryptionModeMask |=
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_WEP104 | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP104;
+ }
+ if (wrqu->param.value & IW_AUTH_CIPHER_TKIP) {
+ priv->connection_config.encryptionModeMask |=
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_TKIP | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_TKIP;
+ }
+ if (wrqu->param.value & IW_AUTH_CIPHER_CCMP) {
+ priv->connection_config.encryptionModeMask |=
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_PAIRWISE_CCMP | CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_CCMP;
+ }
+
+ break;
+
+ case IW_AUTH_CIPHER_GROUP:
+ unifi_trace(priv, UDBG1, "IW_AUTH_CIPHER_GROUP: %d\n", wrqu->param.value);
+ /*
+ * Use the WPA version and the group cipher suite to set the permitted
+ * group key in the MIB. f/w uses this value to validate WPA and RSN IEs
+ * in the probe responses from the desired BSS(ID)
+ */
+
+ priv->connection_config.encryptionModeMask &= ~(CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP40 |
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP104 |
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_TKIP |
+ CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_CCMP);
+ if (wrqu->param.value & IW_AUTH_CIPHER_WEP40) {
+ priv->connection_config.encryptionModeMask |= CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP40;
+ }
+ if (wrqu->param.value & IW_AUTH_CIPHER_WEP104) {
+ priv->connection_config.encryptionModeMask |= CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_WEP104;
+ }
+ if (wrqu->param.value & IW_AUTH_CIPHER_TKIP) {
+ priv->connection_config.encryptionModeMask |= CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_TKIP;
+ }
+ if (wrqu->param.value & IW_AUTH_CIPHER_CCMP) {
+ priv->connection_config.encryptionModeMask |= CSR_WIFI_SME_ENCRYPTION_CIPHER_GROUP_CCMP;
+ }
+
+ break;
+
+ case IW_AUTH_KEY_MGMT:
+ unifi_trace(priv, UDBG1, "IW_AUTH_KEY_MGMT: %d\n", wrqu->param.value);
+ /*
+ IW_AUTH_KEY_MGMT_802_1X 1
+ IW_AUTH_KEY_MGMT_PSK 2
+ */
+ if (priv->connection_config.authModeMask & (CSR_WIFI_SME_AUTH_MODE_8021X_WPA | CSR_WIFI_SME_AUTH_MODE_8021X_WPAPSK)) {
+ /* Check for explicitly set mode. */
+ if (wrqu->param.value == IW_AUTH_KEY_MGMT_802_1X) {
+ priv->connection_config.authModeMask &= ~CSR_WIFI_SME_AUTH_MODE_8021X_WPAPSK;
+ }
+ if (wrqu->param.value == IW_AUTH_KEY_MGMT_PSK) {
+ priv->connection_config.authModeMask &= ~CSR_WIFI_SME_AUTH_MODE_8021X_WPA;
+ }
+ unifi_trace(priv, UDBG5, "IW_AUTH_KEY_MGMT: WPA: %d\n",
+ priv->connection_config.authModeMask);
+ }
+ if (priv->connection_config.authModeMask & (CSR_WIFI_SME_AUTH_MODE_8021X_WPA2 | CSR_WIFI_SME_AUTH_MODE_8021X_WPA2PSK)) {
+ /* Check for explicitly set mode. */
+ if (wrqu->param.value == IW_AUTH_KEY_MGMT_802_1X) {
+ priv->connection_config.authModeMask &= ~CSR_WIFI_SME_AUTH_MODE_8021X_WPA2PSK;
+ }
+ if (wrqu->param.value == IW_AUTH_KEY_MGMT_PSK) {
+ priv->connection_config.authModeMask &= ~CSR_WIFI_SME_AUTH_MODE_8021X_WPA2;
+ }
+ unifi_trace(priv, UDBG5, "IW_AUTH_KEY_MGMT: WPA2: %d\n",
+ priv->connection_config.authModeMask);
+ }
+
+ break;
+ case IW_AUTH_TKIP_COUNTERMEASURES:
+ /*
+ * Set to true at the start of the 60 second backup-off period
+ * following 2 MichaelMIC failures within 60s.
+ */
+ unifi_trace(priv, UDBG1, "IW_AUTH_TKIP_COUNTERMEASURES: %d\n", wrqu->param.value);
+ break;
+
+ case IW_AUTH_DROP_UNENCRYPTED:
+ /*
+ * Set to true on init.
+ * Set to false just before associate if encryption will not be
+ * required.
+ *
+ * Note this is not the same as the 802.1X controlled port
+ */
+ unifi_trace(priv, UDBG1, "IW_AUTH_DROP_UNENCRYPTED: %d\n", wrqu->param.value);
+ break;
+
+ case IW_AUTH_RX_UNENCRYPTED_EAPOL:
+ /*
+ * This is set by wpa_supplicant to allow unencrypted EAPOL messages
+ * even if pairwise keys are set when not using WPA. IEEE 802.1X
+ * specifies that these frames are not encrypted, but WPA encrypts
+ * them when pairwise keys are in use.
+ * I think the UniFi f/w handles this decision for us.
+ */
+ unifi_trace(priv, UDBG1, "IW_AUTH_RX_UNENCRYPTED_EAPOL: %d\n", wrqu->param.value);
+ break;
+
+ case IW_AUTH_ROAMING_CONTROL:
+ unifi_trace(priv, UDBG1, "IW_AUTH_ROAMING_CONTROL: %d\n", wrqu->param.value);
+ break;
+
+ default:
+ unifi_trace(priv, UDBG1, "Unsupported auth param %d to 0x%X\n",
+ wrqu->param.flags & IW_AUTH_INDEX,
+ wrqu->param.value);
+ return -EOPNOTSUPP;
+ }
+
+ unifi_trace(priv, UDBG2, "authModeMask = %d", priv->connection_config.authModeMask);
+ func_exit();
+
+ return 0;
+} /* _unifi_siwauth() */
+
+
+static int
+unifi_siwauth(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ int err = 0;
+
+ UF_RTNL_UNLOCK();
+ err = _unifi_siwauth(dev, info, wrqu, extra);
+ UF_RTNL_LOCK();
+
+ return err;
+} /* unifi_siwauth() */
+
+
+static int
+unifi_giwauth(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ unifi_trace(NULL, UDBG2, "unifi_giwauth\n");
+ return -EOPNOTSUPP;
+} /* unifi_giwauth() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_siwencodeext
+ * unifi_giwencodeext
+ *
+ * Handlers for SIOCSIWENCODEEXT, SIOCGIWENCODEEXT - set/get
+ * encoding token & mode
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * For WPA/WPA2 we don't take note of the IW_ENCODE_EXT_SET_TX_KEY flag.
+ * This flag means "use this key to encode transmissions"; we just
+ * assume only one key will be set and that is the one to use.
+ * ---------------------------------------------------------------------------
+ */
+static int
+_unifi_siwencodeext(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
+ int r = 0;
+ unsigned char *keydata;
+ unsigned char tkip_key[32];
+ int keyid;
+ unsigned char *a = (unsigned char *)ext->addr.sa_data;
+ CsrWifiSmeKey sme_key;
+ CsrWifiSmeKeyType key_type;
+
+ func_enter();
+
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwencodeext: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ unifi_trace(priv, UDBG1, "siwencodeext: flags=0x%X, alg=%d, ext_flags=0x%X, len=%d, index=%d,\n",
+ wrqu->encoding.flags, ext->alg, ext->ext_flags,
+ ext->key_len, (wrqu->encoding.flags & IW_ENCODE_INDEX));
+ unifi_trace(priv, UDBG3, " addr=%02X:%02X:%02X:%02X:%02X:%02X\n",
+ a[0], a[1], a[2], a[3], a[4], a[5]);
+
+ if ((ext->key_len == 0) && (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)) {
+ /* This means use a different key (given by key_idx) for Tx. */
+ /* NYI */
+ unifi_trace(priv, UDBG1, KERN_ERR "unifi_siwencodeext: NYI should change tx key id here!!\n");
+ return -ENOTSUPP;
+ }
+
+ memset(&sme_key, 0, sizeof(sme_key));
+
+ keydata = (unsigned char *)(ext + 1);
+ keyid = (wrqu->encoding.flags & IW_ENCODE_INDEX);
+
+ /*
+ * Check for request to delete keys for an address.
+ */
+ /* Pick out request for no privacy. */
+ if (ext->alg == IW_ENCODE_ALG_NONE) {
+
+ unifi_trace(priv, UDBG1, "Deleting %s key %d\n",
+ (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) ? "GROUP" : "PAIRWISE",
+ keyid);
+
+ if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
+ sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_GROUP;
+ } else {
+ sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
+ }
+ sme_key.keyIndex = (keyid - 1);
+ sme_key.keyLength = 0;
+ sme_key.authenticator = 0;
+ memcpy(sme_key.address.a, a, ETH_ALEN);
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_key(priv, &sme_key, CSR_WIFI_SME_LIST_ACTION_REMOVE);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "Delete key request was rejected with result %d\n", r);
+ return convert_sme_error(r);
+ }
+
+ return 0;
+ }
+
+ /*
+ * Request is to set a key, not delete
+ */
+
+ /* Pick out WEP and use set_wep_key(). */
+ if (ext->alg == IW_ENCODE_ALG_WEP) {
+ /* WEP-40, WEP-104 */
+
+ /* Check for valid key length */
+ if (!((ext->key_len == 5) || (ext->key_len == 13))) {
+ unifi_trace(priv, UDBG1, KERN_ERR "Invalid length for WEP key: %d\n", ext->key_len);
+ return -EINVAL;
+ }
+
+ unifi_trace(priv, UDBG1, "Setting WEP key %d tx:%d\n",
+ keyid, ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY);
+
+ if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
+ sme_key.wepTxKey = TRUE;
+ sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_PAIRWISE;
+ } else {
+ sme_key.wepTxKey = FALSE;
+ sme_key.keyType = CSR_WIFI_SME_KEY_TYPE_GROUP;
+ }
+ sme_key.keyIndex = (keyid - 1);
+ sme_key.keyLength = ext->key_len;
+ sme_key.authenticator = 0;
+ memset(sme_key.address.a, 0xFF, ETH_ALEN);
+ memcpy(sme_key.key, keydata, ext->key_len);
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_key(priv, &sme_key, CSR_WIFI_SME_LIST_ACTION_ADD);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "siwencodeext: Set key failed (%d)", r);
+ return convert_sme_error(r);
+ }
+
+ return 0;
+ }
+
+ /*
+ *
+ * If we reach here, we are dealing with a WPA/WPA2 key
+ *
+ */
+ if (ext->key_len > 32) {
+ return -EINVAL;
+ }
+
+ /*
+ * TKIP keys from wpa_supplicant need swapping.
+ * What about other supplicants (when they come along)?
+ */
+ if ((ext->alg == IW_ENCODE_ALG_TKIP) && (ext->key_len == 32)) {
+ memcpy(tkip_key, keydata, 16);
+ memcpy(tkip_key + 16, keydata + 24, 8);
+ memcpy(tkip_key + 24, keydata + 16, 8);
+ keydata = tkip_key;
+ }
+
+ key_type = (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) ?
+ CSR_WIFI_SME_KEY_TYPE_GROUP : /* Group Key */
+ CSR_WIFI_SME_KEY_TYPE_PAIRWISE; /* Pairwise Key */
+
+ sme_key.keyType = key_type;
+ sme_key.keyIndex = (keyid - 1);
+ sme_key.keyLength = ext->key_len;
+ sme_key.authenticator = 0;
+ memcpy(sme_key.address.a, ext->addr.sa_data, ETH_ALEN);
+ if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
+
+ unifi_trace(priv, UDBG5, "RSC first 6 bytes = %02X:%02X:%02X:%02X:%02X:%02X\n",
+ ext->rx_seq[0], ext->rx_seq[1], ext->rx_seq[2], ext->rx_seq[3], ext->rx_seq[4], ext->rx_seq[5]);
+
+ /* memcpy((u8*)(&sme_key.keyRsc), ext->rx_seq, 8); */
+ sme_key.keyRsc[0] = ext->rx_seq[1] << 8 | ext->rx_seq[0];
+ sme_key.keyRsc[1] = ext->rx_seq[3] << 8 | ext->rx_seq[2];
+ sme_key.keyRsc[2] = ext->rx_seq[5] << 8 | ext->rx_seq[4];
+ sme_key.keyRsc[3] = ext->rx_seq[7] << 8 | ext->rx_seq[6];
+
+ }
+
+ memcpy(sme_key.key, keydata, ext->key_len);
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_key(priv, &sme_key, CSR_WIFI_SME_LIST_ACTION_ADD);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "SETKEYS request was rejected with result %d\n", r);
+ return convert_sme_error(r);
+ }
+
+ func_exit();
+ return r;
+} /* _unifi_siwencodeext() */
+
+
+static int
+unifi_siwencodeext(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ int err = 0;
+
+ err = _unifi_siwencodeext(dev, info, wrqu, extra);
+
+ return err;
+} /* unifi_siwencodeext() */
+
+
+static int
+unifi_giwencodeext(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ return -EOPNOTSUPP;
+} /* unifi_giwencodeext() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_siwpmksa
+ *
+ * SIOCSIWPMKSA - PMKSA cache operation
+ * The caller passes a pmksa structure:
+ * - cmd one of ADD, REMOVE, FLUSH
+ * - bssid MAC address
+ * - pmkid ID string (16 bytes)
+ *
+ * Arguments:
+ * None.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * This is not needed since we provide a siwgenie method.
+ * ---------------------------------------------------------------------------
+ */
+#define UNIFI_PMKID_KEY_SIZE 16
+static int
+unifi_siwpmksa(struct net_device *dev, struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+ struct iw_pmksa *pmksa = (struct iw_pmksa *)extra;
+ CsrResult r = 0;
+ CsrWifiSmePmkidList pmkid_list;
+ CsrWifiSmePmkid pmkid;
+ CsrWifiSmeListAction action;
+
+ CHECK_INITED(priv);
+
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+ unifi_error(priv, "unifi_siwpmksa: not permitted in Mode %d\n",
+ interfacePriv->interfaceMode);
+ return -EPERM;
+ }
+
+
+ unifi_trace(priv, UDBG1, "SIWPMKSA: cmd %d, %02x:%02x:%02x:%02x:%02x:%02x\n",
+ pmksa->cmd,
+ pmksa->bssid.sa_data[0],
+ pmksa->bssid.sa_data[1],
+ pmksa->bssid.sa_data[2],
+ pmksa->bssid.sa_data[3],
+ pmksa->bssid.sa_data[4],
+ pmksa->bssid.sa_data[5]);
+
+ pmkid_list.pmkids = NULL;
+ switch (pmksa->cmd) {
+ case IW_PMKSA_ADD:
+ pmkid_list.pmkids = &pmkid;
+ action = CSR_WIFI_SME_LIST_ACTION_ADD;
+ pmkid_list.pmkidsCount = 1;
+ memcpy(pmkid.bssid.a, pmksa->bssid.sa_data, ETH_ALEN);
+ memcpy(pmkid.pmkid, pmksa->pmkid, UNIFI_PMKID_KEY_SIZE);
+ break;
+ case IW_PMKSA_REMOVE:
+ pmkid_list.pmkids = &pmkid;
+ action = CSR_WIFI_SME_LIST_ACTION_REMOVE;
+ pmkid_list.pmkidsCount = 1;
+ memcpy(pmkid.bssid.a, pmksa->bssid.sa_data, ETH_ALEN);
+ memcpy(pmkid.pmkid, pmksa->pmkid, UNIFI_PMKID_KEY_SIZE);
+ break;
+ case IW_PMKSA_FLUSH:
+ /* Replace current PMKID's with an empty list */
+ pmkid_list.pmkidsCount = 0;
+ action = CSR_WIFI_SME_LIST_ACTION_FLUSH;
+ break;
+ default:
+ unifi_notice(priv, "SIWPMKSA: Unknown command (0x%x)\n", pmksa->cmd);
+ return -EINVAL;
+ }
+
+ /* Set the Value the pmkid's will have 1 added OR 1 removed OR be cleared at this point */
+ UF_RTNL_UNLOCK();
+ r = sme_mgt_pmkid(priv, action, &pmkid_list);
+ UF_RTNL_LOCK();
+ if (r) {
+ unifi_error(priv, "SIWPMKSA: Set PMKID's Failed.\n");
+ }
+
+ return r;
+
+} /* unifi_siwpmksa() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_get_wireless_stats
+ *
+ * get_wireless_stats method for Linux wireless extensions.
+ *
+ * Arguments:
+ * dev Pointer to associated netdevice.
+ *
+ * Returns:
+ * Pointer to iw_statistics struct.
+ * ---------------------------------------------------------------------------
+ */
+struct iw_statistics *
+unifi_get_wireless_stats(struct net_device *dev)
+{
+ netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
+ unifi_priv_t *priv = interfacePriv->privPtr;
+
+ if (priv->init_progress != UNIFI_INIT_COMPLETED) {
+ return NULL;
+ }
+
+ return &priv->wext_wireless_stats;
+} /* unifi_get_wireless_stats() */
+
+
+/*
+ * Structures to export the Wireless Handlers
+ */
+
+static const struct iw_priv_args unifi_private_args[] = {
+ /*{ cmd, set_args, get_args, name } */
+ { SIOCIWS80211POWERSAVEPRIV, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
+ IW_PRIV_TYPE_NONE, "iwprivs80211ps" },
+ { SIOCIWG80211POWERSAVEPRIV, IW_PRIV_TYPE_NONE,
+ IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IWPRIV_POWER_SAVE_MAX_STRING, "iwprivg80211ps" },
+ { SIOCIWS80211RELOADDEFAULTSPRIV, IW_PRIV_TYPE_NONE,
+ IW_PRIV_TYPE_NONE, "iwprivsdefs" },
+ { SIOCIWSSMEDEBUGPRIV, IW_PRIV_TYPE_CHAR | IWPRIV_SME_DEBUG_MAX_STRING, IW_PRIV_TYPE_NONE, "iwprivssmedebug" },
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ { SIOCIWSCONFWAPIPRIV, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
+ IW_PRIV_TYPE_NONE, "iwprivsconfwapi" },
+ { SIOCIWSWAPIKEYPRIV, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof(unifiio_wapi_key_t),
+ IW_PRIV_TYPE_NONE, "iwprivswpikey" },
+#endif
+#ifdef CSR_SUPPORT_WEXT_AP
+ { SIOCIWSAPCFGPRIV, IW_PRIV_TYPE_CHAR | 256, IW_PRIV_TYPE_NONE, "AP_SET_CFG" },
+ { SIOCIWSAPSTARTPRIV, 0,IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED|IWPRIV_SME_MAX_STRING,"AP_BSS_START" },
+ { SIOCIWSAPSTOPPRIV, IW_PRIV_TYPE_CHAR |IW_PRIV_SIZE_FIXED|0,
+ IW_PRIV_TYPE_CHAR |IW_PRIV_SIZE_FIXED|0, "AP_BSS_STOP" },
+#ifdef ANDROID_BUILD
+ { SIOCIWSFWRELOADPRIV, IW_PRIV_TYPE_CHAR |256,
+ IW_PRIV_TYPE_CHAR |IW_PRIV_SIZE_FIXED|0, "WL_FW_RELOAD" },
+ { SIOCIWSSTACKSTART, 0,
+ IW_PRIV_TYPE_CHAR |IW_PRIV_SIZE_FIXED|IWPRIV_SME_MAX_STRING, "START" },
+ { SIOCIWSSTACKSTOP, 0,
+ IW_PRIV_TYPE_CHAR |IW_PRIV_SIZE_FIXED|IWPRIV_SME_MAX_STRING, "STOP" },
+#endif /* ANDROID_BUILD */
+#endif /* CSR_SUPPORT_WEXT_AP */
+};
+
+static const iw_handler unifi_handler[] =
+{
+ (iw_handler) unifi_siwcommit, /* SIOCSIWCOMMIT */
+ (iw_handler) unifi_giwname, /* SIOCGIWNAME */
+ (iw_handler) NULL, /* SIOCSIWNWID */
+ (iw_handler) NULL, /* SIOCGIWNWID */
+ (iw_handler) unifi_siwfreq, /* SIOCSIWFREQ */
+ (iw_handler) unifi_giwfreq, /* SIOCGIWFREQ */
+ (iw_handler) unifi_siwmode, /* SIOCSIWMODE */
+ (iw_handler) unifi_giwmode, /* SIOCGIWMODE */
+ (iw_handler) NULL, /* SIOCSIWSENS */
+ (iw_handler) NULL, /* SIOCGIWSENS */
+ (iw_handler) NULL, /* SIOCSIWRANGE */
+ (iw_handler) unifi_giwrange, /* SIOCGIWRANGE */
+ (iw_handler) NULL, /* SIOCSIWPRIV */
+ (iw_handler) NULL, /* SIOCGIWPRIV */
+ (iw_handler) NULL, /* SIOCSIWSTATS */
+ (iw_handler) NULL, /* SIOCGIWSTATS */
+ (iw_handler) NULL, /* SIOCSIWSPY */
+ (iw_handler) NULL, /* SIOCGIWSPY */
+ (iw_handler) NULL, /* SIOCSIWTHRSPY */
+ (iw_handler) NULL, /* SIOCGIWTHRSPY */
+ (iw_handler) unifi_siwap, /* SIOCSIWAP */
+ (iw_handler) unifi_giwap, /* SIOCGIWAP */
+#if WIRELESS_EXT > 17
+ /* WPA : IEEE 802.11 MLME requests */
+ unifi_siwmlme, /* SIOCSIWMLME, request MLME operation */
+#else
+ (iw_handler) NULL, /* -- hole -- */
+#endif
+ (iw_handler) NULL, /* SIOCGIWAPLIST */
+ (iw_handler) unifi_siwscan, /* SIOCSIWSCAN */
+ (iw_handler) unifi_giwscan, /* SIOCGIWSCAN */
+ (iw_handler) unifi_siwessid, /* SIOCSIWESSID */
+ (iw_handler) unifi_giwessid, /* SIOCGIWESSID */
+ (iw_handler) NULL, /* SIOCSIWNICKN */
+ (iw_handler) NULL, /* SIOCGIWNICKN */
+ (iw_handler) NULL, /* -- hole -- */
+ (iw_handler) NULL, /* -- hole -- */
+ unifi_siwrate, /* SIOCSIWRATE */
+ unifi_giwrate, /* SIOCGIWRATE */
+ unifi_siwrts, /* SIOCSIWRTS */
+ unifi_giwrts, /* SIOCGIWRTS */
+ unifi_siwfrag, /* SIOCSIWFRAG */
+ unifi_giwfrag, /* SIOCGIWFRAG */
+ (iw_handler) NULL, /* SIOCSIWTXPOW */
+ (iw_handler) NULL, /* SIOCGIWTXPOW */
+ (iw_handler) NULL, /* SIOCSIWRETRY */
+ (iw_handler) NULL, /* SIOCGIWRETRY */
+ unifi_siwencode, /* SIOCSIWENCODE */
+ unifi_giwencode, /* SIOCGIWENCODE */
+ unifi_siwpower, /* SIOCSIWPOWER */
+ unifi_giwpower, /* SIOCGIWPOWER */
+#if WIRELESS_EXT > 17
+ (iw_handler) NULL, /* -- hole -- */
+ (iw_handler) NULL, /* -- hole -- */
+
+ /* WPA : Generic IEEE 802.11 informatiom element (e.g., for WPA/RSN/WMM). */
+ unifi_siwgenie, /* SIOCSIWGENIE */ /* set generic IE */
+ unifi_giwgenie, /* SIOCGIWGENIE */ /* get generic IE */
+
+ /* WPA : Authentication mode parameters */
+ unifi_siwauth, /* SIOCSIWAUTH */ /* set authentication mode params */
+ unifi_giwauth, /* SIOCGIWAUTH */ /* get authentication mode params */
+
+ /* WPA : Extended version of encoding configuration */
+ unifi_siwencodeext, /* SIOCSIWENCODEEXT */ /* set encoding token & mode */
+ unifi_giwencodeext, /* SIOCGIWENCODEEXT */ /* get encoding token & mode */
+
+ /* WPA2 : PMKSA cache management */
+ unifi_siwpmksa, /* SIOCSIWPMKSA */ /* PMKSA cache operation */
+ (iw_handler) NULL, /* -- hole -- */
+#endif /* WIRELESS_EXT > 17 */
+};
+
+
+static const iw_handler unifi_private_handler[] =
+{
+ iwprivs80211ps, /* SIOCIWFIRSTPRIV */
+ iwprivg80211ps, /* SIOCIWFIRSTPRIV + 1 */
+ iwprivsdefs, /* SIOCIWFIRSTPRIV + 2 */
+ (iw_handler) NULL,
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ iwprivsconfwapi, /* SIOCIWFIRSTPRIV + 4 */
+ (iw_handler) NULL, /* SIOCIWFIRSTPRIV + 5 */
+ iwprivswpikey, /* SIOCIWFIRSTPRIV + 6 */
+#else
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+#endif
+ (iw_handler) NULL,
+ iwprivssmedebug, /* SIOCIWFIRSTPRIV + 8 */
+#ifdef CSR_SUPPORT_WEXT_AP
+ (iw_handler) NULL,
+ iwprivsapconfig,
+ (iw_handler) NULL,
+ iwprivsapstart,
+ (iw_handler) NULL,
+ iwprivsapstop,
+ (iw_handler) NULL,
+#ifdef ANDROID_BUILD
+ iwprivsapfwreload,
+ (iw_handler) NULL,
+ iwprivsstackstart,
+ (iw_handler) NULL,
+ iwprivsstackstop,
+#else
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+#endif /* ANDROID_BUILD */
+#else
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+ (iw_handler) NULL,
+#endif /* CSR_SUPPORT_WEXT_AP */
+};
+
+struct iw_handler_def unifi_iw_handler_def =
+{
+ .num_standard = sizeof(unifi_handler) / sizeof(iw_handler),
+ .num_private = sizeof(unifi_private_handler) / sizeof(iw_handler),
+ .num_private_args = sizeof(unifi_private_args) / sizeof(struct iw_priv_args),
+ .standard = (iw_handler *) unifi_handler,
+ .private = (iw_handler *) unifi_private_handler,
+ .private_args = (struct iw_priv_args *) unifi_private_args,
+#if IW_HANDLER_VERSION >= 6
+ .get_wireless_stats = unifi_get_wireless_stats,
+#endif
+};
+
+
--- /dev/null
+/*
+ * ***************************************************************************
+ * FILE: ul_int.c
+ *
+ * PURPOSE:
+ * Manage list of client applications using UniFi.
+ *
+ * Copyright (C) 2006-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ***************************************************************************
+ */
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_conversions.h"
+#include "unifi_priv.h"
+#include "unifiio.h"
+#include "unifi_os.h"
+
+static void free_bulkdata_buffers(unifi_priv_t *priv, bulk_data_param_t *bulkdata);
+static void reset_driver_status(unifi_priv_t *priv);
+
+/*
+ * ---------------------------------------------------------------------------
+ * ul_init_clients
+ *
+ * Initialise the clients array to empty.
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * This function needs to be called before priv is stored in
+ * Unifi_instances[].
+ * ---------------------------------------------------------------------------
+ */
+void
+ul_init_clients(unifi_priv_t *priv)
+{
+ int id;
+ ul_client_t *ul_clients;
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 37)
+ sema_init(&priv->udi_logging_mutex, 1);
+#else
+ init_MUTEX(&priv->udi_logging_mutex);
+#endif
+ priv->logging_client = NULL;
+
+ ul_clients = priv->ul_clients;
+
+ for (id = 0; id < MAX_UDI_CLIENTS; id++) {
+ memset(&ul_clients[id], 0, sizeof(ul_client_t));
+
+ ul_clients[id].client_id = id;
+ ul_clients[id].sender_id = UDI_SENDER_ID_BASE + (id << UDI_SENDER_ID_SHIFT);
+ ul_clients[id].instance = -1;
+ ul_clients[id].event_hook = NULL;
+
+ INIT_LIST_HEAD(&ul_clients[id].udi_log);
+ init_waitqueue_head(&ul_clients[id].udi_wq);
+ sema_init(&ul_clients[id].udi_sem, 1);
+
+ ul_clients[id].wake_up_wq_id = 0;
+ ul_clients[id].seq_no = 0;
+ ul_clients[id].wake_seq_no = 0;
+ ul_clients[id].snap_filter.count = 0;
+ }
+} /* ul_init_clients() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * ul_register_client
+ *
+ * This function registers a new ul client.
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * configuration Special configuration for the client.
+ * udi_event_clbk Callback for receiving event from unifi.
+ *
+ * Returns:
+ * 0 if a new clients is registered, -1 otherwise.
+ * ---------------------------------------------------------------------------
+ */
+ul_client_t *
+ul_register_client(unifi_priv_t *priv, unsigned int configuration,
+ udi_event_t udi_event_clbk)
+{
+ unsigned char id, ref;
+ ul_client_t *ul_clients;
+
+ ul_clients = priv->ul_clients;
+
+ /* check for an unused entry */
+ for (id = 0; id < MAX_UDI_CLIENTS; id++) {
+ if (ul_clients[id].udi_enabled == 0) {
+ ul_clients[id].instance = priv->instance;
+ ul_clients[id].udi_enabled = 1;
+ ul_clients[id].configuration = configuration;
+
+ /* Allocate memory for the reply signal.. */
+ ul_clients[id].reply_signal = (CSR_SIGNAL*) CsrPmemAlloc(sizeof(CSR_SIGNAL));
+ if (ul_clients[id].reply_signal == NULL) {
+ unifi_error(priv, "Failed to allocate reply signal for client.\n");
+ return NULL;
+ }
+ /* .. and the bulk data of the reply signal. */
+ for (ref = 0; ref < UNIFI_MAX_DATA_REFERENCES; ref ++) {
+ ul_clients[id].reply_bulkdata[ref] =
+ (bulk_data_t*) CsrPmemAlloc(sizeof(bulk_data_t));
+ /* If allocation fails, free allocated memory. */
+ if (ul_clients[id].reply_bulkdata[ref] == NULL) {
+ for (; ref > 0; ref --) {
+ CsrPmemFree(ul_clients[id].reply_bulkdata[ref - 1]);
+ }
+ CsrPmemFree(ul_clients[id].reply_signal);
+ unifi_error(priv, "Failed to allocate bulk data buffers for client.\n");
+ return NULL;
+ }
+ }
+
+ /* Set the event callback. */
+ ul_clients[id].event_hook = udi_event_clbk;
+
+ unifi_trace(priv, UDBG2, "UDI %d (0x%x) registered. configuration = 0x%x\n",
+ id, &ul_clients[id], configuration);
+ return &ul_clients[id];
+ }
+ }
+ return NULL;
+} /* ul_register_client() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * ul_deregister_client
+ *
+ * This function deregisters a blocking UDI client.
+ *
+ * Arguments:
+ * client Pointer to the client we deregister.
+ *
+ * Returns:
+ * 0 if a new clients is deregistered.
+ * ---------------------------------------------------------------------------
+ */
+int
+ul_deregister_client(ul_client_t *ul_client)
+{
+ struct list_head *pos, *n;
+ udi_log_t *logptr;
+ unifi_priv_t *priv = uf_find_instance(ul_client->instance);
+ int ref;
+
+ ul_client->instance = -1;
+ ul_client->event_hook = NULL;
+ ul_client->udi_enabled = 0;
+ unifi_trace(priv, UDBG5, "UDI (0x%x) deregistered.\n", ul_client);
+
+ /* Free memory allocated for the reply signal and its bulk data. */
+ CsrPmemFree(ul_client->reply_signal);
+ for (ref = 0; ref < UNIFI_MAX_DATA_REFERENCES; ref ++) {
+ CsrPmemFree(ul_client->reply_bulkdata[ref]);
+ }
+
+ if (ul_client->snap_filter.count) {
+ ul_client->snap_filter.count = 0;
+ CsrPmemFree(ul_client->snap_filter.protocols);
+ }
+
+ /* Free anything pending on the udi_log list */
+ down(&ul_client->udi_sem);
+ list_for_each_safe(pos, n, &ul_client->udi_log)
+ {
+ logptr = list_entry(pos, udi_log_t, q);
+ list_del(pos);
+ kfree(logptr);
+ }
+ up(&ul_client->udi_sem);
+
+ return 0;
+} /* ul_deregister_client() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * logging_handler
+ *
+ * This function is registered with the driver core.
+ * It is called every time a UniFi HIP Signal is sent. It iterates over
+ * the list of processes interested in receiving log events and
+ * delivers the events to them.
+ *
+ * Arguments:
+ * ospriv Pointer to driver's private data.
+ * sigdata Pointer to the packed signal buffer.
+ * signal_len Length of the packed signal.
+ * bulkdata Pointer to the signal's bulk data.
+ * dir Direction of the signal
+ * 0 = from-host
+ * 1 = to-host
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+logging_handler(void *ospriv,
+ CsrUint8 *sigdata, CsrUint32 signal_len,
+ const bulk_data_param_t *bulkdata,
+ enum udi_log_direction direction)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+ ul_client_t *client;
+ int dir;
+
+ dir = (direction == UDI_LOG_FROM_HOST) ? UDI_FROM_HOST : UDI_TO_HOST;
+
+ down(&priv->udi_logging_mutex);
+ client = priv->logging_client;
+ if (client != NULL) {
+ client->event_hook(client, sigdata, signal_len,
+ bulkdata, dir);
+ }
+ up(&priv->udi_logging_mutex);
+
+} /* logging_handler() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * ul_log_config_ind
+ *
+ * This function uses the client's register callback
+ * to indicate configuration information e.g core errors.
+ *
+ * Arguments:
+ * priv Pointer to driver's private data.
+ * conf_param Pointer to the configuration data.
+ * len Length of the configuration data.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+ul_log_config_ind(unifi_priv_t *priv, u8 *conf_param, int len)
+{
+#ifdef CSR_SUPPORT_SME
+ if (priv->smepriv == NULL)
+ {
+ return;
+ }
+ if ((CONFIG_IND_ERROR == (*conf_param)) && (priv->wifi_on_state == wifi_on_in_progress)) {
+ unifi_notice(priv, "ul_log_config_ind: wifi on in progress, suppress error\n");
+ } else {
+ /* wifi_off_ind (error or exit) */
+ CsrWifiRouterCtrlWifiOffIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, (CsrWifiRouterCtrlControlIndication)(*conf_param));
+ }
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+ unifi_debug_buf_dump();
+#endif
+#else
+ bulk_data_param_t bulkdata;
+
+ /*
+ * If someone killed unifi_managed before the driver was unloaded
+ * the g_drvpriv pointer is going to be NULL. In this case it is
+ * safe to assume that there is no client to get the indication.
+ */
+ if (!priv) {
+ unifi_notice(NULL, "uf_sme_event_ind: NULL priv\n");
+ return;
+ }
+
+ /* Create a null bulkdata structure. */
+ bulkdata.d[0].data_length = 0;
+ bulkdata.d[1].data_length = 0;
+
+ sme_native_log_event(priv->sme_cli, conf_param, sizeof(CsrUint8),
+ &bulkdata, UDI_CONFIG_IND);
+
+#endif /* CSR_SUPPORT_SME */
+
+} /* ul_log_config_ind */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * free_bulkdata_buffers
+ *
+ * Free the bulkdata buffers e.g. after a failed unifi_send_signal().
+ *
+ * Arguments:
+ * priv Pointer to device private struct
+ * bulkdata Pointer to bulkdata parameter table
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void
+free_bulkdata_buffers(unifi_priv_t *priv, bulk_data_param_t *bulkdata)
+{
+ int i;
+
+ if (bulkdata) {
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; ++i) {
+ if (bulkdata->d[i].data_length != 0) {
+ unifi_net_data_free(priv, (bulk_data_desc_t *)(&bulkdata->d[i]));
+ /* data_length is now 0 */
+ }
+ }
+ }
+
+} /* free_bulkdata_buffers */
+
+static int
+_align_bulk_data_buffers(unifi_priv_t *priv, CsrUint8 *signal,
+ bulk_data_param_t *bulkdata)
+{
+ unsigned int i;
+
+ if ((bulkdata == NULL) || (CSR_WIFI_ALIGN_BYTES == 0)) {
+ return 0;
+ }
+
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
+ {
+ struct sk_buff *skb;
+ /*
+ * The following complex casting is in place in order to eliminate 64-bit compilation warning
+ * "cast to/from pointer from/to integer of different size"
+ */
+ CsrUint32 align_offset = (CsrUint32)(long)(bulkdata->d[i].os_data_ptr) & (CSR_WIFI_ALIGN_BYTES-1);
+ if (align_offset)
+ {
+ skb = (struct sk_buff*)bulkdata->d[i].os_net_buf_ptr;
+ if (skb == NULL) {
+ unifi_warning(priv,
+ "_align_bulk_data_buffers: Align offset found (%d) but skb is NULL!\n",
+ align_offset);
+ return -EINVAL;
+ }
+ if (bulkdata->d[i].data_length == 0) {
+ unifi_warning(priv,
+ "_align_bulk_data_buffers: Align offset found (%d) but length is zero\n",
+ align_offset);
+ return CSR_RESULT_SUCCESS;
+ }
+ unifi_trace(priv, UDBG5,
+ "Align f-h buffer (0x%p) by %d bytes (skb->data: 0x%p)\n",
+ bulkdata->d[i].os_data_ptr, align_offset, skb->data);
+
+
+ /* Check if there is enough headroom... */
+ if (unlikely(skb_headroom(skb) < align_offset))
+ {
+ struct sk_buff *tmp = skb;
+
+ unifi_trace(priv, UDBG5, "Headroom not enough - realloc it\n");
+ skb = skb_realloc_headroom(skb, align_offset);
+ if (skb == NULL) {
+ unifi_error(priv,
+ "_align_bulk_data_buffers: skb_realloc_headroom failed - signal is dropped\n");
+ return -EFAULT;
+ }
+ /* Free the old bulk data only if allocation succeeds */
+ kfree_skb(tmp);
+ /* Bulkdata needs to point to the new skb */
+ bulkdata->d[i].os_net_buf_ptr = (const unsigned char*)skb;
+ bulkdata->d[i].os_data_ptr = (const void*)skb->data;
+ }
+ /* ... before pushing the data to the right alignment offset */
+ skb_push(skb, align_offset);
+
+ }
+ /* The direction bit is zero for the from-host */
+ signal[SIZEOF_SIGNAL_HEADER + (i * SIZEOF_DATAREF) + 1] = align_offset;
+
+ }
+ return 0;
+} /* _align_bulk_data_buffers() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * ul_send_signal_unpacked
+ *
+ * This function sends a host formatted signal to unifi.
+ *
+ * Arguments:
+ * priv Pointer to driver's private data.
+ * sigptr Pointer to the signal.
+ * bulkdata Pointer to the signal's bulk data.
+ *
+ * Returns:
+ * O on success, error code otherwise.
+ *
+ * Notes:
+ * The signals have to be sent in the format described in the host interface
+ * specification, i.e wire formatted. Certain clients use the host formatted
+ * structures. The write_pack() transforms the host formatted signal
+ * into the wired formatted signal. The code is in the core, since the signals
+ * are defined therefore binded to the host interface specification.
+ * ---------------------------------------------------------------------------
+ */
+int
+ul_send_signal_unpacked(unifi_priv_t *priv, CSR_SIGNAL *sigptr,
+ bulk_data_param_t *bulkdata)
+{
+ CsrUint8 sigbuf[UNIFI_PACKED_SIGBUF_SIZE];
+ CsrUint16 packed_siglen;
+ CsrResult csrResult;
+ unsigned long lock_flags;
+ int r;
+
+
+ csrResult = write_pack(sigptr, sigbuf, &packed_siglen);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "Malformed HIP signal in ul_send_signal_unpacked()\n");
+ return CsrHipResultToStatus(csrResult);
+ }
+ r = _align_bulk_data_buffers(priv, sigbuf, (bulk_data_param_t*)bulkdata);
+ if (r) {
+ return r;
+ }
+
+ spin_lock_irqsave(&priv->send_signal_lock, lock_flags);
+ csrResult = unifi_send_signal(priv->card, sigbuf, packed_siglen, bulkdata);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ /* free_bulkdata_buffers(priv, (bulk_data_param_t *)bulkdata); */
+ spin_unlock_irqrestore(&priv->send_signal_lock, lock_flags);
+ return CsrHipResultToStatus(csrResult);
+ }
+ spin_unlock_irqrestore(&priv->send_signal_lock, lock_flags);
+
+ return 0;
+} /* ul_send_signal_unpacked() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * reset_driver_status
+ *
+ * This function is called from ul_send_signal_raw() when it detects
+ * that the SME has sent a MLME-RESET request.
+ *
+ * Arguments:
+ * priv Pointer to device private struct
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+static void
+reset_driver_status(unifi_priv_t *priv)
+{
+ priv->sta_wmm_capabilities = 0;
+#ifdef CSR_NATIVE_LINUX
+#ifdef CSR_SUPPORT_WEXT
+ priv->wext_conf.flag_associated = 0;
+ priv->wext_conf.block_controlled_port = CSR_WIFI_ROUTER_PORT_ACTION_8021X_PORT_OPEN;
+ priv->wext_conf.bss_wmm_capabilities = 0;
+ priv->wext_conf.disable_join_on_ssid_set = 0;
+#endif
+#endif
+} /* reset_driver_status() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * ul_send_signal_raw
+ *
+ * This function sends a wire formatted data signal to unifi.
+ *
+ * Arguments:
+ * priv Pointer to driver's private data.
+ * sigptr Pointer to the signal.
+ * siglen Length of the signal.
+ * bulkdata Pointer to the signal's bulk data.
+ *
+ * Returns:
+ * O on success, error code otherwise.
+ * ---------------------------------------------------------------------------
+ */
+int
+ul_send_signal_raw(unifi_priv_t *priv, unsigned char *sigptr, int siglen,
+ bulk_data_param_t *bulkdata)
+{
+ CsrResult csrResult;
+ unsigned long lock_flags;
+ int r;
+
+ /*
+ * Make sure that the signal is updated with the bulk data
+ * alignment for DMA.
+ */
+ r = _align_bulk_data_buffers(priv, (CsrUint8*)sigptr, bulkdata);
+ if (r) {
+ return r;
+ }
+
+ spin_lock_irqsave(&priv->send_signal_lock, lock_flags);
+ csrResult = unifi_send_signal(priv->card, sigptr, siglen, bulkdata);
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ free_bulkdata_buffers(priv, bulkdata);
+ spin_unlock_irqrestore(&priv->send_signal_lock, lock_flags);
+ return CsrHipResultToStatus(csrResult);
+ }
+ spin_unlock_irqrestore(&priv->send_signal_lock, lock_flags);
+
+ /*
+ * Since this is use by unicli, if we get an MLME reset request
+ * we need to initialize a few status parameters
+ * that the driver uses to make decisions.
+ */
+ if (GET_SIGNAL_ID(sigptr) == CSR_MLME_RESET_REQUEST_ID) {
+ reset_driver_status(priv);
+ }
+
+ return 0;
+} /* ul_send_signal_raw() */
+
+
--- /dev/null
+/*
+ *****************************************************************************
+ *
+ * FILE : unifi_clients.h
+ *
+ * PURPOSE : Private header file for unifi clients.
+ *
+ * UDI = UniFi Debug Interface
+ *
+ * Copyright (C) 2005-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ *****************************************************************************
+ */
+#ifndef __LINUX_UNIFI_CLIENTS_H__
+#define __LINUX_UNIFI_CLIENTS_H__ 1
+
+#include <linux/kernel.h>
+
+#define MAX_UDI_CLIENTS 8
+
+/* The start of the range of process ids allocated for ul clients */
+#define UDI_SENDER_ID_BASE 0xC000
+#define UDI_SENDER_ID_SHIFT 8
+
+
+/* Structure to hold a UDI logged signal */
+typedef struct {
+
+ /* List link structure */
+ struct list_head q;
+
+ /* The message that will be passed to the user app */
+ udi_msg_t msg;
+
+ /* Signal body and data follow */
+
+} udi_log_t;
+
+
+
+typedef struct ul_client ul_client_t;
+
+typedef void (*udi_event_t)(ul_client_t *client,
+ const u8 *sigdata, int signal_len,
+ const bulk_data_param_t *bulkdata,
+ int dir);
+
+void logging_handler(void *ospriv,
+ CsrUint8 *sigdata, CsrUint32 signal_len,
+ const bulk_data_param_t *bulkdata,
+ enum udi_log_direction direction);
+
+
+/*
+ * Structure describing a bulk data slot.
+ * The length field is used to indicate empty/occupied state.
+ */
+typedef struct _bulk_data
+{
+ unsigned char ptr[2000];
+ unsigned int length;
+} bulk_data_t;
+
+
+struct ul_client {
+ /* Index of this client in the ul_clients array. */
+ int client_id;
+
+ /* Index of UniFi device to which this client is attached. */
+ int instance;
+
+ /* Flag to say whether this client has been enabled. */
+ int udi_enabled;
+
+ /* Value to use in signal->SenderProcessId */
+ int sender_id;
+
+ /* Configuration flags, e.g blocking, logging, etc. */
+ unsigned int configuration;
+
+ udi_event_t event_hook;
+
+ /* A list to hold signals received from UniFi for reading by read() */
+ struct list_head udi_log;
+
+ /* Semaphore to protect the udi_log list */
+ struct semaphore udi_sem;
+
+ /*
+ * Linux waitqueue to support blocking read and poll.
+ * Logging clients should wait on udi_log. while
+ * blocking clients should wait on wake_up_wq.
+ */
+ wait_queue_head_t udi_wq;
+ CSR_SIGNAL* reply_signal;
+ bulk_data_t* reply_bulkdata[UNIFI_MAX_DATA_REFERENCES];
+
+ CsrUint16 signal_filter[SIG_FILTER_SIZE];
+
+
+ /* ------------------------------------------------------------------- */
+ /* Code below here is used by the sme_native configuration only */
+
+ /* Flag to wake up blocking clients waiting on udi_wq. */
+ int wake_up_wq_id;
+
+ /*
+ * A 0x00 - 0x0F mask to apply in signal->SenderProcessId.
+ * Every time we do a blocking mlme request we increase this value.
+ * The mlme_wait_for_reply() will wait for this sequence number.
+ * Only the MLME blocking functions update this field.
+ */
+ unsigned char seq_no;
+
+ /*
+ * A 0x00 - 0x0F counter, containing the sequence number of
+ * the signal that this client has last received.
+ * Only the MLME blocking functions update this field.
+ */
+ unsigned char wake_seq_no;
+
+ unifiio_snap_filter_t snap_filter;
+}; /* struct ul_client */
+
+
+#endif /* __LINUX_UNIFI_CLIENTS_H__ */
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * FILE: unifi_config.h
+ *
+ * PURPOSE:
+ * This header file provides parameters that configure the operation
+ * of the driver.
+ *
+ * Copyright (C) 2006-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#ifndef __UNIFI_CONFIG_H__
+#define __UNIFI_CONFIG_H__ 1
+
+/*
+ * Override for the SDIO function block size on this host. When byte mode CMD53s
+ * are not used/supported by the SD host controller, transfers are padded up to
+ * the next block boundary. The 512-byte default on UF6xxx wastes too much space
+ * on the chip, so the block size is reduced to support this configuration.
+ */
+#define CSR_WIFI_HIP_SDIO_BLOCK_SIZE 64
+
+/* Define the number of mini-coredump buffers to allocate at startup. These are
+ * used to record chip status for the last n unexpected resets.
+ */
+#define CSR_WIFI_HIP_NUM_COREDUMP_BUFFERS 5
+
+
+#endif /* __UNIFI_CONFIG_H__ */
--- /dev/null
+/*
+ * ***************************************************************************
+ * FILE: unifi_dbg.c
+ *
+ * PURPOSE:
+ * Handle debug signals received from UniFi.
+ *
+ * Copyright (C) 2007-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ***************************************************************************
+ */
+#include "unifi_priv.h"
+
+/*
+ * ---------------------------------------------------------------------------
+ * debug_string_indication
+ * debug_word16_indication
+ *
+ * Handlers for debug indications.
+ *
+ * Arguments:
+ * priv Pointer to private context structure.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+debug_string_indication(unifi_priv_t *priv, const unsigned char *extra, unsigned int extralen)
+{
+ const unsigned int maxlen = sizeof(priv->last_debug_string) - 1;
+
+ if (extralen > maxlen) {
+ extralen = maxlen;
+ }
+
+ strncpy(priv->last_debug_string, extra, extralen);
+
+ /* Make sure the string is terminated */
+ priv->last_debug_string[extralen] = '\0';
+
+ unifi_info(priv, "unifi debug: %s\n", priv->last_debug_string);
+
+} /* debug_string_indication() */
+
+
+
+void
+debug_word16_indication(unifi_priv_t *priv, const CSR_SIGNAL *sigptr)
+{
+ int i;
+
+ if (priv == NULL) {
+ unifi_info(priv, "Priv is NULL\n");
+ return;
+ }
+
+ for (i = 0; i < 16; i++) {
+ priv->last_debug_word16[i] =
+ sigptr->u.DebugWord16Indication.DebugWords[i];
+ }
+
+ if (priv->last_debug_word16[0] == 0xFA11) {
+ unsigned long ts;
+ ts = (priv->last_debug_word16[6] << 16) | priv->last_debug_word16[5];
+ unifi_info(priv, " %10lu: %s fault %04x, arg %04x (x%d)\n",
+ ts,
+ priv->last_debug_word16[3] == 0x8000 ? "MAC" :
+ priv->last_debug_word16[3] == 0x4000 ? "PHY" :
+ "???",
+ priv->last_debug_word16[1],
+ priv->last_debug_word16[2],
+ priv->last_debug_word16[4]);
+ }
+ else if (priv->last_debug_word16[0] != 0xDBAC)
+ /* suppress SDL Trace output (note: still available to unicli). */
+ {
+ unifi_info(priv, "unifi debug: %04X %04X %04X %04X %04X %04X %04X %04X\n",
+ priv->last_debug_word16[0], priv->last_debug_word16[1],
+ priv->last_debug_word16[2], priv->last_debug_word16[3],
+ priv->last_debug_word16[4], priv->last_debug_word16[5],
+ priv->last_debug_word16[6], priv->last_debug_word16[7]);
+ unifi_info(priv, " %04X %04X %04X %04X %04X %04X %04X %04X\n",
+ priv->last_debug_word16[8], priv->last_debug_word16[9],
+ priv->last_debug_word16[10], priv->last_debug_word16[11],
+ priv->last_debug_word16[12], priv->last_debug_word16[13],
+ priv->last_debug_word16[14], priv->last_debug_word16[15]);
+ }
+
+} /* debug_word16_indication() */
+
+
+void
+debug_generic_indication(unifi_priv_t *priv, const CSR_SIGNAL *sigptr)
+{
+ unifi_info(priv, "debug: %04X %04X %04X %04X %04X %04X %04X %04X\n",
+ sigptr->u.DebugGenericIndication.DebugWords[0],
+ sigptr->u.DebugGenericIndication.DebugWords[1],
+ sigptr->u.DebugGenericIndication.DebugWords[2],
+ sigptr->u.DebugGenericIndication.DebugWords[3],
+ sigptr->u.DebugGenericIndication.DebugWords[4],
+ sigptr->u.DebugGenericIndication.DebugWords[5],
+ sigptr->u.DebugGenericIndication.DebugWords[6],
+ sigptr->u.DebugGenericIndication.DebugWords[7]);
+
+} /* debug_generic_indication() */
+
--- /dev/null
+/*
+ * ***************************************************************************
+ * FILE: unifi_event.c
+ *
+ * PURPOSE:
+ * Process the signals received by UniFi.
+ * It is part of the porting exercise.
+ *
+ * Copyright (C) 2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ***************************************************************************
+ */
+
+
+/*
+ * Porting notes:
+ * The implementation of unifi_receive_event() in Linux is fairly complicated.
+ * The linux driver support multiple userspace applications and several
+ * build configurations, so the received signals are processed by different
+ * processes and multiple times.
+ * In a simple implementation, this function needs to deliver:
+ * - The MLME-UNITDATA.ind signals to the Rx data plane and to the Traffic
+ * Analysis using unifi_ta_sample().
+ * - The MLME-UNITDATA-STATUS.ind signals to the Tx data plane.
+ * - All the other signals to the SME using unifi_sys_hip_ind().
+ */
+
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_conversions.h"
+#include "unifi_priv.h"
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * send_to_client
+ *
+ * Helper for unifi_receive_event.
+ *
+ * This function forwards a signal to one client.
+ *
+ * Arguments:
+ * priv Pointer to driver's private data.
+ * client Pointer to the client structure.
+ * receiver_id The reciever id of the signal.
+ * sigdata Pointer to the packed signal buffer.
+ * siglen Length of the packed signal.
+ * bulkdata Pointer to the signal's bulk data.
+ *
+ * Returns:
+ * None.
+ *
+ * ---------------------------------------------------------------------------
+ */
+static void send_to_client(unifi_priv_t *priv, ul_client_t *client,
+ int receiver_id,
+ unsigned char *sigdata, int siglen,
+ const bulk_data_param_t *bulkdata)
+{
+ if (client && client->event_hook) {
+ /*unifi_trace(priv, UDBG3,
+ "Receive: client %d, (s:0x%X, r:0x%X) - Signal 0x%.4X \n",
+ client->client_id, client->sender_id, receiver_id,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata));*/
+
+ client->event_hook(client, sigdata, siglen, bulkdata, UDI_TO_HOST);
+ }
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * process_pkt_data_ind
+ *
+ * Dispatcher for received signals.
+ *
+ * This function receives the 'to host' signals and forwards
+ * them to the unifi linux clients.
+ *
+ * Arguments:
+ * priv Context
+ * sigdata Pointer to the packed signal buffer(Its in form of MA-PACKET.ind).
+ * bulkdata Pointer to signal's bulkdata
+ * freeBulkData Pointer to a flag which gets set if the bulkdata needs to
+ * be freed after calling the logging handlers. If it is not
+ * set the bulkdata must be freed by the MLME handler or
+ * passed to the network stack.
+ * Returns:
+ * TRUE if the packet should be routed to the SME etc.
+ * FALSE if the packet is for the driver or network stack
+ * ---------------------------------------------------------------------------
+ */
+static CsrBool check_routing_pkt_data_ind(unifi_priv_t *priv,
+ CsrUint8 *sigdata,
+ const bulk_data_param_t* bulkdata,
+ CsrBool *freeBulkData,
+ netInterface_priv_t *interfacePriv)
+{
+ CsrUint16 frmCtrl, receptionStatus, frmCtrlSubType;
+ CsrUint8 *macHdrLocation;
+ CsrUint8 interfaceTag;
+ CsrBool isDataFrame;
+ CsrBool isProtocolVerInvalid = FALSE;
+ CsrBool isDataFrameSubTypeNoData = FALSE;
+
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ static const CsrUint8 wapiProtocolIdSNAPHeader[] = {0x88,0xb4};
+ static const CsrUint8 wapiProtocolIdSNAPHeaderOffset = 6;
+ CsrUint8 *destAddr;
+ CsrUint8 *srcAddr;
+ CsrBool isWapiUnicastPkt = FALSE;
+
+#ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
+ CsrUint16 qosControl;
+#endif
+
+ CsrUint8 llcSnapHeaderOffset = 0;
+
+ destAddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET;
+ srcAddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET;
+
+ /*Individual/Group bit - Bit 0 of first byte*/
+ isWapiUnicastPkt = (!(destAddr[0] & 0x01)) ? TRUE : FALSE;
+#endif
+
+#define CSR_WIFI_MA_PKT_IND_RECEPTION_STATUS_OFFSET sizeof(CSR_SIGNAL_PRIMITIVE_HEADER) + 22
+
+ *freeBulkData = FALSE;
+
+ /* Fetch the MAC header location from MA_PKT_IND packet */
+ macHdrLocation = (CsrUint8 *) bulkdata->d[0].os_data_ptr;
+ /* Fetch the Frame Control value from MAC header */
+ frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation);
+
+ /* Pull out interface tag from virtual interface identifier */
+ interfaceTag = (CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + 14)) & 0xff;
+
+ /* check for MIC failure before processing the signal */
+ receptionStatus = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + CSR_WIFI_MA_PKT_IND_RECEPTION_STATUS_OFFSET);
+
+ /* To discard any spurious MIC failures that could be reported by the firmware */
+ isDataFrame = ((frmCtrl & IEEE80211_FC_TYPE_MASK) == (IEEE802_11_FC_TYPE_DATA & IEEE80211_FC_TYPE_MASK)) ? TRUE : FALSE;
+ /* 0x00 is the only valid protocol version*/
+ isProtocolVerInvalid = (frmCtrl & IEEE80211_FC_PROTO_VERSION_MASK) ? TRUE : FALSE;
+ frmCtrlSubType = (frmCtrl & IEEE80211_FC_SUBTYPE_MASK) >> FRAME_CONTROL_SUBTYPE_FIELD_OFFSET;
+ /*Exclude the no data & reserved sub-types from MIC failure processing*/
+ isDataFrameSubTypeNoData = (((frmCtrlSubType>0x03)&&(frmCtrlSubType<0x08)) || (frmCtrlSubType>0x0B)) ? TRUE : FALSE;
+ if ((receptionStatus == CSR_MICHAEL_MIC_ERROR) &&
+ ((!isDataFrame) || isProtocolVerInvalid || (isDataFrame && isDataFrameSubTypeNoData))) {
+ /* Currently MIC errors are discarded for frames other than data frames. This might need changing when we start
+ * supporting 802.11w (Protected Management frames)
+ */
+ *freeBulkData = TRUE;
+ unifi_trace(priv, UDBG4, "Discarding this frame and ignoring the MIC failure as this is a garbage/non-data/no data frame\n");
+ return FALSE;
+ }
+
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+
+ if (receptionStatus == CSR_MICHAEL_MIC_ERROR) {
+
+ if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA) {
+
+#ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
+ if ((isDataFrame) &&
+ ((IEEE802_11_FC_TYPE_QOS_DATA & IEEE80211_FC_SUBTYPE_MASK) == (frmCtrl & IEEE80211_FC_SUBTYPE_MASK)) &&
+ (priv->isWapiConnection))
+ {
+ qosControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation + (((frmCtrl & IEEE802_11_FC_TO_DS_MASK) && (frmCtrl & IEEE802_11_FC_FROM_DS_MASK)) ? 30 : 24) );
+
+ unifi_trace(priv, UDBG4, "check_routing_pkt_data_ind() :: Value of the QoS control field - 0x%04x \n", qosControl);
+
+ if (qosControl & IEEE802_11_QC_NON_TID_BITS_MASK)
+ {
+ unifi_trace(priv, UDBG4, "Ignore the MIC failure and pass the MPDU to the stack when any of bits [4-15] is set in the QoS control field\n");
+
+ /*Exclude the MIC [16] and the PN [16] that are appended by the firmware*/
+ ((bulk_data_param_t*)bulkdata)->d[0].data_length = bulkdata->d[0].data_length - 32;
+
+ /*Clear the reception status of the signal (CSR_RX_SUCCESS)*/
+ *(sigdata + CSR_WIFI_MA_PKT_IND_RECEPTION_STATUS_OFFSET) = 0x00;
+ *(sigdata + CSR_WIFI_MA_PKT_IND_RECEPTION_STATUS_OFFSET+1) = 0x00;
+
+ *freeBulkData = FALSE;
+
+ return FALSE;
+ }
+ }
+#endif
+ /* If this MIC ERROR reported by the firmware is either for
+ * [1] a WAPI Multicast MPDU and the Multicast filter has NOT been set (It is set only when group key index (MSKID) = 1 in Group Rekeying) OR
+ * [2] a WAPI Unicast MPDU and either the CONTROL PORT is open or the WAPI Unicast filter or filter(s) is NOT set
+ * then report a MIC FAILURE indication to the SME.
+ */
+#ifndef CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION
+ if ((priv->wapi_multicast_filter == 0) || isWapiUnicastPkt) {
+#else
+ /*When SW encryption is enabled and USKID=1 (wapi_unicast_filter = 1), we are expected
+ *to receive MIC failure INDs for unicast MPDUs*/
+ if ( ((priv->wapi_multicast_filter == 0) && !isWapiUnicastPkt) ||
+ ((priv->wapi_unicast_filter == 0) && isWapiUnicastPkt) ) {
+#endif
+ /*Discard the frame*/
+ *freeBulkData = TRUE;
+ unifi_trace(priv, UDBG4, "Discarding the contents of the frame with MIC failure \n");
+
+ if (isWapiUnicastPkt &&
+ ((uf_sme_port_state(priv,srcAddr,UF_CONTROLLED_PORT_Q,interfaceTag) != CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN)||
+#ifndef CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION
+ (priv->wapi_unicast_filter) ||
+#endif
+ (priv->wapi_unicast_queued_pkt_filter))) {
+
+ /* Workaround to handle MIC failures reported by the firmware for encrypted packets from the AP
+ * while we are in the process of re-association induced by unsupported WAPI Unicast key index
+ * - Discard the packets with MIC failures "until" we have
+ * a. negotiated a key,
+ * b. opened the CONTROL PORT and
+ * c. the AP has started using the new key
+ */
+ unifi_trace(priv, UDBG4, "Ignoring the MIC failure as either a. CONTROL PORT isn't OPEN or b. Unicast filter is set or c. WAPI AP using old key for buffered pkts\n");
+
+ /*Ignore this MIC failure*/
+ return FALSE;
+
+ }/*WAPI re-key specific workaround*/
+
+ unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind - MIC FAILURE : interfaceTag %x Src Addr %x:%x:%x:%x:%x:%x\n",
+ interfaceTag, srcAddr[0], srcAddr[1], srcAddr[2], srcAddr[3], srcAddr[4], srcAddr[5]);
+ unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind - MIC FAILURE : Dest Addr %x:%x:%x:%x:%x:%x\n",
+ destAddr[0], destAddr[1], destAddr[2], destAddr[3], destAddr[4], destAddr[5]);
+ unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind - MIC FAILURE : Control Port State - 0x%.4X \n",
+ uf_sme_port_state(priv,srcAddr,UF_CONTROLLED_PORT_Q,interfaceTag));
+
+ unifi_error(priv, "MIC failure in %s\n", __FUNCTION__);
+
+ /*Report the MIC failure to the SME*/
+ return TRUE;
+ }
+ }/* STA mode */
+ else {
+ /* Its AP Mode . Just Return */
+ *freeBulkData = TRUE;
+ unifi_error(priv, "MIC failure in %s\n", __FUNCTION__);
+ return TRUE;
+ } /* AP mode */
+ }/* MIC error */
+#else
+ if (receptionStatus == CSR_MICHAEL_MIC_ERROR) {
+ *freeBulkData = TRUE;
+ unifi_error(priv, "MIC failure in %s\n", __FUNCTION__);
+ return TRUE;
+ }
+#endif /*CSR_WIFI_SECURITY_WAPI_ENABLE*/
+
+ unifi_trace(priv, UDBG4, "frmCtrl = 0x%04x %s\n",
+ frmCtrl,
+ (((frmCtrl & 0x000c)>>FRAME_CONTROL_TYPE_FIELD_OFFSET) == IEEE802_11_FRAMETYPE_MANAGEMENT) ?
+ "Mgt" : "Ctrl/Data");
+
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ /* To ignore MIC failures reported due to the WAPI AP using the old key for queued packets before
+ * starting to use the new key negotiated as part of unicast re-keying
+ */
+ if ((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA)&&
+ isWapiUnicastPkt &&
+ (receptionStatus == CSR_RX_SUCCESS) &&
+ (priv->wapi_unicast_queued_pkt_filter==1)) {
+
+ unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): WAPI unicast pkt received when the (wapi_unicast_queued_pkt_filter) is set\n");
+
+ if (isDataFrame) {
+ switch(frmCtrl & IEEE80211_FC_SUBTYPE_MASK) {
+ case IEEE802_11_FC_TYPE_QOS_DATA & IEEE80211_FC_SUBTYPE_MASK:
+ llcSnapHeaderOffset = MAC_HEADER_SIZE + 2;
+ break;
+ case IEEE802_11_FC_TYPE_QOS_NULL & IEEE80211_FC_SUBTYPE_MASK:
+ case IEEE802_11_FC_TYPE_NULL & IEEE80211_FC_SUBTYPE_MASK:
+ break;
+ default:
+ llcSnapHeaderOffset = MAC_HEADER_SIZE;
+ }
+ }
+
+ if (llcSnapHeaderOffset > 0) {
+ /* QoS data or Data */
+ unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): SNAP header found & its offset %d\n",llcSnapHeaderOffset);
+ if (memcmp((CsrUint8 *)(bulkdata->d[0].os_data_ptr+llcSnapHeaderOffset+wapiProtocolIdSNAPHeaderOffset),
+ wapiProtocolIdSNAPHeader,sizeof(wapiProtocolIdSNAPHeader))) {
+
+ unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): This is a data & NOT a WAI protocol packet\n");
+ /* On the first unicast data pkt that is decrypted successfully after re-keying, reset the filter */
+ priv->wapi_unicast_queued_pkt_filter = 0;
+ unifi_trace(priv, UDBG4, "check_routing_pkt_data_ind(): WAPI AP has started using the new unicast key, no more MIC failures expected (reset filter)\n");
+ }
+ else {
+ unifi_trace(priv, UDBG6, "check_routing_pkt_data_ind(): WAPI - This is a WAI protocol packet\n");
+ }
+ }
+ }
+#endif
+
+
+ switch ((frmCtrl & 0x000c)>>FRAME_CONTROL_TYPE_FIELD_OFFSET) {
+ case IEEE802_11_FRAMETYPE_MANAGEMENT:
+ *freeBulkData = TRUE; /* Free (after SME handler copies it) */
+
+ /* In P2P device mode, filter the legacy AP beacons here */
+ if((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2P)&&\
+ ((CSR_WIFI_80211_GET_FRAME_SUBTYPE(macHdrLocation)) == CSR_WIFI_80211_FRAME_SUBTYPE_BEACON)){
+
+ CsrUint8 *pSsid, *pSsidLen;
+ static CsrUint8 P2PWildCardSsid[CSR_WIFI_P2P_WILDCARD_SSID_LENGTH] = {'D', 'I', 'R', 'E', 'C', 'T', '-'};
+
+ pSsidLen = macHdrLocation + MAC_HEADER_SIZE + CSR_WIFI_BEACON_FIXED_LENGTH;
+ pSsid = pSsidLen + 2;
+
+ if(*(pSsidLen + 1) >= CSR_WIFI_P2P_WILDCARD_SSID_LENGTH){
+ if(memcmp(pSsid, P2PWildCardSsid, CSR_WIFI_P2P_WILDCARD_SSID_LENGTH) == 0){
+ unifi_trace(priv, UDBG6, "Received a P2P Beacon, pass it to SME\n");
+ return TRUE;
+ }
+ }
+ unifi_trace(priv, UDBG6, "Received a Legacy AP beacon in P2P mode, drop it\n");
+ return FALSE;
+ }
+ return TRUE; /* Route to SME */
+ case IEEE802_11_FRAMETYPE_DATA:
+ case IEEE802_11_FRAMETYPE_CONTROL:
+ *freeBulkData = FALSE; /* Network stack or MLME handler frees */
+ return FALSE;
+ default:
+ unifi_error(priv, "Unhandled frame type %04x\n", frmCtrl);
+ *freeBulkData = TRUE; /* Not interested, but must free it */
+ return FALSE;
+ }
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_process_receive_event
+ *
+ * Dispatcher for received signals.
+ *
+ * This function receives the 'to host' signals and forwards
+ * them to the unifi linux clients.
+ *
+ * Arguments:
+ * ospriv Pointer to driver's private data.
+ * sigdata Pointer to the packed signal buffer.
+ * siglen Length of the packed signal.
+ * bulkdata Pointer to the signal's bulk data.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * The signals are received in the format described in the host interface
+ * specification, i.e wire formatted. Certain clients use the same format
+ * to interpret them and other clients use the host formatted structures.
+ * Each client has to call read_unpack_signal() to transform the wire
+ * formatted signal into the host formatted signal, if necessary.
+ * The code is in the core, since the signals are defined therefore
+ * binded to the host interface specification.
+ * ---------------------------------------------------------------------------
+ */
+static void
+unifi_process_receive_event(void *ospriv,
+ CsrUint8 *sigdata, CsrUint32 siglen,
+ const bulk_data_param_t *bulkdata)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+ int i, receiver_id;
+ int client_id;
+ CsrInt16 signal_id;
+ CsrBool pktIndToSme = FALSE, freeBulkData = FALSE;
+
+ func_enter();
+
+ unifi_trace(priv, UDBG5, "unifi_process_receive_event: "
+ "%04x %04x %04x %04x %04x %04x %04x %04x (%d)\n",
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*0) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*1) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*2) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*3) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*4) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*5) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*6) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*7) & 0xFFFF,
+ siglen);
+
+ receiver_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)) & 0xFF00;
+ client_id = (receiver_id & 0x0F00) >> UDI_SENDER_ID_SHIFT;
+ signal_id = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata);
+
+
+
+ /* check for the type of frame received (checks for 802.11 management frames) */
+ if (signal_id == CSR_MA_PACKET_INDICATION_ID)
+ {
+#define CSR_MA_PACKET_INDICATION_INTERFACETAG_OFFSET 14
+ CsrUint8 interfaceTag;
+ netInterface_priv_t *interfacePriv;
+
+ /* Pull out interface tag from virtual interface identifier */
+ interfaceTag = (CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + CSR_MA_PACKET_INDICATION_INTERFACETAG_OFFSET)) & 0xff;
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ /* Update activity for this station in case of IBSS */
+#ifdef CSR_SUPPORT_SME
+ if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_IBSS)
+ {
+ CsrUint8 *saddr;
+ /* Fetch the source address from mac header */
+ saddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR2_OFFSET;
+ unifi_trace(priv, UDBG5,
+ "Updating sta activity in IBSS interfaceTag %x Src Addr %x:%x:%x:%x:%x:%x\n",
+ interfaceTag, saddr[0], saddr[1], saddr[2], saddr[3], saddr[4], saddr[5]);
+
+ uf_update_sta_activity(priv, interfaceTag, saddr);
+ }
+#endif
+
+ pktIndToSme = check_routing_pkt_data_ind(priv, sigdata, bulkdata, &freeBulkData, interfacePriv);
+
+ unifi_trace(priv, UDBG6, "RX: packet entry point to driver from HIP,pkt to SME ?(%s) \n", (pktIndToSme)? "YES":"NO");
+
+ }
+
+ if (pktIndToSme)
+ {
+ /* Management MA_PACKET_IND for SME */
+ if(sigdata != NULL && bulkdata != NULL){
+ send_to_client(priv, priv->sme_cli, receiver_id, sigdata, siglen, bulkdata);
+ }
+ else{
+ unifi_error(priv, "unifi_receive_event2: sigdata or Bulkdata is NULL \n");
+ }
+#ifdef CSR_NATIVE_LINUX
+ send_to_client(priv, priv->wext_client,
+ receiver_id,
+ sigdata, siglen, bulkdata);
+#endif
+ }
+ else
+ {
+ /* Signals with ReceiverId==0 are also reported to SME / WEXT,
+ * unless they are data/control MA_PACKET_INDs or VIF_AVAILABILITY_INDs
+ */
+ if (!receiver_id) {
+ if(signal_id == CSR_MA_VIF_AVAILABILITY_INDICATION_ID) {
+ uf_process_ma_vif_availibility_ind(priv, sigdata, siglen);
+ }
+ else if (signal_id != CSR_MA_PACKET_INDICATION_ID) {
+ send_to_client(priv, priv->sme_cli, receiver_id, sigdata, siglen, bulkdata);
+#ifdef CSR_NATIVE_LINUX
+ send_to_client(priv, priv->wext_client,
+ receiver_id,
+ sigdata, siglen, bulkdata);
+#endif
+ }
+ else
+ {
+
+#if (defined(CSR_SUPPORT_SME) && defined(CSR_WIFI_SECURITY_WAPI_ENABLE))
+ #define CSR_MA_PACKET_INDICATION_RECEPTION_STATUS_OFFSET sizeof(CSR_SIGNAL_PRIMITIVE_HEADER) + 22
+ netInterface_priv_t *interfacePriv;
+ CsrUint8 interfaceTag;
+ CsrUint16 receptionStatus = CSR_RX_SUCCESS;
+
+ /* Pull out interface tag from virtual interface identifier */
+ interfaceTag = (CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + CSR_MA_PACKET_INDICATION_INTERFACETAG_OFFSET)) & 0xff;
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ /* check for MIC failure */
+ receptionStatus = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata + CSR_MA_PACKET_INDICATION_RECEPTION_STATUS_OFFSET);
+
+ /* Send a WAPI MPDU to SME for re-check MIC if the respective filter has been set*/
+ if ((!freeBulkData) &&
+ (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA) &&
+ (receptionStatus == CSR_MICHAEL_MIC_ERROR) &&
+ ((priv->wapi_multicast_filter == 1)
+#ifdef CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION
+ || (priv->wapi_unicast_filter == 1)
+#endif
+ ))
+ {
+ CSR_SIGNAL signal;
+ CsrUint8 *destAddr;
+ CsrResult res;
+ CsrUint16 interfaceTag = 0;
+ CsrBool isMcastPkt = TRUE;
+
+ unifi_trace(priv, UDBG6, "Received a WAPI data packet when the Unicast/Multicast filter is set\n");
+ res = read_unpack_signal(sigdata, &signal);
+ if (res) {
+ unifi_error(priv, "Received unknown or corrupted signal (0x%x).\n",
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata));
+ return;
+ }
+
+ /* Check if the type of MPDU and the respective filter status*/
+ destAddr = (CsrUint8 *) bulkdata->d[0].os_data_ptr + MAC_HEADER_ADDR1_OFFSET;
+ isMcastPkt = (destAddr[0] & 0x01) ? TRUE : FALSE;
+ unifi_trace(priv, UDBG6,
+ "1.MPDU type: (%s), 2.Multicast filter: (%s), 3. Unicast filter: (%s)\n",
+ ((isMcastPkt) ? "Multiast":"Unicast"),
+ ((priv->wapi_multicast_filter) ? "Enabled":"Disabled"),
+ ((priv->wapi_unicast_filter) ? "Enabled":"Disabled"));
+
+ if (((isMcastPkt) && (priv->wapi_multicast_filter == 1))
+#ifdef CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION
+ || ((!isMcastPkt) && (priv->wapi_unicast_filter == 1))
+#endif
+ )
+ {
+ unifi_trace(priv, UDBG4, "Sending the WAPI MPDU for MIC check\n");
+ CsrWifiRouterCtrlWapiRxMicCheckIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, siglen, sigdata, bulkdata->d[0].data_length, (CsrUint8*)bulkdata->d[0].os_data_ptr);
+
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
+ if (bulkdata->d[i].data_length != 0) {
+ unifi_net_data_free(priv, (void *)&bulkdata->d[i]);
+ }
+ }
+ func_exit();
+ return;
+ }
+ } /* CSR_MA_PACKET_INDICATION_ID */
+#endif /*CSR_SUPPORT_SME && CSR_WIFI_SECURITY_WAPI_ENABLE*/
+ }
+ }
+
+ /* calls the registered clients handler callback func.
+ * netdev_mlme_event_handler is one of the registered handler used to route
+ * data packet to network stack or AMP/EAPOL related data to SME
+ *
+ * The freeBulkData check ensures that, it has received a management frame and
+ * the frame needs to be freed here. So not to be passed to netdev handler
+ */
+ if(!freeBulkData){
+ if ((client_id < MAX_UDI_CLIENTS) &&
+ (&priv->ul_clients[client_id] != priv->logging_client)) {
+ unifi_trace(priv, UDBG6, "Call the registered clients handler callback func\n");
+ send_to_client(priv, &priv->ul_clients[client_id],
+ receiver_id,
+ sigdata, siglen, bulkdata);
+ }
+ }
+ }
+
+ /*
+ * Free bulk data buffers here unless it is a CSR_MA_PACKET_INDICATION
+ */
+ switch (signal_id)
+ {
+#ifdef UNIFI_SNIFF_ARPHRD
+ case CSR_MA_SNIFFDATA_INDICATION_ID:
+#endif
+ break;
+
+ case CSR_MA_PACKET_INDICATION_ID:
+ if (!freeBulkData)
+ {
+ break;
+ }
+ /* FALLS THROUGH... */
+ default:
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
+ if (bulkdata->d[i].data_length != 0) {
+ unifi_net_data_free(priv, (void *)&bulkdata->d[i]);
+ }
+ }
+ }
+
+ func_exit();
+} /* unifi_process_receive_event() */
+
+
+#ifdef CSR_WIFI_RX_PATH_SPLIT
+static CsrBool signal_buffer_is_full(unifi_priv_t* priv)
+{
+ return (((priv->rxSignalBuffer.writePointer + 1)% priv->rxSignalBuffer.size) == (priv->rxSignalBuffer.readPointer));
+}
+
+void unifi_rx_queue_flush(void *ospriv)
+{
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+
+ func_enter();
+ unifi_trace(priv, UDBG4, "rx_wq_handler: RdPtr = %d WritePtr = %d\n",
+ priv->rxSignalBuffer.readPointer,priv->rxSignalBuffer.writePointer);
+ if(priv != NULL) {
+ CsrUint8 readPointer = priv->rxSignalBuffer.readPointer;
+ while (readPointer != priv->rxSignalBuffer.writePointer)
+ {
+ rx_buff_struct_t *buf = &priv->rxSignalBuffer.rx_buff[readPointer];
+ unifi_trace(priv, UDBG6, "rx_wq_handler: RdPtr = %d WritePtr = %d\n",
+ readPointer,priv->rxSignalBuffer.writePointer);
+ unifi_process_receive_event(priv, buf->bufptr, buf->sig_len, &buf->data_ptrs);
+ readPointer ++;
+ if(readPointer >= priv->rxSignalBuffer.size) {
+ readPointer = 0;
+ }
+ }
+ priv->rxSignalBuffer.readPointer = readPointer;
+ }
+ func_exit();
+}
+
+void rx_wq_handler(struct work_struct *work)
+{
+ unifi_priv_t *priv = container_of(work, unifi_priv_t, rx_work_struct);
+ unifi_rx_queue_flush(priv);
+}
+#endif
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * unifi_receive_event
+ *
+ * Dispatcher for received signals.
+ *
+ * This function receives the 'to host' signals and forwards
+ * them to the unifi linux clients.
+ *
+ * Arguments:
+ * ospriv Pointer to driver's private data.
+ * sigdata Pointer to the packed signal buffer.
+ * siglen Length of the packed signal.
+ * bulkdata Pointer to the signal's bulk data.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * The signals are received in the format described in the host interface
+ * specification, i.e wire formatted. Certain clients use the same format
+ * to interpret them and other clients use the host formatted structures.
+ * Each client has to call read_unpack_signal() to transform the wire
+ * formatted signal into the host formatted signal, if necessary.
+ * The code is in the core, since the signals are defined therefore
+ * binded to the host interface specification.
+ * ---------------------------------------------------------------------------
+ */
+void
+unifi_receive_event(void *ospriv,
+ CsrUint8 *sigdata, CsrUint32 siglen,
+ const bulk_data_param_t *bulkdata)
+{
+#ifdef CSR_WIFI_RX_PATH_SPLIT
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+ CsrUint8 writePointer;
+ int i;
+ rx_buff_struct_t * rx_buff;
+ func_enter();
+
+ unifi_trace(priv, UDBG5, "unifi_receive_event: "
+ "%04x %04x %04x %04x %04x %04x %04x %04x (%d)\n",
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*0) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*1) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*2) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*3) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*4) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*5) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*6) & 0xFFFF,
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(CsrInt16)*7) & 0xFFFF, siglen);
+ if(signal_buffer_is_full(priv)) {
+ unifi_error(priv,"TO HOST signal queue FULL dropping the PDU\n");
+ for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++) {
+ if (bulkdata->d[i].data_length != 0) {
+ unifi_net_data_free(priv, (void *)&bulkdata->d[i]);
+ }
+ }
+ return;
+ }
+ writePointer = priv->rxSignalBuffer.writePointer;
+ rx_buff = &priv->rxSignalBuffer.rx_buff[writePointer];
+ memcpy(rx_buff->bufptr,sigdata,siglen);
+ rx_buff->sig_len = siglen;
+ rx_buff->data_ptrs = *bulkdata;
+ writePointer++;
+ if(writePointer >= priv->rxSignalBuffer.size) {
+ writePointer =0;
+ }
+ unifi_trace(priv, UDBG4, "unifi_receive_event:writePtr = %d\n",priv->rxSignalBuffer.writePointer);
+ priv->rxSignalBuffer.writePointer = writePointer;
+
+#ifndef CSR_WIFI_RX_PATH_SPLIT_DONT_USE_WQ
+ queue_work(priv->rx_workqueue, &priv->rx_work_struct);
+#endif
+
+#else
+ unifi_process_receive_event(ospriv, sigdata, siglen, bulkdata);
+#endif
+ func_exit();
+} /* unifi_receive_event() */
+
--- /dev/null
+/*
+ *****************************************************************************
+ *
+ * FILE : unifi_native.h
+ *
+ * PURPOSE : Private header file for unifi driver support to wireless extensions.
+ *
+ * UDI = UniFi Debug Interface
+ *
+ * Copyright (C) 2005-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ *****************************************************************************
+ */
+#ifndef __LINUX_UNIFI_NATIVE_H__
+#define __LINUX_UNIFI_NATIVE_H__ 1
+
+#include <linux/kernel.h>
+#include <linux/if_arp.h>
+
+
+/*
+ * scan.c wext.c autojoin.c
+ */
+/* Structure to hold results of a scan */
+typedef struct scan_info {
+
+/* CSR_MLME_SCAN_INDICATION msi; */
+
+ unsigned char *info_elems;
+ int info_elem_length;
+
+} scan_info_t;
+
+
+#define IE_VECTOR_MAXLEN 1024
+
+#ifdef CSR_SUPPORT_WEXT
+/*
+ * Structre to hold the wireless network configuration info.
+ */
+struct wext_config {
+
+ /* Requested channel when setting up an adhoc network */
+ int channel;
+
+ /* wireless extns mode: IW_MODE_AUTO, ADHOC, INFRA, MASTER ... MONITOR */
+ int mode;
+
+ /* The capabilities of the currently joined network */
+ int capability;
+
+ /* The interval between beacons if we create an IBSS */
+ int beacon_period;
+
+ /*
+ * Power-save parameters
+ */
+ /* The listen interval to ask for in Associate req. */
+ int assoc_listen_interval;
+ /* Power-mode to put UniFi into */
+
+ unsigned char desired_ssid[UNIFI_MAX_SSID_LEN]; /* the last ESSID set by SIOCSIWESSID */
+ int power_mode;
+ /* Whether to wake for broadcast packets (using DTIM interval) */
+ int wakeup_for_dtims;
+
+ /* Currently selected WEP Key ID (0..3) */
+ int wep_key_id;
+
+ wep_key_t wep_keys[NUM_WEPKEYS];
+
+/* CSR_AUTHENTICATION_TYPE auth_type; */
+ int privacy;
+
+ u32 join_failure_timeout;
+ u32 auth_failure_timeout;
+ u32 assoc_failure_timeout;
+
+ unsigned char generic_ie[IE_VECTOR_MAXLEN];
+ int generic_ie_len;
+
+ struct iw_statistics wireless_stats;
+
+
+ /* the ESSID we are currently associated to */
+ unsigned char current_ssid[UNIFI_MAX_SSID_LEN];
+ /* the BSSID we are currently associated to */
+ unsigned char current_bssid[6];
+
+ /*
+ * IW_AUTH_WPA_VERSION_DISABLED 0x00000001
+ * IW_AUTH_WPA_VERSION_WPA 0x00000002
+ * IW_AUTH_WPA_VERSION_WPA2 0x00000004
+ */
+ unsigned char wpa_version;
+
+ /*
+ * cipher selection:
+ * IW_AUTH_CIPHER_NONE 0x00000001
+ * IW_AUTH_CIPHER_WEP40 0x00000002
+ * IW_AUTH_CIPHER_TKIP 0x00000004
+ * IW_AUTH_CIPHER_CCMP 0x00000008
+ * IW_AUTH_CIPHER_WEP104 0x00000010
+ */
+ unsigned char pairwise_cipher_used;
+ unsigned char group_cipher_used;
+
+ unsigned int frag_thresh;
+ unsigned int rts_thresh;
+
+ /* U-APSD value, send with Association Request to WMM Enabled APs */
+ unsigned char wmm_bss_uapsd_mask;
+ /* The WMM capabilities of the selected BSS */
+ unsigned int bss_wmm_capabilities;
+
+ /* Flag to prevent a join when the ssid is set */
+ int disable_join_on_ssid_set;
+
+ /* Scan info */
+#define UNIFI_MAX_SCANS 32
+ scan_info_t scan_list[UNIFI_MAX_SCANS];
+ int num_scan_info;
+
+ /* Flag on whether non-802.1x packets are allowed out */
+/* CsrWifiRouterPortAction block_controlled_port;*/
+
+ /* Flag on whether we have completed an authenticate/associate process */
+ unsigned int flag_associated : 1;
+}; /* struct wext_config */
+
+#endif /* CSR_SUPPORT_WEXT */
+
+
+/*
+ * wext.c
+ */
+/*int mlme_set_protection(unifi_priv_t *priv, unsigned char *addr,
+ CSR_PROTECT_TYPE prot, CSR_KEY_TYPE key_type);
+*/
+
+/*
+ * scan.c
+ */
+/*
+void unifi_scan_indication_handler(unifi_priv_t *priv,
+ const CSR_MLME_SCAN_INDICATION *msg,
+ const unsigned char *extra,
+ unsigned int len);
+*/
+void unifi_clear_scan_table(unifi_priv_t *priv);
+scan_info_t *unifi_get_scan_report(unifi_priv_t *priv, int index);
+
+
+/*
+ * Utility functions
+ */
+const unsigned char *unifi_find_info_element(int id,
+ const unsigned char *info,
+ int len);
+int unifi_add_info_element(unsigned char *info,
+ int ie_id,
+ const unsigned char *ie_data,
+ int ie_len);
+
+/*
+ * autojoin.c
+ */
+/* Higher level fns */
+int unifi_autojoin(unifi_priv_t *priv, const char *ssid);
+/*
+int unifi_do_scan(unifi_priv_t *priv, int scantype, CSR_BSS_TYPE bsstype,
+ const char *ssid, int ssid_len);
+*/
+int unifi_set_powermode(unifi_priv_t *priv);
+int unifi_join_ap(unifi_priv_t *priv, scan_info_t *si);
+int unifi_join_bss(unifi_priv_t *priv, unsigned char *macaddr);
+int unifi_leave(unifi_priv_t *priv);
+unsigned int unifi_get_wmm_bss_capabilities(unifi_priv_t *priv,
+ unsigned char *ie_vector,
+ int ie_len, int *ap_capabilities);
+
+/*
+ * Status and management.
+ */
+int uf_init_wext_interface(unifi_priv_t *priv);
+void uf_deinit_wext_interface(unifi_priv_t *priv);
+
+/*
+ * Function to reset UniFi's 802.11 state by sending MLME-RESET.req
+ */
+int unifi_reset_state(unifi_priv_t *priv, unsigned char *macaddr, unsigned char set_default_mib);
+
+
+/*
+ * mlme.c
+ */
+/* Abort an MLME operation - useful in error recovery */
+int uf_abort_mlme(unifi_priv_t *priv);
+
+int unifi_mlme_blocking_request(unifi_priv_t *priv, ul_client_t *pcli,
+ CSR_SIGNAL *sig, bulk_data_param_t *data_ptrs,
+ int timeout);
+void unifi_mlme_copy_reply_and_wakeup_client(ul_client_t *pcli,
+ CSR_SIGNAL *signal, int signal_len,
+ const bulk_data_param_t *bulkdata);
+
+/*
+ * Utility functions
+ */
+const char *lookup_reason_code(int reason);
+const char *lookup_result_code(int result);
+
+
+/*
+ * sme_native.c
+ */
+int uf_sme_init(unifi_priv_t *priv);
+void uf_sme_deinit(unifi_priv_t *priv);
+int sme_sys_suspend(unifi_priv_t *priv);
+int sme_sys_resume(unifi_priv_t *priv);
+int sme_mgt_wifi_on(unifi_priv_t *priv);
+
+/* Callback for event logging to SME clients (unifi_manager) */
+void sme_native_log_event(ul_client_t *client,
+ const u8 *sig_packed, int sig_len,
+ const bulk_data_param_t *bulkdata,
+ int dir);
+
+void sme_native_mlme_event_handler(ul_client_t *pcli,
+ const u8 *sig_packed, int sig_len,
+ const bulk_data_param_t *bulkdata,
+ int dir);
+
+/* Task to query statistics from the MIB */
+#define UF_SME_STATS_WQ_TIMEOUT 2000 /* in msecs */
+void uf_sme_stats_wq(struct work_struct *work);
+
+void uf_native_process_udi_signal(ul_client_t *pcli,
+ const u8 *packed_signal,
+ int packed_signal_len,
+ const bulk_data_param_t *bulkdata, int dir);
+#if 0
+/*
+ * Choose one of these if available in linux/if_arp.h:
+ * #define UNIFI_SNIFF_ARPHRD ARPHRD_IEEE80211_RADIOTAP
+ * #define UNIFI_SNIFF_ARPHRD ARPHRD_IEEE80211_PRISM
+ *
+ * Radiotap is the newer standard for softmac WLAN devices, it works with
+ * Wireshark but not Ethereal (due to a bug in the Ethereal dissector).
+ * Prism is an older (less desirable) format but it does work with Ethereal.
+ */
+#ifdef ARPHRD_IEEE80211_RADIOTAP
+#define UNIFI_SNIFF_ARPHRD ARPHRD_IEEE80211_RADIOTAP
+#else
+#ifdef ARPHRD_IEEE80211_PRISM
+#define UNIFI_SNIFF_ARPHRD ARPHRD_IEEE80211_PRISM
+#endif
+#endif
+#endif
+
+#ifdef UNIFI_SNIFF_ARPHRD
+/*
+ * monitor.c
+ */
+int uf_start_sniff(unifi_priv_t *priv);
+/*
+void ma_sniffdata_ind(void *ospriv,
+ const CSR_MA_SNIFFDATA_INDICATION *ind,
+ const bulk_data_param_t *bulkdata);
+*/
+#endif /* ARPHRD_IEEE80211_PRISM */
+
+#endif /* __LINUX_UNIFI_NATIVE_H__ */
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * FILE: os_linux/unifi_os.h
+ *
+ * PURPOSE:
+ * This header file provides the OS-dependent facilities for a linux
+ * environment.
+ *
+ * Copyright (C) 2005-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#ifndef __UNIFI_OS_LINUX_H__
+#define __UNIFI_OS_LINUX_H__ 1
+
+#include <linux/kernel.h>
+#include <linux/time.h>
+#include <linux/list.h>
+#include <linux/delay.h>
+#include <linux/string.h>
+
+/*
+ * Needed for core/signals.c
+ */
+#include <stddef.h>
+
+
+/* Define INLINE directive*/
+#define INLINE inline
+
+/* Malloc and free */
+CsrResult unifi_net_data_malloc(void *ospriv, bulk_data_desc_t *bulk_data_slot, unsigned int size);
+void unifi_net_data_free(void *ospriv, bulk_data_desc_t *bulk_data_slot);
+#define CSR_WIFI_ALIGN_BYTES 4
+CsrResult unifi_net_dma_align(void *ospriv, bulk_data_desc_t *bulk_data_slot);
+
+/*
+ * Byte Order
+ * Note that __le*_to_cpu and __cpu_to_le* return an unsigned value!
+ */
+#ifdef __KERNEL__
+#define unifi2host_16(n) (__le16_to_cpu((n)))
+#define unifi2host_32(n) (__le32_to_cpu((n)))
+#define host2unifi_16(n) (__cpu_to_le16((n)))
+#define host2unifi_32(n) (__cpu_to_le32((n)))
+#endif
+
+/* Module parameters */
+extern int unifi_debug;
+
+/* debugging */
+#ifdef UNIFI_DEBUG
+/*
+ * unifi_debug is a verbosity level for debug messages
+ * UDBG0 msgs are always printed if UNIFI_DEBUG is defined
+ * UDBG1 msgs are printed if UNIFI_DEBUG is defined and unifi_debug > 0
+ * etc.
+ */
+
+#define func_enter() \
+ do { \
+ if (unifi_debug >= 5) { \
+ printk("unifi: => %s\n", __FUNCTION__); \
+ } \
+ } while (0)
+#define func_exit() \
+ do { \
+ if (unifi_debug >= 5) { \
+ printk("unifi: <= %s\n", __FUNCTION__); \
+ } \
+ } while (0)
+#define func_exit_r(_rc) \
+ do { \
+ if (unifi_debug >= 5) { \
+ printk("unifi: <= %s %d\n", __FUNCTION__, (int)(_rc)); \
+ } \
+ } while (0)
+
+
+#define ASSERT(cond) \
+ do { \
+ if (!(cond)) { \
+ printk("Assertion failed in %s at %s:%d: %s\n", \
+ __FUNCTION__, __FILE__, __LINE__, #cond); \
+ } \
+ } while (0)
+
+
+void unifi_dump(void *ospriv, int lvl, const char *msg, void *mem, CsrUint16 len);
+void dump(void *mem, CsrUint16 len);
+void dump16(void *mem, CsrUint16 len);
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+void dump_str(void *mem, CsrUint16 len);
+#endif /* CSR_WIFI_HIP_DEBUG_OFFLINE */
+
+void unifi_error(void* ospriv, const char *fmt, ...);
+void unifi_warning(void* ospriv, const char *fmt, ...);
+void unifi_notice(void* ospriv, const char *fmt, ...);
+void unifi_info(void* ospriv, const char *fmt, ...);
+
+void unifi_trace(void* ospriv, int level, const char *fmt, ...);
+
+#else
+
+/* Stubs */
+#define func_enter()
+#define func_exit()
+#define func_exit_r(_rc)
+
+#define ASSERT(cond)
+
+static inline void unifi_dump(void *ospriv, int lvl, const char *msg, void *mem, CsrUint16 len) {}
+static inline void dump(void *mem, CsrUint16 len) {}
+static inline void dump16(void *mem, CsrUint16 len) {}
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+static inline void dump_str(void *mem, CsrUint16 len) {}
+#endif /* CSR_WIFI_HIP_DEBUG_OFFLINE */
+
+void unifi_error_nop(void* ospriv, const char *fmt, ...);
+void unifi_trace_nop(void* ospriv, int level, const char *fmt, ...);
+#define unifi_error if(1);else unifi_error_nop
+#define unifi_warning if(1);else unifi_error_nop
+#define unifi_notice if(1);else unifi_error_nop
+#define unifi_info if(1);else unifi_error_nop
+#define unifi_trace if(1);else unifi_trace_nop
+
+#endif /* UNIFI_DEBUG */
+
+
+/* Different levels of diagnostic detail... */
+#define UDBG0 0 /* always prints in debug build */
+#define UDBG1 1
+#define UDBG2 2
+#define UDBG3 3
+#define UDBG4 4
+#define UDBG5 5
+#define UDBG6 6
+#define UDBG7 7
+
+
+#endif /* __UNIFI_OS_LINUX_H__ */
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: unifi_pdu_processing.c
+ *
+ * PURPOSE:
+ * This file provides the PDU handling functionality before it gets sent to unfi and after
+ * receiving a PDU from unifi
+ *
+ * Copyright (C) 2010 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+
+
+#include <linux/types.h>
+#include <linux/etherdevice.h>
+#include <linux/vmalloc.h>
+
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_conversions.h"
+#include "csr_time.h"
+#include "unifi_priv.h"
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,13)
+#include <net/iw_handler.h>
+#endif
+#include <net/pkt_sched.h>
+
+#ifdef CSR_SUPPORT_SME
+static void _update_buffered_pkt_params_after_alignment(unifi_priv_t *priv, bulk_data_param_t *bulkdata,
+ tx_buffered_packets_t* buffered_pkt)
+{
+ struct sk_buff *skb ;
+ CsrUint32 align_offset;
+
+ if (priv == NULL || bulkdata == NULL || buffered_pkt == NULL){
+ return;
+ }
+
+ skb = (struct sk_buff*)bulkdata->d[0].os_net_buf_ptr;
+ align_offset = (CsrUint32)(long)(bulkdata->d[0].os_data_ptr) & (CSR_WIFI_ALIGN_BYTES-1);
+ if(align_offset){
+ skb_pull(skb,align_offset);
+ }
+
+ buffered_pkt->bulkdata.os_data_ptr = bulkdata->d[0].os_data_ptr;
+ buffered_pkt->bulkdata.data_length = bulkdata->d[0].data_length;
+ buffered_pkt->bulkdata.os_net_buf_ptr = bulkdata->d[0].os_net_buf_ptr;
+ buffered_pkt->bulkdata.net_buf_length = bulkdata->d[0].net_buf_length;
+}
+#endif
+
+void
+unifi_frame_ma_packet_req(unifi_priv_t *priv, CSR_PRIORITY priority,
+ CSR_RATE TransmitRate, CSR_CLIENT_TAG hostTag,
+ CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
+ CSR_PROCESS_ID leSenderProcessId, CsrUint8 *peerMacAddress,
+ CSR_SIGNAL *signal)
+{
+
+ CSR_MA_PACKET_REQUEST *req = &signal->u.MaPacketRequest;
+ netInterface_priv_t *interfacePriv;
+ CsrUint8 ba_session_idx = 0;
+ ba_session_tx_struct *ba_session = NULL;
+ CsrUint8 *ba_addr = NULL;
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ UF_TRACE_MAC(priv, UDBG5, "In unifi_frame_ma_packet_req, Frame for Peer:", peerMacAddress);
+ signal->SignalPrimitiveHeader.SignalId = CSR_MA_PACKET_REQUEST_ID;
+ signal->SignalPrimitiveHeader.ReceiverProcessId = 0;
+ signal->SignalPrimitiveHeader.SenderProcessId = leSenderProcessId;
+
+ /* Fill the MA-PACKET.req */
+ req->Priority = priority;
+ unifi_trace(priv, UDBG3, "Tx Frame with Priority: 0x%x\n", req->Priority);
+
+ /* A value of 0 is used for auto selection of rates. But for P2P GO case
+ * for action frames the rate is governed by SME. Hence instead of 0,
+ * the rate is filled in with the value passed here
+ */
+ req->TransmitRate = TransmitRate;
+
+ /* packets from netdev then no confirm required but packets from
+ * Nme/Sme eapol data frames requires the confirmation
+ */
+ req->TransmissionControl = transmissionControl;
+ req->VirtualInterfaceIdentifier =
+ uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag);
+ memcpy(req->Ra.x, peerMacAddress, ETH_ALEN);
+
+ if (hostTag == 0xffffffff) {
+ req->HostTag = interfacePriv->tag++;
+ req->HostTag |= 0x40000000;
+ unifi_trace(priv, UDBG3, "new host tag assigned = 0x%x\n", req->HostTag);
+ interfacePriv->tag &= 0x0fffffff;
+ } else {
+ req->HostTag = hostTag;
+ unifi_trace(priv, UDBG3, "host tag got from SME = 0x%x\n", req->HostTag);
+ }
+ /* check if BA session exists for the peer MAC address on same tID */
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO){
+ ba_addr = peerMacAddress;
+ }else{
+ ba_addr = interfacePriv->bssid.a;
+ }
+ for (ba_session_idx=0; ba_session_idx < MAX_SUPPORTED_BA_SESSIONS_TX; ba_session_idx++){
+ ba_session = interfacePriv->ba_session_tx[ba_session_idx];
+ if (ba_session){
+ if ((!memcmp(ba_session->macAddress.a, ba_addr, ETH_ALEN)) && (ba_session->tID == priority)){
+ req->TransmissionControl |= CSR_ALLOW_BA;
+ break;
+ }
+ }
+ }
+
+ unifi_trace(priv, UDBG5, "leaving unifi_frame_ma_packet_req\n");
+}
+
+#ifdef CSR_SUPPORT_SME
+
+#define TRANSMISSION_CONTROL_TRIGGER_MASK 0x0001
+#define TRANSMISSION_CONTROL_EOSP_MASK 0x0002
+
+static
+int frame_and_send_queued_pdu(unifi_priv_t* priv,tx_buffered_packets_t* buffered_pkt,
+ CsrWifiRouterCtrlStaInfo_t *staRecord,CsrBool moreData , CsrBool eosp)
+{
+
+ CSR_SIGNAL signal;
+ bulk_data_param_t bulkdata;
+ int result;
+ CsrUint8 toDs, fromDs, macHeaderLengthInBytes = MAC_HEADER_SIZE;
+ CsrUint8 *qc;
+ CsrUint16 *fc = (CsrUint16*)(buffered_pkt->bulkdata.os_data_ptr);
+ unsigned long lock_flags;
+ unifi_trace(priv, UDBG3, "frame_and_send_queued_pdu with moreData: %d , EOSP: %d\n",moreData,eosp);
+ unifi_frame_ma_packet_req(priv, buffered_pkt->priority, buffered_pkt->rate, buffered_pkt->hostTag,
+ buffered_pkt->interfaceTag, buffered_pkt->transmissionControl,
+ buffered_pkt->leSenderProcessId, buffered_pkt->peerMacAddress.a, &signal);
+ bulkdata.d[0].os_data_ptr = buffered_pkt->bulkdata.os_data_ptr;
+ bulkdata.d[0].data_length = buffered_pkt->bulkdata.data_length;
+ bulkdata.d[0].os_net_buf_ptr = buffered_pkt->bulkdata.os_net_buf_ptr;
+ bulkdata.d[0].net_buf_length = buffered_pkt->bulkdata.net_buf_length;
+ bulkdata.d[1].os_data_ptr = NULL;
+ bulkdata.d[1].data_length = 0;
+ bulkdata.d[1].os_net_buf_ptr =0;
+ bulkdata.d[1].net_buf_length =0;
+
+ if(moreData) {
+ *fc |= cpu_to_le16(IEEE802_11_FC_MOREDATA_MASK);
+ } else {
+ *fc &= cpu_to_le16(~IEEE802_11_FC_MOREDATA_MASK);
+ }
+
+ if((staRecord != NULL)&& (staRecord->wmmOrQosEnabled == TRUE))
+ {
+ unifi_trace(priv, UDBG3, "frame_and_send_queued_pdu WMM Enabled: %d \n",staRecord->wmmOrQosEnabled);
+
+ toDs = (*fc & cpu_to_le16(IEEE802_11_FC_TO_DS_MASK))?1 : 0;
+ fromDs = (*fc & cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK))? 1: 0;
+
+ switch(le16_to_cpu(*fc) & IEEE80211_FC_SUBTYPE_MASK)
+ {
+ case IEEE802_11_FC_TYPE_QOS_DATA & IEEE80211_FC_SUBTYPE_MASK:
+ case IEEE802_11_FC_TYPE_QOS_NULL & IEEE80211_FC_SUBTYPE_MASK:
+ /* If both are set then the Address4 exists (only for AP) */
+ if (fromDs && toDs) {
+ /* 6 is the size of Address4 field */
+ macHeaderLengthInBytes += (QOS_CONTROL_HEADER_SIZE + 6);
+ } else {
+ macHeaderLengthInBytes += QOS_CONTROL_HEADER_SIZE;
+ }
+
+ /* If order bit set then HT control field is the part of MAC header */
+ if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
+ macHeaderLengthInBytes += HT_CONTROL_HEADER_SIZE;
+ qc = (CsrUint8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-6));
+ } else {
+ qc = (CsrUint8*)(buffered_pkt->bulkdata.os_data_ptr + (macHeaderLengthInBytes-2));
+ }
+ *qc = eosp ? *qc | (1 << 4) : *qc & (~(1 << 4));
+ break;
+ default:
+ if (fromDs && toDs)
+ macHeaderLengthInBytes += 6;
+ }
+
+ }
+ result = ul_send_signal_unpacked(priv, &signal, &bulkdata);
+ if(result){
+ _update_buffered_pkt_params_after_alignment(priv, &bulkdata,buffered_pkt);
+ }
+
+ /* Decrement the packet counts queued in driver */
+ if (result != -ENOSPC) {
+ /* protect entire counter updation by disabling preemption */
+ if (!priv->noOfPktQueuedInDriver) {
+ unifi_error(priv, "packets queued in driver 0 still decrementing\n");
+ } else {
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ priv->noOfPktQueuedInDriver--;
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ }
+ /* Sta Record is available for all unicast (except genericMgt Frames) & in other case its NULL */
+ if (staRecord) {
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ if (!staRecord->noOfPktQueued) {
+ unifi_error(priv, "packets queued in driver per station is 0 still decrementing\n");
+ } else {
+ staRecord->noOfPktQueued--;
+ }
+ /* if the STA alive probe frame has failed then reset the saved host tag */
+ if (result){
+ if (staRecord->nullDataHostTag == buffered_pkt->hostTag){
+ staRecord->nullDataHostTag = INVALID_HOST_TAG;
+ }
+ }
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ }
+
+ }
+ return result;
+}
+#ifdef CSR_SUPPORT_SME
+static
+void set_eosp_transmit_ctrl(unifi_priv_t *priv, struct list_head *txList)
+{
+ /* dequeue the tx data packets from the appropriate queue */
+ tx_buffered_packets_t *tx_q_item = NULL;
+ struct list_head *listHead;
+ struct list_head *placeHolder;
+ unsigned long lock_flags;
+
+
+ unifi_trace(priv, UDBG5, "entering set_eosp_transmit_ctrl\n");
+ /* check for list empty */
+ if (list_empty(txList)) {
+ unifi_warning(priv, "In set_eosp_transmit_ctrl, the list is empty\n");
+ return;
+ }
+
+ /* return the last node , and modify it. */
+
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_for_each_prev_safe(listHead, placeHolder, txList) {
+ tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
+ tx_q_item->transmissionControl |= TRANSMISSION_CONTROL_EOSP_MASK;
+ tx_q_item->transmissionControl = (tx_q_item->transmissionControl & ~(CSR_NO_CONFIRM_REQUIRED));
+ unifi_trace(priv, UDBG1,
+ "set_eosp_transmit_ctrl Transmission Control = 0x%x hostTag = 0x%x \n",tx_q_item->transmissionControl,tx_q_item->hostTag);
+ unifi_trace(priv,UDBG3,"in set_eosp_transmit_ctrl no.of buffered frames %d\n",priv->noOfPktQueuedInDriver);
+ break;
+ }
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ unifi_trace(priv, UDBG1,"List Empty %d\n",list_empty(txList));
+ unifi_trace(priv, UDBG5, "leaving set_eosp_transmit_ctrl\n");
+ return;
+}
+
+static
+void send_vif_availibility_rsp(unifi_priv_t *priv,CSR_VIF_IDENTIFIER vif,CSR_RESULT_CODE resultCode)
+{
+ CSR_SIGNAL signal;
+ CSR_MA_VIF_AVAILABILITY_RESPONSE *rsp;
+ bulk_data_param_t *bulkdata = NULL;
+ int r;
+
+ unifi_trace(priv, UDBG3, "send_vif_availibility_rsp : invoked with resultCode = %d \n", resultCode);
+
+ memset(&signal,0,sizeof(CSR_SIGNAL));
+ rsp = &signal.u.MaVifAvailabilityResponse;
+ rsp->VirtualInterfaceIdentifier = vif;
+ rsp->ResultCode = resultCode;
+ signal.SignalPrimitiveHeader.SignalId = CSR_MA_VIF_AVAILABILITY_RESPONSE_ID;
+ signal.SignalPrimitiveHeader.ReceiverProcessId = 0;
+ signal.SignalPrimitiveHeader.SenderProcessId = priv->netdev_client->sender_id;
+
+ /* Send the signal to UniFi */
+ r = ul_send_signal_unpacked(priv, &signal, bulkdata);
+ if(r) {
+ unifi_error(priv,"Availibility response sending failed %x status %d\n",vif,r);
+ }
+ else {
+ unifi_trace(priv, UDBG3, "send_vif_availibility_rsp : status = %d \n", r);
+ }
+}
+#endif
+
+static
+void verify_and_accomodate_tx_packet(unifi_priv_t *priv)
+{
+ tx_buffered_packets_t *tx_q_item;
+ unsigned long lock_flags;
+ struct list_head *listHead, *list;
+ struct list_head *placeHolder;
+ CsrUint8 i, j,eospFramedeleted=0;
+ CsrBool thresholdExcedeDueToBroadcast = TRUE;
+ /* it will be made it interface Specific in the future when multi interfaces are supported ,
+ right now interface 0 is considered */
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[0];
+ CsrWifiRouterCtrlStaInfo_t *staInfo = NULL;
+
+ unifi_trace(priv, UDBG3, "entering verify_and_accomodate_tx_packet\n");
+
+ for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ staInfo = interfacePriv->staInfo[i];
+ if (staInfo && (staInfo->noOfPktQueued >= CSR_WIFI_DRIVER_MAX_PKT_QUEUING_THRESHOLD_PER_PEER)) {
+ /* remove the first(oldest) packet from the all the access catogory, since data
+ * packets for station record crossed the threshold limit (64 for AP supporting
+ * 8 peers)
+ */
+ unifi_trace(priv,UDBG3,"number of station pkts queued= %d for sta id = %d\n", staInfo->noOfPktQueued, staInfo->aid);
+ for(j = 0; j < MAX_ACCESS_CATOGORY; j++) {
+ list = &staInfo->dataPdu[j];
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_for_each_safe(listHead, placeHolder, list) {
+ tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
+ list_del(listHead);
+ thresholdExcedeDueToBroadcast = FALSE;
+ unifi_net_data_free(priv, &tx_q_item->bulkdata);
+ kfree(tx_q_item);
+ tx_q_item = NULL;
+ if (!priv->noOfPktQueuedInDriver) {
+ unifi_error(priv, "packets queued in driver 0 still decrementing in %s\n", __FUNCTION__);
+ } else {
+ /* protection provided by spinlock */
+ priv->noOfPktQueuedInDriver--;
+
+ }
+ /* Sta Record is available for all unicast (except genericMgt Frames) & in other case its NULL */
+ if (!staInfo->noOfPktQueued) {
+ unifi_error(priv, "packets queued in driver per station is 0 still decrementing in %s\n", __FUNCTION__);
+ } else {
+ spin_lock(&priv->staRecord_lock);
+ staInfo->noOfPktQueued--;
+ spin_unlock(&priv->staRecord_lock);
+ }
+ break;
+ }
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ }
+ }
+ }
+ if (thresholdExcedeDueToBroadcast && interfacePriv->noOfbroadcastPktQueued > CSR_WIFI_DRIVER_MINIMUM_BROADCAST_PKT_THRESHOLD ) {
+ /* Remove the packets from genericMulticastOrBroadCastFrames queue
+ * (the max packets in driver is reached due to broadcast/multicast frames)
+ */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_for_each_safe(listHead, placeHolder, &interfacePriv->genericMulticastOrBroadCastFrames) {
+ tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
+ if(eospFramedeleted){
+ tx_q_item->transmissionControl |= TRANSMISSION_CONTROL_EOSP_MASK;
+ tx_q_item->transmissionControl = (tx_q_item->transmissionControl & ~(CSR_NO_CONFIRM_REQUIRED));
+ unifi_trace(priv, UDBG1,"updating eosp for next packet hostTag:= 0x%x ",tx_q_item->hostTag);
+ eospFramedeleted =0;
+ break;
+ }
+
+ if(tx_q_item->transmissionControl & TRANSMISSION_CONTROL_EOSP_MASK ){
+ eospFramedeleted = 1;
+ }
+ unifi_trace(priv,UDBG1, "freeing of multicast packets ToC = 0x%x hostTag = 0x%x \n",tx_q_item->transmissionControl,tx_q_item->hostTag);
+ list_del(listHead);
+ unifi_net_data_free(priv, &tx_q_item->bulkdata);
+ kfree(tx_q_item);
+ priv->noOfPktQueuedInDriver--;
+ spin_lock(&priv->staRecord_lock);
+ interfacePriv->noOfbroadcastPktQueued--;
+ spin_unlock(&priv->staRecord_lock);
+ if(!eospFramedeleted){
+ break;
+ }
+ }
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ }
+ unifi_trace(priv, UDBG3, "leaving verify_and_accomodate_tx_packet\n");
+}
+
+static
+CsrResult enque_tx_data_pdu(unifi_priv_t *priv, bulk_data_param_t *bulkdata,
+ struct list_head *list, CSR_SIGNAL *signal,
+ CsrBool requeueOnSamePos)
+{
+
+ /* queue the tx data packets on to appropriate queue */
+ CSR_MA_PACKET_REQUEST *req = &signal->u.MaPacketRequest;
+ tx_buffered_packets_t *tx_q_item;
+ unsigned long lock_flags;
+
+ unifi_trace(priv, UDBG5, "entering enque_tx_data_pdu\n");
+ if(!list) {
+ unifi_error(priv,"List is not specified\n");
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Removes aged packets & adds the incoming packet */
+ if (priv->noOfPktQueuedInDriver >= CSR_WIFI_DRIVER_SUPPORT_FOR_MAX_PKT_QUEUEING) {
+ unifi_trace(priv,UDBG3,"number of pkts queued= %d \n", priv->noOfPktQueuedInDriver);
+ verify_and_accomodate_tx_packet(priv);
+ }
+
+
+
+ tx_q_item = (tx_buffered_packets_t *)kmalloc(sizeof(tx_buffered_packets_t), GFP_ATOMIC);
+ if (tx_q_item == NULL) {
+ unifi_error(priv,
+ "Failed to allocate %d bytes for tx packet record\n",
+ sizeof(tx_buffered_packets_t));
+ func_exit();
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* disable the preemption */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ INIT_LIST_HEAD(&tx_q_item->q);
+ /* fill the tx_q structure members */
+ tx_q_item->bulkdata.os_data_ptr = bulkdata->d[0].os_data_ptr;
+ tx_q_item->bulkdata.data_length = bulkdata->d[0].data_length;
+ tx_q_item->bulkdata.os_net_buf_ptr = bulkdata->d[0].os_net_buf_ptr;
+ tx_q_item->bulkdata.net_buf_length = bulkdata->d[0].net_buf_length;
+ tx_q_item->interfaceTag = req->VirtualInterfaceIdentifier & 0xff;
+ tx_q_item->hostTag = req->HostTag;
+ tx_q_item->leSenderProcessId = signal->SignalPrimitiveHeader.SenderProcessId;
+ tx_q_item->transmissionControl = req->TransmissionControl;
+ tx_q_item->priority = req->Priority;
+ tx_q_item->rate = req->TransmitRate;
+ memcpy(tx_q_item->peerMacAddress.a, req->Ra.x, ETH_ALEN);
+
+
+
+ if (requeueOnSamePos) {
+ list_add(&tx_q_item->q, list);
+ } else {
+ list_add_tail(&tx_q_item->q, list);
+ }
+
+ /* Count of packet queued in driver */
+ priv->noOfPktQueuedInDriver++;
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ unifi_trace(priv, UDBG5, "leaving enque_tx_data_pdu\n");
+ return CSR_RESULT_SUCCESS;
+}
+
+#ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
+CsrResult unifi_reque_ma_packet_request (void *ospriv, CsrUint32 host_tag,
+ CsrUint16 txStatus, bulk_data_desc_t *bulkDataDesc)
+{
+ CsrResult status = CSR_RESULT_SUCCESS;
+ unifi_priv_t *priv = (unifi_priv_t*)ospriv;
+ netInterface_priv_t *interfacePriv;
+ struct list_head *list = NULL;
+ CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
+ bulk_data_param_t bulkData;
+ CSR_SIGNAL signal;
+ CSR_PRIORITY priority = 0;
+ CsrUint16 interfaceTag = 0;
+ unifi_TrafficQueue priority_q;
+ CsrUint16 frameControl = 0, frameType = 0;
+ unsigned long lock_flags;
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ /* If the current mode is not AP or P2PGO then just return failure
+ * to clear the hip slot
+ */
+ if(!((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP) ||
+ (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO))) {
+ return CSR_RESULT_FAILURE;
+ }
+
+ unifi_trace(priv, UDBG6, "unifi_reque_ma_packet_request: host_tag = 0x%x\n", host_tag);
+
+ staRecord = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,
+ (((CsrUint8 *) bulkDataDesc->os_data_ptr) + 4),
+ interfaceTag);
+ if (NULL == staRecord) {
+ unifi_trace(priv, UDBG5, "unifi_reque_ma_packet_request: Invalid STA record \n");
+ return CSR_RESULT_FAILURE;
+ }
+
+ /* Update TIM if MA-PACKET.cfm fails with status as Tx-retry-limit or No-BSS and then just return failure
+ * to clear the hip slot associated with the Packet
+ */
+ if (CSR_TX_RETRY_LIMIT == txStatus || CSR_TX_NO_BSS == txStatus) {
+ if (staRecord->timSet == CSR_WIFI_TIM_RESET || staRecord->timSet == CSR_WIFI_TIM_RESETTING)
+ {
+ unifi_trace(priv, UDBG2, "unifi_reque_ma_packet_request: CFM failed with Retry Limit or No BSS-->update TIM\n");
+ if (!staRecord->timRequestPendingFlag) {
+ update_tim(priv, staRecord->aid, 1, interfaceTag, staRecord->assignedHandle);
+ }
+ else {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ staRecord->updateTimReqQueued = 1;
+ unifi_trace(priv, UDBG6, "unifi_reque_ma_packet_request: One more UpdateTim Request(:%d)Queued for AID %x\n",
+ staRecord->updateTimReqQueued, staRecord->aid);
+ }
+ }
+ return CSR_RESULT_FAILURE;
+ }
+ else if ((CSR_TX_LIFETIME == txStatus) || (CSR_TX_BLOCK_ACK_TIMEOUT == txStatus) ||
+ (CSR_TX_FAIL_TRANSMISSION_VIF_INTERRUPTED == txStatus) ||
+ (CSR_TX_REJECTED_PEER_STATION_SLEEPING == txStatus) ||
+ (CSR_TX_REJECTED_DTIM_STARTED == txStatus)) {
+ /* Extract the Frame control and the frame type */
+ frameControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(bulkDataDesc->os_data_ptr);
+ frameType = ((frameControl & IEEE80211_FC_TYPE_MASK) >> FRAME_CONTROL_TYPE_FIELD_OFFSET);
+
+ /* Mgmt frames will not be re-queued for Tx
+ * so just return failure to clear the hip slot
+ */
+ if (IEEE802_11_FRAMETYPE_MANAGEMENT == frameType) {
+ return CSR_RESULT_FAILURE;
+ }
+ else if (IEEE802_11_FRAMETYPE_DATA == frameType) {
+ /* QOS NULL and DATA NULL frames will not be re-queued for Tx
+ * so just return failure to clear the hip slot
+ */
+ if ((((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> FRAME_CONTROL_SUBTYPE_FIELD_OFFSET) == QOS_DATA_NULL) ||
+ (((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> FRAME_CONTROL_SUBTYPE_FIELD_OFFSET)== DATA_NULL )) {
+ return CSR_RESULT_FAILURE;
+ }
+ }
+
+ /* Extract the Packet priority */
+ if (TRUE == staRecord->wmmOrQosEnabled) {
+ CsrUint16 qosControl = 0;
+ CsrUint8 dataFrameType = 0;
+
+ dataFrameType =((frameControl & IEEE80211_FC_SUBTYPE_MASK) >> 4);
+
+ if (dataFrameType == QOS_DATA) {
+ /* QoS control field is offset from frame control by 2 (frame control)
+ * + 2 (duration/ID) + 2 (sequence control) + 3*ETH_ALEN or 4*ETH_ALEN
+ */
+ if((frameControl & IEEE802_11_FC_TO_DS_MASK) && (frameControl & IEEE802_11_FC_FROM_DS_MASK)) {
+ qosControl= CSR_GET_UINT16_FROM_LITTLE_ENDIAN(bulkDataDesc->os_data_ptr + 30);
+ }
+ else {
+ qosControl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(bulkDataDesc->os_data_ptr + 24);
+ }
+ }
+
+ priority = (CSR_PRIORITY)(qosControl & IEEE802_11_QC_TID_MASK);
+
+ if (priority < CSR_QOS_UP0 || priority > CSR_QOS_UP7) {
+ unifi_trace(priv, UDBG5, "unifi_reque_ma_packet_request: Invalid priority:%x \n", priority);
+ return CSR_RESULT_FAILURE;
+ }
+ }
+ else {
+ priority = CSR_CONTENTION;
+ }
+
+ /* Frame Bulk data to requeue it back to HAL Queues */
+ bulkData.d[0].os_data_ptr = bulkDataDesc->os_data_ptr;
+ bulkData.d[0].data_length = bulkDataDesc->data_length;
+ bulkData.d[0].os_net_buf_ptr = bulkDataDesc->os_net_buf_ptr;
+ bulkData.d[0].net_buf_length = bulkDataDesc->net_buf_length;
+
+ bulkData.d[1].os_data_ptr = NULL;
+ bulkData.d[1].os_net_buf_ptr = NULL;
+ bulkData.d[1].data_length = bulkData.d[1].net_buf_length = 0;
+
+ /* Initialize signal to zero */
+ memset(&signal, 0, sizeof(CSR_SIGNAL));
+
+ /* Frame MA Packet Req */
+ unifi_frame_ma_packet_req(priv, priority, 0, host_tag,
+ interfaceTag, CSR_NO_CONFIRM_REQUIRED,
+ priv->netdev_client->sender_id,
+ staRecord->peerMacAddress.a, &signal);
+
+ /* Find the Q-Priority */
+ priority_q = unifi_frame_priority_to_queue(priority);
+ list = &staRecord->dataPdu[priority_q];
+
+ /* Place the Packet on to HAL Queue */
+ status = enque_tx_data_pdu(priv, &bulkData, list, &signal, TRUE);
+
+ /* Update the Per-station queued packet counter */
+ if (!status) {
+ spin_lock_irqsave(&priv->staRecord_lock, lock_flags);
+ staRecord->noOfPktQueued++;
+ spin_unlock_irqrestore(&priv->staRecord_lock, lock_flags);
+ }
+ }
+ else {
+ /* Packet will not be re-queued for any of the other MA Packet Tx failure
+ * reasons so just return failure to clear the hip slot
+ */
+ return CSR_RESULT_FAILURE;
+ }
+
+ return status;
+}
+#endif
+
+static void is_all_ac_deliver_enabled_and_moredata(CsrWifiRouterCtrlStaInfo_t *staRecord, CsrUint8 *allDeliveryEnabled, CsrUint8 *dataAvailable)
+{
+ CsrUint8 i;
+ *allDeliveryEnabled = TRUE;
+ for (i = 0 ;i < MAX_ACCESS_CATOGORY; i++) {
+ if (!IS_DELIVERY_ENABLED(staRecord->powersaveMode[i])) {
+ /* One is is not Delivery Enabled */
+ *allDeliveryEnabled = FALSE;
+ break;
+ }
+ }
+ if (*allDeliveryEnabled) {
+ *dataAvailable = (!list_empty(&staRecord->dataPdu[0]) || !list_empty(&staRecord->dataPdu[1])
+ ||!list_empty(&staRecord->dataPdu[2]) ||!list_empty(&staRecord->dataPdu[3])
+ ||!list_empty(&staRecord->mgtFrames));
+ }
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_handle_tim_cfm
+ *
+ *
+ * This function updates tim status in host depending confirm status from firmware
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * cfm CSR_MLME_SET_TIM_CONFIRM
+ * receiverProcessId SenderProcessID to fetch handle & timSet status
+ *
+ * ---------------------------------------------------------------------------
+ */
+void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, CsrUint16 receiverProcessId)
+{
+ CsrUint8 handle = CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId);
+ CsrUint8 timSetStatus = CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId);
+ CsrUint16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
+ /* This variable holds what TIM value we wanted to set in firmware */
+ CsrUint16 timSetValue = 0;
+ /* Irrespective of interface the count maintained */
+ static CsrUint8 retryCount = 0;
+ unsigned long lock_flags;
+ unifi_trace(priv, UDBG3, "entering %s, handle = %x, timSetStatus = %x\n", __FUNCTION__, handle, timSetStatus);
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_warning(priv, "bad interfaceTag = %x\n", interfaceTag);
+ return;
+ }
+
+ if ((handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) && (handle >= UNIFI_MAX_CONNECTIONS)) {
+ unifi_warning(priv, "bad station Handle = %x\n", handle);
+ return;
+ }
+
+ if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ if ((staRecord = ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[handle]))) == NULL) {
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ unifi_warning(priv, "uf_handle_tim_cfm: station record is NULL handle = %x\n", handle);
+ return;
+ }
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ }
+ switch(timSetStatus)
+ {
+ case CSR_WIFI_TIM_SETTING:
+ timSetValue = CSR_WIFI_TIM_SET;
+ break;
+ case CSR_WIFI_TIM_RESETTING:
+ timSetValue = CSR_WIFI_TIM_RESET;
+ break;
+ default:
+ unifi_warning(priv, "timSet state is %x: Debug\n", timSetStatus);
+ return;
+ }
+
+ /* check TIM confirm for success/failures */
+ switch(cfm->ResultCode)
+ {
+ case CSR_RC_SUCCESS:
+ if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
+ /* Unicast frame & station record available */
+ if (timSetStatus == staRecord->timSet) {
+ staRecord->timSet = timSetValue;
+ /* fh_cmd_q can also be full at some point of time!,
+ * resetting count as queue is cleaned by firmware at this point
+ */
+ retryCount = 0;
+ unifi_trace(priv, UDBG2, "tim (%s) successfully in firmware\n", (timSetValue)?"SET":"RESET");
+ } else {
+ unifi_trace(priv, UDBG3, "receiver processID = %x, success: request & confirm states are not matching in TIM cfm: Debug status = %x, staRecord->timSet = %x, handle = %x\n",
+ receiverProcessId, timSetStatus, staRecord->timSet, handle);
+ }
+
+ /* Reset TIM pending flag to send next TIM request */
+ staRecord->timRequestPendingFlag = FALSE;
+
+ /* Make sure that one more UpdateTim request is queued, if Queued its value
+ * should be CSR_WIFI_TIM_SET or CSR_WIFI_TIM_RESET
+ */
+ if (0xFF != staRecord->updateTimReqQueued)
+ {
+ /* Process the UpdateTim Request which is queued while previous UpdateTim was in progress */
+ if (staRecord->timSet != staRecord->updateTimReqQueued)
+ {
+ unifi_trace(priv, UDBG2, "uf_handle_tim_cfm : Processing Queued UpdateTimReq \n");
+
+ update_tim(priv, staRecord->aid, staRecord->updateTimReqQueued, interfaceTag, handle);
+
+ staRecord->updateTimReqQueued = 0xFF;
+ }
+ }
+ } else {
+
+ interfacePriv->bcTimSet = timSetValue;
+ /* fh_cmd_q can also be full at some point of time!,
+ * resetting count as queue is cleaned by firmware at this point
+ */
+ retryCount = 0;
+ unifi_trace(priv, UDBG3, "tim (%s) successfully for broadcast frame in firmware\n", (timSetValue)?"SET":"RESET");
+
+ /* Reset DTIM pending flag to send next DTIM request */
+ interfacePriv->bcTimSetReqPendingFlag = FALSE;
+
+ /* Make sure that one more UpdateDTim request is queued, if Queued its value
+ * should be CSR_WIFI_TIM_SET or CSR_WIFI_TIM_RESET
+ */
+ if (0xFF != interfacePriv->bcTimSetReqQueued)
+ {
+ /* Process the UpdateTim Request which is queued while previous UpdateTim was in progress */
+ if (interfacePriv->bcTimSet != interfacePriv->bcTimSetReqQueued)
+ {
+ unifi_trace(priv, UDBG2, "uf_handle_tim_cfm : Processing Queued UpdateDTimReq \n");
+
+ update_tim(priv, 0, interfacePriv->bcTimSetReqQueued, interfaceTag, 0xFFFFFFFF);
+
+ interfacePriv->bcTimSetReqQueued = 0xFF;
+ }
+ }
+
+ }
+ break;
+ case CSR_RC_INVALID_PARAMETERS:
+ case CSR_RC_INSUFFICIENT_RESOURCE:
+ /* check for max retry limit & send again
+ * MAX_RETRY_LIMIT is not maintained for each set of transactions..Its generic
+ * If failure crosses this Limit, we have to take a call to FIX
+ */
+ if (retryCount > UNIFI_MAX_RETRY_LIMIT) {
+ CsrBool moreData = FALSE;
+ retryCount = 0;
+ /* Because of continuos traffic in fh_cmd_q the tim set request is failing (exceeding retry limit)
+ * but if we didn't synchronize our timSet varible state with firmware then it can cause below issues
+ * cond 1. We want to SET tim in firmware if its fails & max retry limit reached
+ * -> If host set's the timSet to 1, we wont try to send(as max retry reached) update tim but
+ * firmware is not updated with queue(TIM) status so it wont set TIM in beacon finally host start piling
+ * up data & wont try to set tim in firmware (This can cause worser performance)
+ * cond 2. We want to reset tim in firmware it fails & reaches max retry limit
+ * -> If host sets the timSet to Zero, it wont try to set a TIM request unless we wont have any packets
+ * to be queued, so beacon unnecessarily advertizes the TIM
+ */
+
+ if(staRecord) {
+ if(!staRecord->wmmOrQosEnabled) {
+ moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
+ !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]) ||
+ !list_empty(&staRecord->mgtFrames));
+ } else {
+ /* Peer is QSTA */
+ CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+ /* Check if all AC's are Delivery Enabled */
+ is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
+ /*check for more data in non-delivery enabled queues*/
+ moreData = (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable));
+
+ }
+ /* To avoid cond 1 & 2, check internal Queues status, if we have more Data then set RESET the timSet(0),
+ * so we are trying to be in sync with firmware & next packets before queuing atleast try to
+ * set TIM in firmware otherwise it SET timSet(1)
+ */
+ if (moreData) {
+ staRecord->timSet = CSR_WIFI_TIM_RESET;
+ } else {
+ staRecord->timSet = CSR_WIFI_TIM_SET;
+ }
+ } else {
+ /* Its a broadcast frames */
+ moreData = (!list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) ||
+ !list_empty(&interfacePriv->genericMulticastOrBroadCastFrames));
+ if (moreData) {
+ update_tim(priv, 0, CSR_WIFI_TIM_SET, interfaceTag, 0xFFFFFFFF);
+ } else {
+ update_tim(priv, 0, CSR_WIFI_TIM_RESET, interfaceTag, 0xFFFFFFFF);
+ }
+ }
+
+ unifi_error(priv, "no of error's for TIM setting crossed the Limit: verify\n");
+ return;
+ }
+ retryCount++;
+
+ if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
+ if (timSetStatus == staRecord->timSet) {
+ unifi_warning(priv, "tim request failed, retry for AID = %x\n", staRecord->aid);
+ update_tim(priv, staRecord->aid, timSetValue, interfaceTag, handle);
+ } else {
+ unifi_trace(priv, UDBG1, "failure: request & confirm states are not matching in TIM cfm: Debug status = %x, staRecord->timSet = %x\n",
+ timSetStatus, staRecord->timSet);
+ }
+ } else {
+ unifi_warning(priv, "tim request failed, retry for broadcast frames\n");
+ update_tim(priv, 0, timSetValue, interfaceTag, 0xFFFFFFFF);
+ }
+ break;
+ default:
+ unifi_warning(priv, "tim update request failed resultcode = %x\n", cfm->ResultCode);
+ }
+
+ unifi_trace(priv, UDBG2, "leaving %s\n", __FUNCTION__);
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * update_tim
+ *
+ *
+ * This function updates tim status in firmware for AID[1 to UNIFI_MAX_CONNECTIONS] or
+ * AID[0] for broadcast/multicast packets.
+ *
+ * NOTE: The LSB (least significant BYTE) of senderId while sending this MLME premitive
+ * has been modified(utilized) as below
+ *
+ * SenderID in signal's SignalPrimitiveHeader is 2 byte the lowe byte bitmap is below
+ *
+ * station handle(6 bits) timSet Status (2 bits)
+ * --------------------- ----------------------
+ * 0 0 0 0 0 0 | 0 0
+ *
+ * timSet Status can be one of below:
+ *
+ * CSR_WIFI_TIM_RESET
+ * CSR_WIFI_TIM_RESETTING
+ * CSR_WIFI_TIM_SET
+ * CSR_WIFI_TIM_SETTING
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * aid can be 1 t0 UNIFI_MAX_CONNECTIONS & 0 means multicast/broadcast
+ * setTim value SET(1) / RESET(0)
+ * interfaceTag the interfaceID on which activity going on
+ * handle from (0 <= handle < UNIFI_MAX_CONNECTIONS)
+ *
+ * ---------------------------------------------------------------------------
+ */
+void update_tim(unifi_priv_t * priv, CsrUint16 aid, CsrUint8 setTim, CsrUint16 interfaceTag, CsrUint32 handle)
+{
+ CSR_SIGNAL signal;
+ CsrInt32 r;
+ CSR_MLME_SET_TIM_REQUEST *req = &signal.u.MlmeSetTimRequest;
+ bulk_data_param_t *bulkdata = NULL;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ CsrUint8 senderIdLsb = 0;
+ CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
+ CsrUint32 oldTimSetStatus = 0, timSetStatus = 0;
+
+ unifi_trace(priv, UDBG5, "entering the update_tim routine\n");
+
+
+ if (handle == 0xFFFFFFFF) {
+ handle &= CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE;
+ if (setTim == interfacePriv->bcTimSet)
+ {
+ unifi_trace(priv, UDBG3, "update_tim, Drop:Hdl=%x, timval=%d, globalTim=%d\n", handle, setTim, interfacePriv->bcTimSet);
+ return;
+ }
+ } else if ((handle != 0xFFFFFFFF) && (handle >= UNIFI_MAX_CONNECTIONS)) {
+ unifi_warning(priv, "bad station Handle = %x\n", handle);
+ return;
+ }
+
+ if (setTim) {
+ timSetStatus = CSR_WIFI_TIM_SETTING;
+ } else {
+ timSetStatus = CSR_WIFI_TIM_RESETTING;
+ }
+
+ if (handle != CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE) {
+ if ((staRecord = ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[handle]))) == NULL) {
+ unifi_warning(priv, "station record is NULL in update_tim: handle = %x :debug\n", handle);
+ return;
+ }
+ /* In case of signal sending failed, revert back to old state */
+ oldTimSetStatus = staRecord->timSet;
+ staRecord->timSet = timSetStatus;
+ }
+
+ /* pack senderID LSB */
+ senderIdLsb = CSR_WIFI_PACK_SENDER_ID_LSB_FOR_TIM_REQ(handle, timSetStatus);
+
+ /* initialize signal to zero */
+ memset(&signal, 0, sizeof(CSR_SIGNAL));
+
+ /* Frame the MLME-SET-TIM request */
+ signal.SignalPrimitiveHeader.SignalId = CSR_MLME_SET_TIM_REQUEST_ID;
+ signal.SignalPrimitiveHeader.ReceiverProcessId = 0;
+ CSR_COPY_UINT16_TO_LITTLE_ENDIAN(((priv->netdev_client->sender_id & 0xff00) | senderIdLsb),
+ (u8*)&signal.SignalPrimitiveHeader.SenderProcessId);
+
+ /* set The virtual interfaceIdentifier, aid, tim value */
+ req->VirtualInterfaceIdentifier = uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag);
+ req->AssociationId = aid;
+ req->TimValue = setTim;
+
+
+ unifi_trace(priv, UDBG2, "update_tim:AID %x,senderIdLsb = 0x%x, handle = 0x%x, timSetStatus = %x, sender proceesID = %x \n",
+ aid,senderIdLsb, handle, timSetStatus, signal.SignalPrimitiveHeader.SenderProcessId);
+
+ /* Send the signal to UniFi */
+ r = ul_send_signal_unpacked(priv, &signal, bulkdata);
+ if (r) {
+ /* No need to free bulk data, as TIM request doesn't carries any data */
+ unifi_error(priv, "Error queueing CSR_MLME_SET_TIM_REQUEST signal\n");
+ if (staRecord) {
+ staRecord->timSet = oldTimSetStatus ;
+ }
+ else
+ {
+ /* MLME_SET_TIM.req sending failed here for AID0, so revert back our bcTimSet status */
+ interfacePriv->bcTimSet = !setTim;
+ }
+ }
+ else {
+ /* Update tim request pending flag and ensure no more TIM set requests are send
+ for the same station until TIM confirm is received */
+ if (staRecord) {
+ staRecord->timRequestPendingFlag = TRUE;
+ }
+ else
+ {
+ /* Update tim request (for AID 0) pending flag and ensure no more DTIM set requests are send
+ * for the same station until TIM confirm is received
+ */
+ interfacePriv->bcTimSetReqPendingFlag = TRUE;
+ }
+ }
+ unifi_trace(priv, UDBG5, "leaving the update_tim routine\n");
+}
+
+static
+void process_peer_active_transition(unifi_priv_t * priv,
+ CsrWifiRouterCtrlStaInfo_t *staRecord,
+ CsrUint16 interfaceTag)
+{
+ int r,i;
+ CsrBool spaceAvail[4] = {TRUE,TRUE,TRUE,TRUE};
+ tx_buffered_packets_t * buffered_pkt = NULL;
+ unsigned long lock_flags;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ unifi_trace(priv, UDBG5, "entering process_peer_active_transition\n");
+
+ if(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
+ /* giving more priority to multicast packets so delaying unicast packets*/
+ unifi_trace(priv,UDBG2, "Multicast transmission is going on so resume unicast transmission after DTIM over\n");
+
+ /* As station is active now, even though AP is not able to send frames to it
+ * because of DTIM, it needs to reset the TIM here
+ */
+ if (!staRecord->timRequestPendingFlag){
+ if((staRecord->timSet == CSR_WIFI_TIM_SET) || (staRecord->timSet == CSR_WIFI_TIM_SETTING)){
+ update_tim(priv, staRecord->aid, 0, interfaceTag, staRecord->assignedHandle);
+ }
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ staRecord->updateTimReqQueued = 0;
+ unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
+ staRecord->aid);
+ }
+ return;
+ }
+ while((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->mgtFrames))) {
+ buffered_pkt->transmissionControl &=
+ ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,0,FALSE)) == -ENOSPC) {
+ unifi_trace(priv, UDBG2, "p_p_a_t:(ENOSPC) Mgt Frame queueing \n");
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &staRecord->mgtFrames);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ priv->pausedStaHandle[3]=(CsrUint8)(staRecord->assignedHandle);
+ spaceAvail[3] = FALSE;
+ break;
+ } else {
+ if(r){
+ unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ }
+ if (!staRecord->timRequestPendingFlag) {
+ if (staRecord->txSuspend) {
+ if(staRecord->timSet == CSR_WIFI_TIM_SET) {
+ update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
+ }
+ return;
+ }
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ staRecord->updateTimReqQueued = 0;
+ unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
+ staRecord->aid);
+ }
+ for(i=3;i>=0;i--) {
+ if(!spaceAvail[i])
+ continue;
+ unifi_trace(priv, UDBG6, "p_p_a_t:data pkt sending for AC %d \n",i);
+ while((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[i]))) {
+ buffered_pkt->transmissionControl &=
+ ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,0,FALSE)) == -ENOSPC) {
+ /* Clear the trigger bit transmission control*/
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &staRecord->dataPdu[i]);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ priv->pausedStaHandle[i]=(CsrUint8)(staRecord->assignedHandle);
+ break;
+ } else {
+ if(r){
+ unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ }
+ }
+ if (!staRecord->timRequestPendingFlag){
+ if((staRecord->timSet == CSR_WIFI_TIM_SET) || (staRecord->timSet == CSR_WIFI_TIM_SETTING)) {
+ unifi_trace(priv, UDBG3, "p_p_a_t:resetting tim .....\n");
+ update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
+ }
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ staRecord->updateTimReqQueued = 0;
+ unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
+ staRecord->aid);
+ }
+ unifi_trace(priv, UDBG5, "leaving process_peer_active_transition\n");
+}
+
+
+
+void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,CsrUint16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm)
+{
+ netInterface_priv_t *interfacePriv;
+ CsrUint8 i;
+ CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+
+ if(pkt_cfm->HostTag == interfacePriv->multicastPduHostTag) {
+ unifi_trace(priv,UDBG2,"CFM for marked Multicast Tag = %x\n",interfacePriv->multicastPduHostTag);
+ interfacePriv->multicastPduHostTag = 0xffffffff;
+ resume_suspended_uapsd(priv,interfaceTag);
+ resume_unicast_buffered_frames(priv,interfaceTag);
+ if(list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) &&
+ list_empty(&interfacePriv->genericMulticastOrBroadCastFrames)) {
+ unifi_trace(priv,UDBG1,"Resetting multicastTIM");
+ if (!interfacePriv->bcTimSetReqPendingFlag)
+ {
+ update_tim(priv,0,CSR_WIFI_TIM_RESET,interfaceTag, 0xFFFFFFFF);
+ }
+ else
+ {
+ /* Cache the DTimSet value so that it will processed immidiatly after
+ * completing the current setDTim Request
+ */
+ interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_RESET;
+ unifi_trace(priv, UDBG2, "uf_process_ma_pkt_cfm_for_ap : One more UpdateDTim Request(%d) Queued \n",
+ interfacePriv->bcTimSetReqQueued);
+ }
+
+ }
+ return;
+ }
+
+ /* Check if it is a Confirm for null data frame used
+ * for probing station activity
+ */
+ for(i =0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ staRecord = (CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[i]);
+ if (staRecord && (staRecord->nullDataHostTag == pkt_cfm->HostTag)) {
+
+ unifi_trace(priv, UDBG1, "CFM for Inactive probe Null frame (tag = %x, status = %d)\n",
+ pkt_cfm->HostTag,
+ pkt_cfm->TransmissionStatus
+ );
+ staRecord->nullDataHostTag = INVALID_HOST_TAG;
+
+ if(pkt_cfm->TransmissionStatus == CSR_TX_RETRY_LIMIT){
+ CsrTime now;
+ CsrTime inactive_time;
+
+ unifi_trace(priv, UDBG1, "Nulldata to probe STA ALIVE Failed with retry limit\n");
+ /* Recheck if there is some activity after null data is sent.
+ *
+ * If still there is no activity then send a disconnected indication
+ * to SME to delete the station record.
+ */
+ if (staRecord->activity_flag){
+ return;
+ }
+ now = CsrTimeGet(NULL);
+
+ if (staRecord->lastActivity > now)
+ {
+ /* simple timer wrap (for 1 wrap) */
+ inactive_time = CsrTimeAdd((CsrTime)CsrTimeSub(CSR_SCHED_TIME_MAX, staRecord->lastActivity),
+ now);
+ }
+ else
+ {
+ inactive_time = (CsrTime)CsrTimeSub(now, staRecord->lastActivity);
+ }
+
+ if (inactive_time >= STA_INACTIVE_TIMEOUT_VAL)
+ {
+ struct list_head send_cfm_list;
+ CsrUint8 j;
+
+ /* The SME/NME may be waiting for confirmation for requested frames to this station.
+ * Though this is --VERY UNLIKELY-- in case of station in active mode. But still as a
+ * a defensive check, it loops through buffered frames for this station and if confirmation
+ * is requested, send auto confirmation with failure status. Also flush the frames so
+ * that these are not processed again in PEER_DEL_REQ handler.
+ */
+ INIT_LIST_HEAD(&send_cfm_list);
+
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(staRecord->mgtFrames));
+
+ uf_flush_list(priv, &(staRecord->mgtFrames));
+
+ for(j = 0; j < MAX_ACCESS_CATOGORY; j++){
+ uf_prepare_send_cfm_list_for_queued_pkts(priv,
+ &send_cfm_list,
+ &(staRecord->dataPdu[j]));
+
+ uf_flush_list(priv,&(staRecord->dataPdu[j]));
+ }
+
+ send_auto_ma_packet_confirm(priv, staRecord->interfacePriv, &send_cfm_list);
+
+
+
+ unifi_warning(priv, "uf_process_ma_pkt_cfm_for_ap: Router Disconnected IND Peer (%x-%x-%x-%x-%x-%x)\n",
+ staRecord->peerMacAddress.a[0],
+ staRecord->peerMacAddress.a[1],
+ staRecord->peerMacAddress.a[2],
+ staRecord->peerMacAddress.a[3],
+ staRecord->peerMacAddress.a[4],
+ staRecord->peerMacAddress.a[5]);
+
+ CsrWifiRouterCtrlConnectedIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,
+ 0,
+ staRecord->interfacePriv->InterfaceTag,
+ staRecord->peerMacAddress,
+ CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED);
+ }
+
+ }
+ else if (pkt_cfm->TransmissionStatus == CSR_TX_SUCCESSFUL)
+ {
+ staRecord->activity_flag = TRUE;
+ }
+ }
+ }
+}
+
+#endif
+CsrUint16 uf_get_vif_identifier (CsrWifiRouterCtrlMode mode, CsrUint16 tag)
+{
+ switch(mode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_STA:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
+ return (0x02<<8|tag);
+
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ return (0x03<<8|tag);
+
+ case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
+ return (0x01<<8|tag);
+
+ case CSR_WIFI_ROUTER_CTRL_MODE_MONITOR:
+ return (0x04<<8|tag);
+ case CSR_WIFI_ROUTER_CTRL_MODE_AMP:
+ return (0x05<<8|tag);
+ default:
+ return tag;
+ }
+}
+
+#ifdef CSR_SUPPORT_SME
+
+/*
+ * ---------------------------------------------------------------------------
+ * update_macheader
+ *
+ *
+ * These functions updates mac header for intra BSS packet
+ * routing.
+ * NOTE: This function always has to be called in rx context which
+ * is in bh thread context since GFP_KERNEL is used. In soft IRQ/ Interrupt
+ * context shouldn't be used
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * skb Socket buffer containing data packet to transmit
+ * newSkb Socket buffer containing data packet + Mac header if no sufficient headroom in skb
+ * priority to append QOS control header in Mac header
+ * bulkdata if newSkb allocated then bulkdata updated to send to unifi
+ * interfaceTag the interfaceID on which activity going on
+ * macHeaderLengthInBytes no. of bytes of mac header in received frame
+ * qosDestination used to append Qos control field
+ *
+ * Returns:
+ * Zero on success or -1 on error.
+ * ---------------------------------------------------------------------------
+ */
+
+static int update_macheader(unifi_priv_t *priv, struct sk_buff *skb,
+ struct sk_buff *newSkb, CSR_PRIORITY *priority,
+ bulk_data_param_t *bulkdata, CsrUint16 interfaceTag,
+ CsrUint8 macHeaderLengthInBytes,
+ CsrUint8 qosDestination)
+{
+
+ CsrUint16 *fc = NULL;
+ CsrUint8 direction = 0, toDs, fromDs;
+ CsrUint8 *bufPtr = NULL;
+ CsrUint8 sa[ETH_ALEN], da[ETH_ALEN];
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ int headroom;
+ CsrUint8 macHeaderBuf[IEEE802_11_DATA_FRAME_MAC_HEADER_SIZE] = {0};
+
+ unifi_trace(priv, UDBG5, "entering the update_macheader function\n");
+
+ /* temporary buffer for the Mac header storage */
+ memcpy(macHeaderBuf, skb->data, macHeaderLengthInBytes);
+
+ /* remove the Macheader from the skb */
+ skb_pull(skb, macHeaderLengthInBytes);
+
+ /* get the skb headroom for skb_push check */
+ headroom = skb_headroom(skb);
+
+ /* pointer to frame control field */
+ fc = (CsrUint16*) macHeaderBuf;
+
+ toDs = (*fc & cpu_to_le16(IEEE802_11_FC_TO_DS_MASK))?1 : 0;
+ fromDs = (*fc & cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK))? 1: 0;
+ unifi_trace(priv, UDBG5, "In update_macheader function, fromDs = %x, toDs = %x\n", fromDs, toDs);
+ direction = ((fromDs | (toDs << 1)) & 0x3);
+
+ /* Address1 or 3 from the macheader */
+ memcpy(da, macHeaderBuf+4+toDs*12, ETH_ALEN);
+ /* Address2, 3 or 4 from the mac header */
+ memcpy(sa, macHeaderBuf+10+fromDs*(6+toDs*8), ETH_ALEN);
+
+ unifi_trace(priv, UDBG3, "update_macheader:direction = %x\n", direction);
+ /* update the toDs, fromDs & address fields in Mac header */
+ switch(direction)
+ {
+ case 2:
+ /* toDs = 1 & fromDs = 0 , toAp when frames received from peer
+ * while sending this packet to Destination the Mac header changed
+ * as fromDs = 1 & toDs = 0, fromAp
+ */
+ *fc &= cpu_to_le16(~IEEE802_11_FC_TO_DS_MASK);
+ *fc |= cpu_to_le16(IEEE802_11_FC_FROM_DS_MASK);
+ /* Address1: MAC address of the actual destination (4 = 2+2) */
+ memcpy(macHeaderBuf + 4, da, ETH_ALEN);
+ /* Address2: The MAC address of the AP (10 = 2+2+6) */
+ memcpy(macHeaderBuf + 10, &interfacePriv->bssid, ETH_ALEN);
+ /* Address3: MAC address of the actual source from mac header (16 = 2+2+6+6) */
+ memcpy(macHeaderBuf + 16, sa, ETH_ALEN);
+ break;
+ case 3:
+ unifi_trace(priv, UDBG3, "when both the toDs & fromDS set, NOT SUPPORTED\n");
+ break;
+ default:
+ unifi_trace(priv, UDBG3, "problem in decoding packet in update_macheader \n");
+ return -1;
+ }
+
+ /* frameType is Data always, Validation is done before calling this function */
+
+ /* check for the souce station type */
+ switch(le16_to_cpu(*fc) & IEEE80211_FC_SUBTYPE_MASK)
+ {
+ case IEEE802_11_FC_TYPE_QOS_DATA & IEEE80211_FC_SUBTYPE_MASK:
+ /* No need to modify the qos control field */
+ if (!qosDestination) {
+
+ /* If source Sta is QOS enabled & if this bit set, then HTC is supported by
+ * peer station & htc field present in macHeader
+ */
+ if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
+ /* HT control field present in Mac header
+ * 6 = sizeof(qosControl) + sizeof(htc)
+ */
+ macHeaderLengthInBytes -= 6;
+ } else {
+ macHeaderLengthInBytes -= 2;
+ }
+ /* Destination STA is non qos so change subtype to DATA */
+ *fc &= cpu_to_le16(~IEEE80211_FC_SUBTYPE_MASK);
+ *fc |= cpu_to_le16(IEEE802_11_FC_TYPE_DATA);
+ /* remove the qos control field & HTC(if present). new macHeaderLengthInBytes is less than old
+ * macHeaderLengthInBytes so no need to verify skb headroom
+ */
+ if (headroom < macHeaderLengthInBytes) {
+ unifi_trace(priv, UDBG1, " sufficient headroom not there to push updated mac header \n");
+ return -1;
+ }
+ bufPtr = (CsrUint8 *) skb_push(skb, macHeaderLengthInBytes);
+
+ /* update bulk data os_data_ptr */
+ bulkdata->d[0].os_data_ptr = skb->data;
+ bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
+ bulkdata->d[0].data_length = skb->len;
+
+ } else {
+ /* pointing to QOS control field */
+ CsrUint8 qc;
+ if (*fc & cpu_to_le16(IEEE80211_FC_ORDER_MASK)) {
+ qc = *((CsrUint8*)(macHeaderBuf + (macHeaderLengthInBytes - 4 - 2)));
+ } else {
+ qc = *((CsrUint8*)(macHeaderBuf + (macHeaderLengthInBytes - 2)));
+ }
+
+ if ((qc & IEEE802_11_QC_TID_MASK) > 7) {
+ *priority = 7;
+ } else {
+ *priority = qc & IEEE802_11_QC_TID_MASK;
+ }
+
+ unifi_trace(priv, UDBG1, "Incoming packet priority from QSTA is %x\n", *priority);
+
+ if (headroom < macHeaderLengthInBytes) {
+ unifi_trace(priv, UDBG3, " sufficient headroom not there to push updated mac header \n");
+ return -1;
+ }
+ bufPtr = (CsrUint8 *) skb_push(skb, macHeaderLengthInBytes);
+ }
+ break;
+ default:
+ {
+ bulk_data_param_t data_ptrs;
+ CsrResult csrResult;
+ unifi_trace(priv, UDBG5, "normal Data packet, NO QOS \n");
+
+ if (qosDestination) {
+ CsrUint8 qc = 0;
+ unifi_trace(priv, UDBG3, "destination is QOS station \n");
+
+ /* Set Ma-Packet.req UP to UP0 */
+ *priority = CSR_QOS_UP0;
+
+ /* prepare the qos control field */
+ qc |= CSR_QOS_UP0;
+ /* no Amsdu is in ap buffer so eosp is left 0 */
+ if (da[0] & 0x1) {
+ /* multicast/broadcast frames, no acknowledgement needed */
+ qc |= 1 << 5;
+ }
+
+ /* update new Mac header Length with 2 = sizeof(qos control) */
+ macHeaderLengthInBytes += 2;
+
+ /* received DATA frame but destiantion is QOS station so update subtype to QOS*/
+ *fc &= cpu_to_le16(~IEEE80211_FC_SUBTYPE_MASK);
+ *fc |= cpu_to_le16(IEEE802_11_FC_TYPE_QOS_DATA);
+
+ /* appendQosControlOffset = macHeaderLengthInBytes - 2, since source sta is not QOS */
+ macHeaderBuf[macHeaderLengthInBytes - 2] = qc;
+ /* txopLimit is 0 */
+ macHeaderBuf[macHeaderLengthInBytes - 1] = 0;
+ if (headroom < macHeaderLengthInBytes) {
+ csrResult = unifi_net_data_malloc(priv, &data_ptrs.d[0], skb->len + macHeaderLengthInBytes);
+
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, " failed to allocate request_data. in update_macheader func\n");
+ return -1;
+ }
+ newSkb = (struct sk_buff *)(data_ptrs.d[0].os_net_buf_ptr);
+ newSkb->len = skb->len + macHeaderLengthInBytes;
+
+ memcpy((void*)data_ptrs.d[0].os_data_ptr + macHeaderLengthInBytes,
+ skb->data, skb->len);
+
+ bulkdata->d[0].os_data_ptr = newSkb->data;
+ bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
+ bulkdata->d[0].data_length = newSkb->len;
+
+ bufPtr = (CsrUint8*)data_ptrs.d[0].os_data_ptr;
+
+ /* The old skb will not be used again */
+ kfree_skb(skb);
+ } else {
+ /* skb headroom is sufficient to append Macheader */
+ bufPtr = (CsrUint8*)skb_push(skb, macHeaderLengthInBytes);
+ bulkdata->d[0].os_data_ptr = skb->data;
+ bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
+ bulkdata->d[0].data_length = skb->len;
+ }
+ } else {
+ unifi_trace(priv, UDBG3, "destination is not a QSTA\n");
+ if (headroom < macHeaderLengthInBytes) {
+ csrResult = unifi_net_data_malloc(priv, &data_ptrs.d[0], skb->len + macHeaderLengthInBytes);
+
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, " failed to allocate request_data. in update_macheader func\n");
+ return -1;
+ }
+ newSkb = (struct sk_buff *)(data_ptrs.d[0].os_net_buf_ptr);
+ newSkb->len = skb->len + macHeaderLengthInBytes;
+
+ memcpy((void*)data_ptrs.d[0].os_data_ptr + macHeaderLengthInBytes,
+ skb->data, skb->len);
+
+ bulkdata->d[0].os_data_ptr = newSkb->data;
+ bulkdata->d[0].os_net_buf_ptr = (unsigned char*)newSkb;
+ bulkdata->d[0].data_length = newSkb->len;
+
+ bufPtr = (CsrUint8*)data_ptrs.d[0].os_data_ptr;
+
+ /* The old skb will not be used again */
+ kfree_skb(skb);
+ } else {
+ /* skb headroom is sufficient to append Macheader */
+ bufPtr = (CsrUint8*)skb_push(skb, macHeaderLengthInBytes);
+ bulkdata->d[0].os_data_ptr = skb->data;
+ bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skb;
+ bulkdata->d[0].data_length = skb->len;
+ }
+ }
+ }
+ }
+
+ /* prepare the complete skb, by pushing the MAC header to the begining of the skb->data */
+ unifi_trace(priv, UDBG5, "updated Mac Header: %d \n",macHeaderLengthInBytes);
+ memcpy(bufPtr, macHeaderBuf, macHeaderLengthInBytes);
+
+ unifi_trace(priv, UDBG5, "leaving the update_macheader function\n");
+ return 0;
+}
+/*
+ * ---------------------------------------------------------------------------
+ * uf_ap_process_data_pdu
+ *
+ *
+ * Takes care of intra BSS admission control & routing packets within BSS
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * skb Socket buffer containing data packet to transmit
+ * ehdr ethernet header to fetch priority of packet
+ * srcStaInfo source stations record for connection verification
+ * packed_signal
+ * signal_len
+ * signal MA-PACKET.indication signal
+ * bulkdata if newSkb allocated then bulkdata updated to send to unifi
+ * macHeaderLengthInBytes no. of bytes of mac header in received frame
+ *
+ * Returns:
+ * Zero on success(ap processing complete) or -1 if packet also have to be sent to NETDEV.
+ * ---------------------------------------------------------------------------
+ */
+int
+uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
+ struct ethhdr *ehdr, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
+ const CSR_SIGNAL *signal,
+ bulk_data_param_t *bulkdata,
+ CsrUint8 macHeaderLengthInBytes)
+{
+ const CSR_MA_PACKET_INDICATION *ind = &(signal->u.MaPacketIndication);
+ CsrUint16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0x00ff);
+ struct sk_buff *newSkb = NULL;
+ /* pointer to skb or private skb created using skb_copy() */
+ struct sk_buff *skbPtr = skb;
+ CsrBool sendToNetdev = FALSE;
+ CsrBool qosDestination = FALSE;
+ CSR_PRIORITY priority = CSR_CONTENTION;
+ CsrWifiRouterCtrlStaInfo_t *dstStaInfo = NULL;
+ netInterface_priv_t *interfacePriv;
+
+ unifi_trace(priv, UDBG5, "entering uf_ap_process_data_pdu %d\n",macHeaderLengthInBytes);
+ /* InterfaceTag validation from MA_PACKET.indication */
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_trace(priv, UDBG1, "Interface Tag is Invalid in uf_ap_process_data_pdu\n");
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ return 0;
+ }
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) &&
+ (interfacePriv->intraBssEnabled == FALSE)) {
+ unifi_trace(priv, UDBG2, "uf_ap_process_data_pdu:P2P GO intrabssEnabled?= %d\n", interfacePriv->intraBssEnabled);
+
+ /*In P2P GO case, if intraBSS distribution Disabled then don't do IntraBSS routing */
+ /* If destination in our BSS then drop otherwise give packet to netdev */
+ dstStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, ehdr->h_dest, interfaceTag);
+ if (dstStaInfo) {
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ return 0;
+ }
+ /* May be associated P2PCLI trying to send the packets on backbone (Netdev) */
+ return -1;
+ }
+
+ if(!memcmp(ehdr->h_dest, interfacePriv->bssid.a, ETH_ALEN)) {
+ /* This packet will be given to the TCP/IP stack since this packet is for us(AP)
+ * No routing needed */
+ unifi_trace(priv, UDBG4, "destination address is csr_ap\n");
+ return -1;
+ }
+
+ /* fetch the destination record from staion record database */
+ dstStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, ehdr->h_dest, interfaceTag);
+
+ /* AP mode processing, & if packet is unicast */
+ if(!dstStaInfo) {
+ if (!(ehdr->h_dest[0] & 0x1)) {
+ /* destination not in station record & its a unicast packet, so pass the packet to network stack */
+ unifi_trace(priv, UDBG3, "unicast frame & destination record not exist, send to netdev proto = %x\n", htons(skb->protocol));
+ return -1;
+ } else {
+ /* packet is multicast/broadcast */
+ /* copy the skb to skbPtr, send skb to netdev & skbPtr to multicast/broad cast list */
+ unifi_trace(priv, UDBG5, "skb_copy, in uf_ap_process_data_pdu, protocol = %x\n", htons(skb->protocol));
+ skbPtr = skb_copy(skb, GFP_KERNEL);
+ if(skbPtr == NULL) {
+ /* We don't have memory to don't send the frame in BSS*/
+ unifi_notice(priv, "broacast/multicast frame can't be sent in BSS No memeory: proto = %x\n", htons(skb->protocol));
+ return -1;
+ }
+ sendToNetdev = TRUE;
+ }
+ } else {
+
+ /* validate the Peer & Destination Station record */
+ if (uf_process_station_records_for_sending_data(priv, interfaceTag, srcStaInfo, dstStaInfo)) {
+ unifi_notice(priv, "uf_ap_process_data_pdu: station record validation failed \n");
+ interfacePriv->stats.rx_errors++;
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ return 0;
+ }
+ }
+
+ /* BroadCast packet received and it's been sent as non QOS packets.
+ * Since WMM spec not mandates broadcast/multicast to be sent as QOS data only,
+ * if all Peers are QSTA
+ */
+ if(sendToNetdev) {
+ /* BroadCast packet and it's been sent as non QOS packets */
+ qosDestination = FALSE;
+ } else if(dstStaInfo && (dstStaInfo->wmmOrQosEnabled == TRUE)) {
+ qosDestination = TRUE;
+ }
+
+ unifi_trace(priv, UDBG3, "uf_ap_process_data_pdu QoS destination = %s\n", (qosDestination)? "TRUE": "FALSE");
+
+ /* packet is allowed to send to unifi, update the Mac header */
+ if (update_macheader(priv, skbPtr, newSkb, &priority, bulkdata, interfaceTag, macHeaderLengthInBytes, qosDestination)) {
+ interfacePriv->stats.rx_errors++;
+ unifi_notice(priv, "(Packet Drop) failed to update the Mac header in uf_ap_process_data_pdu\n");
+ if (sendToNetdev) {
+ /* Free's the skb_copy(skbPtr) data since packet processing failed */
+ bulkdata->d[0].os_data_ptr = skbPtr->data;
+ bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skbPtr;
+ bulkdata->d[0].data_length = skbPtr->len;
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ }
+ return -1;
+ }
+
+ unifi_trace(priv, UDBG3, "Mac Header updated...calling uf_process_ma_packet_req \n");
+
+ /* Packet is ready to send to unifi ,transmissionControl = 0x0004, confirmation is not needed for data packets */
+ if (uf_process_ma_packet_req(priv, ehdr->h_dest, 0xffffffff, interfaceTag, CSR_NO_CONFIRM_REQUIRED, (CSR_RATE)0,priority, priv->netdev_client->sender_id, bulkdata)) {
+ if (sendToNetdev) {
+ unifi_trace(priv, UDBG1, "In uf_ap_process_data_pdu, (Packet Drop) uf_process_ma_packet_req failed. freeing skb_copy data (original data sent to Netdev)\n");
+ /* Free's the skb_copy(skbPtr) data since packet processing failed */
+ bulkdata->d[0].os_data_ptr = skbPtr->data;
+ bulkdata->d[0].os_net_buf_ptr = (unsigned char*)skbPtr;
+ bulkdata->d[0].data_length = skbPtr->len;
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ } else {
+ /* This free's the skb data */
+ unifi_trace(priv, UDBG1, "In uf_ap_process_data_pdu, (Packet Drop). Unicast data so freeing original skb \n");
+ unifi_net_data_free(priv, &bulkdata->d[0]);
+ }
+ }
+ unifi_trace(priv, UDBG5, "leaving uf_ap_process_data_pdu\n");
+
+ if (sendToNetdev) {
+ /* The packet is multicast/broadcast, so after AP processing packet has to
+ * be sent to netdev, if peer port state is open
+ */
+ unifi_trace(priv, UDBG4, "Packet will be routed to NetDev\n");
+ return -1;
+ }
+ /* Ap handled the packet & its a unicast packet, no need to send to netdev */
+ return 0;
+}
+
+#endif
+
+CsrResult uf_process_ma_packet_req(unifi_priv_t *priv,
+ CsrUint8 *peerMacAddress,
+ CSR_CLIENT_TAG hostTag,
+ CsrUint16 interfaceTag,
+ CSR_TRANSMISSION_CONTROL transmissionControl,
+ CSR_RATE TransmitRate,
+ CSR_PRIORITY priority,
+ CSR_PROCESS_ID leSenderProcessId,
+ bulk_data_param_t *bulkdata)
+{
+ CsrResult status = CSR_RESULT_SUCCESS;
+ CSR_SIGNAL signal;
+ int result;
+#ifdef CSR_SUPPORT_SME
+ CsrWifiRouterCtrlStaInfo_t *staRecord = NULL;
+ const CsrUint8 *macHdrLocation = bulkdata->d[0].os_data_ptr;
+ CsrWifiPacketType pktType;
+ int frameType = 0;
+ CsrBool queuePacketDozing = FALSE;
+ CsrUint32 priority_q;
+ CsrUint16 frmCtrl;
+ struct list_head * list = NULL; /* List to which buffered PDUs are to be enqueued*/
+ CsrBool setBcTim=FALSE;
+ netInterface_priv_t *interfacePriv;
+ CsrBool requeueOnSamePos = FALSE;
+ CsrUint32 handle = 0xFFFFFFFF;
+ unsigned long lock_flags;
+
+ UF_TRACE_MAC(priv, UDBG5, "entering uf_process_ma_packet_req, peer: ", peerMacAddress);
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "interfaceTag >= CSR_WIFI_NUM_INTERFACES, interfacetag = %d\n", interfaceTag);
+ return CSR_RESULT_FAILURE;
+ }
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+
+ /* fetch the station record for corresponding peer mac address */
+ if ((staRecord = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, peerMacAddress, interfaceTag))) {
+ handle = staRecord->assignedHandle;
+ }
+
+ /* Frame ma-packet.req, this is saved/transmitted depend on queue state */
+ unifi_frame_ma_packet_req(priv, priority, TransmitRate, hostTag,
+ interfaceTag, transmissionControl, leSenderProcessId,
+ peerMacAddress, &signal);
+
+ /* Since it's common path between STA & AP mode, in case of STA packet
+ * need not to be queued but in AP case we have to queue PDU's in
+ * different scenarios
+ */
+ switch(interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ /* For this mode processing done below */
+ break;
+ default:
+ /* In case of STA/IBSS/P2PCLI/AMP, no checks needed send the packet down & return */
+ unifi_trace(priv, UDBG5, "In %s, interface mode is %x \n", __FUNCTION__, interfacePriv->interfaceMode);
+ if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_NONE) {
+ unifi_warning(priv, "In %s, interface mode NONE \n", __FUNCTION__);
+ }
+ if ((result = ul_send_signal_unpacked(priv, &signal, bulkdata))) {
+ status = CSR_RESULT_FAILURE;
+ }
+ return status;
+ }
+
+ /* -----Only AP/P2pGO mode handling falls below----- */
+
+ /* convert priority to queue */
+ priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
+
+ /* check the powersave status of the peer */
+ if (staRecord && (staRecord->currentPeerState ==
+ CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)) {
+ /* Peer is dozing & packet have to be delivered, so buffer the packet &
+ * update the TIM
+ */
+ queuePacketDozing = TRUE;
+ }
+
+ /* find the type of frame unicast or mulicast/broadcast */
+ if (*peerMacAddress & 0x1) {
+ /* Multicast/broadCast data are always triggered by vif_availability.ind
+ * at the DTIM
+ */
+ pktType = CSR_WIFI_MULTICAST_PDU;
+ } else {
+ pktType = CSR_WIFI_UNICAST_PDU;
+ }
+
+ /* Fetch the frame control field from mac header & check for frame type */
+ frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation);
+
+ /* Processing done according to Frame/Packet type */
+ frameType = ((frmCtrl & 0x000c) >> FRAME_CONTROL_TYPE_FIELD_OFFSET);
+ switch(frameType)
+ {
+ case IEEE802_11_FRAMETYPE_MANAGEMENT:
+
+ switch(pktType)
+ {
+ case CSR_WIFI_UNICAST_PDU:
+ unifi_trace(priv, UDBG5, "management unicast PDU in uf_process_ma_packet_req \n");
+ /* push the packet in to the queue with appropriate mgt list */
+ if (!staRecord) {
+ /* push the packet to the unifi if list is empty (if packet lost how to re-enque) */
+ if (list_empty(&interfacePriv->genericMgtFrames)) {
+#ifdef CSR_SUPPORT_SME
+ if(!(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
+#endif
+
+ unifi_trace(priv, UDBG3, "genericMgtFrames list is empty uf_process_ma_packet_req \n");
+ result = ul_send_signal_unpacked(priv, &signal, bulkdata);
+ /* reque only on ENOSPC */
+ if(result == -ENOSPC) {
+ /* requeue the failed packet to genericMgtFrame with same position */
+ unifi_trace(priv, UDBG1, "(ENOSPC) Sending genericMgtFrames Failed so buffering\n");
+ list = &interfacePriv->genericMgtFrames;
+ requeueOnSamePos = TRUE;
+ }
+#ifdef CSR_SUPPORT_SME
+ }else{
+ list = &interfacePriv->genericMgtFrames;
+ unifi_trace(priv, UDBG3, "genericMgtFrames queue empty and dtim started\n hosttag is 0x%x,\n",signal.u.MaPacketRequest.HostTag);
+ update_eosp_to_head_of_broadcast_list_head(priv,interfaceTag);
+ }
+#endif
+ } else {
+ /* Queue the packet to genericMgtFrame of unifi_priv_t data structure */
+ list = &interfacePriv->genericMgtFrames;
+ unifi_trace(priv, UDBG2, "genericMgtFrames queue not empty\n");
+ }
+ } else {
+ /* check peer power state */
+ if (queuePacketDozing || !list_empty(&staRecord->mgtFrames) || IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
+ /* peer is in dozing mode, so queue packet in mgt frame list of station record */
+ /*if multicast traffic is going on, buffer the unicast packets*/
+ list = &staRecord->mgtFrames;
+
+ unifi_trace(priv, UDBG1, "staRecord->MgtFrames list empty? = %s, handle = %d, queuePacketDozing = %d\n",
+ (list_empty(&staRecord->mgtFrames))? "YES": "NO", staRecord->assignedHandle, queuePacketDozing);
+ if(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)){
+ update_eosp_to_head_of_broadcast_list_head(priv,interfaceTag);
+ }
+
+ } else {
+ unifi_trace(priv, UDBG5, "staRecord->mgtFrames list is empty uf_process_ma_packet_req \n");
+ result = ul_send_signal_unpacked(priv, &signal, bulkdata);
+ if(result == -ENOSPC) {
+ /* requeue the failed packet to staRecord->mgtFrames with same position */
+ list = &staRecord->mgtFrames;
+ requeueOnSamePos = TRUE;
+ unifi_trace(priv, UDBG1, "(ENOSPC) Sending MgtFrames Failed handle = %d so buffering\n",staRecord->assignedHandle);
+ priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+ } else if (result) {
+ status = CSR_RESULT_FAILURE;
+ }
+ }
+ }
+ break;
+ case CSR_WIFI_MULTICAST_PDU:
+ unifi_trace(priv, UDBG5, "management multicast/broadcast PDU in uf_process_ma_packet_req 'QUEUE it' \n");
+ /* Queue the packet to genericMulticastOrBroadCastMgtFrames of unifi_priv_t data structure
+ * will be sent when we receive VIF AVAILABILITY from firmware as part of DTIM
+ */
+
+ list = &interfacePriv->genericMulticastOrBroadCastMgtFrames;
+ if((interfacePriv->interfaceMode != CSR_WIFI_ROUTER_CTRL_MODE_IBSS) &&
+ (list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames))) {
+ setBcTim=TRUE;
+ }
+ break;
+ default:
+ unifi_error(priv, "condition never meets: packet type unrecognized\n");
+ }
+ break;
+ case IEEE802_11_FRAMETYPE_DATA:
+ switch(pktType)
+ {
+ case CSR_WIFI_UNICAST_PDU:
+ unifi_trace(priv, UDBG5, "data unicast PDU in uf_process_ma_packet_req \n");
+ /* check peer power state, list status & peer port status */
+ if(!staRecord) {
+ unifi_error(priv, "In %s unicast but staRecord = NULL\n", __FUNCTION__);
+ return CSR_RESULT_FAILURE;
+ } else if (queuePacketDozing || isRouterBufferEnabled(priv,priority_q)|| !list_empty(&staRecord->dataPdu[priority_q]) || IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
+ /* peer is in dozing mode, so queue packet in mgt frame list of station record */
+ /* if multicast traffic is going on, buffet the unicast packets */
+ unifi_trace(priv, UDBG2, "Enqueued to staRecord->dataPdu[%d] queuePacketDozing=%d,\
+ Buffering enabled = %d \n", priority_q,queuePacketDozing,isRouterBufferEnabled(priv,priority_q));
+ list = &staRecord->dataPdu[priority_q];
+ } else {
+ unifi_trace(priv, UDBG5, "staRecord->dataPdu[%d] list is empty uf_process_ma_packet_req \n", priority_q);
+ /* Pdu allowed to send to unifi */
+ result = ul_send_signal_unpacked(priv, &signal, bulkdata);
+ if(result == -ENOSPC) {
+ /* requeue the failed packet to staRecord->dataPdu[priority_q] with same position */
+ unifi_trace(priv, UDBG1, "(ENOSPC) Sending Unicast DataPDU to queue %d Failed so buffering\n",priority_q);
+ requeueOnSamePos = TRUE;
+ list = &staRecord->dataPdu[priority_q];
+ priv->pausedStaHandle[priority_q]=(CsrUint8)(staRecord->assignedHandle);
+ if(!isRouterBufferEnabled(priv,priority_q)) {
+ unifi_error(priv,"Buffering Not enabled for queue %d \n",priority_q);
+ }
+ } else if (result) {
+ status = CSR_RESULT_FAILURE;
+ }
+ }
+ break;
+ case CSR_WIFI_MULTICAST_PDU:
+ unifi_trace(priv, UDBG5, "data multicast/broadcast PDU in uf_process_ma_packet_req \n");
+ /* Queue the packet to genericMulticastOrBroadCastFrames list of unifi_priv_t data structure
+ * will be sent when we receive VIF AVAILABILITY from firmware as part of DTIM
+ */
+ list = &interfacePriv->genericMulticastOrBroadCastFrames;
+ if(list_empty(&interfacePriv->genericMulticastOrBroadCastFrames)) {
+ setBcTim = TRUE;
+ }
+ break;
+ default:
+ unifi_error(priv, "condition never meets: packet type un recognized\n");
+ }
+ break;
+ default:
+ unifi_error(priv, "unrecognized frame type\n");
+ }
+ if(list) {
+ status = enque_tx_data_pdu(priv, bulkdata,list, &signal,requeueOnSamePos);
+ /* Record no. of packet queued for each peer */
+ if (staRecord && (pktType == CSR_WIFI_UNICAST_PDU) && (!status)) {
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ staRecord->noOfPktQueued++;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ }
+ else if ((pktType == CSR_WIFI_MULTICAST_PDU) && (!status))
+ {
+ /* If broadcast Tim is set && queuing is successfull, then only update TIM */
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ interfacePriv->noOfbroadcastPktQueued++;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ }
+ }
+ /* If broadcast Tim is set && queuing is successfull, then only update TIM */
+ if(setBcTim && !status) {
+ unifi_trace(priv, UDBG3, "tim set due to broadcast pkt\n");
+ if (!interfacePriv->bcTimSetReqPendingFlag)
+ {
+ update_tim(priv,0,CSR_WIFI_TIM_SET,interfaceTag, handle);
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_SET;
+ unifi_trace(priv, UDBG2, "uf_process_ma_packet_req : One more UpdateDTim Request(:%d) Queued \n",
+ interfacePriv->bcTimSetReqQueued);
+ }
+ } else if(staRecord && staRecord->currentPeerState ==
+ CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE) {
+ if(staRecord->timSet == CSR_WIFI_TIM_RESET || staRecord->timSet == CSR_WIFI_TIM_RESETTING) {
+ if(!staRecord->wmmOrQosEnabled) {
+ if(!list_empty(&staRecord->mgtFrames) ||
+ !list_empty(&staRecord->dataPdu[3]) ||
+ !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION])) {
+ unifi_trace(priv, UDBG3, "tim set due to unicast pkt & peer in powersave\n");
+ if (!staRecord->timRequestPendingFlag){
+ update_tim(priv,staRecord->aid,1,interfaceTag, handle);
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ staRecord->updateTimReqQueued = 1;
+ unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
+ staRecord->aid);
+ }
+ }
+ } else {
+ /* Check for non delivery enable(i.e trigger enable), all delivery enable & legacy AC for TIM update in firmware */
+ CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+ /* Check if all AC's are Delivery Enabled */
+ is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
+ if (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable)
+ || (!list_empty(&staRecord->mgtFrames))) {
+ if (!staRecord->timRequestPendingFlag) {
+ update_tim(priv,staRecord->aid,1,interfaceTag, handle);
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ staRecord->updateTimReqQueued = 1;
+ unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
+ staRecord->aid);
+ }
+ }
+ }
+ }
+ }
+
+ if((list) && (pktType == CSR_WIFI_UNICAST_PDU && !queuePacketDozing) && !(isRouterBufferEnabled(priv,priority_q)) && !(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
+ unifi_trace(priv, UDBG2, "buffering cleared for queue = %d So resending buffered frames\n",priority_q);
+ uf_send_buffered_frames(priv, priority_q);
+ }
+ unifi_trace(priv, UDBG5, "leaving uf_process_ma_packet_req \n");
+ return status;
+#else
+#ifdef CSR_NATIVE_LINUX
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "interfaceTag >= CSR_WIFI_NUM_INTERFACES, interfacetag = %d\n", interfaceTag);
+ return CSR_RESULT_FAILURE;
+ }
+ /* Frame ma-packet.req, this is saved/transmitted depend on queue state */
+ unifi_frame_ma_packet_req(priv, priority, TransmitRate, hostTag, interfaceTag,
+ transmissionControl, leSenderProcessId,
+ peerMacAddress, &signal);
+ result = ul_send_signal_unpacked(priv, &signal, bulkdata);
+ if (result) {
+ return CSR_RESULT_FAILURE;
+ }
+#endif
+ return status;
+#endif
+}
+
+#ifdef CSR_SUPPORT_SME
+CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *daddr)
+{
+ CsrInt8 protection = 0;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ switch(interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_STA:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PCLI:
+ case CSR_WIFI_ROUTER_CTRL_MODE_AMP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_IBSS:
+ protection = interfacePriv->protect;
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ {
+ CsrWifiRouterCtrlStaInfo_t *dstStaInfo = NULL;
+ if (daddr[0] & 0x1) {
+ unifi_trace(priv, UDBG3, "broadcast/multicast packet in send_ma_pkt_request\n");
+ /* In this mode, the protect member of priv structure has an information of how
+ * AP/P2PGO has started, & the member updated in set mode request for AP/P2PGO
+ */
+ protection = interfacePriv->protect;
+ } else {
+ /* fetch the destination record from staion record database */
+ dstStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, daddr, interfaceTag);
+ if (!dstStaInfo) {
+ unifi_trace(priv, UDBG3, "peer not found in station record in send_ma_pkt_request\n");
+ return -1;
+ }
+ protection = dstStaInfo->protection;
+ }
+ }
+ break;
+ default:
+ unifi_trace(priv, UDBG2, "mode unknown in send_ma_pkt_request\n");
+ }
+ return protection;
+}
+#endif
+#ifdef CSR_SUPPORT_SME
+CsrUint8 send_multicast_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
+{
+ int r;
+ tx_buffered_packets_t * buffered_pkt = NULL;
+ CsrBool moreData = FALSE;
+ CsrUint8 pduSent =0;
+ unsigned long lock_flags;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ CsrUint32 hostTag = 0xffffffff;
+
+ func_enter();
+ if(!isRouterBufferEnabled(priv,UNIFI_TRAFFIC_Q_VO)) {
+ while((interfacePriv->dtimActive)&& (buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMulticastOrBroadCastMgtFrames))) {
+ buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK);
+ moreData = (buffered_pkt->transmissionControl & TRANSMISSION_CONTROL_EOSP_MASK)?FALSE:TRUE;
+
+
+ unifi_trace(priv,UDBG2,"DTIM Occurred for interface:sending Mgt packet %d\n",interfaceTag);
+
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,NULL,moreData,FALSE)) == -ENOSPC) {
+ unifi_trace(priv,UDBG1,"frame_and_send_queued_pdu failed with ENOSPC for host tag = %x\n", buffered_pkt->hostTag);
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &interfacePriv->genericMulticastOrBroadCastMgtFrames);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ break;
+ } else {
+ unifi_trace(priv,UDBG1,"send_multicast_frames: Send genericMulticastOrBroadCastMgtFrames (%x, %x)\n",
+ buffered_pkt->hostTag,
+ r);
+ if(r) {
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ if(!moreData) {
+
+ interfacePriv->dtimActive = FALSE;
+ if(!r) {
+ hostTag = buffered_pkt->hostTag;
+ pduSent++;
+ } else {
+ send_vif_availibility_rsp(priv,uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag),CSR_RC_UNSPECIFIED_FAILURE);
+ }
+ }
+ /* Buffered frame sent successfully */
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ interfacePriv->noOfbroadcastPktQueued--;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ kfree(buffered_pkt);
+ }
+
+ }
+ }
+ if(!isRouterBufferEnabled(priv,UNIFI_TRAFFIC_Q_CONTENTION)) {
+ while((interfacePriv->dtimActive)&& (buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMulticastOrBroadCastFrames))) {
+ buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
+ moreData = (buffered_pkt->transmissionControl & TRANSMISSION_CONTROL_EOSP_MASK)?FALSE:TRUE;
+
+
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,NULL,moreData,FALSE)) == -ENOSPC) {
+ /* Clear the trigger bit transmission control*/
+ buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK);
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &interfacePriv->genericMulticastOrBroadCastFrames);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ break;
+ } else {
+ if(r) {
+ unifi_trace(priv,UDBG1,"send_multicast_frames: Send genericMulticastOrBroadCastFrame failed (%x, %x)\n",
+ buffered_pkt->hostTag,
+ r);
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ if(!moreData) {
+ interfacePriv->dtimActive = FALSE;
+ if(!r) {
+ pduSent ++;
+ hostTag = buffered_pkt->hostTag;
+ } else {
+ send_vif_availibility_rsp(priv,uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag),CSR_RC_UNSPECIFIED_FAILURE);
+ }
+ }
+ /* Buffered frame sent successfully */
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ interfacePriv->noOfbroadcastPktQueued--;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ kfree(buffered_pkt);
+ }
+ }
+ }
+ if((interfacePriv->dtimActive == FALSE)) {
+ /* Record the host Tag*/
+ unifi_trace(priv,UDBG2,"send_multicast_frames: Recorded hostTag of EOSP packet: = 0x%x\n",hostTag);
+ interfacePriv->multicastPduHostTag = hostTag;
+ }
+ return pduSent;
+}
+#endif
+void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,CsrUint8 *sigdata,
+ CsrUint32 siglen)
+{
+#ifdef CSR_SUPPORT_SME
+ CSR_SIGNAL signal;
+ CSR_MA_VIF_AVAILABILITY_INDICATION *ind;
+ int r;
+ CsrUint16 interfaceTag;
+ CsrUint8 pduSent =0;
+ CSR_RESULT_CODE resultCode = CSR_RC_SUCCESS;
+ netInterface_priv_t *interfacePriv;
+
+ func_enter();
+ unifi_trace(priv, UDBG3,
+ "uf_process_ma_vif_availibility_ind: Process signal 0x%.4X\n",
+ *((CsrUint16*)sigdata));
+
+ r = read_unpack_signal(sigdata, &signal);
+ if (r) {
+ unifi_error(priv,
+ "uf_process_ma_vif_availibility_ind: Received unknown signal 0x%.4X.\n",
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(sigdata));
+ func_exit();
+ return;
+ }
+ ind = &signal.u.MaVifAvailabilityIndication;
+ interfaceTag=ind->VirtualInterfaceIdentifier & 0xff;
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "in vif_availability_ind interfaceTag is wrong\n");
+ return;
+ }
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if(ind->Multicast) {
+ if(list_empty(&interfacePriv->genericMulticastOrBroadCastFrames) &&
+ list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames)) {
+ /* This condition can occur because of a potential race where the
+ TIM is not yet reset as host is waiting for confirm but it is sent
+ by firmware and DTIM occurs*/
+ unifi_notice(priv,"ma_vif_availibility_ind recevied for multicast but queues are empty%d\n",interfaceTag);
+ send_vif_availibility_rsp(priv,ind->VirtualInterfaceIdentifier,CSR_RC_NO_BUFFERED_BROADCAST_MULTICAST_FRAMES);
+ interfacePriv->dtimActive = FALSE;
+ if(interfacePriv->multicastPduHostTag == 0xffffffff) {
+ unifi_notice(priv,"ma_vif_availibility_ind recevied for multicast but queues are empty%d\n",interfaceTag);
+ /* This may be an extra request in very rare race conditions but it is fine as it would atleast remove the potential lock up */
+ if (!interfacePriv->bcTimSetReqPendingFlag)
+ {
+ update_tim(priv,0,CSR_WIFI_TIM_RESET,interfaceTag, 0xFFFFFFFF);
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_RESET;
+ unifi_trace(priv, UDBG2, "uf_process_ma_vif_availibility_ind : One more UpdateDTim Request(%d) Queued \n",
+ interfacePriv->bcTimSetReqQueued);
+ }
+ }
+ return;
+ }
+ if(interfacePriv->dtimActive) {
+ unifi_trace(priv,UDBG2,"DTIM Occurred for already active DTIM interface %d\n",interfaceTag);
+ return;
+ } else {
+ unifi_trace(priv,UDBG2,"DTIM Occurred for interface %d\n",interfaceTag);
+ if(list_empty(&interfacePriv->genericMulticastOrBroadCastFrames)) {
+ set_eosp_transmit_ctrl(priv,&interfacePriv->genericMulticastOrBroadCastMgtFrames);
+ } else {
+ set_eosp_transmit_ctrl(priv,&interfacePriv->genericMulticastOrBroadCastFrames);
+ }
+ }
+ interfacePriv->dtimActive = TRUE;
+ pduSent = send_multicast_frames(priv,interfaceTag);
+ }
+ else {
+ unifi_error(priv,"Interface switching is not supported %d\n",interfaceTag);
+ resultCode = CSR_RC_NOT_SUPPORTED;
+ send_vif_availibility_rsp(priv,ind->VirtualInterfaceIdentifier,CSR_RC_NOT_SUPPORTED);
+ }
+#endif
+}
+#ifdef CSR_SUPPORT_SME
+
+#define GET_ACTIVE_INTERFACE_TAG(priv) 0
+
+static CsrBool uf_is_more_data_for_delivery_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t *staRecord)
+{
+ CsrInt8 i;
+
+ for(i=UNIFI_TRAFFIC_Q_VO; i >= UNIFI_TRAFFIC_Q_BK; i--)
+ {
+ if(((staRecord->powersaveMode[i]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)
+ ||(staRecord->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED))
+ &&(!list_empty(&staRecord->dataPdu[i]))) {
+ unifi_trace(priv,UDBG2,"uf_is_more_data_for_delivery_ac: Data Available AC = %d\n", i);
+ return TRUE;
+ }
+ }
+
+ unifi_trace(priv,UDBG2,"uf_is_more_data_for_delivery_ac: Data NOT Available \n");
+ return FALSE;
+}
+
+static CsrBool uf_is_more_data_for_usp_delivery(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t *staRecord, unifi_TrafficQueue queue)
+{
+ CsrInt8 i;
+
+ for(i = queue; i >= UNIFI_TRAFFIC_Q_BK; i--)
+ {
+ if(((staRecord->powersaveMode[i]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)
+ ||(staRecord->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED))
+ &&(!list_empty(&staRecord->dataPdu[i]))) {
+ unifi_trace(priv,UDBG2,"uf_is_more_data_for_usp_delivery: Data Available AC = %d\n", i);
+ return TRUE;
+ }
+ }
+
+ unifi_trace(priv,UDBG2,"uf_is_more_data_for_usp_delivery: Data NOT Available \n");
+ return FALSE;
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_send_buffered_data_from_delivery_ac
+ *
+ * This function takes care of
+ * -> Parsing the delivery enabled queue & sending frame down to HIP
+ * -> Setting EOSP=1 when USP to be terminated
+ * -> Depending on MAX SP length services the USP
+ *
+ * NOTE:This function always called from uf_handle_uspframes_delivery(), Dont
+ * call this function from any other location in code
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * vif interface specific HIP vif instance
+ * staInfo peer for which UAPSD to be scheduled
+ * queue AC from which Data to be sent in USP
+ * txList access category for processing list
+ * ---------------------------------------------------------------------------
+ */
+void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv,
+ CsrWifiRouterCtrlStaInfo_t * staInfo,
+ CsrUint8 queue,
+ struct list_head *txList)
+{
+
+ CsrUint16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
+ tx_buffered_packets_t * buffered_pkt = NULL;
+ unsigned long lock_flags;
+ CsrBool eosp=FALSE;
+ CsrInt8 r =0;
+ CsrBool moreData = FALSE;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ unifi_trace(priv, UDBG2, "++uf_send_buffered_data_from_delivery_ac, active=%x\n", staInfo->uapsdActive);
+
+ if (queue > UNIFI_TRAFFIC_Q_VO)
+ {
+ return;
+ }
+ while((buffered_pkt=dequeue_tx_data_pdu(priv, txList))) {
+ if((IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
+ unifi_trace(priv, UDBG2, "uf_send_buffered_data_from_delivery_ac: DTIM Active, suspend UAPSD, staId: 0x%x\n",
+ staInfo->aid);
+
+ /* Once resume called, the U-APSD delivery operation will resume */
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ staInfo->uspSuspend = TRUE;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ /* re-queueing the packet as DTIM started */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q,txList);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ break;
+ }
+
+ buffered_pkt->transmissionControl &=
+ ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+
+
+ if((staInfo->wmmOrQosEnabled == TRUE)&&(staInfo->uapsdActive == TRUE)) {
+
+ buffered_pkt->transmissionControl = TRANSMISSION_CONTROL_TRIGGER_MASK;
+
+ /* Check All delivery enables Ac for more data, because caller of this
+ * function not aware about last packet
+ * (First check in moreData fetching helps in draining out Mgt frames Q)
+ */
+ moreData = (!list_empty(txList) || uf_is_more_data_for_usp_delivery(priv, staInfo, queue));
+
+ if(staInfo->noOfSpFramesSent == (staInfo->maxSpLength - 1)) {
+ moreData = FALSE;
+ }
+
+ if(moreData == FALSE) {
+ eosp = TRUE;
+ buffered_pkt->transmissionControl =
+ (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+ }
+ } else {
+ /* Non QoS and non U-APSD */
+ unifi_warning(priv, "uf_send_buffered_data_from_delivery_ac: non U-APSD !!! \n");
+ }
+
+ unifi_trace(priv,UDBG2,"uf_send_buffered_data_from_delivery_ac : MoreData:%d, EOSP:%d\n",moreData,eosp);
+
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,moreData,eosp)) == -ENOSPC) {
+
+ unifi_trace(priv, UDBG2, "uf_send_buffered_data_from_delivery_ac: UASPD suspended, ENOSPC in hipQ=%x\n", queue);
+
+ /* Once resume called, the U-APSD delivery operation will resume */
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ staInfo->uspSuspend = TRUE;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q,txList);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ priv->pausedStaHandle[queue]=(CsrUint8)(staInfo->assignedHandle);
+ break;
+ } else {
+ if(r){
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ staInfo->noOfSpFramesSent++;
+ if((!moreData) || (staInfo->noOfSpFramesSent == staInfo->maxSpLength)) {
+ unifi_trace(priv, UDBG2, "uf_send_buffered_data_from_delivery_ac: Terminating USP\n");
+ staInfo->uapsdActive = FALSE;
+ staInfo->uspSuspend = FALSE;
+ staInfo->noOfSpFramesSent = 0;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ break;
+ }
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ }
+ }
+ unifi_trace(priv, UDBG2, "--uf_send_buffered_data_from_delivery_ac, active=%x\n", staInfo->uapsdActive);
+}
+
+void uf_send_buffered_data_from_ac(unifi_priv_t *priv,
+ CsrWifiRouterCtrlStaInfo_t * staInfo,
+ CsrUint8 queue,
+ struct list_head *txList)
+{
+ tx_buffered_packets_t * buffered_pkt = NULL;
+ unsigned long lock_flags;
+ CsrBool eosp=FALSE;
+ CsrBool moreData = FALSE;
+ CsrInt8 r =0;
+
+ func_enter();
+
+ unifi_trace(priv,UDBG2,"uf_send_buffered_data_from_ac :\n");
+
+ while(!isRouterBufferEnabled(priv,queue) &&
+ ((buffered_pkt=dequeue_tx_data_pdu(priv, txList))!=NULL)){
+
+ buffered_pkt->transmissionControl &=
+ ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
+
+ unifi_trace(priv,UDBG3,"uf_send_buffered_data_from_ac : MoreData:%d, EOSP:%d\n",moreData,eosp);
+
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,moreData,eosp)) == -ENOSPC) {
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q,txList);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ if(staInfo != NULL){
+ priv->pausedStaHandle[queue]=(CsrUint8)(staInfo->assignedHandle);
+ }
+ unifi_trace(priv,UDBG3," uf_send_buffered_data_from_ac: PDU sending failed .. no space for queue %d \n",queue);
+ } else {
+ if(r){
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ }
+
+ func_exit();
+
+}
+
+void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue q)
+{
+ CsrUint16 interfaceTag = GET_ACTIVE_INTERFACE_TAG(priv);
+ CsrUint32 startIndex=0,endIndex=0;
+ CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
+ CsrUint8 queue;
+ CsrBool moreData = FALSE;
+
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if(!((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP) ||
+ (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO)))
+ return;
+ func_enter();
+
+ queue = (q<=3)?q:0;
+
+ if(interfacePriv->dtimActive) {
+ /* this function updates dtimActive*/
+ send_multicast_frames(priv,interfaceTag);
+ if(!interfacePriv->dtimActive) {
+ moreData = (!list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) ||
+ !list_empty(&interfacePriv->genericMulticastOrBroadCastFrames));
+ if(!moreData) {
+ if (!interfacePriv->bcTimSetReqPendingFlag)
+ {
+ update_tim(priv,0,CSR_WIFI_TIM_RESET,interfaceTag, 0XFFFFFFFF);
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ interfacePriv->bcTimSetReqQueued = CSR_WIFI_TIM_RESET;
+ unifi_trace(priv, UDBG2, "uf_send_buffered_frames : One more UpdateDTim Request(%d) Queued \n",
+ interfacePriv->bcTimSetReqQueued);
+ }
+ }
+ } else {
+ moreData = (!list_empty(&interfacePriv->genericMulticastOrBroadCastMgtFrames) ||
+ !list_empty(&interfacePriv->genericMulticastOrBroadCastFrames));
+ if(!moreData) {
+ /* This should never happen but if it happens, we need a way out */
+ unifi_error(priv,"ERROR: No More Data but DTIM is active sending Response\n");
+ send_vif_availibility_rsp(priv,uf_get_vif_identifier(interfacePriv->interfaceMode,interfaceTag),CSR_RC_NO_BUFFERED_BROADCAST_MULTICAST_FRAMES);
+ interfacePriv->dtimActive = FALSE;
+ }
+ }
+ func_exit();
+ return;
+ }
+ if(priv->pausedStaHandle[queue] > 7) {
+ priv->pausedStaHandle[queue] = 0;
+ }
+
+ if(queue == UNIFI_TRAFFIC_Q_VO) {
+
+
+ unifi_trace(priv,UDBG2,"uf_send_buffered_frames : trying mgt from queue=%d\n",queue);
+ for(startIndex= 0; startIndex < UNIFI_MAX_CONNECTIONS;startIndex++) {
+ staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv,startIndex,interfaceTag);
+ if(!staInfo ) {
+ continue;
+ } else if((staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)
+ &&(staInfo->uapsdActive == FALSE) ) {
+ continue;
+ }
+
+ if((staInfo != NULL)&&(staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)
+ &&(staInfo->uapsdActive == FALSE)){
+ /*Non-UAPSD case push the management frames out*/
+ if(!list_empty(&staInfo->mgtFrames)){
+ uf_send_buffered_data_from_ac(priv,staInfo, UNIFI_TRAFFIC_Q_VO, &staInfo->mgtFrames);
+ }
+ }
+
+ if(isRouterBufferEnabled(priv,queue)) {
+ unifi_notice(priv,"uf_send_buffered_frames : No space Left for queue = %d\n",queue);
+ break;
+ }
+ }
+ /*push generic management frames out*/
+ if(!list_empty(&interfacePriv->genericMgtFrames)) {
+ unifi_trace(priv,UDBG2,"uf_send_buffered_frames : trying generic mgt from queue=%d\n",queue);
+ uf_send_buffered_data_from_ac(priv,staInfo, UNIFI_TRAFFIC_Q_VO, &interfacePriv->genericMgtFrames);
+ }
+ }
+
+
+ unifi_trace(priv,UDBG2,"uf_send_buffered_frames : Resume called for Queue=%d\n",queue);
+ unifi_trace(priv,UDBG2,"uf_send_buffered_frames : start=%d end=%d\n",startIndex,endIndex);
+
+ startIndex = priv->pausedStaHandle[queue];
+ endIndex = (startIndex + UNIFI_MAX_CONNECTIONS -1) % UNIFI_MAX_CONNECTIONS;
+
+ while(startIndex != endIndex) {
+ staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv,startIndex,interfaceTag);
+ if(!staInfo) {
+ startIndex ++;
+ if(startIndex >= UNIFI_MAX_CONNECTIONS) {
+ startIndex = 0;
+ }
+ continue;
+ } else if((staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)
+ &&(staInfo->uapsdActive == FALSE)) {
+ startIndex ++;
+ if(startIndex >= UNIFI_MAX_CONNECTIONS) {
+ startIndex = 0;
+ }
+ continue;
+ }
+ /* Peer is active or U-APSD is active so send PDUs to the peer */
+ unifi_trace(priv,UDBG2,"uf_send_buffered_frames : trying data from queue=%d\n",queue);
+
+
+ if((staInfo != NULL)&&(staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)
+ &&(staInfo->uapsdActive == FALSE)) {
+ if(!list_empty(&staInfo->dataPdu[queue])) {
+
+ /*Non-UAPSD case push the AC frames out*/
+ uf_send_buffered_data_from_ac(priv, staInfo, queue, (&staInfo->dataPdu[queue]));
+ }
+ }
+ startIndex ++;
+ if(startIndex >= UNIFI_MAX_CONNECTIONS) {
+ startIndex = 0;
+ }
+ }
+ if(isRouterBufferEnabled(priv,queue)) {
+ priv->pausedStaHandle[queue] = endIndex;
+ } else {
+ priv->pausedStaHandle[queue] = 0;
+ }
+
+ /* U-APSD might have stopped because of ENOSPC in lib_hip (pause activity).
+ * So restart it if U-APSD was active with any of the station
+ */
+ unifi_trace(priv, UDBG4, "csrWifiHipSendBufferedFrames: UAPSD Resume Q=%x\n", queue);
+ resume_suspended_uapsd(priv, interfaceTag);
+ func_exit();
+}
+
+
+CsrBool uf_is_more_data_for_non_delivery_ac(CsrWifiRouterCtrlStaInfo_t *staRecord)
+{
+ CsrUint8 i;
+
+ for(i=0;i<=3;i++)
+ {
+ if(((staRecord->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_ONLY_ENABLED)
+ ||(staRecord->powersaveMode[i]==CSR_WIFI_AC_LEGACY_POWER_SAVE))
+ &&(!list_empty(&staRecord->dataPdu[i]))){
+
+ return TRUE;
+ }
+ }
+
+ if(((staRecord->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_TRIGGER_ONLY_ENABLED)
+ ||(staRecord->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_LEGACY_POWER_SAVE))
+ &&(!list_empty(&staRecord->mgtFrames))){
+
+ return TRUE;
+ }
+
+
+
+ return FALSE;
+}
+
+
+int uf_process_station_records_for_sending_data(unifi_priv_t *priv,CsrUint16 interfaceTag,
+ CsrWifiRouterCtrlStaInfo_t *srcStaInfo,
+ CsrWifiRouterCtrlStaInfo_t *dstStaInfo)
+{
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ unifi_trace(priv, UDBG5, "entering uf_process_station_records_for_sending_data\n");
+
+ if (srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_DISCONNECTED) {
+ unifi_error(priv, "Peer State not connected AID = %x, handle = %x, control port state = %x\n",
+ srcStaInfo->aid, srcStaInfo->assignedHandle, srcStaInfo->peerControlledPort->port_action);
+ return -1;
+ }
+ switch (interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ unifi_trace(priv, UDBG5, "mode is AP/P2PGO\n");
+ break;
+ default:
+ unifi_warning(priv, "mode is nor AP neither P2PGO, packet cant be xmit\n");
+ return -1;
+ }
+
+ switch(dstStaInfo->peerControlledPort->port_action)
+ {
+ case CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD:
+ case CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_BLOCK:
+ unifi_trace(priv, UDBG5, "destination port is closed/blocked, discarding the packet\n");
+ return -1;
+ default:
+ unifi_trace(priv, UDBG5, "destination port state is open\n");
+ }
+
+ /* port state is open, destination station record is valid, Power save state is
+ * validated in uf_process_ma_packet_req function
+ */
+ unifi_trace(priv, UDBG5, "leaving uf_process_station_records_for_sending_data\n");
+ return 0;
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_handle_uspframes_delivery
+ *
+ * This function takes care of handling USP session for peer, when
+ * -> trigger frame from peer
+ * -> suspended USP to be processed (resumed)
+ *
+ * NOTE: uf_send_buffered_data_from_delivery_ac() always called from this function, Dont
+ * make a direct call to uf_send_buffered_data_from_delivery_ac() from any other part of
+ * code
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * staInfo peer for which UAPSD to be scheduled
+ * interfaceTag virtual interface tag
+ * ---------------------------------------------------------------------------
+ */
+static void uf_handle_uspframes_delivery(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t *staInfo, CsrUint16 interfaceTag)
+{
+
+ CsrInt8 i;
+ CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ unsigned long lock_flags;
+
+ unifi_trace(priv, UDBG2, " ++ uf_handle_uspframes_delivery, uapsd active=%x, suspended?=%x\n",
+ staInfo->uapsdActive, staInfo->uspSuspend);
+
+ /* Check for Buffered frames according to priority order & deliver it
+ * 1. AC_VO delivery enable & Mgt frames available
+ * 2. Process remaining Ac's from order AC_VO to AC_BK
+ */
+
+ /* USP initiated by WMMPS enabled peer & SET the status flag to TRUE */
+ if (!staInfo->uspSuspend && staInfo->uapsdActive)
+ {
+ unifi_notice(priv, "uf_handle_uspframes_delivery: U-APSD already active! STA=%x:%x:%x:%x:%x:%x\n",
+ staInfo->peerMacAddress.a[0], staInfo->peerMacAddress.a[1],
+ staInfo->peerMacAddress.a[2], staInfo->peerMacAddress.a[3],
+ staInfo->peerMacAddress.a[4], staInfo->peerMacAddress.a[5]);
+ return;
+ }
+
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ staInfo->uapsdActive = TRUE;
+ staInfo->uspSuspend = FALSE;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+
+ if(((staInfo->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED)||
+ (staInfo->powersaveMode[UNIFI_TRAFFIC_Q_VO]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE))
+ && (!list_empty(&staInfo->mgtFrames))) {
+
+ /* Management queue has data && UNIFI_TRAFFIC_Q_VO is delivery enable */
+ unifi_trace(priv, UDBG4, "uf_handle_uspframes_delivery: Sending buffered management frames\n");
+ uf_send_buffered_data_from_delivery_ac(priv, staInfo, UNIFI_TRAFFIC_Q_VO, &staInfo->mgtFrames);
+ }
+
+ if (!uf_is_more_data_for_delivery_ac(priv, staInfo)) {
+ /* All delivery enable AC's are empty, so QNULL to be sent to terminate the USP
+ * NOTE: If we have sent Mgt frame also, we must send QNULL followed to terminate USP
+ */
+ if (!staInfo->uspSuspend) {
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ staInfo->uapsdActive = FALSE;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+
+ unifi_trace(priv, UDBG2, "uf_handle_uspframes_delivery: sending QNull for trigger\n");
+ uf_send_qos_null(priv, interfaceTag, staInfo->peerMacAddress.a, (CSR_PRIORITY) staInfo->triggerFramePriority, staInfo);
+ staInfo->triggerFramePriority = CSR_QOS_UP0;
+ } else {
+ unifi_trace(priv, UDBG2, "uf_handle_uspframes_delivery: MgtQ xfer suspended\n");
+ }
+ } else {
+ for(i = UNIFI_TRAFFIC_Q_VO; i >= UNIFI_TRAFFIC_Q_BK; i--) {
+ if(((staInfo->powersaveMode[i]==CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)
+ ||(staInfo->powersaveMode[i]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED))
+ && (!list_empty(&staInfo->dataPdu[i]))) {
+ /* Deliver Data according to AC priority (from VO to BK) as part of USP */
+ unifi_trace(priv, UDBG4, "uf_handle_uspframes_delivery: Buffered data frames from Queue (%d) for USP\n", i);
+ uf_send_buffered_data_from_delivery_ac(priv, staInfo, i, &staInfo->dataPdu[i]);
+ }
+
+ if ((!staInfo->uapsdActive) ||
+ (staInfo->uspSuspend && IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag))) {
+ /* If DTIM active found on one AC, No need to parse the remaining AC's
+ * as USP suspended. Break out of loop
+ */
+ unifi_trace(priv, UDBG2, "uf_handle_uspframes_delivery: suspend=%x, DTIM=%x, USP terminated=%s\n",
+ staInfo->uspSuspend, IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag),
+ staInfo->uapsdActive?"NO":"YES");
+ break;
+ }
+ }
+ }
+
+ /* Depending on the USP status, update the TIM accordingly for delivery enabled AC only
+ * (since we are not manipulating any Non-delivery list(AC))
+ */
+ is_all_ac_deliver_enabled_and_moredata(staInfo, &allDeliveryEnabled, &dataAvailable);
+ if ((allDeliveryEnabled && !dataAvailable)) {
+ if ((staInfo->timSet != CSR_WIFI_TIM_RESET) || (staInfo->timSet != CSR_WIFI_TIM_RESETTING)) {
+ staInfo->updateTimReqQueued = (CsrUint8) CSR_WIFI_TIM_RESET;
+ unifi_trace(priv, UDBG4, " --uf_handle_uspframes_delivery, UAPSD timset\n");
+ if (!staInfo->timRequestPendingFlag) {
+ update_tim(priv, staInfo->aid, 0, interfaceTag, staInfo->assignedHandle);
+ }
+ }
+ }
+ unifi_trace(priv, UDBG2, " --uf_handle_uspframes_delivery, uapsd active=%x, suspend?=%x\n",
+ staInfo->uapsdActive, staInfo->uspSuspend);
+}
+
+void uf_process_wmm_deliver_ac_uapsd(unifi_priv_t * priv,
+ CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
+ CsrUint16 qosControl,
+ CsrUint16 interfaceTag)
+{
+ CSR_PRIORITY priority;
+ unifi_TrafficQueue priority_q;
+ unsigned long lock_flags;
+
+ unifi_trace(priv, UDBG2, "++uf_process_wmm_deliver_ac_uapsd: uapsdactive?=%x\n", srcStaInfo->uapsdActive);
+ /* If recceived Frames trigger Frame and Devlivery enabled AC has data
+ * then transmit from High priorty delivery enabled AC
+ */
+ priority = (CSR_PRIORITY)(qosControl & IEEE802_11_QC_TID_MASK);
+ priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
+
+ if((srcStaInfo->powersaveMode[priority_q]==CSR_WIFI_AC_TRIGGER_ONLY_ENABLED)
+ ||(srcStaInfo->powersaveMode[priority_q]==CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED)) {
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ srcStaInfo->triggerFramePriority = priority;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ unifi_trace(priv, UDBG2, "uf_process_wmm_deliver_ac_uapsd: trigger frame, Begin U-APSD, triggerQ=%x\n", priority_q);
+ uf_handle_uspframes_delivery(priv, srcStaInfo, interfaceTag);
+ }
+ unifi_trace(priv, UDBG2, "--uf_process_wmm_deliver_ac_uapsd: uapsdactive?=%x\n", srcStaInfo->uapsdActive);
+}
+
+
+void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
+{
+ bulk_data_param_t bulkdata;
+ CsrResult csrResult;
+ struct sk_buff *skb, *newSkb = NULL;
+ CsrWifiMacAddress peerAddress;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ CSR_TRANSMISSION_CONTROL transmissionControl = (TRANSMISSION_CONTROL_EOSP_MASK | TRANSMISSION_CONTROL_TRIGGER_MASK);
+ int r;
+ CSR_SIGNAL signal;
+ CsrUint32 priority_q;
+ CSR_RATE transmitRate = 0;
+
+
+ func_enter();
+ /* Send a Null Frame to Peer,
+ * 32= size of mac header */
+ csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], MAC_HEADER_SIZE + QOS_CONTROL_HEADER_SIZE);
+
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, " failed to allocate request_data. in uf_send_qos_null func\n");
+ return ;
+ }
+ skb = (struct sk_buff *)(bulkdata.d[0].os_net_buf_ptr);
+ skb->len = 0;
+ bulkdata.d[0].os_data_ptr = skb->data;
+ bulkdata.d[0].os_net_buf_ptr = (unsigned char*)skb;
+ bulkdata.d[0].net_buf_length = bulkdata.d[0].data_length = skb->len;
+ bulkdata.d[1].os_data_ptr = NULL;
+ bulkdata.d[1].os_net_buf_ptr = NULL;
+ bulkdata.d[1].net_buf_length = bulkdata.d[1].data_length = 0;
+
+ /* For null frames protection bit should not be set in MAC header, so passing value 0 below for protection field */
+
+ if (prepare_and_add_macheader(priv, skb, newSkb, priority, &bulkdata, interfaceTag, da, interfacePriv->bssid.a, 0)) {
+ unifi_error(priv, "failed to create MAC header\n");
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ return;
+ }
+ memcpy(peerAddress.a, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+ /* convert priority to queue */
+ priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
+
+ /* Frame ma-packet.req, this is saved/transmitted depend on queue state
+ * send the null frame at data rate of 1 Mb/s for AP or 6 Mb/s for P2PGO
+ */
+ switch (interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ transmitRate = 2;
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ transmitRate = 12;
+ break;
+ default:
+ transmitRate = 0;
+ }
+ unifi_frame_ma_packet_req(priv, priority, transmitRate, 0xffffffff, interfaceTag,
+ transmissionControl, priv->netdev_client->sender_id,
+ peerAddress.a, &signal);
+
+ r = ul_send_signal_unpacked(priv, &signal, &bulkdata);
+ if(r) {
+ unifi_error(priv, "failed to send QOS data null packet result: %d\n",r);
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ }
+
+ func_exit();
+ return;
+
+}
+void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo)
+{
+ bulk_data_param_t bulkdata;
+ CsrResult csrResult;
+ struct sk_buff *skb, *newSkb = NULL;
+ CsrWifiMacAddress peerAddress;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ CSR_TRANSMISSION_CONTROL transmissionControl = 0;
+ int r;
+ CSR_SIGNAL signal;
+ CsrUint32 priority_q;
+ CSR_RATE transmitRate = 0;
+ CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
+ unsigned long lock_flags;
+
+ func_enter();
+ /* Send a Null Frame to Peer, size = 24 for MAC header */
+ csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], MAC_HEADER_SIZE);
+
+ if (csrResult != CSR_RESULT_SUCCESS) {
+ unifi_error(priv, "uf_send_nulldata: Failed to allocate memory for NULL frame\n");
+ return ;
+ }
+ skb = (struct sk_buff *)(bulkdata.d[0].os_net_buf_ptr);
+ skb->len = 0;
+ bulkdata.d[0].os_data_ptr = skb->data;
+ bulkdata.d[0].os_net_buf_ptr = (unsigned char*)skb;
+ bulkdata.d[0].net_buf_length = bulkdata.d[0].data_length = skb->len;
+ bulkdata.d[1].os_data_ptr = NULL;
+ bulkdata.d[1].os_net_buf_ptr = NULL;
+ bulkdata.d[1].net_buf_length = bulkdata.d[1].data_length = 0;
+
+ /* For null frames protection bit should not be set in MAC header, so passing value 0 below for protection field */
+ if (prepare_and_add_macheader(priv, skb, newSkb, priority, &bulkdata, interfaceTag, da, interfacePriv->bssid.a, 0)) {
+ unifi_error(priv, "uf_send_nulldata: Failed to create MAC header\n");
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ return;
+ }
+ memcpy(peerAddress.a, ((CsrUint8 *) bulkdata.d[0].os_data_ptr) + 4, ETH_ALEN);
+ /* convert priority to queue */
+ priority_q = unifi_frame_priority_to_queue((CSR_PRIORITY) priority);
+ transmissionControl &= ~(CSR_NO_CONFIRM_REQUIRED);
+
+ /* Frame ma-packet.req, this is saved/transmitted depend on queue state
+ * send the null frame at data rate of 1 Mb/s for AP or 6 Mb/s for P2PGO
+ */
+ switch (interfacePriv->interfaceMode)
+ {
+ case CSR_WIFI_ROUTER_CTRL_MODE_AP:
+ transmitRate = 2;
+ break;
+ case CSR_WIFI_ROUTER_CTRL_MODE_P2PGO:
+ transmitRate = 12;
+ break;
+ default:
+ transmitRate = 0;
+ }
+ unifi_frame_ma_packet_req(priv, priority, transmitRate, INVALID_HOST_TAG, interfaceTag,
+ transmissionControl, priv->netdev_client->sender_id,
+ peerAddress.a, &signal);
+
+ /* Save host tag to check the status on reception of MA packet confirm */
+ srcStaInfo->nullDataHostTag = req->HostTag;
+ unifi_trace(priv, UDBG1, "uf_send_nulldata: STA AID = %d hostTag = %x\n", srcStaInfo->aid, req->HostTag);
+
+ r = ul_send_signal_unpacked(priv, &signal, &bulkdata);
+
+ if(r == -ENOSPC) {
+ unifi_trace(priv, UDBG1, "uf_send_nulldata: ENOSPC Requeue the Null frame\n");
+ enque_tx_data_pdu(priv, &bulkdata, &srcStaInfo->dataPdu[priority_q], &signal, 1);
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ srcStaInfo->noOfPktQueued++;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+
+
+ }
+ if(r && r != -ENOSPC){
+ unifi_error(priv, "uf_send_nulldata: Failed to send Null frame Error = %d\n",r);
+ unifi_net_data_free(priv, &bulkdata.d[0]);
+ srcStaInfo->nullDataHostTag = INVALID_HOST_TAG;
+ }
+
+ func_exit();
+ return;
+}
+
+CsrBool uf_check_broadcast_bssid(unifi_priv_t *priv, const bulk_data_param_t *bulkdata)
+{
+ CsrUint8 *bssid = NULL;
+ static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
+ CsrUint8 toDs, fromDs;
+
+ toDs = (((bulkdata->d[0].os_data_ptr)[1]) & 0x01) ? 1 : 0;
+ fromDs =(((bulkdata->d[0].os_data_ptr)[1]) & 0x02) ? 1 : 0;
+
+ if (toDs && fromDs)
+ {
+ unifi_trace(priv, UDBG6, "Address 4 present, Don't try to find BSSID\n");
+ bssid = NULL;
+ }
+ else if((toDs == 0) && (fromDs ==0))
+ {
+ /* BSSID is Address 3 */
+ bssid = (CsrUint8 *) (bulkdata->d[0].os_data_ptr + 4 + (2 * ETH_ALEN));
+ }
+ else if(toDs)
+ {
+ /* BSSID is Address 1 */
+ bssid = (CsrUint8 *) (bulkdata->d[0].os_data_ptr + 4);
+ }
+ else if(fromDs)
+ {
+ /* BSSID is Address 2 */
+ bssid = (CsrUint8 *) (bulkdata->d[0].os_data_ptr + 4 + ETH_ALEN);
+ }
+
+ if (memcmp(broadcast_address.a, bssid, ETH_ALEN)== 0)
+ {
+ return TRUE;
+ }
+ else
+ {
+ return FALSE;
+ }
+}
+
+
+CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
+ CsrUint8 pmBit,CsrUint16 interfaceTag)
+{
+ CsrBool moreData = FALSE;
+ CsrBool powerSaveChanged = FALSE;
+ unsigned long lock_flags;
+
+ unifi_trace(priv, UDBG3, "entering uf_process_pm_bit_for_peer\n");
+ if (pmBit) {
+ priv->allPeerDozing |= (0x01 << (srcStaInfo->assignedHandle));
+ } else {
+ priv->allPeerDozing &= ~(0x01 << (srcStaInfo->assignedHandle));
+ }
+ if(pmBit) {
+ if(srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE) {
+
+ /* disable the preemption */
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ srcStaInfo->currentPeerState =CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE;
+ powerSaveChanged = TRUE;
+ /* enable the preemption */
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ } else {
+ return powerSaveChanged;
+ }
+ } else {
+ if(srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE) {
+ /* disable the preemption */
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ srcStaInfo->currentPeerState = CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE;
+ powerSaveChanged = TRUE;
+ /* enable the preemption */
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ }else {
+ return powerSaveChanged;
+ }
+ }
+
+
+ if(srcStaInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE) {
+ unifi_trace(priv,UDBG3, "Peer with AID = %d is active now\n",srcStaInfo->aid);
+ process_peer_active_transition(priv,srcStaInfo,interfaceTag);
+ } else {
+ unifi_trace(priv,UDBG3, "Peer with AID = %d is in PS Now\n",srcStaInfo->aid);
+ /* Set TIM if needed */
+ if(!srcStaInfo->wmmOrQosEnabled) {
+ moreData = (!list_empty(&srcStaInfo->mgtFrames) ||
+ !list_empty(&srcStaInfo->dataPdu[UNIFI_TRAFFIC_Q_VO])||
+ !list_empty(&srcStaInfo->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]));
+ if(moreData && (srcStaInfo->timSet == CSR_WIFI_TIM_RESET)) {
+ unifi_trace(priv, UDBG3, "This condition should not occur\n");
+ if (!srcStaInfo->timRequestPendingFlag){
+ update_tim(priv,srcStaInfo->aid,1,interfaceTag, srcStaInfo->assignedHandle);
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ srcStaInfo->updateTimReqQueued = 1;
+ unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", srcStaInfo->updateTimReqQueued,
+ srcStaInfo->aid);
+ }
+
+ }
+ } else {
+ CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+ unifi_trace(priv, UDBG5, "Qos in AP Mode\n");
+ /* Check if all AC's are Delivery Enabled */
+ is_all_ac_deliver_enabled_and_moredata(srcStaInfo, &allDeliveryEnabled, &dataAvailable);
+ /*check for more data in non-delivery enabled queues*/
+ moreData = (uf_is_more_data_for_non_delivery_ac(srcStaInfo) || (allDeliveryEnabled && dataAvailable));
+
+ if(moreData && (srcStaInfo->timSet == CSR_WIFI_TIM_RESET)) {
+ if (!srcStaInfo->timRequestPendingFlag){
+ update_tim(priv,srcStaInfo->aid,1,interfaceTag, srcStaInfo->assignedHandle);
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ srcStaInfo->updateTimReqQueued = 1;
+ unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", srcStaInfo->updateTimReqQueued,
+ srcStaInfo->aid);
+ }
+ }
+ }
+ }
+ unifi_trace(priv, UDBG3, "leaving uf_process_pm_bit_for_peer\n");
+ return powerSaveChanged;
+}
+
+
+
+void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pmBit,CsrUint16 interfaceTag)
+{
+ CsrWifiRouterCtrlStaInfo_t *staRecord =
+ CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, sa, interfaceTag);
+ tx_buffered_packets_t * buffered_pkt = NULL;
+ CsrWifiMacAddress peerMacAddress;
+ unsigned long lock_flags;
+ CsrInt8 r =0;
+ CsrBool moreData = FALSE;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ unifi_trace(priv, UDBG3, "entering uf_process_ps_poll\n");
+ if(!staRecord) {
+ memcpy(peerMacAddress.a,sa,ETH_ALEN);
+ unifi_trace(priv, UDBG3, "In uf_process_ps_poll, sta record not found:unexpected frame addr = %x:%x:%x:%x:%x:%x\n",
+ sa[0], sa[1],sa[2], sa[3], sa[4],sa[5]);
+ CsrWifiRouterCtrlUnexpectedFrameIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,interfaceTag,peerMacAddress);
+ return;
+ }
+
+ uf_process_pm_bit_for_peer(priv,staRecord,pmBit,interfaceTag);
+
+ /* Update station last activity time */
+ staRecord->activity_flag = TRUE;
+
+ /* This should not change the PM bit as PS-POLL has PM bit always set */
+ if(!pmBit) {
+ unifi_notice (priv," PM bit reset in PS-POLL\n");
+ return;
+ }
+
+ if(IS_DTIM_ACTIVE(interfacePriv->dtimActive,interfacePriv->multicastPduHostTag)) {
+ /* giving more priority to multicast packets so dropping ps-poll*/
+ unifi_notice (priv," multicast transmission is going on so don't take action on PS-POLL\n");
+ return;
+ }
+
+ if(!staRecord->wmmOrQosEnabled) {
+ if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->mgtFrames))) {
+ buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
+ moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
+ !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]) ||
+ !list_empty(&staRecord->mgtFrames));
+
+ buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
+ /* Clear the trigger bit transmission control*/
+ buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &staRecord->mgtFrames);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
+ priv->pausedStaHandle[3]=(CsrUint8)(staRecord->assignedHandle);
+ } else {
+ if(r){
+ unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ } else if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]))) {
+ buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
+ moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
+ !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]));
+
+ buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
+ /* Clear the trigger bit transmission control*/
+ buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ priv->pausedStaHandle[3]=(CsrUint8)(staRecord->assignedHandle);
+ unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
+ } else {
+ if(r){
+ unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ } else if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]))) {
+ buffered_pkt->transmissionControl |= TRANSMISSION_CONTROL_TRIGGER_MASK;
+ moreData = !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]);
+
+ buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
+ /* Clear the trigger bit transmission control*/
+ buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+ unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
+ } else {
+ if(r){
+ unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ } else {
+ /* Actually since we have sent an ACK, there
+ * there is no need to send a NULL frame*/
+ }
+ moreData = (!list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_VO]) ||
+ !list_empty(&staRecord->dataPdu[UNIFI_TRAFFIC_Q_CONTENTION]) ||
+ !list_empty(&staRecord->mgtFrames));
+ if(!moreData && (staRecord->timSet == CSR_WIFI_TIM_SET)) {
+ unifi_trace(priv, UDBG3, "more data = NULL, set tim to 0 in uf_process_ps_poll\n");
+ if (!staRecord->timRequestPendingFlag){
+ update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ staRecord->updateTimReqQueued = 0;
+ unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
+ staRecord->aid);
+ }
+ }
+ } else {
+
+ CsrUint8 allDeliveryEnabled = 0, dataAvailable = 0;
+ unifi_trace(priv, UDBG3,"Qos Support station.Processing PS-Poll\n");
+
+ /*Send Data From Management Frames*/
+ /* Priority orders for delivering the buffered packets are
+ * 1. Deliver the Management frames if there
+ * 2. Other access catagory frames which are non deliver enable including UNIFI_TRAFFIC_Q_VO
+ * priority is from VO->BK
+ */
+
+ /* Check if all AC's are Delivery Enabled */
+ is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
+
+ if (allDeliveryEnabled) {
+ unifi_trace(priv, UDBG3, "uf_process_ps_poll: All ACs are delivery enable so Sending QOS Null in response of Ps-poll\n");
+ uf_send_qos_null(priv,interfaceTag,sa,CSR_QOS_UP0,staRecord);
+ return;
+ }
+
+ if (!list_empty(&staRecord->mgtFrames)) {
+ if ((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->mgtFrames))) {
+ /* We dont have packets in non delivery enabled UNIFI_TRAFFIC_Q_VO, So we are looking in management
+ * queue of the station record
+ */
+ moreData = uf_is_more_data_for_non_delivery_ac(staRecord);
+ buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+
+ /* Last parameter is EOSP & its false always for PS-POLL processing */
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
+ /* Clear the trigger bit transmission control*/
+ buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &staRecord->mgtFrames);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+ unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
+ } else {
+ if(r){
+ unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ } else {
+ unifi_error(priv, "uf_process_ps_poll: Mgt frame list empty!! \n");
+ }
+
+ } else {
+ CsrInt8 i;
+ /* We dont have buffered packet in mangement frame queue (1 failed), So proceed with condition 2
+ * UNIFI_TRAFFIC_Q_VO -> VI -> BE -> BK
+ */
+ for(i= 3; i>=0; i--) {
+ if (!IS_DELIVERY_ENABLED(staRecord->powersaveMode[i])) {
+ /* Send One packet, if queue is NULL then continue */
+ if((buffered_pkt=dequeue_tx_data_pdu(priv, &staRecord->dataPdu[i]))) {
+ moreData = uf_is_more_data_for_non_delivery_ac(staRecord);
+
+ buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+
+ /* Last parameter is EOSP & its false always for PS-POLL processing */
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staRecord,moreData,FALSE)) == -ENOSPC) {
+ /* Clear the trigger bit transmission control*/
+ buffered_pkt->transmissionControl &= ~(TRANSMISSION_CONTROL_TRIGGER_MASK | TRANSMISSION_CONTROL_EOSP_MASK);
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &staRecord->dataPdu[i]);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ priv->pausedStaHandle[0]=(CsrUint8)(staRecord->assignedHandle);
+ unifi_trace(priv, UDBG1, "(ENOSPC) PS-POLL received : PDU sending failed \n");
+ } else {
+ if(r) {
+ unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ break;
+ }
+ }
+ }
+ }
+ /* Check if all AC's are Delivery Enabled */
+ is_all_ac_deliver_enabled_and_moredata(staRecord, &allDeliveryEnabled, &dataAvailable);
+ /*check for more data in non-delivery enabled queues*/
+ moreData = (uf_is_more_data_for_non_delivery_ac(staRecord) || (allDeliveryEnabled && dataAvailable));
+ if(!moreData && (staRecord->timSet == CSR_WIFI_TIM_SET)) {
+ unifi_trace(priv, UDBG3, "more data = NULL, set tim to 0 in uf_process_ps_poll\n");
+ if (!staRecord->timRequestPendingFlag){
+ update_tim(priv,staRecord->aid,0,interfaceTag, staRecord->assignedHandle);
+ }
+ else
+ {
+ /* Cache the TimSet value so that it will processed immidiatly after
+ * completing the current setTim Request
+ */
+ staRecord->updateTimReqQueued = 0;
+ unifi_trace(priv, UDBG6, "update_tim : One more UpdateTim Request (Tim value:%d) Queued for AID %x\n", staRecord->updateTimReqQueued,
+ staRecord->aid);
+ }
+
+ }
+ }
+
+ unifi_trace(priv, UDBG3, "leaving uf_process_ps_poll\n");
+}
+
+
+
+void add_to_send_cfm_list(unifi_priv_t * priv,
+ tx_buffered_packets_t *tx_q_item,
+ struct list_head *frames_need_cfm_list)
+{
+ tx_buffered_packets_t *send_cfm_list_item = NULL;
+
+ send_cfm_list_item = (tx_buffered_packets_t *) kmalloc(sizeof(tx_buffered_packets_t), GFP_ATOMIC);
+
+ if(send_cfm_list_item == NULL){
+ unifi_warning(priv, "%s: Failed to allocate memory for new list item \n");
+ return;
+ }
+
+ INIT_LIST_HEAD(&send_cfm_list_item->q);
+
+ send_cfm_list_item->hostTag = tx_q_item->hostTag;
+ send_cfm_list_item->interfaceTag = tx_q_item->interfaceTag;
+ send_cfm_list_item->transmissionControl = tx_q_item->transmissionControl;
+ send_cfm_list_item->leSenderProcessId = tx_q_item->leSenderProcessId;
+ send_cfm_list_item->rate = tx_q_item->rate;
+ memcpy(send_cfm_list_item->peerMacAddress.a, tx_q_item->peerMacAddress.a, ETH_ALEN);
+ send_cfm_list_item->priority = tx_q_item->priority;
+
+ list_add_tail(&send_cfm_list_item->q, frames_need_cfm_list);
+}
+
+void uf_prepare_send_cfm_list_for_queued_pkts(unifi_priv_t * priv,
+ struct list_head *frames_need_cfm_list,
+ struct list_head * list)
+{
+ tx_buffered_packets_t *tx_q_item = NULL;
+ struct list_head *listHead;
+ struct list_head *placeHolder;
+ unsigned long lock_flags;
+
+ func_enter();
+
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+
+ /* Search through the list and if confirmation required for any frames,
+ add it to the send_cfm list */
+ list_for_each_safe(listHead, placeHolder, list) {
+ tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
+
+ if(!tx_q_item) {
+ unifi_error(priv, "Entry should exist, otherwise it is a (BUG)\n");
+ continue;
+ }
+
+ /* check if confirmation is requested and if the sender ID
+ is not netdevice client then save the entry in the list for need cfms */
+ if (!(tx_q_item->transmissionControl & CSR_NO_CONFIRM_REQUIRED) &&
+ (tx_q_item->leSenderProcessId != priv->netdev_client->sender_id)){
+ unifi_trace(priv, UDBG1, "%s: SenderProcessID=%x host tag=%x transmission control=%x\n",
+ __FUNCTION__,
+ tx_q_item->leSenderProcessId,
+ tx_q_item->hostTag,
+ tx_q_item->transmissionControl);
+
+ add_to_send_cfm_list(priv, tx_q_item, frames_need_cfm_list);
+ }
+ }
+
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+
+ func_exit();
+}
+
+
+
+void uf_flush_list(unifi_priv_t * priv, struct list_head * list)
+{
+ tx_buffered_packets_t *tx_q_item;
+ struct list_head *listHead;
+ struct list_head *placeHolder;
+ unsigned long lock_flags;
+
+ unifi_trace(priv, UDBG5, "entering the uf_flush_list \n");
+
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ /* go through list, delete & free memory */
+ list_for_each_safe(listHead, placeHolder, list) {
+ tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
+
+ if(!tx_q_item) {
+ unifi_error(priv, "entry should exists, otherwise crashes (bug)\n");
+ }
+ unifi_trace(priv, UDBG5,
+ "proccess_tx: in uf_flush_list peerMacAddress=%02X%02X%02X%02X%02X%02X senderProcessId=%x\n",
+ tx_q_item->peerMacAddress.a[0], tx_q_item->peerMacAddress.a[1],
+ tx_q_item->peerMacAddress.a[2], tx_q_item->peerMacAddress.a[3],
+ tx_q_item->peerMacAddress.a[4], tx_q_item->peerMacAddress.a[5],
+ tx_q_item->leSenderProcessId);
+
+ list_del(listHead);
+ /* free the allocated memory */
+ unifi_net_data_free(priv, &tx_q_item->bulkdata);
+ kfree(tx_q_item);
+ tx_q_item = NULL;
+ if (!priv->noOfPktQueuedInDriver) {
+ unifi_error(priv, "packets queued in driver 0 still decrementing in %s\n", __FUNCTION__);
+ } else {
+ priv->noOfPktQueuedInDriver--;
+ }
+ }
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+}
+
+tx_buffered_packets_t *dequeue_tx_data_pdu(unifi_priv_t *priv, struct list_head *txList)
+{
+ /* dequeue the tx data packets from the appropriate queue */
+ tx_buffered_packets_t *tx_q_item = NULL;
+ struct list_head *listHead;
+ struct list_head *placeHolder;
+ unsigned long lock_flags;
+
+ unifi_trace(priv, UDBG5, "entering dequeue_tx_data_pdu\n");
+ /* check for list empty */
+ if (list_empty(txList)) {
+ unifi_trace(priv, UDBG5, "In dequeue_tx_data_pdu, the list is empty\n");
+ return NULL;
+ }
+
+ /* Verification, if packet count is negetive */
+ if (priv->noOfPktQueuedInDriver == 0xFFFF) {
+ unifi_warning(priv, "no packet available in queue: debug");
+ return NULL;
+ }
+
+ /* return first node after header, & delete from the list && atleast one item exist */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_for_each_safe(listHead, placeHolder, txList) {
+ tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
+ list_del(listHead);
+ break;
+ }
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+
+ if (tx_q_item) {
+ unifi_trace(priv, UDBG5,
+ "proccess_tx: In dequeue_tx_data_pdu peerMacAddress=%02X%02X%02X%02X%02X%02X senderProcessId=%x\n",
+ tx_q_item->peerMacAddress.a[0], tx_q_item->peerMacAddress.a[1],
+ tx_q_item->peerMacAddress.a[2], tx_q_item->peerMacAddress.a[3],
+ tx_q_item->peerMacAddress.a[4], tx_q_item->peerMacAddress.a[5],
+ tx_q_item->leSenderProcessId);
+ }
+
+ unifi_trace(priv, UDBG5, "leaving dequeue_tx_data_pdu\n");
+ return tx_q_item;
+}
+/* generic function to get the station record handler */
+CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(unifi_priv_t *priv,
+ const CsrUint8 *peerMacAddress,
+ CsrUint16 interfaceTag)
+{
+ CsrUint8 i;
+ netInterface_priv_t *interfacePriv;
+ unsigned long lock_flags;
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "interfaceTag is not proper, interfaceTag = %d\n", interfaceTag);
+ return NULL;
+ }
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ /* disable the preemption untill station record is fetched */
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+
+ for (i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ if (interfacePriv->staInfo[i]!= NULL) {
+ if (!memcmp(((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[i]))->peerMacAddress.a, peerMacAddress, ETH_ALEN)) {
+ /* enable the preemption as station record is fetched */
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ unifi_trace(priv, UDBG5, "peer entry found in station record\n");
+ return ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[i]));
+ }
+ }
+ }
+ /* enable the preemption as station record is fetched */
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ unifi_trace(priv, UDBG5, "peer entry not found in station record\n");
+ return NULL;
+}
+/* generic function to get the station record handler from the handle */
+CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_priv_t *priv,
+ CsrUint32 handle,
+ CsrUint16 interfaceTag)
+{
+ netInterface_priv_t *interfacePriv;
+
+ if ((handle >= UNIFI_MAX_CONNECTIONS) || (interfaceTag >= CSR_WIFI_NUM_INTERFACES)) {
+ unifi_error(priv, "handle/interfaceTag is not proper, handle = %d, interfaceTag = %d\n", handle, interfaceTag);
+ return NULL;
+ }
+ interfacePriv = priv->interfacePriv[interfaceTag];
+ return ((CsrWifiRouterCtrlStaInfo_t *) (interfacePriv->staInfo[handle]));
+}
+
+/* Function to do inactivity */
+void uf_check_inactivity(unifi_priv_t *priv, CsrUint16 interfaceTag, CsrTime currentTime)
+{
+ CsrUint32 i;
+ CsrWifiRouterCtrlStaInfo_t *staInfo;
+ CsrTime elapsedTime; /* Time in microseconds */
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ CsrWifiMacAddress peerMacAddress;
+ unsigned long lock_flags;
+
+ if (interfacePriv == NULL) {
+ unifi_trace(priv, UDBG3, "uf_check_inactivity: Interface priv is NULL \n");
+ return;
+ }
+
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ /* Go through the list of stations to check for inactivity */
+ for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv, i, interfaceTag);
+ if(!staInfo ) {
+ continue;
+ }
+
+ unifi_trace(priv, UDBG3, "Running Inactivity handler Time %xus station's last activity %xus\n",
+ currentTime, staInfo->lastActivity);
+
+
+ elapsedTime = (currentTime >= staInfo->lastActivity)?
+ (currentTime - staInfo->lastActivity):
+ (~((CsrUint32)0) - staInfo->lastActivity + currentTime);
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+
+ if (elapsedTime > MAX_INACTIVITY_INTERVAL) {
+ memcpy((CsrUint8*)&peerMacAddress, (CsrUint8*)&staInfo->peerMacAddress, sizeof(CsrWifiMacAddress));
+
+ /* Indicate inactivity for the station */
+ unifi_trace(priv, UDBG3, "Station %x:%x:%x:%x:%x:%x inactive since %xus\n sending Inactive Ind\n",
+ peerMacAddress.a[0], peerMacAddress.a[1],
+ peerMacAddress.a[2], peerMacAddress.a[3],
+ peerMacAddress.a[4], peerMacAddress.a[5],
+ elapsedTime);
+
+ CsrWifiRouterCtrlStaInactiveIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, peerMacAddress);
+ }
+ }
+
+ interfacePriv->last_inactivity_check = currentTime;
+}
+
+/* Function to update activity of a station */
+void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *peerMacAddress)
+{
+ CsrTime elapsedTime, currentTime; /* Time in microseconds */
+ CsrTime timeHi; /* Not used - Time in microseconds */
+ CsrWifiRouterCtrlStaInfo_t *staInfo;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ unsigned long lock_flags;
+
+ if (interfacePriv == NULL) {
+ unifi_trace(priv, UDBG3, "uf_check_inactivity: Interface priv is NULL \n");
+ return;
+ }
+
+ currentTime = CsrTimeGet(&timeHi);
+
+
+ staInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv, peerMacAddress, interfaceTag);
+
+ if (staInfo == NULL) {
+ unifi_trace(priv, UDBG4, "Sta does not exist yet");
+ return;
+ }
+
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ /* Update activity */
+ staInfo->lastActivity = currentTime;
+
+ /* See if inactivity handler needs to be run
+ * Here it is theoretically possible that the counter may have wrapped around. But
+ * since we just want to know when to run the inactivity handler it does not really matter.
+ * Especially since this is data path it makes sense in keeping it simple and avoiding
+ * 64 bit handling */
+ elapsedTime = (currentTime >= interfacePriv->last_inactivity_check)?
+ (currentTime - interfacePriv->last_inactivity_check):
+ (~((CsrUint32)0) - interfacePriv->last_inactivity_check + currentTime);
+
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+
+ /* Check if it is time to run the inactivity handler */
+ if (elapsedTime > INACTIVITY_CHECK_INTERVAL) {
+ uf_check_inactivity(priv, interfaceTag, currentTime);
+ }
+}
+void resume_unicast_buffered_frames(unifi_priv_t *priv, CsrUint16 interfaceTag)
+{
+
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ CsrUint8 i;
+ int j;
+ tx_buffered_packets_t * buffered_pkt = NULL;
+ CsrBool hipslotFree[4] = {TRUE,TRUE,TRUE,TRUE};
+ int r;
+ unsigned long lock_flags;
+
+ func_enter();
+ while(!isRouterBufferEnabled(priv,3) &&
+ ((buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMgtFrames))!=NULL)) {
+ buffered_pkt->transmissionControl &=
+ ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,NULL,0,FALSE)) == -ENOSPC) {
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &interfacePriv->genericMgtFrames);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ hipslotFree[3]=FALSE;
+ break;
+ }else {
+ if(r){
+ unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ }
+ for(i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ CsrWifiRouterCtrlStaInfo_t *staInfo = interfacePriv->staInfo[i];
+ if(!hipslotFree[0] && !hipslotFree[1] && !hipslotFree[2] && !hipslotFree[3]) {
+ unifi_trace(priv, UDBG3, "(ENOSPC) in resume_unicast_buffered_frames:: hip slots are full \n");
+ break;
+ }
+ if (staInfo && (staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)) {
+ while((( TRUE == hipslotFree[3] ) && (buffered_pkt=dequeue_tx_data_pdu(priv, &staInfo->mgtFrames)))) {
+ buffered_pkt->transmissionControl &=
+ ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,0,FALSE)) == -ENOSPC) {
+ unifi_trace(priv, UDBG3, "(ENOSPC) in resume_unicast_buffered_frames:: hip slots are full for voice queue\n");
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &staInfo->mgtFrames);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ priv->pausedStaHandle[3]=(CsrUint8)(staInfo->assignedHandle);
+ hipslotFree[3] = FALSE;
+ break;
+ } else {
+ if(r){
+ unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ }
+
+ for(j=3;j>=0;j--) {
+ if(!hipslotFree[j])
+ continue;
+
+ while((buffered_pkt=dequeue_tx_data_pdu(priv, &staInfo->dataPdu[j]))) {
+ buffered_pkt->transmissionControl &=
+ ~(TRANSMISSION_CONTROL_TRIGGER_MASK|TRANSMISSION_CONTROL_EOSP_MASK);
+ if((r=frame_and_send_queued_pdu(priv,buffered_pkt,staInfo,0,FALSE)) == -ENOSPC) {
+ /* Enqueue at the head of the queue */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_add(&buffered_pkt->q, &staInfo->dataPdu[j]);
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ priv->pausedStaHandle[j]=(CsrUint8)(staInfo->assignedHandle);
+ hipslotFree[j]=FALSE;
+ break;
+ } else {
+ if(r){
+ unifi_trace (priv, UDBG1, " HIP validation failure : PDU sending failed \n");
+ /* the PDU failed where we can't do any thing so free the storage */
+ unifi_net_data_free(priv, &buffered_pkt->bulkdata);
+ }
+ kfree(buffered_pkt);
+ }
+ }
+ }
+ }
+ }
+ func_exit();
+}
+void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,CsrUint16 interfaceTag)
+{
+
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+ unsigned long lock_flags;
+ struct list_head *listHead;
+ struct list_head *placeHolder;
+ tx_buffered_packets_t *tx_q_item;
+
+ func_enter();
+ if (interfacePriv->noOfbroadcastPktQueued) {
+
+ /* Update the EOSP to the HEAD of b/c list
+ * beacuse we have received any mgmt packet so it should not hold for long time
+ * peer may time out.
+ */
+ spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
+ list_for_each_safe(listHead, placeHolder, &interfacePriv->genericMulticastOrBroadCastFrames) {
+ tx_q_item = list_entry(listHead, tx_buffered_packets_t, q);
+ tx_q_item->transmissionControl |= TRANSMISSION_CONTROL_EOSP_MASK;
+ tx_q_item->transmissionControl = (tx_q_item->transmissionControl & ~(CSR_NO_CONFIRM_REQUIRED));
+ unifi_trace(priv, UDBG1,"updating eosp for list Head hostTag:= 0x%x ",tx_q_item->hostTag);
+ break;
+ }
+ spin_unlock_irqrestore(&priv->tx_q_lock,lock_flags);
+ }
+ func_exit();
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * resume_suspended_uapsd
+ *
+ * This function takes care processing packets of Unscheduled Service Period,
+ * which been suspended earlier due to DTIM/HIP ENOSPC scenarios
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * interfaceTag For which resume should happen
+ * ---------------------------------------------------------------------------
+ */
+void resume_suspended_uapsd(unifi_priv_t* priv,CsrUint16 interfaceTag)
+{
+
+ CsrUint8 startIndex;
+ CsrWifiRouterCtrlStaInfo_t * staInfo = NULL;
+ unsigned long lock_flags;
+
+ unifi_trace(priv, UDBG2, "++resume_suspended_uapsd: \n");
+ for(startIndex= 0; startIndex < UNIFI_MAX_CONNECTIONS;startIndex++) {
+ staInfo = CsrWifiRouterCtrlGetStationRecordFromHandle(priv,startIndex,interfaceTag);
+
+ if(!staInfo || !staInfo->wmmOrQosEnabled) {
+ continue;
+ } else if((staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_POWER_SAVE)
+ &&staInfo->uapsdActive && staInfo->uspSuspend) {
+ /* U-APSD Still active & previously suspended either ENOSPC of FH queues OR
+ * due to DTIM activity
+ */
+ uf_handle_uspframes_delivery(priv, staInfo, interfaceTag);
+ } else {
+ unifi_trace(priv, UDBG2, "resume_suspended_uapsd: PS state=%x, uapsdActive?=%x, suspend?=%x\n",
+ staInfo->currentPeerState, staInfo->uapsdActive, staInfo->uspSuspend);
+ if (staInfo->currentPeerState == CSR_WIFI_ROUTER_CTRL_PEER_CONNECTED_ACTIVE)
+ {
+ spin_lock_irqsave(&priv->staRecord_lock,lock_flags);
+ staInfo->uapsdActive = FALSE;
+ staInfo->uspSuspend = FALSE;
+ spin_unlock_irqrestore(&priv->staRecord_lock,lock_flags);
+ }
+ }
+ }
+ unifi_trace(priv, UDBG2, "--resume_suspended_uapsd:\n");
+}
+
+#endif
--- /dev/null
+/*
+ *****************************************************************************
+ *
+ * FILE : unifi_priv.h
+ *
+ * PURPOSE : Private header file for unifi driver.
+ *
+ * UDI = UniFi Debug Interface
+ *
+ * Copyright (C) 2005-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ *****************************************************************************
+ */
+#ifndef __LINUX_UNIFI_PRIV_H__
+#define __LINUX_UNIFI_PRIV_H__ 1
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/wait.h>
+#include <linux/sched.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/wireless.h>
+#include <linux/cdev.h>
+#include <linux/kthread.h>
+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,19)
+#include <linux/freezer.h>
+#endif
+
+#ifdef CSR_WIFI_SUPPORT_MMC_DRIVER
+#include <linux/mmc/core.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/sdio_func.h>
+#include <linux/mmc/sdio_ids.h>
+#include <linux/mmc/sdio.h>
+#endif /* CSR_WIFI_SUPPORT_MMC_DRIVER */
+
+#include <linux/fs.h>
+
+#ifdef ANDROID_BUILD
+#include <linux/wakelock.h>
+#endif
+
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_unifi_udi.h"
+#include "csr_wifi_router_lib.h"
+#include "unifiio.h"
+#ifndef CSR_WIFI_HIP_TA_DISABLE
+#include "csr_wifi_vif_utils.h"
+#endif
+
+/* Define the unifi_priv_t before include the unifi_native.h */
+struct unifi_priv;
+typedef struct unifi_priv unifi_priv_t;
+#ifdef CSR_SUPPORT_WEXT_AP
+struct CsrWifiSmeApConfig;
+typedef struct CsrWifiSmeApConfig CsrWifiSmeApConfig_t;
+#endif
+#ifdef CSR_SUPPORT_WEXT
+#include "unifi_wext.h"
+#endif
+
+#ifdef ANDROID_BUILD
+extern struct wake_lock unifi_sdio_wake_lock;
+#endif
+
+#include "unifi_clients.h"
+
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
+#include <linux/workqueue.h>
+
+#undef INIT_WORK
+#define INIT_WORK(_work, _func) \
+ do { \
+ INIT_LIST_HEAD(&(_work)->entry); \
+ (_work)->pending = 0; \
+ PREPARE_WORK((_work), (_func), (_work)); \
+ init_timer(&(_work)->timer); \
+ } while(0)
+
+#endif /* Linux kernel < 2.6.20 */
+
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
+#define UF_NETIF_TX_WAKE_ALL_QUEUES(_netdev) netif_tx_wake_all_queues(_netdev)
+#define UF_NETIF_TX_START_ALL_QUEUES(_netdev) netif_tx_start_all_queues(_netdev)
+#define UF_NETIF_TX_STOP_ALL_QUEUES(_netdev) netif_tx_stop_all_queues(_netdev)
+#else
+#define UF_NETIF_TX_WAKE_ALL_QUEUES(_netdev) netif_wake_queue(_netdev)
+#define UF_NETIF_TX_START_ALL_QUEUES(_netdev) netif_start_queue(_netdev)
+#define UF_NETIF_TX_STOP_ALL_QUEUES(_netdev) netif_stop_queue(_netdev)
+#endif /* Linux kernel >= 2.6.27 */
+
+
+#ifdef CSR_NATIVE_LINUX
+#include "sme_native/unifi_native.h"
+#else
+#include "unifi_sme.h"
+#endif
+
+/* The device major number to use when registering the udi driver */
+#define UNIFI_NAME "unifi"
+/*
+ * MAX_UNIFI_DEVS defines the maximum number of UniFi devices that can be present.
+ * This number should be set to the number of SDIO slots supported by the SDIO
+ * host controller on the platform.
+ * Note: If MAX_UNIFI_DEVS value changes, fw_init[] needs to be corrected in drv.c
+ */
+#define MAX_UNIFI_DEVS 2
+
+/* 802.11 Mac header offsets */
+#define MAC_HEADER_SIZE 24
+#define QOS_CONTROL_HEADER_SIZE 2
+#define HT_CONTROL_HEADER_SIZE 4
+#define QOS_DATA 0x8
+#define QOS_DATA_NULL 0xc
+#define DATA_NULL 0x04
+#define FRAME_CONTROL_ORDER_BIT 0x8000
+#define FRAME_CONTROL_TYPE_FIELD_OFFSET 2
+#define FRAME_CONTROL_SUBTYPE_FIELD_OFFSET 4
+#define IEEE802_11_FRAMETYPE_DATA 0x02
+#define IEEE802_11_FRAMETYPE_CONTROL 0x01
+#define IEEE802_11_FRAMETYPE_MANAGEMENT 0x00
+#define IEEE802_11_FRAMETYPE_RESERVED 0x03
+
+/* octet offset from start of mac header for certain fields */
+#define IEEE802_11_ADDR3_OFFSET 16
+#define IEEE802_11_SEQUENCE_CONTROL_OFFSET 22
+#define IEEE802_11_MAX_DATA_LEN 2304
+
+/* frame control (FC) masks, for frame control as 16 bit integer */
+#define IEEE802_11_FC_TO_DS_MASK 0x100
+#define IEEE802_11_FC_FROM_DS_MASK 0x200
+#define IEEE802_11_FC_MOREDATA_MASK 0x2000
+#define IEEE802_11_FC_PROTECTED_MASK 0x4000
+#define IEEE80211_FC_ORDER_MASK 0x8000
+#define IEEE80211_FC_SUBTYPE_MASK 0x00f0
+#define IEEE80211_FC_TYPE_MASK 0x000c
+#define IEEE80211_FC_PROTO_VERSION_MASK 0x0003
+
+/* selected type and subtype combinations as in 7.1.3.1 table 1
+ For frame control as 16 bit integer, or for ls octet
+*/
+#define IEEE802_11_FC_TYPE_DATA 0x08
+#define IEEE802_11_FC_TYPE_NULL 0x48
+#define IEEE802_11_FC_TYPE_QOS_NULL 0xc8
+#define IEEE802_11_FC_TYPE_QOS_DATA 0x88
+
+#define IEEE802_11_FC_TYPE_DATA_SUBTYPE_RESERVED 0x0D
+
+/* qos control (QC) masks for qos control as 16 bit integer, or for ls octet */
+#define IEEE802_11_QC_TID_MASK 0x0f
+#define IEEE802_11_QC_A_MSDU_PRESENT 0x80
+
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND))
+#define IEEE802_11_QC_NON_TID_BITS_MASK 0xFFF0
+#endif
+
+#define CSR_WIFI_EAPOL_M4_HOST_TAG 0x50000000
+#define IEEE802_11_DATA_FRAME_MAC_HEADER_SIZE 36
+#define MAX_ACCESS_CATOGORY 4
+
+/* Time in us to check for inactivity of stations 5 mins */
+#define INACTIVITY_CHECK_INTERVAL 300000000
+/* Time in us before a station is flagged as inactive */
+#define MAX_INACTIVITY_INTERVAL 300000000
+
+
+/* Define for maximum BA session */
+#define MAX_SUPPORTED_BA_SESSIONS_TX 1
+#define MAX_SUPPORTED_BA_SESSIONS_RX 4
+
+#define MAX_BA_WIND_SIZE 64
+#define MAC_HEADER_ADDR1_OFFSET 4
+#define MAC_HEADER_ADDR2_OFFSET 10
+
+/* Define for age (in us) value for frames in MPDU reorder buffer */
+#define CSR_WIFI_BA_MPDU_FRAME_AGE_TIMEOUT 30000 /* 30 milli seconds */
+
+/* This macro used in prepare_and_add_macheader*/
+#define ADDRESS_ONE_OFFSET 20
+
+/* Defines for STA inactivity detection */
+#define STA_INACTIVE_DETECTION_TRIGGER_THRESHOLD 1 /* in number of stations */
+#define STA_INACTIVE_DETECTION_TIMER_INTERVAL 30 /* in seconds */
+#define STA_INACTIVE_TIMEOUT_VAL 120*1000*1000 /* 120 seconds */
+
+/* Test for modes requiring AP firmware patch */
+#define CSR_WIFI_HIP_IS_AP_FW(mode) ((((mode) == CSR_WIFI_ROUTER_CTRL_MODE_AP) || \
+ ((mode) == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO)) ? TRUE : FALSE)
+
+/* Defines used in beacon filtering in case of P2P */
+#define CSR_WIFI_P2P_WILDCARD_SSID_LENGTH 0x7
+#define CSR_WIFI_80211_FRAME_SUBTYPE_BEACON 0x8
+#define CSR_WIFI_BEACON_FIXED_LENGTH 12
+#define CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET 4
+#define CSR_WIFI_80211_FRAME_SUBTYPE_BIT_MASK ((CsrUint8)(0xF << CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET))
+
+#define CSR_WIFI_80211_GET_FRAME_SUBTYPE(frameBuffer) \
+ ((CsrUint8)(((CsrUint8 *)frameBuffer)[0] & CSR_WIFI_80211_FRAME_SUBTYPE_BIT_MASK) >> CSR_WIFI_FRAME_SUBTYPE_BIT_OFFSET)
+
+/* For M4 request received via netdev*/
+
+typedef CsrUint8 CsrWifiPacketType;
+#define CSR_WIFI_UNICAST_PDU ((CsrWifiPacketType) 0x00)
+#define CSR_WIFI_MULTICAST_PDU ((CsrWifiPacketType) 0x1)
+#define CSR_WIFI_BROADCAST_PDU ((CsrWifiPacketType) 0x2)
+
+#define PRIO_TO_NICE(prio) ((prio) - MAX_RT_PRIO - 20)
+
+/* Module parameter variables */
+extern int buswidth;
+extern int sdio_clock;
+extern int use_5g;
+extern int disable_hw_reset;
+extern int disable_power_control;
+extern int enable_wol;
+extern int sme_debug;
+extern int fw_init[MAX_UNIFI_DEVS];
+extern int tl_80211d;
+extern int sdio_byte_mode;
+extern int sdio_block_size;
+extern int coredump_max;
+extern int run_bh_once;
+extern int bh_priority;
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+extern int log_hip_signals;
+#endif
+
+struct dlpriv {
+ const unsigned char *dl_data;
+ int dl_len;
+ void *fw_desc;
+};
+
+
+struct uf_thread {
+
+ struct task_struct *thread_task;
+
+ /* wait_queue for waking the unifi_thread kernel thread */
+ wait_queue_head_t wakeup_q;
+ unsigned int wakeup_flag;
+
+ /*
+ * Use it to block the I/O thread when
+ * an error occurs or UniFi is reinitialised.
+ */
+ int block_thread;
+
+ char name[16];
+ int prio;
+};
+
+/*
+ * Link list to hold the received packets for the period the port
+ * remains closed.
+ */
+typedef struct rx_buffered_packets {
+ /* List link structure */
+ struct list_head q;
+ /* Packet to indicate when the port reopens */
+ struct sk_buff *skb;
+ /* Bulkdata to free in case the port closes and need to discard the packet */
+ bulk_data_param_t bulkdata;
+ /* The source address of the packet */
+ CsrWifiMacAddress sa;
+ /* The destination address of the packet */
+ CsrWifiMacAddress da;
+ /* Corresponding signal */
+ CSR_SIGNAL signal;
+} rx_buffered_packets_t;
+
+
+typedef CsrUint8 CsrWifiAcPowersaveMode;
+#define CSR_WIFI_AC_TRIGGER_ONLY_ENABLED 0x00
+#define CSR_WIFI_AC_DELIVERY_ONLY_ENABLE 0X01
+#define CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED 0X03
+#define CSR_WIFI_AC_LEGACY_POWER_SAVE 0X02
+
+
+#define IS_DELIVERY_ENABLED(mode) (mode & CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)? 1: 0
+#define IS_DELIVERY_AND_TRIGGER_ENABLED(mode) ((mode & CSR_WIFI_AC_DELIVERY_ONLY_ENABLE)||(mode & CSR_WIFI_AC_TRIGGER_AND_DELIVERY_ENABLED))? 1: 0
+#define IS_DTIM_ACTIVE(flag,hostTag) ((flag == TRUE || hostTag != INVALID_HOST_TAG))
+#define INVALID_HOST_TAG 0xFFFFFFFF
+#define UNIFI_TRAFFIC_Q_CONTENTION UNIFI_TRAFFIC_Q_BE
+
+
+
+
+/* Queue to be used for contention priority */
+
+/*
+ * Link list to hold the tx packets for the period the peer
+ * powersave/free slots in unifi
+ */
+typedef struct tx_buffered_packets {
+ /* List link structure */
+ struct list_head q;
+ CsrUint16 interfaceTag;
+ CSR_CLIENT_TAG hostTag;
+ CSR_PROCESS_ID leSenderProcessId;
+ CSR_TRANSMISSION_CONTROL transmissionControl;
+ CSR_RATE rate;
+ /* Bulkdata to free in case the port closes and need to discard the packet */
+ bulk_data_desc_t bulkdata;
+ /* The source address of the packet */
+ CsrWifiMacAddress peerMacAddress;
+ CSR_PRIORITY priority;
+} tx_buffered_packets_t;
+
+/* station record has this data structure */
+typedef struct CsrWifiRouterCtrlStaInfo_t {
+
+ /* Sme sends these parameters */
+ CsrWifiMacAddress peerMacAddress;
+ CsrUint32 assignedHandle;
+ CsrBool wmmOrQosEnabled;
+ CsrWifiAcPowersaveMode powersaveMode[MAX_ACCESS_CATOGORY];
+ CsrUint16 maxSpLength;
+ CsrBool uapsdActive;
+ CsrUint16 noOfSpFramesSent;
+
+ /* Router/Driver database */
+#ifdef CSR_SUPPORT_SME
+ unifi_port_cfg_t *peerControlledPort;
+ unifi_port_cfg_t *peerUnControlledPort;
+
+ /* Inactivity feature parameters */
+ struct netInterface_priv *interfacePriv;
+ struct work_struct send_disconnected_ind_task;
+ CsrBool activity_flag;
+ CsrUint16 listenIntervalInTus;
+ CSR_CLIENT_TAG nullDataHostTag;
+
+ /* Activity timestamps for the station */
+ CsrTime lastActivity;
+
+ /* during m/c transmission sp suspended */
+ CsrBool uspSuspend;
+ CSR_PRIORITY triggerFramePriority;
+#endif
+ CsrWifiRouterCtrlPeerStatus currentPeerState;
+ struct list_head dataPdu[MAX_ACCESS_CATOGORY];
+ struct list_head mgtFrames;
+ CsrUint8 spStatus;
+ CsrUint8 prevFrmType;
+ CsrUint8 prevFrmAccessCatogory;
+ CsrBool protection;
+ CsrUint16 aid;
+ CsrBool txSuspend;
+ CsrUint8 timSet;
+ /* Dont change the value of below macro for SET & RESET */
+#define CSR_WIFI_TIM_RESET 0
+#define CSR_WIFI_TIM_SET 1
+#define CSR_WIFI_TIM_RESETTING 2
+#define CSR_WIFI_TIM_SETTING 3
+
+ CsrBool timRequestPendingFlag;
+ CsrUint8 updateTimReqQueued;
+ CsrUint16 noOfPktQueued;
+}CsrWifiRouterCtrlStaInfo_t;
+
+#ifdef CSR_SUPPORT_WEXT_AP
+struct CsrWifiSmeApConfig {
+ CsrWifiSsid ssid;
+ CsrUint16 channel;
+ CsrWifiNmeApCredentials credentials;
+ CsrUint8 max_connections;
+ CsrUint8 if_index;
+};
+#endif
+
+#ifdef CSR_WIFI_RX_PATH_SPLIT
+/* This is a test code and may be removed later*/
+#define CSR_WIFI_RX_SIGNAL_BUFFER_SIZE (60+1)
+
+typedef struct
+{
+ CsrUint8 *bufptr; /* Signal Primitive */
+ bulk_data_param_t data_ptrs; /* Bulk Data pointers */
+ CsrUint16 sig_len;
+}rx_buff_struct_t;
+
+typedef struct
+{
+ CsrUint8 writePointer; /**< write pointer */
+ CsrUint8 readPointer; /**< read pointer */
+ CsrUint8 size; /**< size of circular buffer */
+ rx_buff_struct_t rx_buff[CSR_WIFI_RX_SIGNAL_BUFFER_SIZE]; /**< Element of ciruclar buffer */
+} rxCircularBuffer_t;
+
+void rx_wq_handler(struct work_struct *work);
+#endif
+
+struct unifi_priv {
+
+ card_t *card;
+ CsrSdioFunction *sdio;
+
+ /* Index into Unifi_instances[] for this device. */
+ int instance;
+ /* Reference count for this instance */
+ int ref_count;
+
+ /* Firmware images */
+ struct dlpriv fw_sta;
+ struct dlpriv fw_conv; /* used for conversion of production test image */
+
+ /* Char device related structures */
+ struct cdev unifi_cdev;
+ struct cdev unifiudi_cdev;
+ struct device *unifi_device;
+
+ /* Which wireless interface to use (1 - 2.4GHz, 2 - 5GHz) */
+ CSR_IFINTERFACE if_index;
+
+ /* For multiple interface support */
+ struct net_device *netdev[CSR_WIFI_NUM_INTERFACES];
+ struct netInterface_priv *interfacePriv[CSR_WIFI_NUM_INTERFACES];
+
+ CsrUint8 totalInterfaceCount;
+
+ int prev_queue;
+
+ /* Name of node under /proc */
+ char proc_entry_name[64];
+
+ /*
+ * Flags:
+ * drop_unencrypted
+ * - Not used?
+ * netdev_registered
+ * - whether the netdev has been registered.
+ */
+ unsigned int drop_unencrypted : 1;
+
+ /* Our list of unifi linux clients. */
+ ul_client_t ul_clients[MAX_UDI_CLIENTS];
+
+ /* Mutex to protect using the logging hook after UDI client is gone */
+ struct semaphore udi_logging_mutex;
+ /* Pointer to the ul_clients[] array */
+ ul_client_t *logging_client;
+
+ /* A ul_client_t* used to send the netdev related MIB requests. */
+ ul_client_t *netdev_client;
+
+ /* The SME ul_client_t pointer. */
+ ul_client_t *sme_cli;
+
+ /* The AMP ul_client_t pointer. */
+ ul_client_t *amp_client;
+
+ /*
+ * Semaphore for locking the top-half to one user process.
+ * This is necessary to prevent multiple processes calling driver
+ * operations. This can happen because the network driver entry points
+ * can be called from multiple processes.
+ */
+#ifdef USE_DRIVER_LOCK
+ struct semaphore lock;
+#endif /* USE_DRIVER_LOCK */
+
+ /* Flag to say that an operation was aborted */
+ int io_aborted;
+
+ struct uf_thread bh_thread;
+
+#define UNIFI_INIT_NONE 0x00
+#define UNIFI_INIT_IN_PROGRESS 0x01
+#define UNIFI_INIT_FW_DOWNLOADED 0x02
+#define UNIFI_INIT_COMPLETED 0x04
+ unsigned char init_progress;
+
+ int sme_is_present;
+
+ /* The WMM features that UniFi uses in the current BSS */
+ unsigned int sta_wmm_capabilities;
+
+ /* Debug only */
+ char last_debug_string[256];
+ unsigned short last_debug_word16[16];
+
+#ifdef CSR_SUPPORT_SME
+ /* lock to protect the tx queues list */
+ spinlock_t tx_q_lock;
+ CsrUint8 allPeerDozing;
+ CsrUint8 pausedStaHandle[MAX_ACCESS_CATOGORY];
+ /* Max packet the driver can queue, irrespective of interface number */
+ CsrUint16 noOfPktQueuedInDriver;
+#define CSR_WIFI_DRIVER_SUPPORT_FOR_MAX_PKT_QUEUEING 512
+#define CSR_WIFI_DRIVER_MAX_PKT_QUEUING_THRESHOLD_PER_PEER 64
+#define CSR_WIFI_DRIVER_MINIMUM_BROADCAST_PKT_THRESHOLD 3
+
+ CsrBool routerBufferEnable[MAX_ACCESS_CATOGORY];
+ /* lock to protect stainfo members and priv members*/
+ spinlock_t staRecord_lock;
+#endif
+#ifdef CSR_NATIVE_LINUX
+#ifdef CSR_SUPPORT_WEXT
+ /* wireless config */
+ struct wext_config wext_conf;
+#endif
+
+ /* Mutex to protect the MLME blocking requests */
+ struct semaphore mlme_blocking_mutex;
+
+ /* The ul_client that provides the blocking API for WEXT calls */
+ ul_client_t *wext_client;
+
+#endif /* CSR_NATIVE_LINUX */
+
+#ifdef CSR_SUPPORT_SME
+ wait_queue_head_t sme_request_wq;
+ /* Semaphore to protect the SME blocking requests */
+ struct semaphore sme_sem;
+ /* Structure to hold the SME blocking requests data*/
+ sme_reply_t sme_reply;
+
+ /* Structure to hold a traffic protocol indication */
+ struct ta_ind {
+ struct work_struct task;
+ CsrWifiRouterCtrlTrafficPacketType packet_type;
+ CsrWifiRouterCtrlProtocolDirection direction;
+ CsrWifiMacAddress src_addr;
+ int in_use;
+ } ta_ind_work;
+
+ struct ta_sample_ind {
+ struct work_struct task;
+ CsrWifiRouterCtrlTrafficStats stats;
+ int in_use;
+ } ta_sample_ind_work;
+
+ __be32 sta_ip_address;
+ CsrWifiRouterCtrlSmeVersions sme_versions;
+
+ /*
+ * Flag to reflect state of unifi_sys_wifi_on_*() progress.
+ * This indicates whether we are in an "wifi on" state when we are
+ * allowed to indication errors with unifi_mgt_wifi_off_ind()
+ */
+ enum {
+ wifi_on_unspecified = -1,
+ wifi_on_in_progress = 0,
+ wifi_on_done = 1,
+ } wifi_on_state;
+
+ /* Userspace TaskId for the SME Set when a wifi on req is received */
+ CsrSchedQid CSR_WIFI_SME_IFACEQUEUE;
+
+ struct work_struct multicast_list_task;
+ /*
+ * The SME installs filters to ask for specific MA-UNITDATA.req
+ * to be passed to different SME components.
+ */
+#define MAX_MA_UNIDATA_IND_FILTERS 8
+ sme_ma_unidata_ind_filter_t sme_unidata_ind_filters[MAX_MA_UNIDATA_IND_FILTERS];
+
+/* UNIFI_CFG related parameters */
+ uf_cfg_bcast_packet_filter_t packet_filters;
+ unsigned char *filter_tclas_ies;
+ /* The structure that holds all the connection configuration. */
+ CsrWifiSmeConnectionConfig connection_config;
+#ifdef CSR_SUPPORT_WEXT
+
+ int ignore_bssid_join;
+ struct iw_statistics wext_wireless_stats;
+
+ /* The MIB and MAC address files contents, read from userspace */
+ CsrWifiSmeDataBlock mib_data;
+ CsrWifiMacAddress sta_mac_address;
+
+ int wep_tx_key_index;
+ wep_key_t wep_keys[NUM_WEPKEYS];
+
+
+#ifdef CSR_SUPPORT_WEXT_AP
+ CsrWifiSmeApMacConfig ap_mac_config;
+ CsrWifiNmeApConfig group_sec_config;
+ CsrWifiSmeApConfig_t ap_config;
+#endif
+ struct work_struct sme_config_task;
+
+#endif /* CSR_SUPPORT_WEXT */
+
+#endif /* CSR_SUPPORT_SME */
+
+#ifdef CSR_SME_USERSPACE
+ void *smepriv;
+#endif /* CSR_SME_USERSPACE */
+
+ card_info_t card_info;
+
+ /* Mutex to protect unifi_send_signal() */
+ spinlock_t send_signal_lock;
+
+
+ /*
+ * The workqueue to offload the TA run
+ * and the multicast addresses list set
+ */
+ struct workqueue_struct *unifi_workqueue;
+
+ unsigned char *mib_cfm_buffer;
+ unsigned int mib_cfm_buffer_length;
+
+ int ptest_mode; /* Set when in production test mode */
+ int coredump_mode; /* Set when SME has requested a coredump */
+ CsrBool wol_suspend; /* Set when suspending with UniFi powered */
+
+#define UF_UNCONTROLLED_PORT_Q 0
+#define UF_CONTROLLED_PORT_Q 1
+
+ /* Semaphore to protect the rx queues list */
+ struct semaphore rx_q_sem;
+
+ /* Spinlock to protect M4 data */
+ spinlock_t m4_lock;
+ /* Mutex to protect BA RX data */
+ struct semaphore ba_mutex;
+
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
+ /* Spinlock to protect the WAPI data */
+ spinlock_t wapi_lock;
+#endif
+
+#ifndef ALLOW_Q_PAUSE
+ /* Array to indicate if a particular Tx queue is paused, this may not be
+ * required in a multiqueue implementation since we can directly stop kernel
+ * queues */
+ CsrUint8 tx_q_paused_flag[UNIFI_TRAFFIC_Q_MAX];
+#endif
+
+#ifdef CSR_WIFI_RX_PATH_SPLIT
+ struct workqueue_struct *rx_workqueue;
+ struct work_struct rx_work_struct;
+ rxCircularBuffer_t rxSignalBuffer;
+
+#endif
+
+ CsrUint32 rxTcpThroughput;
+ CsrUint32 txTcpThroughput;
+ CsrUint32 rxUdpThroughput;
+ CsrUint32 txUdpThroughput;
+
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ /*Set if multicast KeyID = 1*/
+ CsrUint8 wapi_multicast_filter;
+ /*Set if unicast KeyID = 1*/
+ CsrUint8 wapi_unicast_filter;
+ CsrUint8 wapi_unicast_queued_pkt_filter;
+#ifdef CSR_WIFI_SECURITY_WAPI_QOSCTRL_MIC_WORKAROUND
+ CsrBool isWapiConnection;
+#endif
+#endif
+
+#ifdef CSR_WIFI_SPLIT_PATCH
+ CsrWifiRouterCtrlModeSetReq pending_mode_set;
+#endif
+
+ CsrBool cmanrTestMode;
+ CSR_RATE cmanrTestModeTransmitRate;
+
+};
+
+typedef struct {
+ CsrUint16 queue_length[4];
+ CsrUint8 os_queue_paused;
+} unifi_OsQosInfo;
+
+
+typedef struct {
+ CsrBool active;
+ bulk_data_param_t bulkdata;
+ CSR_SIGNAL signal;
+ CsrUint16 sn;
+ CsrTime recv_time;
+} frame_desc_struct;
+
+typedef struct {
+ frame_desc_struct *buffer;
+ CsrUint16 wind_size;
+ CsrUint16 occupied_slots;
+ struct timer_list timer;
+ CsrUint16 timeout;
+ CsrUint16 expected_sn;
+ CsrUint16 start_sn;
+ CsrBool trigger_ba_after_ssn;
+ struct netInterface_priv *interfacePriv;
+ CsrUint16 tID;
+ CsrWifiMacAddress macAddress;
+ struct work_struct send_ba_err_task;
+} ba_session_rx_struct;
+
+
+typedef struct {
+ struct netInterface_priv *interfacePriv;
+ CsrUint16 tID;
+ CsrWifiMacAddress macAddress;
+} ba_session_tx_struct;
+
+typedef struct netInterface_priv
+{
+ CsrUint16 InterfaceTag;
+ struct unifi_priv *privPtr;
+ ba_session_tx_struct *ba_session_tx[MAX_SUPPORTED_BA_SESSIONS_TX];
+ ba_session_rx_struct *ba_session_rx[MAX_SUPPORTED_BA_SESSIONS_RX];
+ frame_desc_struct ba_complete[MAX_BA_WIND_SIZE];
+ CsrUint8 ba_complete_index;
+ CsrUint8 queueEnabled[UNIFI_NO_OF_TX_QS];
+ struct work_struct send_m4_ready_task;
+#ifdef CSR_WIFI_SECURITY_WAPI_ENABLE
+ struct work_struct send_pkt_to_encrypt;
+#endif
+ struct net_device_stats stats;
+ CsrUint8 interfaceMode;
+ CsrBool protect;
+ CsrWifiMacAddress bssid;
+ /*
+ * Flag to reflect state of CONNECTED indication signal.
+ * This indicates whether we are "joined" an Access Point (i.e. have
+ * nominated an AP and are receiving beacons) but give no indication
+ * of whether we are authenticated and/or associated.
+ */
+ enum {
+ UnifiConnectedUnknown = -1,
+ UnifiNotConnected = 0,
+ UnifiConnected = 1,
+ } connected;
+#ifdef CSR_SUPPORT_WEXT
+ /* Tracks when we are waiting for a netdevice state change callback */
+ CsrBool wait_netdev_change;
+ /* True if we have successfully registered for netdev callbacks */
+ CsrBool netdev_callback_registered;
+#endif /* CSR_SUPPORT_WEXT */
+ unsigned int netdev_registered;
+#define UNIFI_MAX_MULTICAST_ADDRESSES 10
+ /* The multicast addresses list that the thread needs to set. */
+ u8 mc_list[UNIFI_MAX_MULTICAST_ADDRESSES*ETH_ALEN];
+ /* The multicast addresses count that the thread needs to set. */
+ int mc_list_count;
+ CsrUint32 tag;
+#ifdef CSR_SUPPORT_SME
+ /* (un)controlled port configuration */
+ unifi_port_config_t controlled_data_port;
+ unifi_port_config_t uncontrolled_data_port;
+
+ /* station record maintenance related data structures */
+ CsrUint8 num_stations_joined;
+ CsrWifiRouterCtrlStaInfo_t *(staInfo)[UNIFI_MAX_CONNECTIONS];
+ struct list_head genericMgtFrames;
+ struct list_head genericMulticastOrBroadCastFrames;
+ struct list_head genericMulticastOrBroadCastMgtFrames;
+
+ /* Timer for detecting station inactivity */
+ struct timer_list sta_activity_check_timer;
+ CsrBool sta_activity_check_enabled;
+
+ /* Timestamp when the last inactivity check was done */
+ CsrTime last_inactivity_check;
+
+ /*number of multicast or borad cast packets queued*/
+ CsrUint16 noOfbroadcastPktQueued;
+#endif
+ /* A list to hold the buffered uncontrolled port packets */
+ struct list_head rx_uncontrolled_list;
+ /* A list to hold the buffered controlled port packets */
+ struct list_head rx_controlled_list;
+ /* Buffered M4 signal to take care of WPA race condition */
+ CSR_SIGNAL m4_signal;
+ bulk_data_desc_t m4_bulk_data;
+
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
+ /* Buffered WAPI Unicast MA Packet Request for encryption in Sme */
+ CSR_SIGNAL wapi_unicast_ma_pkt_sig;
+ bulk_data_desc_t wapi_unicast_bulk_data;
+#endif
+
+ /* This should be removed and m4_hostTag should be used for checking*/
+ CsrBool m4_sent;
+ CSR_CLIENT_TAG m4_hostTag;
+ CsrBool dtimActive;
+ CsrBool intraBssEnabled;
+ CsrUint32 multicastPduHostTag; /* Used to set the tim after getting
+ a confirm for it */
+ CsrBool bcTimSet;
+ CsrBool bcTimSetReqPendingFlag;
+ CsrBool bcTimSetReqQueued;
+} netInterface_priv_t;
+
+#ifndef ALLOW_Q_PAUSE
+#define net_is_tx_q_paused(priv, q) (priv->tx_q_paused_flag[q])
+#define net_tx_q_unpause(priv, q) (priv->tx_q_paused_flag[q] = 0)
+#define net_tx_q_pause(priv, q) (priv->tx_q_paused_flag[q] = 1)
+#endif
+
+#ifdef CSR_SUPPORT_SME
+#define routerStartBuffering(priv,queue) priv->routerBufferEnable[(queue)] = TRUE;
+#define routerStopBuffering(priv,queue) priv->routerBufferEnable[(queue)] = FALSE;
+#define isRouterBufferEnabled(priv,queue) priv->routerBufferEnable[(queue)]
+#endif
+
+#ifdef USE_DRIVER_LOCK
+#define LOCK_DRIVER(_p) down_interruptible(&(_p)->lock)
+#define UNLOCK_DRIVER(_p) up(&(_p)->lock)
+#else
+#define LOCK_DRIVER(_p) (void)(_p); /* as nothing */
+#define UNLOCK_DRIVER(_p) (void)(_p); /* as nothing */
+#endif /* USE_DRIVER_LOCK */
+
+CsrInt32 CsrHipResultToStatus(CsrResult csrResult);
+
+
+/*
+ * SDIO related functions and callbacks
+ */
+int uf_sdio_load(void);
+void uf_sdio_unload(void);
+unifi_priv_t *uf_find_instance(int inst);
+int uf_find_priv(unifi_priv_t *priv);
+int uf_find_netdev_priv(netInterface_priv_t *priv);
+unifi_priv_t *uf_get_instance(int inst);
+void uf_put_instance(int inst);
+int csr_sdio_linux_install_irq(CsrSdioFunction *sdio);
+int csr_sdio_linux_remove_irq(CsrSdioFunction *sdio);
+
+void uf_add_os_device(int bus_id, struct device *os_device);
+void uf_remove_os_device(int bus_id);
+
+
+
+/*
+ * Claim/release SDIO
+ *
+ * For multifunction cards, we cannot grub the SDIO lock around the unifi_bh()
+ * as this prevents other functions using SDIO.
+ * Since some of CSR SDIO API is used regardless of trying to lock unifi_bh()
+ * we have followed this scheme:
+ * 1. If a function needs protection only when CSR_WIFI_SINGLE_FUNCTION is defined
+ * then we call CsrSdioClaim/CsrSdioRelease().
+ * 2. If a function needs protection only when CSR_WIFI_SINGLE_FUNCTION is not defined
+ * then we call _sdio_claim_host/_sdio_claim_host(). Use of this should be restricted
+ * to the SDIO glue layer only (e.g. sdio_mmc.c).
+ * 3. If a function needs protection, regardless of the CSR_WIFI_SINGLE_FUNCTION
+ * then we call directly the sdio_claim_host/sdio_release_host().
+ * Use of this must be restricted to the SDIO glue layer only (e.g. sdio_mmc.c).
+ *
+ * Note: The _func and function pointers are _not_ the same.
+ * The former is the (struct sdio_func*) context, which restricts the use to the SDIO glue layer.
+ * The latter is the (CsrSdioFunction*) context, which allows calls from all layers.
+ */
+
+#ifdef CSR_WIFI_SUPPORT_MMC_DRIVER
+
+#ifdef CSR_WIFI_SINGLE_FUNCTION
+#define CsrSdioClaim(function) sdio_claim_host((function)->priv);
+#define CsrSdioRelease(function) sdio_release_host((function)->priv);
+
+#define _sdio_claim_host(_func)
+#define _sdio_release_host(_func)
+
+#else
+#define CsrSdioClaim(function)
+#define CsrSdioRelease(function)
+
+#define _sdio_claim_host(_func) sdio_claim_host(_func)
+#define _sdio_release_host(_func) sdio_release_host(_func)
+
+#endif /* CSR_WIFI_SINGLE_FUNCTION */
+
+#else
+#define _sdio_claim_host(_func)
+#define _sdio_release_host(_func)
+
+#define CsrSdioClaim(function)
+#define CsrSdioRelease(function)
+
+#endif /* CSR_WIFI_SUPPORT_MMC_DRIVER */
+
+
+/*
+ * Functions to allocate and free an ethernet device.
+ */
+unifi_priv_t *uf_alloc_netdevice(CsrSdioFunction *sdio_dev, int bus_id);
+int uf_free_netdevice(unifi_priv_t *priv);
+
+/* Allocating function for other interfaces */
+CsrBool uf_alloc_netdevice_for_other_interfaces(unifi_priv_t *priv, CsrUint16 interfaceTag);
+
+/*
+ * Firmware download related functions.
+ */
+int uf_run_unifihelper(unifi_priv_t *priv);
+int uf_request_firmware_files(unifi_priv_t *priv, int is_fw);
+int uf_release_firmware_files(unifi_priv_t *priv);
+int uf_release_firmware(unifi_priv_t *priv, struct dlpriv *to_free);
+
+/*
+ * Functions to create and delete the device nodes.
+ */
+int uf_create_device_nodes(unifi_priv_t *priv, int bus_id);
+void uf_destroy_device_nodes(unifi_priv_t *priv);
+
+/*
+ * Upper Edge Initialisation functions
+ */
+int uf_init_bh(unifi_priv_t *priv);
+int uf_init_hw(unifi_priv_t *priv);
+
+/* Thread related helper functions */
+int uf_start_thread(unifi_priv_t *priv, struct uf_thread *thread, int (*func)(void *));
+void uf_stop_thread(unifi_priv_t *priv, struct uf_thread *thread);
+void uf_wait_for_thread_to_stop(unifi_priv_t *priv, struct uf_thread *thread);
+
+
+/*
+ * Unifi Linux functions
+ */
+void ul_init_clients(unifi_priv_t *priv);
+
+/* Configuration flags */
+#define CLI_USING_WIRE_FORMAT 0x0002
+#define CLI_SME_USERSPACE 0x0020
+ul_client_t *ul_register_client(unifi_priv_t *priv,
+ unsigned int configuration,
+ udi_event_t udi_event_clbk);
+int ul_deregister_client(ul_client_t *pcli);
+
+int ul_send_signal_unpacked(unifi_priv_t *priv,
+ CSR_SIGNAL *sigptr,
+ bulk_data_param_t *bulkdata);
+int ul_send_signal_raw(unifi_priv_t *priv,
+ unsigned char *sigptr, int siglen,
+ bulk_data_param_t *bulkdata);
+
+void ul_log_config_ind(unifi_priv_t *priv, u8 *conf_param, int len);
+
+
+/*
+ * Data plane operations
+ */
+/*
+ * data_tx.c
+ */
+int uf_verify_m4(unifi_priv_t *priv, const unsigned char *packet,
+ unsigned int length);
+
+#ifdef CSR_SUPPORT_SME
+CsrBool uf_check_broadcast_bssid(unifi_priv_t *priv, const bulk_data_param_t *bulkdata);
+CsrBool uf_process_pm_bit_for_peer(unifi_priv_t * priv, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,CsrUint8 pmBit,CsrUint16 interfaceTag);
+void uf_process_ps_poll(unifi_priv_t *priv,CsrUint8* sa,CsrUint8* da,CsrUint8 pmBit,CsrUint16 interfaceTag);
+int uf_ap_process_data_pdu(unifi_priv_t *priv, struct sk_buff *skb,
+ struct ethhdr *ehdr, CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
+ const CSR_SIGNAL *signal,
+ bulk_data_param_t *bulkdata,
+ CsrUint8 macHeaderLengthInBytes);
+CsrBool uf_is_more_data_for_non_delivery_ac(CsrWifiRouterCtrlStaInfo_t *staRecord);
+void uf_process_wmm_deliver_ac_uapsd ( unifi_priv_t * priv,
+ CsrWifiRouterCtrlStaInfo_t * srcStaInfo,
+ CsrUint16 qosControl,
+ CsrUint16 interfaceTag);
+
+void uf_send_buffered_data_from_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, CsrUint8 queue, struct list_head *txList);
+void uf_send_buffered_data_from_delivery_ac(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo, CsrUint8 queue, struct list_head *txList);
+
+void uf_continue_uapsd(unifi_priv_t *priv, CsrWifiRouterCtrlStaInfo_t * staInfo);
+void uf_send_qos_null(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
+void uf_send_nulldata(unifi_priv_t * priv,CsrUint16 interfaceTag, const CsrUint8 *da,CSR_PRIORITY priority,CsrWifiRouterCtrlStaInfo_t * srcStaInfo);
+
+
+
+#endif
+CsrResult uf_process_ma_packet_req(unifi_priv_t *priv, CsrUint8 *peerMacAddress, CSR_CLIENT_TAG hostTag, CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl, CSR_RATE TransmitRate, CSR_PRIORITY priority, CSR_PROCESS_ID senderId, bulk_data_param_t *bulkdata);
+void uf_process_ma_vif_availibility_ind(unifi_priv_t *priv,CsrUint8 *sigdata, CsrUint32 siglen);
+#ifdef CSR_SUPPORT_SME
+void uf_send_buffered_frames(unifi_priv_t *priv,unifi_TrafficQueue queue);
+int uf_process_station_records_for_sending_data(unifi_priv_t *priv,CsrUint16 interfaceTag,
+ CsrWifiRouterCtrlStaInfo_t *srcStaInfo,
+ CsrWifiRouterCtrlStaInfo_t *dstStaInfo);
+void uf_prepare_send_cfm_list_for_queued_pkts(unifi_priv_t * priv,
+ struct list_head *frames_need_cfm_list,
+ struct list_head * list);
+void send_auto_ma_packet_confirm(unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ struct list_head *buffered_frames_list);
+void uf_flush_list(unifi_priv_t * priv, struct list_head * list);
+tx_buffered_packets_t *dequeue_tx_data_pdu(unifi_priv_t *priv, struct list_head *txList);
+void resume_unicast_buffered_frames(unifi_priv_t *priv, CsrUint16 interfaceTag);
+void update_eosp_to_head_of_broadcast_list_head(unifi_priv_t *priv,CsrUint16 interfaceTag);
+void resume_suspended_uapsd(unifi_priv_t* priv,CsrUint16 interfaceTag);
+#endif
+/*
+ * netdev.c
+ */
+
+#ifndef P80211_OUI_LEN
+#define P80211_OUI_LEN 3
+#endif
+typedef struct {
+ u8 dsap; /* always 0xAA */
+ u8 ssap; /* always 0xAA */
+ u8 ctrl; /* always 0x03 */
+ u8 oui[P80211_OUI_LEN]; /* organizational universal id */
+ u16 protocol;
+} __attribute__ ((packed)) llc_snap_hdr_t;
+int skb_add_llc_snap(struct net_device *dev, struct sk_buff *skb, int proto);
+int skb_80211_to_ether(unifi_priv_t *priv, struct sk_buff *skb,
+ const unsigned char *daddr, const unsigned char *saddr,
+ const CSR_SIGNAL *signal,
+ bulk_data_param_t *bulkdata);
+
+const char *result_code_str(int result);
+
+
+/* prepares & appends the Mac header for the payload */
+int prepare_and_add_macheader(unifi_priv_t *priv,
+ struct sk_buff *skb,
+ struct sk_buff *newSkb,
+ CSR_PRIORITY priority,
+ bulk_data_param_t *bulkdata,
+ CsrUint16 interfaceTag,
+ const CsrUint8 *daddr,
+ const CsrUint8 *saddr,
+ CsrBool protection);
+CSR_PRIORITY
+get_packet_priority(unifi_priv_t *priv, struct sk_buff *skb, const struct ethhdr *ehdr, netInterface_priv_t *interfacePriv);
+
+void
+unifi_frame_ma_packet_req(unifi_priv_t *priv, CSR_PRIORITY priority,
+ CSR_RATE TransmitRate, CSR_CLIENT_TAG hostTag,
+ CsrUint16 interfaceTag, CSR_TRANSMISSION_CONTROL transmissionControl,
+ CSR_PROCESS_ID leSenderProcessId, CsrUint8 *peerMacAddress,
+ CSR_SIGNAL *signal);
+
+
+/* Pack the LSB to include station handle & status of tim set */
+#define CSR_WIFI_PACK_SENDER_ID_LSB_FOR_TIM_REQ(handle, timState) ((handle << 2) | timState)
+/* get the station record handle from the sender ID */
+#define CSR_WIFI_GET_STATION_HANDLE_FROM_RECEIVER_ID(receiverProcessId) (CsrUint8) ((receiverProcessId & 0xff) >> 2)
+/* get the timSet status from the sender ID */
+#define CSR_WIFI_GET_TIMSET_STATE_FROM_RECEIVER_ID(receiverProcessId) (CsrUint8) (receiverProcessId & 0x03)
+
+/* handle is 6 bits to accomodate in senderId LSB (only 64 station can be associated) */
+#define CSR_WIFI_BROADCAST_OR_MULTICAST_HANDLE 0x3F
+
+void update_tim(unifi_priv_t * priv, CsrUint16 aid, CsrUint8 setTim, CsrUint16 interfaceTag, CsrUint32 handle);
+void uf_handle_tim_cfm(unifi_priv_t *priv, CSR_MLME_SET_TIM_CONFIRM *cfm, CsrUint16 senderProcessId);
+
+/* Clear the Peer station Record, in case of wifioff/unexpected card removal */
+void CsrWifiRouterCtrlInterfaceReset(unifi_priv_t *priv, CsrUint16 interfaceTag);
+
+void scroll_ba_window(unifi_priv_t *priv,
+ netInterface_priv_t *interfacePriv,
+ ba_session_rx_struct *ba_session,
+ CsrUint16 sn);
+
+CsrBool blockack_session_stop(unifi_priv_t *priv,
+ CsrUint16 interfaceTag,
+ CsrWifiRouterCtrlBlockAckRole role,
+ CsrUint16 tID,
+ CsrWifiMacAddress macAddress);
+#ifdef CSR_SUPPORT_SME
+/* Fetch the protection information from interface Mode */
+CsrInt8 uf_get_protection_bit_from_interfacemode(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *daddr);
+#endif
+
+/* Fetch the station record handler from data base for matching Mac address */
+#ifdef CSR_SUPPORT_SME
+CsrWifiRouterCtrlStaInfo_t *CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(unifi_priv_t *priv,
+ const CsrUint8 *peerMacAddress,
+ CsrUint16 interfaceTag);
+
+/* Fetch the station record handler from data base for matching handle */
+CsrWifiRouterCtrlStaInfo_t * CsrWifiRouterCtrlGetStationRecordFromHandle(unifi_priv_t *priv,
+ CsrUint32 handle,
+ CsrUint16 interfaceTag);
+
+void uf_update_sta_activity(unifi_priv_t *priv, CsrUint16 interfaceTag, const CsrUint8 *peerMacAddress);
+void uf_process_ma_pkt_cfm_for_ap(unifi_priv_t *priv,CsrUint16 interfaceTag, const CSR_MA_PACKET_CONFIRM *pkt_cfm);
+#endif
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)
+int uf_install_qdisc(struct net_device *dev);
+#endif
+
+void uf_resume_data_plane(unifi_priv_t *priv, int queue,
+ CsrWifiMacAddress peer_address,
+ CsrUint16 interfaceTag);
+void uf_free_pending_rx_packets(unifi_priv_t *priv, int queue,
+ CsrWifiMacAddress peer_address,CsrUint16 interfaceTag);
+
+int uf_register_netdev(unifi_priv_t *priv, int numOfInterface);
+void uf_unregister_netdev(unifi_priv_t *priv);
+
+void uf_net_get_name(struct net_device *dev, char *name, int len);
+
+void uf_send_queue_info(unifi_priv_t *priv);
+CsrUint16 uf_get_vif_identifier(CsrWifiRouterCtrlMode mode, CsrUint16 tag);
+
+void uf_process_rx_pending_queue(unifi_priv_t *priv, int queue,
+ CsrWifiMacAddress source_address,
+ int indicate, CsrUint16 interfaceTag);
+
+#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
+int uf_register_hip_offline_debug(unifi_priv_t *priv);
+int uf_unregister_hip_offline_debug(unifi_priv_t *priv);
+#endif
+
+/*
+ * inet.c
+ */
+void uf_register_inet_notifier(void);
+void uf_unregister_inet_notifier(void);
+
+
+/*
+ * Suspend / Resume handlers
+ */
+void unifi_resume(void *ospriv);
+void unifi_suspend(void *ospriv);
+
+
+#define QOS_CAPABILITY_WMM_ENABLED 0x0001
+#define QOS_CAPABILITY_WMM_UAPSD 0x0002
+#define QOS_CAPABILITY_ACM_BE_ENABLED 0x0010
+#define QOS_CAPABILITY_ACM_BK_ENABLED 0x0020
+#define QOS_CAPABILITY_ACM_VI_ENABLED 0x0040
+#define QOS_CAPABILITY_ACM_VO_ENABLED 0x0080
+#define QOS_CAPABILITY_TS_BE_ENABLED 0x0100
+#define QOS_CAPABILITY_TS_BK_ENABLED 0x0200
+#define QOS_CAPABILITY_TS_VI_ENABLED 0x0400
+#define QOS_CAPABILITY_TS_VO_ENABLED 0x0800
+
+
+/* EAPOL PDUS */
+#ifndef ETH_P_PAE
+#define ETH_P_PAE 0x888e
+#endif
+#ifndef ETH_P_WAI
+#define ETH_P_WAI 0x88b4
+#endif
+/*
+ * unifi_dbg.c
+ */
+void debug_string_indication(unifi_priv_t *priv,
+ const unsigned char *extra,
+ unsigned int extralen);
+void debug_word16_indication(unifi_priv_t *priv, const CSR_SIGNAL *sigptr);
+void debug_generic_indication(unifi_priv_t *priv, const CSR_SIGNAL *sigptr);
+
+
+/*
+ * putest.c
+ */
+int unifi_putest_start(unifi_priv_t *priv, unsigned char *arg);
+int unifi_putest_cmd52_block_read(unifi_priv_t *priv, unsigned char *arg);
+int unifi_putest_stop(unifi_priv_t *priv, unsigned char *arg);
+int unifi_putest_set_sdio_clock(unifi_priv_t *priv, unsigned char *arg);
+int unifi_putest_cmd52_read(unifi_priv_t *priv, unsigned char *arg);
+int unifi_putest_coredump_prepare(unifi_priv_t *priv, unsigned char *arg);
+int unifi_putest_cmd52_write(unifi_priv_t *priv, unsigned char *arg);
+int unifi_putest_gp_read16(unifi_priv_t *priv, unsigned char *arg);
+int unifi_putest_gp_write16(unifi_priv_t *priv, unsigned char *arg);
+
+int unifi_putest_dl_fw(unifi_priv_t *priv, unsigned char *arg);
+int unifi_putest_dl_fw_buff(unifi_priv_t *priv, unsigned char *arg);
+
+
+/* Macro for formatting a MAC address with a prefix string */
+#define UF_TRACE_MAC(priv, lvl, msg, addr) \
+ unifi_trace(priv, lvl, \
+ "%s %02x-%02x-%02x-%02x-%02x-%02x\n", \
+ msg, \
+ *(((CsrUint8 *)addr)+0), \
+ *(((CsrUint8 *)addr)+1), \
+ *(((CsrUint8 *)addr)+2), \
+ *(((CsrUint8 *)addr)+3), \
+ *(((CsrUint8 *)addr)+4), \
+ *(((CsrUint8 *)addr)+5))
+
+#endif /* __LINUX_UNIFI_PRIV_H__ */
--- /dev/null
+/*
+ * ***************************************************************************
+ * FILE: unifi_sme.c
+ *
+ * PURPOSE: SME related functions.
+ *
+ * Copyright (C) 2007-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ***************************************************************************
+ */
+
+#include "unifi_priv.h"
+#include "csr_wifi_hip_unifi.h"
+#include "csr_wifi_hip_conversions.h"
+
+
+
+
+ int
+convert_sme_error(CsrResult error)
+{
+ switch (error) {
+ case CSR_RESULT_SUCCESS:
+ return 0;
+ case CSR_RESULT_FAILURE:
+ case CSR_WIFI_RESULT_NOT_FOUND:
+ case CSR_WIFI_RESULT_TIMED_OUT:
+ case CSR_WIFI_RESULT_CANCELLED:
+ case CSR_WIFI_RESULT_UNAVAILABLE:
+ return -EIO;
+ case CSR_WIFI_RESULT_NO_ROOM:
+ return -EBUSY;
+ case CSR_WIFI_RESULT_INVALID_PARAMETER:
+ return -EINVAL;
+ case CSR_WIFI_RESULT_UNSUPPORTED:
+ return -EOPNOTSUPP;
+ default:
+ return -EIO;
+ }
+}
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * sme_log_event
+ *
+ * Callback function to be registered as the SME event callback.
+ * Copies the signal content into a new udi_log_t struct and adds
+ * it to the read queue for the SME client.
+ *
+ * Arguments:
+ * arg This is the value given to unifi_add_udi_hook, in
+ * this case a pointer to the client instance.
+ * signal Pointer to the received signal.
+ * signal_len Size of the signal structure in bytes.
+ * bulkdata Pointers to any associated bulk data.
+ * dir Direction of the signal. Zero means from host,
+ * non-zero means to host.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+ void
+sme_log_event(ul_client_t *pcli,
+ const u8 *signal, int signal_len,
+ const bulk_data_param_t *bulkdata,
+ int dir)
+{
+ unifi_priv_t *priv;
+ CSR_SIGNAL unpacked_signal;
+ CsrWifiSmeDataBlock mlmeCommand;
+ CsrWifiSmeDataBlock dataref1;
+ CsrWifiSmeDataBlock dataref2;
+ CsrResult result = CSR_RESULT_SUCCESS;
+ int r;
+
+ /* Following bits are encoded in hostTag These are there to ensure that hostTags are unique*/
+#define CSR_SME_DATA 0x00000000 /* Frames Sent by SME */
+#define CSR_PAL_DATA 0X10000000 /* Frames Sent by PAL-D*/
+#define CSR_NME_DATA 0x20000000 /* Frames Sent by NME*/
+#define APPLICATION_DATA 0x30000000 /* Frames Sent by Application*/
+
+ func_enter();
+ /* Just a sanity check */
+ if ((signal == NULL) || (signal_len <= 0)) {
+ func_exit();
+ return;
+ }
+
+ priv = uf_find_instance(pcli->instance);
+ if (!priv) {
+ unifi_error(priv, "sme_log_event: invalid priv\n");
+ func_exit();
+ return;
+ }
+
+ if (priv->smepriv == NULL) {
+ unifi_error(priv, "sme_log_event: invalid smepriv\n");
+ func_exit();
+ return;
+ }
+
+ unifi_trace(priv, UDBG3,
+ "sme_log_event: Process signal 0x%.4X\n",
+ CSR_GET_UINT16_FROM_LITTLE_ENDIAN(signal));
+
+
+ /* If the signal is known, then do any filtering required, otherwise it pass it to the SME. */
+ r = read_unpack_signal(signal, &unpacked_signal);
+ if (r == CSR_RESULT_SUCCESS) {
+ if ((unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_DEBUG_STRING_INDICATION_ID) ||
+ (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_DEBUG_WORD16_INDICATION_ID))
+ {
+ func_exit();
+ return;
+ }
+ if (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_INDICATION_ID)
+ {
+ CsrUint16 frmCtrl;
+ CsrBool unicastPdu = TRUE;
+ CsrUint8 *macHdrLocation;
+ CsrUint8 *raddr = NULL, *taddr = NULL;
+ CsrWifiMacAddress peerMacAddress;
+ /* Check if we need to send CsrWifiRouterCtrlMicFailureInd*/
+ CSR_MA_PACKET_INDICATION *ind = &unpacked_signal.u.MaPacketIndication;
+
+ macHdrLocation = (CsrUint8 *) bulkdata->d[0].os_data_ptr;
+ /* Fetch the frame control value from mac header */
+ frmCtrl = CSR_GET_UINT16_FROM_LITTLE_ENDIAN(macHdrLocation);
+
+ /* Point to the addresses */
+ raddr = macHdrLocation + MAC_HEADER_ADDR1_OFFSET;
+ taddr = macHdrLocation + MAC_HEADER_ADDR2_OFFSET;
+
+ CsrMemCpy(peerMacAddress.a, taddr, ETH_ALEN);
+
+ if(ind->ReceptionStatus == CSR_MICHAEL_MIC_ERROR)
+ {
+ if (*raddr & 0x1)
+ unicastPdu = FALSE;
+
+ CsrWifiRouterCtrlMicFailureIndSend (priv->CSR_WIFI_SME_IFACEQUEUE, 0,
+ (ind->VirtualInterfaceIdentifier & 0xff),peerMacAddress,
+ unicastPdu);
+ return;
+ }
+ else
+ {
+ if(ind->ReceptionStatus == CSR_RX_SUCCESS)
+ {
+ CsrUint8 pmBit = (frmCtrl & 0x1000)?0x01:0x00;
+ CsrUint16 interfaceTag = (ind->VirtualInterfaceIdentifier & 0xff);
+ CsrWifiRouterCtrlStaInfo_t *srcStaInfo = CsrWifiRouterCtrlGetStationRecordFromPeerMacAddress(priv,taddr,interfaceTag);
+ if((srcStaInfo != NULL) && (uf_check_broadcast_bssid(priv, bulkdata)== FALSE))
+ {
+ uf_process_pm_bit_for_peer(priv,srcStaInfo,pmBit,interfaceTag);
+
+ /* Update station last activity flag */
+ srcStaInfo->activity_flag = TRUE;
+ }
+ }
+ }
+ }
+
+ if (unpacked_signal.SignalPrimitiveHeader.SignalId == CSR_MA_PACKET_CONFIRM_ID)
+ {
+ CSR_MA_PACKET_CONFIRM *cfm = &unpacked_signal.u.MaPacketConfirm;
+ CsrUint16 interfaceTag = (cfm->VirtualInterfaceIdentifier & 0xff);
+ netInterface_priv_t *interfacePriv;
+ CSR_MA_PACKET_REQUEST *req;
+ CsrWifiMacAddress peerMacAddress;
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES)
+ {
+ unifi_error(priv, "Bad MA_PACKET_CONFIRM interfaceTag %d\n", interfaceTag);
+ func_exit();
+ return;
+ }
+
+ unifi_trace(priv,UDBG1,"MA-PACKET Confirm (%x, %x)\n", cfm->HostTag, cfm->TransmissionStatus);
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+#ifdef CSR_SUPPORT_SME
+ if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
+ interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO) {
+
+ if(cfm->HostTag == interfacePriv->multicastPduHostTag){
+ uf_process_ma_pkt_cfm_for_ap(priv ,interfaceTag, cfm);
+ }
+ }
+#endif
+
+ req = &interfacePriv->m4_signal.u.MaPacketRequest;
+
+ if(cfm->HostTag & 0x80000000)
+ {
+ if (cfm->TransmissionStatus != CSR_TX_SUCCESSFUL)
+ {
+ result = CSR_RESULT_FAILURE;
+ }
+#ifdef CSR_SUPPORT_SME
+ memcpy(peerMacAddress.a, req->Ra.x, ETH_ALEN);
+ /* Check if this is a confirm for EAPOL M4 frame and we need to send transmistted ind*/
+ if (interfacePriv->m4_sent && (cfm->HostTag == interfacePriv->m4_hostTag))
+ {
+ unifi_trace(priv, UDBG1, "%s: Sending M4 Transmit CFM\n", __FUNCTION__);
+ CsrWifiRouterCtrlM4TransmittedIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0,
+ interfaceTag,
+ peerMacAddress,
+ result);
+ interfacePriv->m4_sent = FALSE;
+ interfacePriv->m4_hostTag = 0xffffffff;
+ }
+#endif
+ /* If EAPOL was requested via router APIs then send cfm else ignore*/
+ if((cfm->HostTag & 0x80000000) != CSR_WIFI_EAPOL_M4_HOST_TAG) {
+ CsrWifiRouterMaPacketCfmSend((CsrUint16)signal[2],
+ cfm->VirtualInterfaceIdentifier,
+ result,
+ (cfm->HostTag & 0x3fffffff), cfm->Rate);
+ } else {
+ unifi_trace(priv, UDBG1, "%s: M4 received from netdevice\n", __FUNCTION__);
+ }
+ func_exit();
+ return;
+ }
+ }
+ }
+
+ mlmeCommand.length = signal_len;
+ mlmeCommand.data = (CsrUint8*)signal;
+
+ dataref1.length = bulkdata->d[0].data_length;
+ if (dataref1.length > 0) {
+ dataref1.data = (CsrUint8 *) bulkdata->d[0].os_data_ptr;
+ } else
+ {
+ dataref1.data = NULL;
+ }
+
+ dataref2.length = bulkdata->d[1].data_length;
+ if (dataref2.length > 0) {
+ dataref2.data = (CsrUint8 *) bulkdata->d[1].os_data_ptr;
+ } else
+ {
+ dataref2.data = NULL;
+ }
+
+ CsrWifiRouterCtrlHipIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, mlmeCommand.length, mlmeCommand.data,
+ dataref1.length, dataref1.data,
+ dataref2.length, dataref2.data);
+
+ func_exit();
+} /* sme_log_event() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_sme_port_state
+ *
+ * Return the state of the controlled port.
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * address Pointer to the destination for tx or sender for rx address
+ * queue Controlled or uncontrolled queue
+ *
+ * Returns:
+ * An unifi_ControlledPortAction value.
+ * ---------------------------------------------------------------------------
+ */
+CsrWifiRouterCtrlPortAction
+uf_sme_port_state(unifi_priv_t *priv, unsigned char *address, int queue, CsrUint16 interfaceTag)
+{
+ int i;
+ unifi_port_config_t *port;
+ netInterface_priv_t *interfacePriv;
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "uf_sme_port_state: bad interfaceTag\n");
+ return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
+ }
+
+ interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if (queue == UF_CONTROLLED_PORT_Q) {
+ port = &interfacePriv->controlled_data_port;
+ } else {
+ port = &interfacePriv->uncontrolled_data_port;
+ }
+
+ if (!port->entries_in_use) {
+ unifi_trace(priv, UDBG5, "No port configurations, return Discard.\n");
+ return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_CLOSED_DISCARD;
+ }
+
+ /* If the port configuration is common for all destinations, return it. */
+ if (port->overide_action == UF_DATA_PORT_OVERIDE) {
+ unifi_trace(priv, UDBG5, "Single port configuration (%d).\n",
+ port->port_cfg[0].port_action);
+ return port->port_cfg[0].port_action;
+ }
+
+ unifi_trace(priv, UDBG5, "Multiple (%d) port configurations.\n", port->entries_in_use);
+
+ /* If multiple configurations exist.. */
+ for (i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ /* .. go through the list and match the destination address. */
+ if (port->port_cfg[i].in_use &&
+ memcmp(address, port->port_cfg[i].mac_address.a, ETH_ALEN) == 0) {
+ /* Return the desired action. */
+ return port->port_cfg[i].port_action;
+ }
+ }
+
+ /* Could not find any information, return Open. */
+ unifi_trace(priv, UDBG5, "port configuration not found, return Open.\n");
+ return CSR_WIFI_ROUTER_CTRL_PORT_ACTION_8021X_PORT_OPEN;
+} /* uf_sme_port_state() */
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_sme_port_config_handle
+ *
+ * Return the port config handle of the controlled/uncontrolled port.
+ *
+ * Arguments:
+ * priv Pointer to device private context struct
+ * address Pointer to the destination for tx or sender for rx address
+ * queue Controlled or uncontrolled queue
+ *
+ * Returns:
+ * An unifi_port_cfg_t* .
+ * ---------------------------------------------------------------------------
+ */
+unifi_port_cfg_t*
+uf_sme_port_config_handle(unifi_priv_t *priv, unsigned char *address, int queue, CsrUint16 interfaceTag)
+{
+ int i;
+ unifi_port_config_t *port;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "uf_sme_port_config_handle: bad interfaceTag\n");
+ return NULL;
+ }
+
+ if (queue == UF_CONTROLLED_PORT_Q) {
+ port = &interfacePriv->controlled_data_port;
+ } else {
+ port = &interfacePriv->uncontrolled_data_port;
+ }
+
+ if (!port->entries_in_use) {
+ unifi_trace(priv, UDBG5, "No port configurations, return Discard.\n");
+ return NULL;
+ }
+
+ /* If the port configuration is common for all destinations, return it. */
+ if (port->overide_action == UF_DATA_PORT_OVERIDE) {
+ unifi_trace(priv, UDBG5, "Single port configuration (%d).\n",
+ port->port_cfg[0].port_action);
+ if (address) {
+ unifi_trace(priv, UDBG5, "addr[0] = %x, addr[1] = %x, addr[2] = %x, addr[3] = %x\n", address[0], address[1], address[2], address[3]);
+ }
+ return &port->port_cfg[0];
+ }
+
+ unifi_trace(priv, UDBG5, "Multiple port configurations.\n");
+
+ /* If multiple configurations exist.. */
+ for (i = 0; i < UNIFI_MAX_CONNECTIONS; i++) {
+ /* .. go through the list and match the destination address. */
+ if (port->port_cfg[i].in_use &&
+ memcmp(address, port->port_cfg[i].mac_address.a, ETH_ALEN) == 0) {
+ /* Return the desired action. */
+ return &port->port_cfg[i];
+ }
+ }
+
+ /* Could not find any information, return Open. */
+ unifi_trace(priv, UDBG5, "port configuration not found, returning NULL (debug).\n");
+ return NULL;
+} /* uf_sme_port_config_handle */
+
+void
+uf_multicast_list_wq(struct work_struct *work)
+{
+ unifi_priv_t *priv = container_of(work, unifi_priv_t,
+ multicast_list_task);
+ int i;
+ CsrUint16 interfaceTag = 0;
+ CsrWifiMacAddress* multicast_address_list = NULL;
+ int mc_count;
+ u8 *mc_list;
+ netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "uf_multicast_list_wq: bad interfaceTag\n");
+ return;
+ }
+
+ unifi_trace(priv, UDBG5,
+ "uf_multicast_list_wq: list count = %d\n",
+ interfacePriv->mc_list_count);
+
+ /* Flush the current list */
+ CsrWifiRouterCtrlMulticastAddressIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, interfaceTag, CSR_WIFI_SME_LIST_ACTION_FLUSH, 0, NULL);
+
+ mc_count = interfacePriv->mc_list_count;
+ mc_list = interfacePriv->mc_list;
+ /*
+ * Allocate a new list, need to free it later
+ * in unifi_mgt_multicast_address_cfm().
+ */
+ multicast_address_list = CsrPmemAlloc(mc_count * sizeof(CsrWifiMacAddress));
+
+ if (multicast_address_list == NULL) {
+ return;
+ }
+
+ for (i = 0; i < mc_count; i++) {
+ memcpy(multicast_address_list[i].a, mc_list, ETH_ALEN);
+ mc_list += ETH_ALEN;
+ }
+
+ if (priv->smepriv == NULL) {
+ CsrPmemFree(multicast_address_list);
+ return;
+ }
+
+ CsrWifiRouterCtrlMulticastAddressIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,
+ interfaceTag,
+ CSR_WIFI_SME_LIST_ACTION_ADD,
+ mc_count, multicast_address_list);
+
+ /* The SME will take a copy of the addreses*/
+ CsrPmemFree(multicast_address_list);
+}
+
+
+int unifi_cfg_power(unifi_priv_t *priv, unsigned char *arg)
+{
+ unifi_cfg_power_t cfg_power;
+ int rc;
+ int wol;
+
+ if (get_user(cfg_power, (unifi_cfg_power_t*)(((unifi_cfg_command_t*)arg) + 1))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ switch (cfg_power) {
+ case UNIFI_CFG_POWER_OFF:
+ priv->wol_suspend = (enable_wol == UNIFI_WOL_OFF) ? FALSE : TRUE;
+ rc = sme_sys_suspend(priv);
+ if (rc) {
+ return rc;
+ }
+ break;
+ case UNIFI_CFG_POWER_ON:
+ wol = priv->wol_suspend;
+ rc = sme_sys_resume(priv);
+ if (rc) {
+ return rc;
+ }
+ if (wol) {
+ /* Kick the BH to ensure pending transfers are handled when
+ * a suspend happened with card powered.
+ */
+ unifi_send_signal(priv->card, NULL, 0, NULL);
+ }
+ break;
+ default:
+ unifi_error(priv, "WIFI POWER: Unknown value.\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+
+int unifi_cfg_power_save(unifi_priv_t *priv, unsigned char *arg)
+{
+ unifi_cfg_powersave_t cfg_power_save;
+ CsrWifiSmePowerConfig powerConfig;
+ int rc;
+
+ if (get_user(cfg_power_save, (unifi_cfg_powersave_t*)(((unifi_cfg_command_t*)arg) + 1))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ /* Get the coex info from the SME */
+ rc = sme_mgt_power_config_get(priv, &powerConfig);
+ if (rc) {
+ unifi_error(priv, "UNIFI_CFG: Get unifi_PowerConfigValue failed.\n");
+ return rc;
+ }
+
+ switch (cfg_power_save) {
+ case UNIFI_CFG_POWERSAVE_NONE:
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_LOW;
+ break;
+ case UNIFI_CFG_POWERSAVE_FAST:
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_MED;
+ break;
+ case UNIFI_CFG_POWERSAVE_FULL:
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_HIGH;
+ break;
+ case UNIFI_CFG_POWERSAVE_AUTO:
+ powerConfig.powerSaveLevel = CSR_WIFI_SME_POWER_SAVE_LEVEL_AUTO;
+ break;
+ default:
+ unifi_error(priv, "POWERSAVE: Unknown value.\n");
+ return -EINVAL;
+ }
+
+ rc = sme_mgt_power_config_set(priv, &powerConfig);
+
+ if (rc) {
+ unifi_error(priv, "UNIFI_CFG: Set unifi_PowerConfigValue failed.\n");
+ }
+
+ return rc;
+}
+
+
+int unifi_cfg_power_supply(unifi_priv_t *priv, unsigned char *arg)
+{
+ unifi_cfg_powersupply_t cfg_power_supply;
+ CsrWifiSmeHostConfig hostConfig;
+ int rc;
+
+ if (get_user(cfg_power_supply, (unifi_cfg_powersupply_t*)(((unifi_cfg_command_t*)arg) + 1))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ /* Get the coex info from the SME */
+ rc = sme_mgt_host_config_get(priv, &hostConfig);
+ if (rc) {
+ unifi_error(priv, "UNIFI_CFG: Get unifi_HostConfigValue failed.\n");
+ return rc;
+ }
+
+ switch (cfg_power_supply) {
+ case UNIFI_CFG_POWERSUPPLY_MAINS:
+ hostConfig.powerMode = CSR_WIFI_SME_HOST_POWER_MODE_ACTIVE;
+ break;
+ case UNIFI_CFG_POWERSUPPLY_BATTERIES:
+ hostConfig.powerMode = CSR_WIFI_SME_HOST_POWER_MODE_POWER_SAVE;
+ break;
+ default:
+ unifi_error(priv, "POWERSUPPLY: Unknown value.\n");
+ return -EINVAL;
+ }
+
+ rc = sme_mgt_host_config_set(priv, &hostConfig);
+ if (rc) {
+ unifi_error(priv, "UNIFI_CFG: Set unifi_HostConfigValue failed.\n");
+ }
+
+ return rc;
+}
+
+
+int unifi_cfg_packet_filters(unifi_priv_t *priv, unsigned char *arg)
+{
+ unsigned char *tclas_buffer;
+ unsigned int tclas_buffer_length;
+ tclas_t *dhcp_tclas;
+ int rc;
+
+ /* Free any TCLASs previously allocated */
+ if (priv->packet_filters.tclas_ies_length) {
+ CsrPmemFree(priv->filter_tclas_ies);
+ priv->filter_tclas_ies = NULL;
+ }
+
+ tclas_buffer = ((unsigned char*)arg) + sizeof(unifi_cfg_command_t) + sizeof(unsigned int);
+ if (copy_from_user(&priv->packet_filters, (void*)tclas_buffer,
+ sizeof(uf_cfg_bcast_packet_filter_t))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to get the filter struct\n");
+ return -EFAULT;
+ }
+
+ tclas_buffer_length = priv->packet_filters.tclas_ies_length;
+
+ /* Allocate TCLASs if necessary */
+ if (priv->packet_filters.dhcp_filter) {
+ priv->packet_filters.tclas_ies_length += sizeof(tclas_t);
+ }
+ if (priv->packet_filters.tclas_ies_length > 0) {
+ priv->filter_tclas_ies = CsrPmemAlloc(priv->packet_filters.tclas_ies_length);
+ if (priv->filter_tclas_ies == NULL) {
+ return -ENOMEM;
+ }
+ if (tclas_buffer_length) {
+ tclas_buffer += sizeof(uf_cfg_bcast_packet_filter_t) - sizeof(unsigned char*);
+ if (copy_from_user(priv->filter_tclas_ies,
+ tclas_buffer,
+ tclas_buffer_length)) {
+ unifi_error(priv, "UNIFI_CFG: Failed to get the TCLAS buffer\n");
+ return -EFAULT;
+ }
+ }
+ }
+
+ if(priv->packet_filters.dhcp_filter)
+ {
+ /* Append the DHCP tclas IE */
+ dhcp_tclas = (tclas_t*)(priv->filter_tclas_ies + tclas_buffer_length);
+ memset(dhcp_tclas, 0, sizeof(tclas_t));
+ dhcp_tclas->element_id = 14;
+ dhcp_tclas->length = sizeof(tcpip_clsfr_t) + 1;
+ dhcp_tclas->user_priority = 0;
+ dhcp_tclas->tcp_ip_cls_fr.cls_fr_type = 1;
+ dhcp_tclas->tcp_ip_cls_fr.version = 4;
+ ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[0] = 0x00;
+ ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.source_port))[1] = 0x44;
+ ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[0] = 0x00;
+ ((CsrUint8*)(&dhcp_tclas->tcp_ip_cls_fr.dest_port))[1] = 0x43;
+ dhcp_tclas->tcp_ip_cls_fr.protocol = 0x11;
+ dhcp_tclas->tcp_ip_cls_fr.cls_fr_mask = 0x58; //bits: 3,4,6
+ }
+
+ rc = sme_mgt_packet_filter_set(priv);
+
+ return rc;
+}
+
+
+int unifi_cfg_wmm_qos_info(unifi_priv_t *priv, unsigned char *arg)
+{
+ CsrUint8 wmm_qos_info;
+ int rc = 0;
+
+ if (get_user(wmm_qos_info, (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ /* Store the value in the connection info */
+ priv->connection_config.wmmQosInfo = wmm_qos_info;
+
+ return rc;
+}
+
+
+int unifi_cfg_wmm_addts(unifi_priv_t *priv, unsigned char *arg)
+{
+ CsrUint32 addts_tid;
+ CsrUint8 addts_ie_length;
+ CsrUint8 *addts_ie;
+ CsrUint8 *addts_params;
+ CsrWifiSmeDataBlock tspec;
+ CsrWifiSmeDataBlock tclas;
+ int rc;
+
+ addts_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+ if (get_user(addts_tid, (CsrUint32*)addts_params)) {
+ unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ addts_params += sizeof(CsrUint32);
+ if (get_user(addts_ie_length, (CsrUint8*)addts_params)) {
+ unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG4, "addts: tid = 0x%x ie_length = %d\n",
+ addts_tid, addts_ie_length);
+
+ addts_ie = CsrPmemAlloc(addts_ie_length);
+ if (addts_ie == NULL) {
+ unifi_error(priv,
+ "unifi_cfg_wmm_addts: Failed to malloc %d bytes for addts_ie buffer\n",
+ addts_ie_length);
+ return -ENOMEM;
+ }
+
+ addts_params += sizeof(CsrUint8);
+ rc = copy_from_user(addts_ie, addts_params, addts_ie_length);
+ if (rc) {
+ unifi_error(priv, "unifi_cfg_wmm_addts: Failed to get the addts buffer\n");
+ CsrPmemFree(addts_ie);
+ return -EFAULT;
+ }
+
+ tspec.data = addts_ie;
+ tspec.length = addts_ie_length;
+ tclas.data = NULL;
+ tclas.length = 0;
+
+ rc = sme_mgt_tspec(priv, CSR_WIFI_SME_LIST_ACTION_ADD, addts_tid,
+ &tspec, &tclas);
+
+ CsrPmemFree(addts_ie);
+ return rc;
+}
+
+
+int unifi_cfg_wmm_delts(unifi_priv_t *priv, unsigned char *arg)
+{
+ CsrUint32 delts_tid;
+ CsrUint8 *delts_params;
+ CsrWifiSmeDataBlock tspec;
+ CsrWifiSmeDataBlock tclas;
+ int rc;
+
+ delts_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+ if (get_user(delts_tid, (CsrUint32*)delts_params)) {
+ unifi_error(priv, "unifi_cfg_wmm_delts: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG4, "delts: tid = 0x%x\n", delts_tid);
+
+ tspec.data = tclas.data = NULL;
+ tspec.length = tclas.length = 0;
+
+ rc = sme_mgt_tspec(priv, CSR_WIFI_SME_LIST_ACTION_REMOVE, delts_tid,
+ &tspec, &tclas);
+
+ return rc;
+}
+
+int unifi_cfg_strict_draft_n(unifi_priv_t *priv, unsigned char *arg)
+{
+ CsrBool strict_draft_n;
+ CsrUint8 *strict_draft_n_params;
+ int rc;
+
+ CsrWifiSmeStaConfig staConfig;
+ CsrWifiSmeDeviceConfig deviceConfig;
+
+ strict_draft_n_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+ if (get_user(strict_draft_n, (CsrBool*)strict_draft_n_params)) {
+ unifi_error(priv, "unifi_cfg_strict_draft_n: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG4, "strict_draft_n: = %s\n", ((strict_draft_n) ? "yes":"no"));
+
+ rc = sme_mgt_sme_config_get(priv, &staConfig, &deviceConfig);
+
+ if (rc) {
+ unifi_warning(priv, "unifi_cfg_strict_draft_n: Get unifi_SMEConfigValue failed.\n");
+ return -EFAULT;
+ }
+
+ deviceConfig.enableStrictDraftN = strict_draft_n;
+
+ rc = sme_mgt_sme_config_set(priv, &staConfig, &deviceConfig);
+ if (rc) {
+ unifi_warning(priv, "unifi_cfg_strict_draft_n: Set unifi_SMEConfigValue failed.\n");
+ rc = -EFAULT;
+ }
+
+ return rc;
+}
+
+
+int unifi_cfg_enable_okc(unifi_priv_t *priv, unsigned char *arg)
+{
+ CsrBool enable_okc;
+ CsrUint8 *enable_okc_params;
+ int rc;
+
+ CsrWifiSmeStaConfig staConfig;
+ CsrWifiSmeDeviceConfig deviceConfig;
+
+ enable_okc_params = (CsrUint8*)(((unifi_cfg_command_t*)arg) + 1);
+ if (get_user(enable_okc, (CsrBool*)enable_okc_params)) {
+ unifi_error(priv, "unifi_cfg_enable_okc: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ unifi_trace(priv, UDBG4, "enable_okc: = %s\n", ((enable_okc) ? "yes":"no"));
+
+ rc = sme_mgt_sme_config_get(priv, &staConfig, &deviceConfig);
+ if (rc) {
+ unifi_warning(priv, "unifi_cfg_enable_okc: Get unifi_SMEConfigValue failed.\n");
+ return -EFAULT;
+ }
+
+ staConfig.enableOpportunisticKeyCaching = enable_okc;
+
+ rc = sme_mgt_sme_config_set(priv, &staConfig, &deviceConfig);
+ if (rc) {
+ unifi_warning(priv, "unifi_cfg_enable_okc: Set unifi_SMEConfigValue failed.\n");
+ rc = -EFAULT;
+ }
+
+ return rc;
+}
+
+
+int unifi_cfg_get_info(unifi_priv_t *priv, unsigned char *arg)
+{
+ unifi_cfg_get_t get_cmd;
+ char inst_name[IFNAMSIZ];
+ int rc;
+
+ if (get_user(get_cmd, (unifi_cfg_get_t*)(((unifi_cfg_command_t*)arg) + 1))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to get the argument\n");
+ return -EFAULT;
+ }
+
+ switch (get_cmd) {
+ case UNIFI_CFG_GET_COEX:
+ {
+ CsrWifiSmeCoexInfo coexInfo;
+ /* Get the coex info from the SME */
+ rc = sme_mgt_coex_info_get(priv, &coexInfo);
+ if (rc) {
+ unifi_error(priv, "UNIFI_CFG: Get unifi_CoexInfoValue failed.\n");
+ return rc;
+ }
+
+ /* Copy the info to the out buffer */
+ if (copy_to_user((void*)arg,
+ &coexInfo,
+ sizeof(CsrWifiSmeCoexInfo))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to copy the coex info\n");
+ return -EFAULT;
+ }
+ break;
+ }
+ case UNIFI_CFG_GET_POWER_MODE:
+ {
+ CsrWifiSmePowerConfig powerConfig;
+ rc = sme_mgt_power_config_get(priv, &powerConfig);
+ if (rc) {
+ unifi_error(priv, "UNIFI_CFG: Get unifi_PowerConfigValue failed.\n");
+ return rc;
+ }
+
+ /* Copy the info to the out buffer */
+ if (copy_to_user((void*)arg,
+ &powerConfig.powerSaveLevel,
+ sizeof(CsrWifiSmePowerSaveLevel))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to copy the power save info\n");
+ return -EFAULT;
+ }
+ break;
+ }
+ case UNIFI_CFG_GET_POWER_SUPPLY:
+ {
+ CsrWifiSmeHostConfig hostConfig;
+ rc = sme_mgt_host_config_get(priv, &hostConfig);
+ if (rc) {
+ unifi_error(priv, "UNIFI_CFG: Get unifi_HostConfigValue failed.\n");
+ return rc;
+ }
+
+ /* Copy the info to the out buffer */
+ if (copy_to_user((void*)arg,
+ &hostConfig.powerMode,
+ sizeof(CsrWifiSmeHostPowerMode))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to copy the host power mode\n");
+ return -EFAULT;
+ }
+ break;
+ }
+ case UNIFI_CFG_GET_VERSIONS:
+ break;
+ case UNIFI_CFG_GET_INSTANCE:
+ {
+ CsrUint16 InterfaceId=0;
+ uf_net_get_name(priv->netdev[InterfaceId], &inst_name[0], sizeof(inst_name));
+
+ /* Copy the info to the out buffer */
+ if (copy_to_user((void*)arg,
+ &inst_name[0],
+ sizeof(inst_name))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to copy the instance name\n");
+ return -EFAULT;
+ }
+ }
+ break;
+
+ case UNIFI_CFG_GET_AP_CONFIG:
+ {
+#ifdef CSR_SUPPORT_WEXT_AP
+ uf_cfg_ap_config_t cfg_ap_config;
+ cfg_ap_config.channel = priv->ap_config.channel;
+ cfg_ap_config.beaconInterval = priv->ap_mac_config.beaconInterval;
+ cfg_ap_config.wmmEnabled = priv->ap_mac_config.wmmEnabled;
+ cfg_ap_config.dtimPeriod = priv->ap_mac_config.dtimPeriod;
+ cfg_ap_config.phySupportedBitmap = priv->ap_mac_config.phySupportedBitmap;
+ if (copy_to_user((void*)arg,
+ &cfg_ap_config,
+ sizeof(uf_cfg_ap_config_t))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to copy the AP configuration\n");
+ return -EFAULT;
+ }
+#else
+ return -EPERM;
+#endif
+ }
+ break;
+
+
+ default:
+ unifi_error(priv, "unifi_cfg_get_info: Unknown value.\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+#ifdef CSR_SUPPORT_WEXT_AP
+int
+ uf_configure_supported_rates(CsrUint8 * supportedRates, CsrUint8 phySupportedBitmap)
+{
+ int i=0;
+ CsrBool b=FALSE, g = FALSE, n = FALSE;
+ b = phySupportedBitmap & CSR_WIFI_SME_AP_PHY_SUPPORT_B;
+ n = phySupportedBitmap & CSR_WIFI_SME_AP_PHY_SUPPORT_N;
+ g = phySupportedBitmap & CSR_WIFI_SME_AP_PHY_SUPPORT_G;
+ if(b || g) {
+ supportedRates[i++]=0x82;
+ supportedRates[i++]=0x84;
+ supportedRates[i++]=0x8b;
+ supportedRates[i++]=0x96;
+ } else if(n) {
+ /* For some strange reasons WiFi stack needs both b and g rates*/
+ supportedRates[i++]=0x02;
+ supportedRates[i++]=0x04;
+ supportedRates[i++]=0x0b;
+ supportedRates[i++]=0x16;
+ supportedRates[i++]=0x0c;
+ supportedRates[i++]=0x12;
+ supportedRates[i++]=0x18;
+ supportedRates[i++]=0x24;
+ supportedRates[i++]=0x30;
+ supportedRates[i++]=0x48;
+ supportedRates[i++]=0x60;
+ supportedRates[i++]=0x6c;
+ }
+ if(g) {
+ if(!b) {
+ supportedRates[i++]=0x8c;
+ supportedRates[i++]=0x98;
+ supportedRates[i++]=0xb0;
+ } else {
+ supportedRates[i++]=0x0c;
+ supportedRates[i++]=0x18;
+ supportedRates[i++]=0x30;
+ }
+ supportedRates[i++]=0x48;
+ supportedRates[i++]=0x12;
+ supportedRates[i++]=0x24;
+ supportedRates[i++]=0x60;
+ supportedRates[i++]=0x6c;
+ }
+ return i;
+}
+int unifi_cfg_set_ap_config(unifi_priv_t * priv,unsigned char* arg)
+{
+ uf_cfg_ap_config_t cfg_ap_config;
+ char *buffer;
+
+ buffer = ((unsigned char*)arg) + sizeof(unifi_cfg_command_t) + sizeof(unsigned int);
+ if (copy_from_user(&cfg_ap_config, (void*)buffer,
+ sizeof(uf_cfg_ap_config_t))) {
+ unifi_error(priv, "UNIFI_CFG: Failed to get the ap config struct\n");
+ return -EFAULT;
+ }
+ priv->ap_config.channel = cfg_ap_config.channel;
+ priv->ap_mac_config.dtimPeriod = cfg_ap_config.dtimPeriod;
+ priv->ap_mac_config.beaconInterval = cfg_ap_config.beaconInterval;
+ priv->group_sec_config.apGroupkeyTimeout = cfg_ap_config.groupkeyTimeout;
+ priv->group_sec_config.apStrictGtkRekey = cfg_ap_config.strictGtkRekeyEnabled;
+ priv->group_sec_config.apGmkTimeout = cfg_ap_config.gmkTimeout;
+ priv->group_sec_config.apResponseTimeout = cfg_ap_config.responseTimeout;
+ priv->group_sec_config.apRetransLimit = cfg_ap_config.retransLimit;
+
+ priv->ap_mac_config.shortSlotTimeEnabled = cfg_ap_config.shortSlotTimeEnabled;
+ priv->ap_mac_config.ctsProtectionType=cfg_ap_config.ctsProtectionType;
+
+ priv->ap_mac_config.wmmEnabled = cfg_ap_config.wmmEnabled;
+
+ priv->ap_mac_config.apHtParams.rxStbc=cfg_ap_config.rxStbc;
+ priv->ap_mac_config.apHtParams.rifsModeAllowed=cfg_ap_config.rifsModeAllowed;
+
+ priv->ap_mac_config.phySupportedBitmap = cfg_ap_config.phySupportedBitmap;
+ priv->ap_mac_config.maxListenInterval=cfg_ap_config.maxListenInterval;
+
+ priv->ap_mac_config.supportedRatesCount= uf_configure_supported_rates(priv->ap_mac_config.supportedRates,priv->ap_mac_config.phySupportedBitmap);
+
+ return 0;
+}
+
+#endif
+#ifdef CSR_SUPPORT_WEXT
+
+ void
+uf_sme_config_wq(struct work_struct *work)
+{
+ CsrWifiSmeStaConfig staConfig;
+ CsrWifiSmeDeviceConfig deviceConfig;
+ unifi_priv_t *priv = container_of(work, unifi_priv_t, sme_config_task);
+
+ /* Register to receive indications from the SME */
+ CsrWifiSmeEventMaskSetReqSend(0,
+ CSR_WIFI_SME_INDICATIONS_WIFIOFF | CSR_WIFI_SME_INDICATIONS_CONNECTIONQUALITY |
+ CSR_WIFI_SME_INDICATIONS_MEDIASTATUS | CSR_WIFI_SME_INDICATIONS_MICFAILURE);
+
+ if (sme_mgt_sme_config_get(priv, &staConfig, &deviceConfig)) {
+ unifi_warning(priv, "uf_sme_config_wq: Get unifi_SMEConfigValue failed.\n");
+ return;
+ }
+
+ if (priv->if_index == CSR_INDEX_5G) {
+ staConfig.ifIndex = CSR_WIFI_SME_RADIO_IF_GHZ_5_0;
+ } else {
+ staConfig.ifIndex = CSR_WIFI_SME_RADIO_IF_GHZ_2_4;
+ }
+
+ deviceConfig.trustLevel = (CsrWifiSme80211dTrustLevel)tl_80211d;
+ if (sme_mgt_sme_config_set(priv, &staConfig, &deviceConfig)) {
+ unifi_warning(priv,
+ "SME config for 802.11d Trust Level and Radio Band failed.\n");
+ return;
+ }
+
+} /* uf_sme_config_wq() */
+
+#endif /* CSR_SUPPORT_WEXT */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_ta_ind_wq
+ *
+ * Deferred work queue function to send Traffic Analysis protocols
+ * indications to the SME.
+ * These are done in a deferred work queue for two reasons:
+ * - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context
+ * - we want to load the main driver data path as lightly as possible
+ *
+ * The TA classifications already come from a workqueue.
+ *
+ * Arguments:
+ * work Pointer to work queue item.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+ void
+uf_ta_ind_wq(struct work_struct *work)
+{
+ struct ta_ind *ind = container_of(work, struct ta_ind, task);
+ unifi_priv_t *priv = container_of(ind, unifi_priv_t, ta_ind_work);
+ CsrUint16 interfaceTag = 0;
+
+
+ CsrWifiRouterCtrlTrafficProtocolIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0,
+ interfaceTag,
+ ind->packet_type,
+ ind->direction,
+ ind->src_addr);
+ ind->in_use = 0;
+
+} /* uf_ta_ind_wq() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_ta_sample_ind_wq
+ *
+ * Deferred work queue function to send Traffic Analysis sample
+ * indications to the SME.
+ * These are done in a deferred work queue for two reasons:
+ * - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context
+ * - we want to load the main driver data path as lightly as possible
+ *
+ * The TA classifications already come from a workqueue.
+ *
+ * Arguments:
+ * work Pointer to work queue item.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+ void
+uf_ta_sample_ind_wq(struct work_struct *work)
+{
+ struct ta_sample_ind *ind = container_of(work, struct ta_sample_ind, task);
+ unifi_priv_t *priv = container_of(ind, unifi_priv_t, ta_sample_ind_work);
+ CsrUint16 interfaceTag = 0;
+
+ unifi_trace(priv, UDBG5, "rxtcp %d txtcp %d rxudp %d txudp %d prio %d\n",
+ priv->rxTcpThroughput,
+ priv->txTcpThroughput,
+ priv->rxUdpThroughput,
+ priv->txUdpThroughput,
+ priv->bh_thread.prio);
+
+ if(priv->rxTcpThroughput > 1000)
+ {
+ if (bh_priority == -1 && priv->bh_thread.prio != 1)
+ {
+ struct sched_param param;
+ priv->bh_thread.prio = 1;
+ unifi_trace(priv, UDBG1, "%s new thread (RT) priority = %d\n",
+ priv->bh_thread.name, priv->bh_thread.prio);
+ param.sched_priority = priv->bh_thread.prio;
+ sched_setscheduler(priv->bh_thread.thread_task, SCHED_FIFO, ¶m);
+ }
+ } else
+ {
+ if (bh_priority == -1 && priv->bh_thread.prio != DEFAULT_PRIO)
+ {
+ struct sched_param param;
+ param.sched_priority = 0;
+ sched_setscheduler(priv->bh_thread.thread_task, SCHED_NORMAL, ¶m);
+ priv->bh_thread.prio = DEFAULT_PRIO;
+ unifi_trace(priv, UDBG1, "%s new thread priority = %d\n",
+ priv->bh_thread.name, priv->bh_thread.prio);
+ set_user_nice(priv->bh_thread.thread_task, PRIO_TO_NICE(priv->bh_thread.prio));
+ }
+ }
+
+ CsrWifiRouterCtrlTrafficSampleIndSend(priv->CSR_WIFI_SME_IFACEQUEUE,0, interfaceTag, ind->stats);
+
+ ind->in_use = 0;
+
+} /* uf_ta_sample_ind_wq() */
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * uf_send_m4_ready_wq
+ *
+ * Deferred work queue function to send M4 ReadyToSend inds to the SME.
+ * These are done in a deferred work queue for two reasons:
+ * - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context
+ * - we want to load the main driver data path as lightly as possible
+ *
+ * Arguments:
+ * work Pointer to work queue item.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void
+uf_send_m4_ready_wq(struct work_struct *work)
+{
+ netInterface_priv_t *InterfacePriv = container_of(work, netInterface_priv_t, send_m4_ready_task);
+ CsrUint16 iface = InterfacePriv->InterfaceTag;
+ unifi_priv_t *priv = InterfacePriv->privPtr;
+ CSR_MA_PACKET_REQUEST *req = &InterfacePriv->m4_signal.u.MaPacketRequest;
+ CsrWifiMacAddress peer;
+ unsigned long flags;
+
+ func_enter();
+
+ /* The peer address was stored in the signal */
+ spin_lock_irqsave(&priv->m4_lock, flags);
+ memcpy(peer.a, req->Ra.x, sizeof(peer.a));
+ spin_unlock_irqrestore(&priv->m4_lock, flags);
+
+ /* Send a signal to SME */
+ CsrWifiRouterCtrlM4ReadyToSendIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, iface, peer);
+
+ UF_TRACE_MAC(priv, UDBG1, "M4ReadyToSendInd sent for peer", peer.a);
+
+ func_exit();
+
+} /* uf_send_m4_ready_wq() */
+
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
+/*
+ * ---------------------------------------------------------------------------
+ * uf_send_pkt_to_encrypt
+ *
+ * Deferred work queue function to send the WAPI data pkts to SME when unicast KeyId = 1
+ * These are done in a deferred work queue for two reasons:
+ * - the CsrWifiRouterCtrl...Send() functions are not safe for atomic context
+ * - we want to load the main driver data path as lightly as possible
+ *
+ * Arguments:
+ * work Pointer to work queue item.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+void uf_send_pkt_to_encrypt(struct work_struct *work)
+{
+ netInterface_priv_t *interfacePriv = container_of(work, netInterface_priv_t, send_pkt_to_encrypt);
+ CsrUint16 interfaceTag = interfacePriv->InterfaceTag;
+ unifi_priv_t *priv = interfacePriv->privPtr;
+
+ CsrUint32 pktBulkDataLength;
+ CsrUint8 *pktBulkData;
+ unsigned long flags;
+
+ if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA) {
+
+ func_enter();
+
+ pktBulkDataLength = interfacePriv->wapi_unicast_bulk_data.data_length;
+
+ if (pktBulkDataLength > 0) {
+ pktBulkData = (CsrUint8 *)CsrPmemAlloc(pktBulkDataLength);
+ CsrMemSet(pktBulkData, 0, pktBulkDataLength);
+ } else {
+ unifi_error(priv, "uf_send_pkt_to_encrypt() : invalid buffer\n");
+ return;
+ }
+
+ spin_lock_irqsave(&priv->wapi_lock, flags);
+ /* Copy over the MA PKT REQ bulk data */
+ CsrMemCpy(pktBulkData, (CsrUint8*)interfacePriv->wapi_unicast_bulk_data.os_data_ptr, pktBulkDataLength);
+ /* Free any bulk data buffers allocated for the WAPI Data pkt */
+ unifi_net_data_free(priv, &interfacePriv->wapi_unicast_bulk_data);
+ interfacePriv->wapi_unicast_bulk_data.net_buf_length = 0;
+ interfacePriv->wapi_unicast_bulk_data.data_length = 0;
+ interfacePriv->wapi_unicast_bulk_data.os_data_ptr = interfacePriv->wapi_unicast_bulk_data.os_net_buf_ptr = NULL;
+ spin_unlock_irqrestore(&priv->wapi_lock, flags);
+
+ CsrWifiRouterCtrlWapiUnicastTxEncryptIndSend(priv->CSR_WIFI_SME_IFACEQUEUE, 0, interfaceTag, pktBulkDataLength, pktBulkData);
+ unifi_trace(priv, UDBG1, "WapiUnicastTxEncryptInd sent to SME\n");
+
+ CsrPmemFree(pktBulkData); /* Would have been copied over by the SME Handler */
+
+ func_exit();
+ } else {
+ unifi_warning(priv, "uf_send_pkt_to_encrypt() is NOT applicable for interface mode - %d\n",interfacePriv->interfaceMode);
+ }
+}/* uf_send_pkt_to_encrypt() */
+#endif
--- /dev/null
+/*
+ * ***************************************************************************
+ * FILE: unifi_sme.h
+ *
+ * PURPOSE: SME related definitions.
+ *
+ * Copyright (C) 2007-2011 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ***************************************************************************
+ */
+#ifndef __LINUX_UNIFI_SME_H__
+#define __LINUX_UNIFI_SME_H__ 1
+
+#include <linux/kernel.h>
+
+#ifdef CSR_SME_USERSPACE
+#include "sme_userspace.h"
+#endif
+
+#include "csr_wifi_sme_lib.h"
+
+typedef int unifi_data_port_action;
+
+typedef struct unifi_port_cfg
+{
+ /* TRUE if this port entry is allocated */
+ CsrBool in_use;
+ CsrWifiRouterCtrlPortAction port_action;
+ CsrWifiMacAddress mac_address;
+} unifi_port_cfg_t;
+
+#define UNIFI_MAX_CONNECTIONS 8
+#define UNIFI_MAX_RETRY_LIMIT 5
+#define UF_DATA_PORT_NOT_OVERIDE 0
+#define UF_DATA_PORT_OVERIDE 1
+
+typedef struct unifi_port_config
+{
+ int entries_in_use;
+ int overide_action;
+ unifi_port_cfg_t port_cfg[UNIFI_MAX_CONNECTIONS];
+} unifi_port_config_t;
+
+
+enum sme_request_status {
+ SME_REQUEST_EMPTY,
+ SME_REQUEST_PENDING,
+ SME_REQUEST_RECEIVED,
+ SME_REQUEST_TIMEDOUT,
+ SME_REQUEST_CANCELLED,
+};
+
+/* Structure to hold a UDI logged signal */
+typedef struct {
+
+ /* The current status of the request */
+ enum sme_request_status request_status;
+
+ /* The status the SME has passed to us */
+ CsrResult reply_status;
+
+ /* SME's reply to a get request */
+ CsrWifiSmeVersions versions;
+ CsrWifiSmePowerConfig powerConfig;
+ CsrWifiSmeHostConfig hostConfig;
+ CsrWifiSmeStaConfig staConfig;
+ CsrWifiSmeDeviceConfig deviceConfig;
+ CsrWifiSmeCoexInfo coexInfo;
+ CsrWifiSmeCoexConfig coexConfig;
+ CsrWifiSmeMibConfig mibConfig;
+ CsrWifiSmeConnectionInfo connectionInfo;
+ CsrWifiSmeConnectionConfig connectionConfig;
+ CsrWifiSmeConnectionStats connectionStats;
+
+
+ /* SME's reply to a scan request */
+ CsrUint16 reply_scan_results_count;
+ CsrWifiSmeScanResult* reply_scan_results;
+
+} sme_reply_t;
+
+
+typedef struct {
+ CsrUint16 appHandle;
+ CsrWifiRouterEncapsulation encapsulation;
+ CsrUint16 protocol;
+ CsrUint8 oui[3];
+ CsrUint8 in_use;
+} sme_ma_unidata_ind_filter_t;
+
+
+CsrWifiRouterCtrlPortAction uf_sme_port_state(unifi_priv_t *priv,
+ unsigned char *address,
+ int queue,
+ CsrUint16 interfaceTag);
+unifi_port_cfg_t *uf_sme_port_config_handle(unifi_priv_t *priv,
+ unsigned char *address,
+ int queue,
+ CsrUint16 interfaceTag);
+
+
+
+/* Callback for event logging to SME clients */
+void sme_log_event(ul_client_t *client, const u8 *signal, int signal_len,
+ const bulk_data_param_t *bulkdata, int dir);
+
+/* The workqueue task to the set the multicast addresses list */
+void uf_multicast_list_wq(struct work_struct *work);
+
+/* The workqueue task to execute the TA module */
+void uf_ta_wq(struct work_struct *work);
+
+
+/*
+ * SME blocking helper functions
+ */
+#ifdef UNIFI_DEBUG
+# define sme_complete_request(priv, status) uf_sme_complete_request(priv, status, __func__)
+#else
+# define sme_complete_request(priv, status) uf_sme_complete_request(priv, status, NULL)
+#endif
+
+void uf_sme_complete_request(unifi_priv_t *priv, CsrResult reply_status, const char *func);
+void uf_sme_cancel_request(unifi_priv_t *priv, CsrResult reply_status);
+
+
+/*
+ * Blocking functions using the SME SYS API.
+ */
+int sme_sys_suspend(unifi_priv_t *priv);
+int sme_sys_resume(unifi_priv_t *priv);
+
+
+/*
+ * Traffic Analysis workqueue jobs
+ */
+void uf_ta_ind_wq(struct work_struct *work);
+void uf_ta_sample_ind_wq(struct work_struct *work);
+
+/*
+ * SME config workqueue job
+ */
+void uf_sme_config_wq(struct work_struct *work);
+
+/*
+ * To send M4 read to send IND
+ */
+void uf_send_m4_ready_wq(struct work_struct *work);
+
+#if (defined(CSR_WIFI_SECURITY_WAPI_ENABLE) && defined(CSR_WIFI_SECURITY_WAPI_SW_ENCRYPTION))
+/*
+ * To send data pkt to Sme for encryption
+ */
+void uf_send_pkt_to_encrypt(struct work_struct *work);
+#endif
+
+int sme_mgt_power_config_set(unifi_priv_t *priv, CsrWifiSmePowerConfig *powerConfig);
+int sme_mgt_power_config_get(unifi_priv_t *priv, CsrWifiSmePowerConfig *powerConfig);
+int sme_mgt_host_config_set(unifi_priv_t *priv, CsrWifiSmeHostConfig *hostConfig);
+int sme_mgt_host_config_get(unifi_priv_t *priv, CsrWifiSmeHostConfig *hostConfig);
+int sme_mgt_sme_config_set(unifi_priv_t *priv, CsrWifiSmeStaConfig *staConfig, CsrWifiSmeDeviceConfig *deviceConfig);
+int sme_mgt_sme_config_get(unifi_priv_t *priv, CsrWifiSmeStaConfig *staConfig, CsrWifiSmeDeviceConfig *deviceConfig);
+int sme_mgt_coex_info_get(unifi_priv_t *priv, CsrWifiSmeCoexInfo *coexInfo);
+int sme_mgt_packet_filter_set(unifi_priv_t *priv);
+int sme_mgt_tspec(unifi_priv_t *priv, CsrWifiSmeListAction action,
+ CsrUint32 tid, CsrWifiSmeDataBlock *tspec, CsrWifiSmeDataBlock *tclas);
+
+#ifdef CSR_SUPPORT_WEXT
+/*
+ * Blocking functions using the SME MGT API.
+ */
+int sme_mgt_wifi_on(unifi_priv_t *priv);
+int sme_mgt_wifi_off(unifi_priv_t *priv);
+/*int sme_mgt_set_value_async(unifi_priv_t *priv, unifi_AppValue *app_value);
+int sme_mgt_get_value_async(unifi_priv_t *priv, unifi_AppValue *app_value);
+int sme_mgt_get_value(unifi_priv_t *priv, unifi_AppValue *app_value);
+int sme_mgt_set_value(unifi_priv_t *priv, unifi_AppValue *app_value);
+*/
+int sme_mgt_coex_config_set(unifi_priv_t *priv, CsrWifiSmeCoexConfig *coexConfig);
+int sme_mgt_coex_config_get(unifi_priv_t *priv, CsrWifiSmeCoexConfig *coexConfig);
+int sme_mgt_mib_config_set(unifi_priv_t *priv, CsrWifiSmeMibConfig *mibConfig);
+int sme_mgt_mib_config_get(unifi_priv_t *priv, CsrWifiSmeMibConfig *mibConfig);
+
+int sme_mgt_connection_info_set(unifi_priv_t *priv, CsrWifiSmeConnectionInfo *connectionInfo);
+int sme_mgt_connection_info_get(unifi_priv_t *priv, CsrWifiSmeConnectionInfo *connectionInfo);
+int sme_mgt_connection_config_set(unifi_priv_t *priv, CsrWifiSmeConnectionConfig *connectionConfig);
+int sme_mgt_connection_config_get(unifi_priv_t *priv, CsrWifiSmeConnectionConfig *connectionConfig);
+int sme_mgt_connection_stats_get(unifi_priv_t *priv, CsrWifiSmeConnectionStats *connectionStats);
+
+int sme_mgt_versions_get(unifi_priv_t *priv, CsrWifiSmeVersions *versions);
+
+
+int sme_mgt_scan_full(unifi_priv_t *priv, CsrWifiSsid *specific_ssid,
+ int num_channels, unsigned char *channel_list);
+int sme_mgt_scan_results_get_async(unifi_priv_t *priv,
+ struct iw_request_info *info,
+ char *scan_results,
+ long scan_results_len);
+int sme_mgt_disconnect(unifi_priv_t *priv);
+int sme_mgt_connect(unifi_priv_t *priv);
+int sme_mgt_key(unifi_priv_t *priv, CsrWifiSmeKey *sme_key,
+ CsrWifiSmeListAction action);
+int sme_mgt_pmkid(unifi_priv_t *priv, CsrWifiSmeListAction action,
+ CsrWifiSmePmkidList *pmkid_list);
+int sme_mgt_mib_get(unifi_priv_t *priv,
+ unsigned char *varbind, int *length);
+int sme_mgt_mib_set(unifi_priv_t *priv,
+ unsigned char *varbind, int length);
+#ifdef CSR_SUPPORT_WEXT_AP
+int sme_ap_start(unifi_priv_t *priv,CsrUint16 interface_tag,CsrWifiSmeApConfig_t *ap_config);
+int sme_ap_stop(unifi_priv_t *priv,CsrUint16 interface_tag);
+int sme_ap_config(unifi_priv_t *priv,CsrWifiSmeApMacConfig *ap_mac_config, CsrWifiNmeApConfig *group_security_config);
+int uf_configure_supported_rates(CsrUint8 * supportedRates, CsrUint8 phySupportedBitmap);
+#endif
+int unifi_translate_scan(struct net_device *dev,
+ struct iw_request_info *info,
+ char *current_ev, char *end_buf,
+ CsrWifiSmeScanResult *scan_data,
+ int scan_index);
+
+#endif /* CSR_SUPPORT_WEXT */
+
+int unifi_cfg_power(unifi_priv_t *priv, unsigned char *arg);
+int unifi_cfg_power_save(unifi_priv_t *priv, unsigned char *arg);
+int unifi_cfg_power_supply(unifi_priv_t *priv, unsigned char *arg);
+int unifi_cfg_packet_filters(unifi_priv_t *priv, unsigned char *arg);
+int unifi_cfg_wmm_qos_info(unifi_priv_t *priv, unsigned char *arg);
+int unifi_cfg_wmm_addts(unifi_priv_t *priv, unsigned char *arg);
+int unifi_cfg_wmm_delts(unifi_priv_t *priv, unsigned char *arg);
+int unifi_cfg_get_info(unifi_priv_t *priv, unsigned char *arg);
+int unifi_cfg_strict_draft_n(unifi_priv_t *priv, unsigned char *arg);
+int unifi_cfg_enable_okc(unifi_priv_t *priv, unsigned char *arg);
+#ifdef CSR_SUPPORT_WEXT_AP
+int unifi_cfg_set_ap_config(unifi_priv_t * priv,unsigned char* arg);
+#endif
+
+
+
+int convert_sme_error(CsrResult error);
+
+
+#endif /* __LINUX_UNIFI_SME_H__ */
--- /dev/null
+/*
+ *****************************************************************************
+ *
+ * FILE : unifi_wext.h
+ *
+ * PURPOSE : Private header file for unifi driver support to wireless extensions.
+ *
+ * Copyright (C) 2005-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+*****************************************************************************
+ */
+#ifndef __LINUX_UNIFI_WEXT_H__
+#define __LINUX_UNIFI_WEXT_H__ 1
+
+#include <linux/kernel.h>
+#include <net/iw_handler.h>
+#include "csr_wifi_sme_prim.h"
+
+/*
+ * wext.c
+ */
+/* A few details needed for WEP (Wireless Equivalent Privacy) */
+#define UNIFI_MAX_KEY_SIZE 16
+#define NUM_WEPKEYS 4
+#define SMALL_KEY_SIZE 5
+#define LARGE_KEY_SIZE 13
+typedef struct wep_key_t {
+ int len;
+ unsigned char key[UNIFI_MAX_KEY_SIZE]; /* 40-bit and 104-bit keys */
+} wep_key_t;
+
+#define UNIFI_SCAN_ACTIVE 0
+#define UNIFI_SCAN_PASSIVE 1
+#define UNIFI_MAX_SSID_LEN 32
+
+#define MAX_WPA_IE_LEN 64
+#define MAX_RSN_IE_LEN 255
+
+/*
+ * Function to register in the netdev to report wireless stats.
+ */
+struct iw_statistics *unifi_get_wireless_stats(struct net_device *dev);
+
+void uf_sme_wext_set_defaults(unifi_priv_t *priv);
+
+
+/*
+ * wext_events.c
+ */
+/* Functions to generate Wireless Extension events */
+void wext_send_scan_results_event(unifi_priv_t *priv);
+void wext_send_assoc_event(unifi_priv_t *priv, unsigned char *bssid,
+ unsigned char *req_ie, int req_ie_len,
+ unsigned char *resp_ie, int resp_ie_len,
+ unsigned char *scan_ie, unsigned int scan_ie_len);
+void wext_send_disassoc_event(unifi_priv_t *priv);
+void wext_send_michaelmicfailure_event(unifi_priv_t *priv,
+ CsrUint16 count, CsrWifiMacAddress address,
+ CsrWifiSmeKeyType keyType, CsrUint16 interfaceTag);
+void wext_send_pmkid_candidate_event(unifi_priv_t *priv, CsrWifiMacAddress bssid, CsrBool preauth_allowed, CsrUint16 interfaceTag);
+void wext_send_started_event(unifi_priv_t *priv);
+
+
+static inline int
+uf_iwe_stream_add_point(struct iw_request_info *info, char *start, char *stop,
+ struct iw_event *piwe, char *extra)
+{
+ char *new_start;
+
+ new_start = iwe_stream_add_point(
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27) || defined (IW_REQUEST_FLAG_COMPAT)
+ info,
+#endif
+ start, stop, piwe, extra);
+ if (unlikely(new_start == start))
+ {
+ return -E2BIG;
+ }
+
+ return (new_start - start);
+}
+
+
+static inline int
+uf_iwe_stream_add_event(struct iw_request_info *info, char *start, char *stop,
+ struct iw_event *piwe, int len)
+{
+ char *new_start;
+
+ new_start = iwe_stream_add_event(
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27) || defined(IW_REQUEST_FLAG_COMPAT)
+ info,
+#endif
+ start, stop, piwe, len);
+ if (unlikely(new_start == start)) {
+ return -E2BIG;
+ }
+
+ return (new_start - start);
+}
+
+static inline int
+uf_iwe_stream_add_value(struct iw_request_info *info, char *stream, char *start,
+ char *stop, struct iw_event *piwe, int len)
+{
+ char *new_start;
+
+ new_start = iwe_stream_add_value(
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27) || defined(IW_REQUEST_FLAG_COMPAT)
+ info,
+#endif
+ stream, start, stop, piwe, len);
+ if (unlikely(new_start == start)) {
+ return -E2BIG;
+ }
+
+ return (new_start - start);
+}
+
+
+#endif /* __LINUX_UNIFI_WEXT_H__ */
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ *
+ * FILE: unifiio.h
+ *
+ * Public definitions for the UniFi linux driver.
+ * This is mostly ioctl command values and structs.
+ *
+ * Include <sys/ioctl.h> or similar before this file
+ *
+ * Copyright (C) 2005-2009 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#ifndef __UNIFIIO_H__
+#define __UNIFIIO_H__
+
+#include <linux/types.h>
+#include "csr_types.h"
+
+#define UNIFI_GET_UDI_ENABLE _IOR('u', 1, int)
+#define UNIFI_SET_UDI_ENABLE _IOW('u', 2, int)
+/* Values for UDI_ENABLE */
+#define UDI_ENABLE_DATA 0x1
+#define UDI_ENABLE_CONTROL 0x2
+
+/* MIB set/get. Arg is a pointer to a varbind */
+#define UNIFI_GET_MIB _IOWR('u', 3, unsigned char *)
+#define UNIFI_SET_MIB _IOW ('u', 4, unsigned char *)
+#define MAX_VARBIND_LENGTH 127
+
+/* Private IOCTLs */
+#define SIOCIWS80211POWERSAVEPRIV SIOCIWFIRSTPRIV
+#define SIOCIWG80211POWERSAVEPRIV SIOCIWFIRSTPRIV + 1
+#define SIOCIWS80211RELOADDEFAULTSPRIV SIOCIWFIRSTPRIV + 2
+#define SIOCIWSCONFWAPIPRIV SIOCIWFIRSTPRIV + 4
+#define SIOCIWSWAPIKEYPRIV SIOCIWFIRSTPRIV + 6
+#define SIOCIWSSMEDEBUGPRIV SIOCIWFIRSTPRIV + 8
+#define SIOCIWSAPCFGPRIV SIOCIWFIRSTPRIV + 10
+#define SIOCIWSAPSTARTPRIV SIOCIWFIRSTPRIV + 12
+#define SIOCIWSAPSTOPPRIV SIOCIWFIRSTPRIV + 14
+#define SIOCIWSFWRELOADPRIV SIOCIWFIRSTPRIV + 16
+#define SIOCIWSSTACKSTART SIOCIWFIRSTPRIV + 18
+#define SIOCIWSSTACKSTOP SIOCIWFIRSTPRIV + 20
+
+
+
+#define IWPRIV_POWER_SAVE_MAX_STRING 32
+#define IWPRIV_SME_DEBUG_MAX_STRING 32
+#define IWPRIV_SME_MAX_STRING 120
+
+
+/* Private configuration commands */
+#define UNIFI_CFG _IOWR('u', 5, unsigned char *)
+/*
+ * <------------------ Read/Write Buffer -------------------->
+ * _____________________________________________________________
+ * | Cmd | Arg | ... Buffer (opt) ... |
+ * -------------------------------------------------------------
+ * <-- uint --><-- uint --><----- unsigned char buffer ------>
+ *
+ * Cmd: A unifi_cfg_command_t command.
+ * Arg: Out:Length if Cmd==UNIFI_CFG_GET
+ * In:PowerOnOff if Cmd==UNIFI_CFG_POWER
+ * In:PowerMode if Cmd==UNIFI_CFG_POWERSAVE
+ * In:Length if Cmd==UNIFI_CFG_FILTER
+ * In:WMM Qos Info if Cmd==UNIFI_CFG_WMM_QOS_INFO
+ * Buffer: Out:Data if Cmd==UNIFI_CFG_GET
+ * NULL if Cmd==UNIFI_CFG_POWER
+ * NULL if Cmd==UNIFI_CFG_POWERSAVE
+ * In:Filters if Cmd==UNIFI_CFG_FILTER
+ *
+ * where Filters is a uf_cfg_bcast_packet_filter_t structure
+ * followed by 0 - n tclas_t structures. The length of the tclas_t
+ * structures is obtained by uf_cfg_bcast_packet_filter_t::tclas_ies_length.
+ */
+
+
+#define UNIFI_PUTEST _IOWR('u', 6, unsigned char *)
+/*
+ * <------------------ Read/Write Buffer -------------------->
+ * _____________________________________________________________
+ * | Cmd | Arg | ... Buffer (opt) ... |
+ * -------------------------------------------------------------
+ * <-- uint --><-- uint --><----- unsigned char buffer ------>
+ *
+ * Cmd: A unifi_putest_command_t command.
+ * Arg: N/A if Cmd==UNIFI_PUTEST_START
+ * N/A if Cmd==UNIFI_PUTEST_STOP
+ * In:int (Clock Speed) if Cmd==UNIFI_PUTEST_SET_SDIO_CLOCK
+ * In/Out:sizeof(unifi_putest_cmd52) if Cmd==UNIFI_PUTEST_CMD52_READ
+ * In:sizeof(unifi_putest_cmd52) if Cmd==UNIFI_PUTEST_CMD52_WRITE
+ * In:uint (f/w file name length) if Cmd==UNIFI_PUTEST_DL_FW
+ * Buffer: NULL if Cmd==UNIFI_PUTEST_START
+ * NULL if Cmd==UNIFI_PUTEST_STOP
+ * NULL if Cmd==UNIFI_PUTEST_SET_SDIO_CLOCK
+ * In/Out:unifi_putest_cmd52 if Cmd==UNIFI_PUTEST_CMD52_READ
+ * In:unifi_putest_cmd52 if Cmd==UNIFI_PUTEST_CMD52_WRITE
+ * In:f/w file name if Cmd==UNIFI_PUTEST_DL_FW
+ */
+
+#define UNIFI_BUILD_TYPE _IOWR('u', 7, unsigned char)
+#define UNIFI_BUILD_NME 1
+#define UNIFI_BUILD_WEXT 2
+#define UNIFI_BUILD_AP 3
+
+/* debugging */
+#define UNIFI_KICK _IO ('u', 0x10)
+#define UNIFI_SET_DEBUG _IO ('u', 0x11)
+#define UNIFI_SET_TRACE _IO ('u', 0x12)
+
+#define UNIFI_GET_INIT_STATUS _IOR ('u', 0x15, int)
+#define UNIFI_SET_UDI_LOG_MASK _IOR('u', 0x18, unifiio_filter_t)
+#define UNIFI_SET_UDI_SNAP_MASK _IOW('u', 0x1a, unifiio_snap_filter_t)
+#define UNIFI_SET_AMP_ENABLE _IOWR('u', 0x1b, int)
+
+#define UNIFI_INIT_HW _IOR ('u', 0x13, unsigned char)
+#define UNIFI_INIT_NETDEV _IOW ('u', 0x14, unsigned char[6])
+#define UNIFI_SME_PRESENT _IOW ('u', 0x19, int)
+
+#define UNIFI_CFG_PERIOD_TRAFFIC _IOW ('u', 0x21, unsigned char *)
+#define UNIFI_CFG_UAPSD_TRAFFIC _IOW ('u', 0x22, unsigned char)
+
+#define UNIFI_COREDUMP_GET_REG _IOWR('u', 0x23, unifiio_coredump_req_t)
+
+
+/*
+ * Following reset, f/w may only be downloaded using CMD52.
+ * This is slow, so there is a facility to download a secondary
+ * loader first which supports CMD53.
+ * If loader_len is > 0, then loader_data is assumed to point to
+ * a suitable secondary loader that can be used to download the
+ * main image.
+ *
+ * The driver will run the host protocol initialisation sequence
+ * after downloading the image.
+ *
+ * If both lengths are zero, then the f/w is assumed to have been
+ * booted from Flash and the host protocol initialisation sequence
+ * is run.
+ */
+typedef struct {
+
+ /* Number of bytes in the image */
+ int img_len;
+
+ /* Pointer to image data. */
+ unsigned char *img_data;
+
+
+ /* Number of bytes in the loader image */
+ int loader_len;
+
+ /* Pointer to loader image data. */
+ unsigned char *loader_data;
+
+} unifiio_img_t;
+
+
+/* Structure of data read from the unifi device. */
+typedef struct
+{
+ /* Length (in bytes) of entire structure including appended bulk data */
+ int length;
+
+ /* System time (in milliseconds) that signal was transferred */
+ int timestamp;
+
+ /* Direction in which signal was transferred. */
+ int direction;
+#define UDI_FROM_HOST 0
+#define UDI_TO_HOST 1
+#define UDI_CONFIG_IND 2
+
+ /* The length of the signal (in bytes) not including bulk data */
+ int signal_length;
+
+ /* Signal body follows, then any bulk data */
+
+} udi_msg_t;
+
+
+typedef enum
+{
+ UfSigFil_AllOn = 0, /* Log all signal IDs */
+ UfSigFil_AllOff = 1, /* Don't log any signal IDs */
+ UfSigFil_SelectOn = 2, /* Log these signal IDs */
+ UfSigFil_SelectOff = 3 /* Don't log these signal IDs */
+} uf_sigfilter_action_t;
+
+typedef struct {
+
+ /* Number of 16-bit ints in the sig_ids array */
+ int num_sig_ids;
+ /* The action to perform */
+ uf_sigfilter_action_t action;
+ /* List of signal IDs to pass or block */
+ unsigned short *sig_ids;
+
+} unifiio_filter_t;
+
+
+typedef struct {
+ /* Number of 16-bit ints in the protocols array */
+ CsrUint16 count;
+ /* List of protocol ids to pass */
+ CsrUint16 *protocols;
+} unifiio_snap_filter_t;
+
+
+
+typedef CsrUint8 unifi_putest_command_t;
+
+#define UNIFI_PUTEST_START 0
+#define UNIFI_PUTEST_STOP 1
+#define UNIFI_PUTEST_SET_SDIO_CLOCK 2
+#define UNIFI_PUTEST_CMD52_READ 3
+#define UNIFI_PUTEST_CMD52_WRITE 4
+#define UNIFI_PUTEST_DL_FW 5
+#define UNIFI_PUTEST_DL_FW_BUFF 6
+#define UNIFI_PUTEST_CMD52_BLOCK_READ 7
+#define UNIFI_PUTEST_COREDUMP_PREPARE 8
+#define UNIFI_PUTEST_GP_READ16 9
+#define UNIFI_PUTEST_GP_WRITE16 10
+
+
+struct unifi_putest_cmd52 {
+ int funcnum;
+ unsigned long addr;
+ unsigned char data;
+};
+
+
+struct unifi_putest_block_cmd52_r {
+ int funcnum;
+ unsigned long addr;
+ unsigned int length;
+ unsigned char *data;
+};
+
+struct unifi_putest_gp_rw16 {
+ unsigned long addr; /* generic address */
+ unsigned short data;
+};
+
+typedef enum unifi_cfg_command {
+ UNIFI_CFG_GET,
+ UNIFI_CFG_POWER,
+ UNIFI_CFG_POWERSAVE,
+ UNIFI_CFG_FILTER,
+ UNIFI_CFG_POWERSUPPLY,
+ UNIFI_CFG_WMM_QOSINFO,
+ UNIFI_CFG_WMM_ADDTS,
+ UNIFI_CFG_WMM_DELTS,
+ UNIFI_CFG_STRICT_DRAFT_N,
+ UNIFI_CFG_ENABLE_OKC,
+ UNIFI_CFG_SET_AP_CONFIG,
+ UNIFI_CFG_CORE_DUMP /* request to take a fw core dump */
+} unifi_cfg_command_t;
+
+typedef enum unifi_cfg_power {
+ UNIFI_CFG_POWER_UNSPECIFIED,
+ UNIFI_CFG_POWER_OFF,
+ UNIFI_CFG_POWER_ON
+} unifi_cfg_power_t;
+
+typedef enum unifi_cfg_powersupply {
+ UNIFI_CFG_POWERSUPPLY_UNSPECIFIED,
+ UNIFI_CFG_POWERSUPPLY_MAINS,
+ UNIFI_CFG_POWERSUPPLY_BATTERIES
+} unifi_cfg_powersupply_t;
+
+typedef enum unifi_cfg_powersave {
+ UNIFI_CFG_POWERSAVE_UNSPECIFIED,
+ UNIFI_CFG_POWERSAVE_NONE,
+ UNIFI_CFG_POWERSAVE_FAST,
+ UNIFI_CFG_POWERSAVE_FULL,
+ UNIFI_CFG_POWERSAVE_AUTO
+} unifi_cfg_powersave_t;
+
+typedef enum unifi_cfg_get {
+ UNIFI_CFG_GET_COEX,
+ UNIFI_CFG_GET_POWER_MODE,
+ UNIFI_CFG_GET_VERSIONS,
+ UNIFI_CFG_GET_POWER_SUPPLY,
+ UNIFI_CFG_GET_INSTANCE,
+ UNIFI_CFG_GET_AP_CONFIG
+} unifi_cfg_get_t;
+
+#define UNIFI_CFG_FILTER_NONE 0x0000
+#define UNIFI_CFG_FILTER_DHCP 0x0001
+#define UNIFI_CFG_FILTER_ARP 0x0002
+#define UNIFI_CFG_FILTER_NBNS 0x0004
+#define UNIFI_CFG_FILTER_NBDS 0x0008
+#define UNIFI_CFG_FILTER_CUPS 0x0010
+#define UNIFI_CFG_FILTER_ALL 0xFFFF
+
+
+typedef struct uf_cfg_bcast_packet_filter
+{
+ unsigned long filter_mode; //as defined by HIP protocol
+ unsigned char arp_filter;
+ unsigned char dhcp_filter;
+ unsigned long tclas_ies_length; // length of tclas_ies in bytes
+ unsigned char tclas_ies[1]; // variable length depending on above field
+} uf_cfg_bcast_packet_filter_t;
+
+typedef struct uf_cfg_ap_config
+{
+ CsrUint8 phySupportedBitmap;
+ CsrUint8 channel;
+ CsrUint16 beaconInterval;
+ CsrUint8 dtimPeriod;
+ CsrBool wmmEnabled;
+ CsrUint8 shortSlotTimeEnabled;
+ CsrUint16 groupkeyTimeout;
+ CsrBool strictGtkRekeyEnabled;
+ CsrUint16 gmkTimeout;
+ CsrUint16 responseTimeout;
+ CsrUint8 retransLimit;
+ CsrUint8 rxStbc;
+ CsrBool rifsModeAllowed;
+ CsrUint8 dualCtsProtection;
+ CsrUint8 ctsProtectionType;
+ CsrUint16 maxListenInterval;
+}uf_cfg_ap_config_t;
+
+typedef struct tcpic_clsfr
+{
+ __u8 cls_fr_type;
+ __u8 cls_fr_mask;
+ __u8 version;
+ __u8 source_ip_addr[4];
+ __u8 dest_ip_addr[4];
+ __u16 source_port;
+ __u16 dest_port;
+ __u8 dscp;
+ __u8 protocol;
+ __u8 reserved;
+} __attribute__ ((packed)) tcpip_clsfr_t;
+
+typedef struct tclas {
+ __u8 element_id;
+ __u8 length;
+ __u8 user_priority;
+ tcpip_clsfr_t tcp_ip_cls_fr;
+} __attribute__ ((packed)) tclas_t;
+
+
+#define CONFIG_IND_ERROR 0x01
+#define CONFIG_IND_EXIT 0x02
+#define CONFIG_SME_NOT_PRESENT 0x10
+#define CONFIG_SME_PRESENT 0x20
+
+/* WAPI Key */
+typedef struct
+{
+ CsrUint8 unicastKey;
+ /* If non zero, then unicast key otherwise group key */
+ CsrUint8 keyIndex;
+ CsrUint8 keyRsc[16];
+ CsrUint8 authenticator;
+ /* If non zero, then authenticator otherwise supplicant */
+ CsrUint8 address[6];
+ CsrUint8 key[32];
+} unifiio_wapi_key_t;
+
+/* Values describing XAP memory regions captured by the mini-coredump system */
+typedef enum unifiio_coredump_space {
+ UNIFIIO_COREDUMP_MAC_REG,
+ UNIFIIO_COREDUMP_PHY_REG,
+ UNIFIIO_COREDUMP_SH_DMEM,
+ UNIFIIO_COREDUMP_MAC_DMEM,
+ UNIFIIO_COREDUMP_PHY_DMEM,
+ UNIFIIO_COREDUMP_TRIGGER_MAGIC = 0xFEED
+} unifiio_coredump_space_t;
+
+/* Userspace tool uses this structure to retrieve a register value from a
+ * mini-coredump buffer previously saved by the HIP
+ */
+typedef struct unifiio_coredump_req {
+ /* From user */
+ int index; /* 0=newest, -1=oldest */
+ unsigned int offset; /* register offset in space */
+ unifiio_coredump_space_t space; /* memory space */
+ /* Filled by driver */
+ unsigned int drv_build; /* driver build id */
+ unsigned int chip_ver; /* chip version */
+ unsigned int fw_ver; /* firmware version */
+ int requestor; /* requestor: 0=auto dump, 1=manual */
+ unsigned int timestamp; /* time of capture by driver */
+ unsigned int serial; /* capture serial number */
+ int value; /* 16 bit register value, -ve for error */
+} unifiio_coredump_req_t; /* Core-dumped register value request */
+
+#endif /* __UNIFIIO_H__ */
--- /dev/null
+/*
+ * ---------------------------------------------------------------------------
+ * FILE: wext_events.c
+ *
+ * PURPOSE:
+ * Code to generate iwevents.
+ *
+ * Copyright (C) 2006-2008 by Cambridge Silicon Radio Ltd.
+ *
+ * Refer to LICENSE.txt included with this source code for details on
+ * the license terms.
+ *
+ * ---------------------------------------------------------------------------
+ */
+#include <linux/types.h>
+#include <linux/etherdevice.h>
+#include <linux/if_arp.h>
+#include "csr_wifi_hip_unifi.h"
+#include "unifi_priv.h"
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * wext_send_assoc_event
+ *
+ * Send wireless-extension events up to userland to announce
+ * successful association with an AP.
+ *
+ * Arguments:
+ * priv Pointer to driver context.
+ * bssid MAC address of AP we associated with
+ * req_ie, req_ie_len IEs in the original request
+ * resp_ie, resp_ie_len IEs in the response
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * This is sent on first successful association, and again if we
+ * roam to another AP.
+ * ---------------------------------------------------------------------------
+ */
+void
+wext_send_assoc_event(unifi_priv_t *priv, unsigned char *bssid,
+ unsigned char *req_ie, int req_ie_len,
+ unsigned char *resp_ie, int resp_ie_len,
+ unsigned char *scan_ie, unsigned int scan_ie_len)
+{
+#if WIRELESS_EXT > 17
+ union iwreq_data wrqu;
+
+ if (req_ie_len == 0) req_ie = NULL;
+ wrqu.data.length = req_ie_len;
+ wrqu.data.flags = 0;
+ wireless_send_event(priv->netdev[CSR_WIFI_INTERFACE_IN_USE], IWEVASSOCREQIE, &wrqu, req_ie);
+
+ if (resp_ie_len == 0) resp_ie = NULL;
+ wrqu.data.length = resp_ie_len;
+ wrqu.data.flags = 0;
+ wireless_send_event(priv->netdev[CSR_WIFI_INTERFACE_IN_USE], IWEVASSOCRESPIE, &wrqu, resp_ie);
+
+ if (scan_ie_len > 0) {
+ wrqu.data.length = scan_ie_len;
+ wrqu.data.flags = 0;
+ wireless_send_event(priv->netdev[CSR_WIFI_INTERFACE_IN_USE], IWEVGENIE, &wrqu, scan_ie);
+ }
+
+ memcpy(&wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
+ wireless_send_event(priv->netdev[CSR_WIFI_INTERFACE_IN_USE], SIOCGIWAP, &wrqu, NULL);
+#endif
+} /* wext_send_assoc_event() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * wext_send_disassoc_event
+ *
+ * Send a wireless-extension event up to userland to announce
+ * that we disassociated from an AP.
+ *
+ * Arguments:
+ * priv Pointer to driver context.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * The semantics of wpa_supplicant (the userland SME application) are
+ * that a SIOCGIWAP event with MAC address of all zero means
+ * disassociate.
+ * ---------------------------------------------------------------------------
+ */
+void
+wext_send_disassoc_event(unifi_priv_t *priv)
+{
+#if WIRELESS_EXT > 17
+ union iwreq_data wrqu;
+
+ memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
+ wireless_send_event(priv->netdev[CSR_WIFI_INTERFACE_IN_USE], SIOCGIWAP, &wrqu, NULL);
+#endif
+} /* wext_send_disassoc_event() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * wext_send_scan_results_event
+ *
+ * Send wireless-extension events up to userland to announce
+ * completion of a scan.
+ *
+ * Arguments:
+ * priv Pointer to driver context.
+ *
+ * Returns:
+ * None.
+ *
+ * Notes:
+ * This doesn't actually report the results, they are retrieved
+ * using the SIOCGIWSCAN ioctl command.
+ * ---------------------------------------------------------------------------
+ */
+void
+wext_send_scan_results_event(unifi_priv_t *priv)
+{
+#if WIRELESS_EXT > 17
+ union iwreq_data wrqu;
+
+ wrqu.data.length = 0;
+ wrqu.data.flags = 0;
+ wireless_send_event(priv->netdev[CSR_WIFI_INTERFACE_IN_USE], SIOCGIWSCAN, &wrqu, NULL);
+
+#endif
+} /* wext_send_scan_results_event() */
+
+
+
+/*
+ * ---------------------------------------------------------------------------
+ * wext_send_michaelmicfailure_event
+ *
+ * Send wireless-extension events up to userland to announce
+ * completion of a scan.
+ *
+ * Arguments:
+ * priv Pointer to driver context.
+ * count, macaddr, key_type, key_idx, tsc
+ * Parameters from report from UniFi.
+ *
+ * Returns:
+ * None.
+ * ---------------------------------------------------------------------------
+ */
+#if WIRELESS_EXT >= 18
+static inline void
+_send_michaelmicfailure_event(struct net_device *dev,
+ int count, const unsigned char *macaddr,
+ int key_type, int key_idx,
+ unsigned char *tsc)
+{
+ union iwreq_data wrqu;
+ struct iw_michaelmicfailure mmf;
+
+ memset(&mmf, 0, sizeof(mmf));
+
+ mmf.flags = key_idx & IW_MICFAILURE_KEY_ID;
+ if (key_type == CSR_GROUP) {
+ mmf.flags |= IW_MICFAILURE_GROUP;
+ } else {
+ mmf.flags |= IW_MICFAILURE_PAIRWISE;
+ }
+ mmf.flags |= ((count << 5) & IW_MICFAILURE_COUNT);
+
+ mmf.src_addr.sa_family = ARPHRD_ETHER;
+ memcpy(mmf.src_addr.sa_data, macaddr, ETH_ALEN);
+
+ memcpy(mmf.tsc, tsc, IW_ENCODE_SEQ_MAX_SIZE);
+
+ memset(&wrqu, 0, sizeof(wrqu));
+ wrqu.data.length = sizeof(mmf);
+
+ wireless_send_event(dev, IWEVMICHAELMICFAILURE, &wrqu, (char *)&mmf);
+}
+#elif WIRELESS_EXT >= 15
+static inline void
+_send_michaelmicfailure_event(struct net_device *dev,
+ int count, const unsigned char *macaddr,
+ int key_type, int key_idx,
+ unsigned char *tsc)
+{
+ union iwreq_data wrqu;
+ char buf[128];
+
+ sprintf(buf,
+ "MLME-MICHAELMICFAILURE.indication(keyid=%d %scast addr=%02x:%02x:%02x:%02x:%02x:%02x)",
+ key_idx, (key_type == CSR_GROUP) ? "broad" : "uni",
+ macaddr[0], macaddr[1], macaddr[2],
+ macaddr[3], macaddr[4], macaddr[5]);
+ memset(&wrqu, 0, sizeof(wrqu));
+ wrqu.data.length = strlen(buf);
+ wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
+}
+#else /* WIRELESS_EXT >= 15 */
+static inline void
+_send_michaelmicfailure_event(struct net_device *dev,
+ int count, const unsigned char *macaddr,
+ int key_type, int key_idx,
+ unsigned char *tsc)
+{
+ /* Not supported before WEXT 15 */
+}
+#endif /* WIRELESS_EXT >= 15 */
+
+
+void
+wext_send_michaelmicfailure_event(unifi_priv_t *priv,
+ CsrUint16 count,
+ CsrWifiMacAddress address,
+ CsrWifiSmeKeyType keyType,
+ CsrUint16 interfaceTag)
+{
+ unsigned char tsc[8] = {0};
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "wext_send_michaelmicfailure_event bad interfaceTag\n");
+ return;
+ }
+
+ _send_michaelmicfailure_event(priv->netdev[interfaceTag],
+ count,
+ address.a,
+ keyType,
+ 0,
+ tsc);
+} /* wext_send_michaelmicfailure_event() */
+
+void
+wext_send_pmkid_candidate_event(unifi_priv_t *priv, CsrWifiMacAddress bssid, CsrBool preauth_allowed, CsrUint16 interfaceTag)
+{
+#if WIRELESS_EXT > 17
+ union iwreq_data wrqu;
+ struct iw_pmkid_cand pmkid_cand;
+
+ if (interfaceTag >= CSR_WIFI_NUM_INTERFACES) {
+ unifi_error(priv, "wext_send_pmkid_candidate_event bad interfaceTag\n");
+ return;
+ }
+
+ memset(&pmkid_cand, 0, sizeof(pmkid_cand));
+
+ if (preauth_allowed) {
+ pmkid_cand.flags |= IW_PMKID_CAND_PREAUTH;
+ }
+ pmkid_cand.bssid.sa_family = ARPHRD_ETHER;
+ memcpy(pmkid_cand.bssid.sa_data, bssid.a, ETH_ALEN);
+ /* Used as priority, smaller the number higher the priority, not really used in our case */
+ pmkid_cand.index = 1;
+
+ memset(&wrqu, 0, sizeof(wrqu));
+ wrqu.data.length = sizeof(pmkid_cand);
+
+ wireless_send_event(priv->netdev[interfaceTag], IWEVPMKIDCAND, &wrqu, (char *)&pmkid_cand);
+#endif
+} /* wext_send_pmkid_candidate_event() */
+
+/*
+ * Send a custom WEXT event to say we have completed initialisation
+ * and are now ready for WEXT ioctls. Used by Android wpa_supplicant.
+ */
+void
+wext_send_started_event(unifi_priv_t *priv)
+{
+#if WIRELESS_EXT > 17
+ union iwreq_data wrqu;
+ char data[] = "STARTED";
+
+ wrqu.data.length = sizeof(data);
+ wrqu.data.flags = 0;
+ wireless_send_event(priv->netdev[CSR_WIFI_INTERFACE_IN_USE], IWEVCUSTOM, &wrqu, data);
+#endif
+} /* wext_send_started_event() */
+
MODULE_AUTHOR("Victor Soriano <vjsoriano@agere.com>");
MODULE_AUTHOR("Mark Einon <mark.einon@gmail.com>");
MODULE_LICENSE("Dual BSD/GPL");
-MODULE_DESCRIPTION("10/100/1000 Base-T Ethernet Driver "
- "for the ET1310 by Agere Systems");
+MODULE_DESCRIPTION("10/100/1000 Base-T Ethernet Driver for the ET1310 by Agere Systems");
/* EEPROM defines */
#define MAX_NUM_REGISTER_POLLS 1000
/* Set the link status interrupt only. Bad behavior when link status
* and auto neg are set, we run into a nested interrupt problem
*/
- imr |= (ET_PHY_INT_MASK_AUTONEGSTAT &
- ET_PHY_INT_MASK_LINKSTAT &
+ imr |= (ET_PHY_INT_MASK_AUTONEGSTAT |
+ ET_PHY_INT_MASK_LINKSTAT |
ET_PHY_INT_MASK_ENABLE);
et131x_mii_write(adapter, PHY_INTERRUPT_MASK, imr);
if ((adapter->eeprom_data[1] & 0x4) == 0) {
et131x_mii_read(adapter, PHY_LED_2, &lcr2);
- lcr2 &= (ET_LED2_LED_100TX & ET_LED2_LED_1000T);
+ lcr2 &= (ET_LED2_LED_100TX | ET_LED2_LED_1000T);
lcr2 |= (LED_VAL_LINKON_ACTIVE << LED_LINK_SHIFT);
if ((adapter->eeprom_data[1] & 0x8) == 0)
(ring_index == 0 &&
buff_index > rx_local->fbr[1]->num_entries - 1) ||
(ring_index == 1 &&
- buff_index > rx_local->fbr[0]->num_entries - 1))
+ buff_index > rx_local->fbr[0]->num_entries - 1)) {
#else
- if (ring_index != 1 || buff_index > rx_local->fbr[0]->num_entries - 1)
+ if (ring_index != 1 || buff_index > rx_local->fbr[0]->num_entries - 1) {
#endif
- {
/* Illegal buffer or ring index cannot be used by S/W*/
dev_err(&adapter->pdev->dev,
"NICRxPkts PSR Entry %d indicates "
phydev->advertising = phydev->supported;
adapter->phydev = phydev;
- dev_info(&adapter->pdev->dev, "attached PHY driver [%s] "
- "(mii_bus:phy_addr=%s)\n",
+ dev_info(&adapter->pdev->dev, "attached PHY driver [%s] (mii_bus:phy_addr=%s)\n",
phydev->drv->name, dev_name(&phydev->dev));
return 0;
{
struct ft1000_info *pInfo = netdev_priv(dev);
struct timeval tv;
- int ret;
DEBUG("ft1000_open is called for card %d\n", pInfo->CardNumber);
netif_carrier_on(dev);
- ret = ft1000_submit_rx_urb(pInfo);
-
- return ret;
+ return ft1000_submit_rx_urb(pInfo);
}
//---------------------------------------------------------------------------
struct ft1000_info *pft1000info = NULL;
const struct firmware *dsp_fw;
- ft1000dev = kmalloc(sizeof(struct ft1000_device), GFP_KERNEL);
+ ft1000dev = kzalloc(sizeof(struct ft1000_device), GFP_KERNEL);
if (!ft1000dev) {
printk(KERN_ERR "out of memory allocating device structure\n");
- return 0;
+ return -ENOMEM;
}
- memset(ft1000dev, 0, sizeof(*ft1000dev));
-
dev = interface_to_usbdev(interface);
DEBUG("ft1000_probe: usb device descriptor info:\n");
DEBUG("ft1000_probe: number of configuration is %d\n",
* GNU General Public License for more details.
*/
-#include <linux/version.h>
#include <linux/etherdevice.h>
#include <asm/byteorder.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
-#include <linux/version.h>
#include <linux/mmc/core.h>
#include <linux/mmc/card.h>
*/
#include <linux/module.h>
-#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/usb.h>
#include <asm/byteorder.h>
+#include <linux/kthread.h>
#include "gdm_usb.h"
#include "gdm_wimax.h"
}
}
-static void gdm_usb_send_complete(struct urb *urb)
+static void __gdm_usb_send_complete(struct urb *urb)
{
struct usb_tx *t = urb->context;
struct tx_cxt *tx = t->tx_cxt;
u8 *pkt = t->buf;
u16 cmd_evt;
- unsigned long flags;
/* Completion by usb_unlink_urb */
if (urb->status == -ECONNRESET)
return;
- spin_lock_irqsave(&tx->lock, flags);
-
if (t->callback)
t->callback(t->cb_data);
put_tx_struct(tx, t);
else
free_tx_struct(t);
+}
+
+static void gdm_usb_send_complete(struct urb *urb)
+{
+ struct usb_tx *t = urb->context;
+ struct tx_cxt *tx = t->tx_cxt;
+ unsigned long flags;
+ spin_lock_irqsave(&tx->lock, flags);
+ __gdm_usb_send_complete(urb);
spin_unlock_irqrestore(&tx->lock, flags);
}
send_fail:
t->callback = NULL;
- gdm_usb_send_complete(t->urb);
+ __gdm_usb_send_complete(t->urb);
spin_unlock_irqrestore(&tx->lock, flags);
return ret;
}
if (ret) {
t->callback = NULL;
- gdm_usb_send_complete(t->urb);
+ __gdm_usb_send_complete(t->urb);
}
}
}
if (ret) {
t->callback = NULL;
- gdm_usb_send_complete(t->urb);
+ __gdm_usb_send_complete(t->urb);
}
}
static int __init usb_gdm_wimax_init(void)
{
#ifdef CONFIG_WIMAX_GDM72XX_K_MODE
- kernel_thread(k_mode_thread, NULL, CLONE_KERNEL);
+ kthread_run(k_mode_thread, NULL, "WiMax_thread");
#endif /* CONFIG_WIMAX_GDM72XX_K_MODE */
return usb_register(&gdm_usb_driver);
}
* GNU General Public License for more details.
*/
-#include <linux/version.h>
#include <linux/etherdevice.h>
#include <asm/byteorder.h>
#include <linux/ip.h>
#define __GDM_WIMAX_H__
#include <linux/netdevice.h>
-#include <linux/version.h>
#include <linux/types.h>
#include "wm_ioctl.h"
#if defined(CONFIG_WIMAX_GDM72XX_QOS)
* GNU General Public License for more details.
*/
-#include <linux/version.h>
#include <linux/module.h>
#include <linux/etherdevice.h>
#include <linux/netlink.h>
}
seq++;
- nlh = NLMSG_PUT(skb, 0, seq, type, len);
- memcpy(NLMSG_DATA(nlh), msg, len);
+ nlh = nlmsg_put(skb, 0, seq, type, len, 0);
+ if (!nlh) {
+ kfree_skb(skb);
+ return -EMSGSIZE;
+ }
+
+ memcpy(nlmsg_data(nlh), msg, len);
NETLINK_CB(skb).pid = 0;
NETLINK_CB(skb).dst_group = 0;
ret = 0;
}
-nlmsg_failure:
return ret;
}
*/
#include <linux/module.h>
-#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/uaccess.h>
#include <linux/module.h>
-#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/usb.h>
where chip_state is a structure of local state data for this instance of
the chip.
-That data can be accessed using iio_priv(struct iio_dev *)
+That data can be accessed using iio_priv(struct iio_dev *).
Then fill in the following:
and for associate parameters such as offsets and scales.
* info->write_raw:
Raw value writing function. Used for writable device values such
- as DAC values and caliboffset.
+ as DAC values and calibbias.
* info->read_event_config:
Typically only set if there are some interrupt lines. This
is used to read if an on sensor event detector is enabled.
Poll function related elements. This controls what occurs when a trigger
to which this device is attached sends an event.
- indio_dev->channels:
- Specification of device channels. Most attributes etc are built
- form this spec.
+ Specification of device channels. Most attributes etc. are built
+ from this spec.
- indio_dev->num_channels:
How many channels are there?
gets confused)
On remove, iio_device_unregister(indio_dev) will remove the device from
-the core, and iio_device_free will clean up.
+the core, and iio_device_free(indio_dev) will clean up.
*
*/
+#define _GNU_SOURCE
+
#include <unistd.h>
#include <dirent.h>
#include <fcntl.h>
#include <string.h>
#include <poll.h>
#include <endian.h>
+#include <getopt.h>
+#include <inttypes.h>
#include "iio_utils.h"
/**
* size_from_channelarray() - calculate the storage size of a scan
- * @channels: the channel info array
- * @num_channels: size of the channel info array
+ * @channels: the channel info array
+ * @num_channels: number of channels
*
* Has the side effect of filling the channels[i].location values used
* in processing the buffer output.
void print2byte(int input, struct iio_channel_info *info)
{
/* First swap if incorrect endian */
-
if (info->be)
input = be16toh((uint16_t)input);
else
input = le16toh((uint16_t)input);
- /* shift before conversion to avoid sign extension
- of left aligned data */
+ /*
+ * Shift before conversion to avoid sign extension
+ * of left aligned data
+ */
input = input >> info->shift;
if (info->is_signed) {
int16_t val = input;
val &= (1 << info->bits_used) - 1;
val = (int16_t)(val << (16 - info->bits_used)) >>
(16 - info->bits_used);
- printf("%05f ", val,
- (float)(val + info->offset)*info->scale);
+ printf("%05f ", ((float)val + info->offset)*info->scale);
} else {
uint16_t val = input;
val &= (1 << info->bits_used) - 1;
/**
* process_scan() - print out the values in SI units
* @data: pointer to the start of the scan
- * @infoarray: information about the channels. Note
+ * @channels: information about the channels. Note
* size_from_channelarray must have been called first to fill the
* location offsets.
- * @num_channels: the number of active channels
+ * @num_channels: number of channels
**/
void process_scan(char *data,
- struct iio_channel_info *infoarray,
+ struct iio_channel_info *channels,
int num_channels)
{
int k;
for (k = 0; k < num_channels; k++)
- switch (infoarray[k].bytes) {
+ switch (channels[k].bytes) {
/* only a few cases implemented so far */
case 2:
- print2byte(*(uint16_t *)(data + infoarray[k].location),
- &infoarray[k]);
+ print2byte(*(uint16_t *)(data + channels[k].location),
+ &channels[k]);
break;
case 8:
- if (infoarray[k].is_signed) {
+ if (channels[k].is_signed) {
int64_t val = *(int64_t *)
(data +
- infoarray[k].location);
- if ((val >> infoarray[k].bits_used) & 1)
- val = (val & infoarray[k].mask) |
- ~infoarray[k].mask;
+ channels[k].location);
+ if ((val >> channels[k].bits_used) & 1)
+ val = (val & channels[k].mask) |
+ ~channels[k].mask;
/* special case for timestamp */
- if (infoarray[k].scale == 1.0f &&
- infoarray[k].offset == 0.0f)
- printf(" %lld", val);
+ if (channels[k].scale == 1.0f &&
+ channels[k].offset == 0.0f)
+ printf("%" PRId64 " ", val);
else
printf("%05f ", ((float)val +
- infoarray[k].offset)*
- infoarray[k].scale);
+ channels[k].offset)*
+ channels[k].scale);
}
break;
default:
unsigned long timedelay = 1000000;
unsigned long buf_len = 128;
-
int ret, c, i, j, toread;
-
- FILE *fp_ev;
int fp;
int num_channels;
int noevents = 0;
char *dummy;
- struct iio_channel_info *infoarray;
+ struct iio_channel_info *channels;
while ((c = getopt(argc, argv, "l:w:c:et:n:")) != -1) {
switch (c) {
asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num);
if (trigger_name == NULL) {
/*
- * Build the trigger name. If it is device associated it's
+ * Build the trigger name. If it is device associated its
* name is <device_name>_dev[n] where n matches the device
* number found above
*/
* Parse the files in scan_elements to identify what channels are
* present
*/
- ret = build_channel_array(dev_dir_name, &infoarray, &num_channels);
+ ret = build_channel_array(dev_dir_name, &channels, &num_channels);
if (ret) {
printf("Problem reading scan element information\n");
printf("diag %s\n", dev_dir_name);
goto error_free_triggername;
}
printf("%s %s\n", dev_dir_name, trigger_name);
- /* Set the device trigger to be the data rdy trigger found above */
+ /* Set the device trigger to be the data ready trigger found above */
ret = write_sysfs_string_and_verify("trigger/current_trigger",
dev_dir_name,
trigger_name);
ret = write_sysfs_int("enable", buf_dir_name, 1);
if (ret < 0)
goto error_free_buf_dir_name;
- scan_size = size_from_channelarray(infoarray, num_channels);
+ scan_size = size_from_channelarray(channels, num_channels);
data = malloc(scan_size*buf_len);
if (!data) {
ret = -ENOMEM;
/* Attempt to open non blocking the access dev */
fp = open(buffer_access, O_RDONLY | O_NONBLOCK);
- if (fp == -1) { /*If it isn't there make the node */
+ if (fp == -1) { /* If it isn't there make the node */
printf("Failed to open %s\n", buffer_access);
ret = -errno;
goto error_free_buffer_access;
}
for (i = 0; i < read_size/scan_size; i++)
process_scan(data + scan_size*i,
- infoarray,
+ channels,
num_channels);
}
- /* Stop the ring buffer */
+ /* Stop the buffer */
ret = write_sysfs_int("enable", buf_dir_name, 0);
if (ret < 0)
goto error_close_buffer_access;
- /* Disconnect from the trigger - just write a dummy name.*/
+ /* Disconnect the trigger - just write a dummy name. */
write_sysfs_string("trigger/current_trigger",
dev_dir_name, "NULL");
[IIO_ANGL] = "angl",
[IIO_TIMESTAMP] = "timestamp",
[IIO_CAPACITANCE] = "capacitance",
+ [IIO_ALTVOLTAGE] = "altvoltage",
};
static const char * const iio_ev_type_text[] = {
case IIO_ANGL:
case IIO_TIMESTAMP:
case IIO_CAPACITANCE:
+ case IIO_ALTVOLTAGE:
break;
default:
return false;
* the Free Software Foundation.
*/
-/* Made up value to limit allocation sizes */
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdio.h>
#include <stdint.h>
#include <dirent.h>
+#include <errno.h>
+/* Made up value to limit allocation sizes */
#define IIO_MAX_NAME_LENGTH 30
#define FORMAT_SCAN_ELEMENTS_DIR "%s/scan_elements"
* @full_name: the full channel name
* @generic_name: the output generic channel name
**/
-static int iioutils_break_up_name(const char *full_name,
+inline int iioutils_break_up_name(const char *full_name,
char **generic_name)
{
char *current;
{
DIR *dp;
FILE *sysfsfp;
- int count, temp, i;
+ int count, i;
struct iio_channel_info *current;
int ret;
const struct dirent *ent;
The aim is to fill the gap between the somewhat similar hwmon and
input subsystems. Hwmon is very much directed at low sample rate
sensors used in applications such as fan speed control and temperature
-measurement. Input is, as it's name suggests focused on input
+measurement. Input is, as its name suggests focused on input
devices. In some cases there is considerable overlap between these and
IIO.
which in turn contains the 4 function pointers
(preenable, postenable, predisable and postdisable).
These are used to perform device specific steps on either side
-of the core changing it's current mode to indicate that the buffer
-is enabled or disabled (along with enabling triggering etc as appropriate).
+of the core changing its current mode to indicate that the buffer
+is enabled or disabled (along with enabling triggering etc. as appropriate).
Also in struct iio_ring_buffer is a struct iio_ring_access_funcs.
The function pointers within here are used to allow the core to handle
it comes back in SI units, it should also include _input else it
should include _raw to signify it is not in SI units.
-What: /sys/.../device[n]/proximity_on_chip_ambient_infrared_supression
+What: /sys/.../device[n]/proximity_on_chip_ambient_infrared_suppression
KernelVersion: 2.6.37
Contact: linux-iio@vger.kernel.org
Description:
source "drivers/staging/iio/adc/Kconfig"
source "drivers/staging/iio/addac/Kconfig"
source "drivers/staging/iio/cdc/Kconfig"
-source "drivers/staging/iio/dac/Kconfig"
source "drivers/staging/iio/frequency/Kconfig"
source "drivers/staging/iio/gyro/Kconfig"
source "drivers/staging/iio/impedance-analyzer/Kconfig"
obj-y += adc/
obj-y += addac/
obj-y += cdc/
-obj-y += dac/
obj-y += frequency/
obj-y += gyro/
obj-y += impedance-analyzer/
{
struct iio_dev *indio_dev = spi_get_drvdata(spi);
- flush_scheduled_work();
-
iio_device_unregister(indio_dev);
adis16209_remove_trigger(indio_dev);
iio_buffer_unregister(indio_dev);
{
struct iio_dev *indio_dev = spi_get_drvdata(spi);
- flush_scheduled_work();
-
sysfs_remove_bin_file(&indio_dev->dev.kobj, &adc2_bin);
sysfs_remove_bin_file(&indio_dev->dev.kobj, &adc1_bin);
sysfs_remove_bin_file(&indio_dev->dev.kobj, &accel_bin);
struct iio_dev *indio_dev = spi_get_drvdata(spi);
- flush_scheduled_work();
-
iio_device_unregister(indio_dev);
adis16240_remove_trigger(indio_dev);
iio_buffer_unregister(indio_dev);
config AD7298
tristate "Analog Devices AD7298 ADC driver"
depends on SPI
- select IIO_KFIFO_BUF if IIO_BUFFER
+ select IIO_TRIGGERED_BUFFER if IIO_BUFFER
help
Say yes here to build support for Analog Devices AD7298
8 Channel ADC with temperature sensor.
tristate "Analog Devices AD7606 ADC driver"
depends on GPIOLIB
select IIO_BUFFER
- select IIO_TRIGGER
- select IIO_KFIFO_BUF
+ select IIO_TRIGGERED_BUFFER
help
Say yes here to build support for Analog Devices:
ad7606, ad7606-6, ad7606-4 analog to digital converters (ADC).
bool "Analog Devices AD799x: use ring buffer"
depends on AD799X
select IIO_BUFFER
- select IIO_KFIFO_BUF
+ select IIO_TRIGGERED_BUFFER
help
Say yes here to include ring buffer support in the AD799X
ADC driver.
tristate "Analog Devices AD7475/6/7/8 AD7466/7/8 and AD7495 ADC driver"
depends on SPI
select IIO_BUFFER
- select IIO_KFIFO_BUF
- select IIO_TRIGGER
+ select IIO_TRIGGERED_BUFFER
help
Say yes here to build support for Analog Devices
AD7475, AD7476, AD7477, AD7478, AD7466, AD7467, AD7468, AD7495
tristate "Analog Devices AD7887 ADC driver"
depends on SPI
select IIO_BUFFER
- select IIO_KFIFO_BUF
- select IIO_TRIGGER
+ select IIO_TRIGGERED_BUFFER
help
Say yes here to build support for Analog Devices
AD7887 SPI analog to digital converter (ADC).
tristate "Analog Devices AD7792 AD7793 ADC driver"
depends on SPI
select IIO_BUFFER
- select IIO_KFIFO_BUF
- select IIO_TRIGGER
+ select IIO_TRIGGERED_BUFFER
help
Say yes here to build support for Analog Devices
AD7792 and AD7793 SPI analog to digital converters (ADC).
tristate "Analog Devices AD7190 AD7192 AD7195 ADC driver"
depends on SPI
select IIO_BUFFER
- select IIO_KFIFO_BUF
- select IIO_TRIGGER
+ select IIO_TRIGGERED_BUFFER
help
Say yes here to build support for Analog Devices AD7190,
AD7192 or AD7195 SPI analog to digital converters (ADC).
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/buffer.h>
-#include <linux/iio/kfifo_buf.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
#include "ad7192.h"
static int ad7192_register_ring_funcs_and_init(struct iio_dev *indio_dev)
{
- int ret;
-
- indio_dev->buffer = iio_kfifo_allocate(indio_dev);
- if (!indio_dev->buffer) {
- ret = -ENOMEM;
- goto error_ret;
- }
- indio_dev->pollfunc = iio_alloc_pollfunc(&iio_pollfunc_store_time,
- &ad7192_trigger_handler,
- IRQF_ONESHOT,
- indio_dev,
- "ad7192_consumer%d",
- indio_dev->id);
- if (indio_dev->pollfunc == NULL) {
- ret = -ENOMEM;
- goto error_deallocate_kfifo;
- }
-
- /* Ring buffer functions - here trigger setup related */
- indio_dev->setup_ops = &ad7192_ring_setup_ops;
-
- /* Flag that polled ring buffering is possible */
- indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
- return 0;
-
-error_deallocate_kfifo:
- iio_kfifo_free(indio_dev->buffer);
-error_ret:
- return ret;
+ return iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
+ &ad7192_trigger_handler, &ad7192_ring_setup_ops);
}
static void ad7192_ring_cleanup(struct iio_dev *indio_dev)
{
- iio_dealloc_pollfunc(indio_dev->pollfunc);
- iio_kfifo_free(indio_dev->buffer);
+ iio_triggered_buffer_cleanup(indio_dev);
}
/**
if (ret)
goto error_ring_cleanup;
- ret = iio_buffer_register(indio_dev,
- indio_dev->channels,
- indio_dev->num_channels);
- if (ret)
- goto error_remove_trigger;
-
ret = ad7192_setup(st);
if (ret)
- goto error_unreg_ring;
+ goto error_remove_trigger;
ret = iio_device_register(indio_dev);
if (ret < 0)
- goto error_unreg_ring;
+ goto error_remove_trigger;
return 0;
-error_unreg_ring:
- iio_buffer_unregister(indio_dev);
error_remove_trigger:
ad7192_remove_trigger(indio_dev);
error_ring_cleanup:
struct ad7192_state *st = iio_priv(indio_dev);
iio_device_unregister(indio_dev);
- iio_buffer_unregister(indio_dev);
ad7192_remove_trigger(indio_dev);
ad7192_ring_cleanup(indio_dev);
#ifdef CONFIG_IIO_BUFFER
int ad7298_register_ring_funcs_and_init(struct iio_dev *indio_dev);
void ad7298_ring_cleanup(struct iio_dev *indio_dev);
+int ad7298_update_scan_mode(struct iio_dev *indio_dev,
+ const unsigned long *active_scan_mask);
#else /* CONFIG_IIO_BUFFER */
static inline int
static inline void ad7298_ring_cleanup(struct iio_dev *indio_dev)
{
}
+
+#define ad7298_update_scan_mode NULL
+
#endif /* CONFIG_IIO_BUFFER */
#endif /* IIO_ADC_AD7298_H_ */
.channel = 0,
.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
- .address = 9,
- .scan_index = AD7298_CH_TEMP,
+ .address = AD7298_CH_TEMP,
+ .scan_index = -1,
.scan_type = {
.sign = 's',
.realbits = 32,
static const struct iio_info ad7298_info = {
.read_raw = &ad7298_read_raw,
+ .update_scan_mode = ad7298_update_scan_mode,
.driver_module = THIS_MODULE,
};
if (ret)
goto error_disable_reg;
- ret = iio_buffer_register(indio_dev,
- &ad7298_channels[1], /* skip temp0 */
- ARRAY_SIZE(ad7298_channels) - 1);
- if (ret)
- goto error_cleanup_ring;
ret = iio_device_register(indio_dev);
if (ret)
- goto error_unregister_ring;
+ goto error_cleanup_ring;
return 0;
-error_unregister_ring:
- iio_buffer_unregister(indio_dev);
error_cleanup_ring:
ad7298_ring_cleanup(indio_dev);
error_disable_reg:
struct ad7298_state *st = iio_priv(indio_dev);
iio_device_unregister(indio_dev);
- iio_buffer_unregister(indio_dev);
ad7298_ring_cleanup(indio_dev);
if (!IS_ERR(st->reg)) {
regulator_disable(st->reg);
#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
-#include <linux/iio/kfifo_buf.h>
#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
#include "ad7298.h"
/**
- * ad7298_ring_preenable() setup the parameters of the ring before enabling
- *
- * The complex nature of the setting of the number of bytes per datum is due
- * to this driver currently ensuring that the timestamp is stored at an 8
- * byte boundary.
+ * ad7298_update_scan_mode() setup the spi transfer buffer for the new scan mask
**/
-static int ad7298_ring_preenable(struct iio_dev *indio_dev)
+int ad7298_update_scan_mode(struct iio_dev *indio_dev,
+ const unsigned long *active_scan_mask)
{
struct ad7298_state *st = iio_priv(indio_dev);
int i, m;
unsigned short command;
- int scan_count, ret;
-
- ret = iio_sw_buffer_preenable(indio_dev);
- if (ret < 0)
- return ret;
+ int scan_count;
/* Now compute overall size */
- scan_count = bitmap_weight(indio_dev->active_scan_mask,
- indio_dev->masklength);
+ scan_count = bitmap_weight(active_scan_mask, indio_dev->masklength);
command = AD7298_WRITE | st->ext_ref;
for (i = 0, m = AD7298_CH(0); i < AD7298_MAX_CHAN; i++, m >>= 1)
- if (test_bit(i, indio_dev->active_scan_mask))
+ if (test_bit(i, active_scan_mask))
command |= m;
st->tx_buf[0] = cpu_to_be16(command);
return IRQ_HANDLED;
}
-static const struct iio_buffer_setup_ops ad7298_ring_setup_ops = {
- .preenable = &ad7298_ring_preenable,
- .postenable = &iio_triggered_buffer_postenable,
- .predisable = &iio_triggered_buffer_predisable,
-};
-
int ad7298_register_ring_funcs_and_init(struct iio_dev *indio_dev)
{
- int ret;
-
- indio_dev->buffer = iio_kfifo_allocate(indio_dev);
- if (!indio_dev->buffer) {
- ret = -ENOMEM;
- goto error_ret;
- }
- indio_dev->pollfunc = iio_alloc_pollfunc(NULL,
- &ad7298_trigger_handler,
- IRQF_ONESHOT,
- indio_dev,
- "ad7298_consumer%d",
- indio_dev->id);
-
- if (indio_dev->pollfunc == NULL) {
- ret = -ENOMEM;
- goto error_deallocate_kfifo;
- }
-
- /* Ring buffer functions - here trigger setup related */
- indio_dev->setup_ops = &ad7298_ring_setup_ops;
- indio_dev->buffer->scan_timestamp = true;
-
- /* Flag that polled ring buffering is possible */
- indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
- return 0;
-
-error_deallocate_kfifo:
- iio_kfifo_free(indio_dev->buffer);
-error_ret:
- return ret;
+ return iio_triggered_buffer_setup(indio_dev, NULL,
+ &ad7298_trigger_handler, NULL);
}
void ad7298_ring_cleanup(struct iio_dev *indio_dev)
{
- iio_dealloc_pollfunc(indio_dev->pollfunc);
- iio_kfifo_free(indio_dev->buffer);
+ iio_triggered_buffer_cleanup(indio_dev);
}
if (ret)
goto error_disable_reg;
- ret = iio_buffer_register(indio_dev,
- st->chip_info->channel,
- ARRAY_SIZE(st->chip_info->channel));
- if (ret)
- goto error_cleanup_ring;
-
ret = iio_device_register(indio_dev);
if (ret)
goto error_ring_unregister;
return 0;
error_ring_unregister:
- iio_buffer_unregister(indio_dev);
-error_cleanup_ring:
ad7476_ring_cleanup(indio_dev);
error_disable_reg:
if (!IS_ERR(st->reg))
struct ad7476_state *st = iio_priv(indio_dev);
iio_device_unregister(indio_dev);
- iio_buffer_unregister(indio_dev);
ad7476_ring_cleanup(indio_dev);
if (!IS_ERR(st->reg)) {
regulator_disable(st->reg);
#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
-#include <linux/iio/kfifo_buf.h>
#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
#include "ad7476.h"
return IRQ_HANDLED;
}
-static const struct iio_buffer_setup_ops ad7476_ring_setup_ops = {
- .preenable = &iio_sw_buffer_preenable,
- .postenable = &iio_triggered_buffer_postenable,
- .predisable = &iio_triggered_buffer_predisable,
-};
-
int ad7476_register_ring_funcs_and_init(struct iio_dev *indio_dev)
{
- struct ad7476_state *st = iio_priv(indio_dev);
- int ret = 0;
-
- indio_dev->buffer = iio_kfifo_allocate(indio_dev);
- if (!indio_dev->buffer) {
- ret = -ENOMEM;
- goto error_ret;
- }
- indio_dev->pollfunc
- = iio_alloc_pollfunc(NULL,
- &ad7476_trigger_handler,
- IRQF_ONESHOT,
- indio_dev,
- "%s_consumer%d",
- spi_get_device_id(st->spi)->name,
- indio_dev->id);
- if (indio_dev->pollfunc == NULL) {
- ret = -ENOMEM;
- goto error_deallocate_kfifo;
- }
-
- /* Ring buffer functions - here trigger setup related */
- indio_dev->setup_ops = &ad7476_ring_setup_ops;
- indio_dev->buffer->scan_timestamp = true;
-
- /* Flag that polled ring buffering is possible */
- indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
- return 0;
-
-error_deallocate_kfifo:
- iio_kfifo_free(indio_dev->buffer);
-error_ret:
- return ret;
+ return iio_triggered_buffer_setup(indio_dev, NULL,
+ &ad7476_trigger_handler, NULL);
}
void ad7476_ring_cleanup(struct iio_dev *indio_dev)
{
- iio_dealloc_pollfunc(indio_dev->pollfunc);
- iio_kfifo_free(indio_dev->buffer);
+ iio_triggered_buffer_cleanup(indio_dev);
}
if (ret)
goto error_free_irq;
- ret = iio_buffer_register(indio_dev,
- indio_dev->channels,
- indio_dev->num_channels);
- if (ret)
- goto error_cleanup_ring;
ret = iio_device_register(indio_dev);
if (ret)
goto error_unregister_ring;
return indio_dev;
error_unregister_ring:
- iio_buffer_unregister(indio_dev);
-
-error_cleanup_ring:
ad7606_ring_cleanup(indio_dev);
error_free_irq:
struct ad7606_state *st = iio_priv(indio_dev);
iio_device_unregister(indio_dev);
- iio_buffer_unregister(indio_dev);
ad7606_ring_cleanup(indio_dev);
free_irq(irq, indio_dev);
#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
-#include <linux/iio/kfifo_buf.h>
#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
#include "ad7606.h"
kfree(buf);
}
-static const struct iio_buffer_setup_ops ad7606_ring_setup_ops = {
- .preenable = &iio_sw_buffer_preenable,
- .postenable = &iio_triggered_buffer_postenable,
- .predisable = &iio_triggered_buffer_predisable,
-};
-
int ad7606_register_ring_funcs_and_init(struct iio_dev *indio_dev)
{
struct ad7606_state *st = iio_priv(indio_dev);
- int ret;
-
- indio_dev->buffer = iio_kfifo_allocate(indio_dev);
- if (!indio_dev->buffer) {
- ret = -ENOMEM;
- goto error_ret;
- }
-
- indio_dev->pollfunc = iio_alloc_pollfunc(&ad7606_trigger_handler_th_bh,
- &ad7606_trigger_handler_th_bh,
- 0,
- indio_dev,
- "%s_consumer%d",
- indio_dev->name,
- indio_dev->id);
- if (indio_dev->pollfunc == NULL) {
- ret = -ENOMEM;
- goto error_deallocate_kfifo;
- }
-
- /* Ring buffer functions - here trigger setup related */
-
- indio_dev->setup_ops = &ad7606_ring_setup_ops;
- indio_dev->buffer->scan_timestamp = true;
INIT_WORK(&st->poll_work, &ad7606_poll_bh_to_ring);
- /* Flag that polled ring buffering is possible */
- indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
- return 0;
-
-error_deallocate_kfifo:
- iio_kfifo_free(indio_dev->buffer);
-error_ret:
- return ret;
+ return iio_triggered_buffer_setup(indio_dev,
+ &ad7606_trigger_handler_th_bh, &ad7606_trigger_handler_th_bh,
+ NULL);
}
void ad7606_ring_cleanup(struct iio_dev *indio_dev)
{
- iio_dealloc_pollfunc(indio_dev->pollfunc);
- iio_kfifo_free(indio_dev->buffer);
+ iio_triggered_buffer_cleanup(indio_dev);
}
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/buffer.h>
-#include <linux/iio/kfifo_buf.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
#include "ad7793.h"
static int ad7793_register_ring_funcs_and_init(struct iio_dev *indio_dev)
{
- int ret;
-
- indio_dev->buffer = iio_kfifo_allocate(indio_dev);
- if (!indio_dev->buffer) {
- ret = -ENOMEM;
- goto error_ret;
- }
- indio_dev->pollfunc = iio_alloc_pollfunc(&iio_pollfunc_store_time,
- &ad7793_trigger_handler,
- IRQF_ONESHOT,
- indio_dev,
- "ad7793_consumer%d",
- indio_dev->id);
- if (indio_dev->pollfunc == NULL) {
- ret = -ENOMEM;
- goto error_deallocate_kfifo;
- }
-
- /* Ring buffer functions - here trigger setup related */
- indio_dev->setup_ops = &ad7793_ring_setup_ops;
-
- /* Flag that polled ring buffering is possible */
- indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
- return 0;
-
-error_deallocate_kfifo:
- iio_kfifo_free(indio_dev->buffer);
-error_ret:
- return ret;
+ return iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
+ &ad7793_trigger_handler, &ad7793_ring_setup_ops);
}
static void ad7793_ring_cleanup(struct iio_dev *indio_dev)
{
- iio_dealloc_pollfunc(indio_dev->pollfunc);
- iio_kfifo_free(indio_dev->buffer);
+ iio_triggered_buffer_cleanup(indio_dev);
}
/**
if (ret)
goto error_unreg_ring;
- ret = iio_buffer_register(indio_dev,
- indio_dev->channels,
- indio_dev->num_channels);
- if (ret)
- goto error_remove_trigger;
-
ret = ad7793_setup(st);
if (ret)
- goto error_uninitialize_ring;
+ goto error_remove_trigger;
ret = iio_device_register(indio_dev);
if (ret)
- goto error_uninitialize_ring;
+ goto error_remove_trigger;
return 0;
-error_uninitialize_ring:
- iio_buffer_unregister(indio_dev);
error_remove_trigger:
ad7793_remove_trigger(indio_dev);
error_unreg_ring:
struct ad7793_state *st = iio_priv(indio_dev);
iio_device_unregister(indio_dev);
- iio_buffer_unregister(indio_dev);
ad7793_remove_trigger(indio_dev);
ad7793_ring_cleanup(indio_dev);
if (ret)
goto error_disable_reg;
- ret = iio_buffer_register(indio_dev,
- indio_dev->channels,
- indio_dev->num_channels);
- if (ret)
- goto error_cleanup_ring;
-
ret = iio_device_register(indio_dev);
if (ret)
goto error_unregister_ring;
return 0;
error_unregister_ring:
- iio_buffer_unregister(indio_dev);
-error_cleanup_ring:
ad7887_ring_cleanup(indio_dev);
error_disable_reg:
if (!IS_ERR(st->reg))
struct ad7887_state *st = iio_priv(indio_dev);
iio_device_unregister(indio_dev);
- iio_buffer_unregister(indio_dev);
ad7887_ring_cleanup(indio_dev);
if (!IS_ERR(st->reg)) {
regulator_disable(st->reg);
#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
-#include <linux/iio/kfifo_buf.h>
#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
#include "ad7887.h"
int ad7887_register_ring_funcs_and_init(struct iio_dev *indio_dev)
{
- int ret;
-
- indio_dev->buffer = iio_kfifo_allocate(indio_dev);
- if (!indio_dev->buffer) {
- ret = -ENOMEM;
- goto error_ret;
- }
- indio_dev->pollfunc = iio_alloc_pollfunc(&iio_pollfunc_store_time,
- &ad7887_trigger_handler,
- IRQF_ONESHOT,
- indio_dev,
- "ad7887_consumer%d",
- indio_dev->id);
- if (indio_dev->pollfunc == NULL) {
- ret = -ENOMEM;
- goto error_deallocate_kfifo;
- }
- /* Ring buffer functions - here trigger setup related */
- indio_dev->setup_ops = &ad7887_ring_setup_ops;
-
- /* Flag that polled ring buffering is possible */
- indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
- return 0;
-
-error_deallocate_kfifo:
- iio_kfifo_free(indio_dev->buffer);
-error_ret:
- return ret;
+ return iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
+ &ad7887_trigger_handler, &ad7887_ring_setup_ops);
}
void ad7887_ring_cleanup(struct iio_dev *indio_dev)
{
- iio_dealloc_pollfunc(indio_dev->pollfunc);
- iio_kfifo_free(indio_dev->buffer);
+ iio_triggered_buffer_cleanup(indio_dev);
}
u16 vref_mv;
};
-int ad7997_8_set_scan_mode(struct ad799x_state *st, unsigned mask);
-
#ifdef CONFIG_AD799X_RING_BUFFER
int ad799x_register_ring_funcs_and_init(struct iio_dev *indio_dev);
void ad799x_ring_cleanup(struct iio_dev *indio_dev);
return ret;
}
-int ad7997_8_set_scan_mode(struct ad799x_state *st, unsigned mask)
+static int ad7997_8_update_scan_mode(struct iio_dev *indio_dev,
+ const unsigned long *scan_mask)
{
- return ad799x_i2c_write16(st, AD7998_CONF_REG,
- st->config | (mask << AD799X_CHANNEL_SHIFT));
+ struct ad799x_state *st = iio_priv(indio_dev);
+
+ switch (st->id) {
+ case ad7997:
+ case ad7998:
+ return ad799x_i2c_write16(st, AD7998_CONF_REG,
+ st->config | (*scan_mask << AD799X_CHANNEL_SHIFT));
+ default:
+ break;
+ }
+
+ return 0;
}
static int ad799x_scan_direct(struct ad799x_state *st, unsigned ch)
.read_event_value = &ad799x_read_event_value,
.write_event_value = &ad799x_write_event_value,
.driver_module = THIS_MODULE,
+ .update_scan_mode = ad7997_8_update_scan_mode,
};
#define AD799X_EV_MASK (IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) | \
if (ret)
goto error_disable_reg;
- ret = iio_buffer_register(indio_dev,
- indio_dev->channels,
- indio_dev->num_channels);
- if (ret)
- goto error_cleanup_ring;
-
if (client->irq > 0) {
ret = request_threaded_irq(client->irq,
NULL,
if (client->irq > 0)
free_irq(client->irq, indio_dev);
- iio_buffer_unregister(indio_dev);
ad799x_ring_cleanup(indio_dev);
if (!IS_ERR(st->reg)) {
regulator_disable(st->reg);
#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
-#include <linux/iio/kfifo_buf.h>
#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
#include "ad799x.h"
-/**
- * ad799x_ring_preenable() setup the parameters of the ring before enabling
- *
- * The complex nature of the setting of the number of bytes per datum is due
- * to this driver currently ensuring that the timestamp is stored at an 8
- * byte boundary.
- **/
-static int ad799x_ring_preenable(struct iio_dev *indio_dev)
-{
- struct ad799x_state *st = iio_priv(indio_dev);
- /*
- * Need to figure out the current mode based upon the requested
- * scan mask in iio_dev
- */
-
- if (st->id == ad7997 || st->id == ad7998)
- ad7997_8_set_scan_mode(st, *indio_dev->active_scan_mask);
-
- return iio_sw_buffer_preenable(indio_dev);
-}
-
/**
* ad799x_trigger_handler() bh of trigger launched polling to ring buffer
*
return IRQ_HANDLED;
}
-static const struct iio_buffer_setup_ops ad799x_buf_setup_ops = {
- .preenable = &ad799x_ring_preenable,
- .postenable = &iio_triggered_buffer_postenable,
- .predisable = &iio_triggered_buffer_predisable,
-};
-
int ad799x_register_ring_funcs_and_init(struct iio_dev *indio_dev)
{
- int ret = 0;
-
- indio_dev->buffer = iio_kfifo_allocate(indio_dev);
- if (!indio_dev->buffer) {
- ret = -ENOMEM;
- goto error_ret;
- }
- indio_dev->pollfunc = iio_alloc_pollfunc(NULL,
- &ad799x_trigger_handler,
- IRQF_ONESHOT,
- indio_dev,
- "%s_consumer%d",
- indio_dev->name,
- indio_dev->id);
- if (indio_dev->pollfunc == NULL) {
- ret = -ENOMEM;
- goto error_deallocate_kfifo;
- }
-
- /* Ring buffer functions - here trigger setup related */
- indio_dev->setup_ops = &ad799x_buf_setup_ops;
- indio_dev->buffer->scan_timestamp = true;
-
- /* Flag that polled ring buffering is possible */
- indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
- return 0;
-
-error_deallocate_kfifo:
- iio_kfifo_free(indio_dev->buffer);
-error_ret:
- return ret;
+ return iio_triggered_buffer_setup(indio_dev, NULL,
+ &ad799x_trigger_handler, NULL);
}
void ad799x_ring_cleanup(struct iio_dev *indio_dev)
{
- iio_dealloc_pollfunc(indio_dev->pollfunc);
- iio_kfifo_free(indio_dev->buffer);
+ iio_triggered_buffer_cleanup(indio_dev);
}
+++ /dev/null
-#
-# DAC drivers
-#
-menu "Digital to analog converters"
-
-config AD5064
- tristate "Analog Devices AD5064/64-1/65/44/45/24/25, AD5628/48/66/68 DAC driver"
- depends on SPI
- help
- Say yes here to build support for Analog Devices AD5024, AD5025, AD5044,
- AD5045, AD5064, AD5064-1, AD5065, AD5628, AD5648, AD5666, AD5668 Digital
- to Analog Converter.
-
- To compile this driver as a module, choose M here: the
- module will be called ad5064.
-
-config AD5360
- tristate "Analog Devices Analog Devices AD5360/61/62/63/70/71/73 DAC driver"
- depends on SPI
- help
- Say yes here to build support for Analog Devices AD5360, AD5361,
- AD5362, AD5363, AD5370, AD5371, AD5373 multi-channel
- Digital to Analog Converters (DAC).
-
- To compile this driver as module choose M here: the module will be called
- ad5360.
-
-config AD5380
- tristate "Analog Devices AD5380/81/82/83/84/90/91/92 DAC driver"
- depends on (SPI_MASTER || I2C)
- select REGMAP_I2C if I2C
- select REGMAP_SPI if SPI_MASTER
- help
- Say yes here to build support for Analog Devices AD5380, AD5381,
- AD5382, AD5383, AD5384, AD5390, AD5391, AD5392 multi-channel
- Digital to Analog Converters (DAC).
-
- To compile this driver as module choose M here: the module will be called
- ad5380.
-
-config AD5421
- tristate "Analog Devices AD5421 DAC driver"
- depends on SPI
- help
- Say yes here to build support for Analog Devices AD5421 loop-powered
- digital-to-analog convertors (DAC).
-
- To compile this driver as module choose M here: the module will be called
- ad5421.
-
-config AD5624R_SPI
- tristate "Analog Devices AD5624/44/64R DAC spi driver"
- depends on SPI
- help
- Say yes here to build support for Analog Devices AD5624R, AD5644R and
- AD5664R converters (DAC). This driver uses the common SPI interface.
-
-config AD5446
- tristate "Analog Devices AD5446 and similar single channel DACs driver"
- depends on SPI
- help
- Say yes here to build support for Analog Devices AD5444, AD5446,
- AD5512A, AD5541A, AD5542A, AD5543, AD5553, AD5601, AD5611, AD5620,
- AD5621, AD5640, AD5660, AD5662 DACs.
-
- To compile this driver as a module, choose M here: the
- module will be called ad5446.
-
-config AD5504
- tristate "Analog Devices AD5504/AD5501 DAC SPI driver"
- depends on SPI
- help
- Say yes here to build support for Analog Devices AD5504, AD5501,
- High Voltage Digital to Analog Converter.
-
- To compile this driver as a module, choose M here: the
- module will be called ad5504.
-
-config AD5764
- tristate "Analog Devices AD5764/64R/44/44R DAC driver"
- depends on SPI_MASTER
- help
- Say yes here to build support for Analog Devices AD5764, AD5764R, AD5744,
- AD5744R Digital to Analog Converter.
-
- To compile this driver as a module, choose M here: the
- module will be called ad5764.
-
-config AD5791
- tristate "Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC SPI driver"
- depends on SPI
- help
- Say yes here to build support for Analog Devices AD5760, AD5780,
- AD5781, AD5790, AD5791 High Resolution Voltage Output Digital to
- Analog Converter.
-
- To compile this driver as a module, choose M here: the
- module will be called ad5791.
-
-config AD5686
- tristate "Analog Devices AD5686R/AD5685R/AD5684R DAC SPI driver"
- depends on SPI
- help
- Say yes here to build support for Analog Devices AD5686R, AD5685R,
- AD5684R, AD5791 Voltage Output Digital to
- Analog Converter.
-
- To compile this driver as a module, choose M here: the
- module will be called ad5686.
-
-config MAX517
- tristate "Maxim MAX517/518/519 DAC driver"
- depends on I2C && EXPERIMENTAL
- help
- If you say yes here you get support for the Maxim chips MAX517,
- MAX518 and MAX519 (I2C 8-Bit DACs with rail-to-rail outputs).
-
- This driver can also be built as a module. If so, the module
- will be called max517.
-
-endmenu
+++ /dev/null
-#
-# Makefile for industrial I/O DAC drivers
-#
-
-obj-$(CONFIG_AD5360) += ad5360.o
-obj-$(CONFIG_AD5380) += ad5380.o
-obj-$(CONFIG_AD5421) += ad5421.o
-obj-$(CONFIG_AD5624R_SPI) += ad5624r_spi.o
-obj-$(CONFIG_AD5064) += ad5064.o
-obj-$(CONFIG_AD5504) += ad5504.o
-obj-$(CONFIG_AD5446) += ad5446.o
-obj-$(CONFIG_AD5764) += ad5764.o
-obj-$(CONFIG_AD5791) += ad5791.o
-obj-$(CONFIG_AD5686) += ad5686.o
-obj-$(CONFIG_MAX517) += max517.o
+++ /dev/null
-/*
- * AD5024, AD5025, AD5044, AD5045, AD5064, AD5064-1, AD5065, AD5628, AD5648,
- * AD5666, AD5668 Digital to analog converters driver
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#include <linux/device.h>
-#include <linux/err.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/regulator/consumer.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include "dac.h"
-
-#define AD5064_MAX_DAC_CHANNELS 8
-#define AD5064_MAX_VREFS 4
-
-#define AD5064_ADDR(x) ((x) << 20)
-#define AD5064_CMD(x) ((x) << 24)
-
-#define AD5064_ADDR_DAC(chan) (chan)
-#define AD5064_ADDR_ALL_DAC 0xF
-
-#define AD5064_CMD_WRITE_INPUT_N 0x0
-#define AD5064_CMD_UPDATE_DAC_N 0x1
-#define AD5064_CMD_WRITE_INPUT_N_UPDATE_ALL 0x2
-#define AD5064_CMD_WRITE_INPUT_N_UPDATE_N 0x3
-#define AD5064_CMD_POWERDOWN_DAC 0x4
-#define AD5064_CMD_CLEAR 0x5
-#define AD5064_CMD_LDAC_MASK 0x6
-#define AD5064_CMD_RESET 0x7
-#define AD5064_CMD_CONFIG 0x8
-
-#define AD5064_CONFIG_DAISY_CHAIN_ENABLE BIT(1)
-#define AD5064_CONFIG_INT_VREF_ENABLE BIT(0)
-
-#define AD5064_LDAC_PWRDN_NONE 0x0
-#define AD5064_LDAC_PWRDN_1K 0x1
-#define AD5064_LDAC_PWRDN_100K 0x2
-#define AD5064_LDAC_PWRDN_3STATE 0x3
-
-/**
- * struct ad5064_chip_info - chip specific information
- * @shared_vref: whether the vref supply is shared between channels
- * @internal_vref: internal reference voltage. 0 if the chip has no internal
- * vref.
- * @channel: channel specification
- * @num_channels: number of channels
- */
-
-struct ad5064_chip_info {
- bool shared_vref;
- unsigned long internal_vref;
- const struct iio_chan_spec *channels;
- unsigned int num_channels;
-};
-
-/**
- * struct ad5064_state - driver instance specific data
- * @spi: spi_device
- * @chip_info: chip model specific constants, available modes etc
- * @vref_reg: vref supply regulators
- * @pwr_down: whether channel is powered down
- * @pwr_down_mode: channel's current power down mode
- * @dac_cache: current DAC raw value (chip does not support readback)
- * @use_internal_vref: set to true if the internal reference voltage should be
- * used.
- * @data: spi transfer buffers
- */
-
-struct ad5064_state {
- struct spi_device *spi;
- const struct ad5064_chip_info *chip_info;
- struct regulator_bulk_data vref_reg[AD5064_MAX_VREFS];
- bool pwr_down[AD5064_MAX_DAC_CHANNELS];
- u8 pwr_down_mode[AD5064_MAX_DAC_CHANNELS];
- unsigned int dac_cache[AD5064_MAX_DAC_CHANNELS];
- bool use_internal_vref;
-
- /*
- * DMA (thus cache coherency maintenance) requires the
- * transfer buffers to live in their own cache lines.
- */
- __be32 data ____cacheline_aligned;
-};
-
-enum ad5064_type {
- ID_AD5024,
- ID_AD5025,
- ID_AD5044,
- ID_AD5045,
- ID_AD5064,
- ID_AD5064_1,
- ID_AD5065,
- ID_AD5628_1,
- ID_AD5628_2,
- ID_AD5648_1,
- ID_AD5648_2,
- ID_AD5666_1,
- ID_AD5666_2,
- ID_AD5668_1,
- ID_AD5668_2,
-};
-
-static int ad5064_spi_write(struct ad5064_state *st, unsigned int cmd,
- unsigned int addr, unsigned int val, unsigned int shift)
-{
- val <<= shift;
-
- st->data = cpu_to_be32(AD5064_CMD(cmd) | AD5064_ADDR(addr) | val);
-
- return spi_write(st->spi, &st->data, sizeof(st->data));
-}
-
-static int ad5064_sync_powerdown_mode(struct ad5064_state *st,
- unsigned int channel)
-{
- unsigned int val;
- int ret;
-
- val = (0x1 << channel);
-
- if (st->pwr_down[channel])
- val |= st->pwr_down_mode[channel] << 8;
-
- ret = ad5064_spi_write(st, AD5064_CMD_POWERDOWN_DAC, 0, val, 0);
-
- return ret;
-}
-
-static const char ad5064_powerdown_modes[][15] = {
- [AD5064_LDAC_PWRDN_NONE] = "",
- [AD5064_LDAC_PWRDN_1K] = "1kohm_to_gnd",
- [AD5064_LDAC_PWRDN_100K] = "100kohm_to_gnd",
- [AD5064_LDAC_PWRDN_3STATE] = "three_state",
-};
-
-static ssize_t ad5064_read_powerdown_mode_available(struct iio_dev *indio_dev,
- uintptr_t private, const struct iio_chan_spec *chan, char *buf)
-{
- return sprintf(buf, "%s %s %s\n", ad5064_powerdown_modes[1],
- ad5064_powerdown_modes[2], ad5064_powerdown_modes[3]);
-}
-
-static ssize_t ad5064_read_powerdown_mode(struct iio_dev *indio_dev,
- uintptr_t private, const struct iio_chan_spec *chan, char *buf)
-{
- struct ad5064_state *st = iio_priv(indio_dev);
-
- return sprintf(buf, "%s\n",
- ad5064_powerdown_modes[st->pwr_down_mode[chan->channel]]);
-}
-
-static ssize_t ad5064_write_powerdown_mode(struct iio_dev *indio_dev,
- uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
- size_t len)
-{
- struct ad5064_state *st = iio_priv(indio_dev);
- unsigned int mode, i;
- int ret;
-
- mode = 0;
-
- for (i = 1; i < ARRAY_SIZE(ad5064_powerdown_modes); ++i) {
- if (sysfs_streq(buf, ad5064_powerdown_modes[i])) {
- mode = i;
- break;
- }
- }
- if (mode == 0)
- return -EINVAL;
-
- mutex_lock(&indio_dev->mlock);
- st->pwr_down_mode[chan->channel] = mode;
-
- ret = ad5064_sync_powerdown_mode(st, chan->channel);
- mutex_unlock(&indio_dev->mlock);
-
- return ret ? ret : len;
-}
-
-static ssize_t ad5064_read_dac_powerdown(struct iio_dev *indio_dev,
- uintptr_t private, const struct iio_chan_spec *chan, char *buf)
-{
- struct ad5064_state *st = iio_priv(indio_dev);
-
- return sprintf(buf, "%d\n", st->pwr_down[chan->channel]);
-}
-
-static ssize_t ad5064_write_dac_powerdown(struct iio_dev *indio_dev,
- uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
- size_t len)
-{
- struct ad5064_state *st = iio_priv(indio_dev);
- bool pwr_down;
- int ret;
-
- ret = strtobool(buf, &pwr_down);
- if (ret)
- return ret;
-
- mutex_lock(&indio_dev->mlock);
- st->pwr_down[chan->channel] = pwr_down;
-
- ret = ad5064_sync_powerdown_mode(st, chan->channel);
- mutex_unlock(&indio_dev->mlock);
- return ret ? ret : len;
-}
-
-static int ad5064_get_vref(struct ad5064_state *st,
- struct iio_chan_spec const *chan)
-{
- unsigned int i;
-
- if (st->use_internal_vref)
- return st->chip_info->internal_vref;
-
- i = st->chip_info->shared_vref ? 0 : chan->channel;
- return regulator_get_voltage(st->vref_reg[i].consumer);
-}
-
-static int ad5064_read_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int *val,
- int *val2,
- long m)
-{
- struct ad5064_state *st = iio_priv(indio_dev);
- int scale_uv;
-
- switch (m) {
- case IIO_CHAN_INFO_RAW:
- *val = st->dac_cache[chan->channel];
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_SCALE:
- scale_uv = ad5064_get_vref(st, chan);
- if (scale_uv < 0)
- return scale_uv;
-
- scale_uv = (scale_uv * 100) >> chan->scan_type.realbits;
- *val = scale_uv / 100000;
- *val2 = (scale_uv % 100000) * 10;
- return IIO_VAL_INT_PLUS_MICRO;
- default:
- break;
- }
- return -EINVAL;
-}
-
-static int ad5064_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan, int val, int val2, long mask)
-{
- struct ad5064_state *st = iio_priv(indio_dev);
- int ret;
-
- switch (mask) {
- case IIO_CHAN_INFO_RAW:
- if (val > (1 << chan->scan_type.realbits) || val < 0)
- return -EINVAL;
-
- mutex_lock(&indio_dev->mlock);
- ret = ad5064_spi_write(st, AD5064_CMD_WRITE_INPUT_N_UPDATE_N,
- chan->address, val, chan->scan_type.shift);
- if (ret == 0)
- st->dac_cache[chan->channel] = val;
- mutex_unlock(&indio_dev->mlock);
- break;
- default:
- ret = -EINVAL;
- }
-
- return ret;
-}
-
-static const struct iio_info ad5064_info = {
- .read_raw = ad5064_read_raw,
- .write_raw = ad5064_write_raw,
- .driver_module = THIS_MODULE,
-};
-
-static struct iio_chan_spec_ext_info ad5064_ext_info[] = {
- {
- .name = "powerdown",
- .read = ad5064_read_dac_powerdown,
- .write = ad5064_write_dac_powerdown,
- },
- {
- .name = "powerdown_mode",
- .read = ad5064_read_powerdown_mode,
- .write = ad5064_write_powerdown_mode,
- },
- {
- .name = "powerdown_mode_available",
- .shared = true,
- .read = ad5064_read_powerdown_mode_available,
- },
- { },
-};
-
-#define AD5064_CHANNEL(chan, bits) { \
- .type = IIO_VOLTAGE, \
- .indexed = 1, \
- .output = 1, \
- .channel = (chan), \
- .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
- IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \
- .address = AD5064_ADDR_DAC(chan), \
- .scan_type = IIO_ST('u', (bits), 16, 20 - (bits)), \
- .ext_info = ad5064_ext_info, \
-}
-
-#define DECLARE_AD5064_CHANNELS(name, bits) \
-const struct iio_chan_spec name[] = { \
- AD5064_CHANNEL(0, bits), \
- AD5064_CHANNEL(1, bits), \
- AD5064_CHANNEL(2, bits), \
- AD5064_CHANNEL(3, bits), \
- AD5064_CHANNEL(4, bits), \
- AD5064_CHANNEL(5, bits), \
- AD5064_CHANNEL(6, bits), \
- AD5064_CHANNEL(7, bits), \
-}
-
-static DECLARE_AD5064_CHANNELS(ad5024_channels, 12);
-static DECLARE_AD5064_CHANNELS(ad5044_channels, 14);
-static DECLARE_AD5064_CHANNELS(ad5064_channels, 16);
-
-static const struct ad5064_chip_info ad5064_chip_info_tbl[] = {
- [ID_AD5024] = {
- .shared_vref = false,
- .channels = ad5024_channels,
- .num_channels = 4,
- },
- [ID_AD5025] = {
- .shared_vref = false,
- .channels = ad5024_channels,
- .num_channels = 2,
- },
- [ID_AD5044] = {
- .shared_vref = false,
- .channels = ad5044_channels,
- .num_channels = 4,
- },
- [ID_AD5045] = {
- .shared_vref = false,
- .channels = ad5044_channels,
- .num_channels = 2,
- },
- [ID_AD5064] = {
- .shared_vref = false,
- .channels = ad5064_channels,
- .num_channels = 4,
- },
- [ID_AD5064_1] = {
- .shared_vref = true,
- .channels = ad5064_channels,
- .num_channels = 4,
- },
- [ID_AD5065] = {
- .shared_vref = false,
- .channels = ad5064_channels,
- .num_channels = 2,
- },
- [ID_AD5628_1] = {
- .shared_vref = true,
- .internal_vref = 2500000,
- .channels = ad5024_channels,
- .num_channels = 8,
- },
- [ID_AD5628_2] = {
- .shared_vref = true,
- .internal_vref = 5000000,
- .channels = ad5024_channels,
- .num_channels = 8,
- },
- [ID_AD5648_1] = {
- .shared_vref = true,
- .internal_vref = 2500000,
- .channels = ad5044_channels,
- .num_channels = 8,
- },
- [ID_AD5648_2] = {
- .shared_vref = true,
- .internal_vref = 5000000,
- .channels = ad5044_channels,
- .num_channels = 8,
- },
- [ID_AD5666_1] = {
- .shared_vref = true,
- .internal_vref = 2500000,
- .channels = ad5064_channels,
- .num_channels = 4,
- },
- [ID_AD5666_2] = {
- .shared_vref = true,
- .internal_vref = 5000000,
- .channels = ad5064_channels,
- .num_channels = 4,
- },
- [ID_AD5668_1] = {
- .shared_vref = true,
- .internal_vref = 2500000,
- .channels = ad5064_channels,
- .num_channels = 8,
- },
- [ID_AD5668_2] = {
- .shared_vref = true,
- .internal_vref = 5000000,
- .channels = ad5064_channels,
- .num_channels = 8,
- },
-};
-
-static inline unsigned int ad5064_num_vref(struct ad5064_state *st)
-{
- return st->chip_info->shared_vref ? 1 : st->chip_info->num_channels;
-}
-
-static const char * const ad5064_vref_names[] = {
- "vrefA",
- "vrefB",
- "vrefC",
- "vrefD",
-};
-
-static const char * const ad5064_vref_name(struct ad5064_state *st,
- unsigned int vref)
-{
- return st->chip_info->shared_vref ? "vref" : ad5064_vref_names[vref];
-}
-
-static int __devinit ad5064_probe(struct spi_device *spi)
-{
- enum ad5064_type type = spi_get_device_id(spi)->driver_data;
- struct iio_dev *indio_dev;
- struct ad5064_state *st;
- unsigned int i;
- int ret;
-
- indio_dev = iio_device_alloc(sizeof(*st));
- if (indio_dev == NULL)
- return -ENOMEM;
-
- st = iio_priv(indio_dev);
- spi_set_drvdata(spi, indio_dev);
-
- st->chip_info = &ad5064_chip_info_tbl[type];
- st->spi = spi;
-
- for (i = 0; i < ad5064_num_vref(st); ++i)
- st->vref_reg[i].supply = ad5064_vref_name(st, i);
-
- ret = regulator_bulk_get(&st->spi->dev, ad5064_num_vref(st),
- st->vref_reg);
- if (ret) {
- if (!st->chip_info->internal_vref)
- goto error_free;
- st->use_internal_vref = true;
- ret = ad5064_spi_write(st, AD5064_CMD_CONFIG, 0,
- AD5064_CONFIG_INT_VREF_ENABLE, 0);
- if (ret) {
- dev_err(&spi->dev, "Failed to enable internal vref: %d\n",
- ret);
- goto error_free;
- }
- } else {
- ret = regulator_bulk_enable(ad5064_num_vref(st), st->vref_reg);
- if (ret)
- goto error_free_reg;
- }
-
- for (i = 0; i < st->chip_info->num_channels; ++i) {
- st->pwr_down_mode[i] = AD5064_LDAC_PWRDN_1K;
- st->dac_cache[i] = 0x8000;
- }
-
- indio_dev->dev.parent = &spi->dev;
- indio_dev->name = spi_get_device_id(spi)->name;
- indio_dev->info = &ad5064_info;
- indio_dev->modes = INDIO_DIRECT_MODE;
- indio_dev->channels = st->chip_info->channels;
- indio_dev->num_channels = st->chip_info->num_channels;
-
- ret = iio_device_register(indio_dev);
- if (ret)
- goto error_disable_reg;
-
- return 0;
-
-error_disable_reg:
- if (!st->use_internal_vref)
- regulator_bulk_disable(ad5064_num_vref(st), st->vref_reg);
-error_free_reg:
- if (!st->use_internal_vref)
- regulator_bulk_free(ad5064_num_vref(st), st->vref_reg);
-error_free:
- iio_device_free(indio_dev);
-
- return ret;
-}
-
-
-static int __devexit ad5064_remove(struct spi_device *spi)
-{
- struct iio_dev *indio_dev = spi_get_drvdata(spi);
- struct ad5064_state *st = iio_priv(indio_dev);
-
- iio_device_unregister(indio_dev);
-
- if (!st->use_internal_vref) {
- regulator_bulk_disable(ad5064_num_vref(st), st->vref_reg);
- regulator_bulk_free(ad5064_num_vref(st), st->vref_reg);
- }
-
- iio_device_free(indio_dev);
-
- return 0;
-}
-
-static const struct spi_device_id ad5064_id[] = {
- {"ad5024", ID_AD5024},
- {"ad5025", ID_AD5025},
- {"ad5044", ID_AD5044},
- {"ad5045", ID_AD5045},
- {"ad5064", ID_AD5064},
- {"ad5064-1", ID_AD5064_1},
- {"ad5065", ID_AD5065},
- {"ad5628-1", ID_AD5628_1},
- {"ad5628-2", ID_AD5628_2},
- {"ad5648-1", ID_AD5648_1},
- {"ad5648-2", ID_AD5648_2},
- {"ad5666-1", ID_AD5666_1},
- {"ad5666-2", ID_AD5666_2},
- {"ad5668-1", ID_AD5668_1},
- {"ad5668-2", ID_AD5668_2},
- {"ad5668-3", ID_AD5668_2}, /* similar enough to ad5668-2 */
- {}
-};
-MODULE_DEVICE_TABLE(spi, ad5064_id);
-
-static struct spi_driver ad5064_driver = {
- .driver = {
- .name = "ad5064",
- .owner = THIS_MODULE,
- },
- .probe = ad5064_probe,
- .remove = __devexit_p(ad5064_remove),
- .id_table = ad5064_id,
-};
-module_spi_driver(ad5064_driver);
-
-MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
-MODULE_DESCRIPTION("Analog Devices AD5024/25/44/45/64/64-1/65, AD5628/48/66/68 DAC");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-/*
- * Analog devices AD5360, AD5361, AD5362, AD5363, AD5370, AD5371, AD5373
- * multi-channel Digital to Analog Converters driver
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#include <linux/device.h>
-#include <linux/err.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/regulator/consumer.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include "dac.h"
-
-#define AD5360_CMD(x) ((x) << 22)
-#define AD5360_ADDR(x) ((x) << 16)
-
-#define AD5360_READBACK_TYPE(x) ((x) << 13)
-#define AD5360_READBACK_ADDR(x) ((x) << 7)
-
-#define AD5360_CHAN_ADDR(chan) ((chan) + 0x8)
-
-#define AD5360_CMD_WRITE_DATA 0x3
-#define AD5360_CMD_WRITE_OFFSET 0x2
-#define AD5360_CMD_WRITE_GAIN 0x1
-#define AD5360_CMD_SPECIAL_FUNCTION 0x0
-
-/* Special function register addresses */
-#define AD5360_REG_SF_NOP 0x0
-#define AD5360_REG_SF_CTRL 0x1
-#define AD5360_REG_SF_OFS(x) (0x2 + (x))
-#define AD5360_REG_SF_READBACK 0x5
-
-#define AD5360_SF_CTRL_PWR_DOWN BIT(0)
-
-#define AD5360_READBACK_X1A 0x0
-#define AD5360_READBACK_X1B 0x1
-#define AD5360_READBACK_OFFSET 0x2
-#define AD5360_READBACK_GAIN 0x3
-#define AD5360_READBACK_SF 0x4
-
-
-/**
- * struct ad5360_chip_info - chip specific information
- * @channel_template: channel specification template
- * @num_channels: number of channels
- * @channels_per_group: number of channels per group
- * @num_vrefs: number of vref supplies for the chip
-*/
-
-struct ad5360_chip_info {
- struct iio_chan_spec channel_template;
- unsigned int num_channels;
- unsigned int channels_per_group;
- unsigned int num_vrefs;
-};
-
-/**
- * struct ad5360_state - driver instance specific data
- * @spi: spi_device
- * @chip_info: chip model specific constants, available modes etc
- * @vref_reg: vref supply regulators
- * @ctrl: control register cache
- * @data: spi transfer buffers
- */
-
-struct ad5360_state {
- struct spi_device *spi;
- const struct ad5360_chip_info *chip_info;
- struct regulator_bulk_data vref_reg[3];
- unsigned int ctrl;
-
- /*
- * DMA (thus cache coherency maintenance) requires the
- * transfer buffers to live in their own cache lines.
- */
- union {
- __be32 d32;
- u8 d8[4];
- } data[2] ____cacheline_aligned;
-};
-
-enum ad5360_type {
- ID_AD5360,
- ID_AD5361,
- ID_AD5362,
- ID_AD5363,
- ID_AD5370,
- ID_AD5371,
- ID_AD5372,
- ID_AD5373,
-};
-
-#define AD5360_CHANNEL(bits) { \
- .type = IIO_VOLTAGE, \
- .indexed = 1, \
- .output = 1, \
- .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
- IIO_CHAN_INFO_SCALE_SEPARATE_BIT | \
- IIO_CHAN_INFO_OFFSET_SEPARATE_BIT | \
- IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT | \
- IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, \
- .scan_type = IIO_ST('u', (bits), 16, 16 - (bits)) \
-}
-
-static const struct ad5360_chip_info ad5360_chip_info_tbl[] = {
- [ID_AD5360] = {
- .channel_template = AD5360_CHANNEL(16),
- .num_channels = 16,
- .channels_per_group = 8,
- .num_vrefs = 2,
- },
- [ID_AD5361] = {
- .channel_template = AD5360_CHANNEL(14),
- .num_channels = 16,
- .channels_per_group = 8,
- .num_vrefs = 2,
- },
- [ID_AD5362] = {
- .channel_template = AD5360_CHANNEL(16),
- .num_channels = 8,
- .channels_per_group = 4,
- .num_vrefs = 2,
- },
- [ID_AD5363] = {
- .channel_template = AD5360_CHANNEL(14),
- .num_channels = 8,
- .channels_per_group = 4,
- .num_vrefs = 2,
- },
- [ID_AD5370] = {
- .channel_template = AD5360_CHANNEL(16),
- .num_channels = 40,
- .channels_per_group = 8,
- .num_vrefs = 2,
- },
- [ID_AD5371] = {
- .channel_template = AD5360_CHANNEL(14),
- .num_channels = 40,
- .channels_per_group = 8,
- .num_vrefs = 3,
- },
- [ID_AD5372] = {
- .channel_template = AD5360_CHANNEL(16),
- .num_channels = 32,
- .channels_per_group = 8,
- .num_vrefs = 2,
- },
- [ID_AD5373] = {
- .channel_template = AD5360_CHANNEL(14),
- .num_channels = 32,
- .channels_per_group = 8,
- .num_vrefs = 2,
- },
-};
-
-static unsigned int ad5360_get_channel_vref_index(struct ad5360_state *st,
- unsigned int channel)
-{
- unsigned int i;
-
- /* The first groups have their own vref, while the remaining groups
- * share the last vref */
- i = channel / st->chip_info->channels_per_group;
- if (i >= st->chip_info->num_vrefs)
- i = st->chip_info->num_vrefs - 1;
-
- return i;
-}
-
-static int ad5360_get_channel_vref(struct ad5360_state *st,
- unsigned int channel)
-{
- unsigned int i = ad5360_get_channel_vref_index(st, channel);
-
- return regulator_get_voltage(st->vref_reg[i].consumer);
-}
-
-
-static int ad5360_write_unlocked(struct iio_dev *indio_dev,
- unsigned int cmd, unsigned int addr, unsigned int val,
- unsigned int shift)
-{
- struct ad5360_state *st = iio_priv(indio_dev);
-
- val <<= shift;
- val |= AD5360_CMD(cmd) | AD5360_ADDR(addr);
- st->data[0].d32 = cpu_to_be32(val);
-
- return spi_write(st->spi, &st->data[0].d8[1], 3);
-}
-
-static int ad5360_write(struct iio_dev *indio_dev, unsigned int cmd,
- unsigned int addr, unsigned int val, unsigned int shift)
-{
- int ret;
-
- mutex_lock(&indio_dev->mlock);
- ret = ad5360_write_unlocked(indio_dev, cmd, addr, val, shift);
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static int ad5360_read(struct iio_dev *indio_dev, unsigned int type,
- unsigned int addr)
-{
- struct ad5360_state *st = iio_priv(indio_dev);
- struct spi_message m;
- int ret;
- struct spi_transfer t[] = {
- {
- .tx_buf = &st->data[0].d8[1],
- .len = 3,
- .cs_change = 1,
- }, {
- .rx_buf = &st->data[1].d8[1],
- .len = 3,
- },
- };
-
- spi_message_init(&m);
- spi_message_add_tail(&t[0], &m);
- spi_message_add_tail(&t[1], &m);
-
- mutex_lock(&indio_dev->mlock);
-
- st->data[0].d32 = cpu_to_be32(AD5360_CMD(AD5360_CMD_SPECIAL_FUNCTION) |
- AD5360_ADDR(AD5360_REG_SF_READBACK) |
- AD5360_READBACK_TYPE(type) |
- AD5360_READBACK_ADDR(addr));
-
- ret = spi_sync(st->spi, &m);
- if (ret >= 0)
- ret = be32_to_cpu(st->data[1].d32) & 0xffff;
-
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static ssize_t ad5360_read_dac_powerdown(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5360_state *st = iio_priv(indio_dev);
-
- return sprintf(buf, "%d\n", (bool)(st->ctrl & AD5360_SF_CTRL_PWR_DOWN));
-}
-
-static int ad5360_update_ctrl(struct iio_dev *indio_dev, unsigned int set,
- unsigned int clr)
-{
- struct ad5360_state *st = iio_priv(indio_dev);
- unsigned int ret;
-
- mutex_lock(&indio_dev->mlock);
-
- st->ctrl |= set;
- st->ctrl &= ~clr;
-
- ret = ad5360_write_unlocked(indio_dev, AD5360_CMD_SPECIAL_FUNCTION,
- AD5360_REG_SF_CTRL, st->ctrl, 0);
-
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static ssize_t ad5360_write_dac_powerdown(struct device *dev,
- struct device_attribute *attr, const char *buf, size_t len)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- bool pwr_down;
- int ret;
-
- ret = strtobool(buf, &pwr_down);
- if (ret)
- return ret;
-
- if (pwr_down)
- ret = ad5360_update_ctrl(indio_dev, AD5360_SF_CTRL_PWR_DOWN, 0);
- else
- ret = ad5360_update_ctrl(indio_dev, 0, AD5360_SF_CTRL_PWR_DOWN);
-
- return ret ? ret : len;
-}
-
-static IIO_DEVICE_ATTR(out_voltage_powerdown,
- S_IRUGO | S_IWUSR,
- ad5360_read_dac_powerdown,
- ad5360_write_dac_powerdown, 0);
-
-static struct attribute *ad5360_attributes[] = {
- &iio_dev_attr_out_voltage_powerdown.dev_attr.attr,
- NULL,
-};
-
-static const struct attribute_group ad5360_attribute_group = {
- .attrs = ad5360_attributes,
-};
-
-static int ad5360_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int val,
- int val2,
- long mask)
-{
- struct ad5360_state *st = iio_priv(indio_dev);
- int max_val = (1 << chan->scan_type.realbits);
- unsigned int ofs_index;
-
- switch (mask) {
- case IIO_CHAN_INFO_RAW:
- if (val >= max_val || val < 0)
- return -EINVAL;
-
- return ad5360_write(indio_dev, AD5360_CMD_WRITE_DATA,
- chan->address, val, chan->scan_type.shift);
-
- case IIO_CHAN_INFO_CALIBBIAS:
- if (val >= max_val || val < 0)
- return -EINVAL;
-
- return ad5360_write(indio_dev, AD5360_CMD_WRITE_OFFSET,
- chan->address, val, chan->scan_type.shift);
-
- case IIO_CHAN_INFO_CALIBSCALE:
- if (val >= max_val || val < 0)
- return -EINVAL;
-
- return ad5360_write(indio_dev, AD5360_CMD_WRITE_GAIN,
- chan->address, val, chan->scan_type.shift);
-
- case IIO_CHAN_INFO_OFFSET:
- if (val <= -max_val || val > 0)
- return -EINVAL;
-
- val = -val;
-
- /* offset is supposed to have the same scale as raw, but it
- * is always 14bits wide, so on a chip where the raw value has
- * more bits, we need to shift offset. */
- val >>= (chan->scan_type.realbits - 14);
-
- /* There is one DAC offset register per vref. Changing one
- * channels offset will also change the offset for all other
- * channels which share the same vref supply. */
- ofs_index = ad5360_get_channel_vref_index(st, chan->channel);
- return ad5360_write(indio_dev, AD5360_CMD_SPECIAL_FUNCTION,
- AD5360_REG_SF_OFS(ofs_index), val, 0);
- default:
- break;
- }
-
- return -EINVAL;
-}
-
-static int ad5360_read_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int *val,
- int *val2,
- long m)
-{
- struct ad5360_state *st = iio_priv(indio_dev);
- unsigned int ofs_index;
- int scale_uv;
- int ret;
-
- switch (m) {
- case IIO_CHAN_INFO_RAW:
- ret = ad5360_read(indio_dev, AD5360_READBACK_X1A,
- chan->address);
- if (ret < 0)
- return ret;
- *val = ret >> chan->scan_type.shift;
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_SCALE:
- /* vout = 4 * vref * dac_code */
- scale_uv = ad5360_get_channel_vref(st, chan->channel) * 4 * 100;
- if (scale_uv < 0)
- return scale_uv;
-
- scale_uv >>= (chan->scan_type.realbits);
- *val = scale_uv / 100000;
- *val2 = (scale_uv % 100000) * 10;
- return IIO_VAL_INT_PLUS_MICRO;
- case IIO_CHAN_INFO_CALIBBIAS:
- ret = ad5360_read(indio_dev, AD5360_READBACK_OFFSET,
- chan->address);
- if (ret < 0)
- return ret;
- *val = ret;
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_CALIBSCALE:
- ret = ad5360_read(indio_dev, AD5360_READBACK_GAIN,
- chan->address);
- if (ret < 0)
- return ret;
- *val = ret;
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_OFFSET:
- ofs_index = ad5360_get_channel_vref_index(st, chan->channel);
- ret = ad5360_read(indio_dev, AD5360_READBACK_SF,
- AD5360_REG_SF_OFS(ofs_index));
- if (ret < 0)
- return ret;
-
- ret <<= (chan->scan_type.realbits - 14);
- *val = -ret;
- return IIO_VAL_INT;
- }
-
- return -EINVAL;
-}
-
-static const struct iio_info ad5360_info = {
- .read_raw = ad5360_read_raw,
- .write_raw = ad5360_write_raw,
- .attrs = &ad5360_attribute_group,
- .driver_module = THIS_MODULE,
-};
-
-static const char * const ad5360_vref_name[] = {
- "vref0", "vref1", "vref2"
-};
-
-static int __devinit ad5360_alloc_channels(struct iio_dev *indio_dev)
-{
- struct ad5360_state *st = iio_priv(indio_dev);
- struct iio_chan_spec *channels;
- unsigned int i;
-
- channels = kcalloc(st->chip_info->num_channels,
- sizeof(struct iio_chan_spec), GFP_KERNEL);
-
- if (!channels)
- return -ENOMEM;
-
- for (i = 0; i < st->chip_info->num_channels; ++i) {
- channels[i] = st->chip_info->channel_template;
- channels[i].channel = i;
- channels[i].address = AD5360_CHAN_ADDR(i);
- }
-
- indio_dev->channels = channels;
-
- return 0;
-}
-
-static int __devinit ad5360_probe(struct spi_device *spi)
-{
- enum ad5360_type type = spi_get_device_id(spi)->driver_data;
- struct iio_dev *indio_dev;
- struct ad5360_state *st;
- unsigned int i;
- int ret;
-
- indio_dev = iio_device_alloc(sizeof(*st));
- if (indio_dev == NULL) {
- dev_err(&spi->dev, "Failed to allocate iio device\n");
- return -ENOMEM;
- }
-
- st = iio_priv(indio_dev);
- spi_set_drvdata(spi, indio_dev);
-
- st->chip_info = &ad5360_chip_info_tbl[type];
- st->spi = spi;
-
- indio_dev->dev.parent = &spi->dev;
- indio_dev->name = spi_get_device_id(spi)->name;
- indio_dev->info = &ad5360_info;
- indio_dev->modes = INDIO_DIRECT_MODE;
- indio_dev->num_channels = st->chip_info->num_channels;
-
- ret = ad5360_alloc_channels(indio_dev);
- if (ret) {
- dev_err(&spi->dev, "Failed to allocate channel spec: %d\n", ret);
- goto error_free;
- }
-
- for (i = 0; i < st->chip_info->num_vrefs; ++i)
- st->vref_reg[i].supply = ad5360_vref_name[i];
-
- ret = regulator_bulk_get(&st->spi->dev, st->chip_info->num_vrefs,
- st->vref_reg);
- if (ret) {
- dev_err(&spi->dev, "Failed to request vref regulators: %d\n", ret);
- goto error_free_channels;
- }
-
- ret = regulator_bulk_enable(st->chip_info->num_vrefs, st->vref_reg);
- if (ret) {
- dev_err(&spi->dev, "Failed to enable vref regulators: %d\n", ret);
- goto error_free_reg;
- }
-
- ret = iio_device_register(indio_dev);
- if (ret) {
- dev_err(&spi->dev, "Failed to register iio device: %d\n", ret);
- goto error_disable_reg;
- }
-
- return 0;
-
-error_disable_reg:
- regulator_bulk_disable(st->chip_info->num_vrefs, st->vref_reg);
-error_free_reg:
- regulator_bulk_free(st->chip_info->num_vrefs, st->vref_reg);
-error_free_channels:
- kfree(indio_dev->channels);
-error_free:
- iio_device_free(indio_dev);
-
- return ret;
-}
-
-static int __devexit ad5360_remove(struct spi_device *spi)
-{
- struct iio_dev *indio_dev = spi_get_drvdata(spi);
- struct ad5360_state *st = iio_priv(indio_dev);
-
- iio_device_unregister(indio_dev);
-
- kfree(indio_dev->channels);
-
- regulator_bulk_disable(st->chip_info->num_vrefs, st->vref_reg);
- regulator_bulk_free(st->chip_info->num_vrefs, st->vref_reg);
-
- iio_device_free(indio_dev);
-
- return 0;
-}
-
-static const struct spi_device_id ad5360_ids[] = {
- { "ad5360", ID_AD5360 },
- { "ad5361", ID_AD5361 },
- { "ad5362", ID_AD5362 },
- { "ad5363", ID_AD5363 },
- { "ad5370", ID_AD5370 },
- { "ad5371", ID_AD5371 },
- { "ad5372", ID_AD5372 },
- { "ad5373", ID_AD5373 },
- {}
-};
-MODULE_DEVICE_TABLE(spi, ad5360_ids);
-
-static struct spi_driver ad5360_driver = {
- .driver = {
- .name = "ad5360",
- .owner = THIS_MODULE,
- },
- .probe = ad5360_probe,
- .remove = __devexit_p(ad5360_remove),
- .id_table = ad5360_ids,
-};
-module_spi_driver(ad5360_driver);
-
-MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
-MODULE_DESCRIPTION("Analog Devices AD5360/61/62/63/70/71/72/73 DAC");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-/*
- * Analog devices AD5380, AD5381, AD5382, AD5383, AD5390, AD5391, AD5392
- * multi-channel Digital to Analog Converters driver
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#include <linux/device.h>
-#include <linux/err.h>
-#include <linux/i2c.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/regmap.h>
-#include <linux/regulator/consumer.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include "dac.h"
-
-
-#define AD5380_REG_DATA(x) (((x) << 2) | 3)
-#define AD5380_REG_OFFSET(x) (((x) << 2) | 2)
-#define AD5380_REG_GAIN(x) (((x) << 2) | 1)
-#define AD5380_REG_SF_PWR_DOWN (8 << 2)
-#define AD5380_REG_SF_PWR_UP (9 << 2)
-#define AD5380_REG_SF_CTRL (12 << 2)
-
-#define AD5380_CTRL_PWR_DOWN_MODE_OFFSET 13
-#define AD5380_CTRL_INT_VREF_2V5 BIT(12)
-#define AD5380_CTRL_INT_VREF_EN BIT(10)
-
-/**
- * struct ad5380_chip_info - chip specific information
- * @channel_template: channel specification template
- * @num_channels: number of channels
- * @int_vref: internal vref in uV
-*/
-
-struct ad5380_chip_info {
- struct iio_chan_spec channel_template;
- unsigned int num_channels;
- unsigned int int_vref;
-};
-
-/**
- * struct ad5380_state - driver instance specific data
- * @regmap: regmap instance used by the device
- * @chip_info: chip model specific constants, available modes etc
- * @vref_reg: vref supply regulator
- * @vref: actual reference voltage used in uA
- * @pwr_down: whether the chip is currently in power down mode
- */
-
-struct ad5380_state {
- struct regmap *regmap;
- const struct ad5380_chip_info *chip_info;
- struct regulator *vref_reg;
- int vref;
- bool pwr_down;
-};
-
-enum ad5380_type {
- ID_AD5380_3,
- ID_AD5380_5,
- ID_AD5381_3,
- ID_AD5381_5,
- ID_AD5382_3,
- ID_AD5382_5,
- ID_AD5383_3,
- ID_AD5383_5,
- ID_AD5390_3,
- ID_AD5390_5,
- ID_AD5391_3,
- ID_AD5391_5,
- ID_AD5392_3,
- ID_AD5392_5,
-};
-
-#define AD5380_CHANNEL(_bits) { \
- .type = IIO_VOLTAGE, \
- .indexed = 1, \
- .output = 1, \
- .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
- IIO_CHAN_INFO_SCALE_SHARED_BIT | \
- IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT | \
- IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, \
- .scan_type = IIO_ST('u', (_bits), 16, 14 - (_bits)) \
-}
-
-static const struct ad5380_chip_info ad5380_chip_info_tbl[] = {
- [ID_AD5380_3] = {
- .channel_template = AD5380_CHANNEL(14),
- .num_channels = 40,
- .int_vref = 1250000,
- },
- [ID_AD5380_5] = {
- .channel_template = AD5380_CHANNEL(14),
- .num_channels = 40,
- .int_vref = 2500000,
- },
- [ID_AD5381_3] = {
- .channel_template = AD5380_CHANNEL(12),
- .num_channels = 16,
- .int_vref = 1250000,
- },
- [ID_AD5381_5] = {
- .channel_template = AD5380_CHANNEL(12),
- .num_channels = 16,
- .int_vref = 2500000,
- },
- [ID_AD5382_3] = {
- .channel_template = AD5380_CHANNEL(14),
- .num_channels = 32,
- .int_vref = 1250000,
- },
- [ID_AD5382_5] = {
- .channel_template = AD5380_CHANNEL(14),
- .num_channels = 32,
- .int_vref = 2500000,
- },
- [ID_AD5383_3] = {
- .channel_template = AD5380_CHANNEL(12),
- .num_channels = 32,
- .int_vref = 1250000,
- },
- [ID_AD5383_5] = {
- .channel_template = AD5380_CHANNEL(12),
- .num_channels = 32,
- .int_vref = 2500000,
- },
- [ID_AD5390_3] = {
- .channel_template = AD5380_CHANNEL(14),
- .num_channels = 16,
- .int_vref = 1250000,
- },
- [ID_AD5390_5] = {
- .channel_template = AD5380_CHANNEL(14),
- .num_channels = 16,
- .int_vref = 2500000,
- },
- [ID_AD5391_3] = {
- .channel_template = AD5380_CHANNEL(12),
- .num_channels = 16,
- .int_vref = 1250000,
- },
- [ID_AD5391_5] = {
- .channel_template = AD5380_CHANNEL(12),
- .num_channels = 16,
- .int_vref = 2500000,
- },
- [ID_AD5392_3] = {
- .channel_template = AD5380_CHANNEL(14),
- .num_channels = 8,
- .int_vref = 1250000,
- },
- [ID_AD5392_5] = {
- .channel_template = AD5380_CHANNEL(14),
- .num_channels = 8,
- .int_vref = 2500000,
- },
-};
-
-static ssize_t ad5380_read_dac_powerdown(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5380_state *st = iio_priv(indio_dev);
-
- return sprintf(buf, "%d\n", st->pwr_down);
-}
-
-static ssize_t ad5380_write_dac_powerdown(struct device *dev,
- struct device_attribute *attr, const char *buf, size_t len)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5380_state *st = iio_priv(indio_dev);
- bool pwr_down;
- int ret;
-
- ret = strtobool(buf, &pwr_down);
- if (ret)
- return ret;
-
- mutex_lock(&indio_dev->mlock);
-
- if (pwr_down)
- ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_DOWN, 0);
- else
- ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_UP, 0);
-
- st->pwr_down = pwr_down;
-
- mutex_unlock(&indio_dev->mlock);
-
- return ret ? ret : len;
-}
-
-static IIO_DEVICE_ATTR(out_voltage_powerdown,
- S_IRUGO | S_IWUSR,
- ad5380_read_dac_powerdown,
- ad5380_write_dac_powerdown, 0);
-
-static const char ad5380_powerdown_modes[][15] = {
- [0] = "100kohm_to_gnd",
- [1] = "three_state",
-};
-
-static ssize_t ad5380_read_powerdown_mode(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5380_state *st = iio_priv(indio_dev);
- unsigned int mode;
- int ret;
-
- ret = regmap_read(st->regmap, AD5380_REG_SF_CTRL, &mode);
- if (ret)
- return ret;
-
- mode = (mode >> AD5380_CTRL_PWR_DOWN_MODE_OFFSET) & 1;
-
- return sprintf(buf, "%s\n", ad5380_powerdown_modes[mode]);
-}
-
-static ssize_t ad5380_write_powerdown_mode(struct device *dev,
- struct device_attribute *attr, const char *buf, size_t len)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5380_state *st = iio_priv(indio_dev);
- unsigned int i;
- int ret;
-
- for (i = 0; i < ARRAY_SIZE(ad5380_powerdown_modes); ++i) {
- if (sysfs_streq(buf, ad5380_powerdown_modes[i]))
- break;
- }
-
- if (i == ARRAY_SIZE(ad5380_powerdown_modes))
- return -EINVAL;
-
- ret = regmap_update_bits(st->regmap, AD5380_REG_SF_CTRL,
- 1 << AD5380_CTRL_PWR_DOWN_MODE_OFFSET,
- i << AD5380_CTRL_PWR_DOWN_MODE_OFFSET);
-
- return ret ? ret : len;
-}
-
-static IIO_DEVICE_ATTR(out_voltage_powerdown_mode,
- S_IRUGO | S_IWUSR,
- ad5380_read_powerdown_mode,
- ad5380_write_powerdown_mode, 0);
-
-static IIO_CONST_ATTR(out_voltage_powerdown_mode_available,
- "100kohm_to_gnd three_state");
-
-static struct attribute *ad5380_attributes[] = {
- &iio_dev_attr_out_voltage_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage_powerdown_mode.dev_attr.attr,
- &iio_const_attr_out_voltage_powerdown_mode_available.dev_attr.attr,
- NULL,
-};
-
-static const struct attribute_group ad5380_attribute_group = {
- .attrs = ad5380_attributes,
-};
-
-static unsigned int ad5380_info_to_reg(struct iio_chan_spec const *chan,
- long info)
-{
- switch (info) {
- case 0:
- return AD5380_REG_DATA(chan->address);
- case IIO_CHAN_INFO_CALIBBIAS:
- return AD5380_REG_OFFSET(chan->address);
- case IIO_CHAN_INFO_CALIBSCALE:
- return AD5380_REG_GAIN(chan->address);
- default:
- break;
- }
-
- return 0;
-}
-
-static int ad5380_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan, int val, int val2, long info)
-{
- const unsigned int max_val = (1 << chan->scan_type.realbits);
- struct ad5380_state *st = iio_priv(indio_dev);
-
- switch (info) {
- case IIO_CHAN_INFO_RAW:
- case IIO_CHAN_INFO_CALIBSCALE:
- if (val >= max_val || val < 0)
- return -EINVAL;
-
- return regmap_write(st->regmap,
- ad5380_info_to_reg(chan, info),
- val << chan->scan_type.shift);
- case IIO_CHAN_INFO_CALIBBIAS:
- val += (1 << chan->scan_type.realbits) / 2;
- if (val >= max_val || val < 0)
- return -EINVAL;
-
- return regmap_write(st->regmap,
- AD5380_REG_OFFSET(chan->address),
- val << chan->scan_type.shift);
- default:
- break;
- }
- return -EINVAL;
-}
-
-static int ad5380_read_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan, int *val, int *val2, long info)
-{
- struct ad5380_state *st = iio_priv(indio_dev);
- unsigned long scale_uv;
- int ret;
-
- switch (info) {
- case IIO_CHAN_INFO_RAW:
- case IIO_CHAN_INFO_CALIBSCALE:
- ret = regmap_read(st->regmap, ad5380_info_to_reg(chan, info),
- val);
- if (ret)
- return ret;
- *val >>= chan->scan_type.shift;
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_CALIBBIAS:
- ret = regmap_read(st->regmap, AD5380_REG_OFFSET(chan->address),
- val);
- if (ret)
- return ret;
- *val >>= chan->scan_type.shift;
- val -= (1 << chan->scan_type.realbits) / 2;
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_SCALE:
- scale_uv = ((2 * st->vref) >> chan->scan_type.realbits) * 100;
- *val = scale_uv / 100000;
- *val2 = (scale_uv % 100000) * 10;
- return IIO_VAL_INT_PLUS_MICRO;
- default:
- break;
- }
-
- return -EINVAL;
-}
-
-static const struct iio_info ad5380_info = {
- .read_raw = ad5380_read_raw,
- .write_raw = ad5380_write_raw,
- .attrs = &ad5380_attribute_group,
- .driver_module = THIS_MODULE,
-};
-
-static int __devinit ad5380_alloc_channels(struct iio_dev *indio_dev)
-{
- struct ad5380_state *st = iio_priv(indio_dev);
- struct iio_chan_spec *channels;
- unsigned int i;
-
- channels = kcalloc(st->chip_info->num_channels,
- sizeof(struct iio_chan_spec), GFP_KERNEL);
-
- if (!channels)
- return -ENOMEM;
-
- for (i = 0; i < st->chip_info->num_channels; ++i) {
- channels[i] = st->chip_info->channel_template;
- channels[i].channel = i;
- channels[i].address = i;
- }
-
- indio_dev->channels = channels;
-
- return 0;
-}
-
-static int __devinit ad5380_probe(struct device *dev, struct regmap *regmap,
- enum ad5380_type type, const char *name)
-{
- struct iio_dev *indio_dev;
- struct ad5380_state *st;
- unsigned int ctrl = 0;
- int ret;
-
- indio_dev = iio_device_alloc(sizeof(*st));
- if (indio_dev == NULL) {
- dev_err(dev, "Failed to allocate iio device\n");
- ret = -ENOMEM;
- goto error_regmap_exit;
- }
-
- st = iio_priv(indio_dev);
- dev_set_drvdata(dev, indio_dev);
-
- st->chip_info = &ad5380_chip_info_tbl[type];
- st->regmap = regmap;
-
- indio_dev->dev.parent = dev;
- indio_dev->name = name;
- indio_dev->info = &ad5380_info;
- indio_dev->modes = INDIO_DIRECT_MODE;
- indio_dev->num_channels = st->chip_info->num_channels;
-
- ret = ad5380_alloc_channels(indio_dev);
- if (ret) {
- dev_err(dev, "Failed to allocate channel spec: %d\n", ret);
- goto error_free;
- }
-
- if (st->chip_info->int_vref == 2500000)
- ctrl |= AD5380_CTRL_INT_VREF_2V5;
-
- st->vref_reg = regulator_get(dev, "vref");
- if (!IS_ERR(st->vref_reg)) {
- ret = regulator_enable(st->vref_reg);
- if (ret) {
- dev_err(dev, "Failed to enable vref regulators: %d\n",
- ret);
- goto error_free_reg;
- }
-
- st->vref = regulator_get_voltage(st->vref_reg);
- } else {
- st->vref = st->chip_info->int_vref;
- ctrl |= AD5380_CTRL_INT_VREF_EN;
- }
-
- ret = regmap_write(st->regmap, AD5380_REG_SF_CTRL, ctrl);
- if (ret) {
- dev_err(dev, "Failed to write to device: %d\n", ret);
- goto error_disable_reg;
- }
-
- ret = iio_device_register(indio_dev);
- if (ret) {
- dev_err(dev, "Failed to register iio device: %d\n", ret);
- goto error_disable_reg;
- }
-
- return 0;
-
-error_disable_reg:
- if (!IS_ERR(st->vref_reg))
- regulator_disable(st->vref_reg);
-error_free_reg:
- if (!IS_ERR(st->vref_reg))
- regulator_put(st->vref_reg);
-
- kfree(indio_dev->channels);
-error_free:
- iio_device_free(indio_dev);
-error_regmap_exit:
- regmap_exit(regmap);
-
- return ret;
-}
-
-static int __devexit ad5380_remove(struct device *dev)
-{
- struct iio_dev *indio_dev = dev_get_drvdata(dev);
- struct ad5380_state *st = iio_priv(indio_dev);
-
- iio_device_unregister(indio_dev);
-
- kfree(indio_dev->channels);
-
- if (!IS_ERR(st->vref_reg)) {
- regulator_disable(st->vref_reg);
- regulator_put(st->vref_reg);
- }
-
- regmap_exit(st->regmap);
- iio_device_free(indio_dev);
-
- return 0;
-}
-
-static bool ad5380_reg_false(struct device *dev, unsigned int reg)
-{
- return false;
-}
-
-static const struct regmap_config ad5380_regmap_config = {
- .reg_bits = 10,
- .val_bits = 14,
-
- .max_register = AD5380_REG_DATA(40),
- .cache_type = REGCACHE_RBTREE,
-
- .volatile_reg = ad5380_reg_false,
- .readable_reg = ad5380_reg_false,
-};
-
-#if IS_ENABLED(CONFIG_SPI_MASTER)
-
-static int __devinit ad5380_spi_probe(struct spi_device *spi)
-{
- const struct spi_device_id *id = spi_get_device_id(spi);
- struct regmap *regmap;
-
- regmap = regmap_init_spi(spi, &ad5380_regmap_config);
-
- if (IS_ERR(regmap))
- return PTR_ERR(regmap);
-
- return ad5380_probe(&spi->dev, regmap, id->driver_data, id->name);
-}
-
-static int __devexit ad5380_spi_remove(struct spi_device *spi)
-{
- return ad5380_remove(&spi->dev);
-}
-
-static const struct spi_device_id ad5380_spi_ids[] = {
- { "ad5380-3", ID_AD5380_3 },
- { "ad5380-5", ID_AD5380_5 },
- { "ad5381-3", ID_AD5381_3 },
- { "ad5381-5", ID_AD5381_5 },
- { "ad5382-3", ID_AD5382_3 },
- { "ad5382-5", ID_AD5382_5 },
- { "ad5383-3", ID_AD5383_3 },
- { "ad5383-5", ID_AD5383_5 },
- { "ad5384-3", ID_AD5380_3 },
- { "ad5384-5", ID_AD5380_5 },
- { "ad5390-3", ID_AD5390_3 },
- { "ad5390-5", ID_AD5390_5 },
- { "ad5391-3", ID_AD5391_3 },
- { "ad5391-5", ID_AD5391_5 },
- { "ad5392-3", ID_AD5392_3 },
- { "ad5392-5", ID_AD5392_5 },
- { }
-};
-MODULE_DEVICE_TABLE(spi, ad5380_spi_ids);
-
-static struct spi_driver ad5380_spi_driver = {
- .driver = {
- .name = "ad5380",
- .owner = THIS_MODULE,
- },
- .probe = ad5380_spi_probe,
- .remove = __devexit_p(ad5380_spi_remove),
- .id_table = ad5380_spi_ids,
-};
-
-static inline int ad5380_spi_register_driver(void)
-{
- return spi_register_driver(&ad5380_spi_driver);
-}
-
-static inline void ad5380_spi_unregister_driver(void)
-{
- spi_unregister_driver(&ad5380_spi_driver);
-}
-
-#else
-
-static inline int ad5380_spi_register_driver(void)
-{
- return 0;
-}
-
-static inline void ad5380_spi_unregister_driver(void)
-{
-}
-
-#endif
-
-#if IS_ENABLED(CONFIG_I2C)
-
-static int __devinit ad5380_i2c_probe(struct i2c_client *i2c,
- const struct i2c_device_id *id)
-{
- struct regmap *regmap;
-
- regmap = regmap_init_i2c(i2c, &ad5380_regmap_config);
-
- if (IS_ERR(regmap))
- return PTR_ERR(regmap);
-
- return ad5380_probe(&i2c->dev, regmap, id->driver_data, id->name);
-}
-
-static int __devexit ad5380_i2c_remove(struct i2c_client *i2c)
-{
- return ad5380_remove(&i2c->dev);
-}
-
-static const struct i2c_device_id ad5380_i2c_ids[] = {
- { "ad5380-3", ID_AD5380_3 },
- { "ad5380-5", ID_AD5380_5 },
- { "ad5381-3", ID_AD5381_3 },
- { "ad5381-5", ID_AD5381_5 },
- { "ad5382-3", ID_AD5382_3 },
- { "ad5382-5", ID_AD5382_5 },
- { "ad5383-3", ID_AD5383_3 },
- { "ad5383-5", ID_AD5383_5 },
- { "ad5384-3", ID_AD5380_3 },
- { "ad5384-5", ID_AD5380_5 },
- { "ad5390-3", ID_AD5390_3 },
- { "ad5390-5", ID_AD5390_5 },
- { "ad5391-3", ID_AD5391_3 },
- { "ad5391-5", ID_AD5391_5 },
- { "ad5392-3", ID_AD5392_3 },
- { "ad5392-5", ID_AD5392_5 },
- { }
-};
-MODULE_DEVICE_TABLE(i2c, ad5380_i2c_ids);
-
-static struct i2c_driver ad5380_i2c_driver = {
- .driver = {
- .name = "ad5380",
- .owner = THIS_MODULE,
- },
- .probe = ad5380_i2c_probe,
- .remove = __devexit_p(ad5380_i2c_remove),
- .id_table = ad5380_i2c_ids,
-};
-
-static inline int ad5380_i2c_register_driver(void)
-{
- return i2c_add_driver(&ad5380_i2c_driver);
-}
-
-static inline void ad5380_i2c_unregister_driver(void)
-{
- i2c_del_driver(&ad5380_i2c_driver);
-}
-
-#else
-
-static inline int ad5380_i2c_register_driver(void)
-{
- return 0;
-}
-
-static inline void ad5380_i2c_unregister_driver(void)
-{
-}
-
-#endif
-
-static int __init ad5380_spi_init(void)
-{
- int ret;
-
- ret = ad5380_spi_register_driver();
- if (ret)
- return ret;
-
- ret = ad5380_i2c_register_driver();
- if (ret) {
- ad5380_spi_unregister_driver();
- return ret;
- }
-
- return 0;
-}
-module_init(ad5380_spi_init);
-
-static void __exit ad5380_spi_exit(void)
-{
- ad5380_i2c_unregister_driver();
- ad5380_spi_unregister_driver();
-
-}
-module_exit(ad5380_spi_exit);
-
-MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
-MODULE_DESCRIPTION("Analog Devices AD5380/81/82/83/84/90/91/92 DAC");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-/*
- * AD5421 Digital to analog converters driver
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#include <linux/device.h>
-#include <linux/delay.h>
-#include <linux/err.h>
-#include <linux/module.h>
-#include <linux/interrupt.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include <linux/iio/events.h>
-#include "dac.h"
-#include "ad5421.h"
-
-
-#define AD5421_REG_DAC_DATA 0x1
-#define AD5421_REG_CTRL 0x2
-#define AD5421_REG_OFFSET 0x3
-#define AD5421_REG_GAIN 0x4
-/* load dac and fault shared the same register number. Writing to it will cause
- * a dac load command, reading from it will return the fault status register */
-#define AD5421_REG_LOAD_DAC 0x5
-#define AD5421_REG_FAULT 0x5
-#define AD5421_REG_FORCE_ALARM_CURRENT 0x6
-#define AD5421_REG_RESET 0x7
-#define AD5421_REG_START_CONVERSION 0x8
-#define AD5421_REG_NOOP 0x9
-
-#define AD5421_CTRL_WATCHDOG_DISABLE BIT(12)
-#define AD5421_CTRL_AUTO_FAULT_READBACK BIT(11)
-#define AD5421_CTRL_MIN_CURRENT BIT(9)
-#define AD5421_CTRL_ADC_SOURCE_TEMP BIT(8)
-#define AD5421_CTRL_ADC_ENABLE BIT(7)
-#define AD5421_CTRL_PWR_DOWN_INT_VREF BIT(6)
-
-#define AD5421_FAULT_SPI BIT(15)
-#define AD5421_FAULT_PEC BIT(14)
-#define AD5421_FAULT_OVER_CURRENT BIT(13)
-#define AD5421_FAULT_UNDER_CURRENT BIT(12)
-#define AD5421_FAULT_TEMP_OVER_140 BIT(11)
-#define AD5421_FAULT_TEMP_OVER_100 BIT(10)
-#define AD5421_FAULT_UNDER_VOLTAGE_6V BIT(9)
-#define AD5421_FAULT_UNDER_VOLTAGE_12V BIT(8)
-
-/* These bits will cause the fault pin to go high */
-#define AD5421_FAULT_TRIGGER_IRQ \
- (AD5421_FAULT_SPI | AD5421_FAULT_PEC | AD5421_FAULT_OVER_CURRENT | \
- AD5421_FAULT_UNDER_CURRENT | AD5421_FAULT_TEMP_OVER_140)
-
-/**
- * struct ad5421_state - driver instance specific data
- * @spi: spi_device
- * @ctrl: control register cache
- * @current_range: current range which the device is configured for
- * @data: spi transfer buffers
- * @fault_mask: software masking of events
- */
-struct ad5421_state {
- struct spi_device *spi;
- unsigned int ctrl;
- enum ad5421_current_range current_range;
- unsigned int fault_mask;
-
- /*
- * DMA (thus cache coherency maintenance) requires the
- * transfer buffers to live in their own cache lines.
- */
- union {
- u32 d32;
- u8 d8[4];
- } data[2] ____cacheline_aligned;
-};
-
-static const struct iio_chan_spec ad5421_channels[] = {
- {
- .type = IIO_CURRENT,
- .indexed = 1,
- .output = 1,
- .channel = 0,
- .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
- IIO_CHAN_INFO_SCALE_SHARED_BIT |
- IIO_CHAN_INFO_OFFSET_SHARED_BIT |
- IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT |
- IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT,
- .scan_type = IIO_ST('u', 16, 16, 0),
- .event_mask = IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) |
- IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING),
- },
- {
- .type = IIO_TEMP,
- .channel = -1,
- .event_mask = IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
- },
-};
-
-static int ad5421_write_unlocked(struct iio_dev *indio_dev,
- unsigned int reg, unsigned int val)
-{
- struct ad5421_state *st = iio_priv(indio_dev);
-
- st->data[0].d32 = cpu_to_be32((reg << 16) | val);
-
- return spi_write(st->spi, &st->data[0].d8[1], 3);
-}
-
-static int ad5421_write(struct iio_dev *indio_dev, unsigned int reg,
- unsigned int val)
-{
- int ret;
-
- mutex_lock(&indio_dev->mlock);
- ret = ad5421_write_unlocked(indio_dev, reg, val);
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static int ad5421_read(struct iio_dev *indio_dev, unsigned int reg)
-{
- struct ad5421_state *st = iio_priv(indio_dev);
- struct spi_message m;
- int ret;
- struct spi_transfer t[] = {
- {
- .tx_buf = &st->data[0].d8[1],
- .len = 3,
- .cs_change = 1,
- }, {
- .rx_buf = &st->data[1].d8[1],
- .len = 3,
- },
- };
-
- spi_message_init(&m);
- spi_message_add_tail(&t[0], &m);
- spi_message_add_tail(&t[1], &m);
-
- mutex_lock(&indio_dev->mlock);
-
- st->data[0].d32 = cpu_to_be32((1 << 23) | (reg << 16));
-
- ret = spi_sync(st->spi, &m);
- if (ret >= 0)
- ret = be32_to_cpu(st->data[1].d32) & 0xffff;
-
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static int ad5421_update_ctrl(struct iio_dev *indio_dev, unsigned int set,
- unsigned int clr)
-{
- struct ad5421_state *st = iio_priv(indio_dev);
- unsigned int ret;
-
- mutex_lock(&indio_dev->mlock);
-
- st->ctrl &= ~clr;
- st->ctrl |= set;
-
- ret = ad5421_write_unlocked(indio_dev, AD5421_REG_CTRL, st->ctrl);
-
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static irqreturn_t ad5421_fault_handler(int irq, void *data)
-{
- struct iio_dev *indio_dev = data;
- struct ad5421_state *st = iio_priv(indio_dev);
- unsigned int fault;
- unsigned int old_fault = 0;
- unsigned int events;
-
- fault = ad5421_read(indio_dev, AD5421_REG_FAULT);
- if (!fault)
- return IRQ_NONE;
-
- /* If we had a fault, this might mean that the DAC has lost its state
- * and has been reset. Make sure that the control register actually
- * contains what we expect it to contain. Otherwise the watchdog might
- * be enabled and we get watchdog timeout faults, which will render the
- * DAC unusable. */
- ad5421_update_ctrl(indio_dev, 0, 0);
-
-
- /* The fault pin stays high as long as a fault condition is present and
- * it is not possible to mask fault conditions. For certain fault
- * conditions for example like over-temperature it takes some time
- * until the fault condition disappears. If we would exit the interrupt
- * handler immediately after handling the event it would be entered
- * again instantly. Thus we fall back to polling in case we detect that
- * a interrupt condition is still present.
- */
- do {
- /* 0xffff is a invalid value for the register and will only be
- * read if there has been a communication error */
- if (fault == 0xffff)
- fault = 0;
-
- /* we are only interested in new events */
- events = (old_fault ^ fault) & fault;
- events &= st->fault_mask;
-
- if (events & AD5421_FAULT_OVER_CURRENT) {
- iio_push_event(indio_dev,
- IIO_UNMOD_EVENT_CODE(IIO_CURRENT,
- 0,
- IIO_EV_TYPE_THRESH,
- IIO_EV_DIR_RISING),
- iio_get_time_ns());
- }
-
- if (events & AD5421_FAULT_UNDER_CURRENT) {
- iio_push_event(indio_dev,
- IIO_UNMOD_EVENT_CODE(IIO_CURRENT,
- 0,
- IIO_EV_TYPE_THRESH,
- IIO_EV_DIR_FALLING),
- iio_get_time_ns());
- }
-
- if (events & AD5421_FAULT_TEMP_OVER_140) {
- iio_push_event(indio_dev,
- IIO_UNMOD_EVENT_CODE(IIO_TEMP,
- 0,
- IIO_EV_TYPE_MAG,
- IIO_EV_DIR_RISING),
- iio_get_time_ns());
- }
-
- old_fault = fault;
- fault = ad5421_read(indio_dev, AD5421_REG_FAULT);
-
- /* still active? go to sleep for some time */
- if (fault & AD5421_FAULT_TRIGGER_IRQ)
- msleep(1000);
-
- } while (fault & AD5421_FAULT_TRIGGER_IRQ);
-
-
- return IRQ_HANDLED;
-}
-
-static void ad5421_get_current_min_max(struct ad5421_state *st,
- unsigned int *min, unsigned int *max)
-{
- /* The current range is configured using external pins, which are
- * usually hard-wired and not run-time switchable. */
- switch (st->current_range) {
- case AD5421_CURRENT_RANGE_4mA_20mA:
- *min = 4000;
- *max = 20000;
- break;
- case AD5421_CURRENT_RANGE_3mA8_21mA:
- *min = 3800;
- *max = 21000;
- break;
- case AD5421_CURRENT_RANGE_3mA2_24mA:
- *min = 3200;
- *max = 24000;
- break;
- default:
- *min = 0;
- *max = 1;
- break;
- }
-}
-
-static inline unsigned int ad5421_get_offset(struct ad5421_state *st)
-{
- unsigned int min, max;
-
- ad5421_get_current_min_max(st, &min, &max);
- return (min * (1 << 16)) / (max - min);
-}
-
-static inline unsigned int ad5421_get_scale(struct ad5421_state *st)
-{
- unsigned int min, max;
-
- ad5421_get_current_min_max(st, &min, &max);
- return ((max - min) * 1000) / (1 << 16);
-}
-
-static int ad5421_read_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan, int *val, int *val2, long m)
-{
- struct ad5421_state *st = iio_priv(indio_dev);
- int ret;
-
- if (chan->type != IIO_CURRENT)
- return -EINVAL;
-
- switch (m) {
- case IIO_CHAN_INFO_RAW:
- ret = ad5421_read(indio_dev, AD5421_REG_DAC_DATA);
- if (ret < 0)
- return ret;
- *val = ret;
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_SCALE:
- *val = 0;
- *val2 = ad5421_get_scale(st);
- return IIO_VAL_INT_PLUS_MICRO;
- case IIO_CHAN_INFO_OFFSET:
- *val = ad5421_get_offset(st);
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_CALIBBIAS:
- ret = ad5421_read(indio_dev, AD5421_REG_OFFSET);
- if (ret < 0)
- return ret;
- *val = ret - 32768;
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_CALIBSCALE:
- ret = ad5421_read(indio_dev, AD5421_REG_GAIN);
- if (ret < 0)
- return ret;
- *val = ret;
- return IIO_VAL_INT;
- }
-
- return -EINVAL;
-}
-
-static int ad5421_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan, int val, int val2, long mask)
-{
- const unsigned int max_val = 1 << 16;
-
- switch (mask) {
- case IIO_CHAN_INFO_RAW:
- if (val >= max_val || val < 0)
- return -EINVAL;
-
- return ad5421_write(indio_dev, AD5421_REG_DAC_DATA, val);
- case IIO_CHAN_INFO_CALIBBIAS:
- val += 32768;
- if (val >= max_val || val < 0)
- return -EINVAL;
-
- return ad5421_write(indio_dev, AD5421_REG_OFFSET, val);
- case IIO_CHAN_INFO_CALIBSCALE:
- if (val >= max_val || val < 0)
- return -EINVAL;
-
- return ad5421_write(indio_dev, AD5421_REG_GAIN, val);
- default:
- break;
- }
-
- return -EINVAL;
-}
-
-static int ad5421_write_event_config(struct iio_dev *indio_dev,
- u64 event_code, int state)
-{
- struct ad5421_state *st = iio_priv(indio_dev);
- unsigned int mask;
-
- switch (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code)) {
- case IIO_CURRENT:
- if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
- IIO_EV_DIR_RISING)
- mask = AD5421_FAULT_OVER_CURRENT;
- else
- mask = AD5421_FAULT_UNDER_CURRENT;
- break;
- case IIO_TEMP:
- mask = AD5421_FAULT_TEMP_OVER_140;
- break;
- default:
- return -EINVAL;
- }
-
- mutex_lock(&indio_dev->mlock);
- if (state)
- st->fault_mask |= mask;
- else
- st->fault_mask &= ~mask;
- mutex_unlock(&indio_dev->mlock);
-
- return 0;
-}
-
-static int ad5421_read_event_config(struct iio_dev *indio_dev,
- u64 event_code)
-{
- struct ad5421_state *st = iio_priv(indio_dev);
- unsigned int mask;
-
- switch (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code)) {
- case IIO_CURRENT:
- if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
- IIO_EV_DIR_RISING)
- mask = AD5421_FAULT_OVER_CURRENT;
- else
- mask = AD5421_FAULT_UNDER_CURRENT;
- break;
- case IIO_TEMP:
- mask = AD5421_FAULT_TEMP_OVER_140;
- break;
- default:
- return -EINVAL;
- }
-
- return (bool)(st->fault_mask & mask);
-}
-
-static int ad5421_read_event_value(struct iio_dev *indio_dev, u64 event_code,
- int *val)
-{
- int ret;
-
- switch (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code)) {
- case IIO_CURRENT:
- ret = ad5421_read(indio_dev, AD5421_REG_DAC_DATA);
- if (ret < 0)
- return ret;
- *val = ret;
- break;
- case IIO_TEMP:
- *val = 140000;
- break;
- default:
- return -EINVAL;
- }
-
- return 0;
-}
-
-static const struct iio_info ad5421_info = {
- .read_raw = ad5421_read_raw,
- .write_raw = ad5421_write_raw,
- .read_event_config = ad5421_read_event_config,
- .write_event_config = ad5421_write_event_config,
- .read_event_value = ad5421_read_event_value,
- .driver_module = THIS_MODULE,
-};
-
-static int __devinit ad5421_probe(struct spi_device *spi)
-{
- struct ad5421_platform_data *pdata = dev_get_platdata(&spi->dev);
- struct iio_dev *indio_dev;
- struct ad5421_state *st;
- int ret;
-
- indio_dev = iio_device_alloc(sizeof(*st));
- if (indio_dev == NULL) {
- dev_err(&spi->dev, "Failed to allocate iio device\n");
- return -ENOMEM;
- }
-
- st = iio_priv(indio_dev);
- spi_set_drvdata(spi, indio_dev);
-
- st->spi = spi;
-
- indio_dev->dev.parent = &spi->dev;
- indio_dev->name = "ad5421";
- indio_dev->info = &ad5421_info;
- indio_dev->modes = INDIO_DIRECT_MODE;
- indio_dev->channels = ad5421_channels;
- indio_dev->num_channels = ARRAY_SIZE(ad5421_channels);
-
- st->ctrl = AD5421_CTRL_WATCHDOG_DISABLE |
- AD5421_CTRL_AUTO_FAULT_READBACK;
-
- if (pdata) {
- st->current_range = pdata->current_range;
- if (pdata->external_vref)
- st->ctrl |= AD5421_CTRL_PWR_DOWN_INT_VREF;
- } else {
- st->current_range = AD5421_CURRENT_RANGE_4mA_20mA;
- }
-
- /* write initial ctrl register value */
- ad5421_update_ctrl(indio_dev, 0, 0);
-
- if (spi->irq) {
- ret = request_threaded_irq(spi->irq,
- NULL,
- ad5421_fault_handler,
- IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
- "ad5421 fault",
- indio_dev);
- if (ret)
- goto error_free;
- }
-
- ret = iio_device_register(indio_dev);
- if (ret) {
- dev_err(&spi->dev, "Failed to register iio device: %d\n", ret);
- goto error_free_irq;
- }
-
- return 0;
-
-error_free_irq:
- if (spi->irq)
- free_irq(spi->irq, indio_dev);
-error_free:
- iio_device_free(indio_dev);
-
- return ret;
-}
-
-static int __devexit ad5421_remove(struct spi_device *spi)
-{
- struct iio_dev *indio_dev = spi_get_drvdata(spi);
-
- iio_device_unregister(indio_dev);
- if (spi->irq)
- free_irq(spi->irq, indio_dev);
- iio_device_free(indio_dev);
-
- return 0;
-}
-
-static struct spi_driver ad5421_driver = {
- .driver = {
- .name = "ad5421",
- .owner = THIS_MODULE,
- },
- .probe = ad5421_probe,
- .remove = __devexit_p(ad5421_remove),
-};
-module_spi_driver(ad5421_driver);
-
-MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
-MODULE_DESCRIPTION("Analog Devices AD5421 DAC");
-MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("spi:ad5421");
+++ /dev/null
-#ifndef __IIO_DAC_AD5421_H__
-#define __IIO_DAC_AD5421_H__
-
-/*
- * TODO: This file needs to go into include/linux/iio
- */
-
-/**
- * enum ad5421_current_range - Current range the AD5421 is configured for.
- * @AD5421_CURRENT_RANGE_4mA_20mA: 4 mA to 20 mA (RANGE1,0 pins = 00)
- * @AD5421_CURRENT_RANGE_3mA8_21mA: 3.8 mA to 21 mA (RANGE1,0 pins = x1)
- * @AD5421_CURRENT_RANGE_3mA2_24mA: 3.2 mA to 24 mA (RANGE1,0 pins = 10)
- */
-
-enum ad5421_current_range {
- AD5421_CURRENT_RANGE_4mA_20mA,
- AD5421_CURRENT_RANGE_3mA8_21mA,
- AD5421_CURRENT_RANGE_3mA2_24mA,
-};
-
-/**
- * struct ad5421_platform_data - AD5421 DAC driver platform data
- * @external_vref: whether an external reference voltage is used or not
- * @current_range: Current range the AD5421 is configured for
- */
-
-struct ad5421_platform_data {
- bool external_vref;
- enum ad5421_current_range current_range;
-};
-
-#endif
+++ /dev/null
-/*
- * AD5446 SPI DAC driver
- *
- * Copyright 2010 Analog Devices Inc.
- *
- * Licensed under the GPL-2 or later.
- */
-
-#include <linux/interrupt.h>
-#include <linux/workqueue.h>
-#include <linux/device.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/list.h>
-#include <linux/spi/spi.h>
-#include <linux/regulator/consumer.h>
-#include <linux/err.h>
-#include <linux/module.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include "dac.h"
-
-#include "ad5446.h"
-
-static int ad5446_write(struct ad5446_state *st, unsigned val)
-{
- __be16 data = cpu_to_be16(val);
- return spi_write(st->spi, &data, sizeof(data));
-}
-
-static int ad5660_write(struct ad5446_state *st, unsigned val)
-{
- uint8_t data[3];
-
- data[0] = (val >> 16) & 0xFF;
- data[1] = (val >> 8) & 0xFF;
- data[2] = val & 0xFF;
-
- return spi_write(st->spi, data, sizeof(data));
-}
-
-static const char * const ad5446_powerdown_modes[] = {
- "", "1kohm_to_gnd", "100kohm_to_gnd", "three_state"
-};
-
-static ssize_t ad5446_read_powerdown_mode_available(struct iio_dev *indio_dev,
- uintptr_t private, const struct iio_chan_spec *chan, char *buf)
-{
- return sprintf(buf, "%s %s %s\n", ad5446_powerdown_modes[1],
- ad5446_powerdown_modes[2], ad5446_powerdown_modes[3]);
-}
-
-static ssize_t ad5446_write_powerdown_mode(struct iio_dev *indio_dev,
- uintptr_t private,
- const struct iio_chan_spec *chan,
- const char *buf, size_t len)
-{
- struct ad5446_state *st = iio_priv(indio_dev);
- int i;
-
- for (i = 1; i < ARRAY_SIZE(ad5446_powerdown_modes); i++) {
- if (sysfs_streq(buf, ad5446_powerdown_modes[i])) {
- st->pwr_down_mode = i;
- break;
- }
- }
-
- if (i == ARRAY_SIZE(ad5446_powerdown_modes))
- return -EINVAL;
-
- return len;
-}
-
-static ssize_t ad5446_read_powerdown_mode(struct iio_dev *indio_dev,
- uintptr_t private,
- const struct iio_chan_spec *chan,
- char *buf)
-{
- struct ad5446_state *st = iio_priv(indio_dev);
-
- return sprintf(buf, "%s\n", ad5446_powerdown_modes[st->pwr_down_mode]);
-}
-
-static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
- uintptr_t private,
- const struct iio_chan_spec *chan,
- char *buf)
-{
- struct ad5446_state *st = iio_priv(indio_dev);
-
- return sprintf(buf, "%d\n", st->pwr_down);
-}
-
-static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
- uintptr_t private,
- const struct iio_chan_spec *chan,
- const char *buf, size_t len)
-{
- struct ad5446_state *st = iio_priv(indio_dev);
- unsigned int shift;
- unsigned int val;
- bool powerdown;
- int ret;
-
- ret = strtobool(buf, &powerdown);
- if (ret)
- return ret;
-
- mutex_lock(&indio_dev->mlock);
- st->pwr_down = powerdown;
-
- if (st->pwr_down) {
- shift = chan->scan_type.realbits + chan->scan_type.shift;
- val = st->pwr_down_mode << shift;
- } else {
- val = st->cached_val;
- }
-
- ret = st->chip_info->write(st, val);
- mutex_unlock(&indio_dev->mlock);
-
- return ret ? ret : len;
-}
-
-static const struct iio_chan_spec_ext_info ad5064_ext_info_powerdown[] = {
- {
- .name = "powerdown",
- .read = ad5446_read_dac_powerdown,
- .write = ad5446_write_dac_powerdown,
- }, {
- .name = "powerdown_mode",
- .read = ad5446_read_powerdown_mode,
- .write = ad5446_write_powerdown_mode,
- }, {
- .name = "powerdown_mode_available",
- .shared = true,
- .read = ad5446_read_powerdown_mode_available,
- },
- { },
-};
-
-#define _AD5446_CHANNEL(bits, storage, shift, ext) { \
- .type = IIO_VOLTAGE, \
- .indexed = 1, \
- .output = 1, \
- .channel = 0, \
- .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
- IIO_CHAN_INFO_SCALE_SHARED_BIT, \
- .scan_type = IIO_ST('u', (bits), (storage), (shift)), \
- .ext_info = (ext), \
-}
-
-#define AD5446_CHANNEL(bits, storage, shift) \
- _AD5446_CHANNEL(bits, storage, shift, NULL)
-
-#define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
- _AD5446_CHANNEL(bits, storage, shift, ad5064_ext_info_powerdown)
-
-static const struct ad5446_chip_info ad5446_chip_info_tbl[] = {
- [ID_AD5444] = {
- .channel = AD5446_CHANNEL(12, 16, 2),
- .write = ad5446_write,
- },
- [ID_AD5446] = {
- .channel = AD5446_CHANNEL(14, 16, 0),
- .write = ad5446_write,
- },
- [ID_AD5541A] = {
- .channel = AD5446_CHANNEL(16, 16, 0),
- .write = ad5446_write,
- },
- [ID_AD5512A] = {
- .channel = AD5446_CHANNEL(12, 16, 4),
- .write = ad5446_write,
- },
- [ID_AD5553] = {
- .channel = AD5446_CHANNEL(14, 16, 0),
- .write = ad5446_write,
- },
- [ID_AD5601] = {
- .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
- .write = ad5446_write,
- },
- [ID_AD5611] = {
- .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
- .write = ad5446_write,
- },
- [ID_AD5621] = {
- .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
- .write = ad5446_write,
- },
- [ID_AD5620_2500] = {
- .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
- .int_vref_mv = 2500,
- .write = ad5446_write,
- },
- [ID_AD5620_1250] = {
- .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
- .int_vref_mv = 1250,
- .write = ad5446_write,
- },
- [ID_AD5640_2500] = {
- .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
- .int_vref_mv = 2500,
- .write = ad5446_write,
- },
- [ID_AD5640_1250] = {
- .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
- .int_vref_mv = 1250,
- .write = ad5446_write,
- },
- [ID_AD5660_2500] = {
- .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
- .int_vref_mv = 2500,
- .write = ad5660_write,
- },
- [ID_AD5660_1250] = {
- .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
- .int_vref_mv = 1250,
- .write = ad5660_write,
- },
- [ID_AD5662] = {
- .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
- .write = ad5660_write,
- },
-};
-
-static int ad5446_read_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int *val,
- int *val2,
- long m)
-{
- struct ad5446_state *st = iio_priv(indio_dev);
- unsigned long scale_uv;
-
- switch (m) {
- case IIO_CHAN_INFO_RAW:
- *val = st->cached_val;
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_SCALE:
- scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
- *val = scale_uv / 1000;
- *val2 = (scale_uv % 1000) * 1000;
- return IIO_VAL_INT_PLUS_MICRO;
-
- }
- return -EINVAL;
-}
-
-static int ad5446_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int val,
- int val2,
- long mask)
-{
- struct ad5446_state *st = iio_priv(indio_dev);
- int ret = 0;
-
- switch (mask) {
- case IIO_CHAN_INFO_RAW:
- if (val >= (1 << chan->scan_type.realbits) || val < 0)
- return -EINVAL;
-
- val <<= chan->scan_type.shift;
- mutex_lock(&indio_dev->mlock);
- st->cached_val = val;
- if (!st->pwr_down)
- ret = st->chip_info->write(st, val);
- mutex_unlock(&indio_dev->mlock);
- break;
- default:
- ret = -EINVAL;
- }
-
- return ret;
-}
-
-static const struct iio_info ad5446_info = {
- .read_raw = ad5446_read_raw,
- .write_raw = ad5446_write_raw,
- .driver_module = THIS_MODULE,
-};
-
-static int __devinit ad5446_probe(struct spi_device *spi)
-{
- struct ad5446_state *st;
- struct iio_dev *indio_dev;
- struct regulator *reg;
- int ret, voltage_uv = 0;
-
- reg = regulator_get(&spi->dev, "vcc");
- if (!IS_ERR(reg)) {
- ret = regulator_enable(reg);
- if (ret)
- goto error_put_reg;
-
- voltage_uv = regulator_get_voltage(reg);
- }
-
- indio_dev = iio_device_alloc(sizeof(*st));
- if (indio_dev == NULL) {
- ret = -ENOMEM;
- goto error_disable_reg;
- }
- st = iio_priv(indio_dev);
- st->chip_info =
- &ad5446_chip_info_tbl[spi_get_device_id(spi)->driver_data];
-
- spi_set_drvdata(spi, indio_dev);
- st->reg = reg;
- st->spi = spi;
-
- /* Establish that the iio_dev is a child of the spi device */
- indio_dev->dev.parent = &spi->dev;
- indio_dev->name = spi_get_device_id(spi)->name;
- indio_dev->info = &ad5446_info;
- indio_dev->modes = INDIO_DIRECT_MODE;
- indio_dev->channels = &st->chip_info->channel;
- indio_dev->num_channels = 1;
-
- if (st->chip_info->int_vref_mv)
- st->vref_mv = st->chip_info->int_vref_mv;
- else if (voltage_uv)
- st->vref_mv = voltage_uv / 1000;
- else
- dev_warn(&spi->dev, "reference voltage unspecified\n");
-
- ret = iio_device_register(indio_dev);
- if (ret)
- goto error_free_device;
-
- return 0;
-
-error_free_device:
- iio_device_free(indio_dev);
-error_disable_reg:
- if (!IS_ERR(reg))
- regulator_disable(reg);
-error_put_reg:
- if (!IS_ERR(reg))
- regulator_put(reg);
-
- return ret;
-}
-
-static int ad5446_remove(struct spi_device *spi)
-{
- struct iio_dev *indio_dev = spi_get_drvdata(spi);
- struct ad5446_state *st = iio_priv(indio_dev);
-
- iio_device_unregister(indio_dev);
- if (!IS_ERR(st->reg)) {
- regulator_disable(st->reg);
- regulator_put(st->reg);
- }
- iio_device_free(indio_dev);
-
- return 0;
-}
-
-static const struct spi_device_id ad5446_id[] = {
- {"ad5444", ID_AD5444},
- {"ad5446", ID_AD5446},
- {"ad5512a", ID_AD5512A},
- {"ad5541a", ID_AD5541A},
- {"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */
- {"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */
- {"ad5553", ID_AD5553},
- {"ad5601", ID_AD5601},
- {"ad5611", ID_AD5611},
- {"ad5621", ID_AD5621},
- {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
- {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
- {"ad5640-2500", ID_AD5640_2500},
- {"ad5640-1250", ID_AD5640_1250},
- {"ad5660-2500", ID_AD5660_2500},
- {"ad5660-1250", ID_AD5660_1250},
- {"ad5662", ID_AD5662},
- {}
-};
-MODULE_DEVICE_TABLE(spi, ad5446_id);
-
-static struct spi_driver ad5446_driver = {
- .driver = {
- .name = "ad5446",
- .owner = THIS_MODULE,
- },
- .probe = ad5446_probe,
- .remove = __devexit_p(ad5446_remove),
- .id_table = ad5446_id,
-};
-module_spi_driver(ad5446_driver);
-
-MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
-MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-/*
- * AD5446 SPI DAC driver
- *
- * Copyright 2010 Analog Devices Inc.
- *
- * Licensed under the GPL-2 or later.
- */
-#ifndef IIO_DAC_AD5446_H_
-#define IIO_DAC_AD5446_H_
-
-/* DAC Control Bits */
-
-#define AD5446_LOAD (0x0 << 14) /* Load and update */
-#define AD5446_SDO_DIS (0x1 << 14) /* Disable SDO */
-#define AD5446_NOP (0x2 << 14) /* No operation */
-#define AD5446_CLK_RISING (0x3 << 14) /* Clock data on rising edge */
-
-#define AD5620_LOAD (0x0 << 14) /* Load and update Norm Operation*/
-#define AD5620_PWRDWN_1k (0x1 << 14) /* Power-down: 1kOhm to GND */
-#define AD5620_PWRDWN_100k (0x2 << 14) /* Power-down: 100kOhm to GND */
-#define AD5620_PWRDWN_TRISTATE (0x3 << 14) /* Power-down: Three-state */
-
-#define AD5660_LOAD (0x0 << 16) /* Load and update Norm Operation*/
-#define AD5660_PWRDWN_1k (0x1 << 16) /* Power-down: 1kOhm to GND */
-#define AD5660_PWRDWN_100k (0x2 << 16) /* Power-down: 100kOhm to GND */
-#define AD5660_PWRDWN_TRISTATE (0x3 << 16) /* Power-down: Three-state */
-
-#define MODE_PWRDWN_1k 0x1
-#define MODE_PWRDWN_100k 0x2
-#define MODE_PWRDWN_TRISTATE 0x3
-
-/**
- * struct ad5446_state - driver instance specific data
- * @spi: spi_device
- * @chip_info: chip model specific constants, available modes etc
- * @reg: supply regulator
- * @vref_mv: actual reference voltage used
- */
-
-struct ad5446_state {
- struct spi_device *spi;
- const struct ad5446_chip_info *chip_info;
- struct regulator *reg;
- unsigned short vref_mv;
- unsigned cached_val;
- unsigned pwr_down_mode;
- unsigned pwr_down;
-};
-
-/**
- * struct ad5446_chip_info - chip specific information
- * @channel: channel spec for the DAC
- * @int_vref_mv: AD5620/40/60: the internal reference voltage
- * @write: chip specific helper function to write to the register
- */
-
-struct ad5446_chip_info {
- struct iio_chan_spec channel;
- u16 int_vref_mv;
- int (*write)(struct ad5446_state *st, unsigned val);
-};
-
-/**
- * ad5446_supported_device_ids:
- * The AD5620/40/60 parts are available in different fixed internal reference
- * voltage options. The actual part numbers may look differently
- * (and a bit cryptic), however this style is used to make clear which
- * parts are supported here.
- */
-
-enum ad5446_supported_device_ids {
- ID_AD5444,
- ID_AD5446,
- ID_AD5541A,
- ID_AD5512A,
- ID_AD5553,
- ID_AD5601,
- ID_AD5611,
- ID_AD5621,
- ID_AD5620_2500,
- ID_AD5620_1250,
- ID_AD5640_2500,
- ID_AD5640_1250,
- ID_AD5660_2500,
- ID_AD5660_1250,
- ID_AD5662,
-};
-
-#endif /* IIO_DAC_AD5446_H_ */
+++ /dev/null
-/*
- * AD5504, AD5501 High Voltage Digital to Analog Converter
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#include <linux/interrupt.h>
-#include <linux/fs.h>
-#include <linux/device.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/regulator/consumer.h>
-#include <linux/module.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include <linux/iio/events.h>
-#include "dac.h"
-#include "ad5504.h"
-
-#define AD5504_CHANNEL(_chan) { \
- .type = IIO_VOLTAGE, \
- .indexed = 1, \
- .output = 1, \
- .channel = (_chan), \
- .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
- IIO_CHAN_INFO_SCALE_SHARED_BIT, \
- .address = AD5504_ADDR_DAC(_chan), \
- .scan_type = IIO_ST('u', 12, 16, 0), \
-}
-
-static const struct iio_chan_spec ad5504_channels[] = {
- AD5504_CHANNEL(0),
- AD5504_CHANNEL(1),
- AD5504_CHANNEL(2),
- AD5504_CHANNEL(3),
-};
-
-static int ad5504_spi_write(struct spi_device *spi, u8 addr, u16 val)
-{
- u16 tmp = cpu_to_be16(AD5504_CMD_WRITE |
- AD5504_ADDR(addr) |
- (val & AD5504_RES_MASK));
-
- return spi_write(spi, (u8 *)&tmp, 2);
-}
-
-static int ad5504_spi_read(struct spi_device *spi, u8 addr)
-{
- u16 tmp = cpu_to_be16(AD5504_CMD_READ | AD5504_ADDR(addr));
- u16 val;
- int ret;
- struct spi_transfer t = {
- .tx_buf = &tmp,
- .rx_buf = &val,
- .len = 2,
- };
- struct spi_message m;
-
- spi_message_init(&m);
- spi_message_add_tail(&t, &m);
- ret = spi_sync(spi, &m);
-
- if (ret < 0)
- return ret;
-
- return be16_to_cpu(val) & AD5504_RES_MASK;
-}
-
-static int ad5504_read_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int *val,
- int *val2,
- long m)
-{
- struct ad5504_state *st = iio_priv(indio_dev);
- unsigned long scale_uv;
- int ret;
-
- switch (m) {
- case IIO_CHAN_INFO_RAW:
- ret = ad5504_spi_read(st->spi, chan->address);
- if (ret < 0)
- return ret;
-
- *val = ret;
-
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_SCALE:
- scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
- *val = scale_uv / 1000;
- *val2 = (scale_uv % 1000) * 1000;
- return IIO_VAL_INT_PLUS_MICRO;
-
- }
- return -EINVAL;
-}
-
-static int ad5504_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int val,
- int val2,
- long mask)
-{
- struct ad5504_state *st = iio_priv(indio_dev);
- int ret;
-
- switch (mask) {
- case IIO_CHAN_INFO_RAW:
- if (val >= (1 << chan->scan_type.realbits) || val < 0)
- return -EINVAL;
-
- return ad5504_spi_write(st->spi, chan->address, val);
- default:
- ret = -EINVAL;
- }
-
- return -EINVAL;
-}
-
-static ssize_t ad5504_read_powerdown_mode(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5504_state *st = iio_priv(indio_dev);
-
- const char mode[][14] = {"20kohm_to_gnd", "three_state"};
-
- return sprintf(buf, "%s\n", mode[st->pwr_down_mode]);
-}
-
-static ssize_t ad5504_write_powerdown_mode(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5504_state *st = iio_priv(indio_dev);
- int ret;
-
- if (sysfs_streq(buf, "20kohm_to_gnd"))
- st->pwr_down_mode = AD5504_DAC_PWRDN_20K;
- else if (sysfs_streq(buf, "three_state"))
- st->pwr_down_mode = AD5504_DAC_PWRDN_3STATE;
- else
- ret = -EINVAL;
-
- return ret ? ret : len;
-}
-
-static ssize_t ad5504_read_dac_powerdown(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5504_state *st = iio_priv(indio_dev);
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- return sprintf(buf, "%d\n",
- !(st->pwr_down_mask & (1 << this_attr->address)));
-}
-
-static ssize_t ad5504_write_dac_powerdown(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- long readin;
- int ret;
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5504_state *st = iio_priv(indio_dev);
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- ret = strict_strtol(buf, 10, &readin);
- if (ret)
- return ret;
-
- if (readin == 0)
- st->pwr_down_mask |= (1 << this_attr->address);
- else if (readin == 1)
- st->pwr_down_mask &= ~(1 << this_attr->address);
- else
- ret = -EINVAL;
-
- ret = ad5504_spi_write(st->spi, AD5504_ADDR_CTRL,
- AD5504_DAC_PWRDWN_MODE(st->pwr_down_mode) |
- AD5504_DAC_PWR(st->pwr_down_mask));
-
- /* writes to the CTRL register must be followed by a NOOP */
- ad5504_spi_write(st->spi, AD5504_ADDR_NOOP, 0);
-
- return ret ? ret : len;
-}
-
-static IIO_DEVICE_ATTR(out_voltage_powerdown_mode, S_IRUGO |
- S_IWUSR, ad5504_read_powerdown_mode,
- ad5504_write_powerdown_mode, 0);
-
-static IIO_CONST_ATTR(out_voltage_powerdown_mode_available,
- "20kohm_to_gnd three_state");
-
-#define IIO_DEV_ATTR_DAC_POWERDOWN(_num, _show, _store, _addr) \
- IIO_DEVICE_ATTR(out_voltage##_num##_powerdown, \
- S_IRUGO | S_IWUSR, _show, _store, _addr)
-static IIO_DEV_ATTR_DAC_POWERDOWN(0, ad5504_read_dac_powerdown,
- ad5504_write_dac_powerdown, 0);
-static IIO_DEV_ATTR_DAC_POWERDOWN(1, ad5504_read_dac_powerdown,
- ad5504_write_dac_powerdown, 1);
-static IIO_DEV_ATTR_DAC_POWERDOWN(2, ad5504_read_dac_powerdown,
- ad5504_write_dac_powerdown, 2);
-static IIO_DEV_ATTR_DAC_POWERDOWN(3, ad5504_read_dac_powerdown,
- ad5504_write_dac_powerdown, 3);
-
-static struct attribute *ad5504_attributes[] = {
- &iio_dev_attr_out_voltage0_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage1_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage2_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage3_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage_powerdown_mode.dev_attr.attr,
- &iio_const_attr_out_voltage_powerdown_mode_available.dev_attr.attr,
- NULL,
-};
-
-static const struct attribute_group ad5504_attribute_group = {
- .attrs = ad5504_attributes,
-};
-
-static struct attribute *ad5501_attributes[] = {
- &iio_dev_attr_out_voltage0_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage_powerdown_mode.dev_attr.attr,
- &iio_const_attr_out_voltage_powerdown_mode_available.dev_attr.attr,
- NULL,
-};
-
-static const struct attribute_group ad5501_attribute_group = {
- .attrs = ad5501_attributes,
-};
-
-static IIO_CONST_ATTR(temp0_thresh_rising_value, "110000");
-static IIO_CONST_ATTR(temp0_thresh_rising_en, "1");
-
-static struct attribute *ad5504_ev_attributes[] = {
- &iio_const_attr_temp0_thresh_rising_value.dev_attr.attr,
- &iio_const_attr_temp0_thresh_rising_en.dev_attr.attr,
- NULL,
-};
-
-static struct attribute_group ad5504_ev_attribute_group = {
- .attrs = ad5504_ev_attributes,
- .name = "events",
-};
-
-static irqreturn_t ad5504_event_handler(int irq, void *private)
-{
- iio_push_event(private,
- IIO_UNMOD_EVENT_CODE(IIO_TEMP,
- 0,
- IIO_EV_TYPE_THRESH,
- IIO_EV_DIR_RISING),
- iio_get_time_ns());
-
- return IRQ_HANDLED;
-}
-
-static const struct iio_info ad5504_info = {
- .write_raw = ad5504_write_raw,
- .read_raw = ad5504_read_raw,
- .attrs = &ad5504_attribute_group,
- .event_attrs = &ad5504_ev_attribute_group,
- .driver_module = THIS_MODULE,
-};
-
-static const struct iio_info ad5501_info = {
- .write_raw = ad5504_write_raw,
- .read_raw = ad5504_read_raw,
- .attrs = &ad5501_attribute_group,
- .event_attrs = &ad5504_ev_attribute_group,
- .driver_module = THIS_MODULE,
-};
-
-static int __devinit ad5504_probe(struct spi_device *spi)
-{
- struct ad5504_platform_data *pdata = spi->dev.platform_data;
- struct iio_dev *indio_dev;
- struct ad5504_state *st;
- struct regulator *reg;
- int ret, voltage_uv = 0;
-
- indio_dev = iio_device_alloc(sizeof(*st));
- if (indio_dev == NULL) {
- ret = -ENOMEM;
- goto error_ret;
- }
- reg = regulator_get(&spi->dev, "vcc");
- if (!IS_ERR(reg)) {
- ret = regulator_enable(reg);
- if (ret)
- goto error_put_reg;
-
- voltage_uv = regulator_get_voltage(reg);
- }
-
- spi_set_drvdata(spi, indio_dev);
- st = iio_priv(indio_dev);
- if (voltage_uv)
- st->vref_mv = voltage_uv / 1000;
- else if (pdata)
- st->vref_mv = pdata->vref_mv;
- else
- dev_warn(&spi->dev, "reference voltage unspecified\n");
-
- st->reg = reg;
- st->spi = spi;
- indio_dev->dev.parent = &spi->dev;
- indio_dev->name = spi_get_device_id(st->spi)->name;
- if (spi_get_device_id(st->spi)->driver_data == ID_AD5501) {
- indio_dev->info = &ad5501_info;
- indio_dev->num_channels = 1;
- } else {
- indio_dev->info = &ad5504_info;
- indio_dev->num_channels = 4;
- }
- indio_dev->channels = ad5504_channels;
- indio_dev->modes = INDIO_DIRECT_MODE;
-
- if (spi->irq) {
- ret = request_threaded_irq(spi->irq,
- NULL,
- &ad5504_event_handler,
- IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
- spi_get_device_id(st->spi)->name,
- indio_dev);
- if (ret)
- goto error_disable_reg;
- }
-
- ret = iio_device_register(indio_dev);
- if (ret)
- goto error_free_irq;
-
- return 0;
-
-error_free_irq:
- free_irq(spi->irq, indio_dev);
-error_disable_reg:
- if (!IS_ERR(reg))
- regulator_disable(reg);
-error_put_reg:
- if (!IS_ERR(reg))
- regulator_put(reg);
-
- iio_device_free(indio_dev);
-error_ret:
- return ret;
-}
-
-static int __devexit ad5504_remove(struct spi_device *spi)
-{
- struct iio_dev *indio_dev = spi_get_drvdata(spi);
- struct ad5504_state *st = iio_priv(indio_dev);
-
- iio_device_unregister(indio_dev);
- if (spi->irq)
- free_irq(spi->irq, indio_dev);
-
- if (!IS_ERR(st->reg)) {
- regulator_disable(st->reg);
- regulator_put(st->reg);
- }
- iio_device_free(indio_dev);
-
- return 0;
-}
-
-static const struct spi_device_id ad5504_id[] = {
- {"ad5504", ID_AD5504},
- {"ad5501", ID_AD5501},
- {}
-};
-MODULE_DEVICE_TABLE(spi, ad5504_id);
-
-static struct spi_driver ad5504_driver = {
- .driver = {
- .name = "ad5504",
- .owner = THIS_MODULE,
- },
- .probe = ad5504_probe,
- .remove = __devexit_p(ad5504_remove),
- .id_table = ad5504_id,
-};
-module_spi_driver(ad5504_driver);
-
-MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
-MODULE_DESCRIPTION("Analog Devices AD5501/AD5501 DAC");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-/*
- * AD5504 SPI DAC driver
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#ifndef SPI_AD5504_H_
-#define SPI_AD5504_H_
-
-#define AD5505_BITS 12
-#define AD5504_RES_MASK ((1 << (AD5505_BITS)) - 1)
-
-#define AD5504_CMD_READ (1 << 15)
-#define AD5504_CMD_WRITE (0 << 15)
-#define AD5504_ADDR(addr) ((addr) << 12)
-
-/* Registers */
-#define AD5504_ADDR_NOOP 0
-#define AD5504_ADDR_DAC(x) ((x) + 1)
-#define AD5504_ADDR_ALL_DAC 5
-#define AD5504_ADDR_CTRL 7
-
-/* Control Register */
-#define AD5504_DAC_PWR(ch) ((ch) << 2)
-#define AD5504_DAC_PWRDWN_MODE(mode) ((mode) << 6)
-#define AD5504_DAC_PWRDN_20K 0
-#define AD5504_DAC_PWRDN_3STATE 1
-
-/*
- * TODO: struct ad5504_platform_data needs to go into include/linux/iio
- */
-
-struct ad5504_platform_data {
- u16 vref_mv;
-};
-
-/**
- * struct ad5446_state - driver instance specific data
- * @us: spi_device
- * @reg: supply regulator
- * @vref_mv: actual reference voltage used
- * @pwr_down_mask power down mask
- * @pwr_down_mode current power down mode
- */
-
-struct ad5504_state {
- struct spi_device *spi;
- struct regulator *reg;
- unsigned short vref_mv;
- unsigned pwr_down_mask;
- unsigned pwr_down_mode;
-};
-
-/**
- * ad5504_supported_device_ids:
- */
-
-enum ad5504_supported_device_ids {
- ID_AD5504,
- ID_AD5501,
-};
-
-#endif /* SPI_AD5504_H_ */
+++ /dev/null
-/*
- * AD5624R SPI DAC driver
- *
- * Copyright 2010-2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-#ifndef SPI_AD5624R_H_
-#define SPI_AD5624R_H_
-
-#define AD5624R_DAC_CHANNELS 4
-
-#define AD5624R_ADDR_DAC0 0x0
-#define AD5624R_ADDR_DAC1 0x1
-#define AD5624R_ADDR_DAC2 0x2
-#define AD5624R_ADDR_DAC3 0x3
-#define AD5624R_ADDR_ALL_DAC 0x7
-
-#define AD5624R_CMD_WRITE_INPUT_N 0x0
-#define AD5624R_CMD_UPDATE_DAC_N 0x1
-#define AD5624R_CMD_WRITE_INPUT_N_UPDATE_ALL 0x2
-#define AD5624R_CMD_WRITE_INPUT_N_UPDATE_N 0x3
-#define AD5624R_CMD_POWERDOWN_DAC 0x4
-#define AD5624R_CMD_RESET 0x5
-#define AD5624R_CMD_LDAC_SETUP 0x6
-#define AD5624R_CMD_INTERNAL_REFER_SETUP 0x7
-
-#define AD5624R_LDAC_PWRDN_NONE 0x0
-#define AD5624R_LDAC_PWRDN_1K 0x1
-#define AD5624R_LDAC_PWRDN_100K 0x2
-#define AD5624R_LDAC_PWRDN_3STATE 0x3
-
-/**
- * struct ad5624r_chip_info - chip specific information
- * @channels: channel spec for the DAC
- * @int_vref_mv: AD5620/40/60: the internal reference voltage
- */
-
-struct ad5624r_chip_info {
- const struct iio_chan_spec *channels;
- u16 int_vref_mv;
-};
-
-/**
- * struct ad5446_state - driver instance specific data
- * @indio_dev: the industrial I/O device
- * @us: spi_device
- * @chip_info: chip model specific constants, available modes etc
- * @reg: supply regulator
- * @vref_mv: actual reference voltage used
- * @pwr_down_mask power down mask
- * @pwr_down_mode current power down mode
- */
-
-struct ad5624r_state {
- struct spi_device *us;
- const struct ad5624r_chip_info *chip_info;
- struct regulator *reg;
- unsigned short vref_mv;
- unsigned pwr_down_mask;
- unsigned pwr_down_mode;
-};
-
-/**
- * ad5624r_supported_device_ids:
- * The AD5624/44/64 parts are available in different
- * fixed internal reference voltage options.
- */
-
-enum ad5624r_supported_device_ids {
- ID_AD5624R3,
- ID_AD5644R3,
- ID_AD5664R3,
- ID_AD5624R5,
- ID_AD5644R5,
- ID_AD5664R5,
-};
-
-#endif /* SPI_AD5624R_H_ */
+++ /dev/null
-/*
- * AD5624R, AD5644R, AD5664R Digital to analog convertors spi driver
- *
- * Copyright 2010-2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#include <linux/interrupt.h>
-#include <linux/fs.h>
-#include <linux/device.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/regulator/consumer.h>
-#include <linux/module.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include "dac.h"
-#include "ad5624r.h"
-
-#define AD5624R_CHANNEL(_chan, _bits) { \
- .type = IIO_VOLTAGE, \
- .indexed = 1, \
- .output = 1, \
- .channel = (_chan), \
- .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
- IIO_CHAN_INFO_SCALE_SHARED_BIT, \
- .address = (_chan), \
- .scan_type = IIO_ST('u', (_bits), 16, 16 - (_bits)), \
-}
-
-#define DECLARE_AD5624R_CHANNELS(_name, _bits) \
- const struct iio_chan_spec _name##_channels[] = { \
- AD5624R_CHANNEL(0, _bits), \
- AD5624R_CHANNEL(1, _bits), \
- AD5624R_CHANNEL(2, _bits), \
- AD5624R_CHANNEL(3, _bits), \
-}
-
-static DECLARE_AD5624R_CHANNELS(ad5624r, 12);
-static DECLARE_AD5624R_CHANNELS(ad5644r, 14);
-static DECLARE_AD5624R_CHANNELS(ad5664r, 16);
-
-static const struct ad5624r_chip_info ad5624r_chip_info_tbl[] = {
- [ID_AD5624R3] = {
- .channels = ad5624r_channels,
- .int_vref_mv = 1250,
- },
- [ID_AD5624R5] = {
- .channels = ad5624r_channels,
- .int_vref_mv = 2500,
- },
- [ID_AD5644R3] = {
- .channels = ad5644r_channels,
- .int_vref_mv = 1250,
- },
- [ID_AD5644R5] = {
- .channels = ad5644r_channels,
- .int_vref_mv = 2500,
- },
- [ID_AD5664R3] = {
- .channels = ad5664r_channels,
- .int_vref_mv = 1250,
- },
- [ID_AD5664R5] = {
- .channels = ad5664r_channels,
- .int_vref_mv = 2500,
- },
-};
-
-static int ad5624r_spi_write(struct spi_device *spi,
- u8 cmd, u8 addr, u16 val, u8 len)
-{
- u32 data;
- u8 msg[3];
-
- /*
- * The input shift register is 24 bits wide. The first two bits are
- * don't care bits. The next three are the command bits, C2 to C0,
- * followed by the 3-bit DAC address, A2 to A0, and then the
- * 16-, 14-, 12-bit data-word. The data-word comprises the 16-,
- * 14-, 12-bit input code followed by 0, 2, or 4 don't care bits,
- * for the AD5664R, AD5644R, and AD5624R, respectively.
- */
- data = (0 << 22) | (cmd << 19) | (addr << 16) | (val << (16 - len));
- msg[0] = data >> 16;
- msg[1] = data >> 8;
- msg[2] = data;
-
- return spi_write(spi, msg, 3);
-}
-
-static int ad5624r_read_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int *val,
- int *val2,
- long m)
-{
- struct ad5624r_state *st = iio_priv(indio_dev);
- unsigned long scale_uv;
-
- switch (m) {
- case IIO_CHAN_INFO_SCALE:
- scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
- *val = scale_uv / 1000;
- *val2 = (scale_uv % 1000) * 1000;
- return IIO_VAL_INT_PLUS_MICRO;
-
- }
- return -EINVAL;
-}
-
-static int ad5624r_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int val,
- int val2,
- long mask)
-{
- struct ad5624r_state *st = iio_priv(indio_dev);
- int ret;
-
- switch (mask) {
- case IIO_CHAN_INFO_RAW:
- if (val >= (1 << chan->scan_type.realbits) || val < 0)
- return -EINVAL;
-
- return ad5624r_spi_write(st->us,
- AD5624R_CMD_WRITE_INPUT_N_UPDATE_N,
- chan->address, val,
- chan->scan_type.shift);
- default:
- ret = -EINVAL;
- }
-
- return -EINVAL;
-}
-
-static ssize_t ad5624r_read_powerdown_mode(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5624r_state *st = iio_priv(indio_dev);
-
- char mode[][15] = {"", "1kohm_to_gnd", "100kohm_to_gnd", "three_state"};
-
- return sprintf(buf, "%s\n", mode[st->pwr_down_mode]);
-}
-
-static ssize_t ad5624r_write_powerdown_mode(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5624r_state *st = iio_priv(indio_dev);
- int ret;
-
- if (sysfs_streq(buf, "1kohm_to_gnd"))
- st->pwr_down_mode = AD5624R_LDAC_PWRDN_1K;
- else if (sysfs_streq(buf, "100kohm_to_gnd"))
- st->pwr_down_mode = AD5624R_LDAC_PWRDN_100K;
- else if (sysfs_streq(buf, "three_state"))
- st->pwr_down_mode = AD5624R_LDAC_PWRDN_3STATE;
- else
- ret = -EINVAL;
-
- return ret ? ret : len;
-}
-
-static ssize_t ad5624r_read_dac_powerdown(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5624r_state *st = iio_priv(indio_dev);
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- return sprintf(buf, "%d\n",
- !!(st->pwr_down_mask & (1 << this_attr->address)));
-}
-
-static ssize_t ad5624r_write_dac_powerdown(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- long readin;
- int ret;
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5624r_state *st = iio_priv(indio_dev);
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- ret = strict_strtol(buf, 10, &readin);
- if (ret)
- return ret;
-
- if (readin == 1)
- st->pwr_down_mask |= (1 << this_attr->address);
- else if (!readin)
- st->pwr_down_mask &= ~(1 << this_attr->address);
- else
- ret = -EINVAL;
-
- ret = ad5624r_spi_write(st->us, AD5624R_CMD_POWERDOWN_DAC, 0,
- (st->pwr_down_mode << 4) |
- st->pwr_down_mask, 16);
-
- return ret ? ret : len;
-}
-
-static IIO_DEVICE_ATTR(out_voltage_powerdown_mode, S_IRUGO |
- S_IWUSR, ad5624r_read_powerdown_mode,
- ad5624r_write_powerdown_mode, 0);
-
-static IIO_CONST_ATTR(out_voltage_powerdown_mode_available,
- "1kohm_to_gnd 100kohm_to_gnd three_state");
-
-#define IIO_DEV_ATTR_DAC_POWERDOWN(_num, _show, _store, _addr) \
- IIO_DEVICE_ATTR(out_voltage##_num##_powerdown, \
- S_IRUGO | S_IWUSR, _show, _store, _addr)
-
-static IIO_DEV_ATTR_DAC_POWERDOWN(0, ad5624r_read_dac_powerdown,
- ad5624r_write_dac_powerdown, 0);
-static IIO_DEV_ATTR_DAC_POWERDOWN(1, ad5624r_read_dac_powerdown,
- ad5624r_write_dac_powerdown, 1);
-static IIO_DEV_ATTR_DAC_POWERDOWN(2, ad5624r_read_dac_powerdown,
- ad5624r_write_dac_powerdown, 2);
-static IIO_DEV_ATTR_DAC_POWERDOWN(3, ad5624r_read_dac_powerdown,
- ad5624r_write_dac_powerdown, 3);
-
-static struct attribute *ad5624r_attributes[] = {
- &iio_dev_attr_out_voltage0_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage1_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage2_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage3_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage_powerdown_mode.dev_attr.attr,
- &iio_const_attr_out_voltage_powerdown_mode_available.dev_attr.attr,
- NULL,
-};
-
-static const struct attribute_group ad5624r_attribute_group = {
- .attrs = ad5624r_attributes,
-};
-
-static const struct iio_info ad5624r_info = {
- .write_raw = ad5624r_write_raw,
- .read_raw = ad5624r_read_raw,
- .attrs = &ad5624r_attribute_group,
- .driver_module = THIS_MODULE,
-};
-
-static int __devinit ad5624r_probe(struct spi_device *spi)
-{
- struct ad5624r_state *st;
- struct iio_dev *indio_dev;
- int ret, voltage_uv = 0;
-
- indio_dev = iio_device_alloc(sizeof(*st));
- if (indio_dev == NULL) {
- ret = -ENOMEM;
- goto error_ret;
- }
- st = iio_priv(indio_dev);
- st->reg = regulator_get(&spi->dev, "vcc");
- if (!IS_ERR(st->reg)) {
- ret = regulator_enable(st->reg);
- if (ret)
- goto error_put_reg;
-
- voltage_uv = regulator_get_voltage(st->reg);
- }
-
- spi_set_drvdata(spi, indio_dev);
- st->chip_info =
- &ad5624r_chip_info_tbl[spi_get_device_id(spi)->driver_data];
-
- if (voltage_uv)
- st->vref_mv = voltage_uv / 1000;
- else
- st->vref_mv = st->chip_info->int_vref_mv;
-
- st->us = spi;
-
- indio_dev->dev.parent = &spi->dev;
- indio_dev->name = spi_get_device_id(spi)->name;
- indio_dev->info = &ad5624r_info;
- indio_dev->modes = INDIO_DIRECT_MODE;
- indio_dev->channels = st->chip_info->channels;
- indio_dev->num_channels = AD5624R_DAC_CHANNELS;
-
- ret = ad5624r_spi_write(spi, AD5624R_CMD_INTERNAL_REFER_SETUP, 0,
- !!voltage_uv, 16);
- if (ret)
- goto error_disable_reg;
-
- ret = iio_device_register(indio_dev);
- if (ret)
- goto error_disable_reg;
-
- return 0;
-
-error_disable_reg:
- if (!IS_ERR(st->reg))
- regulator_disable(st->reg);
-error_put_reg:
- if (!IS_ERR(st->reg))
- regulator_put(st->reg);
- iio_device_free(indio_dev);
-error_ret:
-
- return ret;
-}
-
-static int __devexit ad5624r_remove(struct spi_device *spi)
-{
- struct iio_dev *indio_dev = spi_get_drvdata(spi);
- struct ad5624r_state *st = iio_priv(indio_dev);
-
- iio_device_unregister(indio_dev);
- if (!IS_ERR(st->reg)) {
- regulator_disable(st->reg);
- regulator_put(st->reg);
- }
- iio_device_free(indio_dev);
-
- return 0;
-}
-
-static const struct spi_device_id ad5624r_id[] = {
- {"ad5624r3", ID_AD5624R3},
- {"ad5644r3", ID_AD5644R3},
- {"ad5664r3", ID_AD5664R3},
- {"ad5624r5", ID_AD5624R5},
- {"ad5644r5", ID_AD5644R5},
- {"ad5664r5", ID_AD5664R5},
- {}
-};
-MODULE_DEVICE_TABLE(spi, ad5624r_id);
-
-static struct spi_driver ad5624r_driver = {
- .driver = {
- .name = "ad5624r",
- .owner = THIS_MODULE,
- },
- .probe = ad5624r_probe,
- .remove = __devexit_p(ad5624r_remove),
- .id_table = ad5624r_id,
-};
-module_spi_driver(ad5624r_driver);
-
-MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
-MODULE_DESCRIPTION("Analog Devices AD5624/44/64R DAC spi driver");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-/*
- * AD5686R, AD5685R, AD5684R Digital to analog converters driver
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#include <linux/interrupt.h>
-#include <linux/fs.h>
-#include <linux/device.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/regulator/consumer.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include "dac.h"
-
-#define AD5686_DAC_CHANNELS 4
-
-#define AD5686_ADDR(x) ((x) << 16)
-#define AD5686_CMD(x) ((x) << 20)
-
-#define AD5686_ADDR_DAC(chan) (0x1 << (chan))
-#define AD5686_ADDR_ALL_DAC 0xF
-
-#define AD5686_CMD_NOOP 0x0
-#define AD5686_CMD_WRITE_INPUT_N 0x1
-#define AD5686_CMD_UPDATE_DAC_N 0x2
-#define AD5686_CMD_WRITE_INPUT_N_UPDATE_N 0x3
-#define AD5686_CMD_POWERDOWN_DAC 0x4
-#define AD5686_CMD_LDAC_MASK 0x5
-#define AD5686_CMD_RESET 0x6
-#define AD5686_CMD_INTERNAL_REFER_SETUP 0x7
-#define AD5686_CMD_DAISY_CHAIN_ENABLE 0x8
-#define AD5686_CMD_READBACK_ENABLE 0x9
-
-#define AD5686_LDAC_PWRDN_NONE 0x0
-#define AD5686_LDAC_PWRDN_1K 0x1
-#define AD5686_LDAC_PWRDN_100K 0x2
-#define AD5686_LDAC_PWRDN_3STATE 0x3
-
-/**
- * struct ad5686_chip_info - chip specific information
- * @int_vref_mv: AD5620/40/60: the internal reference voltage
- * @channel: channel specification
-*/
-
-struct ad5686_chip_info {
- u16 int_vref_mv;
- struct iio_chan_spec channel[AD5686_DAC_CHANNELS];
-};
-
-/**
- * struct ad5446_state - driver instance specific data
- * @spi: spi_device
- * @chip_info: chip model specific constants, available modes etc
- * @reg: supply regulator
- * @vref_mv: actual reference voltage used
- * @pwr_down_mask: power down mask
- * @pwr_down_mode: current power down mode
- * @data: spi transfer buffers
- */
-
-struct ad5686_state {
- struct spi_device *spi;
- const struct ad5686_chip_info *chip_info;
- struct regulator *reg;
- unsigned short vref_mv;
- unsigned pwr_down_mask;
- unsigned pwr_down_mode;
- /*
- * DMA (thus cache coherency maintenance) requires the
- * transfer buffers to live in their own cache lines.
- */
-
- union {
- u32 d32;
- u8 d8[4];
- } data[3] ____cacheline_aligned;
-};
-
-/**
- * ad5686_supported_device_ids:
- */
-
-enum ad5686_supported_device_ids {
- ID_AD5684,
- ID_AD5685,
- ID_AD5686,
-};
-#define AD5868_CHANNEL(chan, bits, shift) { \
- .type = IIO_VOLTAGE, \
- .indexed = 1, \
- .output = 1, \
- .channel = chan, \
- .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
- IIO_CHAN_INFO_SCALE_SHARED_BIT, \
- .address = AD5686_ADDR_DAC(chan), \
- .scan_type = IIO_ST('u', bits, 16, shift) \
-}
-static const struct ad5686_chip_info ad5686_chip_info_tbl[] = {
- [ID_AD5684] = {
- .channel[0] = AD5868_CHANNEL(0, 12, 4),
- .channel[1] = AD5868_CHANNEL(1, 12, 4),
- .channel[2] = AD5868_CHANNEL(2, 12, 4),
- .channel[3] = AD5868_CHANNEL(3, 12, 4),
- .int_vref_mv = 2500,
- },
- [ID_AD5685] = {
- .channel[0] = AD5868_CHANNEL(0, 14, 2),
- .channel[1] = AD5868_CHANNEL(1, 14, 2),
- .channel[2] = AD5868_CHANNEL(2, 14, 2),
- .channel[3] = AD5868_CHANNEL(3, 14, 2),
- .int_vref_mv = 2500,
- },
- [ID_AD5686] = {
- .channel[0] = AD5868_CHANNEL(0, 16, 0),
- .channel[1] = AD5868_CHANNEL(1, 16, 0),
- .channel[2] = AD5868_CHANNEL(2, 16, 0),
- .channel[3] = AD5868_CHANNEL(3, 16, 0),
- .int_vref_mv = 2500,
- },
-};
-
-static int ad5686_spi_write(struct ad5686_state *st,
- u8 cmd, u8 addr, u16 val, u8 shift)
-{
- val <<= shift;
-
- st->data[0].d32 = cpu_to_be32(AD5686_CMD(cmd) |
- AD5686_ADDR(addr) |
- val);
-
- return spi_write(st->spi, &st->data[0].d8[1], 3);
-}
-
-static int ad5686_spi_read(struct ad5686_state *st, u8 addr)
-{
- struct spi_transfer t[] = {
- {
- .tx_buf = &st->data[0].d8[1],
- .len = 3,
- .cs_change = 1,
- }, {
- .tx_buf = &st->data[1].d8[1],
- .rx_buf = &st->data[2].d8[1],
- .len = 3,
- },
- };
- struct spi_message m;
- int ret;
-
- spi_message_init(&m);
- spi_message_add_tail(&t[0], &m);
- spi_message_add_tail(&t[1], &m);
-
- st->data[0].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_READBACK_ENABLE) |
- AD5686_ADDR(addr));
- st->data[1].d32 = cpu_to_be32(AD5686_CMD(AD5686_CMD_NOOP));
-
- ret = spi_sync(st->spi, &m);
- if (ret < 0)
- return ret;
-
- return be32_to_cpu(st->data[2].d32);
-}
-
-static ssize_t ad5686_read_powerdown_mode(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5686_state *st = iio_priv(indio_dev);
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- char mode[][15] = {"", "1kohm_to_gnd", "100kohm_to_gnd", "three_state"};
-
- return sprintf(buf, "%s\n", mode[(st->pwr_down_mode >>
- (this_attr->address * 2)) & 0x3]);
-}
-
-static ssize_t ad5686_write_powerdown_mode(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5686_state *st = iio_priv(indio_dev);
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
- unsigned mode;
-
- if (sysfs_streq(buf, "1kohm_to_gnd"))
- mode = AD5686_LDAC_PWRDN_1K;
- else if (sysfs_streq(buf, "100kohm_to_gnd"))
- mode = AD5686_LDAC_PWRDN_100K;
- else if (sysfs_streq(buf, "three_state"))
- mode = AD5686_LDAC_PWRDN_3STATE;
- else
- return -EINVAL;
-
- st->pwr_down_mode &= ~(0x3 << (this_attr->address * 2));
- st->pwr_down_mode |= (mode << (this_attr->address * 2));
-
- return len;
-}
-
-static ssize_t ad5686_read_dac_powerdown(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5686_state *st = iio_priv(indio_dev);
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- return sprintf(buf, "%d\n", !!(st->pwr_down_mask &
- (0x3 << (this_attr->address * 2))));
-}
-
-static ssize_t ad5686_write_dac_powerdown(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- bool readin;
- int ret;
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5686_state *st = iio_priv(indio_dev);
- struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
-
- ret = strtobool(buf, &readin);
- if (ret)
- return ret;
-
- if (readin == true)
- st->pwr_down_mask |= (0x3 << (this_attr->address * 2));
- else
- st->pwr_down_mask &= ~(0x3 << (this_attr->address * 2));
-
- ret = ad5686_spi_write(st, AD5686_CMD_POWERDOWN_DAC, 0,
- st->pwr_down_mask & st->pwr_down_mode, 0);
-
- return ret ? ret : len;
-}
-
-static IIO_CONST_ATTR(out_voltage_powerdown_mode_available,
- "1kohm_to_gnd 100kohm_to_gnd three_state");
-
-#define IIO_DEV_ATTR_DAC_POWERDOWN_MODE(_num) \
- IIO_DEVICE_ATTR(out_voltage##_num##_powerdown_mode, \
- S_IRUGO | S_IWUSR, \
- ad5686_read_powerdown_mode, \
- ad5686_write_powerdown_mode, _num)
-
-static IIO_DEV_ATTR_DAC_POWERDOWN_MODE(0);
-static IIO_DEV_ATTR_DAC_POWERDOWN_MODE(1);
-static IIO_DEV_ATTR_DAC_POWERDOWN_MODE(2);
-static IIO_DEV_ATTR_DAC_POWERDOWN_MODE(3);
-
-#define IIO_DEV_ATTR_DAC_POWERDOWN(_num) \
- IIO_DEVICE_ATTR(out_voltage##_num##_powerdown, \
- S_IRUGO | S_IWUSR, \
- ad5686_read_dac_powerdown, \
- ad5686_write_dac_powerdown, _num)
-
-static IIO_DEV_ATTR_DAC_POWERDOWN(0);
-static IIO_DEV_ATTR_DAC_POWERDOWN(1);
-static IIO_DEV_ATTR_DAC_POWERDOWN(2);
-static IIO_DEV_ATTR_DAC_POWERDOWN(3);
-
-static struct attribute *ad5686_attributes[] = {
- &iio_dev_attr_out_voltage0_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage1_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage2_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage3_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage0_powerdown_mode.dev_attr.attr,
- &iio_dev_attr_out_voltage1_powerdown_mode.dev_attr.attr,
- &iio_dev_attr_out_voltage2_powerdown_mode.dev_attr.attr,
- &iio_dev_attr_out_voltage3_powerdown_mode.dev_attr.attr,
- &iio_const_attr_out_voltage_powerdown_mode_available.dev_attr.attr,
- NULL,
-};
-
-static const struct attribute_group ad5686_attribute_group = {
- .attrs = ad5686_attributes,
-};
-
-static int ad5686_read_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int *val,
- int *val2,
- long m)
-{
- struct ad5686_state *st = iio_priv(indio_dev);
- unsigned long scale_uv;
- int ret;
-
- switch (m) {
- case IIO_CHAN_INFO_RAW:
- mutex_lock(&indio_dev->mlock);
- ret = ad5686_spi_read(st, chan->address);
- mutex_unlock(&indio_dev->mlock);
- if (ret < 0)
- return ret;
- *val = ret;
- return IIO_VAL_INT;
- break;
- case IIO_CHAN_INFO_SCALE:
- scale_uv = (st->vref_mv * 100000)
- >> (chan->scan_type.realbits);
- *val = scale_uv / 100000;
- *val2 = (scale_uv % 100000) * 10;
- return IIO_VAL_INT_PLUS_MICRO;
-
- }
- return -EINVAL;
-}
-
-static int ad5686_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int val,
- int val2,
- long mask)
-{
- struct ad5686_state *st = iio_priv(indio_dev);
- int ret;
-
- switch (mask) {
- case IIO_CHAN_INFO_RAW:
- if (val > (1 << chan->scan_type.realbits) || val < 0)
- return -EINVAL;
-
- mutex_lock(&indio_dev->mlock);
- ret = ad5686_spi_write(st,
- AD5686_CMD_WRITE_INPUT_N_UPDATE_N,
- chan->address,
- val,
- chan->scan_type.shift);
- mutex_unlock(&indio_dev->mlock);
- break;
- default:
- ret = -EINVAL;
- }
-
- return ret;
-}
-
-static const struct iio_info ad5686_info = {
- .read_raw = ad5686_read_raw,
- .write_raw = ad5686_write_raw,
- .attrs = &ad5686_attribute_group,
- .driver_module = THIS_MODULE,
-};
-
-static int __devinit ad5686_probe(struct spi_device *spi)
-{
- struct ad5686_state *st;
- struct iio_dev *indio_dev;
- int ret, regdone = 0, voltage_uv = 0;
-
- indio_dev = iio_device_alloc(sizeof(*st));
- if (indio_dev == NULL)
- return -ENOMEM;
-
- st = iio_priv(indio_dev);
- spi_set_drvdata(spi, indio_dev);
-
- st->reg = regulator_get(&spi->dev, "vcc");
- if (!IS_ERR(st->reg)) {
- ret = regulator_enable(st->reg);
- if (ret)
- goto error_put_reg;
-
- voltage_uv = regulator_get_voltage(st->reg);
- }
-
- st->chip_info =
- &ad5686_chip_info_tbl[spi_get_device_id(spi)->driver_data];
-
- if (voltage_uv)
- st->vref_mv = voltage_uv / 1000;
- else
- st->vref_mv = st->chip_info->int_vref_mv;
-
- st->spi = spi;
-
- indio_dev->dev.parent = &spi->dev;
- indio_dev->name = spi_get_device_id(spi)->name;
- indio_dev->info = &ad5686_info;
- indio_dev->modes = INDIO_DIRECT_MODE;
- indio_dev->channels = st->chip_info->channel;
- indio_dev->num_channels = AD5686_DAC_CHANNELS;
-
- regdone = 1;
- ret = ad5686_spi_write(st, AD5686_CMD_INTERNAL_REFER_SETUP, 0,
- !!voltage_uv, 0);
- if (ret)
- goto error_disable_reg;
-
- ret = iio_device_register(indio_dev);
- if (ret)
- goto error_disable_reg;
-
- return 0;
-
-error_disable_reg:
- if (!IS_ERR(st->reg))
- regulator_disable(st->reg);
-error_put_reg:
- if (!IS_ERR(st->reg))
- regulator_put(st->reg);
-
- iio_device_free(indio_dev);
-
- return ret;
-}
-
-static int __devexit ad5686_remove(struct spi_device *spi)
-{
- struct iio_dev *indio_dev = spi_get_drvdata(spi);
- struct ad5686_state *st = iio_priv(indio_dev);
-
- iio_device_unregister(indio_dev);
- if (!IS_ERR(st->reg)) {
- regulator_disable(st->reg);
- regulator_put(st->reg);
- }
- iio_device_free(indio_dev);
-
- return 0;
-}
-
-static const struct spi_device_id ad5686_id[] = {
- {"ad5684", ID_AD5684},
- {"ad5685", ID_AD5685},
- {"ad5686", ID_AD5686},
- {}
-};
-MODULE_DEVICE_TABLE(spi, ad5686_id);
-
-static struct spi_driver ad5686_driver = {
- .driver = {
- .name = "ad5686",
- .owner = THIS_MODULE,
- },
- .probe = ad5686_probe,
- .remove = __devexit_p(ad5686_remove),
- .id_table = ad5686_id,
-};
-module_spi_driver(ad5686_driver);
-
-MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
-MODULE_DESCRIPTION("Analog Devices AD5686/85/84 DAC");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-/*
- * Analog devices AD5764, AD5764R, AD5744, AD5744R quad-channel
- * Digital to Analog Converters driver
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#include <linux/device.h>
-#include <linux/err.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/regulator/consumer.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include "dac.h"
-
-#define AD5764_REG_SF_NOP 0x0
-#define AD5764_REG_SF_CONFIG 0x1
-#define AD5764_REG_SF_CLEAR 0x4
-#define AD5764_REG_SF_LOAD 0x5
-#define AD5764_REG_DATA(x) ((2 << 3) | (x))
-#define AD5764_REG_COARSE_GAIN(x) ((3 << 3) | (x))
-#define AD5764_REG_FINE_GAIN(x) ((4 << 3) | (x))
-#define AD5764_REG_OFFSET(x) ((5 << 3) | (x))
-
-#define AD5764_NUM_CHANNELS 4
-
-/**
- * struct ad5764_chip_info - chip specific information
- * @int_vref: Value of the internal reference voltage in uV - 0 if external
- * reference voltage is used
- * @channel channel specification
-*/
-
-struct ad5764_chip_info {
- unsigned long int_vref;
- const struct iio_chan_spec *channels;
-};
-
-/**
- * struct ad5764_state - driver instance specific data
- * @spi: spi_device
- * @chip_info: chip info
- * @vref_reg: vref supply regulators
- * @data: spi transfer buffers
- */
-
-struct ad5764_state {
- struct spi_device *spi;
- const struct ad5764_chip_info *chip_info;
- struct regulator_bulk_data vref_reg[2];
-
- /*
- * DMA (thus cache coherency maintenance) requires the
- * transfer buffers to live in their own cache lines.
- */
- union {
- __be32 d32;
- u8 d8[4];
- } data[2] ____cacheline_aligned;
-};
-
-enum ad5764_type {
- ID_AD5744,
- ID_AD5744R,
- ID_AD5764,
- ID_AD5764R,
-};
-
-#define AD5764_CHANNEL(_chan, _bits) { \
- .type = IIO_VOLTAGE, \
- .indexed = 1, \
- .output = 1, \
- .channel = (_chan), \
- .address = (_chan), \
- .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
- IIO_CHAN_INFO_OFFSET_SHARED_BIT | \
- IIO_CHAN_INFO_SCALE_SEPARATE_BIT | \
- IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT | \
- IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT, \
- .scan_type = IIO_ST('u', (_bits), 16, 16 - (_bits)) \
-}
-
-#define DECLARE_AD5764_CHANNELS(_name, _bits) \
-const struct iio_chan_spec _name##_channels[] = { \
- AD5764_CHANNEL(0, (_bits)), \
- AD5764_CHANNEL(1, (_bits)), \
- AD5764_CHANNEL(2, (_bits)), \
- AD5764_CHANNEL(3, (_bits)), \
-};
-
-static DECLARE_AD5764_CHANNELS(ad5764, 16);
-static DECLARE_AD5764_CHANNELS(ad5744, 14);
-
-static const struct ad5764_chip_info ad5764_chip_infos[] = {
- [ID_AD5744] = {
- .int_vref = 0,
- .channels = ad5744_channels,
- },
- [ID_AD5744R] = {
- .int_vref = 5000000,
- .channels = ad5744_channels,
- },
- [ID_AD5764] = {
- .int_vref = 0,
- .channels = ad5764_channels,
- },
- [ID_AD5764R] = {
- .int_vref = 5000000,
- .channels = ad5764_channels,
- },
-};
-
-static int ad5764_write(struct iio_dev *indio_dev, unsigned int reg,
- unsigned int val)
-{
- struct ad5764_state *st = iio_priv(indio_dev);
- int ret;
-
- mutex_lock(&indio_dev->mlock);
- st->data[0].d32 = cpu_to_be32((reg << 16) | val);
-
- ret = spi_write(st->spi, &st->data[0].d8[1], 3);
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static int ad5764_read(struct iio_dev *indio_dev, unsigned int reg,
- unsigned int *val)
-{
- struct ad5764_state *st = iio_priv(indio_dev);
- struct spi_message m;
- int ret;
- struct spi_transfer t[] = {
- {
- .tx_buf = &st->data[0].d8[1],
- .len = 3,
- .cs_change = 1,
- }, {
- .rx_buf = &st->data[1].d8[1],
- .len = 3,
- },
- };
-
- spi_message_init(&m);
- spi_message_add_tail(&t[0], &m);
- spi_message_add_tail(&t[1], &m);
-
- mutex_lock(&indio_dev->mlock);
-
- st->data[0].d32 = cpu_to_be32((1 << 23) | (reg << 16));
-
- ret = spi_sync(st->spi, &m);
- if (ret >= 0)
- *val = be32_to_cpu(st->data[1].d32) & 0xffff;
-
- mutex_unlock(&indio_dev->mlock);
-
- return ret;
-}
-
-static int ad5764_chan_info_to_reg(struct iio_chan_spec const *chan, long info)
-{
- switch (info) {
- case 0:
- return AD5764_REG_DATA(chan->address);
- case IIO_CHAN_INFO_CALIBBIAS:
- return AD5764_REG_OFFSET(chan->address);
- case IIO_CHAN_INFO_CALIBSCALE:
- return AD5764_REG_FINE_GAIN(chan->address);
- default:
- break;
- }
-
- return 0;
-}
-
-static int ad5764_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan, int val, int val2, long info)
-{
- const int max_val = (1 << chan->scan_type.realbits);
- unsigned int reg;
-
- switch (info) {
- case IIO_CHAN_INFO_RAW:
- if (val >= max_val || val < 0)
- return -EINVAL;
- val <<= chan->scan_type.shift;
- break;
- case IIO_CHAN_INFO_CALIBBIAS:
- if (val >= 128 || val < -128)
- return -EINVAL;
- break;
- case IIO_CHAN_INFO_CALIBSCALE:
- if (val >= 32 || val < -32)
- return -EINVAL;
- break;
- default:
- return -EINVAL;
- }
-
- reg = ad5764_chan_info_to_reg(chan, info);
- return ad5764_write(indio_dev, reg, (u16)val);
-}
-
-static int ad5764_get_channel_vref(struct ad5764_state *st,
- unsigned int channel)
-{
- if (st->chip_info->int_vref)
- return st->chip_info->int_vref;
- else
- return regulator_get_voltage(st->vref_reg[channel / 2].consumer);
-}
-
-static int ad5764_read_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan, int *val, int *val2, long info)
-{
- struct ad5764_state *st = iio_priv(indio_dev);
- unsigned long scale_uv;
- unsigned int reg;
- int vref;
- int ret;
-
- switch (info) {
- case IIO_CHAN_INFO_RAW:
- reg = AD5764_REG_DATA(chan->address);
- ret = ad5764_read(indio_dev, reg, val);
- if (ret < 0)
- return ret;
- *val >>= chan->scan_type.shift;
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_CALIBBIAS:
- reg = AD5764_REG_OFFSET(chan->address);
- ret = ad5764_read(indio_dev, reg, val);
- if (ret < 0)
- return ret;
- *val = sign_extend32(*val, 7);
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_CALIBSCALE:
- reg = AD5764_REG_FINE_GAIN(chan->address);
- ret = ad5764_read(indio_dev, reg, val);
- if (ret < 0)
- return ret;
- *val = sign_extend32(*val, 5);
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_SCALE:
- /* vout = 4 * vref + ((dac_code / 65535) - 0.5) */
- vref = ad5764_get_channel_vref(st, chan->channel);
- if (vref < 0)
- return vref;
-
- scale_uv = (vref * 4 * 100) >> chan->scan_type.realbits;
- *val = scale_uv / 100000;
- *val2 = (scale_uv % 100000) * 10;
- return IIO_VAL_INT_PLUS_MICRO;
- case IIO_CHAN_INFO_OFFSET:
- *val = -(1 << chan->scan_type.realbits) / 2;
- return IIO_VAL_INT;
- }
-
- return -EINVAL;
-}
-
-static const struct iio_info ad5764_info = {
- .read_raw = ad5764_read_raw,
- .write_raw = ad5764_write_raw,
- .driver_module = THIS_MODULE,
-};
-
-static int __devinit ad5764_probe(struct spi_device *spi)
-{
- enum ad5764_type type = spi_get_device_id(spi)->driver_data;
- struct iio_dev *indio_dev;
- struct ad5764_state *st;
- int ret;
-
- indio_dev = iio_device_alloc(sizeof(*st));
- if (indio_dev == NULL) {
- dev_err(&spi->dev, "Failed to allocate iio device\n");
- return -ENOMEM;
- }
-
- st = iio_priv(indio_dev);
- spi_set_drvdata(spi, indio_dev);
-
- st->spi = spi;
- st->chip_info = &ad5764_chip_infos[type];
-
- indio_dev->dev.parent = &spi->dev;
- indio_dev->name = spi_get_device_id(spi)->name;
- indio_dev->info = &ad5764_info;
- indio_dev->modes = INDIO_DIRECT_MODE;
- indio_dev->num_channels = AD5764_NUM_CHANNELS;
- indio_dev->channels = st->chip_info->channels;
-
- if (st->chip_info->int_vref == 0) {
- st->vref_reg[0].supply = "vrefAB";
- st->vref_reg[1].supply = "vrefCD";
-
- ret = regulator_bulk_get(&st->spi->dev,
- ARRAY_SIZE(st->vref_reg), st->vref_reg);
- if (ret) {
- dev_err(&spi->dev, "Failed to request vref regulators: %d\n",
- ret);
- goto error_free;
- }
-
- ret = regulator_bulk_enable(ARRAY_SIZE(st->vref_reg),
- st->vref_reg);
- if (ret) {
- dev_err(&spi->dev, "Failed to enable vref regulators: %d\n",
- ret);
- goto error_free_reg;
- }
- }
-
- ret = iio_device_register(indio_dev);
- if (ret) {
- dev_err(&spi->dev, "Failed to register iio device: %d\n", ret);
- goto error_disable_reg;
- }
-
- return 0;
-
-error_disable_reg:
- if (st->chip_info->int_vref == 0)
- regulator_bulk_disable(ARRAY_SIZE(st->vref_reg), st->vref_reg);
-error_free_reg:
- if (st->chip_info->int_vref == 0)
- regulator_bulk_free(ARRAY_SIZE(st->vref_reg), st->vref_reg);
-error_free:
- iio_device_free(indio_dev);
-
- return ret;
-}
-
-static int __devexit ad5764_remove(struct spi_device *spi)
-{
- struct iio_dev *indio_dev = spi_get_drvdata(spi);
- struct ad5764_state *st = iio_priv(indio_dev);
-
- iio_device_unregister(indio_dev);
-
- if (st->chip_info->int_vref == 0) {
- regulator_bulk_disable(ARRAY_SIZE(st->vref_reg), st->vref_reg);
- regulator_bulk_free(ARRAY_SIZE(st->vref_reg), st->vref_reg);
- }
-
- iio_device_free(indio_dev);
-
- return 0;
-}
-
-static const struct spi_device_id ad5764_ids[] = {
- { "ad5744", ID_AD5744 },
- { "ad5744r", ID_AD5744R },
- { "ad5764", ID_AD5764 },
- { "ad5764r", ID_AD5764R },
- { }
-};
-MODULE_DEVICE_TABLE(spi, ad5764_ids);
-
-static struct spi_driver ad5764_driver = {
- .driver = {
- .name = "ad5764",
- .owner = THIS_MODULE,
- },
- .probe = ad5764_probe,
- .remove = __devexit_p(ad5764_remove),
- .id_table = ad5764_ids,
-};
-module_spi_driver(ad5764_driver);
-
-MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
-MODULE_DESCRIPTION("Analog Devices AD5744/AD5744R/AD5764/AD5764R DAC");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-/*
- * AD5760, AD5780, AD5781, AD5790, AD5791 Voltage Output Digital to Analog
- * Converter
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#include <linux/interrupt.h>
-#include <linux/fs.h>
-#include <linux/device.h>
-#include <linux/kernel.h>
-#include <linux/spi/spi.h>
-#include <linux/slab.h>
-#include <linux/sysfs.h>
-#include <linux/regulator/consumer.h>
-#include <linux/module.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include "dac.h"
-#include "ad5791.h"
-
-static int ad5791_spi_write(struct spi_device *spi, u8 addr, u32 val)
-{
- union {
- u32 d32;
- u8 d8[4];
- } data;
-
- data.d32 = cpu_to_be32(AD5791_CMD_WRITE |
- AD5791_ADDR(addr) |
- (val & AD5791_DAC_MASK));
-
- return spi_write(spi, &data.d8[1], 3);
-}
-
-static int ad5791_spi_read(struct spi_device *spi, u8 addr, u32 *val)
-{
- union {
- u32 d32;
- u8 d8[4];
- } data[3];
- int ret;
- struct spi_message msg;
- struct spi_transfer xfers[] = {
- {
- .tx_buf = &data[0].d8[1],
- .bits_per_word = 8,
- .len = 3,
- .cs_change = 1,
- }, {
- .tx_buf = &data[1].d8[1],
- .rx_buf = &data[2].d8[1],
- .bits_per_word = 8,
- .len = 3,
- },
- };
-
- data[0].d32 = cpu_to_be32(AD5791_CMD_READ |
- AD5791_ADDR(addr));
- data[1].d32 = cpu_to_be32(AD5791_ADDR(AD5791_ADDR_NOOP));
-
- spi_message_init(&msg);
- spi_message_add_tail(&xfers[0], &msg);
- spi_message_add_tail(&xfers[1], &msg);
- ret = spi_sync(spi, &msg);
-
- *val = be32_to_cpu(data[2].d32);
-
- return ret;
-}
-
-#define AD5791_CHAN(bits, shift) { \
- .type = IIO_VOLTAGE, \
- .output = 1, \
- .indexed = 1, \
- .address = AD5791_ADDR_DAC0, \
- .channel = 0, \
- .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
- IIO_CHAN_INFO_SCALE_SHARED_BIT | \
- IIO_CHAN_INFO_OFFSET_SHARED_BIT, \
- .scan_type = IIO_ST('u', bits, 24, shift) \
-}
-
-static const struct iio_chan_spec ad5791_channels[] = {
- [ID_AD5760] = AD5791_CHAN(16, 4),
- [ID_AD5780] = AD5791_CHAN(18, 2),
- [ID_AD5781] = AD5791_CHAN(18, 2),
- [ID_AD5791] = AD5791_CHAN(20, 0)
-};
-
-static ssize_t ad5791_read_powerdown_mode(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5791_state *st = iio_priv(indio_dev);
-
- const char mode[][14] = {"6kohm_to_gnd", "three_state"};
-
- return sprintf(buf, "%s\n", mode[st->pwr_down_mode]);
-}
-
-static ssize_t ad5791_write_powerdown_mode(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5791_state *st = iio_priv(indio_dev);
- int ret;
-
- if (sysfs_streq(buf, "6kohm_to_gnd"))
- st->pwr_down_mode = AD5791_DAC_PWRDN_6K;
- else if (sysfs_streq(buf, "three_state"))
- st->pwr_down_mode = AD5791_DAC_PWRDN_3STATE;
- else
- ret = -EINVAL;
-
- return ret ? ret : len;
-}
-
-static ssize_t ad5791_read_dac_powerdown(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5791_state *st = iio_priv(indio_dev);
-
- return sprintf(buf, "%d\n", st->pwr_down);
-}
-
-static ssize_t ad5791_write_dac_powerdown(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- long readin;
- int ret;
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ad5791_state *st = iio_priv(indio_dev);
-
- ret = strict_strtol(buf, 10, &readin);
- if (ret)
- return ret;
-
- if (readin == 0) {
- st->pwr_down = false;
- st->ctrl &= ~(AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
- } else if (readin == 1) {
- st->pwr_down = true;
- if (st->pwr_down_mode == AD5791_DAC_PWRDN_6K)
- st->ctrl |= AD5791_CTRL_OPGND;
- else if (st->pwr_down_mode == AD5791_DAC_PWRDN_3STATE)
- st->ctrl |= AD5791_CTRL_DACTRI;
- } else
- ret = -EINVAL;
-
- ret = ad5791_spi_write(st->spi, AD5791_ADDR_CTRL, st->ctrl);
-
- return ret ? ret : len;
-}
-
-static IIO_DEVICE_ATTR(out_voltage_powerdown_mode, S_IRUGO |
- S_IWUSR, ad5791_read_powerdown_mode,
- ad5791_write_powerdown_mode, 0);
-
-static IIO_CONST_ATTR(out_voltage_powerdown_mode_available,
- "6kohm_to_gnd three_state");
-
-#define IIO_DEV_ATTR_DAC_POWERDOWN(_num, _show, _store, _addr) \
- IIO_DEVICE_ATTR(out_voltage##_num##_powerdown, \
- S_IRUGO | S_IWUSR, _show, _store, _addr)
-
-static IIO_DEV_ATTR_DAC_POWERDOWN(0, ad5791_read_dac_powerdown,
- ad5791_write_dac_powerdown, 0);
-
-static struct attribute *ad5791_attributes[] = {
- &iio_dev_attr_out_voltage0_powerdown.dev_attr.attr,
- &iio_dev_attr_out_voltage_powerdown_mode.dev_attr.attr,
- &iio_const_attr_out_voltage_powerdown_mode_available.dev_attr.attr,
- NULL,
-};
-
-static const struct attribute_group ad5791_attribute_group = {
- .attrs = ad5791_attributes,
-};
-
-static int ad5791_get_lin_comp(unsigned int span)
-{
- if (span <= 10000)
- return AD5791_LINCOMP_0_10;
- else if (span <= 12000)
- return AD5791_LINCOMP_10_12;
- else if (span <= 16000)
- return AD5791_LINCOMP_12_16;
- else if (span <= 19000)
- return AD5791_LINCOMP_16_19;
- else
- return AD5791_LINCOMP_19_20;
-}
-
-static int ad5780_get_lin_comp(unsigned int span)
-{
- if (span <= 10000)
- return AD5780_LINCOMP_0_10;
- else
- return AD5780_LINCOMP_10_20;
-}
-static const struct ad5791_chip_info ad5791_chip_info_tbl[] = {
- [ID_AD5760] = {
- .get_lin_comp = ad5780_get_lin_comp,
- },
- [ID_AD5780] = {
- .get_lin_comp = ad5780_get_lin_comp,
- },
- [ID_AD5781] = {
- .get_lin_comp = ad5791_get_lin_comp,
- },
- [ID_AD5791] = {
- .get_lin_comp = ad5791_get_lin_comp,
- },
-};
-
-static int ad5791_read_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int *val,
- int *val2,
- long m)
-{
- struct ad5791_state *st = iio_priv(indio_dev);
- u64 val64;
- int ret;
-
- switch (m) {
- case IIO_CHAN_INFO_RAW:
- ret = ad5791_spi_read(st->spi, chan->address, val);
- if (ret)
- return ret;
- *val &= AD5791_DAC_MASK;
- *val >>= chan->scan_type.shift;
- return IIO_VAL_INT;
- case IIO_CHAN_INFO_SCALE:
- *val = 0;
- *val2 = (((u64)st->vref_mv) * 1000000ULL) >> chan->scan_type.realbits;
- return IIO_VAL_INT_PLUS_MICRO;
- case IIO_CHAN_INFO_OFFSET:
- val64 = (((u64)st->vref_neg_mv) << chan->scan_type.realbits);
- do_div(val64, st->vref_mv);
- *val = -val64;
- return IIO_VAL_INT;
- default:
- return -EINVAL;
- }
-
-};
-
-
-static int ad5791_write_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *chan,
- int val,
- int val2,
- long mask)
-{
- struct ad5791_state *st = iio_priv(indio_dev);
-
- switch (mask) {
- case IIO_CHAN_INFO_RAW:
- val &= AD5791_RES_MASK(chan->scan_type.realbits);
- val <<= chan->scan_type.shift;
-
- return ad5791_spi_write(st->spi, chan->address, val);
-
- default:
- return -EINVAL;
- }
-}
-
-static const struct iio_info ad5791_info = {
- .read_raw = &ad5791_read_raw,
- .write_raw = &ad5791_write_raw,
- .attrs = &ad5791_attribute_group,
- .driver_module = THIS_MODULE,
-};
-
-static int __devinit ad5791_probe(struct spi_device *spi)
-{
- struct ad5791_platform_data *pdata = spi->dev.platform_data;
- struct iio_dev *indio_dev;
- struct ad5791_state *st;
- int ret, pos_voltage_uv = 0, neg_voltage_uv = 0;
-
- indio_dev = iio_device_alloc(sizeof(*st));
- if (indio_dev == NULL) {
- ret = -ENOMEM;
- goto error_ret;
- }
- st = iio_priv(indio_dev);
- st->reg_vdd = regulator_get(&spi->dev, "vdd");
- if (!IS_ERR(st->reg_vdd)) {
- ret = regulator_enable(st->reg_vdd);
- if (ret)
- goto error_put_reg_pos;
-
- pos_voltage_uv = regulator_get_voltage(st->reg_vdd);
- }
-
- st->reg_vss = regulator_get(&spi->dev, "vss");
- if (!IS_ERR(st->reg_vss)) {
- ret = regulator_enable(st->reg_vss);
- if (ret)
- goto error_put_reg_neg;
-
- neg_voltage_uv = regulator_get_voltage(st->reg_vss);
- }
-
- st->pwr_down = true;
- st->spi = spi;
-
- if (!IS_ERR(st->reg_vss) && !IS_ERR(st->reg_vdd)) {
- st->vref_mv = (pos_voltage_uv + neg_voltage_uv) / 1000;
- st->vref_neg_mv = neg_voltage_uv / 1000;
- } else if (pdata) {
- st->vref_mv = pdata->vref_pos_mv + pdata->vref_neg_mv;
- st->vref_neg_mv = pdata->vref_neg_mv;
- } else {
- dev_warn(&spi->dev, "reference voltage unspecified\n");
- }
-
- ret = ad5791_spi_write(spi, AD5791_ADDR_SW_CTRL, AD5791_SWCTRL_RESET);
- if (ret)
- goto error_disable_reg_neg;
-
- st->chip_info = &ad5791_chip_info_tbl[spi_get_device_id(spi)
- ->driver_data];
-
-
- st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info->get_lin_comp(st->vref_mv))
- | ((pdata && pdata->use_rbuf_gain2) ? 0 : AD5791_CTRL_RBUF) |
- AD5791_CTRL_BIN2SC;
-
- ret = ad5791_spi_write(spi, AD5791_ADDR_CTRL, st->ctrl |
- AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
- if (ret)
- goto error_disable_reg_neg;
-
- spi_set_drvdata(spi, indio_dev);
- indio_dev->dev.parent = &spi->dev;
- indio_dev->info = &ad5791_info;
- indio_dev->modes = INDIO_DIRECT_MODE;
- indio_dev->channels
- = &ad5791_channels[spi_get_device_id(spi)->driver_data];
- indio_dev->num_channels = 1;
- indio_dev->name = spi_get_device_id(st->spi)->name;
- ret = iio_device_register(indio_dev);
- if (ret)
- goto error_disable_reg_neg;
-
- return 0;
-
-error_disable_reg_neg:
- if (!IS_ERR(st->reg_vss))
- regulator_disable(st->reg_vss);
-error_put_reg_neg:
- if (!IS_ERR(st->reg_vss))
- regulator_put(st->reg_vss);
-
- if (!IS_ERR(st->reg_vdd))
- regulator_disable(st->reg_vdd);
-error_put_reg_pos:
- if (!IS_ERR(st->reg_vdd))
- regulator_put(st->reg_vdd);
- iio_device_free(indio_dev);
-error_ret:
-
- return ret;
-}
-
-static int __devexit ad5791_remove(struct spi_device *spi)
-{
- struct iio_dev *indio_dev = spi_get_drvdata(spi);
- struct ad5791_state *st = iio_priv(indio_dev);
-
- iio_device_unregister(indio_dev);
- if (!IS_ERR(st->reg_vdd)) {
- regulator_disable(st->reg_vdd);
- regulator_put(st->reg_vdd);
- }
-
- if (!IS_ERR(st->reg_vss)) {
- regulator_disable(st->reg_vss);
- regulator_put(st->reg_vss);
- }
- iio_device_free(indio_dev);
-
- return 0;
-}
-
-static const struct spi_device_id ad5791_id[] = {
- {"ad5760", ID_AD5760},
- {"ad5780", ID_AD5780},
- {"ad5781", ID_AD5781},
- {"ad5790", ID_AD5791},
- {"ad5791", ID_AD5791},
- {}
-};
-MODULE_DEVICE_TABLE(spi, ad5791_id);
-
-static struct spi_driver ad5791_driver = {
- .driver = {
- .name = "ad5791",
- .owner = THIS_MODULE,
- },
- .probe = ad5791_probe,
- .remove = __devexit_p(ad5791_remove),
- .id_table = ad5791_id,
-};
-module_spi_driver(ad5791_driver);
-
-MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
-MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC");
-MODULE_LICENSE("GPL v2");
+++ /dev/null
-/*
- * AD5791 SPI DAC driver
- *
- * Copyright 2011 Analog Devices Inc.
- *
- * Licensed under the GPL-2.
- */
-
-#ifndef SPI_AD5791_H_
-#define SPI_AD5791_H_
-
-#define AD5791_RES_MASK(x) ((1 << (x)) - 1)
-#define AD5791_DAC_MASK AD5791_RES_MASK(20)
-#define AD5791_DAC_MSB (1 << 19)
-
-#define AD5791_CMD_READ (1 << 23)
-#define AD5791_CMD_WRITE (0 << 23)
-#define AD5791_ADDR(addr) ((addr) << 20)
-
-/* Registers */
-#define AD5791_ADDR_NOOP 0
-#define AD5791_ADDR_DAC0 1
-#define AD5791_ADDR_CTRL 2
-#define AD5791_ADDR_CLRCODE 3
-#define AD5791_ADDR_SW_CTRL 4
-
-/* Control Register */
-#define AD5791_CTRL_RBUF (1 << 1)
-#define AD5791_CTRL_OPGND (1 << 2)
-#define AD5791_CTRL_DACTRI (1 << 3)
-#define AD5791_CTRL_BIN2SC (1 << 4)
-#define AD5791_CTRL_SDODIS (1 << 5)
-#define AD5761_CTRL_LINCOMP(x) ((x) << 6)
-
-#define AD5791_LINCOMP_0_10 0
-#define AD5791_LINCOMP_10_12 1
-#define AD5791_LINCOMP_12_16 2
-#define AD5791_LINCOMP_16_19 3
-#define AD5791_LINCOMP_19_20 12
-
-#define AD5780_LINCOMP_0_10 0
-#define AD5780_LINCOMP_10_20 12
-
-/* Software Control Register */
-#define AD5791_SWCTRL_LDAC (1 << 0)
-#define AD5791_SWCTRL_CLR (1 << 1)
-#define AD5791_SWCTRL_RESET (1 << 2)
-
-#define AD5791_DAC_PWRDN_6K 0
-#define AD5791_DAC_PWRDN_3STATE 1
-
-/*
- * TODO: struct ad5791_platform_data needs to go into include/linux/iio
- */
-
-/**
- * struct ad5791_platform_data - platform specific information
- * @vref_pos_mv: Vdd Positive Analog Supply Volatge (mV)
- * @vref_neg_mv: Vdd Negative Analog Supply Volatge (mV)
- * @use_rbuf_gain2: ext. amplifier connected in gain of two configuration
- */
-
-struct ad5791_platform_data {
- u16 vref_pos_mv;
- u16 vref_neg_mv;
- bool use_rbuf_gain2;
-};
-
-/**
- * struct ad5791_chip_info - chip specific information
- * @get_lin_comp: function pointer to the device specific function
- */
-
-struct ad5791_chip_info {
- int (*get_lin_comp) (unsigned int span);
-};
-
-/**
- * struct ad5791_state - driver instance specific data
- * @us: spi_device
- * @reg_vdd: positive supply regulator
- * @reg_vss: negative supply regulator
- * @chip_info: chip model specific constants
- * @vref_mv: actual reference voltage used
- * @vref_neg_mv: voltage of the negative supply
- * @pwr_down_mode current power down mode
- */
-
-struct ad5791_state {
- struct spi_device *spi;
- struct regulator *reg_vdd;
- struct regulator *reg_vss;
- const struct ad5791_chip_info *chip_info;
- unsigned short vref_mv;
- unsigned int vref_neg_mv;
- unsigned ctrl;
- unsigned pwr_down_mode;
- bool pwr_down;
-};
-
-/**
- * ad5791_supported_device_ids:
- */
-
-enum ad5791_supported_device_ids {
- ID_AD5760,
- ID_AD5780,
- ID_AD5781,
- ID_AD5791,
-};
-
-#endif /* SPI_AD5791_H_ */
+++ /dev/null
-/*
- * dac.h - sysfs attributes associated with DACs
- */
-
-#define IIO_DEV_ATTR_OUT_RAW(_num, _store, _addr) \
- IIO_DEVICE_ATTR(out_voltage##_num##_raw, S_IWUSR, NULL, _store, _addr)
+++ /dev/null
-/*
- * max517.c - Support for Maxim MAX517, MAX518 and MAX519
- *
- * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/jiffies.h>
-#include <linux/i2c.h>
-#include <linux/err.h>
-
-#include <linux/iio/iio.h>
-#include <linux/iio/sysfs.h>
-#include "dac.h"
-
-#include "max517.h"
-
-#define MAX517_DRV_NAME "max517"
-
-/* Commands */
-#define COMMAND_CHANNEL0 0x00
-#define COMMAND_CHANNEL1 0x01 /* for MAX518 and MAX519 */
-#define COMMAND_PD 0x08 /* Power Down */
-
-enum max517_device_ids {
- ID_MAX517,
- ID_MAX518,
- ID_MAX519,
-};
-
-struct max517_data {
- struct iio_dev *indio_dev;
- struct i2c_client *client;
- unsigned short vref_mv[2];
-};
-
-/*
- * channel: bit 0: channel 1
- * bit 1: channel 2
- * (this way, it's possible to set both channels at once)
- */
-static ssize_t max517_set_value(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t count, int channel)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct max517_data *data = iio_priv(indio_dev);
- struct i2c_client *client = data->client;
- u8 outbuf[4]; /* 1x or 2x command + value */
- int outbuf_size = 0;
- int res;
- long val;
-
- res = strict_strtol(buf, 10, &val);
-
- if (res)
- return res;
-
- if (val < 0 || val > 255)
- return -EINVAL;
-
- if (channel & 1) {
- outbuf[outbuf_size++] = COMMAND_CHANNEL0;
- outbuf[outbuf_size++] = val;
- }
- if (channel & 2) {
- outbuf[outbuf_size++] = COMMAND_CHANNEL1;
- outbuf[outbuf_size++] = val;
- }
-
- /*
- * At this point, there are always 1 or 2 two-byte commands in
- * outbuf. With 2 commands, the device can set two outputs
- * simultaneously, latching the values upon the end of the I2C
- * transfer.
- */
-
- res = i2c_master_send(client, outbuf, outbuf_size);
- if (res < 0)
- return res;
-
- return count;
-}
-
-static ssize_t max517_set_value_1(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t count)
-{
- return max517_set_value(dev, attr, buf, count, 1);
-}
-static IIO_DEV_ATTR_OUT_RAW(1, max517_set_value_1, 0);
-
-static ssize_t max517_set_value_2(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t count)
-{
- return max517_set_value(dev, attr, buf, count, 2);
-}
-static IIO_DEV_ATTR_OUT_RAW(2, max517_set_value_2, 1);
-
-static ssize_t max517_set_value_both(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t count)
-{
- return max517_set_value(dev, attr, buf, count, 3);
-}
-static IIO_DEVICE_ATTR_NAMED(out_voltage1and2_raw,
- out_voltage1&2_raw, S_IWUSR, NULL,
- max517_set_value_both, -1);
-
-static ssize_t max517_show_scale(struct device *dev,
- struct device_attribute *attr,
- char *buf, int channel)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct max517_data *data = iio_priv(indio_dev);
- /* Corresponds to Vref / 2^(bits) */
- unsigned int scale_uv = (data->vref_mv[channel - 1] * 1000) >> 8;
-
- return sprintf(buf, "%d.%03d\n", scale_uv / 1000, scale_uv % 1000);
-}
-
-static ssize_t max517_show_scale1(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- return max517_show_scale(dev, attr, buf, 1);
-}
-static IIO_DEVICE_ATTR(out_voltage1_scale, S_IRUGO,
- max517_show_scale1, NULL, 0);
-
-static ssize_t max517_show_scale2(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- return max517_show_scale(dev, attr, buf, 2);
-}
-static IIO_DEVICE_ATTR(out_voltage2_scale, S_IRUGO,
- max517_show_scale2, NULL, 0);
-
-/* On MAX517 variant, we have one output */
-static struct attribute *max517_attributes[] = {
- &iio_dev_attr_out_voltage1_raw.dev_attr.attr,
- &iio_dev_attr_out_voltage1_scale.dev_attr.attr,
- NULL
-};
-
-static struct attribute_group max517_attribute_group = {
- .attrs = max517_attributes,
-};
-
-/* On MAX518 and MAX519 variant, we have two outputs */
-static struct attribute *max518_attributes[] = {
- &iio_dev_attr_out_voltage1_raw.dev_attr.attr,
- &iio_dev_attr_out_voltage1_scale.dev_attr.attr,
- &iio_dev_attr_out_voltage2_raw.dev_attr.attr,
- &iio_dev_attr_out_voltage2_scale.dev_attr.attr,
- &iio_dev_attr_out_voltage1and2_raw.dev_attr.attr,
- NULL
-};
-
-static struct attribute_group max518_attribute_group = {
- .attrs = max518_attributes,
-};
-
-#ifdef CONFIG_PM_SLEEP
-static int max517_suspend(struct device *dev)
-{
- u8 outbuf = COMMAND_PD;
-
- return i2c_master_send(to_i2c_client(dev), &outbuf, 1);
-}
-
-static int max517_resume(struct device *dev)
-{
- u8 outbuf = 0;
-
- return i2c_master_send(to_i2c_client(dev), &outbuf, 1);
-}
-
-static SIMPLE_DEV_PM_OPS(max517_pm_ops, max517_suspend, max517_resume);
-#define MAX517_PM_OPS (&max517_pm_ops)
-#else
-#define MAX517_PM_OPS NULL
-#endif
-
-static const struct iio_info max517_info = {
- .attrs = &max517_attribute_group,
- .driver_module = THIS_MODULE,
-};
-
-static const struct iio_info max518_info = {
- .attrs = &max518_attribute_group,
- .driver_module = THIS_MODULE,
-};
-
-static int max517_probe(struct i2c_client *client,
- const struct i2c_device_id *id)
-{
- struct max517_data *data;
- struct iio_dev *indio_dev;
- struct max517_platform_data *platform_data = client->dev.platform_data;
- int err;
-
- indio_dev = iio_device_alloc(sizeof(*data));
- if (indio_dev == NULL) {
- err = -ENOMEM;
- goto exit;
- }
- data = iio_priv(indio_dev);
- i2c_set_clientdata(client, indio_dev);
- data->client = client;
-
- /* establish that the iio_dev is a child of the i2c device */
- indio_dev->dev.parent = &client->dev;
-
- /* reduced attribute set for MAX517 */
- if (id->driver_data == ID_MAX517)
- indio_dev->info = &max517_info;
- else
- indio_dev->info = &max518_info;
- indio_dev->modes = INDIO_DIRECT_MODE;
-
- /*
- * Reference voltage on MAX518 and default is 5V, else take vref_mv
- * from platform_data
- */
- if (id->driver_data == ID_MAX518 || !platform_data) {
- data->vref_mv[0] = data->vref_mv[1] = 5000; /* mV */
- } else {
- data->vref_mv[0] = platform_data->vref_mv[0];
- data->vref_mv[1] = platform_data->vref_mv[1];
- }
-
- err = iio_device_register(indio_dev);
- if (err)
- goto exit_free_device;
-
- dev_info(&client->dev, "DAC registered\n");
-
- return 0;
-
-exit_free_device:
- iio_device_free(indio_dev);
-exit:
- return err;
-}
-
-static int max517_remove(struct i2c_client *client)
-{
- iio_device_unregister(i2c_get_clientdata(client));
- iio_device_free(i2c_get_clientdata(client));
-
- return 0;
-}
-
-static const struct i2c_device_id max517_id[] = {
- { "max517", ID_MAX517 },
- { "max518", ID_MAX518 },
- { "max519", ID_MAX519 },
- { }
-};
-MODULE_DEVICE_TABLE(i2c, max517_id);
-
-static struct i2c_driver max517_driver = {
- .driver = {
- .name = MAX517_DRV_NAME,
- .pm = MAX517_PM_OPS,
- },
- .probe = max517_probe,
- .remove = max517_remove,
- .id_table = max517_id,
-};
-module_i2c_driver(max517_driver);
-
-MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
-MODULE_DESCRIPTION("MAX517/MAX518/MAX519 8-bit DAC");
-MODULE_LICENSE("GPL");
+++ /dev/null
-/*
- * MAX517 DAC driver
- *
- * Copyright 2011 Roland Stigge <stigge@antcom.de>
- *
- * Licensed under the GPL-2 or later.
- */
-#ifndef IIO_DAC_MAX517_H_
-#define IIO_DAC_MAX517_H_
-
-/*
- * TODO: struct max517_platform_data needs to go into include/linux/iio
- */
-
-struct max517_platform_data {
- u16 vref_mv[2];
-};
-
-#endif /* IIO_DAC_MAX517_H_ */
long mask)
{
int ret = -EINVAL;
- u16 ut;
+ u16 ut = 0;
/* Take the iio_dev status lock */
mutex_lock(&indio_dev->mlock);
if (ret)
goto err_ret;
- flush_scheduled_work();
-
adis16260_remove_trigger(indio_dev);
iio_buffer_unregister(indio_dev);
adis16260_unconfigure_ring(indio_dev);
/*
* A few elements needed to fake a bus for this driver
- * Note instances parmeter controls how many of these
+ * Note instances parameter controls how many of these
* dummy devices are registered.
*/
static unsigned instances = 1;
.scan_index = accelx,
.scan_type = { /* Description of storage in buffer */
.sign = 's', /* signed */
- .realbits = 16, /* 12 bits */
+ .realbits = 16, /* 16 bits */
.storagebits = 16, /* 16 bits used for storage */
.shift = 0, /* zero shift */
},
* iio_dummy_write_raw() - data write function.
* @indio_dev: the struct iio_dev associated with this device instance
* @chan: the channel whose data is to be read
- * @val: first element of returned value (typically INT)
- * @val2: second element of returned value (typically MICRO)
- * @mask: what we actually want to read. 0 is the channel, everything else
+ * @val: first element of value to set (typically INT)
+ * @val2: second element of value to set (typically MICRO)
+ * @mask: what we actually want to write. 0 is the channel, everything else
* is as per the info_mask in iio_chan_spec.
*
* Note that all raw writes are assumed IIO_VAL_INT and info mask elements
* software culled hardware scans:
* occasionally a driver may process the nearest hardware
* scan to avoid storing elements that are not desired. This
- * is the fidliest option by far.
- * Here lets pretend we have random access. And the values are
+ * is the fiddliest option by far.
+ * Here let's pretend we have random access. And the values are
* in the constant table fakedata.
*/
int i, j;
for (i = 0, j = 0;
i < bitmap_weight(indio_dev->active_scan_mask,
indio_dev->masklength);
- i++) {
+ i++, j++) {
j = find_next_bit(buffer->scan_mask,
- indio_dev->masklength, j + 1);
- /* random access read form the 'device' */
+ indio_dev->masklength, j);
+ /* random access read from the 'device' */
data[i] = fakedata[j];
len += 2;
}
}
- /* Store a timestampe at an 8 byte boundary */
+ /* Store the timestamp at an 8 byte aligned offset */
if (indio_dev->scan_timestamp)
- *(s64 *)(((phys_addr_t)data + len
- + sizeof(s64) - 1) & ~(sizeof(s64) - 1))
+ *(s64 *)((phys_addr_t)data + ALIGN(len, sizeof(s64)))
= iio_get_time_ns();
buffer->access->store_to(buffer, (u8 *)data, pf->timestamp);
#define ADIS16350_ZTEMP_OUT 0x14 /* Z-axis gyroscope temperature measurement */
#define ADIS16300_PITCH_OUT 0x12 /* X axis inclinometer output measurement */
-#define ADIS16300_ROLL_OUT 0x12 /* Y axis inclinometer output measurement */
+#define ADIS16300_ROLL_OUT 0x14 /* Y axis inclinometer output measurement */
+#define ADIS16300_AUX_ADC 0x16 /* Auxiliary ADC measurement */
/* Calibration parameters */
#define ADIS16400_XGYRO_OFF 0x1A /* X-axis gyroscope bias offset factor */
temp,
temp0, temp1, temp2,
in1,
+ in2,
incli_x,
incli_y,
};
-static u8 adis16400_addresses[17][2] = {
+static u8 adis16400_addresses[18][2] = {
[in_supply] = { ADIS16400_SUPPLY_OUT },
[gyro_x] = { ADIS16400_XGYRO_OUT, ADIS16400_XGYRO_OFF },
[gyro_y] = { ADIS16400_YGYRO_OUT, ADIS16400_YGYRO_OFF },
[temp0] = { ADIS16350_XTEMP_OUT },
[temp1] = { ADIS16350_YTEMP_OUT },
[temp2] = { ADIS16350_ZTEMP_OUT },
- [in1] = { ADIS16400_AUX_ADC },
+ [in1] = { ADIS16300_AUX_ADC },
+ [in2] = { ADIS16400_AUX_ADC },
[incli_x] = { ADIS16300_PITCH_OUT },
[incli_y] = { ADIS16300_ROLL_OUT }
};
.channel = 1,
.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
- .address = in1,
+ .address = in2,
.scan_index = ADIS16400_SCAN_ADC_0,
.scan_type = IIO_ST('s', 12, 16, 0),
},
.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
IIO_CHAN_INFO_OFFSET_SEPARATE_BIT |
IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
- .address = temp,
+ .address = temp0,
.scan_index = ADIS16400_SCAN_TEMP,
.scan_type = IIO_ST('s', 12, 16, 0),
}, {
.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT |
IIO_CHAN_INFO_SCALE_SHARED_BIT,
- .address = accel_z,
- .scan_index = ADIS16400_SCAN_ACC_Z,
+ .address = temp0,
+ .scan_index = ADIS16400_SCAN_TEMP,
.scan_type = IIO_ST('s', 14, 16, 0),
},
IIO_CHAN_SOFT_TIMESTAMP(12)
}
/* proximity scheme */
-static ssize_t show_prox_infrared_supression(struct device *dev,
+static ssize_t show_prox_infrared_suppression(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
struct isl29018_chip *chip = iio_priv(indio_dev);
/* return the "proximity scheme" i.e. if the chip does on chip
- infrared supression (1 means perform on chip supression) */
+ infrared suppression (1 means perform on chip suppression) */
return sprintf(buf, "%d\n", chip->prox_scheme);
}
-static ssize_t store_prox_infrared_supression(struct device *dev,
+static ssize_t store_prox_infrared_suppression(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct iio_dev *indio_dev = dev_to_iio_dev(dev);
}
/* get the "proximity scheme" i.e. if the chip does on chip
- infrared supression (1 means perform on chip supression) */
+ infrared suppression (1 means perform on chip suppression) */
mutex_lock(&chip->lock);
chip->prox_scheme = (int)lval;
mutex_unlock(&chip->lock);
static IIO_CONST_ATTR(adc_resolution_available, "4 8 12 16");
static IIO_DEVICE_ATTR(adc_resolution, S_IRUGO | S_IWUSR,
show_resolution, store_resolution, 0);
-static IIO_DEVICE_ATTR(proximity_on_chip_ambient_infrared_supression,
+static IIO_DEVICE_ATTR(proximity_on_chip_ambient_infrared_suppression,
S_IRUGO | S_IWUSR,
- show_prox_infrared_supression,
- store_prox_infrared_supression, 0);
+ show_prox_infrared_suppression,
+ store_prox_infrared_suppression, 0);
#define ISL29018_DEV_ATTR(name) (&iio_dev_attr_##name.dev_attr.attr)
#define ISL29018_CONST_ATTR(name) (&iio_const_attr_##name.dev_attr.attr)
ISL29018_CONST_ATTR(range_available),
ISL29018_DEV_ATTR(adc_resolution),
ISL29018_CONST_ATTR(adc_resolution_available),
- ISL29018_DEV_ATTR(proximity_on_chip_ambient_infrared_supression),
+ ISL29018_DEV_ATTR(proximity_on_chip_ambient_infrared_suppression),
NULL
};
return -EINVAL;
}
- /* determine als integration regster */
+ /* determine als integration register */
als_count = (chip->taos_settings.als_time * 100 + 135) / 270;
if (als_count == 0)
als_count = 1; /* ensure at least one cycle */
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/module.h>
-#include <linux/version.h>
#include <linux/iio/events.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
return -EINVAL;
}
- /* determine als integration regster */
+ /* determine als integration register */
als_count = (chip->tsl2x7x_settings.als_time * 100 + 135) / 270;
if (als_count == 0)
als_count = 1; /* ensure at least one cycle */
config SENSORS_AK8975
tristate "Asahi Kasei AK8975 3-Axis Magnetometer"
depends on I2C
- depends on GENERIC_GPIO
+ depends on GPIOLIB
help
Say yes here to build support for Asahi Kasei AK8975 3-Axis
Magnetometer.
struct mutex lock;
u8 asa[3];
long raw_to_gauss[3];
- bool mode;
u8 reg_cache[AK8975_MAX_REGS];
int eoc_gpio;
int eoc_irq;
return ret;
}
+ /* After reading fuse ROM data set power-down mode */
+ ret = ak8975_write_data(client,
+ AK8975_REG_CNTL,
+ AK8975_REG_CNTL_MODE_POWER_DOWN,
+ AK8975_REG_CNTL_MODE_MASK,
+ AK8975_REG_CNTL_MODE_SHIFT);
+ if (ret < 0) {
+ dev_err(&client->dev, "Error in setting power-down mode\n");
+ return ret;
+ }
+
/*
* Precalculate scale factor (in Gauss units) for each axis and
* store in the device data.
return 0;
}
-/*
- * Shows the device's mode. 0 = off, 1 = on.
- */
-static ssize_t show_mode(struct device *dev, struct device_attribute *devattr,
- char *buf)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ak8975_data *data = iio_priv(indio_dev);
-
- return sprintf(buf, "%u\n", data->mode);
-}
-
-/*
- * Sets the device's mode. 0 = off, 1 = on. The device's mode must be on
- * for the magn raw attributes to be available.
- */
-static ssize_t store_mode(struct device *dev, struct device_attribute *devattr,
- const char *buf, size_t count)
-{
- struct iio_dev *indio_dev = dev_to_iio_dev(dev);
- struct ak8975_data *data = iio_priv(indio_dev);
- struct i2c_client *client = data->client;
- bool value;
- int ret;
-
- /* Convert mode string and do some basic sanity checking on it.
- only 0 or 1 are valid. */
- ret = strtobool(buf, &value);
- if (ret < 0)
- return ret;
-
- mutex_lock(&data->lock);
-
- /* Write the mode to the device. */
- if (data->mode != value) {
- ret = ak8975_write_data(client,
- AK8975_REG_CNTL,
- (u8)value,
- AK8975_REG_CNTL_MODE_MASK,
- AK8975_REG_CNTL_MODE_SHIFT);
-
- if (ret < 0) {
- dev_err(&client->dev, "Error in setting mode\n");
- mutex_unlock(&data->lock);
- return ret;
- }
- data->mode = value;
- }
-
- mutex_unlock(&data->lock);
-
- return count;
-}
-
static int wait_conversion_complete_gpio(struct ak8975_data *data)
{
struct i2c_client *client = data->client;
mutex_lock(&data->lock);
- if (data->mode == 0) {
- dev_err(&client->dev, "Operating mode is in power down mode\n");
- ret = -EBUSY;
- goto exit;
- }
-
/* Set up the device for taking a sample. */
ret = ak8975_write_data(client,
AK8975_REG_CNTL,
AK8975_CHANNEL(X, 0), AK8975_CHANNEL(Y, 1), AK8975_CHANNEL(Z, 2),
};
-static IIO_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, show_mode, store_mode, 0);
-
-static struct attribute *ak8975_attr[] = {
- &iio_dev_attr_mode.dev_attr.attr,
- NULL
-};
-
-static struct attribute_group ak8975_attr_group = {
- .attrs = ak8975_attr,
-};
-
static const struct iio_info ak8975_info = {
- .attrs = &ak8975_attr_group,
.read_raw = &ak8975_read_raw,
.driver_module = THIS_MODULE,
};
-static int ak8975_probe(struct i2c_client *client,
+static int __devinit ak8975_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct ak8975_data *data;
/* We may not have a GPIO based IRQ to scan, that is fine, we will
poll if so */
if (gpio_is_valid(eoc_gpio)) {
- err = gpio_request(eoc_gpio, "ak_8975");
+ err = gpio_request_one(eoc_gpio, GPIOF_IN, "ak_8975");
if (err < 0) {
dev_err(&client->dev,
"failed to request GPIO %d, error %d\n",
eoc_gpio, err);
goto exit;
}
-
- err = gpio_direction_input(eoc_gpio);
- if (err < 0) {
- dev_err(&client->dev,
- "Failed to configure input direction for GPIO %d, error %d\n",
- eoc_gpio, err);
- goto exit_gpio;
- }
}
/* Register with IIO */
return err;
}
-static int ak8975_remove(struct i2c_client *client)
+static int __devexit ak8975_remove(struct i2c_client *client)
{
struct iio_dev *indio_dev = i2c_get_clientdata(client);
struct ak8975_data *data = iio_priv(indio_dev);
.driver_module = THIS_MODULE,
};
-static int hmc5843_probe(struct i2c_client *client,
+static int __devinit hmc5843_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct hmc5843_data *data;
return err;
}
-static int hmc5843_remove(struct i2c_client *client)
+static int __devexit hmc5843_remove(struct i2c_client *client)
{
struct iio_dev *indio_dev = i2c_get_clientdata(client);
},
.id_table = hmc5843_id,
.probe = hmc5843_probe,
- .remove = hmc5843_remove,
+ .remove = __devexit_p(hmc5843_remove),
.detect = hmc5843_detect,
.address_list = normal_i2c,
};
* @read_p: read pointer (oldest available)
* @write_p: write pointer
* @half_p: half buffer length behind write_p (event generation)
- * @update_needed: flag to indicated change in size requested
+ * @update_needed: flag to indicate change in size requested
*
* Note that the first element of all ring buffers must be a
* struct iio_buffer.
}
EXPORT_SYMBOL(iio_sw_rb_free);
-MODULE_DESCRIPTION("Industrialio I/O software ring buffer");
+MODULE_DESCRIPTION("Industrial I/O software ring buffer");
MODULE_LICENSE("GPL");
static ssize_t iio_bfin_tmr_frequency_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
- struct iio_trigger *trig = dev_get_drvdata(dev);
+ struct iio_trigger *trig = to_iio_trigger(dev);
struct bfin_tmr_state *st = trig->private_data;
long val;
int ret;
struct device_attribute *attr,
char *buf)
{
- struct iio_trigger *trig = dev_get_drvdata(dev);
+ struct iio_trigger *trig = to_iio_trigger(dev);
struct bfin_tmr_state *st = trig->private_data;
return sprintf(buf, "%lu\n",
struct device_attribute *attr,
char *buf)
{
- struct iio_trigger *trig = dev_get_drvdata(dev);
+ struct iio_trigger *trig = to_iio_trigger(dev);
struct iio_prtc_trigger_info *trig_info = trig->private_data;
return sprintf(buf, "%u\n", trig_info->frequency);
}
const char *buf,
size_t len)
{
- struct iio_trigger *trig = dev_get_drvdata(dev);
+ struct iio_trigger *trig = to_iio_trigger(dev);
struct iio_prtc_trigger_info *trig_info = trig->private_data;
unsigned long val;
int ret;
static ssize_t iio_sysfs_trigger_poll(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
- struct iio_trigger *trig = dev_get_drvdata(dev);
+ struct iio_trigger *trig = to_iio_trigger(dev);
iio_trigger_poll_chained(trig, 0);
return count;
TPCI-200
--------
-* It receives the name of the mezzanine plugged in each slot by SYSFS.
- No autodetection supported yet, because the mezzanine driver could not be
- loaded at the time that the tpci200 driver loads.
-
* It has a linked list with the tpci200 devices it is managing. Get rid of it
and use driver_for_each_device() instead.
* Software Foundation; version 2 of the License.
*/
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
#include <linux/module.h>
#include "tpci200.h"
struct tpci200_board *tpci200;
int found = 0;
- if (dev == NULL) {
- pr_info("Slot doesn't exist.\n");
+ if (dev == NULL)
return NULL;
- }
list_for_each_entry(tpci200, &tpci200_list, list) {
if (tpci200->number == dev->bus_nr) {
}
if (!found) {
- pr_err("Carrier not found\n");
+ dev_err(&dev->dev, "Carrier not found\n");
return NULL;
}
if (dev->slot >= TPCI200_NB_SLOT) {
- pr_info("Slot [%d:%d] doesn't exist! Last tpci200 slot is %d.\n",
- dev->bus_nr, dev->slot, TPCI200_NB_SLOT-1);
- return NULL;
- }
-
- BUG_ON(tpci200->slots == NULL);
- if (tpci200->slots[dev->slot].dev == NULL) {
- pr_info("Slot [%d:%d] is not registered !\n", dev->bus_nr,
- dev->slot);
+ dev_info(&dev->dev,
+ "Slot [%d:%d] doesn't exist! Last tpci200 slot is %d.\n",
+ dev->bus_nr, dev->slot, TPCI200_NB_SLOT-1);
return NULL;
}
addr = &dev->mem_space;
break;
default:
- pr_err("Slot [%d:%d] space number %d doesn't exist !\n",
- dev->bus_nr, dev->slot, space);
+ dev_err(&dev->dev,
+ "Slot [%d:%d] space number %d doesn't exist !\n",
+ dev->bus_nr, dev->slot, space);
return NULL;
break;
}
if ((addr->size == 0) || (addr->address == NULL)) {
- pr_err("Error, slot space not mapped !\n");
+ dev_err(&dev->dev, "Error, slot space not mapped !\n");
return NULL;
}
return -EINVAL;
if (offset >= addr->size) {
- pr_err("Error, slot space offset error !\n");
+ dev_err(&dev->dev, "Error, slot space offset error !\n");
return -EFAULT;
}
return -EINVAL;
if ((offset+2) >= addr->size) {
- pr_err("Error, slot space offset error !\n");
+ dev_err(&dev->dev, "Error, slot space offset error !\n");
return -EFAULT;
}
*value = __tpci200_read16(addr->address, offset);
return -EINVAL;
if ((offset+4) >= addr->size) {
- pr_err("Error, slot space offset error !\n");
+ dev_err(&dev->dev, "Error, slot space offset error !\n");
return -EFAULT;
}
return -EINVAL;
if (offset >= addr->size) {
- pr_err("Error, slot space offset error !\n");
+ dev_err(&dev->dev, "Error, slot space offset error !\n");
return -EFAULT;
}
return -EINVAL;
if ((offset+2) >= addr->size) {
- pr_err("Error, slot space offset error !\n");
+ dev_err(&dev->dev, "Error, slot space offset error !\n");
return -EFAULT;
}
return -EINVAL;
if ((offset+4) >= addr->size) {
- pr_err("Error, slot space offset error !\n");
+ dev_err(&dev->dev, "Error, slot space offset error !\n");
return -EFAULT;
}
pci_disable_device(tpci200->info->pdev);
pci_dev_put(tpci200->info->pdev);
- kfree(tpci200->info);
-
for (i = 0; i < TPCI200_NB_SLOT; i++) {
tpci200->slots[i].io_phys.address = NULL;
tpci200->slots[i].io_phys.size = 0;
{
struct tpci200_board *tpci200 = (struct tpci200_board *) dev_id;
int i;
- unsigned long flags;
unsigned short status_reg, reg_value;
unsigned short unhandled_ints = 0;
irqreturn_t ret = IRQ_NONE;
- spin_lock_irqsave(&tpci200->info->access_lock, flags);
-
/* Read status register */
status_reg = readw(tpci200->info->interface_regs +
TPCI200_STATUS_REG);
if (unhandled_ints) {
for (i = 0; i < TPCI200_NB_SLOT; i++) {
if (unhandled_ints & ((TPCI200_INT0_EN | TPCI200_INT1_EN) << (2*i))) {
- pr_info("No registered ISR for slot [%d:%d]!. IRQ will be disabled.\n",
- tpci200->number, i);
+ dev_info(&tpci200->slots[i].dev->dev,
+ "No registered ISR for slot [%d:%d]!. IRQ will be disabled.\n",
+ tpci200->number, i);
reg_value = readw(
tpci200->info->interface_regs +
control_reg[i]);
}
}
- spin_unlock_irqrestore(&tpci200->info->access_lock, flags);
return ret;
}
-#ifdef CONFIG_SYSFS
-
-static struct ipack_device *tpci200_slot_register(unsigned int tpci200_number,
- unsigned int slot_position)
-{
- int found = 0;
- struct ipack_device *dev;
- struct tpci200_board *tpci200;
-
- list_for_each_entry(tpci200, &tpci200_list, list) {
- if (tpci200->number == tpci200_number) {
- found = 1;
- break;
- }
- }
-
- if (!found) {
- pr_err("carrier board not found for the device\n");
- return NULL;
- }
-
- if (slot_position >= TPCI200_NB_SLOT) {
- pr_info("Slot [%d:%d] doesn't exist!\n", tpci200_number,
- slot_position);
- return NULL;
- }
-
- if (mutex_lock_interruptible(&tpci200->mutex))
- return NULL;
-
- if (tpci200->slots[slot_position].dev != NULL) {
- pr_err("Slot [%d:%d] already installed !\n", tpci200_number,
- slot_position);
- goto err_unlock;
- }
-
- /*
- * Give the same IRQ number as the slot number.
- * The TPCI200 has assigned his own two IRQ by PCI bus driver
- */
- dev = ipack_device_register(tpci200->info->ipack_bus,
- slot_position, slot_position);
- if (dev == NULL) {
- pr_info("Slot [%d:%d] Unable to register an ipack device\n",
- tpci200_number, slot_position);
- goto err_unlock;
- }
-
- tpci200->slots[slot_position].dev = dev;
- mutex_unlock(&tpci200->mutex);
- return dev;
-
-err_unlock:
- mutex_unlock(&tpci200->mutex);
- return NULL;
-}
-
-static ssize_t tpci200_store_board(struct device *pdev, const char *buf,
- size_t count, int slot)
-{
- struct tpci200_board *card = dev_get_drvdata(pdev);
- struct ipack_device *dev = card->slots[slot].dev;
-
- if (dev != NULL)
- return -EBUSY;
-
- dev = tpci200_slot_register(card->number, slot);
- if (dev == NULL)
- return -ENODEV;
-
- return count;
-}
-
-static ssize_t tpci200_show_board(struct device *pdev, char *buf, int slot)
-{
- struct tpci200_board *card = dev_get_drvdata(pdev);
- struct ipack_device *dev = card->slots[slot].dev;
-
- if (dev != NULL)
- return snprintf(buf, PAGE_SIZE, "%s\n", dev_name(&dev->dev));
- else
- return snprintf(buf, PAGE_SIZE, "none\n");
-}
-
-static ssize_t tpci200_show_description(struct device *pdev,
- struct device_attribute *attr,
- char *buf)
-{
- return snprintf(buf, PAGE_SIZE,
- "TEWS tpci200 carrier PCI for Industry-pack mezzanines.\n");
-}
-
-static ssize_t tpci200_show_board_slot0(struct device *pdev,
- struct device_attribute *attr,
- char *buf)
-{
- return tpci200_show_board(pdev, buf, 0);
-}
-
-static ssize_t tpci200_store_board_slot0(struct device *pdev,
- struct device_attribute *attr,
- const char *buf, size_t count)
-{
- return tpci200_store_board(pdev, buf, count, 0);
-}
-
-static ssize_t tpci200_show_board_slot1(struct device *pdev,
- struct device_attribute *attr,
- char *buf)
-{
- return tpci200_show_board(pdev, buf, 1);
-}
-
-static ssize_t tpci200_store_board_slot1(struct device *pdev,
- struct device_attribute *attr,
- const char *buf, size_t count)
-{
- return tpci200_store_board(pdev, buf, count, 1);
-}
-
-static ssize_t tpci200_show_board_slot2(struct device *pdev,
- struct device_attribute *attr,
- char *buf)
-{
- return tpci200_show_board(pdev, buf, 2);
-}
-
-static ssize_t tpci200_store_board_slot2(struct device *pdev,
- struct device_attribute *attr,
- const char *buf, size_t count)
-{
- return tpci200_store_board(pdev, buf, count, 2);
-}
-
-
-static ssize_t tpci200_show_board_slot3(struct device *pdev,
- struct device_attribute *attr,
- char *buf)
-{
- return tpci200_show_board(pdev, buf, 3);
-}
-
-static ssize_t tpci200_store_board_slot3(struct device *pdev,
- struct device_attribute *attr,
- const char *buf, size_t count)
-{
- return tpci200_store_board(pdev, buf, count, 3);
-}
-
-/* Declaration of the device attributes for the TPCI200 */
-static DEVICE_ATTR(description, S_IRUGO,
- tpci200_show_description, NULL);
-static DEVICE_ATTR(board_slot0, S_IRUGO | S_IWUSR,
- tpci200_show_board_slot0, tpci200_store_board_slot0);
-static DEVICE_ATTR(board_slot1, S_IRUGO | S_IWUSR,
- tpci200_show_board_slot1, tpci200_store_board_slot1);
-static DEVICE_ATTR(board_slot2, S_IRUGO | S_IWUSR,
- tpci200_show_board_slot2, tpci200_store_board_slot2);
-static DEVICE_ATTR(board_slot3, S_IRUGO | S_IWUSR,
- tpci200_show_board_slot3, tpci200_store_board_slot3);
-
-static struct attribute *tpci200_attrs[] = {
- &dev_attr_description.attr,
- &dev_attr_board_slot0.attr,
- &dev_attr_board_slot1.attr,
- &dev_attr_board_slot2.attr,
- &dev_attr_board_slot3.attr,
- NULL,
-};
-
-static struct attribute_group tpci200_attr_group = {
- .attrs = tpci200_attrs,
-};
-
-static int tpci200_create_sysfs_files(struct tpci200_board *card)
-{
- return sysfs_create_group(&card->info->pdev->dev.kobj,
- &tpci200_attr_group);
-}
-
-static void tpci200_remove_sysfs_files(struct tpci200_board *card)
-{
- sysfs_remove_group(&card->info->pdev->dev.kobj, &tpci200_attr_group);
-}
-
-#else
-
-static int tpci200_create_sysfs_files(struct tpci200_board *card)
-{
- return 0;
-}
-
-static void tpci200_remove_sysfs_files(struct tpci200_board *card)
-{
-}
-
-#endif /* CONFIG_SYSFS */
-
static int tpci200_register(struct tpci200_board *tpci200)
{
- int i;
+ int i;
int res;
unsigned long ioidint_base;
unsigned long mem_base;
if (pci_enable_device(tpci200->info->pdev) < 0)
return -ENODEV;
- if (tpci200_create_sysfs_files(tpci200) < 0) {
- pr_err("failed creating sysfs files\n");
- res = -EFAULT;
- goto out_disable_pci;
- }
-
/* Request IP interface register (Bar 2) */
res = pci_request_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR,
"Carrier IP interface registers");
if (res) {
- pr_err("(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 2 !",
- tpci200->info->pdev->bus->number,
- tpci200->info->pdev->devfn);
- goto out_remove_sysfs;
+ dev_err(&tpci200->info->pdev->dev,
+ "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 2 !",
+ tpci200->info->pdev->bus->number,
+ tpci200->info->pdev->devfn);
+ goto out_disable_pci;
}
/* Request IO ID INT space (Bar 3) */
TPCI200_IO_ID_INT_SPACES_BAR,
"Carrier IO ID INT space");
if (res) {
- pr_err("(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 3 !",
- tpci200->info->pdev->bus->number,
- tpci200->info->pdev->devfn);
+ dev_err(&tpci200->info->pdev->dev,
+ "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 3 !",
+ tpci200->info->pdev->bus->number,
+ tpci200->info->pdev->devfn);
goto out_release_ip_space;
}
res = pci_request_region(tpci200->info->pdev, TPCI200_MEM8_SPACE_BAR,
"Carrier MEM space");
if (res) {
- pr_err("(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 4!",
- tpci200->info->pdev->bus->number,
- tpci200->info->pdev->devfn);
+ dev_err(&tpci200->info->pdev->dev,
+ "(bn 0x%X, sn 0x%X) failed to allocate PCI resource for BAR 4!",
+ tpci200->info->pdev->bus->number,
+ tpci200->info->pdev->devfn);
goto out_release_ioid_int_space;
}
TPCI200_MEM8_SPACE_BAR),
TPCI200_MEM8_SIZE);
- spin_lock_init(&tpci200->info->access_lock);
ioidint_base = pci_resource_start(tpci200->info->pdev,
TPCI200_IO_ID_INT_SPACES_BAR);
mem_base = pci_resource_start(tpci200->info->pdev,
tpci200_interrupt, IRQF_SHARED,
KBUILD_MODNAME, (void *) tpci200);
if (res) {
- pr_err("(bn 0x%X, sn 0x%X) unable to register IRQ !",
- tpci200->info->pdev->bus->number,
- tpci200->info->pdev->devfn);
- tpci200_unregister(tpci200);
- goto out_err;
+ dev_err(&tpci200->info->pdev->dev,
+ "(bn 0x%X, sn 0x%X) unable to register IRQ !",
+ tpci200->info->pdev->bus->number,
+ tpci200->info->pdev->devfn);
+ goto out_release_ioid_int_space;
}
return 0;
pci_release_region(tpci200->info->pdev, TPCI200_IO_ID_INT_SPACES_BAR);
out_release_ip_space:
pci_release_region(tpci200->info->pdev, TPCI200_IP_INTERFACE_BAR);
-out_remove_sysfs:
- tpci200_remove_sysfs_files(tpci200);
out_disable_pci:
pci_disable_device(tpci200->info->pdev);
-out_err:
return res;
}
static int tpci200_free_irq(struct ipack_device *dev)
{
- int res;
struct slot_irq *slot_irq;
struct tpci200_board *tpci200;
tpci200 = check_slot(dev);
- if (tpci200 == NULL) {
- res = -EINVAL;
- goto out;
- }
+ if (tpci200 == NULL)
+ return -EINVAL;
- if (mutex_lock_interruptible(&tpci200->mutex)) {
- res = -ERESTARTSYS;
- goto out;
- }
+ if (mutex_lock_interruptible(&tpci200->mutex))
+ return -ERESTARTSYS;
if (tpci200->slots[dev->slot].irq == NULL) {
- res = -EINVAL;
- goto out_unlock;
+ mutex_unlock(&tpci200->mutex);
+ return -EINVAL;
}
__tpci200_free_irq(tpci200, dev);
tpci200->slots[dev->slot].irq = NULL;
kfree(slot_irq);
-out_unlock:
mutex_unlock(&tpci200->mutex);
-out:
- return res;
+ return 0;
}
static int tpci200_slot_unmap_space(struct ipack_device *dev, int space)
{
- int res;
struct ipack_addr_space *virt_addr_space;
struct tpci200_board *tpci200;
tpci200 = check_slot(dev);
- if (tpci200 == NULL) {
- res = -EINVAL;
- goto out;
- }
+ if (tpci200 == NULL)
+ return -EINVAL;
- if (mutex_lock_interruptible(&tpci200->mutex)) {
- res = -ERESTARTSYS;
- goto out;
- }
+ if (mutex_lock_interruptible(&tpci200->mutex))
+ return -ERESTARTSYS;
switch (space) {
case IPACK_IO_SPACE:
if (dev->io_space.address == NULL) {
- pr_info("Slot [%d:%d] IO space not mapped !\n",
- dev->bus_nr, dev->slot);
+ dev_info(&dev->dev,
+ "Slot [%d:%d] IO space not mapped !\n",
+ dev->bus_nr, dev->slot);
goto out_unlock;
}
virt_addr_space = &dev->io_space;
break;
case IPACK_ID_SPACE:
if (dev->id_space.address == NULL) {
- pr_info("Slot [%d:%d] ID space not mapped !\n",
- dev->bus_nr, dev->slot);
+ dev_info(&dev->dev,
+ "Slot [%d:%d] ID space not mapped !\n",
+ dev->bus_nr, dev->slot);
goto out_unlock;
}
virt_addr_space = &dev->id_space;
break;
case IPACK_MEM_SPACE:
if (dev->mem_space.address == NULL) {
- pr_info("Slot [%d:%d] MEM space not mapped !\n",
- dev->bus_nr, dev->slot);
- goto out_unlock;
+ dev_info(&dev->dev,
+ "Slot [%d:%d] MEM space not mapped !\n",
+ dev->bus_nr, dev->slot);
+ goto out_unlock;
}
virt_addr_space = &dev->mem_space;
break;
default:
- pr_err("Slot [%d:%d] space number %d doesn't exist !\n",
- dev->bus_nr, dev->slot, space);
- res = -EINVAL;
- goto out_unlock;
- break;
+ dev_err(&dev->dev,
+ "Slot [%d:%d] space number %d doesn't exist !\n",
+ dev->bus_nr, dev->slot, space);
+ mutex_unlock(&tpci200->mutex);
+ return -EINVAL;
}
iounmap(virt_addr_space->address);
virt_addr_space->size = 0;
out_unlock:
mutex_unlock(&tpci200->mutex);
-out:
- return res;
+ return 0;
}
static int tpci200_slot_unregister(struct ipack_device *dev)
static int tpci200_slot_map_space(struct ipack_device *dev,
unsigned int memory_size, int space)
{
- int res;
+ int res = 0;
unsigned int size_to_map;
void __iomem *phys_address;
struct ipack_addr_space *virt_addr_space;
struct tpci200_board *tpci200;
tpci200 = check_slot(dev);
- if (tpci200 == NULL) {
- res = -EINVAL;
- goto out;
- }
+ if (tpci200 == NULL)
+ return -EINVAL;
- if (mutex_lock_interruptible(&tpci200->mutex)) {
- res = -ERESTARTSYS;
- goto out;
- }
+ if (mutex_lock_interruptible(&tpci200->mutex))
+ return -ERESTARTSYS;
switch (space) {
case IPACK_IO_SPACE:
if (dev->io_space.address != NULL) {
- pr_err("Slot [%d:%d] IO space already mapped !\n",
- tpci200->number, dev->slot);
+ dev_err(&dev->dev,
+ "Slot [%d:%d] IO space already mapped !\n",
+ tpci200->number, dev->slot);
res = -EINVAL;
goto out_unlock;
}
break;
case IPACK_ID_SPACE:
if (dev->id_space.address != NULL) {
- pr_err("Slot [%d:%d] ID space already mapped !\n",
- tpci200->number, dev->slot);
+ dev_err(&dev->dev,
+ "Slot [%d:%d] ID space already mapped !\n",
+ tpci200->number, dev->slot);
res = -EINVAL;
goto out_unlock;
}
break;
case IPACK_MEM_SPACE:
if (dev->mem_space.address != NULL) {
- pr_err("Slot [%d:%d] MEM space already mapped !\n",
- tpci200->number, dev->slot);
+ dev_err(&dev->dev,
+ "Slot [%d:%d] MEM space already mapped !\n",
+ tpci200->number, dev->slot);
res = -EINVAL;
goto out_unlock;
}
virt_addr_space = &dev->mem_space;
if (memory_size > tpci200->slots[dev->slot].mem_phys.size) {
- pr_err("Slot [%d:%d] request is 0x%X memory, only 0x%X available !\n",
- dev->bus_nr, dev->slot, memory_size,
- tpci200->slots[dev->slot].mem_phys.size);
+ dev_err(&dev->dev,
+ "Slot [%d:%d] request is 0x%X memory, only 0x%X available !\n",
+ dev->bus_nr, dev->slot, memory_size,
+ tpci200->slots[dev->slot].mem_phys.size);
res = -EINVAL;
goto out_unlock;
}
size_to_map = memory_size;
break;
default:
- pr_err("Slot [%d:%d] space %d doesn't exist !\n",
- tpci200->number, dev->slot, space);
+ dev_err(&dev->dev, "Slot [%d:%d] space %d doesn't exist !\n",
+ tpci200->number, dev->slot, space);
res = -EINVAL;
goto out_unlock;
- break;
}
virt_addr_space->size = size_to_map;
out_unlock:
mutex_unlock(&tpci200->mutex);
-out:
return res;
}
struct tpci200_board *tpci200;
tpci200 = check_slot(dev);
- if (tpci200 == NULL) {
- res = -EINVAL;
- goto out;
- }
+ if (tpci200 == NULL)
+ return -EINVAL;
- if (mutex_lock_interruptible(&tpci200->mutex)) {
- res = -ERESTARTSYS;
- goto out;
- }
+ if (mutex_lock_interruptible(&tpci200->mutex))
+ return -ERESTARTSYS;
if (tpci200->slots[dev->slot].irq != NULL) {
- pr_err("Slot [%d:%d] IRQ already registered !\n", dev->bus_nr,
- dev->slot);
+ dev_err(&dev->dev,
+ "Slot [%d:%d] IRQ already registered !\n", dev->bus_nr,
+ dev->slot);
res = -EINVAL;
goto out_unlock;
}
slot_irq = kzalloc(sizeof(struct slot_irq), GFP_KERNEL);
if (slot_irq == NULL) {
- pr_err("Slot [%d:%d] unable to allocate memory for IRQ !\n",
- dev->bus_nr, dev->slot);
+ dev_err(&dev->dev,
+ "Slot [%d:%d] unable to allocate memory for IRQ !\n",
+ dev->bus_nr, dev->slot);
res = -ENOMEM;
goto out_unlock;
}
slot_irq->vector = vector;
slot_irq->handler = handler;
slot_irq->arg = arg;
- slot_irq->name = dev_name(&dev->dev);
tpci200->slots[dev->slot].irq = slot_irq;
res = __tpci200_request_irq(tpci200, dev);
out_unlock:
mutex_unlock(&tpci200->mutex);
-out:
return res;
}
-static void tpci200_slot_remove(struct tpci200_slot *slot)
-{
- if ((slot->dev == NULL) ||
- (slot->dev->driver->ops->remove == NULL))
- return;
-
- slot->dev->driver->ops->remove(slot->dev);
-}
-
static void tpci200_uninstall(struct tpci200_board *tpci200)
{
int i;
for (i = 0; i < TPCI200_NB_SLOT; i++)
- tpci200_slot_remove(&tpci200->slots[i]);
+ tpci200_slot_unregister(tpci200->slots[i].dev);
tpci200_unregister(tpci200);
kfree(tpci200->slots);
tpci200->slots = kzalloc(
TPCI200_NB_SLOT * sizeof(struct tpci200_slot), GFP_KERNEL);
- if (tpci200->slots == NULL) {
- res = -ENOMEM;
- goto out_err;
- }
+ if (tpci200->slots == NULL)
+ return -ENOMEM;
res = tpci200_register(tpci200);
- if (res)
- goto out_free;
+ if (res) {
+ kfree(tpci200->slots);
+ tpci200->slots = NULL;
+ return res;
+ }
mutex_init(&tpci200->mutex);
return 0;
-
-out_free:
- kfree(tpci200->slots);
- tpci200->slots = NULL;
-out_err:
- return res;
}
static int tpci200_pciprobe(struct pci_dev *pdev,
const struct pci_device_id *id)
{
- int ret;
+ int ret, i;
struct tpci200_board *tpci200;
tpci200 = kzalloc(sizeof(struct tpci200_board), GFP_KERNEL);
/* register the device and initialize it */
ret = tpci200_install(tpci200);
if (ret) {
- pr_err("Error during tpci200 install !\n");
+ dev_err(&pdev->dev, "Error during tpci200 install !\n");
kfree(tpci200->info);
kfree(tpci200);
return -ENODEV;
TPCI200_NB_SLOT,
&tpci200_bus_ops);
if (!tpci200->info->ipack_bus) {
- pr_err("error registering the carrier on ipack driver\n");
+ dev_err(&pdev->dev,
+ "error registering the carrier on ipack driver\n");
tpci200_uninstall(tpci200);
kfree(tpci200->info);
kfree(tpci200);
dev_set_drvdata(&pdev->dev, tpci200);
/* add the registered device in an internal linked list */
list_add_tail(&tpci200->list, &tpci200_list);
+
+ /*
+ * Give the same IRQ number as the slot number.
+ * The TPCI200 has assigned his own two IRQ by PCI bus driver
+ */
+ for (i = 0; i < TPCI200_NB_SLOT; i++)
+ tpci200->slots[i].dev =
+ ipack_device_register(tpci200->info->ipack_bus, i, i);
return ret;
}
static void __tpci200_pci_remove(struct tpci200_board *tpci200)
{
tpci200_uninstall(tpci200);
- tpci200_remove_sysfs_files(tpci200);
list_del(&tpci200->list);
ipack_bus_unregister(tpci200->info->ipack_bus);
kfree(tpci200->info);
}
}
-static struct pci_device_id tpci200_idtable[2] = {
+static DEFINE_PCI_DEVICE_TABLE(tpci200_idtable) = {
{ TPCI200_VENDOR_ID, TPCI200_DEVICE_ID, TPCI200_SUBVENDOR_ID,
TPCI200_SUBDEVICE_ID },
{ 0, },
};
+MODULE_DEVICE_TABLE(pci, tpci200_idtable);
+
static struct pci_driver tpci200_pci_drv = {
.name = "tpci200",
.id_table = tpci200_idtable,
#ifndef _TPCI200_H_
#define _TPCI200_H_
-#include <linux/version.h>
#include <linux/limits.h>
#include <linux/pci.h>
#include <linux/spinlock.h>
* @vector Vector number
* @handler Handler called when IRQ arrives
* @arg Handler argument
- * @name IRQ name
*
*/
struct slot_irq {
int vector;
int (*handler)(void *);
void *arg;
- const char *name;
};
/**
* @interface_regs Pointer to IP interface space (Bar 2)
* @ioidint_space Pointer to IP ID, IO and INT space (Bar 3)
* @mem8_space Pointer to MEM space (Bar 4)
- * @access_lock Mutex lock for simultaneous access
*
*/
struct tpci200_infos {
void __iomem *interface_regs;
void __iomem *ioidint_space;
void __iomem *mem8_space;
- spinlock_t access_lock;
struct ipack_bus_device *ipack_bus;
};
struct tpci200_board {
* Software Foundation; version 2 of the License.
*/
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
#include <linux/device.h>
#include <linux/module.h>
-#include <linux/moduleparam.h>
#include <linux/interrupt.h>
-#include <linux/fs.h>
-#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/tty.h>
#include <linux/serial.h>
#include <linux/tty_flip.h>
#include <linux/slab.h>
-#include <linux/uaccess.h>
#include <linux/atomic.h>
#include "../ipack.h"
#include "ipoctal.h"
struct scc2698_channel *chan_regs;
struct scc2698_block *block_regs;
struct ipoctal_stats chan_stats[NR_CHANNELS];
- char *buffer[NR_CHANNELS];
unsigned int nb_bytes[NR_CHANNELS];
unsigned int count_wr[NR_CHANNELS];
- struct ipoctal_config chan_config[NR_CHANNELS];
wait_queue_head_t queue[NR_CHANNELS];
- unsigned short error_flag[NR_CHANNELS];
spinlock_t lock[NR_CHANNELS];
unsigned int pointer_read[NR_CHANNELS];
unsigned int pointer_write[NR_CHANNELS];
ipoctal = ipoctal_find_board(tty);
if (ipoctal == NULL) {
- pr_err("Device not found. Major %d\n", tty->driver->major);
+ dev_err(tty->dev, "Device not found. Major %d\n",
+ tty->driver->major);
return -ENODEV;
}
ipoctal = ipoctal_find_board(tty);
if (ipoctal == NULL) {
- pr_err("Device not found. Major %d\n", tty->driver->major);
+ dev_err(tty->dev, "Device not found. Major %d\n",
+ tty->driver->major);
return -ENODEV;
}
CR_CMD_RESET_ERR_STATUS);
if (sr & SR_OVERRUN_ERROR) {
- ipoctal->error_flag[channel] |= UART_OVERRUN;
ipoctal->chan_stats[channel].overrun_err++;
/* Overrun doesn't affect the current character*/
tty_insert_flip_char(tty, 0, TTY_OVERRUN);
}
if (sr & SR_PARITY_ERROR) {
- ipoctal->error_flag[channel] |= UART_PARITY;
ipoctal->chan_stats[channel].parity_err++;
flag = TTY_PARITY;
}
if (sr & SR_FRAMING_ERROR) {
- ipoctal->error_flag[channel] |= UART_FRAMING;
ipoctal->chan_stats[channel].framing_err++;
flag = TTY_FRAME;
}
if (sr & SR_RECEIVED_BREAK) {
- ipoctal->error_flag[channel] |= UART_BREAK;
ipoctal->chan_stats[channel].rcv_break++;
flag = TTY_BREAK;
}
ipoctal->nb_bytes[channel] = 0;
continue;
}
- spin_lock(&ipoctal->lock[channel]);
- value = ipoctal->buffer[channel][*pointer_write];
+
+ value = ipoctal->tty_port[channel].xmit_buf[*pointer_write];
ipoctal_write_io_reg(ipoctal,
&ipoctal->chan_regs[channel].u.w.thr,
value);
(*pointer_write)++;
*pointer_write = *pointer_write % PAGE_SIZE;
ipoctal->nb_bytes[channel]--;
- spin_unlock(&ipoctal->lock[channel]);
if ((ipoctal->nb_bytes[channel] == 0) &&
(waitqueue_active(&ipoctal->queue[channel]))) {
res = ipoctal->dev->bus->ops->map_space(ipoctal->dev, 0,
IPACK_ID_SPACE);
if (res) {
- pr_err("Unable to map slot [%d:%d] ID space!\n", bus_nr, slot);
+ dev_err(&ipoctal->dev->dev,
+ "Unable to map slot [%d:%d] ID space!\n",
+ bus_nr, slot);
return res;
}
res = ipoctal->dev->bus->ops->map_space(ipoctal->dev, 0,
IPACK_IO_SPACE);
if (res) {
- pr_err("Unable to map slot [%d:%d] IO space!\n", bus_nr, slot);
+ dev_err(&ipoctal->dev->dev,
+ "Unable to map slot [%d:%d] IO space!\n",
+ bus_nr, slot);
goto out_unregister_id_space;
}
res = ipoctal->dev->bus->ops->map_space(ipoctal->dev,
0x8000, IPACK_MEM_SPACE);
if (res) {
- pr_err("Unable to map slot [%d:%d] MEM space!\n", bus_nr, slot);
+ dev_err(&ipoctal->dev->dev,
+ "Unable to map slot [%d:%d] MEM space!\n",
+ bus_nr, slot);
goto out_unregister_io_space;
}
tty_set_operations(tty, &ipoctal_fops);
res = tty_register_driver(tty);
if (res) {
- pr_err("Can't register tty driver.\n");
+ dev_err(&ipoctal->dev->dev, "Can't register tty driver.\n");
put_tty_driver(tty);
goto out_unregister_slot_unmap;
}
ipoctal_reset_stats(&ipoctal->chan_stats[i]);
ipoctal->nb_bytes[i] = 0;
init_waitqueue_head(&ipoctal->queue[i]);
- ipoctal->error_flag[i] = UART_NOERROR;
spin_lock_init(&ipoctal->lock[i]);
ipoctal->pointer_read[i] = 0;
ipoctal_copy_write_buffer(ipoctal, channel, buf, count);
- ipoctal->error_flag[channel] = UART_NOERROR;
-
/* As the IP-OCTAL 485 only supports half duplex, do it manually */
if (ipoctal->board_id == IP_OCTAL_485_ID) {
ipoctal_write_io_reg(ipoctal,
if (cflag & CRTSCTS) {
mr1 |= MR1_RxRTS_CONTROL_ON;
mr2 |= MR2_TxRTS_CONTROL_OFF | MR2_CTS_ENABLE_TX_ON;
- ipoctal->chan_config[channel].flow_control = 1;
} else {
mr1 |= MR1_RxRTS_CONTROL_OFF;
mr2 |= MR2_TxRTS_CONTROL_OFF | MR2_CTS_ENABLE_TX_OFF;
- ipoctal->chan_config[channel].flow_control = 0;
}
break;
case IP_OCTAL_422_ID:
mr1 |= MR1_RxRTS_CONTROL_OFF;
mr2 |= MR2_TxRTS_CONTROL_OFF | MR2_CTS_ENABLE_TX_OFF;
- ipoctal->chan_config[channel].flow_control = 0;
break;
case IP_OCTAL_485_ID:
mr1 |= MR1_RxRTS_CONTROL_OFF;
mr2 |= MR2_TxRTS_CONTROL_ON | MR2_CTS_ENABLE_TX_OFF;
- ipoctal->chan_config[channel].flow_control = 0;
break;
default:
return;
ipoctal_write_io_reg(ipoctal, &ipoctal->chan_regs[channel].u.w.mr, mr2);
ipoctal_write_io_reg(ipoctal, &ipoctal->chan_regs[channel].u.w.csr, csr);
- /* save the setup in the structure */
- ipoctal->chan_config[channel].baud = tty_get_baud_rate(tty);
- ipoctal->chan_config[channel].bits_per_char = cflag & CSIZE;
- ipoctal->chan_config[channel].parity = cflag & PARENB;
- ipoctal->chan_config[channel].stop_bits = cflag & CSTOPB;
-
/* Enable again the RX */
ipoctal_write_io_reg(ipoctal, &ipoctal->chan_regs[channel].u.w.cr,
CR_ENABLE_RX);
tty_unregister_driver(ipoctal->tty_drv);
put_tty_driver(ipoctal->tty_drv);
-
- /* Tell the carrier board to free all the resources for this device */
- if (ipoctal->dev->bus->ops->remove_device != NULL)
- ipoctal->dev->bus->ops->remove_device(ipoctal->dev);
-
list_del(&ipoctal->list);
kfree(ipoctal);
}
struct ipoctal *p, *next;
list_for_each_entry_safe(p, next, &ipoctal_list, list)
- __ipoctal_remove(p);
+ p->dev->bus->ops->remove_device(p->dev);
ipack_driver_unregister(&driver);
}
#define MAX_DEVICES (NR_CHANNELS * IPOCTAL_MAX_BOARDS)
#define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
-/**
- * enum uart_parity_e - UART supported parity.
- */
-enum uart_parity_e {
- UART_NONE = 0,
- UART_ODD = 1,
- UART_EVEN = 2,
-};
-
-/**
- * enum uart_error - UART error type
- *
- */
-enum uart_error {
- UART_NOERROR = 0, /* No error during transmission */
- UART_TIMEOUT = 1 << 0, /* Timeout error */
- UART_OVERRUN = 1 << 1, /* Overrun error */
- UART_PARITY = 1 << 2, /* Parity error */
- UART_FRAMING = 1 << 3, /* Framing error */
- UART_BREAK = 1 << 4, /* Received break */
-};
-
-/**
- * struct ipoctal_config - Serial configuration
- *
- * @baud: Baud rate
- * @stop_bits: Stop bits (1 or 2)
- * @bits_per_char: data size in bits
- * @parity
- * @flow_control: Flow control management (RTS/CTS) (0 disabled, 1 enabled)
- */
-struct ipoctal_config {
- unsigned int baud;
- unsigned int stop_bits;
- unsigned int bits_per_char;
- unsigned short parity;
- unsigned int flow_control;
-};
-
/**
* struct ipoctal_stats -- Stats since last reset
*
* Software Foundation; version 2 of the License.
*/
-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-
#include <linux/module.h>
-#include <linux/mutex.h>
#include <linux/slab.h>
+#include <linux/idr.h>
#include "ipack.h"
#define to_ipack_dev(device) container_of(device, struct ipack_device, dev)
#define to_ipack_driver(drv) container_of(drv, struct ipack_driver, driver)
-/* used when allocating bus numbers */
-#define IPACK_MAXBUS 64
-
-static DEFINE_MUTEX(ipack_mutex);
-
-struct ipack_busmap {
- unsigned long busmap[IPACK_MAXBUS / (8*sizeof(unsigned long))];
-};
-static struct ipack_busmap busmap;
+static DEFINE_IDA(ipack_ida);
static void ipack_device_release(struct device *dev)
{
if (ret)
dev->driver = drv;
- return 0;
+ return ret;
}
static int ipack_bus_probe(struct device *device)
.remove = ipack_bus_remove,
};
-static int ipack_assign_bus_number(void)
-{
- int busnum;
-
- mutex_lock(&ipack_mutex);
- busnum = find_next_zero_bit(busmap.busmap, IPACK_MAXBUS, 1);
-
- if (busnum >= IPACK_MAXBUS) {
- pr_err("too many buses\n");
- busnum = -1;
- goto error_find_busnum;
- }
-
- set_bit(busnum, busmap.busmap);
-
-error_find_busnum:
- mutex_unlock(&ipack_mutex);
- return busnum;
-}
-
struct ipack_bus_device *ipack_bus_register(struct device *parent, int slots,
struct ipack_bus_ops *ops)
{
if (!bus)
return NULL;
- bus_nr = ipack_assign_bus_number();
+ bus_nr = ida_simple_get(&ipack_ida, 0, 0, GFP_KERNEL);
if (bus_nr < 0) {
kfree(bus);
return NULL;
int ipack_bus_unregister(struct ipack_bus_device *bus)
{
- mutex_lock(&ipack_mutex);
- clear_bit(bus->bus_nr, busmap.busmap);
- mutex_unlock(&ipack_mutex);
+ ida_simple_remove(&ipack_ida, bus->bus_nr);
kfree(bus);
return 0;
}
ret = device_register(&dev->dev);
if (ret < 0) {
- pr_err("error registering the device.\n");
- dev->driver->ops->remove(dev);
kfree(dev);
return NULL;
}
static int __init ipack_init(void)
{
+ ida_init(&ipack_ida);
return bus_register(&ipack_bus_type);
}
static void __exit ipack_exit(void)
{
bus_unregister(&ipack_bus_type);
+ ida_destroy(&ipack_ida);
}
module_init(ipack_init);
if (MiscReg03 & 0x02) {
if (!us->SM_Status.Ready && !us->MS_Status.Ready) {
result = ENE_SMInit(us);
- if (result != USB_STOR_XFER_GOOD) {
+ if (result != USB_STOR_XFER_GOOD)
return USB_STOR_TRANSPORT_ERROR;
- }
}
}
/* we use this macro to help us write into the buffer */
#undef SPRINTF
#define SPRINTF(args...) \
- do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
+ do { \
+ if (pos < buffer+length) \
+ pos += sprintf(pos, ## args); \
+ } while (0)
/*
* proc_info()
pos += sprintf(pos, " Quirks:");
#define US_FLAG(name, value) \
- if (us->fflags & value)\
- pos += sprintf(pos, " " #name);
+ do { \
+ if (us->fflags & value) \
+ pos += sprintf(pos, " " #name); \
+ } while (0);
US_DO_ALL_FLAGS
#undef US_FLAG
Say Y to enable support for battery and charger interface for
nVidia compliant embedded controllers.
-config NVEC_LEDS
- bool "NVEC leds"
- depends on MFD_NVEC && LEDS_CLASS
+config NVEC_PAZ00
+ bool "Support for OEM specific functions on Compal PAZ00 based devices"
+ depends on MFD_NVEC && LEDS_CLASS && MACH_PAZ00
help
- Say Y to enable yellow side leds on AC100 or other nVidia tegra nvec leds
+ Say Y to enable control of the yellow side leds on Compal PAZ00 based
+ devices, e.g. Toshbia AC100 and Dynabooks AZ netbooks.
obj-$(CONFIG_MFD_NVEC) += nvec.o
obj-$(CONFIG_NVEC_POWER) += nvec_power.o
obj-$(CONFIG_KEYBOARD_NVEC) += nvec_kbd.o
-obj-$(CONFIG_NVEC_LEDS) += nvec_leds.o
+obj-$(CONFIG_NVEC_PAZ00) += nvec_paz00.o
.id = 2,
},
{
- .name = "nvec-leds",
+ .name = "nvec-paz00",
.id = 1,
},
};
static int nvec_status_notifier(struct notifier_block *nb,
unsigned long event_type, void *data)
{
+ struct nvec_chip *nvec = container_of(nb, struct nvec_chip,
+ nvec_status_notifier);
unsigned char *msg = (unsigned char *)data;
if (event_type != NVEC_CNTL)
return NOTIFY_DONE;
- printk(KERN_WARNING "unhandled msg type %ld\n", event_type);
+ dev_warn(nvec->dev, "unhandled msg type %ld\n", event_type);
print_hex_dump(KERN_WARNING, "payload: ", DUMP_PREFIX_NONE, 16, 1,
msg, msg[1] + 2, true);
clk_disable(nvec->i2c_clk);
}
+#ifdef CONFIG_PM_SLEEP
static void nvec_disable_i2c_slave(struct nvec_chip *nvec)
{
disable_irq(nvec->irq);
writel(I2C_SL_NEWSL | I2C_SL_NACK, nvec->base + I2C_SL_CNFG);
clk_disable(nvec->i2c_clk);
}
+#endif
static void nvec_power_off(void)
{
struct nvec_chip *nvec;
struct nvec_msg *msg;
struct resource *res;
- struct resource *iomem;
void __iomem *base;
- nvec = kzalloc(sizeof(struct nvec_chip), GFP_KERNEL);
+ nvec = devm_kzalloc(&pdev->dev, sizeof(struct nvec_chip), GFP_KERNEL);
if (nvec == NULL) {
dev_err(&pdev->dev, "failed to reserve memory\n");
return -ENOMEM;
nvec->gpio = of_get_named_gpio(nvec->dev->of_node, "request-gpios", 0);
if (nvec->gpio < 0) {
dev_err(&pdev->dev, "no gpio specified");
- goto failed;
+ return -ENODEV;
}
if (of_property_read_u32(nvec->dev->of_node, "slave-addr", &nvec->i2c_addr)) {
dev_err(&pdev->dev, "no i2c address specified");
- goto failed;
+ return -ENODEV;
}
} else {
dev_err(&pdev->dev, "no platform data\n");
- goto failed;
+ return -ENODEV;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
return -ENODEV;
}
- iomem = request_mem_region(res->start, resource_size(res), pdev->name);
- if (!iomem) {
- dev_err(&pdev->dev, "I2C region already claimed\n");
- return -EBUSY;
- }
-
- base = ioremap(iomem->start, resource_size(iomem));
+ base = devm_request_and_ioremap(&pdev->dev, res);
if (!base) {
dev_err(&pdev->dev, "Can't ioremap I2C region\n");
return -ENOMEM;
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!res) {
dev_err(&pdev->dev, "no irq resource?\n");
- ret = -ENODEV;
- goto err_iounmap;
+ return -ENODEV;
}
i2c_clk = clk_get_sys("tegra-i2c.2", NULL);
if (IS_ERR(i2c_clk)) {
dev_err(nvec->dev, "failed to get controller clock\n");
- goto err_iounmap;
+ return -ENODEV;
}
nvec->base = base;
INIT_WORK(&nvec->tx_work, nvec_request_master);
nvec->wq = alloc_workqueue("nvec", WQ_NON_REENTRANT, 2);
- err = gpio_request_one(nvec->gpio, GPIOF_OUT_INIT_HIGH, "nvec gpio");
+ err = devm_gpio_request_one(&pdev->dev, nvec->gpio, GPIOF_OUT_INIT_HIGH,
+ "nvec gpio");
if (err < 0) {
dev_err(nvec->dev, "couldn't request gpio\n");
- goto failed;
+ destroy_workqueue(nvec->wq);
+ return -ENODEV;
}
- err = request_irq(nvec->irq, nvec_interrupt, 0, "nvec", nvec);
+ err = devm_request_irq(&pdev->dev, nvec->irq, nvec_interrupt, 0,
+ "nvec", nvec);
if (err) {
dev_err(nvec->dev, "couldn't request irq\n");
- goto failed;
+ destroy_workqueue(nvec->wq);
+ return -ENODEV;
}
disable_irq(nvec->irq);
nvec_write_async(nvec, "\x01\x01\x01\x00\x00\x80\x00", 7);
return 0;
-
-err_iounmap:
- iounmap(base);
-failed:
- kfree(nvec);
- return -ENOMEM;
}
static int __devexit tegra_nvec_remove(struct platform_device *pdev)
nvec_write_async(nvec, EC_DISABLE_EVENT_REPORTING, 3);
mfd_remove_devices(nvec->dev);
- free_irq(nvec->irq, &nvec_interrupt);
- iounmap(nvec->base);
- gpio_free(nvec->gpio);
destroy_workqueue(nvec->wq);
- kfree(nvec);
return 0;
}
-#ifdef CONFIG_PM
-
-static int tegra_nvec_suspend(struct platform_device *pdev, pm_message_t state)
+#ifdef CONFIG_PM_SLEEP
+static int nvec_suspend(struct device *dev)
{
+ struct platform_device *pdev = to_platform_device(dev);
struct nvec_chip *nvec = platform_get_drvdata(pdev);
struct nvec_msg *msg;
return 0;
}
-static int tegra_nvec_resume(struct platform_device *pdev)
+static int nvec_resume(struct device *dev)
{
+ struct platform_device *pdev = to_platform_device(dev);
struct nvec_chip *nvec = platform_get_drvdata(pdev);
dev_dbg(nvec->dev, "resuming\n");
return 0;
}
-
-#else
-#define tegra_nvec_suspend NULL
-#define tegra_nvec_resume NULL
#endif
+static const SIMPLE_DEV_PM_OPS(nvec_pm_ops, nvec_suspend, nvec_resume);
+
/* Match table for of_platform binding */
static const struct of_device_id nvidia_nvec_of_match[] __devinitconst = {
{ .compatible = "nvidia,nvec", },
static struct platform_driver nvec_device_driver = {
.probe = tegra_nvec_probe,
.remove = __devexit_p(tegra_nvec_remove),
- .suspend = tegra_nvec_suspend,
- .resume = tegra_nvec_resume,
.driver = {
.name = "nvec",
.owner = THIS_MODULE,
+ .pm = &nvec_pm_ops,
.of_match_table = nvidia_nvec_of_match,
}
};
-static int __init tegra_nvec_init(void)
-{
- return platform_driver_register(&nvec_device_driver);
-}
-
-module_init(tegra_nvec_init);
+module_platform_driver(nvec_device_driver);
MODULE_ALIAS("platform:nvec");
MODULE_DESCRIPTION("NVIDIA compliant embedded controller interface");
return err;
}
+static int __devexit nvec_kbd_remove(struct platform_device *pdev)
+{
+ input_unregister_device(keys_dev.input);
+ input_free_device(keys_dev.input);
+
+ return 0;
+}
+
static struct platform_driver nvec_kbd_driver = {
.probe = nvec_kbd_probe,
+ .remove = __devexit_p(nvec_kbd_remove),
.driver = {
.name = "nvec-kbd",
.owner = THIS_MODULE,
},
};
-static int __init nvec_kbd_init(void)
-{
- return platform_driver_register(&nvec_kbd_driver);
-}
-
-module_init(nvec_kbd_init);
+module_platform_driver(nvec_kbd_driver);
MODULE_AUTHOR("Marc Dietrich <marvin24@gmx.de>");
MODULE_DESCRIPTION("NVEC keyboard driver");
+++ /dev/null
-/*
- * nvec_leds: LED driver for a NVIDIA compliant embedded controller
- *
- * Copyright (C) 2011 The AC100 Kernel Team <ac100@lists.launchpad.net>
- *
- * Authors: Ilya Petrov <ilya.muromec@gmail.com>
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License. See the file "COPYING" in the main directory of this archive
- * for more details.
- *
- */
-
-#include <linux/module.h>
-#include <linux/err.h>
-#include <linux/slab.h>
-#include <linux/leds.h>
-#include <linux/platform_device.h>
-#include "nvec.h"
-
-#define to_nvec_led(led_cdev) \
- container_of(led_cdev, struct nvec_led, cdev)
-
-#define NVEC_LED_REQ {'\x0d', '\x10', '\x45', '\x10', '\x00'}
-
-#define NVEC_LED_MAX 8
-
-struct nvec_led {
- struct led_classdev cdev;
- struct nvec_chip *nvec;
-};
-
-static void nvec_led_brightness_set(struct led_classdev *led_cdev,
- enum led_brightness value)
-{
- struct nvec_led *led = to_nvec_led(led_cdev);
- unsigned char buf[] = NVEC_LED_REQ;
- buf[4] = value;
-
- nvec_write_async(led->nvec, buf, sizeof(buf));
-
- led->cdev.brightness = value;
-
-}
-
-static int __devinit nvec_led_probe(struct platform_device *pdev)
-{
- struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);
- struct nvec_led *led;
- int ret = 0;
-
- led = kzalloc(sizeof(*led), GFP_KERNEL);
- if (led == NULL)
- return -ENOMEM;
-
- led->cdev.max_brightness = NVEC_LED_MAX;
-
- led->cdev.brightness_set = nvec_led_brightness_set;
- led->cdev.name = "nvec-led";
- led->cdev.flags |= LED_CORE_SUSPENDRESUME;
- led->nvec = nvec;
-
- platform_set_drvdata(pdev, led);
-
- ret = led_classdev_register(&pdev->dev, &led->cdev);
- if (ret < 0)
- goto err_led;
-
- /* to expose the default value to userspace */
- led->cdev.brightness = 0;
-
- return 0;
-
-err_led:
- kfree(led);
- return ret;
-}
-
-static int __devexit nvec_led_remove(struct platform_device *pdev)
-{
- struct nvec_led *led = platform_get_drvdata(pdev);
-
- led_classdev_unregister(&led->cdev);
- kfree(led);
- return 0;
-}
-
-static struct platform_driver nvec_led_driver = {
- .probe = nvec_led_probe,
- .remove = __devexit_p(nvec_led_remove),
- .driver = {
- .name = "nvec-leds",
- .owner = THIS_MODULE,
- },
-};
-
-static int __init nvec_led_init(void)
-{
- return platform_driver_register(&nvec_led_driver);
-}
-
-module_init(nvec_led_init);
-
-static void __exit nvec_led_exit(void)
-{
- platform_driver_unregister(&nvec_led_driver);
-}
-
-module_exit(nvec_led_exit);
-
-MODULE_AUTHOR("Ilya Petrov <ilya.muromec@gmail.com>");
-MODULE_DESCRIPTION("Tegra NVEC LED driver");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:nvec-leds");
--- /dev/null
+/*
+ * nvec_paz00: OEM specific driver for Compal PAZ00 based devices
+ *
+ * Copyright (C) 2011 The AC100 Kernel Team <ac100@lists.launchpad.net>
+ *
+ * Authors: Ilya Petrov <ilya.muromec@gmail.com>
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/leds.h>
+#include <linux/platform_device.h>
+#include "nvec.h"
+
+#define to_nvec_led(led_cdev) \
+ container_of(led_cdev, struct nvec_led, cdev)
+
+#define NVEC_LED_REQ {'\x0d', '\x10', '\x45', '\x10', '\x00'}
+
+#define NVEC_LED_MAX 8
+
+struct nvec_led {
+ struct led_classdev cdev;
+ struct nvec_chip *nvec;
+};
+
+static void nvec_led_brightness_set(struct led_classdev *led_cdev,
+ enum led_brightness value)
+{
+ struct nvec_led *led = to_nvec_led(led_cdev);
+ unsigned char buf[] = NVEC_LED_REQ;
+ buf[4] = value;
+
+ nvec_write_async(led->nvec, buf, sizeof(buf));
+
+ led->cdev.brightness = value;
+
+}
+
+static int __devinit nvec_paz00_probe(struct platform_device *pdev)
+{
+ struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);
+ struct nvec_led *led;
+ int ret = 0;
+
+ led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
+ if (led == NULL)
+ return -ENOMEM;
+
+ led->cdev.max_brightness = NVEC_LED_MAX;
+
+ led->cdev.brightness_set = nvec_led_brightness_set;
+ led->cdev.name = "paz00-led";
+ led->cdev.flags |= LED_CORE_SUSPENDRESUME;
+ led->nvec = nvec;
+
+ platform_set_drvdata(pdev, led);
+
+ ret = led_classdev_register(&pdev->dev, &led->cdev);
+ if (ret < 0)
+ return ret;
+
+ /* to expose the default value to userspace */
+ led->cdev.brightness = 0;
+
+ return 0;
+}
+
+static int __devexit nvec_paz00_remove(struct platform_device *pdev)
+{
+ struct nvec_led *led = platform_get_drvdata(pdev);
+
+ led_classdev_unregister(&led->cdev);
+
+ return 0;
+}
+
+static struct platform_driver nvec_paz00_driver = {
+ .probe = nvec_paz00_probe,
+ .remove = __devexit_p(nvec_paz00_remove),
+ .driver = {
+ .name = "nvec-paz00",
+ .owner = THIS_MODULE,
+ },
+};
+
+module_platform_driver(nvec_paz00_driver);
+
+MODULE_AUTHOR("Ilya Petrov <ilya.muromec@gmail.com>");
+MODULE_DESCRIPTION("Tegra NVEC PAZ00 driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:nvec-paz00");
static int __devinit nvec_power_probe(struct platform_device *pdev)
{
struct power_supply *psy;
- struct nvec_power *power =
- kzalloc(sizeof(struct nvec_power), GFP_NOWAIT);
+ struct nvec_power *power;
struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);
+ power = devm_kzalloc(&pdev->dev, sizeof(struct nvec_power), GFP_NOWAIT);
+ if (power == NULL)
+ return -ENOMEM;
+
dev_set_drvdata(&pdev->dev, power);
power->nvec = nvec;
power->notifier.notifier_call = nvec_power_bat_notifier;
break;
default:
- kfree(power);
return -ENODEV;
}
return power_supply_register(&pdev->dev, psy);
}
+static int __devexit nvec_power_remove(struct platform_device *pdev)
+{
+ struct nvec_power *power = platform_get_drvdata(pdev);
+
+ cancel_delayed_work_sync(&power->poller);
+ switch (pdev->id) {
+ case AC:
+ power_supply_unregister(&nvec_psy);
+ break;
+ case BAT:
+ power_supply_unregister(&nvec_bat_psy);
+ }
+
+ return 0;
+}
+
static struct platform_driver nvec_power_driver = {
.probe = nvec_power_probe,
+ .remove = __devexit_p(nvec_power_remove),
.driver = {
.name = "nvec-power",
.owner = THIS_MODULE,
}
};
-static int __init nvec_power_init(void)
-{
- return platform_driver_register(&nvec_power_driver);
-}
-
-module_init(nvec_power_init);
+module_platform_driver(nvec_power_driver);
MODULE_AUTHOR("Ilya Petrov <ilya.muromec@gmail.com>");
MODULE_LICENSE("GPL");
static int __devinit nvec_mouse_probe(struct platform_device *pdev)
{
struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);
- struct serio *ser_dev = kzalloc(sizeof(struct serio), GFP_KERNEL);
+ struct serio *ser_dev;
+
+ ser_dev = devm_kzalloc(&pdev->dev, sizeof(struct serio), GFP_KERNEL);
+ if (ser_dev == NULL)
+ return -ENOMEM;
ser_dev->id.type = SERIO_PS_PSTHRU;
ser_dev->write = ps2_sendcommand;
return 0;
}
-static int nvec_mouse_suspend(struct platform_device *pdev, pm_message_t state)
+static int __devexit nvec_mouse_remove(struct platform_device *pdev)
+{
+ serio_unregister_port(ps2_dev.ser_dev);
+
+ return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int nvec_mouse_suspend(struct device *dev)
{
+ struct platform_device *pdev = to_platform_device(dev);
struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);
/* disable mouse */
return 0;
}
-static int nvec_mouse_resume(struct platform_device *pdev)
+static int nvec_mouse_resume(struct device *dev)
{
+ struct platform_device *pdev = to_platform_device(dev);
struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);
ps2_startstreaming(ps2_dev.ser_dev);
return 0;
}
+#endif
+
+static const SIMPLE_DEV_PM_OPS(nvec_mouse_pm_ops, nvec_mouse_suspend,
+ nvec_mouse_resume);
static struct platform_driver nvec_mouse_driver = {
.probe = nvec_mouse_probe,
- .suspend = nvec_mouse_suspend,
- .resume = nvec_mouse_resume,
+ .remove = __devexit_p(nvec_mouse_remove),
.driver = {
.name = "nvec-mouse",
.owner = THIS_MODULE,
+ .pm = &nvec_mouse_pm_ops,
},
};
-static int __init nvec_mouse_init(void)
-{
- return platform_driver_register(&nvec_mouse_driver);
-}
-
-module_init(nvec_mouse_init);
+module_platform_driver(nvec_mouse_driver);
MODULE_DESCRIPTION("NVEC mouse driver");
MODULE_AUTHOR("Marc Dietrich <marvin24@gmx.de>");
/* allocation list and lock */
struct list_head alloc_head;
- spinlock_t list_lock;
};
#endif
static struct tcm *containers[TILFMT_NFORMATS];
static struct dmm *omap_dmm;
+/* global spinlock for protecting lists */
+static DEFINE_SPINLOCK(list_lock);
+
/* Geometry table */
#define GEOM(xshift, yshift, bytes_per_pixel) { \
.x_shft = (xshift), \
down(&dmm->engine_sem);
/* grab an idle engine */
- spin_lock(&dmm->list_lock);
+ spin_lock(&list_lock);
if (!list_empty(&dmm->idle_head)) {
engine = list_entry(dmm->idle_head.next, struct refill_engine,
idle_node);
list_del(&engine->idle_node);
}
- spin_unlock(&dmm->list_lock);
+ spin_unlock(&list_lock);
BUG_ON(!engine);
}
cleanup:
- spin_lock(&dmm->list_lock);
+ spin_lock(&list_lock);
list_add(&engine->idle_node, &dmm->idle_head);
- spin_unlock(&dmm->list_lock);
+ spin_unlock(&list_lock);
up(&omap_dmm->engine_sem);
return ret;
}
/* add to allocation list */
- spin_lock(&omap_dmm->list_lock);
+ spin_lock(&list_lock);
list_add(&block->alloc_node, &omap_dmm->alloc_head);
- spin_unlock(&omap_dmm->list_lock);
+ spin_unlock(&list_lock);
return block;
}
return ERR_PTR(-ENOMEM);
}
- spin_lock(&omap_dmm->list_lock);
+ spin_lock(&list_lock);
list_add(&block->alloc_node, &omap_dmm->alloc_head);
- spin_unlock(&omap_dmm->list_lock);
+ spin_unlock(&list_lock);
return block;
}
if (block->area.tcm)
dev_err(omap_dmm->dev, "failed to release block\n");
- spin_lock(&omap_dmm->list_lock);
+ spin_lock(&list_lock);
list_del(&block->alloc_node);
- spin_unlock(&omap_dmm->list_lock);
+ spin_unlock(&list_lock);
kfree(block);
return ret;
if (omap_dmm) {
/* free all area regions */
- spin_lock(&omap_dmm->list_lock);
+ spin_lock(&list_lock);
list_for_each_entry_safe(block, _block, &omap_dmm->alloc_head,
alloc_node) {
list_del(&block->alloc_node);
kfree(block);
}
- spin_unlock(&omap_dmm->list_lock);
+ spin_unlock(&list_lock);
for (i = 0; i < omap_dmm->num_lut; i++)
if (omap_dmm->tcm && omap_dmm->tcm[i])
vfree(omap_dmm->lut);
- if (omap_dmm->irq != -1)
+ if (omap_dmm->irq > 0)
free_irq(omap_dmm->irq, omap_dmm);
iounmap(omap_dmm->base);
goto fail;
}
+ /* initialize lists */
+ INIT_LIST_HEAD(&omap_dmm->alloc_head);
+ INIT_LIST_HEAD(&omap_dmm->idle_head);
+
/* lookup hwmod data - base address and irq */
mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
if (!mem) {
}
sema_init(&omap_dmm->engine_sem, omap_dmm->num_engines);
- INIT_LIST_HEAD(&omap_dmm->idle_head);
for (i = 0; i < omap_dmm->num_engines; i++) {
omap_dmm->engines[i].id = i;
omap_dmm->engines[i].dmm = omap_dmm;
containers[TILFMT_32BIT] = omap_dmm->tcm[0];
containers[TILFMT_PAGE] = omap_dmm->tcm[0];
- INIT_LIST_HEAD(&omap_dmm->alloc_head);
- spin_lock_init(&omap_dmm->list_lock);
-
area = (struct tcm_area) {
.is2d = true,
.tcm = NULL,
return 0;
fail:
- omap_dmm_remove(dev);
+ if (omap_dmm_remove(dev))
+ dev_err(&dev->dev, "cleanup failed\n");
return ret;
}
map[i] = global_map + i * (w_adj + 1);
map[i][w_adj] = 0;
}
- spin_lock_irqsave(&omap_dmm->list_lock, flags);
+ spin_lock_irqsave(&list_lock, flags);
list_for_each_entry(block, &omap_dmm->alloc_head, alloc_node) {
if (block->fmt != TILFMT_PAGE) {
}
}
- spin_unlock_irqrestore(&omap_dmm->list_lock, flags);
+ spin_unlock_irqrestore(&list_lock, flags);
if (s) {
seq_printf(s, "BEGIN DMM TILER MAP\n");
TODO:
- - review user mode interface and determine if ioctls can be replaced
- with something better. correctly export data structures to user mode
- if ioctls are still required and allocate ioctl numbers from
- ioctl-number.txt.
+ - Convert event tracing code to in-kernel tracing infrastructure
+ - Check for remaining ioctl & check if that can be converted into
+ sysfs entries
+ - Convert debug prints to appropriate dev_debug or something better
+ - Modify Kconfig to add CONFIG option for enabling/disabling event
+ tracing.
- check USB HCD implementation is complete and correct.
- - remove any debug and trace code.
- code review by USB developer community.
- testing with as many devices as possible.
#define OZ_IOCTL_GET_PD_LIST _IOR(OZ_IOCTL_MAGIC, 0, struct oz_pd_list)
#define OZ_IOCTL_SET_ACTIVE_PD _IOW(OZ_IOCTL_MAGIC, 1, struct oz_mac_addr)
#define OZ_IOCTL_GET_ACTIVE_PD _IOR(OZ_IOCTL_MAGIC, 2, struct oz_mac_addr)
-#define OZ_IOCTL_ADD_BINDING _IOW(OZ_IOCTL_MAGIC, 5, struct oz_binding_info)
-#define OZ_IOCTL_REMOVE_BINDING _IOW(OZ_IOCTL_MAGIC, 8, struct oz_binding_info)
-#define OZ_IOCTL_MAX 9
+#define OZ_IOCTL_ADD_BINDING _IOW(OZ_IOCTL_MAGIC, 3, struct oz_binding_info)
+#define OZ_IOCTL_REMOVE_BINDING _IOW(OZ_IOCTL_MAGIC, 4, struct oz_binding_info)
+#define OZ_IOCTL_MAX 5
#endif /* _OZAPPIF_H */
/*------------------------------------------------------------------------------
*/
static struct oz_cdev g_cdev;
+struct class *g_oz_class;
/*------------------------------------------------------------------------------
* Context: process and softirq
*/
int oz_cdev_register(void)
{
int err;
+ struct device *dev;
memset(&g_cdev, 0, sizeof(g_cdev));
err = alloc_chrdev_region(&g_cdev.devnum, 0, 1, "ozwpan");
if (err < 0)
- return err;
+ goto out3;
oz_trace("Alloc dev number %d:%d\n", MAJOR(g_cdev.devnum),
MINOR(g_cdev.devnum));
cdev_init(&g_cdev.cdev, &oz_fops);
spin_lock_init(&g_cdev.lock);
init_waitqueue_head(&g_cdev.rdq);
err = cdev_add(&g_cdev.cdev, g_cdev.devnum, 1);
+ if (err < 0) {
+ oz_trace("Failed to add cdev\n");
+ goto out2;
+ }
+ g_oz_class = class_create(THIS_MODULE, "ozmo_wpan");
+ if (IS_ERR(g_oz_class)) {
+ oz_trace("Failed to register ozmo_wpan class\n");
+ goto out1;
+ }
+ dev = device_create(g_oz_class, NULL, g_cdev.devnum, NULL, "ozwpan");
+ if (IS_ERR(dev)) {
+ oz_trace("Failed to create sysfs entry for cdev\n");
+ goto out1;
+ }
return 0;
+out1:
+ cdev_del(&g_cdev.cdev);
+out2:
+ unregister_chrdev_region(g_cdev.devnum, 1);
+out3:
+ return err;
}
/*------------------------------------------------------------------------------
* Context: process
{
cdev_del(&g_cdev.cdev);
unregister_chrdev_region(g_cdev.devnum, 1);
+ if (g_oz_class) {
+ device_destroy(g_oz_class, g_cdev.devnum);
+ class_destroy(g_oz_class);
+ }
return 0;
}
/*------------------------------------------------------------------------------
MODULE_AUTHOR("Chris Kelly");
MODULE_DESCRIPTION("Ozmo Devices USB over WiFi hcd driver");
-MODULE_VERSION("1.0.9");
+MODULE_VERSION("1.0.10");
MODULE_LICENSE("GPL");
/*------------------------------------------------------------------------------
*/
#define OZ_MAX_TX_POOL_SIZE 6
-/* Maximum number of uncompleted isoc frames that can be pending.
+/* Maximum number of uncompleted isoc frames that can be pending in network.
*/
#define OZ_MAX_SUBMITTED_ISOC 16
+/* Maximum number of uncompleted isoc frames that can be pending in Tx Queue.
+ */
+#define OZ_MAX_TX_QUEUE_ISOC 32
/*------------------------------------------------------------------------------
*/
static struct oz_tx_frame *oz_tx_frame_alloc(struct oz_pd *pd);
static void oz_tx_frame_free(struct oz_pd *pd, struct oz_tx_frame *f);
+static void oz_tx_isoc_free(struct oz_pd *pd, struct oz_tx_frame *f);
static struct sk_buff *oz_build_frame(struct oz_pd *pd, struct oz_tx_frame *f);
static int oz_send_isoc_frame(struct oz_pd *pd);
static void oz_retire_frame(struct oz_pd *pd, struct oz_tx_frame *f);
static void oz_isoc_stream_free(struct oz_isoc_stream *st);
-static int oz_send_next_queued_frame(struct oz_pd *pd, int *more_data);
+static int oz_send_next_queued_frame(struct oz_pd *pd, int more_data);
static void oz_isoc_destructor(struct sk_buff *skb);
static int oz_def_app_init(void);
static void oz_def_app_term(void);
while (e != &pd->tx_queue) {
f = container_of(e, struct oz_tx_frame, link);
e = e->next;
+ if (f->skb != NULL)
+ kfree_skb(f->skb);
oz_retire_frame(pd, f);
}
oz_elt_buf_term(&pd->elt_buff);
}
return f;
}
+/*------------------------------------------------------------------------------
+ * Context: softirq or process
+ */
+static void oz_tx_isoc_free(struct oz_pd *pd, struct oz_tx_frame *f)
+{
+ pd->nb_queued_isoc_frames--;
+ list_del_init(&f->link);
+ if (pd->tx_pool_count < OZ_MAX_TX_POOL_SIZE) {
+ f->link.next = pd->tx_pool;
+ pd->tx_pool = &f->link;
+ pd->tx_pool_count++;
+ } else {
+ kfree(f);
+ }
+ oz_trace2(OZ_TRACE_TX_FRAMES, "Releasing ISOC Frame isoc_nb= %d\n",
+ pd->nb_queued_isoc_frames);
+}
/*------------------------------------------------------------------------------
* Context: softirq or process
*/
if (f)
kfree(f);
}
+/*------------------------------------------------------------------------------
+ * Context: softirq-serialized
+ */
+void oz_set_more_bit(struct sk_buff *skb)
+{
+ struct oz_hdr *oz_hdr = (struct oz_hdr *)skb_network_header(skb);
+ oz_hdr->control |= OZ_F_MORE_DATA;
+}
+/*------------------------------------------------------------------------------
+ * Context: softirq-serialized
+ */
+void oz_set_last_pkt_nb(struct oz_pd *pd, struct sk_buff *skb)
+{
+ struct oz_hdr *oz_hdr = (struct oz_hdr *)skb_network_header(skb);
+ oz_hdr->last_pkt_num = pd->trigger_pkt_num & OZ_LAST_PN_MASK;
+}
/*------------------------------------------------------------------------------
* Context: softirq
*/
f = oz_tx_frame_alloc(pd);
if (f == 0)
return -1;
+ f->skb = NULL;
f->hdr.control =
(OZ_PROTOCOL_VERSION<<OZ_VERSION_SHIFT) | OZ_F_ACK_REQUESTED;
++pd->last_tx_pkt_num;
/*------------------------------------------------------------------------------
* Context: softirq-serialized
*/
-static int oz_send_next_queued_frame(struct oz_pd *pd, int *more_data)
+static int oz_send_next_queued_frame(struct oz_pd *pd, int more_data)
{
struct sk_buff *skb;
struct oz_tx_frame *f;
struct list_head *e;
- *more_data = 0;
spin_lock(&pd->tx_frame_lock);
e = pd->last_sent_frame->next;
if (e == &pd->tx_queue) {
spin_unlock(&pd->tx_frame_lock);
return -1;
}
- pd->last_sent_frame = e;
- if (e->next != &pd->tx_queue)
- *more_data = 1;
f = container_of(e, struct oz_tx_frame, link);
+
+ if (f->skb != NULL) {
+ skb = f->skb;
+ oz_tx_isoc_free(pd, f);
+ spin_unlock(&pd->tx_frame_lock);
+ if (more_data)
+ oz_set_more_bit(skb);
+ oz_set_last_pkt_nb(pd, skb);
+ if ((int)atomic_read(&g_submitted_isoc) <
+ OZ_MAX_SUBMITTED_ISOC) {
+ if (dev_queue_xmit(skb) < 0) {
+ oz_trace2(OZ_TRACE_TX_FRAMES,
+ "Dropping ISOC Frame\n");
+ oz_event_log(OZ_EVT_TX_ISOC_DROP, 0, 0, 0, 0);
+ return -1;
+ }
+ atomic_inc(&g_submitted_isoc);
+ oz_trace2(OZ_TRACE_TX_FRAMES,
+ "Sending ISOC Frame, nb_isoc= %d\n",
+ pd->nb_queued_isoc_frames);
+ return 0;
+ } else {
+ kfree_skb(skb);
+ oz_trace2(OZ_TRACE_TX_FRAMES, "Dropping ISOC Frame>\n");
+ oz_event_log(OZ_EVT_TX_ISOC_DROP, 0, 0, 0, 0);
+ return -1;
+ }
+ }
+
+ pd->last_sent_frame = e;
skb = oz_build_frame(pd, f);
spin_unlock(&pd->tx_frame_lock);
+ if (more_data)
+ oz_set_more_bit(skb);
oz_trace2(OZ_TRACE_TX_FRAMES, "TX frame PN=0x%x\n", f->hdr.pkt_num);
if (skb) {
oz_event_log(OZ_EVT_TX_FRAME,
0, f->hdr.pkt_num);
if (dev_queue_xmit(skb) < 0)
return -1;
+
}
return 0;
}
*/
void oz_send_queued_frames(struct oz_pd *pd, int backlog)
{
- int more;
- if (backlog < OZ_MAX_QUEUED_FRAMES) {
- if (oz_send_next_queued_frame(pd, &more) >= 0) {
- while (more && oz_send_next_queued_frame(pd, &more))
- ;
- } else {
- if (((pd->mode & OZ_F_ISOC_ANYTIME) == 0)
- || (pd->isoc_sent == 0)) {
- if (oz_prepare_frame(pd, 1) >= 0)
- oz_send_next_queued_frame(pd, &more);
- }
+ while (oz_prepare_frame(pd, 0) >= 0)
+ backlog++;
+
+ switch (pd->mode & (OZ_F_ISOC_NO_ELTS | OZ_F_ISOC_ANYTIME)) {
+
+ case OZ_F_ISOC_NO_ELTS: {
+ backlog += pd->nb_queued_isoc_frames;
+ if (backlog <= 0)
+ goto out;
+ if (backlog > OZ_MAX_SUBMITTED_ISOC)
+ backlog = OZ_MAX_SUBMITTED_ISOC;
+ break;
+ }
+ case OZ_NO_ELTS_ANYTIME: {
+ if ((backlog <= 0) && (pd->isoc_sent == 0))
+ goto out;
+ break;
+ }
+ default: {
+ if (backlog <= 0)
+ goto out;
+ break;
}
- } else {
- oz_send_next_queued_frame(pd, &more);
}
+ while (backlog--) {
+ if (oz_send_next_queued_frame(pd, backlog) < 0)
+ break;
+ }
+ return;
+
+out: oz_prepare_frame(pd, 1);
+ oz_send_next_queued_frame(pd, 0);
}
/*------------------------------------------------------------------------------
* Context: softirq
f = container_of(e, struct oz_tx_frame, link);
pkt_num = le32_to_cpu(get_unaligned(&f->hdr.pkt_num));
diff = (lpn - (pkt_num & OZ_LAST_PN_MASK)) & OZ_LAST_PN_MASK;
- if (diff > OZ_LAST_PN_HALF_CYCLE)
+ if ((diff > OZ_LAST_PN_HALF_CYCLE) || (pkt_num == 0))
break;
+ oz_trace2(OZ_TRACE_TX_FRAMES, "Releasing pkt_num= %u, nb= %d\n",
+ pkt_num, pd->nb_queued_frames);
if (first == 0)
first = e;
last = e;
skb_reset_network_header(skb);
skb->dev = dev;
skb->protocol = htons(OZ_ETHERTYPE);
+ /* For audio packet set priority to AC_VO */
+ skb->priority = 0x7;
size = sizeof(struct oz_hdr) + sizeof(struct oz_isoc_large);
oz_hdr = (struct oz_hdr *)skb_put(skb, size);
}
memcpy(oz_hdr, &oz, sizeof(oz));
memcpy(oz_hdr+1, &iso, sizeof(iso));
if (dev_hard_header(skb, dev, OZ_ETHERTYPE, pd->mac_addr,
- dev->dev_addr, skb->len) < 0) {
- kfree_skb(skb);
- return -1;
+ dev->dev_addr, skb->len) < 0)
+ goto out;
+
+ skb->destructor = oz_isoc_destructor;
+ /*Queue for Xmit if mode is not ANYTIME*/
+ if (!(pd->mode & OZ_F_ISOC_ANYTIME)) {
+ struct oz_tx_frame *isoc_unit = NULL;
+ int nb = pd->nb_queued_isoc_frames;
+ if (nb >= OZ_MAX_TX_QUEUE_ISOC) {
+ oz_trace2(OZ_TRACE_TX_FRAMES,
+ "Dropping ISOC Unit nb= %d\n",
+ nb);
+ goto out;
+ }
+ isoc_unit = oz_tx_frame_alloc(pd);
+ if (isoc_unit == NULL)
+ goto out;
+ isoc_unit->hdr = oz;
+ isoc_unit->skb = skb;
+ spin_lock_bh(&pd->tx_frame_lock);
+ list_add_tail(&isoc_unit->link, &pd->tx_queue);
+ pd->nb_queued_isoc_frames++;
+ spin_unlock_bh(&pd->tx_frame_lock);
+ oz_trace2(OZ_TRACE_TX_FRAMES,
+ "Added ISOC Frame to Tx Queue isoc_nb= %d, nb= %d\n",
+ pd->nb_queued_isoc_frames, pd->nb_queued_frames);
+ oz_event_log(OZ_EVT_TX_ISOC, nb_units, iso.frame_number,
+ skb, atomic_read(&g_submitted_isoc));
+ return 0;
}
+
+ /*In ANYTIME mode Xmit unit immediately*/
if (atomic_read(&g_submitted_isoc) < OZ_MAX_SUBMITTED_ISOC) {
- skb->destructor = oz_isoc_destructor;
atomic_inc(&g_submitted_isoc);
oz_event_log(OZ_EVT_TX_ISOC, nb_units, iso.frame_number,
- skb, atomic_read(&g_submitted_isoc));
- if (dev_queue_xmit(skb) < 0)
+ skb, atomic_read(&g_submitted_isoc));
+ if (dev_queue_xmit(skb) < 0) {
+ oz_event_log(OZ_EVT_TX_ISOC_DROP, 0, 0, 0, 0);
return -1;
- } else {
- oz_event_log(OZ_EVT_TX_ISOC_DROP, 0, 0, 0, 0);
- kfree_skb(skb);
+ } else
+ return 0;
}
+
+out: oz_event_log(OZ_EVT_TX_ISOC_DROP, 0, 0, 0, 0);
+ kfree_skb(skb);
+ return -1;
+
}
return 0;
}
struct list_head link;
struct list_head elt_list;
struct oz_hdr hdr;
+ struct sk_buff *skb;
int total_size;
};
u8 ms_per_isoc;
unsigned max_stream_buffering;
int nb_queued_frames;
+ int nb_queued_isoc_frames;
struct list_head *tx_pool;
int tx_pool_count;
spinlock_t tx_frame_lock;
void oz_apps_term(void);
#endif /* Sentry */
-
pd->mode = body->mode;
pd->pd_info = body->pd_info;
if (pd->mode & OZ_F_ISOC_NO_ELTS) {
- pd->mode |= OZ_F_ISOC_ANYTIME;
pd->ms_per_isoc = body->ms_per_isoc;
if (!pd->ms_per_isoc)
pd->ms_per_isoc = 4;
}
if (pd && !dup && ((pd->mode & OZ_MODE_MASK) == OZ_MODE_TRIGGERED)) {
+ oz_trace2(OZ_TRACE_RX_FRAMES, "Received TRIGGER Frame\n");
pd->last_sent_frame = &pd->tx_queue;
if (oz_hdr->control & OZ_F_ACK) {
/* Retire completed frames */
int backlog = pd->nb_queued_frames;
pd->trigger_pkt_num = pkt_num;
/* Send queued frames */
- while (oz_prepare_frame(pd, 0) >= 0)
- ;
oz_send_queued_frames(pd, backlog);
}
}
{
struct oz_binding *binding;
- binding = kmalloc(sizeof(struct oz_binding), GFP_ATOMIC);
+ binding = kmalloc(sizeof(struct oz_binding), GFP_KERNEL);
if (binding) {
binding->ptype.type = __constant_htons(OZ_ETHERTYPE);
binding->ptype.func = oz_pkt_recv;
#define OZ_MODE_MASK 0xf
#define OZ_F_ISOC_NO_ELTS 0x40
#define OZ_F_ISOC_ANYTIME 0x80
+#define OZ_NO_ELTS_ANYTIME 0xc0
/* Keep alive field.
*/
static unsigned long cnt;
cnt++;
if (!(cnt&(cnt-1)))
- pr_err("ramster_remote_put: message failed, "
- "ret=%d, cnt=%lu\n", ret, cnt);
+ pr_err("ramster_remote_put: message failed, ret=%d, cnt=%lu\n",
+ ret, cnt);
ret = -1;
}
#endif
return -EINVAL;
if (wrqu->retry.flags & IW_RETRY_MAX) {
- wrqu->retry.flags = IW_RETRY_LIMIT & IW_RETRY_MAX;
+ wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
wrqu->retry.value = priv->retry_rts;
} else {
- wrqu->retry.flags = IW_RETRY_LIMIT & IW_RETRY_MIN;
+ wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
wrqu->retry.value = priv->retry_data;
}
return -EINVAL;
if (wrqu->retry.flags & IW_RETRY_MAX) {
- wrqu->retry.flags = IW_RETRY_LIMIT & IW_RETRY_MAX;
+ wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
wrqu->retry.value = priv->retry_rts;
} else {
- wrqu->retry.flags = IW_RETRY_LIMIT & IW_RETRY_MIN;
+ wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
wrqu->retry.value = priv->retry_data;
}
return 0;
#include "usb_ops.h"
#include "usb_osintf.h"
-#define DRVER "v7_0.20100831"
-
static struct usb_interface *pintf;
static int r871xu_drv_init(struct usb_interface *pusb_intf,
struct net_device *pnetdev;
struct usb_device *udev;
- printk(KERN_INFO "r8712u: DriverVersion: %s\n", DRVER);
+ printk(KERN_INFO "r8712u: Staging version\n");
/* In this probe function, O.S. will provide the usb interface pointer
* to driver. We have to increase the reference count of the usb device
* structure by using the usb_get_dev function.
break;
}
- if (chip->option.auto_delink_en && !chip->card_ready) {
+ if (chip->option.auto_delink_en && !chip->card_ready)
rts51x_auto_delink(chip);
- } else {
+ else
chip->auto_delink_counter = 0;
- }
}
void rts51x_add_cmd(struct rts51x_chip *chip,
/*---- error code ----*/
#define CUR_ERR 0x70 /* current error */
-/*---- sense key Infomation ----*/
+/*---- sense key Information ----*/
#define SKSV 0x80
#define CDB_ILLEGAL 0x40
#include "rts51x_card.h"
#include "rts51x_fop.h"
#include "sd_cprm.h"
-#include "rts51x.h"
#define RTS5139_IOC_MAGIC 0x39
#define GET_BATCHRSP 0x44
#ifdef SUPPORT_CPRM
-/* SD Pass Through Command Extention */
+/* SD Pass Through Command Extension */
#define SD_PASS_THRU_MODE 0xD0
#define SD_EXECUTE_NO_DATA 0xD1
#define SD_EXECUTE_READ 0xD2
if (buf[1] & 0x80)
TRACE_RET(chip, STATUS_FAIL);
}
- if (buf[1] & 0x7F) {
+ if (buf[1] & 0x7F)
TRACE_RET(chip, STATUS_FAIL);
- }
if (buf[2] & 0xF8)
TRACE_RET(chip, STATUS_FAIL);
return STATUS_SUCCESS;
}
-static int ext_sd_get_rsp(struct rts51x_chip *chip, int len, u8 *rsp, u8 rsp_type)
+static int ext_sd_get_rsp(struct rts51x_chip *chip, int len,
+ u8 *rsp, u8 rsp_type)
{
int retval, rsp_len;
u16 reg_addr;
buf[15] = chip->max_lun;
- len = min(18, (int)scsi_bufflen(srb));
+ len = min_t(unsigned, 18, scsi_bufflen(srb));
rts51x_set_xfer_buf(buf, len, srb);
return TRANSPORT_GOOD;
if (!CHK_MSPRO(ms_card)) {
/* Build table for the last segment,
- * to check if L2P talbe block exist,erasing it
+ * to check if L2P table block exists, erasing it
*/
retval = ms_build_l2p_tbl(chip, ms_card->total_block / 512 - 1);
if (retval != STATUS_SUCCESS) {
RTSX_DEBUGP("func_group4_mask = 0x%02x\n", buf[0x07]);
} else {
/* Maximum current consumption, check whether current is acceptable;
- * bit[511:496] = 0x0000 means some error happaned.
+ * bit[511:496] = 0x0000 means some error happened.
*/
u16 cc = ((u16)buf[0] << 8) | buf[1];
RTSX_DEBUGP("Maximum current consumption: %dmA\n", cc);
SBE_2T3E3_21143_VAL_NUMBER_OF_RECEIVE_PACKETS;
dc_write(sc->addr, SBE_2T3E3_21143_REG_GENERAL_PURPOSE_TIMER_AND_INTERRUPT_MITIGATION_CONTROL, val);
- /* prepare descriptors and data for receive and transmit procecsses */
+ /* prepare descriptors and data for receive and transmit processes */
if (dc_init_descriptor_list(sc) != 0)
return;
/* All access to registers done via the 21143 on port 0 must be
* protected via the card->bootrom_lock. */
-/* priviate define to be used here only - must be protected by card->bootrom_lock */
+/* private define to be used here only - must be protected by card->bootrom_lock */
#define cpld_write_nolock(channel, reg, val) \
bootrom_write((channel), CPLD_MAP_REG(reg, channel), val)
* @size: size of parameter to copy (in bytes)
* @max_size: size to move up offset; SEP mesg is in word sizes
* @msg_offset: pointer to current offset (is updated)
- * @byte_array: flag ti indicate wheter endian must be changed
+ * @byte_array: flag ti indicate whether endian must be changed
* Copies data into the message area from caller
*/
static void sep_write_msg(struct this_task_ctx *ta_ctx, void *in_addr,
* @size: size of parameter to copy (in bytes)
* @max_size: size to move up offset; SEP mesg is in word sizes
* @msg_offset: pointer to current offset (is updated)
- * @byte_array: flag ti indicate wheter endian must be changed
+ * @byte_array: flag ti indicate whether endian must be changed
* Copies data out of the message area to caller
*/
static void sep_read_msg(struct this_task_ctx *ta_ctx, void *in_addr,
/**
* The following unlocks the sep and makes it available
* to any other application
- * First, null out crypto entries in sep before relesing it
+ * First, null out crypto entries in sep before releasing it
*/
ta_ctx->sep_used->current_hash_req = NULL;
ta_ctx->sep_used->current_cypher_req = NULL;
ta_ctx->call_status.status = 0;
- /* Remove anything confidentail */
+ /* Remove anything confidential */
memset(ta_ctx->sep_used->shared_addr, 0,
SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES);
current->comm, sizeof(current->comm));
if (!ta_ctx->queue_elem) {
- dev_dbg(&sep->pdev->dev, "[PID%d] updating queue"
- " status error\n", current->pid);
+ dev_dbg(&sep->pdev->dev,
+ "[PID%d] updating queue status error\n", current->pid);
return -EINVAL;
}
req->nbytes, ta_ctx->walk.blocksize, &new_sg, 1);
if (int_error < 0) {
- dev_warn(&ta_ctx->sep_used->pdev->dev, "oddball page eerror\n");
+ dev_warn(&ta_ctx->sep_used->pdev->dev, "oddball page error\n");
return -ENOMEM;
} else if (int_error == 1) {
ta_ctx->src_sg = new_sg;
sizeof(struct sep_hash_private_context));
/**
- * Following is only for finup; if we just completd the
+ * Following is only for finup; if we just completed the
* data portion of finup, we now need to kick off the
* finish portion of finup.
*/
}
/**
- * The sep_finish function is the function that is schedule (via tasket)
+ * The sep_finish function is the function that is scheduled (via tasklet)
* by the interrupt service routine when the SEP sends and interrupt
* This is only called by the interrupt handler as a tasklet.
*/
head_len = (block_size - int_ctx->prev_update_bytes) % block_size;
tail_len = (req->nbytes - head_len) % block_size;
- /* Make sure all pages are even block */
+ /* Make sure all pages are an even block */
int_error = sep_oddball_pages(ta_ctx->sep_used, req->src,
req->nbytes,
block_size, &new_sg, 1);
dev_dbg(&ta_ctx->sep_used->pdev->dev, "block_size is %x\n", block_size);
dev_dbg(&ta_ctx->sep_used->pdev->dev, "tail len is %x\n", tail_len);
- /* Make sure all pages are even block */
+ /* Make sure all pages are an even block */
int_error = sep_oddball_pages(ta_ctx->sep_used, req->src,
req->nbytes,
block_size, &new_sg, 1);
};
/*
- command structure for building dcb block (currently for ext app only
+ command structure for building dcb block (currently for ext app only)
*/
struct build_dcb_struct {
/* address value of the data in */
u32 dmatables_len;
/* size of input data */
u32 input_data_len;
- /* secure dma use (for imr memory restriced area in output */
+ /* secure dma use (for imr memory restricted area in output) */
bool secure_dma;
struct sep_dma_resource dma_res_arr[SEP_MAX_NUM_SYNC_DMA_OPS];
/* Scatter gather for kernel crypto */
/**
* sep_free_dma_table_data_handler - free DMA table
- * @sep: pointere to struct sep_device
+ * @sep: pointer to struct sep_device
* @dma_ctx: dma context
*
- * Handles the request to free DMA table for synchronic actions
+ * Handles the request to free DMA table for synchronic actions
*/
int sep_free_dma_table_data_handler(struct sep_device *sep,
struct sep_dma_context **dma_ctx);
#define SEP_DRIVER_POLLING_MODE 0
/* flag which defines if the shared area address should be
- reconfiged (send to SEP anew) during init of the driver */
+ reconfigured (send to SEP anew) during init of the driver */
#define SEP_DRIVER_RECONFIG_MESSAGE_AREA 0
/* the mode for running on the ARM1172 Evaluation platform (flag is 1) */
(SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES + \
SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES)
-/* synhronic dma tables area offset */
+/* synchronic dma tables area offset */
#define SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES \
(SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + \
SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES)
#endif
/**
- * Currenlty, there is only one SEP device per platform;
+ * Currently, there is only one SEP device per platform;
* In event platforms in the future have more than one SEP
* device, this will be a linked list
*/
* @sep: SEP device
* @sep_queue_info: pointer to status queue
*
- * This function will removes information about transaction from the queue.
+ * This function will remove information about transaction from the queue.
*/
void sep_queue_status_remove(struct sep_device *sep,
struct sep_queue_info **queue_elem)
end_function_setpid:
/*
* The pid_doing_transaction indicates that this process
- * now owns the facilities to performa a transaction with
+ * now owns the facilities to perform a transaction with
* the SEP. While this process is performing a transaction,
* no other process who has the SEP device open can perform
* any transactions. This method allows more than one process
/**
* sep_free_dma_table_data_handler - free DMA table
- * @sep: pointere to struct sep_device
+ * @sep: pointer to struct sep_device
* @dma_ctx: dma context
*
- * Handles the request to free DMA table for synchronic actions
+ * Handles the request to free DMA table for synchronic actions
*/
int sep_free_dma_table_data_handler(struct sep_device *sep,
struct sep_dma_context **dma_ctx)
* don't have a page array; the page array is generated
* only in the lock_user_pages, which is not called
* for kernel crypto, which is what the sg (scatter gather
- * is used for exclusively
+ * is used for exclusively)
*/
if (dma->src_sg) {
dma_unmap_sg(&sep->pdev->dev, dma->src_sg,
/* Map array */
struct sep_dma_map *map_array;
- /* Set start and end pages and num pages */
+ /* Set start and end pages and num pages */
end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT;
start_page = app_virt_addr >> PAGE_SHIFT;
num_pages = end_page - start_page + 1;
/* Array of lli */
struct sep_lli_entry *lli_array;
- /* Set start and end pages and num pages */
+ /* Set start and end pages and num pages */
end_page = (app_virt_addr + data_size - 1) >> PAGE_SHIFT;
start_page = app_virt_addr >> PAGE_SHIFT;
num_pages = end_page - start_page + 1;
- dev_dbg(&sep->pdev->dev, "[PID%d] lock user pages"
- " app_virt_addr is %x\n", current->pid, app_virt_addr);
+ dev_dbg(&sep->pdev->dev,
+ "[PID%d] lock user pages app_virt_addr is %x\n",
+ current->pid, app_virt_addr);
dev_dbg(&sep->pdev->dev, "[PID%d] data_size is (hex) %x\n",
current->pid, data_size);
* @num_table_entries_ptr: pointer to number of tables
* @table_data_size: total data size
*
- * Builds ant lli table from the lli_array according to
+ * Builds an lli table from the lli_array according to
* the given size of data
*/
static void sep_build_lli_table(struct sep_device *sep,
* @virt_address: virtual address to convert
*
* This functions returns the physical address inside shared area according
- * to the virtual address. It can be either on the externa RAM device
+ * to the virtual address. It can be either on the external RAM device
* (ioremapped), or on the system RAM
* This implementation is for the external RAM
*/
*
* This functions returns the virtual address inside shared area
* according to the physical address. It can be either on the
- * externa RAM device (ioremapped), or on the system RAM
+ * external RAM device (ioremapped), or on the system RAM
* This implementation is for the external RAM
*/
static void *sep_shared_area_bus_to_virt(struct sep_device *sep,
* @lli_table_ptr:
* @num_entries_ptr:
* @table_data_size_ptr:
- * @is_kva: set for kernel data (kernel cryptio call)
+ * @is_kva: set for kernel data (kernel crypt io call)
*
- * This function prepares only input DMA table for synhronic symmetric
+ * This function prepares only input DMA table for synchronic symmetric
* operations (HASH)
* Note that all bus addresses that are passed to the SEP
* are in 32 bit format; the SEP is a 32 bit device
void *dma_lli_table_alloc_addr = NULL;
void *dma_in_lli_table_ptr = NULL;
- dev_dbg(&sep->pdev->dev, "[PID%d] prepare intput dma "
- "tbl data size: (hex) %x\n",
- current->pid, data_size);
+ dev_dbg(&sep->pdev->dev,
+ "[PID%d] prepare intput dma tbl data size: (hex) %x\n",
+ current->pid, data_size);
dev_dbg(&sep->pdev->dev, "[PID%d] block_size is (hex) %x\n",
current->pid, block_size);
u32 last_table_flag = 0;
/* The data size that should be in table */
u32 table_data_size = 0;
- /* Number of etnries in the input table */
+ /* Number of entries in the input table */
u32 num_entries_in_table = 0;
- /* Number of etnries in the output table */
+ /* Number of entries in the output table */
u32 num_entries_out_table = 0;
if (!dma_ctx) {
* @table_data_size_ptr:
* @is_kva: set for kernel data; used only for kernel crypto module
*
- * This function builds input and output DMA tables for synhronic
+ * This function builds input and output DMA tables for synchronic
* symmetric operations (AES, DES, HASH). It also checks that each table
* is of the modular block size
* Note that all bus addresses that are passed to the SEP
}
}
- dev_dbg(&sep->pdev->dev, "[PID%d] After lock; prep input output dma "
- "table sep_in_num_pages is (hex) %x\n", current->pid,
+ dev_dbg(&sep->pdev->dev,
+ "[PID%d] After lock; prep input output dma table sep_in_num_pages is (hex) %x\n",
+ current->pid,
dma_ctx->dma_res_arr[dma_ctx->nr_dcb_creat].in_num_pages);
dev_dbg(&sep->pdev->dev, "[PID%d] sep_out_num_pages is (hex) %x\n",
current->pid,
dma_ctx->dma_res_arr[dma_ctx->nr_dcb_creat].out_num_pages);
- dev_dbg(&sep->pdev->dev, "[PID%d] SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP"
- " is (hex) %x\n", current->pid,
- SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
+ dev_dbg(&sep->pdev->dev,
+ "[PID%d] SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is (hex) %x\n",
+ current->pid, SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP);
- /* Call the fucntion that creates table from the lli arrays */
+ /* Call the function that creates table from the lli arrays */
dev_dbg(&sep->pdev->dev, "[PID%d] calling create table from lli\n",
current->pid);
error = sep_construct_dma_tables_from_lli(
goto end_function;
}
- /* Checks that user has called necessarry apis */
+ /* Checks that user has called necessary apis */
if (0 == test_bit(SEP_FASTCALL_WRITE_DONE_OFFSET,
&call_status->status)) {
dev_warn(&sep->pdev->dev,
* buffers created. Only SEP_DOUBLEBUF_USERS_LIMIT number
* of threads can progress further at a time
*/
- dev_dbg(&sep->pdev->dev, "[PID%d] waiting for double buffering "
- "region access\n", current->pid);
+ dev_dbg(&sep->pdev->dev,
+ "[PID%d] waiting for double buffering region access\n",
+ current->pid);
error = down_interruptible(&sep->sep_doublebuf);
dev_dbg(&sep->pdev->dev, "[PID%d] double buffering region start\n",
current->pid);
current->comm, sizeof(current->comm));
if (!my_queue_elem) {
- dev_dbg(&sep->pdev->dev, "[PID%d] updating queue"
- "status error\n", current->pid);
+ dev_dbg(&sep->pdev->dev,
+ "[PID%d] updating queue status error\n", current->pid);
error = -ENOMEM;
goto end_function_error_doublebuf;
}
INIT_LIST_HEAD(&sep->sep_queue_status);
- dev_dbg(&sep->pdev->dev, "sep probe: PCI obtained, "
- "device being prepared\n");
+ dev_dbg(&sep->pdev->dev,
+ "sep probe: PCI obtained, device being prepared\n");
/* Set up our register area */
sep->reg_physical_addr = pci_resource_start(sep->pdev, 0);
static DEFINE_PCI_DEVICE_TABLE(sep_pci_id_tbl) = {
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x0826)},
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x08e9)},
- {0}
+ {0}
};
/* Export our pci_device_id structure to user space */
/*
* qt_setuart
- * issuse a SET_UART vendor-spcific request on the default control pipe
+ * issues a SET_UART vendor-specific request on the default control pipe
* If successful sets baud rate divisor and LCR value
*/
static int qt_setuart(struct usb_serial *serial, unsigned short Uart_Number,
return -ESPIPE;
/*
- * Turn off the RTS and DTR and loopbcck and then only turn on what was
+ * Turn off the RTS and DTR and loopback and then only turn on what was
* asked for
*/
mcr &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP);
* Oasis cards (single and dual port PCI-x Gigabit) copper and fiber
* Kalahari cards (dual and quad port PCI-e Gigabit) copper and fiber
*
- * The driver was acutally tested on Oasis and Kalahari cards.
+ * The driver was actually tested on Oasis and Kalahari cards.
*
*
* NOTE: This is the standard, non-accelerated version of Alacritech's
+++ /dev/null
-config FB_SM7XX
- tristate "Silicon Motion SM7XX Frame Buffer Support"
- depends on FB
- select FB_CFB_FILLRECT
- select FB_CFB_COPYAREA
- select FB_CFB_IMAGEBLIT
- help
- Frame Buffer driver for the Silicon Motion SM7XX serial graphic card.
+++ /dev/null
-obj-$(CONFIG_FB_SM7XX) += sm7xx.o
-
-sm7xx-y := smtcfb.o
+++ /dev/null
-TODO:
-- Dual head support
-- 2D acceleration support
-- use kernel coding style
-- refine the code and remove unused code
-- move it to drivers/video/sm7xx/ or make it be drivers/video/sm7xxfb.c
-
-Please send any patches to Greg Kroah-Hartman <greg@kroah.com> and
-Teddy Wang <teddy.wang@siliconmotion.com.cn>.
+++ /dev/null
-/*
- * Silicon Motion SM7XX frame buffer device
- *
- * Copyright (C) 2006 Silicon Motion Technology Corp.
- * Authors: Ge Wang, gewang@siliconmotion.com
- * Boyod boyod.yang@siliconmotion.com.cn
- *
- * Copyright (C) 2009 Lemote, Inc.
- * Author: Wu Zhangjin, wuzhangjin@gmail.com
- *
- * Copyright (C) 2011 Igalia, S.L.
- * Author: Javier M. Mellid <jmunhoz@igalia.com>
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License. See the file COPYING in the main directory of this archive for
- * more details.
- *
- */
-
-#include <linux/io.h>
-#include <linux/fb.h>
-#include <linux/pci.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/uaccess.h>
-#include <linux/module.h>
-#include <linux/console.h>
-#include <linux/screen_info.h>
-
-#ifdef CONFIG_PM
-#include <linux/pm.h>
-#endif
-
-#include "smtcfb.h"
-
-struct screen_info smtc_screen_info;
-
-/*
-* Private structure
-*/
-struct smtcfb_info {
- struct fb_info fb;
- struct pci_dev *pdev;
- struct {
- u8 red, green, blue;
- } palette[NR_RGB];
- u_int palette_size;
-
- u16 chipID;
- unsigned char __iomem *m_pMMIO;
- char __iomem *m_pLFB;
- char *m_pDPR;
- char *m_pVPR;
- char *m_pCPR;
-
- u_int width;
- u_int height;
- u_int hz;
- u_long BaseAddressInVRAM;
- u8 chipRevID;
-};
-
-struct vesa_mode_table {
- char mode_index[6];
- u16 lfb_width;
- u16 lfb_height;
- u16 lfb_depth;
-};
-
-static struct vesa_mode_table vesa_mode[] = {
- {"0x301", 640, 480, 8},
- {"0x303", 800, 600, 8},
- {"0x305", 1024, 768, 8},
- {"0x307", 1280, 1024, 8},
-
- {"0x311", 640, 480, 16},
- {"0x314", 800, 600, 16},
- {"0x317", 1024, 768, 16},
- {"0x31A", 1280, 1024, 16},
-
- {"0x312", 640, 480, 24},
- {"0x315", 800, 600, 24},
- {"0x318", 1024, 768, 24},
- {"0x31B", 1280, 1024, 24},
-};
-
-char __iomem *smtc_RegBaseAddress; /* Memory Map IO starting address */
-char __iomem *smtc_VRAMBaseAddress; /* video memory starting address */
-
-static u32 colreg[17];
-
-static struct fb_var_screeninfo smtcfb_var = {
- .xres = 1024,
- .yres = 600,
- .xres_virtual = 1024,
- .yres_virtual = 600,
- .bits_per_pixel = 16,
- .red = {16, 8, 0},
- .green = {8, 8, 0},
- .blue = {0, 8, 0},
- .activate = FB_ACTIVATE_NOW,
- .height = -1,
- .width = -1,
- .vmode = FB_VMODE_NONINTERLACED,
-};
-
-static struct fb_fix_screeninfo smtcfb_fix = {
- .id = "sm712fb",
- .type = FB_TYPE_PACKED_PIXELS,
- .visual = FB_VISUAL_TRUECOLOR,
- .line_length = 800 * 3,
- .accel = FB_ACCEL_SMI_LYNX,
-};
-
-static void sm712_set_timing(struct smtcfb_info *sfb)
-{
- int i = 0, j = 0;
- u32 m_nScreenStride;
-
- dev_dbg(&sfb->pdev->dev,
- "sfb->width=%d sfb->height=%d "
- "sfb->fb.var.bits_per_pixel=%d sfb->hz=%d\n",
- sfb->width, sfb->height, sfb->fb.var.bits_per_pixel, sfb->hz);
-
- for (j = 0; j < numVGAModes; j++) {
- if (VGAMode[j].mmSizeX == sfb->width &&
- VGAMode[j].mmSizeY == sfb->height &&
- VGAMode[j].bpp == sfb->fb.var.bits_per_pixel &&
- VGAMode[j].hz == sfb->hz) {
-
- dev_dbg(&sfb->pdev->dev,
- "VGAMode[j].mmSizeX=%d VGAMode[j].mmSizeY=%d "
- "VGAMode[j].bpp=%d VGAMode[j].hz=%d\n",
- VGAMode[j].mmSizeX, VGAMode[j].mmSizeY,
- VGAMode[j].bpp, VGAMode[j].hz);
-
- dev_dbg(&sfb->pdev->dev, "VGAMode index=%d\n", j);
-
- smtc_mmiowb(0x0, 0x3c6);
-
- smtc_seqw(0, 0x1);
-
- smtc_mmiowb(VGAMode[j].Init_MISC, 0x3c2);
-
- /* init SEQ register SR00 - SR04 */
- for (i = 0; i < SIZE_SR00_SR04; i++)
- smtc_seqw(i, VGAMode[j].Init_SR00_SR04[i]);
-
- /* init SEQ register SR10 - SR24 */
- for (i = 0; i < SIZE_SR10_SR24; i++)
- smtc_seqw(i + 0x10,
- VGAMode[j].Init_SR10_SR24[i]);
-
- /* init SEQ register SR30 - SR75 */
- for (i = 0; i < SIZE_SR30_SR75; i++)
- if (((i + 0x30) != 0x62) \
- && ((i + 0x30) != 0x6a) \
- && ((i + 0x30) != 0x6b))
- smtc_seqw(i + 0x30,
- VGAMode[j].Init_SR30_SR75[i]);
-
- /* init SEQ register SR80 - SR93 */
- for (i = 0; i < SIZE_SR80_SR93; i++)
- smtc_seqw(i + 0x80,
- VGAMode[j].Init_SR80_SR93[i]);
-
- /* init SEQ register SRA0 - SRAF */
- for (i = 0; i < SIZE_SRA0_SRAF; i++)
- smtc_seqw(i + 0xa0,
- VGAMode[j].Init_SRA0_SRAF[i]);
-
- /* init Graphic register GR00 - GR08 */
- for (i = 0; i < SIZE_GR00_GR08; i++)
- smtc_grphw(i, VGAMode[j].Init_GR00_GR08[i]);
-
- /* init Attribute register AR00 - AR14 */
- for (i = 0; i < SIZE_AR00_AR14; i++)
- smtc_attrw(i, VGAMode[j].Init_AR00_AR14[i]);
-
- /* init CRTC register CR00 - CR18 */
- for (i = 0; i < SIZE_CR00_CR18; i++)
- smtc_crtcw(i, VGAMode[j].Init_CR00_CR18[i]);
-
- /* init CRTC register CR30 - CR4D */
- for (i = 0; i < SIZE_CR30_CR4D; i++)
- smtc_crtcw(i + 0x30,
- VGAMode[j].Init_CR30_CR4D[i]);
-
- /* init CRTC register CR90 - CRA7 */
- for (i = 0; i < SIZE_CR90_CRA7; i++)
- smtc_crtcw(i + 0x90,
- VGAMode[j].Init_CR90_CRA7[i]);
- }
- }
- smtc_mmiowb(0x67, 0x3c2);
-
- /* set VPR registers */
- writel(0x0, sfb->m_pVPR + 0x0C);
- writel(0x0, sfb->m_pVPR + 0x40);
-
- /* set data width */
- m_nScreenStride =
- (sfb->width * sfb->fb.var.bits_per_pixel) / 64;
- switch (sfb->fb.var.bits_per_pixel) {
- case 8:
- writel(0x0, sfb->m_pVPR + 0x0);
- break;
- case 16:
- writel(0x00020000, sfb->m_pVPR + 0x0);
- break;
- case 24:
- writel(0x00040000, sfb->m_pVPR + 0x0);
- break;
- case 32:
- writel(0x00030000, sfb->m_pVPR + 0x0);
- break;
- }
- writel((u32) (((m_nScreenStride + 2) << 16) | m_nScreenStride),
- sfb->m_pVPR + 0x10);
-
-}
-
-static void sm712_setpalette(int regno, unsigned red, unsigned green,
- unsigned blue, struct fb_info *info)
-{
- struct smtcfb_info *sfb = info->par;
-
- if (sfb->BaseAddressInVRAM)
- /*
- * second display palette for dual head. Enable CRT RAM, 6-bit
- * RAM
- */
- smtc_seqw(0x66, (smtc_seqr(0x66) & 0xC3) | 0x20);
- else
- /* primary display palette. Enable LCD RAM only, 6-bit RAM */
- smtc_seqw(0x66, (smtc_seqr(0x66) & 0xC3) | 0x10);
- smtc_mmiowb(regno, dac_reg);
- smtc_mmiowb(red >> 10, dac_val);
- smtc_mmiowb(green >> 10, dac_val);
- smtc_mmiowb(blue >> 10, dac_val);
-}
-
-static void smtc_set_timing(struct smtcfb_info *sfb)
-{
- switch (sfb->chipID) {
- case 0x710:
- case 0x712:
- case 0x720:
- sm712_set_timing(sfb);
- break;
- }
-}
-
-/* chan_to_field
- *
- * convert a colour value into a field position
- *
- * from pxafb.c
- */
-
-static inline unsigned int chan_to_field(unsigned int chan,
- struct fb_bitfield *bf)
-{
- chan &= 0xffff;
- chan >>= 16 - bf->length;
- return chan << bf->offset;
-}
-
-static int smtc_blank(int blank_mode, struct fb_info *info)
-{
- /* clear DPMS setting */
- switch (blank_mode) {
- case FB_BLANK_UNBLANK:
- /* Screen On: HSync: On, VSync : On */
- smtc_seqw(0x01, (smtc_seqr(0x01) & (~0x20)));
- smtc_seqw(0x6a, 0x16);
- smtc_seqw(0x6b, 0x02);
- smtc_seqw(0x21, (smtc_seqr(0x21) & 0x77));
- smtc_seqw(0x22, (smtc_seqr(0x22) & (~0x30)));
- smtc_seqw(0x23, (smtc_seqr(0x23) & (~0xc0)));
- smtc_seqw(0x24, (smtc_seqr(0x24) | 0x01));
- smtc_seqw(0x31, (smtc_seqr(0x31) | 0x03));
- break;
- case FB_BLANK_NORMAL:
- /* Screen Off: HSync: On, VSync : On Soft blank */
- smtc_seqw(0x01, (smtc_seqr(0x01) & (~0x20)));
- smtc_seqw(0x6a, 0x16);
- smtc_seqw(0x6b, 0x02);
- smtc_seqw(0x22, (smtc_seqr(0x22) & (~0x30)));
- smtc_seqw(0x23, (smtc_seqr(0x23) & (~0xc0)));
- smtc_seqw(0x24, (smtc_seqr(0x24) | 0x01));
- smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
- break;
- case FB_BLANK_VSYNC_SUSPEND:
- /* Screen On: HSync: On, VSync : Off */
- smtc_seqw(0x01, (smtc_seqr(0x01) | 0x20));
- smtc_seqw(0x20, (smtc_seqr(0x20) & (~0xB0)));
- smtc_seqw(0x6a, 0x0c);
- smtc_seqw(0x6b, 0x02);
- smtc_seqw(0x21, (smtc_seqr(0x21) | 0x88));
- smtc_seqw(0x22, ((smtc_seqr(0x22) & (~0x30)) | 0x20));
- smtc_seqw(0x23, ((smtc_seqr(0x23) & (~0xc0)) | 0x20));
- smtc_seqw(0x24, (smtc_seqr(0x24) & (~0x01)));
- smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
- smtc_seqw(0x34, (smtc_seqr(0x34) | 0x80));
- break;
- case FB_BLANK_HSYNC_SUSPEND:
- /* Screen On: HSync: Off, VSync : On */
- smtc_seqw(0x01, (smtc_seqr(0x01) | 0x20));
- smtc_seqw(0x20, (smtc_seqr(0x20) & (~0xB0)));
- smtc_seqw(0x6a, 0x0c);
- smtc_seqw(0x6b, 0x02);
- smtc_seqw(0x21, (smtc_seqr(0x21) | 0x88));
- smtc_seqw(0x22, ((smtc_seqr(0x22) & (~0x30)) | 0x10));
- smtc_seqw(0x23, ((smtc_seqr(0x23) & (~0xc0)) | 0xD8));
- smtc_seqw(0x24, (smtc_seqr(0x24) & (~0x01)));
- smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
- smtc_seqw(0x34, (smtc_seqr(0x34) | 0x80));
- break;
- case FB_BLANK_POWERDOWN:
- /* Screen On: HSync: Off, VSync : Off */
- smtc_seqw(0x01, (smtc_seqr(0x01) | 0x20));
- smtc_seqw(0x20, (smtc_seqr(0x20) & (~0xB0)));
- smtc_seqw(0x6a, 0x0c);
- smtc_seqw(0x6b, 0x02);
- smtc_seqw(0x21, (smtc_seqr(0x21) | 0x88));
- smtc_seqw(0x22, ((smtc_seqr(0x22) & (~0x30)) | 0x30));
- smtc_seqw(0x23, ((smtc_seqr(0x23) & (~0xc0)) | 0xD8));
- smtc_seqw(0x24, (smtc_seqr(0x24) & (~0x01)));
- smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
- smtc_seqw(0x34, (smtc_seqr(0x34) | 0x80));
- break;
- default:
- return -EINVAL;
- }
-
- return 0;
-}
-
-static int smtc_setcolreg(unsigned regno, unsigned red, unsigned green,
- unsigned blue, unsigned trans, struct fb_info *info)
-{
- struct smtcfb_info *sfb = (struct smtcfb_info *)info;
- u32 val;
-
- if (regno > 255)
- return 1;
-
- switch (sfb->fb.fix.visual) {
- case FB_VISUAL_DIRECTCOLOR:
- case FB_VISUAL_TRUECOLOR:
- /*
- * 16/32 bit true-colour, use pseuo-palette for 16 base color
- */
- if (regno < 16) {
- if (sfb->fb.var.bits_per_pixel == 16) {
- u32 *pal = sfb->fb.pseudo_palette;
- val = chan_to_field(red, &sfb->fb.var.red);
- val |= chan_to_field(green, \
- &sfb->fb.var.green);
- val |= chan_to_field(blue, &sfb->fb.var.blue);
-#ifdef __BIG_ENDIAN
- pal[regno] =
- ((red & 0xf800) >> 8) |
- ((green & 0xe000) >> 13) |
- ((green & 0x1c00) << 3) |
- ((blue & 0xf800) >> 3);
-#else
- pal[regno] = val;
-#endif
- } else {
- u32 *pal = sfb->fb.pseudo_palette;
- val = chan_to_field(red, &sfb->fb.var.red);
- val |= chan_to_field(green, \
- &sfb->fb.var.green);
- val |= chan_to_field(blue, &sfb->fb.var.blue);
-#ifdef __BIG_ENDIAN
- val =
- (val & 0xff00ff00 >> 8) |
- (val & 0x00ff00ff << 8);
-#endif
- pal[regno] = val;
- }
- }
- break;
-
- case FB_VISUAL_PSEUDOCOLOR:
- /* color depth 8 bit */
- sm712_setpalette(regno, red, green, blue, info);
- break;
-
- default:
- return 1; /* unknown type */
- }
-
- return 0;
-
-}
-
-#ifdef __BIG_ENDIAN
-static ssize_t smtcfb_read(struct fb_info *info, char __user *buf, size_t
- count, loff_t *ppos)
-{
- unsigned long p = *ppos;
-
- u32 *buffer, *dst;
- u32 __iomem *src;
- int c, i, cnt = 0, err = 0;
- unsigned long total_size;
-
- if (!info || !info->screen_base)
- return -ENODEV;
-
- if (info->state != FBINFO_STATE_RUNNING)
- return -EPERM;
-
- total_size = info->screen_size;
-
- if (total_size == 0)
- total_size = info->fix.smem_len;
-
- if (p >= total_size)
- return 0;
-
- if (count >= total_size)
- count = total_size;
-
- if (count + p > total_size)
- count = total_size - p;
-
- buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL);
- if (!buffer)
- return -ENOMEM;
-
- src = (u32 __iomem *) (info->screen_base + p);
-
- if (info->fbops->fb_sync)
- info->fbops->fb_sync(info);
-
- while (count) {
- c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
- dst = buffer;
- for (i = c >> 2; i--;) {
- *dst = fb_readl(src++);
- *dst =
- (*dst & 0xff00ff00 >> 8) |
- (*dst & 0x00ff00ff << 8);
- dst++;
- }
- if (c & 3) {
- u8 *dst8 = (u8 *) dst;
- u8 __iomem *src8 = (u8 __iomem *) src;
-
- for (i = c & 3; i--;) {
- if (i & 1) {
- *dst8++ = fb_readb(++src8);
- } else {
- *dst8++ = fb_readb(--src8);
- src8 += 2;
- }
- }
- src = (u32 __iomem *) src8;
- }
-
- if (copy_to_user(buf, buffer, c)) {
- err = -EFAULT;
- break;
- }
- *ppos += c;
- buf += c;
- cnt += c;
- count -= c;
- }
-
- kfree(buffer);
-
- return (err) ? err : cnt;
-}
-
-static ssize_t
-smtcfb_write(struct fb_info *info, const char __user *buf, size_t count,
- loff_t *ppos)
-{
- unsigned long p = *ppos;
-
- u32 *buffer, *src;
- u32 __iomem *dst;
- int c, i, cnt = 0, err = 0;
- unsigned long total_size;
-
- if (!info || !info->screen_base)
- return -ENODEV;
-
- if (info->state != FBINFO_STATE_RUNNING)
- return -EPERM;
-
- total_size = info->screen_size;
-
- if (total_size == 0)
- total_size = info->fix.smem_len;
-
- if (p > total_size)
- return -EFBIG;
-
- if (count > total_size) {
- err = -EFBIG;
- count = total_size;
- }
-
- if (count + p > total_size) {
- if (!err)
- err = -ENOSPC;
-
- count = total_size - p;
- }
-
- buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL);
- if (!buffer)
- return -ENOMEM;
-
- dst = (u32 __iomem *) (info->screen_base + p);
-
- if (info->fbops->fb_sync)
- info->fbops->fb_sync(info);
-
- while (count) {
- c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
- src = buffer;
-
- if (copy_from_user(src, buf, c)) {
- err = -EFAULT;
- break;
- }
-
- for (i = c >> 2; i--;) {
- fb_writel((*src & 0xff00ff00 >> 8) |
- (*src & 0x00ff00ff << 8), dst++);
- src++;
- }
- if (c & 3) {
- u8 *src8 = (u8 *) src;
- u8 __iomem *dst8 = (u8 __iomem *) dst;
-
- for (i = c & 3; i--;) {
- if (i & 1) {
- fb_writeb(*src8++, ++dst8);
- } else {
- fb_writeb(*src8++, --dst8);
- dst8 += 2;
- }
- }
- dst = (u32 __iomem *) dst8;
- }
-
- *ppos += c;
- buf += c;
- cnt += c;
- count -= c;
- }
-
- kfree(buffer);
-
- return (cnt) ? cnt : err;
-}
-#endif /* ! __BIG_ENDIAN */
-
-void smtcfb_setmode(struct smtcfb_info *sfb)
-{
- switch (sfb->fb.var.bits_per_pixel) {
- case 32:
- sfb->fb.fix.visual = FB_VISUAL_TRUECOLOR;
- sfb->fb.fix.line_length = sfb->fb.var.xres * 4;
- sfb->fb.var.red.length = 8;
- sfb->fb.var.green.length = 8;
- sfb->fb.var.blue.length = 8;
- sfb->fb.var.red.offset = 16;
- sfb->fb.var.green.offset = 8;
- sfb->fb.var.blue.offset = 0;
-
- break;
- case 8:
- sfb->fb.fix.visual = FB_VISUAL_PSEUDOCOLOR;
- sfb->fb.fix.line_length = sfb->fb.var.xres;
- sfb->fb.var.red.offset = 5;
- sfb->fb.var.red.length = 3;
- sfb->fb.var.green.offset = 2;
- sfb->fb.var.green.length = 3;
- sfb->fb.var.blue.offset = 0;
- sfb->fb.var.blue.length = 2;
- break;
- case 24:
- sfb->fb.fix.visual = FB_VISUAL_TRUECOLOR;
- sfb->fb.fix.line_length = sfb->fb.var.xres * 3;
- sfb->fb.var.red.length = 8;
- sfb->fb.var.green.length = 8;
- sfb->fb.var.blue.length = 8;
-
- sfb->fb.var.red.offset = 16;
- sfb->fb.var.green.offset = 8;
- sfb->fb.var.blue.offset = 0;
-
- break;
- case 16:
- default:
- sfb->fb.fix.visual = FB_VISUAL_TRUECOLOR;
- sfb->fb.fix.line_length = sfb->fb.var.xres * 2;
-
- sfb->fb.var.red.length = 5;
- sfb->fb.var.green.length = 6;
- sfb->fb.var.blue.length = 5;
-
- sfb->fb.var.red.offset = 11;
- sfb->fb.var.green.offset = 5;
- sfb->fb.var.blue.offset = 0;
-
- break;
- }
-
- sfb->width = sfb->fb.var.xres;
- sfb->height = sfb->fb.var.yres;
- sfb->hz = 60;
- smtc_set_timing(sfb);
-}
-
-static int smtc_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
-{
- /* sanity checks */
- if (var->xres_virtual < var->xres)
- var->xres_virtual = var->xres;
-
- if (var->yres_virtual < var->yres)
- var->yres_virtual = var->yres;
-
- /* set valid default bpp */
- if ((var->bits_per_pixel != 8) && (var->bits_per_pixel != 16) &&
- (var->bits_per_pixel != 24) && (var->bits_per_pixel != 32))
- var->bits_per_pixel = 16;
-
- return 0;
-}
-
-static int smtc_set_par(struct fb_info *info)
-{
- struct smtcfb_info *sfb = (struct smtcfb_info *)info;
-
- smtcfb_setmode(sfb);
-
- return 0;
-}
-
-static struct fb_ops smtcfb_ops = {
- .owner = THIS_MODULE,
- .fb_check_var = smtc_check_var,
- .fb_set_par = smtc_set_par,
- .fb_setcolreg = smtc_setcolreg,
- .fb_blank = smtc_blank,
- .fb_fillrect = cfb_fillrect,
- .fb_imageblit = cfb_imageblit,
- .fb_copyarea = cfb_copyarea,
-#ifdef __BIG_ENDIAN
- .fb_read = smtcfb_read,
- .fb_write = smtcfb_write,
-#endif
-};
-
-/*
- * Alloc struct smtcfb_info and assign the default value
- */
-static struct smtcfb_info *smtc_alloc_fb_info(struct pci_dev *pdev, char *name)
-{
- struct smtcfb_info *sfb;
-
- sfb = kzalloc(sizeof(*sfb), GFP_KERNEL);
-
- if (!sfb)
- return NULL;
-
- sfb->pdev = pdev;
-
- /*** Init sfb->fb with default value ***/
- sfb->fb.flags = FBINFO_FLAG_DEFAULT;
- sfb->fb.fbops = &smtcfb_ops;
- sfb->fb.var = smtcfb_var;
- sfb->fb.fix = smtcfb_fix;
-
- strcpy(sfb->fb.fix.id, name);
-
- sfb->fb.fix.type = FB_TYPE_PACKED_PIXELS;
- sfb->fb.fix.type_aux = 0;
- sfb->fb.fix.xpanstep = 0;
- sfb->fb.fix.ypanstep = 0;
- sfb->fb.fix.ywrapstep = 0;
- sfb->fb.fix.accel = FB_ACCEL_SMI_LYNX;
-
- sfb->fb.var.nonstd = 0;
- sfb->fb.var.activate = FB_ACTIVATE_NOW;
- sfb->fb.var.height = -1;
- sfb->fb.var.width = -1;
- /* text mode acceleration */
- sfb->fb.var.accel_flags = FB_ACCELF_TEXT;
- sfb->fb.var.vmode = FB_VMODE_NONINTERLACED;
-
- sfb->fb.par = sfb;
-
- sfb->fb.pseudo_palette = colreg;
-
- return sfb;
-}
-
-/*
- * Unmap in the memory mapped IO registers
- */
-
-static void smtc_unmap_mmio(struct smtcfb_info *sfb)
-{
- if (sfb && smtc_RegBaseAddress)
- smtc_RegBaseAddress = NULL;
-}
-
-/*
- * Map in the screen memory
- */
-
-static int smtc_map_smem(struct smtcfb_info *sfb,
- struct pci_dev *pdev, u_long smem_len)
-{
- if (sfb->fb.var.bits_per_pixel == 32) {
-#ifdef __BIG_ENDIAN
- sfb->fb.fix.smem_start = pci_resource_start(pdev, 0)
- + 0x800000;
-#else
- sfb->fb.fix.smem_start = pci_resource_start(pdev, 0);
-#endif
- } else {
- sfb->fb.fix.smem_start = pci_resource_start(pdev, 0);
- }
-
- sfb->fb.fix.smem_len = smem_len;
-
- sfb->fb.screen_base = smtc_VRAMBaseAddress;
-
- if (!sfb->fb.screen_base) {
- dev_err(&pdev->dev,
- "%s: unable to map screen memory\n", sfb->fb.fix.id);
- return -ENOMEM;
- }
-
- return 0;
-}
-
-/*
- * Unmap in the screen memory
- *
- */
-static void smtc_unmap_smem(struct smtcfb_info *sfb)
-{
- if (sfb && sfb->fb.screen_base) {
- iounmap(sfb->fb.screen_base);
- sfb->fb.screen_base = NULL;
- }
-}
-
-/*
- * We need to wake up the LynxEM+, and make sure its in linear memory mode.
- */
-static inline void sm7xx_init_hw(void)
-{
- outb_p(0x18, 0x3c4);
- outb_p(0x11, 0x3c5);
-}
-
-static void smtc_free_fb_info(struct smtcfb_info *sfb)
-{
- if (sfb) {
- fb_alloc_cmap(&sfb->fb.cmap, 0, 0);
- kfree(sfb);
- }
-}
-
-/*
- * sm712vga_setup - process command line options, get vga parameter
- * @options: string of options
- * Returns zero.
- *
- */
-static int __init sm712vga_setup(char *options)
-{
- int index;
-
- if (!options || !*options)
- return -EINVAL;
-
- smtc_screen_info.lfb_width = 0;
- smtc_screen_info.lfb_height = 0;
- smtc_screen_info.lfb_depth = 0;
-
- pr_debug("sm712vga_setup = %s\n", options);
-
- for (index = 0;
- index < ARRAY_SIZE(vesa_mode);
- index++) {
- if (strstr(options, vesa_mode[index].mode_index)) {
- smtc_screen_info.lfb_width = vesa_mode[index].lfb_width;
- smtc_screen_info.lfb_height =
- vesa_mode[index].lfb_height;
- smtc_screen_info.lfb_depth = vesa_mode[index].lfb_depth;
- return 0;
- }
- }
-
- return -1;
-}
-__setup("vga=", sm712vga_setup);
-
-static int __devinit smtcfb_pci_probe(struct pci_dev *pdev,
- const struct pci_device_id *ent)
-{
- struct smtcfb_info *sfb;
- u_long smem_size = 0x00800000; /* default 8MB */
- char name[16];
- int err;
- unsigned long pFramebufferPhysical;
-
- dev_info(&pdev->dev, "Silicon Motion display driver.");
-
- err = pci_enable_device(pdev); /* enable SMTC chip */
- if (err)
- return err;
-
- sfb = smtc_alloc_fb_info(pdev, name);
-
- if (!sfb)
- goto failed_free;
-
- sfb->chipID = ent->device;
- sprintf(name, "sm%Xfb", sfb->chipID);
-
- pci_set_drvdata(pdev, sfb);
-
- sm7xx_init_hw();
-
- /*get mode parameter from smtc_screen_info */
- if (smtc_screen_info.lfb_width != 0) {
- sfb->fb.var.xres = smtc_screen_info.lfb_width;
- sfb->fb.var.yres = smtc_screen_info.lfb_height;
- sfb->fb.var.bits_per_pixel = smtc_screen_info.lfb_depth;
- } else {
- /* default resolution 1024x600 16bit mode */
- sfb->fb.var.xres = SCREEN_X_RES;
- sfb->fb.var.yres = SCREEN_Y_RES;
- sfb->fb.var.bits_per_pixel = SCREEN_BPP;
- }
-
-#ifdef __BIG_ENDIAN
- if (sfb->fb.var.bits_per_pixel == 24)
- sfb->fb.var.bits_per_pixel = (smtc_screen_info.lfb_depth = 32);
-#endif
- /* Map address and memory detection */
- pFramebufferPhysical = pci_resource_start(pdev, 0);
- pci_read_config_byte(pdev, PCI_REVISION_ID, &sfb->chipRevID);
-
- switch (sfb->chipID) {
- case 0x710:
- case 0x712:
- sfb->fb.fix.mmio_start = pFramebufferPhysical + 0x00400000;
- sfb->fb.fix.mmio_len = 0x00400000;
- smem_size = SM712_VIDEOMEMORYSIZE;
-#ifdef __BIG_ENDIAN
- sfb->m_pLFB = (smtc_VRAMBaseAddress =
- ioremap(pFramebufferPhysical, 0x00c00000));
-#else
- sfb->m_pLFB = (smtc_VRAMBaseAddress =
- ioremap(pFramebufferPhysical, 0x00800000));
-#endif
- sfb->m_pMMIO = (smtc_RegBaseAddress =
- smtc_VRAMBaseAddress + 0x00700000);
- sfb->m_pDPR = smtc_VRAMBaseAddress + 0x00408000;
- sfb->m_pVPR = sfb->m_pLFB + 0x0040c000;
-#ifdef __BIG_ENDIAN
- if (sfb->fb.var.bits_per_pixel == 32) {
- smtc_VRAMBaseAddress += 0x800000;
- sfb->m_pLFB += 0x800000;
- dev_info(&pdev->dev,
- "smtc_VRAMBaseAddress=%p sfb->m_pLFB=%p",
- smtc_VRAMBaseAddress, sfb->m_pLFB);
- }
-#endif
- if (!smtc_RegBaseAddress) {
- dev_err(&pdev->dev,
- "%s: unable to map memory mapped IO!",
- sfb->fb.fix.id);
- err = -ENOMEM;
- goto failed_fb;
- }
-
- /* set MCLK = 14.31818 * (0x16 / 0x2) */
- smtc_seqw(0x6a, 0x16);
- smtc_seqw(0x6b, 0x02);
- smtc_seqw(0x62, 0x3e);
- /* enable PCI burst */
- smtc_seqw(0x17, 0x20);
- /* enable word swap */
-#ifdef __BIG_ENDIAN
- if (sfb->fb.var.bits_per_pixel == 32)
- smtc_seqw(0x17, 0x30);
-#endif
- break;
- case 0x720:
- sfb->fb.fix.mmio_start = pFramebufferPhysical;
- sfb->fb.fix.mmio_len = 0x00200000;
- smem_size = SM722_VIDEOMEMORYSIZE;
- sfb->m_pDPR = ioremap(pFramebufferPhysical, 0x00a00000);
- sfb->m_pLFB = (smtc_VRAMBaseAddress =
- sfb->m_pDPR + 0x00200000);
- sfb->m_pMMIO = (smtc_RegBaseAddress =
- sfb->m_pDPR + 0x000c0000);
- sfb->m_pVPR = sfb->m_pDPR + 0x800;
-
- smtc_seqw(0x62, 0xff);
- smtc_seqw(0x6a, 0x0d);
- smtc_seqw(0x6b, 0x02);
- break;
- default:
- dev_err(&pdev->dev,
- "No valid Silicon Motion display chip was detected!");
-
- goto failed_fb;
- }
-
- /* can support 32 bpp */
- if (15 == sfb->fb.var.bits_per_pixel)
- sfb->fb.var.bits_per_pixel = 16;
-
- sfb->fb.var.xres_virtual = sfb->fb.var.xres;
- sfb->fb.var.yres_virtual = sfb->fb.var.yres;
- err = smtc_map_smem(sfb, pdev, smem_size);
- if (err)
- goto failed;
-
- smtcfb_setmode(sfb);
- /* Primary display starting from 0 position */
- sfb->BaseAddressInVRAM = 0;
-
- err = register_framebuffer(&sfb->fb);
- if (err < 0)
- goto failed;
-
- dev_info(&pdev->dev,
- "Silicon Motion SM%X Rev%X primary display mode %dx%d-%d Init Complete.",
- sfb->chipID, sfb->chipRevID, sfb->fb.var.xres,
- sfb->fb.var.yres, sfb->fb.var.bits_per_pixel);
-
- return 0;
-
-failed:
- dev_err(&pdev->dev, "Silicon Motion, Inc. primary display init fail.");
-
- smtc_unmap_smem(sfb);
- smtc_unmap_mmio(sfb);
-failed_fb:
- smtc_free_fb_info(sfb);
-
-failed_free:
- pci_disable_device(pdev);
-
- return err;
-}
-
-
-static DEFINE_PCI_DEVICE_TABLE(smtcfb_pci_table) = {
- { PCI_DEVICE(0x126f, 0x710), },
- { PCI_DEVICE(0x126f, 0x712), },
- { PCI_DEVICE(0x126f, 0x720), },
- {0,}
-};
-
-
-static void __devexit smtcfb_pci_remove(struct pci_dev *pdev)
-{
- struct smtcfb_info *sfb;
-
- sfb = pci_get_drvdata(pdev);
- pci_set_drvdata(pdev, NULL);
- smtc_unmap_smem(sfb);
- smtc_unmap_mmio(sfb);
- unregister_framebuffer(&sfb->fb);
- smtc_free_fb_info(sfb);
-}
-
-#ifdef CONFIG_PM
-static int smtcfb_pci_suspend(struct device *device)
-{
- struct pci_dev *pdev = to_pci_dev(device);
- struct smtcfb_info *sfb;
-
- sfb = pci_get_drvdata(pdev);
-
- /* set the hw in sleep mode use externel clock and self memory refresh
- * so that we can turn off internal PLLs later on
- */
- smtc_seqw(0x20, (smtc_seqr(0x20) | 0xc0));
- smtc_seqw(0x69, (smtc_seqr(0x69) & 0xf7));
-
- console_lock();
- fb_set_suspend(&sfb->fb, 1);
- console_unlock();
-
- /* additionally turn off all function blocks including internal PLLs */
- smtc_seqw(0x21, 0xff);
-
- return 0;
-}
-
-static int smtcfb_pci_resume(struct device *device)
-{
- struct pci_dev *pdev = to_pci_dev(device);
- struct smtcfb_info *sfb;
-
- sfb = pci_get_drvdata(pdev);
-
- /* reinit hardware */
- sm7xx_init_hw();
- switch (sfb->chipID) {
- case 0x710:
- case 0x712:
- /* set MCLK = 14.31818 * (0x16 / 0x2) */
- smtc_seqw(0x6a, 0x16);
- smtc_seqw(0x6b, 0x02);
- smtc_seqw(0x62, 0x3e);
- /* enable PCI burst */
- smtc_seqw(0x17, 0x20);
-#ifdef __BIG_ENDIAN
- if (sfb->fb.var.bits_per_pixel == 32)
- smtc_seqw(0x17, 0x30);
-#endif
- break;
- case 0x720:
- smtc_seqw(0x62, 0xff);
- smtc_seqw(0x6a, 0x0d);
- smtc_seqw(0x6b, 0x02);
- break;
- }
-
- smtc_seqw(0x34, (smtc_seqr(0x34) | 0xc0));
- smtc_seqw(0x33, ((smtc_seqr(0x33) | 0x08) & 0xfb));
-
- smtcfb_setmode(sfb);
-
- console_lock();
- fb_set_suspend(&sfb->fb, 0);
- console_unlock();
-
- return 0;
-}
-
-static const struct dev_pm_ops sm7xx_pm_ops = {
- .suspend = smtcfb_pci_suspend,
- .resume = smtcfb_pci_resume,
- .freeze = smtcfb_pci_suspend,
- .thaw = smtcfb_pci_resume,
- .poweroff = smtcfb_pci_suspend,
- .restore = smtcfb_pci_resume,
-};
-
-#define SM7XX_PM_OPS (&sm7xx_pm_ops)
-
-#else /* !CONFIG_PM */
-
-#define SM7XX_PM_OPS NULL
-
-#endif /* !CONFIG_PM */
-
-static struct pci_driver smtcfb_driver = {
- .name = "smtcfb",
- .id_table = smtcfb_pci_table,
- .probe = smtcfb_pci_probe,
- .remove = __devexit_p(smtcfb_pci_remove),
- .driver.pm = SM7XX_PM_OPS,
-};
-
-static int __init smtcfb_init(void)
-{
- return pci_register_driver(&smtcfb_driver);
-}
-
-static void __exit smtcfb_exit(void)
-{
- pci_unregister_driver(&smtcfb_driver);
-}
-
-module_init(smtcfb_init);
-module_exit(smtcfb_exit);
-
-MODULE_AUTHOR("Siliconmotion ");
-MODULE_DESCRIPTION("Framebuffer driver for SMI Graphic Cards");
-MODULE_LICENSE("GPL");
+++ /dev/null
-/*
- * Silicon Motion SM712 frame buffer device
- *
- * Copyright (C) 2006 Silicon Motion Technology Corp.
- * Authors: Ge Wang, gewang@siliconmotion.com
- * Boyod boyod.yang@siliconmotion.com.cn
- *
- * Copyright (C) 2009 Lemote, Inc.
- * Author: Wu Zhangjin, wuzhangjin@gmail.com
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License. See the file COPYING in the main directory of this archive for
- * more details.
- */
-
-#define NR_PALETTE 256
-#define NR_RGB 2
-
-#define FB_ACCEL_SMI_LYNX 88
-
-#define SCREEN_X_RES 1024
-#define SCREEN_Y_RES 600
-#define SCREEN_BPP 16
-
-/*Assume SM712 graphics chip has 4MB VRAM */
-#define SM712_VIDEOMEMORYSIZE 0x00400000
-/*Assume SM722 graphics chip has 8MB VRAM */
-#define SM722_VIDEOMEMORYSIZE 0x00800000
-
-#define dac_reg (0x3c8)
-#define dac_val (0x3c9)
-
-extern char __iomem *smtc_RegBaseAddress;
-#define smtc_mmiowb(dat, reg) writeb(dat, smtc_RegBaseAddress + reg)
-#define smtc_mmioww(dat, reg) writew(dat, smtc_RegBaseAddress + reg)
-#define smtc_mmiowl(dat, reg) writel(dat, smtc_RegBaseAddress + reg)
-
-#define smtc_mmiorb(reg) readb(smtc_RegBaseAddress + reg)
-#define smtc_mmiorw(reg) readw(smtc_RegBaseAddress + reg)
-#define smtc_mmiorl(reg) readl(smtc_RegBaseAddress + reg)
-
-#define SIZE_SR00_SR04 (0x04 - 0x00 + 1)
-#define SIZE_SR10_SR24 (0x24 - 0x10 + 1)
-#define SIZE_SR30_SR75 (0x75 - 0x30 + 1)
-#define SIZE_SR80_SR93 (0x93 - 0x80 + 1)
-#define SIZE_SRA0_SRAF (0xAF - 0xA0 + 1)
-#define SIZE_GR00_GR08 (0x08 - 0x00 + 1)
-#define SIZE_AR00_AR14 (0x14 - 0x00 + 1)
-#define SIZE_CR00_CR18 (0x18 - 0x00 + 1)
-#define SIZE_CR30_CR4D (0x4D - 0x30 + 1)
-#define SIZE_CR90_CRA7 (0xA7 - 0x90 + 1)
-#define SIZE_VPR (0x6C + 1)
-#define SIZE_DPR (0x44 + 1)
-
-static inline void smtc_crtcw(int reg, int val)
-{
- smtc_mmiowb(reg, 0x3d4);
- smtc_mmiowb(val, 0x3d5);
-}
-
-static inline unsigned int smtc_crtcr(int reg)
-{
- smtc_mmiowb(reg, 0x3d4);
- return smtc_mmiorb(0x3d5);
-}
-
-static inline void smtc_grphw(int reg, int val)
-{
- smtc_mmiowb(reg, 0x3ce);
- smtc_mmiowb(val, 0x3cf);
-}
-
-static inline unsigned int smtc_grphr(int reg)
-{
- smtc_mmiowb(reg, 0x3ce);
- return smtc_mmiorb(0x3cf);
-}
-
-static inline void smtc_attrw(int reg, int val)
-{
- smtc_mmiorb(0x3da);
- smtc_mmiowb(reg, 0x3c0);
- smtc_mmiorb(0x3c1);
- smtc_mmiowb(val, 0x3c0);
-}
-
-static inline void smtc_seqw(int reg, int val)
-{
- smtc_mmiowb(reg, 0x3c4);
- smtc_mmiowb(val, 0x3c5);
-}
-
-static inline unsigned int smtc_seqr(int reg)
-{
- smtc_mmiowb(reg, 0x3c4);
- return smtc_mmiorb(0x3c5);
-}
-
-/* The next structure holds all information relevant for a specific video mode.
- */
-
-struct ModeInit {
- int mmSizeX;
- int mmSizeY;
- int bpp;
- int hz;
- unsigned char Init_MISC;
- unsigned char Init_SR00_SR04[SIZE_SR00_SR04];
- unsigned char Init_SR10_SR24[SIZE_SR10_SR24];
- unsigned char Init_SR30_SR75[SIZE_SR30_SR75];
- unsigned char Init_SR80_SR93[SIZE_SR80_SR93];
- unsigned char Init_SRA0_SRAF[SIZE_SRA0_SRAF];
- unsigned char Init_GR00_GR08[SIZE_GR00_GR08];
- unsigned char Init_AR00_AR14[SIZE_AR00_AR14];
- unsigned char Init_CR00_CR18[SIZE_CR00_CR18];
- unsigned char Init_CR30_CR4D[SIZE_CR30_CR4D];
- unsigned char Init_CR90_CRA7[SIZE_CR90_CRA7];
-};
-
-/**********************************************************************
- SM712 Mode table.
- **********************************************************************/
-struct ModeInit VGAMode[] = {
- {
- /* mode#0: 640 x 480 16Bpp 60Hz */
- 640, 480, 16, 60,
- /* Init_MISC */
- 0xE3,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x00, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xFF, 0xBE, 0xEF, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
- 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x30, 0x02, 0x01, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x32, 0x03, 0xA0, 0x09, 0xC0, 0x32, 0x32, 0x32,
- 0x32, 0x32, 0x32, 0x32, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x32, 0x32, 0x32,
- 0x04, 0x24, 0x63, 0x4F, 0x52, 0x0B, 0xDF, 0xEA,
- 0x04, 0x50, 0x19, 0x32, 0x32, 0x00, 0x00, 0x32,
- 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x74, 0x14, 0x07, 0x82, 0x07, 0x04,
- 0x00, 0x45, 0x30, 0x30, 0x40, 0x30,
- },
- { /* Init_SR80_SR93 */
- 0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x32,
- 0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x32, 0x32,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
- 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xFF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0x5F, 0x4F, 0x4F, 0x00, 0x53, 0x1F, 0x0B, 0x3E,
- 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xEA, 0x0C, 0xDF, 0x50, 0x40, 0xDF, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x03, 0x20,
- 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xFF, 0xFD,
- 0x5F, 0x4F, 0x00, 0x54, 0x00, 0x0B, 0xDF, 0x00,
- 0xEA, 0x0C, 0x2E, 0x00, 0x4F, 0xDF,
- },
- { /* Init_CR90_CRA7 */
- 0x56, 0xDD, 0x5E, 0xEA, 0x87, 0x44, 0x8F, 0x55,
- 0x0A, 0x8F, 0x55, 0x0A, 0x00, 0x00, 0x18, 0x00,
- 0x11, 0x10, 0x0B, 0x0A, 0x0A, 0x0A, 0x0A, 0x00,
- },
- },
- {
- /* mode#1: 640 x 480 24Bpp 60Hz */
- 640, 480, 24, 60,
- /* Init_MISC */
- 0xE3,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x00, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xFF, 0xBE, 0xEF, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
- 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x30, 0x02, 0x01, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x32, 0x03, 0xA0, 0x09, 0xC0, 0x32, 0x32, 0x32,
- 0x32, 0x32, 0x32, 0x32, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x32, 0x32, 0x32,
- 0x04, 0x24, 0x63, 0x4F, 0x52, 0x0B, 0xDF, 0xEA,
- 0x04, 0x50, 0x19, 0x32, 0x32, 0x00, 0x00, 0x32,
- 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x74, 0x14, 0x07, 0x82, 0x07, 0x04,
- 0x00, 0x45, 0x30, 0x30, 0x40, 0x30,
- },
- { /* Init_SR80_SR93 */
- 0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x32,
- 0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x32, 0x32,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
- 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xFF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0x5F, 0x4F, 0x4F, 0x00, 0x53, 0x1F, 0x0B, 0x3E,
- 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xEA, 0x0C, 0xDF, 0x50, 0x40, 0xDF, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x03, 0x20,
- 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xFF, 0xFD,
- 0x5F, 0x4F, 0x00, 0x54, 0x00, 0x0B, 0xDF, 0x00,
- 0xEA, 0x0C, 0x2E, 0x00, 0x4F, 0xDF,
- },
- { /* Init_CR90_CRA7 */
- 0x56, 0xDD, 0x5E, 0xEA, 0x87, 0x44, 0x8F, 0x55,
- 0x0A, 0x8F, 0x55, 0x0A, 0x00, 0x00, 0x18, 0x00,
- 0x11, 0x10, 0x0B, 0x0A, 0x0A, 0x0A, 0x0A, 0x00,
- },
- },
- {
- /* mode#0: 640 x 480 32Bpp 60Hz */
- 640, 480, 32, 60,
- /* Init_MISC */
- 0xE3,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x00, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xFF, 0xBE, 0xEF, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
- 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x30, 0x02, 0x01, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x32, 0x03, 0xA0, 0x09, 0xC0, 0x32, 0x32, 0x32,
- 0x32, 0x32, 0x32, 0x32, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x32, 0x32, 0x32,
- 0x04, 0x24, 0x63, 0x4F, 0x52, 0x0B, 0xDF, 0xEA,
- 0x04, 0x50, 0x19, 0x32, 0x32, 0x00, 0x00, 0x32,
- 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x74, 0x14, 0x07, 0x82, 0x07, 0x04,
- 0x00, 0x45, 0x30, 0x30, 0x40, 0x30,
- },
- { /* Init_SR80_SR93 */
- 0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x32,
- 0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x32, 0x32,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
- 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xFF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0x5F, 0x4F, 0x4F, 0x00, 0x53, 0x1F, 0x0B, 0x3E,
- 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xEA, 0x0C, 0xDF, 0x50, 0x40, 0xDF, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x03, 0x20,
- 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xFF, 0xFD,
- 0x5F, 0x4F, 0x00, 0x54, 0x00, 0x0B, 0xDF, 0x00,
- 0xEA, 0x0C, 0x2E, 0x00, 0x4F, 0xDF,
- },
- { /* Init_CR90_CRA7 */
- 0x56, 0xDD, 0x5E, 0xEA, 0x87, 0x44, 0x8F, 0x55,
- 0x0A, 0x8F, 0x55, 0x0A, 0x00, 0x00, 0x18, 0x00,
- 0x11, 0x10, 0x0B, 0x0A, 0x0A, 0x0A, 0x0A, 0x00,
- },
- },
-
- { /* mode#2: 800 x 600 16Bpp 60Hz */
- 800, 600, 16, 60,
- /* Init_MISC */
- 0x2B,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x03, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xFF, 0xBE, 0xEE, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
- 0x99, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x30, 0x02, 0x01, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x34, 0x03, 0x20, 0x09, 0xC0, 0x24, 0x24, 0x24,
- 0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x38, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x24, 0x24, 0x24,
- 0x04, 0x48, 0x83, 0x63, 0x68, 0x72, 0x57, 0x58,
- 0x04, 0x55, 0x59, 0x24, 0x24, 0x00, 0x00, 0x24,
- 0x01, 0x80, 0x7A, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x74, 0x14, 0x1C, 0x85, 0x35, 0x13,
- 0x02, 0x45, 0x30, 0x35, 0x40, 0x20,
- },
- { /* Init_SR80_SR93 */
- 0x00, 0x00, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x24,
- 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x24, 0x24,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
- 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xBF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0x7F, 0x63, 0x63, 0x00, 0x68, 0x18, 0x72, 0xF0,
- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x58, 0x0C, 0x57, 0x64, 0x40, 0x57, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x03, 0x20,
- 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xBF, 0xFD,
- 0x7F, 0x63, 0x00, 0x69, 0x18, 0x72, 0x57, 0x00,
- 0x58, 0x0C, 0xE0, 0x20, 0x63, 0x57,
- },
- { /* Init_CR90_CRA7 */
- 0x56, 0x4B, 0x5E, 0x55, 0x86, 0x9D, 0x8E, 0xAA,
- 0xDB, 0x2A, 0xDF, 0x33, 0x00, 0x00, 0x18, 0x00,
- 0x20, 0x1F, 0x1A, 0x19, 0x0F, 0x0F, 0x0F, 0x00,
- },
- },
- { /* mode#3: 800 x 600 24Bpp 60Hz */
- 800, 600, 24, 60,
- 0x2B,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x03, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xFF, 0xBE, 0xEE, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
- 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x30, 0x02, 0x01, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x36, 0x03, 0x20, 0x09, 0xC0, 0x36, 0x36, 0x36,
- 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x36, 0x36, 0x36,
- 0x04, 0x48, 0x83, 0x63, 0x68, 0x72, 0x57, 0x58,
- 0x04, 0x55, 0x59, 0x36, 0x36, 0x00, 0x00, 0x36,
- 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x74, 0x14, 0x1C, 0x85, 0x35, 0x13,
- 0x02, 0x45, 0x30, 0x30, 0x40, 0x20,
- },
- { /* Init_SR80_SR93 */
- 0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x36,
- 0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x36, 0x36,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
- 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xBF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0x7F, 0x63, 0x63, 0x00, 0x68, 0x18, 0x72, 0xF0,
- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x58, 0x0C, 0x57, 0x64, 0x40, 0x57, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x03, 0x20,
- 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xBF, 0xFD,
- 0x7F, 0x63, 0x00, 0x69, 0x18, 0x72, 0x57, 0x00,
- 0x58, 0x0C, 0xE0, 0x20, 0x63, 0x57,
- },
- { /* Init_CR90_CRA7 */
- 0x56, 0x4B, 0x5E, 0x55, 0x86, 0x9D, 0x8E, 0xAA,
- 0xDB, 0x2A, 0xDF, 0x33, 0x00, 0x00, 0x18, 0x00,
- 0x20, 0x1F, 0x1A, 0x19, 0x0F, 0x0F, 0x0F, 0x00,
- },
- },
- { /* mode#7: 800 x 600 32Bpp 60Hz */
- 800, 600, 32, 60,
- /* Init_MISC */
- 0x2B,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x03, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xFF, 0xBE, 0xEE, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
- 0x99, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x30, 0x02, 0x01, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x34, 0x03, 0x20, 0x09, 0xC0, 0x24, 0x24, 0x24,
- 0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x38, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x24, 0x24, 0x24,
- 0x04, 0x48, 0x83, 0x63, 0x68, 0x72, 0x57, 0x58,
- 0x04, 0x55, 0x59, 0x24, 0x24, 0x00, 0x00, 0x24,
- 0x01, 0x80, 0x7A, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x74, 0x14, 0x1C, 0x85, 0x35, 0x13,
- 0x02, 0x45, 0x30, 0x35, 0x40, 0x20,
- },
- { /* Init_SR80_SR93 */
- 0x00, 0x00, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x24,
- 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x24, 0x24,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
- 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xBF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0x7F, 0x63, 0x63, 0x00, 0x68, 0x18, 0x72, 0xF0,
- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x58, 0x0C, 0x57, 0x64, 0x40, 0x57, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x03, 0x20,
- 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xBF, 0xFD,
- 0x7F, 0x63, 0x00, 0x69, 0x18, 0x72, 0x57, 0x00,
- 0x58, 0x0C, 0xE0, 0x20, 0x63, 0x57,
- },
- { /* Init_CR90_CRA7 */
- 0x56, 0x4B, 0x5E, 0x55, 0x86, 0x9D, 0x8E, 0xAA,
- 0xDB, 0x2A, 0xDF, 0x33, 0x00, 0x00, 0x18, 0x00,
- 0x20, 0x1F, 0x1A, 0x19, 0x0F, 0x0F, 0x0F, 0x00,
- },
- },
- /* We use 1024x768 table to light 1024x600 panel for lemote */
- { /* mode#4: 1024 x 600 16Bpp 60Hz */
- 1024, 600, 16, 60,
- /* Init_MISC */
- 0xEB,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x00, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xC8, 0x40, 0x14, 0x60, 0x00, 0x0A, 0x17, 0x20,
- 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x30, 0x02, 0x00, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x22, 0x03, 0x24, 0x09, 0xC0, 0x22, 0x22, 0x22,
- 0x22, 0x22, 0x22, 0x22, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x22, 0x22, 0x22,
- 0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
- 0x00, 0x60, 0x59, 0x22, 0x22, 0x00, 0x00, 0x22,
- 0x01, 0x80, 0x7A, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x16, 0x02, 0x0D, 0x82, 0x09, 0x02,
- 0x04, 0x45, 0x3F, 0x30, 0x40, 0x20,
- },
- { /* Init_SR80_SR93 */
- 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
- 0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
- 0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
- 0x00, 0x00, 0x00, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
- 0xA3, 0x7F, 0x00, 0x82, 0x0b, 0x6f, 0x57, 0x00,
- 0x5c, 0x0f, 0xE0, 0xe0, 0x7F, 0x57,
- },
- { /* Init_CR90_CRA7 */
- 0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
- 0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
- 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
- },
- },
- { /* mode#5: 1024 x 768 24Bpp 60Hz */
- 1024, 768, 24, 60,
- /* Init_MISC */
- 0xEB,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x03, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
- 0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x30, 0x02, 0x01, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
- 0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
- 0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
- 0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
- 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x74, 0x14, 0x3B, 0x0D, 0x09, 0x02,
- 0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
- },
- { /* Init_SR80_SR93 */
- 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
- 0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
- 0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
- 0x00, 0x00, 0x00, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
- 0xA3, 0x7F, 0x00, 0x86, 0x15, 0x24, 0xFF, 0x00,
- 0x01, 0x07, 0xE5, 0x20, 0x7F, 0xFF,
- },
- { /* Init_CR90_CRA7 */
- 0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
- 0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
- 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
- },
- },
- { /* mode#4: 1024 x 768 32Bpp 60Hz */
- 1024, 768, 32, 60,
- /* Init_MISC */
- 0xEB,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x03, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
- 0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x32, 0x02, 0x01, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
- 0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
- 0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
- 0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
- 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x74, 0x14, 0x3B, 0x0D, 0x09, 0x02,
- 0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
- },
- { /* Init_SR80_SR93 */
- 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
- 0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
- 0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
- 0x00, 0x00, 0x00, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
- 0xA3, 0x7F, 0x00, 0x86, 0x15, 0x24, 0xFF, 0x00,
- 0x01, 0x07, 0xE5, 0x20, 0x7F, 0xFF,
- },
- { /* Init_CR90_CRA7 */
- 0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
- 0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
- 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
- },
- },
- { /* mode#6: 320 x 240 16Bpp 60Hz */
- 320, 240, 16, 60,
- /* Init_MISC */
- 0xEB,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x03, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
- 0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x32, 0x02, 0x01, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
- 0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
- 0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
- 0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
- 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x74, 0x14, 0x08, 0x43, 0x08, 0x43,
- 0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
- },
- { /* Init_SR80_SR93 */
- 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
- 0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
- 0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
- 0x00, 0x00, 0x30, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
- 0x2E, 0x27, 0x00, 0x2b, 0x0c, 0x0F, 0xEF, 0x00,
- 0xFe, 0x0f, 0x01, 0xC0, 0x27, 0xEF,
- },
- { /* Init_CR90_CRA7 */
- 0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
- 0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
- 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
- },
- },
-
- { /* mode#8: 320 x 240 32Bpp 60Hz */
- 320, 240, 32, 60,
- /* Init_MISC */
- 0xEB,
- { /* Init_SR0_SR4 */
- 0x03, 0x01, 0x0F, 0x03, 0x0E,
- },
- { /* Init_SR10_SR24 */
- 0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
- 0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xC4, 0x32, 0x02, 0x01, 0x01,
- },
- { /* Init_SR30_SR75 */
- 0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
- 0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
- 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
- 0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
- 0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
- 0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
- 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
- 0x50, 0x03, 0x74, 0x14, 0x08, 0x43, 0x08, 0x43,
- 0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
- },
- { /* Init_SR80_SR93 */
- 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
- 0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
- 0x00, 0x00, 0x00, 0x00,
- },
- { /* Init_SRA0_SRAF */
- 0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
- 0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
- },
- { /* Init_GR00_GR08 */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
- 0xFF,
- },
- { /* Init_AR00_AR14 */
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
- 0x41, 0x00, 0x0F, 0x00, 0x00,
- },
- { /* Init_CR00_CR18 */
- 0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
- 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
- 0xFF,
- },
- { /* Init_CR30_CR4D */
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
- 0x00, 0x00, 0x30, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
- 0x2E, 0x27, 0x00, 0x2b, 0x0c, 0x0F, 0xEF, 0x00,
- 0xFe, 0x0f, 0x01, 0xC0, 0x27, 0xEF,
- },
- { /* Init_CR90_CRA7 */
- 0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
- 0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
- 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
- },
- },
-};
-
-#define numVGAModes ARRAY_SIZE(VGAMode)
--- /dev/null
+config FB_SM7XX
+ tristate "Silicon Motion SM7XX framebuffer support"
+ depends on FB
+ select FB_CFB_FILLRECT
+ select FB_CFB_COPYAREA
+ select FB_CFB_IMAGEBLIT
+ help
+ Frame buffer driver for the Silicon Motion SM710, SM712, SM721
+ and SM722 chips.
+
+ This driver is also available as a module. The module will be
+ called sm7xxfb. If you want to compile it as a module, say M
+ here and read <file:Documentation/kbuild/modules.txt>.
--- /dev/null
+obj-$(CONFIG_FB_SM7XX) += sm7xxfb.o
--- /dev/null
+TODO:
+- Dual head support
+- 2D acceleration support
+- use kernel coding style
+- refine the code and remove unused code
+- move it to drivers/video/sm7xxfb.c
+
+Please send any patches to Greg Kroah-Hartman <greg@kroah.com> and
+Teddy Wang <teddy.wang@siliconmotion.com.cn>.
--- /dev/null
+/*
+ * Silicon Motion SM712 frame buffer device
+ *
+ * Copyright (C) 2006 Silicon Motion Technology Corp.
+ * Authors: Ge Wang, gewang@siliconmotion.com
+ * Boyod boyod.yang@siliconmotion.com.cn
+ *
+ * Copyright (C) 2009 Lemote, Inc.
+ * Author: Wu Zhangjin, wuzhangjin@gmail.com
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of this archive for
+ * more details.
+ */
+
+#define NR_PALETTE 256
+
+#define FB_ACCEL_SMI_LYNX 88
+
+#define SCREEN_X_RES 1024
+#define SCREEN_Y_RES 600
+#define SCREEN_BPP 16
+
+/*Assume SM712 graphics chip has 4MB VRAM */
+#define SM712_VIDEOMEMORYSIZE 0x00400000
+/*Assume SM722 graphics chip has 8MB VRAM */
+#define SM722_VIDEOMEMORYSIZE 0x00800000
+
+#define dac_reg (0x3c8)
+#define dac_val (0x3c9)
+
+extern char __iomem *smtc_RegBaseAddress;
+#define smtc_mmiowb(dat, reg) writeb(dat, smtc_RegBaseAddress + reg)
+#define smtc_mmioww(dat, reg) writew(dat, smtc_RegBaseAddress + reg)
+#define smtc_mmiowl(dat, reg) writel(dat, smtc_RegBaseAddress + reg)
+
+#define smtc_mmiorb(reg) readb(smtc_RegBaseAddress + reg)
+#define smtc_mmiorw(reg) readw(smtc_RegBaseAddress + reg)
+#define smtc_mmiorl(reg) readl(smtc_RegBaseAddress + reg)
+
+#define SIZE_SR00_SR04 (0x04 - 0x00 + 1)
+#define SIZE_SR10_SR24 (0x24 - 0x10 + 1)
+#define SIZE_SR30_SR75 (0x75 - 0x30 + 1)
+#define SIZE_SR80_SR93 (0x93 - 0x80 + 1)
+#define SIZE_SRA0_SRAF (0xAF - 0xA0 + 1)
+#define SIZE_GR00_GR08 (0x08 - 0x00 + 1)
+#define SIZE_AR00_AR14 (0x14 - 0x00 + 1)
+#define SIZE_CR00_CR18 (0x18 - 0x00 + 1)
+#define SIZE_CR30_CR4D (0x4D - 0x30 + 1)
+#define SIZE_CR90_CRA7 (0xA7 - 0x90 + 1)
+#define SIZE_VPR (0x6C + 1)
+#define SIZE_DPR (0x44 + 1)
+
+static inline void smtc_crtcw(int reg, int val)
+{
+ smtc_mmiowb(reg, 0x3d4);
+ smtc_mmiowb(val, 0x3d5);
+}
+
+static inline unsigned int smtc_crtcr(int reg)
+{
+ smtc_mmiowb(reg, 0x3d4);
+ return smtc_mmiorb(0x3d5);
+}
+
+static inline void smtc_grphw(int reg, int val)
+{
+ smtc_mmiowb(reg, 0x3ce);
+ smtc_mmiowb(val, 0x3cf);
+}
+
+static inline unsigned int smtc_grphr(int reg)
+{
+ smtc_mmiowb(reg, 0x3ce);
+ return smtc_mmiorb(0x3cf);
+}
+
+static inline void smtc_attrw(int reg, int val)
+{
+ smtc_mmiorb(0x3da);
+ smtc_mmiowb(reg, 0x3c0);
+ smtc_mmiorb(0x3c1);
+ smtc_mmiowb(val, 0x3c0);
+}
+
+static inline void smtc_seqw(int reg, int val)
+{
+ smtc_mmiowb(reg, 0x3c4);
+ smtc_mmiowb(val, 0x3c5);
+}
+
+static inline unsigned int smtc_seqr(int reg)
+{
+ smtc_mmiowb(reg, 0x3c4);
+ return smtc_mmiorb(0x3c5);
+}
+
+/* The next structure holds all information relevant for a specific video mode.
+ */
+
+struct ModeInit {
+ int mmSizeX;
+ int mmSizeY;
+ int bpp;
+ int hz;
+ unsigned char Init_MISC;
+ unsigned char Init_SR00_SR04[SIZE_SR00_SR04];
+ unsigned char Init_SR10_SR24[SIZE_SR10_SR24];
+ unsigned char Init_SR30_SR75[SIZE_SR30_SR75];
+ unsigned char Init_SR80_SR93[SIZE_SR80_SR93];
+ unsigned char Init_SRA0_SRAF[SIZE_SRA0_SRAF];
+ unsigned char Init_GR00_GR08[SIZE_GR00_GR08];
+ unsigned char Init_AR00_AR14[SIZE_AR00_AR14];
+ unsigned char Init_CR00_CR18[SIZE_CR00_CR18];
+ unsigned char Init_CR30_CR4D[SIZE_CR30_CR4D];
+ unsigned char Init_CR90_CRA7[SIZE_CR90_CRA7];
+};
+
+/**********************************************************************
+ SM712 Mode table.
+ **********************************************************************/
+struct ModeInit VGAMode[] = {
+ {
+ /* mode#0: 640 x 480 16Bpp 60Hz */
+ 640, 480, 16, 60,
+ /* Init_MISC */
+ 0xE3,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x00, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xFF, 0xBE, 0xEF, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
+ 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x30, 0x02, 0x01, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x32, 0x03, 0xA0, 0x09, 0xC0, 0x32, 0x32, 0x32,
+ 0x32, 0x32, 0x32, 0x32, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x32, 0x32, 0x32,
+ 0x04, 0x24, 0x63, 0x4F, 0x52, 0x0B, 0xDF, 0xEA,
+ 0x04, 0x50, 0x19, 0x32, 0x32, 0x00, 0x00, 0x32,
+ 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x74, 0x14, 0x07, 0x82, 0x07, 0x04,
+ 0x00, 0x45, 0x30, 0x30, 0x40, 0x30,
+ },
+ { /* Init_SR80_SR93 */
+ 0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x32,
+ 0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x32, 0x32,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
+ 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xFF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0x5F, 0x4F, 0x4F, 0x00, 0x53, 0x1F, 0x0B, 0x3E,
+ 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xEA, 0x0C, 0xDF, 0x50, 0x40, 0xDF, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x03, 0x20,
+ 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xFF, 0xFD,
+ 0x5F, 0x4F, 0x00, 0x54, 0x00, 0x0B, 0xDF, 0x00,
+ 0xEA, 0x0C, 0x2E, 0x00, 0x4F, 0xDF,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x56, 0xDD, 0x5E, 0xEA, 0x87, 0x44, 0x8F, 0x55,
+ 0x0A, 0x8F, 0x55, 0x0A, 0x00, 0x00, 0x18, 0x00,
+ 0x11, 0x10, 0x0B, 0x0A, 0x0A, 0x0A, 0x0A, 0x00,
+ },
+ },
+ {
+ /* mode#1: 640 x 480 24Bpp 60Hz */
+ 640, 480, 24, 60,
+ /* Init_MISC */
+ 0xE3,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x00, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xFF, 0xBE, 0xEF, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
+ 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x30, 0x02, 0x01, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x32, 0x03, 0xA0, 0x09, 0xC0, 0x32, 0x32, 0x32,
+ 0x32, 0x32, 0x32, 0x32, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x32, 0x32, 0x32,
+ 0x04, 0x24, 0x63, 0x4F, 0x52, 0x0B, 0xDF, 0xEA,
+ 0x04, 0x50, 0x19, 0x32, 0x32, 0x00, 0x00, 0x32,
+ 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x74, 0x14, 0x07, 0x82, 0x07, 0x04,
+ 0x00, 0x45, 0x30, 0x30, 0x40, 0x30,
+ },
+ { /* Init_SR80_SR93 */
+ 0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x32,
+ 0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x32, 0x32,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
+ 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xFF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0x5F, 0x4F, 0x4F, 0x00, 0x53, 0x1F, 0x0B, 0x3E,
+ 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xEA, 0x0C, 0xDF, 0x50, 0x40, 0xDF, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x03, 0x20,
+ 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xFF, 0xFD,
+ 0x5F, 0x4F, 0x00, 0x54, 0x00, 0x0B, 0xDF, 0x00,
+ 0xEA, 0x0C, 0x2E, 0x00, 0x4F, 0xDF,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x56, 0xDD, 0x5E, 0xEA, 0x87, 0x44, 0x8F, 0x55,
+ 0x0A, 0x8F, 0x55, 0x0A, 0x00, 0x00, 0x18, 0x00,
+ 0x11, 0x10, 0x0B, 0x0A, 0x0A, 0x0A, 0x0A, 0x00,
+ },
+ },
+ {
+ /* mode#0: 640 x 480 32Bpp 60Hz */
+ 640, 480, 32, 60,
+ /* Init_MISC */
+ 0xE3,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x00, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xFF, 0xBE, 0xEF, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
+ 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x30, 0x02, 0x01, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x32, 0x03, 0xA0, 0x09, 0xC0, 0x32, 0x32, 0x32,
+ 0x32, 0x32, 0x32, 0x32, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x32, 0x32, 0x32,
+ 0x04, 0x24, 0x63, 0x4F, 0x52, 0x0B, 0xDF, 0xEA,
+ 0x04, 0x50, 0x19, 0x32, 0x32, 0x00, 0x00, 0x32,
+ 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x74, 0x14, 0x07, 0x82, 0x07, 0x04,
+ 0x00, 0x45, 0x30, 0x30, 0x40, 0x30,
+ },
+ { /* Init_SR80_SR93 */
+ 0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x32,
+ 0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x32, 0x32,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
+ 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xFF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0x5F, 0x4F, 0x4F, 0x00, 0x53, 0x1F, 0x0B, 0x3E,
+ 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xEA, 0x0C, 0xDF, 0x50, 0x40, 0xDF, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x03, 0x20,
+ 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xFF, 0xFD,
+ 0x5F, 0x4F, 0x00, 0x54, 0x00, 0x0B, 0xDF, 0x00,
+ 0xEA, 0x0C, 0x2E, 0x00, 0x4F, 0xDF,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x56, 0xDD, 0x5E, 0xEA, 0x87, 0x44, 0x8F, 0x55,
+ 0x0A, 0x8F, 0x55, 0x0A, 0x00, 0x00, 0x18, 0x00,
+ 0x11, 0x10, 0x0B, 0x0A, 0x0A, 0x0A, 0x0A, 0x00,
+ },
+ },
+
+ { /* mode#2: 800 x 600 16Bpp 60Hz */
+ 800, 600, 16, 60,
+ /* Init_MISC */
+ 0x2B,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x03, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xFF, 0xBE, 0xEE, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
+ 0x99, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x30, 0x02, 0x01, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x34, 0x03, 0x20, 0x09, 0xC0, 0x24, 0x24, 0x24,
+ 0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x38, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x24, 0x24, 0x24,
+ 0x04, 0x48, 0x83, 0x63, 0x68, 0x72, 0x57, 0x58,
+ 0x04, 0x55, 0x59, 0x24, 0x24, 0x00, 0x00, 0x24,
+ 0x01, 0x80, 0x7A, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x74, 0x14, 0x1C, 0x85, 0x35, 0x13,
+ 0x02, 0x45, 0x30, 0x35, 0x40, 0x20,
+ },
+ { /* Init_SR80_SR93 */
+ 0x00, 0x00, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x24,
+ 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x24, 0x24,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
+ 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xBF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0x7F, 0x63, 0x63, 0x00, 0x68, 0x18, 0x72, 0xF0,
+ 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x58, 0x0C, 0x57, 0x64, 0x40, 0x57, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x03, 0x20,
+ 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xBF, 0xFD,
+ 0x7F, 0x63, 0x00, 0x69, 0x18, 0x72, 0x57, 0x00,
+ 0x58, 0x0C, 0xE0, 0x20, 0x63, 0x57,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x56, 0x4B, 0x5E, 0x55, 0x86, 0x9D, 0x8E, 0xAA,
+ 0xDB, 0x2A, 0xDF, 0x33, 0x00, 0x00, 0x18, 0x00,
+ 0x20, 0x1F, 0x1A, 0x19, 0x0F, 0x0F, 0x0F, 0x00,
+ },
+ },
+ { /* mode#3: 800 x 600 24Bpp 60Hz */
+ 800, 600, 24, 60,
+ 0x2B,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x03, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xFF, 0xBE, 0xEE, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
+ 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x30, 0x02, 0x01, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x36, 0x03, 0x20, 0x09, 0xC0, 0x36, 0x36, 0x36,
+ 0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x36, 0x36, 0x36,
+ 0x04, 0x48, 0x83, 0x63, 0x68, 0x72, 0x57, 0x58,
+ 0x04, 0x55, 0x59, 0x36, 0x36, 0x00, 0x00, 0x36,
+ 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x74, 0x14, 0x1C, 0x85, 0x35, 0x13,
+ 0x02, 0x45, 0x30, 0x30, 0x40, 0x20,
+ },
+ { /* Init_SR80_SR93 */
+ 0xFF, 0x07, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x36,
+ 0xF7, 0x00, 0x00, 0x00, 0xEF, 0xFF, 0x36, 0x36,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
+ 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xBF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0x7F, 0x63, 0x63, 0x00, 0x68, 0x18, 0x72, 0xF0,
+ 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x58, 0x0C, 0x57, 0x64, 0x40, 0x57, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x03, 0x20,
+ 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xBF, 0xFD,
+ 0x7F, 0x63, 0x00, 0x69, 0x18, 0x72, 0x57, 0x00,
+ 0x58, 0x0C, 0xE0, 0x20, 0x63, 0x57,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x56, 0x4B, 0x5E, 0x55, 0x86, 0x9D, 0x8E, 0xAA,
+ 0xDB, 0x2A, 0xDF, 0x33, 0x00, 0x00, 0x18, 0x00,
+ 0x20, 0x1F, 0x1A, 0x19, 0x0F, 0x0F, 0x0F, 0x00,
+ },
+ },
+ { /* mode#7: 800 x 600 32Bpp 60Hz */
+ 800, 600, 32, 60,
+ /* Init_MISC */
+ 0x2B,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x03, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xFF, 0xBE, 0xEE, 0xFF, 0x00, 0x0E, 0x17, 0x2C,
+ 0x99, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x30, 0x02, 0x01, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x34, 0x03, 0x20, 0x09, 0xC0, 0x24, 0x24, 0x24,
+ 0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x38, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x24, 0x24, 0x24,
+ 0x04, 0x48, 0x83, 0x63, 0x68, 0x72, 0x57, 0x58,
+ 0x04, 0x55, 0x59, 0x24, 0x24, 0x00, 0x00, 0x24,
+ 0x01, 0x80, 0x7A, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x74, 0x14, 0x1C, 0x85, 0x35, 0x13,
+ 0x02, 0x45, 0x30, 0x35, 0x40, 0x20,
+ },
+ { /* Init_SR80_SR93 */
+ 0x00, 0x00, 0x00, 0x6F, 0x7F, 0x7F, 0xFF, 0x24,
+ 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x24, 0x24,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFF, 0xBF, 0xFF, 0xFF, 0xED, 0xED, 0xED,
+ 0x7B, 0xFF, 0xFF, 0xFF, 0xBF, 0xEF, 0xBF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0x7F, 0x63, 0x63, 0x00, 0x68, 0x18, 0x72, 0xF0,
+ 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x58, 0x0C, 0x57, 0x64, 0x40, 0x57, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x03, 0x20,
+ 0x00, 0x00, 0x00, 0x40, 0x00, 0xE7, 0xBF, 0xFD,
+ 0x7F, 0x63, 0x00, 0x69, 0x18, 0x72, 0x57, 0x00,
+ 0x58, 0x0C, 0xE0, 0x20, 0x63, 0x57,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x56, 0x4B, 0x5E, 0x55, 0x86, 0x9D, 0x8E, 0xAA,
+ 0xDB, 0x2A, 0xDF, 0x33, 0x00, 0x00, 0x18, 0x00,
+ 0x20, 0x1F, 0x1A, 0x19, 0x0F, 0x0F, 0x0F, 0x00,
+ },
+ },
+ /* We use 1024x768 table to light 1024x600 panel for lemote */
+ { /* mode#4: 1024 x 600 16Bpp 60Hz */
+ 1024, 600, 16, 60,
+ /* Init_MISC */
+ 0xEB,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x00, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xC8, 0x40, 0x14, 0x60, 0x00, 0x0A, 0x17, 0x20,
+ 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x30, 0x02, 0x00, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x22, 0x03, 0x24, 0x09, 0xC0, 0x22, 0x22, 0x22,
+ 0x22, 0x22, 0x22, 0x22, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x22, 0x22, 0x22,
+ 0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
+ 0x00, 0x60, 0x59, 0x22, 0x22, 0x00, 0x00, 0x22,
+ 0x01, 0x80, 0x7A, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x16, 0x02, 0x0D, 0x82, 0x09, 0x02,
+ 0x04, 0x45, 0x3F, 0x30, 0x40, 0x20,
+ },
+ { /* Init_SR80_SR93 */
+ 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
+ 0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
+ 0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
+ 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
+ 0x00, 0x00, 0x00, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
+ 0xA3, 0x7F, 0x00, 0x82, 0x0b, 0x6f, 0x57, 0x00,
+ 0x5c, 0x0f, 0xE0, 0xe0, 0x7F, 0x57,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
+ 0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
+ },
+ },
+ { /* mode#5: 1024 x 768 24Bpp 60Hz */
+ 1024, 768, 24, 60,
+ /* Init_MISC */
+ 0xEB,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x03, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
+ 0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x30, 0x02, 0x01, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
+ 0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
+ 0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
+ 0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
+ 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x74, 0x14, 0x3B, 0x0D, 0x09, 0x02,
+ 0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
+ },
+ { /* Init_SR80_SR93 */
+ 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
+ 0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
+ 0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
+ 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
+ 0x00, 0x00, 0x00, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
+ 0xA3, 0x7F, 0x00, 0x86, 0x15, 0x24, 0xFF, 0x00,
+ 0x01, 0x07, 0xE5, 0x20, 0x7F, 0xFF,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
+ 0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
+ },
+ },
+ { /* mode#4: 1024 x 768 32Bpp 60Hz */
+ 1024, 768, 32, 60,
+ /* Init_MISC */
+ 0xEB,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x03, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
+ 0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x32, 0x02, 0x01, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
+ 0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
+ 0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
+ 0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
+ 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x74, 0x14, 0x3B, 0x0D, 0x09, 0x02,
+ 0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
+ },
+ { /* Init_SR80_SR93 */
+ 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
+ 0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
+ 0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
+ 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
+ 0x00, 0x00, 0x00, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
+ 0xA3, 0x7F, 0x00, 0x86, 0x15, 0x24, 0xFF, 0x00,
+ 0x01, 0x07, 0xE5, 0x20, 0x7F, 0xFF,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
+ 0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
+ },
+ },
+ { /* mode#6: 320 x 240 16Bpp 60Hz */
+ 320, 240, 16, 60,
+ /* Init_MISC */
+ 0xEB,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x03, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
+ 0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x32, 0x02, 0x01, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
+ 0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
+ 0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
+ 0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
+ 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x74, 0x14, 0x08, 0x43, 0x08, 0x43,
+ 0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
+ },
+ { /* Init_SR80_SR93 */
+ 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
+ 0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
+ 0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
+ 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
+ 0x00, 0x00, 0x30, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
+ 0x2E, 0x27, 0x00, 0x2b, 0x0c, 0x0F, 0xEF, 0x00,
+ 0xFe, 0x0f, 0x01, 0xC0, 0x27, 0xEF,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
+ 0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
+ },
+ },
+
+ { /* mode#8: 320 x 240 32Bpp 60Hz */
+ 320, 240, 32, 60,
+ /* Init_MISC */
+ 0xEB,
+ { /* Init_SR0_SR4 */
+ 0x03, 0x01, 0x0F, 0x03, 0x0E,
+ },
+ { /* Init_SR10_SR24 */
+ 0xF3, 0xB6, 0xC0, 0xDD, 0x00, 0x0E, 0x17, 0x2C,
+ 0x99, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xC4, 0x32, 0x02, 0x01, 0x01,
+ },
+ { /* Init_SR30_SR75 */
+ 0x38, 0x03, 0x20, 0x09, 0xC0, 0x3A, 0x3A, 0x3A,
+ 0x3A, 0x3A, 0x3A, 0x3A, 0x00, 0x00, 0x03, 0xFF,
+ 0x00, 0xFC, 0x00, 0x00, 0x20, 0x18, 0x00, 0xFC,
+ 0x20, 0x0C, 0x44, 0x20, 0x00, 0x00, 0x00, 0x3A,
+ 0x06, 0x68, 0xA7, 0x7F, 0x83, 0x24, 0xFF, 0x03,
+ 0x00, 0x60, 0x59, 0x3A, 0x3A, 0x00, 0x00, 0x3A,
+ 0x01, 0x80, 0x7E, 0x1A, 0x1A, 0x00, 0x00, 0x00,
+ 0x50, 0x03, 0x74, 0x14, 0x08, 0x43, 0x08, 0x43,
+ 0x04, 0x45, 0x30, 0x30, 0x40, 0x20,
+ },
+ { /* Init_SR80_SR93 */
+ 0xFF, 0x07, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x3A,
+ 0xF7, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x3A, 0x3A,
+ 0x00, 0x00, 0x00, 0x00,
+ },
+ { /* Init_SRA0_SRAF */
+ 0x00, 0xFB, 0x9F, 0x01, 0x00, 0xED, 0xED, 0xED,
+ 0x7B, 0xFB, 0xFF, 0xFF, 0x97, 0xEF, 0xBF, 0xDF,
+ },
+ { /* Init_GR00_GR08 */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F,
+ 0xFF,
+ },
+ { /* Init_AR00_AR14 */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ 0x41, 0x00, 0x0F, 0x00, 0x00,
+ },
+ { /* Init_CR00_CR18 */
+ 0xA3, 0x7F, 0x7F, 0x00, 0x85, 0x16, 0x24, 0xF5,
+ 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x03, 0x09, 0xFF, 0x80, 0x40, 0xFF, 0x00, 0xE3,
+ 0xFF,
+ },
+ { /* Init_CR30_CR4D */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20,
+ 0x00, 0x00, 0x30, 0x40, 0x00, 0xFF, 0xBF, 0xFF,
+ 0x2E, 0x27, 0x00, 0x2b, 0x0c, 0x0F, 0xEF, 0x00,
+ 0xFe, 0x0f, 0x01, 0xC0, 0x27, 0xEF,
+ },
+ { /* Init_CR90_CRA7 */
+ 0x55, 0xD9, 0x5D, 0xE1, 0x86, 0x1B, 0x8E, 0x26,
+ 0xDA, 0x8D, 0xDE, 0x94, 0x00, 0x00, 0x18, 0x00,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x03,
+ },
+ },
+};
+
+#define numVGAModes ARRAY_SIZE(VGAMode)
--- /dev/null
+/*
+ * Silicon Motion SM7XX frame buffer device
+ *
+ * Copyright (C) 2006 Silicon Motion Technology Corp.
+ * Authors: Ge Wang, gewang@siliconmotion.com
+ * Boyod boyod.yang@siliconmotion.com.cn
+ *
+ * Copyright (C) 2009 Lemote, Inc.
+ * Author: Wu Zhangjin, wuzhangjin@gmail.com
+ *
+ * Copyright (C) 2011 Igalia, S.L.
+ * Author: Javier M. Mellid <jmunhoz@igalia.com>
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of this archive for
+ * more details.
+ *
+ * Framebuffer driver for Silicon Motion SM710, SM712, SM721 and SM722 chips
+ */
+
+#include <linux/io.h>
+#include <linux/fb.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/console.h>
+#include <linux/screen_info.h>
+
+#ifdef CONFIG_PM
+#include <linux/pm.h>
+#endif
+
+#include "sm7xx.h"
+
+struct screen_info smtc_screen_info;
+
+/*
+* Private structure
+*/
+struct smtcfb_info {
+ struct fb_info fb;
+ struct pci_dev *pdev;
+
+ u16 chipID;
+ unsigned char __iomem *m_pMMIO;
+ char __iomem *m_pLFB;
+ char *m_pDPR;
+ char *m_pVPR;
+ char *m_pCPR;
+
+ u_int width;
+ u_int height;
+ u_int hz;
+
+ u8 chipRevID;
+};
+
+struct vesa_mode_table {
+ char mode_index[6];
+ u16 lfb_width;
+ u16 lfb_height;
+ u16 lfb_depth;
+};
+
+static struct vesa_mode_table vesa_mode[] = {
+ {"0x301", 640, 480, 8},
+ {"0x303", 800, 600, 8},
+ {"0x305", 1024, 768, 8},
+ {"0x307", 1280, 1024, 8},
+
+ {"0x311", 640, 480, 16},
+ {"0x314", 800, 600, 16},
+ {"0x317", 1024, 768, 16},
+ {"0x31A", 1280, 1024, 16},
+
+ {"0x312", 640, 480, 24},
+ {"0x315", 800, 600, 24},
+ {"0x318", 1024, 768, 24},
+ {"0x31B", 1280, 1024, 24},
+};
+
+char __iomem *smtc_RegBaseAddress; /* Memory Map IO starting address */
+char __iomem *smtc_VRAMBaseAddress; /* video memory starting address */
+
+static u32 colreg[17];
+
+static struct fb_var_screeninfo smtcfb_var = {
+ .xres = 1024,
+ .yres = 600,
+ .xres_virtual = 1024,
+ .yres_virtual = 600,
+ .bits_per_pixel = 16,
+ .red = {16, 8, 0},
+ .green = {8, 8, 0},
+ .blue = {0, 8, 0},
+ .activate = FB_ACTIVATE_NOW,
+ .height = -1,
+ .width = -1,
+ .vmode = FB_VMODE_NONINTERLACED,
+};
+
+static struct fb_fix_screeninfo smtcfb_fix = {
+ .id = "sm712fb",
+ .type = FB_TYPE_PACKED_PIXELS,
+ .visual = FB_VISUAL_TRUECOLOR,
+ .line_length = 800 * 3,
+ .accel = FB_ACCEL_SMI_LYNX,
+};
+
+static void sm712_set_timing(struct smtcfb_info *sfb)
+{
+ int i = 0, j = 0;
+ u32 m_nScreenStride;
+
+ dev_dbg(&sfb->pdev->dev,
+ "sfb->width=%d sfb->height=%d "
+ "sfb->fb.var.bits_per_pixel=%d sfb->hz=%d\n",
+ sfb->width, sfb->height, sfb->fb.var.bits_per_pixel, sfb->hz);
+
+ for (j = 0; j < numVGAModes; j++) {
+ if (VGAMode[j].mmSizeX == sfb->width &&
+ VGAMode[j].mmSizeY == sfb->height &&
+ VGAMode[j].bpp == sfb->fb.var.bits_per_pixel &&
+ VGAMode[j].hz == sfb->hz) {
+
+ dev_dbg(&sfb->pdev->dev,
+ "VGAMode[j].mmSizeX=%d VGAMode[j].mmSizeY=%d "
+ "VGAMode[j].bpp=%d VGAMode[j].hz=%d\n",
+ VGAMode[j].mmSizeX, VGAMode[j].mmSizeY,
+ VGAMode[j].bpp, VGAMode[j].hz);
+
+ dev_dbg(&sfb->pdev->dev, "VGAMode index=%d\n", j);
+
+ smtc_mmiowb(0x0, 0x3c6);
+
+ smtc_seqw(0, 0x1);
+
+ smtc_mmiowb(VGAMode[j].Init_MISC, 0x3c2);
+
+ /* init SEQ register SR00 - SR04 */
+ for (i = 0; i < SIZE_SR00_SR04; i++)
+ smtc_seqw(i, VGAMode[j].Init_SR00_SR04[i]);
+
+ /* init SEQ register SR10 - SR24 */
+ for (i = 0; i < SIZE_SR10_SR24; i++)
+ smtc_seqw(i + 0x10,
+ VGAMode[j].Init_SR10_SR24[i]);
+
+ /* init SEQ register SR30 - SR75 */
+ for (i = 0; i < SIZE_SR30_SR75; i++)
+ if (((i + 0x30) != 0x62) \
+ && ((i + 0x30) != 0x6a) \
+ && ((i + 0x30) != 0x6b))
+ smtc_seqw(i + 0x30,
+ VGAMode[j].Init_SR30_SR75[i]);
+
+ /* init SEQ register SR80 - SR93 */
+ for (i = 0; i < SIZE_SR80_SR93; i++)
+ smtc_seqw(i + 0x80,
+ VGAMode[j].Init_SR80_SR93[i]);
+
+ /* init SEQ register SRA0 - SRAF */
+ for (i = 0; i < SIZE_SRA0_SRAF; i++)
+ smtc_seqw(i + 0xa0,
+ VGAMode[j].Init_SRA0_SRAF[i]);
+
+ /* init Graphic register GR00 - GR08 */
+ for (i = 0; i < SIZE_GR00_GR08; i++)
+ smtc_grphw(i, VGAMode[j].Init_GR00_GR08[i]);
+
+ /* init Attribute register AR00 - AR14 */
+ for (i = 0; i < SIZE_AR00_AR14; i++)
+ smtc_attrw(i, VGAMode[j].Init_AR00_AR14[i]);
+
+ /* init CRTC register CR00 - CR18 */
+ for (i = 0; i < SIZE_CR00_CR18; i++)
+ smtc_crtcw(i, VGAMode[j].Init_CR00_CR18[i]);
+
+ /* init CRTC register CR30 - CR4D */
+ for (i = 0; i < SIZE_CR30_CR4D; i++)
+ smtc_crtcw(i + 0x30,
+ VGAMode[j].Init_CR30_CR4D[i]);
+
+ /* init CRTC register CR90 - CRA7 */
+ for (i = 0; i < SIZE_CR90_CRA7; i++)
+ smtc_crtcw(i + 0x90,
+ VGAMode[j].Init_CR90_CRA7[i]);
+ }
+ }
+ smtc_mmiowb(0x67, 0x3c2);
+
+ /* set VPR registers */
+ writel(0x0, sfb->m_pVPR + 0x0C);
+ writel(0x0, sfb->m_pVPR + 0x40);
+
+ /* set data width */
+ m_nScreenStride =
+ (sfb->width * sfb->fb.var.bits_per_pixel) / 64;
+ switch (sfb->fb.var.bits_per_pixel) {
+ case 8:
+ writel(0x0, sfb->m_pVPR + 0x0);
+ break;
+ case 16:
+ writel(0x00020000, sfb->m_pVPR + 0x0);
+ break;
+ case 24:
+ writel(0x00040000, sfb->m_pVPR + 0x0);
+ break;
+ case 32:
+ writel(0x00030000, sfb->m_pVPR + 0x0);
+ break;
+ }
+ writel((u32) (((m_nScreenStride + 2) << 16) | m_nScreenStride),
+ sfb->m_pVPR + 0x10);
+
+}
+
+static void sm712_setpalette(int regno, unsigned red, unsigned green,
+ unsigned blue, struct fb_info *info)
+{
+ /* set bit 5:4 = 01 (write LCD RAM only) */
+ smtc_seqw(0x66, (smtc_seqr(0x66) & 0xC3) | 0x10);
+
+ smtc_mmiowb(regno, dac_reg);
+ smtc_mmiowb(red >> 10, dac_val);
+ smtc_mmiowb(green >> 10, dac_val);
+ smtc_mmiowb(blue >> 10, dac_val);
+}
+
+static void smtc_set_timing(struct smtcfb_info *sfb)
+{
+ switch (sfb->chipID) {
+ case 0x710:
+ case 0x712:
+ case 0x720:
+ sm712_set_timing(sfb);
+ break;
+ }
+}
+
+/* chan_to_field
+ *
+ * convert a colour value into a field position
+ *
+ * from pxafb.c
+ */
+
+static inline unsigned int chan_to_field(unsigned int chan,
+ struct fb_bitfield *bf)
+{
+ chan &= 0xffff;
+ chan >>= 16 - bf->length;
+ return chan << bf->offset;
+}
+
+static int smtc_blank(int blank_mode, struct fb_info *info)
+{
+ /* clear DPMS setting */
+ switch (blank_mode) {
+ case FB_BLANK_UNBLANK:
+ /* Screen On: HSync: On, VSync : On */
+ smtc_seqw(0x01, (smtc_seqr(0x01) & (~0x20)));
+ smtc_seqw(0x6a, 0x16);
+ smtc_seqw(0x6b, 0x02);
+ smtc_seqw(0x21, (smtc_seqr(0x21) & 0x77));
+ smtc_seqw(0x22, (smtc_seqr(0x22) & (~0x30)));
+ smtc_seqw(0x23, (smtc_seqr(0x23) & (~0xc0)));
+ smtc_seqw(0x24, (smtc_seqr(0x24) | 0x01));
+ smtc_seqw(0x31, (smtc_seqr(0x31) | 0x03));
+ break;
+ case FB_BLANK_NORMAL:
+ /* Screen Off: HSync: On, VSync : On Soft blank */
+ smtc_seqw(0x01, (smtc_seqr(0x01) & (~0x20)));
+ smtc_seqw(0x6a, 0x16);
+ smtc_seqw(0x6b, 0x02);
+ smtc_seqw(0x22, (smtc_seqr(0x22) & (~0x30)));
+ smtc_seqw(0x23, (smtc_seqr(0x23) & (~0xc0)));
+ smtc_seqw(0x24, (smtc_seqr(0x24) | 0x01));
+ smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
+ break;
+ case FB_BLANK_VSYNC_SUSPEND:
+ /* Screen On: HSync: On, VSync : Off */
+ smtc_seqw(0x01, (smtc_seqr(0x01) | 0x20));
+ smtc_seqw(0x20, (smtc_seqr(0x20) & (~0xB0)));
+ smtc_seqw(0x6a, 0x0c);
+ smtc_seqw(0x6b, 0x02);
+ smtc_seqw(0x21, (smtc_seqr(0x21) | 0x88));
+ smtc_seqw(0x22, ((smtc_seqr(0x22) & (~0x30)) | 0x20));
+ smtc_seqw(0x23, ((smtc_seqr(0x23) & (~0xc0)) | 0x20));
+ smtc_seqw(0x24, (smtc_seqr(0x24) & (~0x01)));
+ smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
+ smtc_seqw(0x34, (smtc_seqr(0x34) | 0x80));
+ break;
+ case FB_BLANK_HSYNC_SUSPEND:
+ /* Screen On: HSync: Off, VSync : On */
+ smtc_seqw(0x01, (smtc_seqr(0x01) | 0x20));
+ smtc_seqw(0x20, (smtc_seqr(0x20) & (~0xB0)));
+ smtc_seqw(0x6a, 0x0c);
+ smtc_seqw(0x6b, 0x02);
+ smtc_seqw(0x21, (smtc_seqr(0x21) | 0x88));
+ smtc_seqw(0x22, ((smtc_seqr(0x22) & (~0x30)) | 0x10));
+ smtc_seqw(0x23, ((smtc_seqr(0x23) & (~0xc0)) | 0xD8));
+ smtc_seqw(0x24, (smtc_seqr(0x24) & (~0x01)));
+ smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
+ smtc_seqw(0x34, (smtc_seqr(0x34) | 0x80));
+ break;
+ case FB_BLANK_POWERDOWN:
+ /* Screen On: HSync: Off, VSync : Off */
+ smtc_seqw(0x01, (smtc_seqr(0x01) | 0x20));
+ smtc_seqw(0x20, (smtc_seqr(0x20) & (~0xB0)));
+ smtc_seqw(0x6a, 0x0c);
+ smtc_seqw(0x6b, 0x02);
+ smtc_seqw(0x21, (smtc_seqr(0x21) | 0x88));
+ smtc_seqw(0x22, ((smtc_seqr(0x22) & (~0x30)) | 0x30));
+ smtc_seqw(0x23, ((smtc_seqr(0x23) & (~0xc0)) | 0xD8));
+ smtc_seqw(0x24, (smtc_seqr(0x24) & (~0x01)));
+ smtc_seqw(0x31, ((smtc_seqr(0x31) & (~0x07)) | 0x00));
+ smtc_seqw(0x34, (smtc_seqr(0x34) | 0x80));
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int smtc_setcolreg(unsigned regno, unsigned red, unsigned green,
+ unsigned blue, unsigned trans, struct fb_info *info)
+{
+ struct smtcfb_info *sfb = (struct smtcfb_info *)info;
+ u32 val;
+
+ if (regno > 255)
+ return 1;
+
+ switch (sfb->fb.fix.visual) {
+ case FB_VISUAL_DIRECTCOLOR:
+ case FB_VISUAL_TRUECOLOR:
+ /*
+ * 16/32 bit true-colour, use pseudo-palette for 16 base color
+ */
+ if (regno < 16) {
+ if (sfb->fb.var.bits_per_pixel == 16) {
+ u32 *pal = sfb->fb.pseudo_palette;
+ val = chan_to_field(red, &sfb->fb.var.red);
+ val |= chan_to_field(green, \
+ &sfb->fb.var.green);
+ val |= chan_to_field(blue, &sfb->fb.var.blue);
+#ifdef __BIG_ENDIAN
+ pal[regno] =
+ ((red & 0xf800) >> 8) |
+ ((green & 0xe000) >> 13) |
+ ((green & 0x1c00) << 3) |
+ ((blue & 0xf800) >> 3);
+#else
+ pal[regno] = val;
+#endif
+ } else {
+ u32 *pal = sfb->fb.pseudo_palette;
+ val = chan_to_field(red, &sfb->fb.var.red);
+ val |= chan_to_field(green, \
+ &sfb->fb.var.green);
+ val |= chan_to_field(blue, &sfb->fb.var.blue);
+#ifdef __BIG_ENDIAN
+ val =
+ (val & 0xff00ff00 >> 8) |
+ (val & 0x00ff00ff << 8);
+#endif
+ pal[regno] = val;
+ }
+ }
+ break;
+
+ case FB_VISUAL_PSEUDOCOLOR:
+ /* color depth 8 bit */
+ sm712_setpalette(regno, red, green, blue, info);
+ break;
+
+ default:
+ return 1; /* unknown type */
+ }
+
+ return 0;
+
+}
+
+#ifdef __BIG_ENDIAN
+static ssize_t smtcfb_read(struct fb_info *info, char __user *buf, size_t
+ count, loff_t *ppos)
+{
+ unsigned long p = *ppos;
+
+ u32 *buffer, *dst;
+ u32 __iomem *src;
+ int c, i, cnt = 0, err = 0;
+ unsigned long total_size;
+
+ if (!info || !info->screen_base)
+ return -ENODEV;
+
+ if (info->state != FBINFO_STATE_RUNNING)
+ return -EPERM;
+
+ total_size = info->screen_size;
+
+ if (total_size == 0)
+ total_size = info->fix.smem_len;
+
+ if (p >= total_size)
+ return 0;
+
+ if (count >= total_size)
+ count = total_size;
+
+ if (count + p > total_size)
+ count = total_size - p;
+
+ buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL);
+ if (!buffer)
+ return -ENOMEM;
+
+ src = (u32 __iomem *) (info->screen_base + p);
+
+ if (info->fbops->fb_sync)
+ info->fbops->fb_sync(info);
+
+ while (count) {
+ c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
+ dst = buffer;
+ for (i = c >> 2; i--;) {
+ *dst = fb_readl(src++);
+ *dst =
+ (*dst & 0xff00ff00 >> 8) |
+ (*dst & 0x00ff00ff << 8);
+ dst++;
+ }
+ if (c & 3) {
+ u8 *dst8 = (u8 *) dst;
+ u8 __iomem *src8 = (u8 __iomem *) src;
+
+ for (i = c & 3; i--;) {
+ if (i & 1) {
+ *dst8++ = fb_readb(++src8);
+ } else {
+ *dst8++ = fb_readb(--src8);
+ src8 += 2;
+ }
+ }
+ src = (u32 __iomem *) src8;
+ }
+
+ if (copy_to_user(buf, buffer, c)) {
+ err = -EFAULT;
+ break;
+ }
+ *ppos += c;
+ buf += c;
+ cnt += c;
+ count -= c;
+ }
+
+ kfree(buffer);
+
+ return (err) ? err : cnt;
+}
+
+static ssize_t
+smtcfb_write(struct fb_info *info, const char __user *buf, size_t count,
+ loff_t *ppos)
+{
+ unsigned long p = *ppos;
+
+ u32 *buffer, *src;
+ u32 __iomem *dst;
+ int c, i, cnt = 0, err = 0;
+ unsigned long total_size;
+
+ if (!info || !info->screen_base)
+ return -ENODEV;
+
+ if (info->state != FBINFO_STATE_RUNNING)
+ return -EPERM;
+
+ total_size = info->screen_size;
+
+ if (total_size == 0)
+ total_size = info->fix.smem_len;
+
+ if (p > total_size)
+ return -EFBIG;
+
+ if (count > total_size) {
+ err = -EFBIG;
+ count = total_size;
+ }
+
+ if (count + p > total_size) {
+ if (!err)
+ err = -ENOSPC;
+
+ count = total_size - p;
+ }
+
+ buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count, GFP_KERNEL);
+ if (!buffer)
+ return -ENOMEM;
+
+ dst = (u32 __iomem *) (info->screen_base + p);
+
+ if (info->fbops->fb_sync)
+ info->fbops->fb_sync(info);
+
+ while (count) {
+ c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
+ src = buffer;
+
+ if (copy_from_user(src, buf, c)) {
+ err = -EFAULT;
+ break;
+ }
+
+ for (i = c >> 2; i--;) {
+ fb_writel((*src & 0xff00ff00 >> 8) |
+ (*src & 0x00ff00ff << 8), dst++);
+ src++;
+ }
+ if (c & 3) {
+ u8 *src8 = (u8 *) src;
+ u8 __iomem *dst8 = (u8 __iomem *) dst;
+
+ for (i = c & 3; i--;) {
+ if (i & 1) {
+ fb_writeb(*src8++, ++dst8);
+ } else {
+ fb_writeb(*src8++, --dst8);
+ dst8 += 2;
+ }
+ }
+ dst = (u32 __iomem *) dst8;
+ }
+
+ *ppos += c;
+ buf += c;
+ cnt += c;
+ count -= c;
+ }
+
+ kfree(buffer);
+
+ return (cnt) ? cnt : err;
+}
+#endif /* ! __BIG_ENDIAN */
+
+void smtcfb_setmode(struct smtcfb_info *sfb)
+{
+ switch (sfb->fb.var.bits_per_pixel) {
+ case 32:
+ sfb->fb.fix.visual = FB_VISUAL_TRUECOLOR;
+ sfb->fb.fix.line_length = sfb->fb.var.xres * 4;
+ sfb->fb.var.red.length = 8;
+ sfb->fb.var.green.length = 8;
+ sfb->fb.var.blue.length = 8;
+ sfb->fb.var.red.offset = 16;
+ sfb->fb.var.green.offset = 8;
+ sfb->fb.var.blue.offset = 0;
+ break;
+ case 24:
+ sfb->fb.fix.visual = FB_VISUAL_TRUECOLOR;
+ sfb->fb.fix.line_length = sfb->fb.var.xres * 3;
+ sfb->fb.var.red.length = 8;
+ sfb->fb.var.green.length = 8;
+ sfb->fb.var.blue.length = 8;
+ sfb->fb.var.red.offset = 16;
+ sfb->fb.var.green.offset = 8;
+ sfb->fb.var.blue.offset = 0;
+ break;
+ case 8:
+ sfb->fb.fix.visual = FB_VISUAL_PSEUDOCOLOR;
+ sfb->fb.fix.line_length = sfb->fb.var.xres;
+ sfb->fb.var.red.length = 3;
+ sfb->fb.var.green.length = 3;
+ sfb->fb.var.blue.length = 2;
+ sfb->fb.var.red.offset = 5;
+ sfb->fb.var.green.offset = 2;
+ sfb->fb.var.blue.offset = 0;
+ break;
+ case 16:
+ default:
+ sfb->fb.fix.visual = FB_VISUAL_TRUECOLOR;
+ sfb->fb.fix.line_length = sfb->fb.var.xres * 2;
+ sfb->fb.var.red.length = 5;
+ sfb->fb.var.green.length = 6;
+ sfb->fb.var.blue.length = 5;
+ sfb->fb.var.red.offset = 11;
+ sfb->fb.var.green.offset = 5;
+ sfb->fb.var.blue.offset = 0;
+ break;
+ }
+
+ sfb->width = sfb->fb.var.xres;
+ sfb->height = sfb->fb.var.yres;
+ sfb->hz = 60;
+ smtc_set_timing(sfb);
+}
+
+static int smtc_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
+{
+ /* sanity checks */
+ if (var->xres_virtual < var->xres)
+ var->xres_virtual = var->xres;
+
+ if (var->yres_virtual < var->yres)
+ var->yres_virtual = var->yres;
+
+ /* set valid default bpp */
+ if ((var->bits_per_pixel != 8) && (var->bits_per_pixel != 16) &&
+ (var->bits_per_pixel != 24) && (var->bits_per_pixel != 32))
+ var->bits_per_pixel = 16;
+
+ return 0;
+}
+
+static int smtc_set_par(struct fb_info *info)
+{
+ struct smtcfb_info *sfb = (struct smtcfb_info *)info;
+
+ smtcfb_setmode(sfb);
+
+ return 0;
+}
+
+static struct fb_ops smtcfb_ops = {
+ .owner = THIS_MODULE,
+ .fb_check_var = smtc_check_var,
+ .fb_set_par = smtc_set_par,
+ .fb_setcolreg = smtc_setcolreg,
+ .fb_blank = smtc_blank,
+ .fb_fillrect = cfb_fillrect,
+ .fb_imageblit = cfb_imageblit,
+ .fb_copyarea = cfb_copyarea,
+#ifdef __BIG_ENDIAN
+ .fb_read = smtcfb_read,
+ .fb_write = smtcfb_write,
+#endif
+};
+
+/*
+ * Alloc struct smtcfb_info and assign the default value
+ */
+static struct smtcfb_info *smtc_alloc_fb_info(struct pci_dev *pdev, char *name)
+{
+ struct smtcfb_info *sfb;
+
+ sfb = kzalloc(sizeof(*sfb), GFP_KERNEL);
+
+ if (!sfb)
+ return NULL;
+
+ sfb->pdev = pdev;
+
+ /*** Init sfb->fb with default value ***/
+ sfb->fb.flags = FBINFO_FLAG_DEFAULT;
+ sfb->fb.fbops = &smtcfb_ops;
+ sfb->fb.var = smtcfb_var;
+ sfb->fb.fix = smtcfb_fix;
+
+ strcpy(sfb->fb.fix.id, name);
+
+ sfb->fb.fix.type = FB_TYPE_PACKED_PIXELS;
+ sfb->fb.fix.type_aux = 0;
+ sfb->fb.fix.xpanstep = 0;
+ sfb->fb.fix.ypanstep = 0;
+ sfb->fb.fix.ywrapstep = 0;
+ sfb->fb.fix.accel = FB_ACCEL_SMI_LYNX;
+
+ sfb->fb.var.nonstd = 0;
+ sfb->fb.var.activate = FB_ACTIVATE_NOW;
+ sfb->fb.var.height = -1;
+ sfb->fb.var.width = -1;
+ /* text mode acceleration */
+ sfb->fb.var.accel_flags = FB_ACCELF_TEXT;
+ sfb->fb.var.vmode = FB_VMODE_NONINTERLACED;
+
+ sfb->fb.par = sfb;
+
+ sfb->fb.pseudo_palette = colreg;
+
+ return sfb;
+}
+
+/*
+ * free struct smtcfb_info
+ */
+static void smtc_free_fb_info(struct smtcfb_info *sfb)
+{
+ kfree(sfb);
+}
+
+/*
+ * Unmap in the memory mapped IO registers
+ */
+
+static void smtc_unmap_mmio(struct smtcfb_info *sfb)
+{
+ if (sfb && smtc_RegBaseAddress)
+ smtc_RegBaseAddress = NULL;
+}
+
+/*
+ * Map in the screen memory
+ */
+
+static int smtc_map_smem(struct smtcfb_info *sfb,
+ struct pci_dev *pdev, u_long smem_len)
+{
+
+ sfb->fb.fix.smem_start = pci_resource_start(pdev, 0);
+
+#ifdef __BIG_ENDIAN
+ if (sfb->fb.var.bits_per_pixel == 32)
+ sfb->fb.fix.smem_start += 0x800000;
+#endif
+
+ sfb->fb.fix.smem_len = smem_len;
+
+ sfb->fb.screen_base = smtc_VRAMBaseAddress;
+
+ if (!sfb->fb.screen_base) {
+ dev_err(&pdev->dev,
+ "%s: unable to map screen memory\n", sfb->fb.fix.id);
+ return -ENOMEM;
+ }
+
+ return 0;
+}
+
+/*
+ * Unmap in the screen memory
+ *
+ */
+static void smtc_unmap_smem(struct smtcfb_info *sfb)
+{
+ if (sfb && sfb->fb.screen_base) {
+ iounmap(sfb->fb.screen_base);
+ sfb->fb.screen_base = NULL;
+ }
+}
+
+/*
+ * We need to wake up the device and make sure its in linear memory mode.
+ */
+static inline void sm7xx_init_hw(void)
+{
+ outb_p(0x18, 0x3c4);
+ outb_p(0x11, 0x3c5);
+}
+
+/*
+ * sm712vga_setup - process command line options, get vga parameter
+ * @options: string of options
+ * Returns zero.
+ *
+ */
+static int __init sm712vga_setup(char *options)
+{
+ int index;
+
+ if (!options || !*options)
+ return -EINVAL;
+
+ smtc_screen_info.lfb_width = 0;
+ smtc_screen_info.lfb_height = 0;
+ smtc_screen_info.lfb_depth = 0;
+
+ pr_debug("sm712vga_setup = %s\n", options);
+
+ for (index = 0;
+ index < ARRAY_SIZE(vesa_mode);
+ index++) {
+ if (strstr(options, vesa_mode[index].mode_index)) {
+ smtc_screen_info.lfb_width = vesa_mode[index].lfb_width;
+ smtc_screen_info.lfb_height =
+ vesa_mode[index].lfb_height;
+ smtc_screen_info.lfb_depth = vesa_mode[index].lfb_depth;
+ return 0;
+ }
+ }
+
+ return -1;
+}
+__setup("vga=", sm712vga_setup);
+
+static int __devinit smtcfb_pci_probe(struct pci_dev *pdev,
+ const struct pci_device_id *ent)
+{
+ struct smtcfb_info *sfb;
+ u_long smem_size = 0x00800000; /* default 8MB */
+ char name[16];
+ int err;
+ unsigned long pFramebufferPhysical;
+
+ dev_info(&pdev->dev, "Silicon Motion display driver.");
+
+ err = pci_enable_device(pdev); /* enable SMTC chip */
+ if (err)
+ return err;
+
+ sfb = smtc_alloc_fb_info(pdev, name);
+
+ if (!sfb)
+ goto failed_free;
+
+ sfb->chipID = ent->device;
+ sprintf(name, "sm%Xfb", sfb->chipID);
+
+ pci_set_drvdata(pdev, sfb);
+
+ sm7xx_init_hw();
+
+ /*get mode parameter from smtc_screen_info */
+ if (smtc_screen_info.lfb_width != 0) {
+ sfb->fb.var.xres = smtc_screen_info.lfb_width;
+ sfb->fb.var.yres = smtc_screen_info.lfb_height;
+ sfb->fb.var.bits_per_pixel = smtc_screen_info.lfb_depth;
+ } else {
+ /* default resolution 1024x600 16bit mode */
+ sfb->fb.var.xres = SCREEN_X_RES;
+ sfb->fb.var.yres = SCREEN_Y_RES;
+ sfb->fb.var.bits_per_pixel = SCREEN_BPP;
+ }
+
+#ifdef __BIG_ENDIAN
+ if (sfb->fb.var.bits_per_pixel == 24)
+ sfb->fb.var.bits_per_pixel = (smtc_screen_info.lfb_depth = 32);
+#endif
+ /* Map address and memory detection */
+ pFramebufferPhysical = pci_resource_start(pdev, 0);
+ pci_read_config_byte(pdev, PCI_REVISION_ID, &sfb->chipRevID);
+
+ switch (sfb->chipID) {
+ case 0x710:
+ case 0x712:
+ sfb->fb.fix.mmio_start = pFramebufferPhysical + 0x00400000;
+ sfb->fb.fix.mmio_len = 0x00400000;
+ smem_size = SM712_VIDEOMEMORYSIZE;
+#ifdef __BIG_ENDIAN
+ sfb->m_pLFB = (smtc_VRAMBaseAddress =
+ ioremap(pFramebufferPhysical, 0x00c00000));
+#else
+ sfb->m_pLFB = (smtc_VRAMBaseAddress =
+ ioremap(pFramebufferPhysical, 0x00800000));
+#endif
+ sfb->m_pMMIO = (smtc_RegBaseAddress =
+ smtc_VRAMBaseAddress + 0x00700000);
+ sfb->m_pDPR = smtc_VRAMBaseAddress + 0x00408000;
+ sfb->m_pVPR = sfb->m_pLFB + 0x0040c000;
+#ifdef __BIG_ENDIAN
+ if (sfb->fb.var.bits_per_pixel == 32) {
+ smtc_VRAMBaseAddress += 0x800000;
+ sfb->m_pLFB += 0x800000;
+ dev_info(&pdev->dev,
+ "smtc_VRAMBaseAddress=%p sfb->m_pLFB=%p",
+ smtc_VRAMBaseAddress, sfb->m_pLFB);
+ }
+#endif
+ if (!smtc_RegBaseAddress) {
+ dev_err(&pdev->dev,
+ "%s: unable to map memory mapped IO!",
+ sfb->fb.fix.id);
+ err = -ENOMEM;
+ goto failed_fb;
+ }
+
+ /* set MCLK = 14.31818 * (0x16 / 0x2) */
+ smtc_seqw(0x6a, 0x16);
+ smtc_seqw(0x6b, 0x02);
+ smtc_seqw(0x62, 0x3e);
+ /* enable PCI burst */
+ smtc_seqw(0x17, 0x20);
+ /* enable word swap */
+#ifdef __BIG_ENDIAN
+ if (sfb->fb.var.bits_per_pixel == 32)
+ smtc_seqw(0x17, 0x30);
+#endif
+ break;
+ case 0x720:
+ sfb->fb.fix.mmio_start = pFramebufferPhysical;
+ sfb->fb.fix.mmio_len = 0x00200000;
+ smem_size = SM722_VIDEOMEMORYSIZE;
+ sfb->m_pDPR = ioremap(pFramebufferPhysical, 0x00a00000);
+ sfb->m_pLFB = (smtc_VRAMBaseAddress =
+ sfb->m_pDPR + 0x00200000);
+ sfb->m_pMMIO = (smtc_RegBaseAddress =
+ sfb->m_pDPR + 0x000c0000);
+ sfb->m_pVPR = sfb->m_pDPR + 0x800;
+
+ smtc_seqw(0x62, 0xff);
+ smtc_seqw(0x6a, 0x0d);
+ smtc_seqw(0x6b, 0x02);
+ break;
+ default:
+ dev_err(&pdev->dev,
+ "No valid Silicon Motion display chip was detected!");
+
+ goto failed_fb;
+ }
+
+ /* can support 32 bpp */
+ if (15 == sfb->fb.var.bits_per_pixel)
+ sfb->fb.var.bits_per_pixel = 16;
+
+ sfb->fb.var.xres_virtual = sfb->fb.var.xres;
+ sfb->fb.var.yres_virtual = sfb->fb.var.yres;
+ err = smtc_map_smem(sfb, pdev, smem_size);
+ if (err)
+ goto failed;
+
+ smtcfb_setmode(sfb);
+
+ err = register_framebuffer(&sfb->fb);
+ if (err < 0)
+ goto failed;
+
+ dev_info(&pdev->dev,
+ "Silicon Motion SM%X Rev%X primary display mode %dx%d-%d Init Complete.",
+ sfb->chipID, sfb->chipRevID, sfb->fb.var.xres,
+ sfb->fb.var.yres, sfb->fb.var.bits_per_pixel);
+
+ return 0;
+
+failed:
+ dev_err(&pdev->dev, "Silicon Motion, Inc. primary display init fail.");
+
+ smtc_unmap_smem(sfb);
+ smtc_unmap_mmio(sfb);
+failed_fb:
+ smtc_free_fb_info(sfb);
+
+failed_free:
+ pci_disable_device(pdev);
+
+ return err;
+}
+
+/*
+ * 0x710 (LynxEM)
+ * 0x712 (LynxEM+)
+ * 0x720 (Lynx3DM, Lynx3DM+)
+ */
+static DEFINE_PCI_DEVICE_TABLE(smtcfb_pci_table) = {
+ { PCI_DEVICE(0x126f, 0x710), },
+ { PCI_DEVICE(0x126f, 0x712), },
+ { PCI_DEVICE(0x126f, 0x720), },
+ {0,}
+};
+
+static void __devexit smtcfb_pci_remove(struct pci_dev *pdev)
+{
+ struct smtcfb_info *sfb;
+
+ sfb = pci_get_drvdata(pdev);
+ pci_set_drvdata(pdev, NULL);
+ smtc_unmap_smem(sfb);
+ smtc_unmap_mmio(sfb);
+ unregister_framebuffer(&sfb->fb);
+ smtc_free_fb_info(sfb);
+}
+
+#ifdef CONFIG_PM
+static int smtcfb_pci_suspend(struct device *device)
+{
+ struct pci_dev *pdev = to_pci_dev(device);
+ struct smtcfb_info *sfb;
+
+ sfb = pci_get_drvdata(pdev);
+
+ /* set the hw in sleep mode use external clock and self memory refresh
+ * so that we can turn off internal PLLs later on
+ */
+ smtc_seqw(0x20, (smtc_seqr(0x20) | 0xc0));
+ smtc_seqw(0x69, (smtc_seqr(0x69) & 0xf7));
+
+ console_lock();
+ fb_set_suspend(&sfb->fb, 1);
+ console_unlock();
+
+ /* additionally turn off all function blocks including internal PLLs */
+ smtc_seqw(0x21, 0xff);
+
+ return 0;
+}
+
+static int smtcfb_pci_resume(struct device *device)
+{
+ struct pci_dev *pdev = to_pci_dev(device);
+ struct smtcfb_info *sfb;
+
+ sfb = pci_get_drvdata(pdev);
+
+ /* reinit hardware */
+ sm7xx_init_hw();
+ switch (sfb->chipID) {
+ case 0x710:
+ case 0x712:
+ /* set MCLK = 14.31818 * (0x16 / 0x2) */
+ smtc_seqw(0x6a, 0x16);
+ smtc_seqw(0x6b, 0x02);
+ smtc_seqw(0x62, 0x3e);
+ /* enable PCI burst */
+ smtc_seqw(0x17, 0x20);
+#ifdef __BIG_ENDIAN
+ if (sfb->fb.var.bits_per_pixel == 32)
+ smtc_seqw(0x17, 0x30);
+#endif
+ break;
+ case 0x720:
+ smtc_seqw(0x62, 0xff);
+ smtc_seqw(0x6a, 0x0d);
+ smtc_seqw(0x6b, 0x02);
+ break;
+ }
+
+ smtc_seqw(0x34, (smtc_seqr(0x34) | 0xc0));
+ smtc_seqw(0x33, ((smtc_seqr(0x33) | 0x08) & 0xfb));
+
+ smtcfb_setmode(sfb);
+
+ console_lock();
+ fb_set_suspend(&sfb->fb, 0);
+ console_unlock();
+
+ return 0;
+}
+
+static const struct dev_pm_ops sm7xx_pm_ops = {
+ .suspend = smtcfb_pci_suspend,
+ .resume = smtcfb_pci_resume,
+ .freeze = smtcfb_pci_suspend,
+ .thaw = smtcfb_pci_resume,
+ .poweroff = smtcfb_pci_suspend,
+ .restore = smtcfb_pci_resume,
+};
+
+#define SM7XX_PM_OPS (&sm7xx_pm_ops)
+
+#else /* !CONFIG_PM */
+
+#define SM7XX_PM_OPS NULL
+
+#endif /* !CONFIG_PM */
+
+static struct pci_driver smtcfb_driver = {
+ .name = "smtcfb",
+ .id_table = smtcfb_pci_table,
+ .probe = smtcfb_pci_probe,
+ .remove = __devexit_p(smtcfb_pci_remove),
+ .driver.pm = SM7XX_PM_OPS,
+};
+
+static int __init smtcfb_init(void)
+{
+ return pci_register_driver(&smtcfb_driver);
+}
+
+static void __exit smtcfb_exit(void)
+{
+ pci_unregister_driver(&smtcfb_driver);
+}
+
+module_init(smtcfb_init);
+module_exit(smtcfb_exit);
+
+MODULE_AUTHOR("Siliconmotion ");
+MODULE_DESCRIPTION("Framebuffer driver for SMI Graphic Cards");
+MODULE_LICENSE("GPL");
static int handle_goto(struct vc_data *vc, u_char type, u_char ch, u_short key)
{
- static u_char *goto_buf = "\0\0\0\0\0\0";
+ static u_char goto_buf[8];
static int num;
int maxlen, go_pos;
char *cp;
if (spk_sel_cons != vc_cons[fg_console].d) {
speakup_clear_selection();
spk_sel_cons = vc_cons[fg_console].d;
- printk(KERN_WARNING
+ dev_warn(tty->dev,
"Selection: mark console not the same as cut\n");
return -EINVAL;
}
/* Allocate a new buffer before freeing the old one ... */
bp = kmalloc((sel_end-sel_start)/2+1, GFP_ATOMIC);
if (!bp) {
- printk(KERN_WARNING "selection: kmalloc() failed\n");
+ dev_warn(tty->dev, "selection: kmalloc() failed\n");
speakup_clear_selection();
return -ENOMEM;
}
count = sel_buffer_lth - pasted;
count = min_t(int, count, tty->receive_room);
tty->ldisc->ops->receive_buf(tty, sel_buffer + pasted,
- 0, count);
+ NULL, count);
pasted += count;
}
remove_wait_queue(&vc->paste_wait, &wait);
sbin_PROGRAMS := usbip usbipd
-usbip_SOURCES := usbip.c utils.c usbip_network.c \
+usbip_SOURCES := usbip.h utils.h usbip.c utils.c usbip_network.c \
usbip_attach.c usbip_detach.c usbip_list.c \
usbip_bind.c usbip_unbind.c
-usbipd_SOURCES := usbipd.c usbip_network.c
+
+usbipd_SOURCES := usbip_network.h usbipd.c usbip_network.c
unsigned long unlink_seqnum;
};
-/*
- * The number of ports is less than 16 ?
- * USB_MAXCHILDREN is statically defined to 16 in usb.h. Its maximum value
- * would be 31 because the event_bits[1] of struct usb_hub is defined as
- * unsigned long in hub.h
- */
+/* Number of supported ports. Value has an upperbound of USB_MAXCHILDREN */
#define VHCI_NPORTS 8
/* for usb_bus.hcpriv */
| USB_PORT_STAT_C_RESET) << 16)
/*
- * This function is almostly the same as dummy_hcd.c:dummy_hub_status() without
- * suspend/resume support. But, it is modified to provide multiple ports.
+ * Returns 0 if the status hasn't changed, or the number of bytes in buf.
+ * Ports are 0-indexed from the HCD point of view,
+ * and 1-indexed from the USB core pointer of view.
*
* @buf: a bitmap to show which port status has been changed.
- * bit 0: reserved or used for another purpose?
+ * bit 0: reserved
* bit 1: the status of port 0 has been changed.
* bit 2: the status of port 1 has been changed.
* ...
- * bit 7: the status of port 6 has been changed.
- * bit 8: the status of port 7 has been changed.
- * ...
- * bit 15: the status of port 14 has been changed.
- *
- * So, the maximum number of ports is 31 ( port 0 to port 30) ?
- *
- * The return value is the actual transferred length in byte. If nothing has
- * been changed, return 0. In the case that the number of ports is less than or
- * equal to 6 (VHCI_NPORTS==7), return 1.
- *
*/
static int vhci_hub_status(struct usb_hcd *hcd, char *buf)
{
struct vhci_hcd *vhci;
unsigned long flags;
- int retval = 0;
-
- /* the enough buffer is allocated according to USB_MAXCHILDREN */
- unsigned long *event_bits = (unsigned long *) buf;
+ int retval;
int rhport;
int changed = 0;
- *event_bits = 0;
+ retval = DIV_ROUND_UP(VHCI_NPORTS + 1, 8);
+ memset(buf, 0, retval);
vhci = hcd_to_vhci(hcd);
spin_lock_irqsave(&vhci->lock, flags);
if (!HCD_HW_ACCESSIBLE(hcd)) {
- usbip_dbg_vhci_rh("hw accessible flag in on?\n");
+ usbip_dbg_vhci_rh("hw accessible flag not on?\n");
goto done;
}
for (rhport = 0; rhport < VHCI_NPORTS; rhport++) {
if ((vhci->port_status[rhport] & PORT_C_MASK)) {
/* The status of a port has been changed, */
- usbip_dbg_vhci_rh("port %d is changed\n", rhport);
+ usbip_dbg_vhci_rh("port %d status changed\n", rhport);
- *event_bits |= 1 << (rhport + 1);
+ buf[(rhport + 1) / 8] |= 1 << (rhport + 1) % 8;
changed = 1;
}
}
if (hcd->state == HC_STATE_SUSPENDED)
usb_hcd_resume_root_hub(hcd);
- if (changed)
- retval = 1 + (VHCI_NPORTS / 8);
- else
- retval = 0;
-
done:
spin_unlock_irqrestore(&vhci->lock, flags);
- return retval;
+ return changed ? retval : 0;
}
/* See hub_configure in hub.c */
#include <net/iw_handler.h>
#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
-#define SUPPORTED_WIRELESS_EXT 18
+#define SUPPORTED_WIRELESS_EXT 18
#else
-#define SUPPORTED_WIRELESS_EXT 17
+#define SUPPORTED_WIRELESS_EXT 17
#endif
static const long frequency_list[] = {
- 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
- 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
- 5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
- 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
- 5700, 5745, 5765, 5785, 5805, 5825
- };
+ 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
+ 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
+ 5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
+ 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
+ 5700, 5745, 5765, 5785, 5805, 5825
+};
-static int msglevel =MSG_LEVEL_INFO;
+static int msglevel = MSG_LEVEL_INFO;
struct iw_statistics *iwctl_get_wireless_stats(struct net_device *dev)
{
long ldBm;
pDevice->wstats.status = pDevice->eOPMode;
- if(pDevice->scStatistic.LinkQuality > 100)
- pDevice->scStatistic.LinkQuality = 100;
- pDevice->wstats.qual.qual =(BYTE) pDevice->scStatistic.LinkQuality;
+ if (pDevice->scStatistic.LinkQuality > 100)
+ pDevice->scStatistic.LinkQuality = 100;
+ pDevice->wstats.qual.qual =(BYTE)pDevice->scStatistic.LinkQuality;
RFvRSSITodBm(pDevice, (BYTE)(pDevice->uCurrRSSI), &ldBm);
pDevice->wstats.qual.level = ldBm;
pDevice->wstats.qual.noise = 0;
pDevice->wstats.discard.retries = pDevice->scStatistic.dwTsrErr;
pDevice->wstats.discard.misc = 0;
pDevice->wstats.miss.beacon = 0;
-
return &pDevice->wstats;
}
/*
- * Wireless Handler : get protocol name
+ * Wireless Handler: get protocol name
*/
-
-int iwctl_giwname(struct net_device *dev,
- struct iw_request_info *info,
- char *wrq,
- char *extra)
+int iwctl_giwname(struct net_device *dev, struct iw_request_info *info,
+ char *wrq, char *extra)
{
strcpy(wrq, "802.11-a/b/g");
return 0;
}
/*
- * Wireless Handler : set scan
+ * Wireless Handler: set scan
*/
-
-int iwctl_siwscan(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_siwscan(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- struct iw_scan_req *req = (struct iw_scan_req *)extra;
- BYTE abyScanSSID[WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1];
- PWLAN_IE_SSID pItemSSID=NULL;
-
- if (!(pDevice->flags & DEVICE_FLAGS_OPENED))
- return -EINVAL;
-
- PRINT_K(" SIOCSIWSCAN \n");
-
-if (pMgmt->eScanState == WMAC_IS_SCANNING) {
- // In scanning..
- PRINT_K("SIOCSIWSCAN(overlap??)-->In scanning...\n");
- return -EAGAIN;
- }
-
-if(pDevice->byReAssocCount > 0) { //reject scan when re-associating!
-//send scan event to wpa_Supplicant
- union iwreq_data wrqu;
- PRINT_K("wireless_send_event--->SIOCGIWSCAN(scan done)\n");
- memset(&wrqu, 0, sizeof(wrqu));
- wireless_send_event(pDevice->dev, SIOCGIWSCAN, &wrqu, NULL);
- return 0;
-}
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ struct iw_scan_req *req = (struct iw_scan_req *)extra;
+ BYTE abyScanSSID[WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1];
+ PWLAN_IE_SSID pItemSSID=NULL;
+
+ if (!(pDevice->flags & DEVICE_FLAGS_OPENED))
+ return -EINVAL;
+
+ PRINT_K(" SIOCSIWSCAN \n");
+
+ if (pMgmt->eScanState == WMAC_IS_SCANNING) {
+ // In scanning..
+ PRINT_K("SIOCSIWSCAN(overlap??)-->In scanning...\n");
+ return -EAGAIN;
+ }
+
+ if (pDevice->byReAssocCount > 0) { // reject scan when re-associating!
+ // send scan event to wpa_Supplicant
+ union iwreq_data wrqu;
+ PRINT_K("wireless_send_event--->SIOCGIWSCAN(scan done)\n");
+ memset(&wrqu, 0, sizeof(wrqu));
+ wireless_send_event(pDevice->dev, SIOCGIWSCAN, &wrqu, NULL);
+ return 0;
+ }
spin_lock_irq(&pDevice->lock);
- BSSvClearBSSList((void *) pDevice, pDevice->bLinkPass);
-
-//mike add: active scan OR passive scan OR desire_ssid scan
- if(wrq->length == sizeof(struct iw_scan_req)) {
- if (wrq->flags & IW_SCAN_THIS_ESSID) { //desire_ssid scan
- memset(abyScanSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
- pItemSSID = (PWLAN_IE_SSID)abyScanSSID;
- pItemSSID->byElementID = WLAN_EID_SSID;
- memcpy(pItemSSID->abySSID, req->essid, (int)req->essid_len);
- if (pItemSSID->abySSID[req->essid_len - 1] == '\0') {
- if(req->essid_len>0)
- pItemSSID->len = req->essid_len - 1;
- }
- else
- pItemSSID->len = req->essid_len;
- pMgmt->eScanType = WMAC_SCAN_PASSIVE;
- PRINT_K("SIOCSIWSCAN:[desired_ssid=%s,len=%d]\n",((PWLAN_IE_SSID)abyScanSSID)->abySSID,
- ((PWLAN_IE_SSID)abyScanSSID)->len);
- bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, abyScanSSID);
- spin_unlock_irq(&pDevice->lock);
+ BSSvClearBSSList((void *)pDevice, pDevice->bLinkPass);
+
+ // mike add: active scan OR passive scan OR desire_ssid scan
+ if (wrq->length == sizeof(struct iw_scan_req)) {
+ if (wrq->flags & IW_SCAN_THIS_ESSID) { // desire_ssid scan
+ memset(abyScanSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
+ pItemSSID = (PWLAN_IE_SSID)abyScanSSID;
+ pItemSSID->byElementID = WLAN_EID_SSID;
+ memcpy(pItemSSID->abySSID, req->essid, (int)req->essid_len);
+ if (pItemSSID->abySSID[req->essid_len - 1] == '\0') {
+ if (req->essid_len > 0)
+ pItemSSID->len = req->essid_len - 1;
+ }
+ else
+ pItemSSID->len = req->essid_len;
+ pMgmt->eScanType = WMAC_SCAN_PASSIVE;
+ PRINT_K("SIOCSIWSCAN:[desired_ssid=%s,len=%d]\n", ((PWLAN_IE_SSID)abyScanSSID)->abySSID,
+ ((PWLAN_IE_SSID)abyScanSSID)->len);
+ bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, abyScanSSID);
+ spin_unlock_irq(&pDevice->lock);
+
+ return 0;
+ } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) { // passive scan
+ pMgmt->eScanType = WMAC_SCAN_PASSIVE;
+ }
+ } else { // active scan
+ pMgmt->eScanType = WMAC_SCAN_ACTIVE;
+ }
- return 0;
- }
- else if(req->scan_type == IW_SCAN_TYPE_PASSIVE) { //passive scan
- pMgmt->eScanType = WMAC_SCAN_PASSIVE;
- }
- }
- else { //active scan
- pMgmt->eScanType = WMAC_SCAN_ACTIVE;
- }
-
- pMgmt->eScanType = WMAC_SCAN_PASSIVE;
- bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
+ pMgmt->eScanType = WMAC_SCAN_PASSIVE;
+ bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
spin_unlock_irq(&pDevice->lock);
return 0;
/*
* Wireless Handler : get scan results
*/
-
-int iwctl_giwscan(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_giwscan(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- int ii, jj, kk;
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- PKnownBSS pBSS;
- PWLAN_IE_SSID pItemSSID;
- PWLAN_IE_SUPP_RATES pSuppRates, pExtSuppRates;
+ int ii;
+ int jj;
+ int kk;
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ PKnownBSS pBSS;
+ PWLAN_IE_SSID pItemSSID;
+ PWLAN_IE_SUPP_RATES pSuppRates;
+ PWLAN_IE_SUPP_RATES pExtSuppRates;
char *current_ev = extra;
char *end_buf = extra + IW_SCAN_MAX_DATA;
char *current_val = NULL;
long ldBm;
char buf[MAX_WPA_IE_LEN * 2 + 30];
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSCAN\n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSCAN\n");
- if (pMgmt->eScanState == WMAC_IS_SCANNING) {
- // In scanning..
+ if (pMgmt->eScanState == WMAC_IS_SCANNING) {
+ // In scanning..
return -EAGAIN;
}
pBSS = &(pMgmt->sBSSList[0]);
- for (ii = 0, jj = 0; jj < MAX_BSS_NUM ; jj++) {
+ for (ii = 0, jj = 0; jj < MAX_BSS_NUM ; jj++) {
if (current_ev >= end_buf)
break;
- pBSS = &(pMgmt->sBSSList[jj]);
- if (pBSS->bActive) {
- //ADD mac address
- memset(&iwe, 0, sizeof(iwe));
- iwe.cmd = SIOCGIWAP;
- iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
+ pBSS = &(pMgmt->sBSSList[jj]);
+ if (pBSS->bActive) {
+ // ADD mac address
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = SIOCGIWAP;
+ iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
memcpy(iwe.u.ap_addr.sa_data, pBSS->abyBSSID, WLAN_BSSID_LEN);
- current_ev = iwe_stream_add_event(info,current_ev,end_buf, &iwe, IW_EV_ADDR_LEN);
- //ADD ssid
- memset(&iwe, 0, sizeof(iwe));
- iwe.cmd = SIOCGIWESSID;
- pItemSSID = (PWLAN_IE_SSID)pBSS->abySSID;
- iwe.u.data.length = pItemSSID->len;
- iwe.u.data.flags = 1;
- current_ev = iwe_stream_add_point(info,current_ev,end_buf, &iwe, pItemSSID->abySSID);
- //ADD mode
- memset(&iwe, 0, sizeof(iwe));
- iwe.cmd = SIOCGIWMODE;
- if (WLAN_GET_CAP_INFO_ESS(pBSS->wCapInfo)) {
- iwe.u.mode = IW_MODE_INFRA;
- }
- else {
- iwe.u.mode = IW_MODE_ADHOC;
- }
- iwe.len = IW_EV_UINT_LEN;
- current_ev = iwe_stream_add_event(info,current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
- //ADD frequency
- pSuppRates = (PWLAN_IE_SUPP_RATES)pBSS->abySuppRates;
- pExtSuppRates = (PWLAN_IE_SUPP_RATES)pBSS->abyExtSuppRates;
- memset(&iwe, 0, sizeof(iwe));
- iwe.cmd = SIOCGIWFREQ;
- iwe.u.freq.m = pBSS->uChannel;
- iwe.u.freq.e = 0;
- iwe.u.freq.i = 0;
- current_ev = iwe_stream_add_event(info,current_ev,end_buf, &iwe, IW_EV_FREQ_LEN);
+ current_ev = iwe_stream_add_event(info,current_ev,end_buf, &iwe, IW_EV_ADDR_LEN);
+ // ADD ssid
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = SIOCGIWESSID;
+ pItemSSID = (PWLAN_IE_SSID)pBSS->abySSID;
+ iwe.u.data.length = pItemSSID->len;
+ iwe.u.data.flags = 1;
+ current_ev = iwe_stream_add_point(info, current_ev, end_buf, &iwe, pItemSSID->abySSID);
+ // ADD mode
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = SIOCGIWMODE;
+ if (WLAN_GET_CAP_INFO_ESS(pBSS->wCapInfo))
+ iwe.u.mode = IW_MODE_INFRA;
+ else
+ iwe.u.mode = IW_MODE_ADHOC;
+ iwe.len = IW_EV_UINT_LEN;
+ current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
+ // ADD frequency
+ pSuppRates = (PWLAN_IE_SUPP_RATES)pBSS->abySuppRates;
+ pExtSuppRates = (PWLAN_IE_SUPP_RATES)pBSS->abyExtSuppRates;
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = SIOCGIWFREQ;
+ iwe.u.freq.m = pBSS->uChannel;
+ iwe.u.freq.e = 0;
+ iwe.u.freq.i = 0;
+ current_ev = iwe_stream_add_event(info, current_ev,end_buf, &iwe, IW_EV_FREQ_LEN);
{
- int f = (int)pBSS->uChannel - 1;
- if(f < 0)f = 0;
- iwe.u.freq.m = frequency_list[f] * 100000;
- iwe.u.freq.e = 1;
+ int f = (int)pBSS->uChannel - 1;
+ if (f < 0)
+ f = 0;
+ iwe.u.freq.m = frequency_list[f] * 100000;
+ iwe.u.freq.e = 1;
}
- current_ev = iwe_stream_add_event(info,current_ev,end_buf, &iwe, IW_EV_FREQ_LEN);
- //ADD quality
- memset(&iwe, 0, sizeof(iwe));
- iwe.cmd = IWEVQUAL;
- RFvRSSITodBm(pDevice, (BYTE)(pBSS->uRSSI), &ldBm);
- iwe.u.qual.level = ldBm;
- iwe.u.qual.noise = 0;
-
- if(-ldBm<50){
+ current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
+ // ADD quality
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = IWEVQUAL;
+ RFvRSSITodBm(pDevice, (BYTE)(pBSS->uRSSI), &ldBm);
+ iwe.u.qual.level = ldBm;
+ iwe.u.qual.noise = 0;
+
+ if (-ldBm<50)
iwe.u.qual.qual = 100;
- }else if(-ldBm > 90) {
- iwe.u.qual.qual = 0;
- }else {
- iwe.u.qual.qual=(40-(-ldBm-50))*100/40;
+ else if (-ldBm > 90)
+ iwe.u.qual.qual = 0;
+ else
+ iwe.u.qual.qual = (40 - (-ldBm - 50)) * 100 / 40;
+ iwe.u.qual.updated = 7;
+
+ current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
+ // ADD encryption
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = SIOCGIWENCODE;
+ iwe.u.data.length = 0;
+ if (WLAN_GET_CAP_INFO_PRIVACY(pBSS->wCapInfo))
+ iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
+ else
+ iwe.u.data.flags = IW_ENCODE_DISABLED;
+ current_ev = iwe_stream_add_point(info, current_ev, end_buf, &iwe, pItemSSID->abySSID);
+
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = SIOCGIWRATE;
+ iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
+ current_val = current_ev + IW_EV_LCP_LEN;
+
+ for (kk = 0; kk < 12; kk++) {
+ if (pSuppRates->abyRates[kk] == 0)
+ break;
+ // Bit rate given in 500 kb/s units (+ 0x80)
+ iwe.u.bitrate.value = ((pSuppRates->abyRates[kk] & 0x7f) * 500000);
+ current_val = iwe_stream_add_value(info, current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
+ }
+ for (kk = 0; kk < 8; kk++) {
+ if (pExtSuppRates->abyRates[kk] == 0)
+ break;
+ // Bit rate given in 500 kb/s units (+ 0x80)
+ iwe.u.bitrate.value = ((pExtSuppRates->abyRates[kk] & 0x7f) * 500000);
+ current_val = iwe_stream_add_value(info, current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
}
- iwe.u.qual.updated=7;
-
- current_ev = iwe_stream_add_event(info,current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
- //ADD encryption
- memset(&iwe, 0, sizeof(iwe));
- iwe.cmd = SIOCGIWENCODE;
- iwe.u.data.length = 0;
- if (WLAN_GET_CAP_INFO_PRIVACY(pBSS->wCapInfo)) {
- iwe.u.data.flags =IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
- }else {
- iwe.u.data.flags = IW_ENCODE_DISABLED;
- }
- current_ev = iwe_stream_add_point(info,current_ev,end_buf, &iwe, pItemSSID->abySSID);
-
- memset(&iwe, 0, sizeof(iwe));
- iwe.cmd = SIOCGIWRATE;
- iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
- current_val = current_ev + IW_EV_LCP_LEN;
-
- for (kk = 0 ; kk < 12 ; kk++) {
- if (pSuppRates->abyRates[kk] == 0)
- break;
- // Bit rate given in 500 kb/s units (+ 0x80)
- iwe.u.bitrate.value = ((pSuppRates->abyRates[kk] & 0x7f) * 500000);
- current_val = iwe_stream_add_value(info,current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
- }
- for (kk = 0 ; kk < 8 ; kk++) {
- if (pExtSuppRates->abyRates[kk] == 0)
- break;
- // Bit rate given in 500 kb/s units (+ 0x80)
- iwe.u.bitrate.value = ((pExtSuppRates->abyRates[kk] & 0x7f) * 500000);
- current_val = iwe_stream_add_value(info,current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
- }
-
- if((current_val - current_ev) > IW_EV_LCP_LEN)
- current_ev = current_val;
-
- memset(&iwe, 0, sizeof(iwe));
- iwe.cmd = IWEVCUSTOM;
- sprintf(buf, "bcn_int=%d", pBSS->wBeaconInterval);
- iwe.u.data.length = strlen(buf);
- current_ev = iwe_stream_add_point(info,current_ev, end_buf, &iwe, buf);
-
- if ((pBSS->wWPALen > 0) && (pBSS->wWPALen <= MAX_WPA_IE_LEN)) {
- memset(&iwe, 0, sizeof(iwe));
- iwe.cmd = IWEVGENIE;
- iwe.u.data.length = pBSS->wWPALen;
- current_ev = iwe_stream_add_point(info,current_ev, end_buf, &iwe, pBSS->byWPAIE);
- }
-
- if ((pBSS->wRSNLen > 0) && (pBSS->wRSNLen <= MAX_WPA_IE_LEN)) {
- memset(&iwe, 0, sizeof(iwe));
- iwe.cmd = IWEVGENIE;
- iwe.u.data.length = pBSS->wRSNLen;
- current_ev = iwe_stream_add_point(info,current_ev, end_buf, &iwe, pBSS->byRSNIE);
- }
-
- }
- }// for
+ if ((current_val - current_ev) > IW_EV_LCP_LEN)
+ current_ev = current_val;
+
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = IWEVCUSTOM;
+ sprintf(buf, "bcn_int=%d", pBSS->wBeaconInterval);
+ iwe.u.data.length = strlen(buf);
+ current_ev = iwe_stream_add_point(info, current_ev, end_buf, &iwe, buf);
+
+ if ((pBSS->wWPALen > 0) && (pBSS->wWPALen <= MAX_WPA_IE_LEN)) {
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = IWEVGENIE;
+ iwe.u.data.length = pBSS->wWPALen;
+ current_ev = iwe_stream_add_point(info, current_ev, end_buf, &iwe, pBSS->byWPAIE);
+ }
+
+ if ((pBSS->wRSNLen > 0) && (pBSS->wRSNLen <= MAX_WPA_IE_LEN)) {
+ memset(&iwe, 0, sizeof(iwe));
+ iwe.cmd = IWEVGENIE;
+ iwe.u.data.length = pBSS->wRSNLen;
+ current_ev = iwe_stream_add_point(info, current_ev, end_buf, &iwe, pBSS->byRSNIE);
+ }
+ }
+ } // for
wrq->length = current_ev - extra;
return 0;
-
}
-
/*
- * Wireless Handler : set frequence or channel
+ * Wireless Handler: set frequence or channel
*/
-
-int iwctl_siwfreq(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_freq *wrq,
- char *extra)
+int iwctl_siwfreq(struct net_device *dev, struct iw_request_info *info,
+ struct iw_freq *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
+ PSDevice pDevice = netdev_priv(dev);
int rc = 0;
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWFREQ \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWFREQ \n");
// If setting by frequency, convert to a channel
- if((wrq->e == 1) &&
- (wrq->m >= (int) 2.412e8) &&
- (wrq->m <= (int) 2.487e8)) {
+ if ((wrq->e == 1) && (wrq->m >= (int)2.412e8) &&
+ (wrq->m <= (int)2.487e8)) {
int f = wrq->m / 100000;
int c = 0;
- while((c < 14) && (f != frequency_list[c]))
+ while ((c < 14) && (f != frequency_list[c]))
c++;
wrq->e = 0;
wrq->m = c + 1;
}
// Setting by channel number
- if((wrq->m > 14) || (wrq->e > 0))
+ if ((wrq->m > 14) || (wrq->e > 0)) {
rc = -EOPNOTSUPP;
- else {
+ } else {
int channel = wrq->m;
- if((channel < 1) || (channel > 14)) {
+ if ((channel < 1) || (channel > 14)) {
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: New channel value of %d is invalid!\n", dev->name, wrq->m);
rc = -EINVAL;
} else {
- // Yes ! We can set it !!!
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Set to channel = %d\n", channel);
- pDevice->uChannel = channel;
+ // Yes ! We can set it !!!
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Set to channel = %d\n", channel);
+ pDevice->uChannel = channel;
}
}
-
return rc;
}
/*
- * Wireless Handler : get frequence or channel
+ * Wireless Handler: get frequence or channel
*/
-
-int iwctl_giwfreq(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_freq *wrq,
- char *extra)
+int iwctl_giwfreq(struct net_device *dev, struct iw_request_info *info,
+ struct iw_freq *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWFREQ \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWFREQ \n");
#ifdef WEXT_USECHANNELS
wrq->m = (int)pMgmt->uCurrChannel;
#else
{
int f = (int)pMgmt->uCurrChannel - 1;
- if(f < 0)
- f = 0;
+ if (f < 0)
+ f = 0;
wrq->m = frequency_list[f] * 100000;
wrq->e = 1;
}
#endif
-
return 0;
}
/*
- * Wireless Handler : set operation mode
+ * Wireless Handler: set operation mode
*/
-
-int iwctl_siwmode(struct net_device *dev,
- struct iw_request_info *info,
- __u32 *wmode,
- char *extra)
+int iwctl_siwmode(struct net_device *dev, struct iw_request_info *info,
+ __u32 *wmode, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- int rc = 0;
-
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMODE \n");
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ int rc = 0;
- if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP && pDevice->bEnableHostapd) {
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Can't set operation mode, hostapd is running \n");
- return rc;
- }
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMODE \n");
- switch(*wmode) {
+ if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP && pDevice->bEnableHostapd) {
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Can't set operation mode, hostapd is running \n");
+ return rc;
+ }
+ switch (*wmode) {
case IW_MODE_ADHOC:
- if (pMgmt->eConfigMode != WMAC_CONFIG_IBSS_STA) {
- pMgmt->eConfigMode = WMAC_CONFIG_IBSS_STA;
- if (pDevice->flags & DEVICE_FLAGS_OPENED) {
- pDevice->bCommit = TRUE;
- }
+ if (pMgmt->eConfigMode != WMAC_CONFIG_IBSS_STA) {
+ pMgmt->eConfigMode = WMAC_CONFIG_IBSS_STA;
+ if (pDevice->flags & DEVICE_FLAGS_OPENED)
+ pDevice->bCommit = TRUE;
}
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to ad-hoc \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to ad-hoc \n");
break;
case IW_MODE_AUTO:
case IW_MODE_INFRA:
- if (pMgmt->eConfigMode != WMAC_CONFIG_ESS_STA) {
- pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
- if (pDevice->flags & DEVICE_FLAGS_OPENED) {
- pDevice->bCommit = TRUE;
- }
+ if (pMgmt->eConfigMode != WMAC_CONFIG_ESS_STA) {
+ pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
+ if (pDevice->flags & DEVICE_FLAGS_OPENED)
+ pDevice->bCommit = TRUE;
}
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to infrastructure \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to infrastructure \n");
break;
case IW_MODE_MASTER:
- pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
+ pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
rc = -EOPNOTSUPP;
break;
- if (pMgmt->eConfigMode != WMAC_CONFIG_AP) {
- pMgmt->eConfigMode = WMAC_CONFIG_AP;
- if (pDevice->flags & DEVICE_FLAGS_OPENED) {
- pDevice->bCommit = TRUE;
- }
+ if (pMgmt->eConfigMode != WMAC_CONFIG_AP) {
+ pMgmt->eConfigMode = WMAC_CONFIG_AP;
+ if (pDevice->flags & DEVICE_FLAGS_OPENED)
+ pDevice->bCommit = TRUE;
}
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to Access Point \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to Access Point \n");
break;
case IW_MODE_REPEAT:
- pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
+ pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
rc = -EOPNOTSUPP;
break;
default:
}
/*
- * Wireless Handler : get operation mode
+ * Wireless Handler: get operation mode
*/
-
-void iwctl_giwmode(struct net_device *dev,
- struct iw_request_info *info,
- __u32 *wmode,
- char *extra)
+void iwctl_giwmode(struct net_device *dev, struct iw_request_info *info,
+ __u32 *wmode, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
-
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWMODE \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWMODE \n");
// If not managed, assume it's ad-hoc
switch (pMgmt->eConfigMode) {
case WMAC_CONFIG_ESS_STA:
*wmode = IW_MODE_INFRA;
break;
case WMAC_CONFIG_IBSS_STA:
- *wmode = IW_MODE_ADHOC;
+ *wmode = IW_MODE_ADHOC;
break;
case WMAC_CONFIG_AUTO:
*wmode = IW_MODE_INFRA;
}
}
-
/*
- * Wireless Handler : get capability range
+ * Wireless Handler: get capability range
*/
-
-void iwctl_giwrange(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+void iwctl_giwrange(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- struct iw_range *range = (struct iw_range *) extra;
- int i,k;
- BYTE abySupportedRates[13]= {0x02, 0x04, 0x0B, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x90};
+ struct iw_range *range = (struct iw_range *)extra;
+ int i;
+ int k;
+ BYTE abySupportedRates[13] = {
+ 0x02, 0x04, 0x0B, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48,
+ 0x60, 0x6C, 0x90
+ };
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWRANGE\n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWRANGE\n");
if (wrq->pointer) {
wrq->length = sizeof(struct iw_range);
memset(range, 0, sizeof(struct iw_range));
range->max_nwid = 0x0000;
range->num_channels = 14;
// Should be based on cap_rid.country to give only
- // what the current card support
+ // what the current card support
k = 0;
for (i = 0; i < 14; i++) {
range->freq[k].i = i + 1; // List index
}
range->num_frequency = k;
// Hum... Should put the right values there
- range->max_qual.qual = 100;
+ range->max_qual.qual = 100;
range->max_qual.level = 0;
range->max_qual.noise = 0;
range->sensitivity = 255;
- for (i = 0 ; i < 13 ; i++) {
+ for (i = 0; i < 13; i++) {
range->bitrate[i] = abySupportedRates[i] * 500000;
- if(range->bitrate[i] == 0)
+ if (range->bitrate[i] == 0)
break;
}
range->num_bitrates = i;
// Set an indication of the max TCP throughput
// in bit/s that we can expect using this interface.
// May be use for QoS stuff... Jean II
- if(i > 2)
+ if (i > 2)
range->throughput = 5 * 1000 * 1000;
else
range->throughput = 1.5 * 1000 * 1000;
range->min_frag = 256;
range->max_frag = 2312;
+ // the encoding capabilities
+ range->num_encoding_sizes = 3;
+ // 64(40) bits WEP
+ range->encoding_size[0] = 5;
+ // 128(104) bits WEP
+ range->encoding_size[1] = 13;
+ // 256 bits for WPA-PSK
+ range->encoding_size[2] = 32;
+ // 4 keys are allowed
+ range->max_encoding_tokens = 4;
- // the encoding capabilities
- range->num_encoding_sizes = 3;
- // 64(40) bits WEP
- range->encoding_size[0] = 5;
- // 128(104) bits WEP
- range->encoding_size[1] = 13;
- // 256 bits for WPA-PSK
- range->encoding_size[2] = 32;
- // 4 keys are allowed
- range->max_encoding_tokens = 4;
-
- range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
- IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
+ range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
+ IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
range->min_pmp = 0;
- range->max_pmp = 1000000;// 1 secs
+ range->max_pmp = 1000000; // 1 secs
range->min_pmt = 0;
- range->max_pmt = 1000000;// 1 secs
+ range->max_pmt = 1000000; // 1 secs
range->pmp_flags = IW_POWER_PERIOD;
range->pmt_flags = IW_POWER_TIMEOUT;
range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
// Transmit Power - values are in mW
-
- range->txpower[0] = 100;
+ range->txpower[0] = 100;
range->num_txpower = 1;
range->txpower_capa = IW_TXPOW_MWATT;
range->we_version_source = SUPPORTED_WIRELESS_EXT;
// Note : with or without the (local->rssi), results
// are somewhat different. - Jean II
range->avg_qual.qual = 6;
- range->avg_qual.level = 176; // -80 dBm
+ range->avg_qual.level = 176; // -80 dBm
range->avg_qual.noise = 0;
}
}
-
/*
* Wireless Handler : set ap mac address
*/
-
-int iwctl_siwap(struct net_device *dev,
- struct iw_request_info *info,
- struct sockaddr *wrq,
- char *extra)
+int iwctl_siwap(struct net_device *dev, struct iw_request_info *info,
+ struct sockaddr *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- int rc = 0;
- BYTE ZeroBSSID[WLAN_BSSID_LEN]={0x00,0x00,0x00,0x00,0x00,0x00};
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ int rc = 0;
+ BYTE ZeroBSSID[WLAN_BSSID_LEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
- PRINT_K(" SIOCSIWAP \n");
+ PRINT_K(" SIOCSIWAP \n");
if (wrq->sa_family != ARPHRD_ETHER)
rc = -EINVAL;
else {
memcpy(pMgmt->abyDesireBSSID, wrq->sa_data, 6);
+ // mike: add
+ if ((is_broadcast_ether_addr(pMgmt->abyDesireBSSID)) ||
+ (memcmp(pMgmt->abyDesireBSSID, ZeroBSSID, 6) == 0)) {
+ PRINT_K("SIOCSIWAP:invalid desired BSSID return!\n");
+ return rc;
+ }
+ // mike add: if desired AP is hidden ssid(there are
+ // two same BSSID in list), then ignore,because you
+ // don't known which one to be connect with??
+ {
+ unsigned ii;
+ unsigned uSameBssidNum = 0;
+ for (ii = 0; ii < MAX_BSS_NUM; ii++) {
+ if (pMgmt->sBSSList[ii].bActive &&
+ !compare_ether_addr(pMgmt->sBSSList[ii].abyBSSID,
+ pMgmt->abyDesireBSSID)) {
+ uSameBssidNum++;
+ }
+ }
+ if (uSameBssidNum >= 2) { //hit: desired AP is in hidden ssid mode!!!
+ PRINT_K("SIOCSIWAP:ignore for desired AP in hidden mode\n");
+ return rc;
+ }
+ }
- //mike :add
- if ((is_broadcast_ether_addr(pMgmt->abyDesireBSSID)) ||
- (memcmp(pMgmt->abyDesireBSSID, ZeroBSSID, 6) == 0)){
- PRINT_K("SIOCSIWAP:invalid desired BSSID return!\n");
- return rc;
- }
- //mike add: if desired AP is hidden ssid(there are two same BSSID in list),
- // then ignore,because you don't known which one to be connect with??
- {
- unsigned int ii, uSameBssidNum = 0;
- for (ii = 0; ii < MAX_BSS_NUM; ii++) {
- if (pMgmt->sBSSList[ii].bActive &&
- !compare_ether_addr(pMgmt->sBSSList[ii].abyBSSID,
- pMgmt->abyDesireBSSID)) {
- uSameBssidNum++;
- }
- }
- if(uSameBssidNum >= 2) { //hit: desired AP is in hidden ssid mode!!!
- PRINT_K("SIOCSIWAP:ignore for desired AP in hidden mode\n");
- return rc;
- }
- }
-
- if (pDevice->flags & DEVICE_FLAGS_OPENED) {
- pDevice->bCommit = TRUE;
- }
+ if (pDevice->flags & DEVICE_FLAGS_OPENED)
+ pDevice->bCommit = TRUE;
}
return rc;
}
/*
- * Wireless Handler : get ap mac address
+ * Wireless Handler: get ap mac address
*/
-
-int iwctl_giwap(struct net_device *dev,
- struct iw_request_info *info,
- struct sockaddr *wrq,
- char *extra)
+int iwctl_giwap(struct net_device *dev, struct iw_request_info *info,
+ struct sockaddr *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
-
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAP \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAP \n");
- memcpy(wrq->sa_data, pMgmt->abyCurrBSSID, 6);
+ memcpy(wrq->sa_data, pMgmt->abyCurrBSSID, 6);
- if ((pDevice->bLinkPass == FALSE) && (pMgmt->eCurrMode != WMAC_MODE_ESS_AP))
- memset(wrq->sa_data, 0, 6);
+ if ((pDevice->bLinkPass == FALSE) && (pMgmt->eCurrMode != WMAC_MODE_ESS_AP))
+ memset(wrq->sa_data, 0, 6);
- if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
- memcpy(wrq->sa_data, pMgmt->abyCurrBSSID, 6);
- }
+ if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP)
+ memcpy(wrq->sa_data, pMgmt->abyCurrBSSID, 6);
wrq->sa_family = ARPHRD_ETHER;
-
return 0;
-
}
-
/*
- * Wireless Handler : get ap list
+ * Wireless Handler: get ap list
*/
-
-int iwctl_giwaplist(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_giwaplist(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- int ii,jj, rc = 0;
+ int ii;
+ int jj;
+ int rc = 0;
struct sockaddr sock[IW_MAX_AP];
struct iw_quality qual[IW_MAX_AP];
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
-
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAPLIST \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAPLIST \n");
// Only super-user can see AP list
if (!capable(CAP_NET_ADMIN)) {
}
if (wrq->pointer) {
-
PKnownBSS pBSS = &(pMgmt->sBSSList[0]);
for (ii = 0, jj= 0; ii < MAX_BSS_NUM; ii++) {
- pBSS = &(pMgmt->sBSSList[ii]);
- if (!pBSS->bActive)
- continue;
- if ( jj >= IW_MAX_AP)
- break;
+ pBSS = &(pMgmt->sBSSList[ii]);
+ if (!pBSS->bActive)
+ continue;
+ if (jj >= IW_MAX_AP)
+ break;
memcpy(sock[jj].sa_data, pBSS->abyBSSID, 6);
sock[jj].sa_family = ARPHRD_ETHER;
qual[jj].level = pBSS->uRSSI;
wrq->flags = 1; // Should be define'd
wrq->length = jj;
- memcpy(extra, sock, sizeof(struct sockaddr)*jj);
- memcpy(extra + sizeof(struct sockaddr)*jj, qual, sizeof(struct iw_quality)*jj);
+ memcpy(extra, sock, sizeof(struct sockaddr) * jj);
+ memcpy(extra + sizeof(struct sockaddr) * jj, qual, sizeof(struct iw_quality) * jj);
}
-
return rc;
}
-
/*
- * Wireless Handler : set essid
+ * Wireless Handler: set essid
*/
-
-int iwctl_siwessid(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_siwessid(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- PWLAN_IE_SSID pItemSSID;
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ PWLAN_IE_SSID pItemSSID;
- if (!(pDevice->flags & DEVICE_FLAGS_OPENED))
- return -EINVAL;
+ if (!(pDevice->flags & DEVICE_FLAGS_OPENED))
+ return -EINVAL;
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWESSID :\n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWESSID :\n");
- pDevice->fWPA_Authened = FALSE;
+ pDevice->fWPA_Authened = FALSE;
// Check if we asked for `any'
- if(wrq->flags == 0) {
+ if (wrq->flags == 0) {
// Just send an empty SSID list
memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
- memset(pMgmt->abyDesireBSSID, 0xFF,6);
- PRINT_K("set essid to 'any' \n");
- #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
- //Unknown desired AP,so here need not associate??
- return 0;
- #endif
+ memset(pMgmt->abyDesireBSSID, 0xFF,6);
+ PRINT_K("set essid to 'any' \n");
+#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
+ // Unknown desired AP, so here need not associate??
+ return 0;
+#endif
} else {
// Set the SSID
memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
- pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
- pItemSSID->byElementID = WLAN_EID_SSID;
+ pItemSSID = (PWLAN_IE_SSID)pMgmt->abyDesireSSID;
+ pItemSSID->byElementID = WLAN_EID_SSID;
memcpy(pItemSSID->abySSID, extra, wrq->length);
- if (pItemSSID->abySSID[wrq->length - 1] == '\0') {
- if(wrq->length>0)
- pItemSSID->len = wrq->length - 1;
- }
- else
- pItemSSID->len = wrq->length;
- PRINT_K("set essid to %s \n",pItemSSID->abySSID);
+ if (pItemSSID->abySSID[wrq->length - 1] == '\0') {
+ if (wrq->length>0)
+ pItemSSID->len = wrq->length - 1;
+ } else {
+ pItemSSID->len = wrq->length;
+ }
+ PRINT_K("set essid to %s \n", pItemSSID->abySSID);
- //mike:need clear desiredBSSID
- if(pItemSSID->len==0) {
- memset(pMgmt->abyDesireBSSID, 0xFF,6);
- return 0;
- }
+ // mike: need clear desiredBSSID
+ if (pItemSSID->len==0) {
+ memset(pMgmt->abyDesireBSSID, 0xFF, 6);
+ return 0;
+ }
#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
- //Wext wil order another command of siwap to link with desired AP,
- //so here need not associate??
- if(pDevice->bWPASuppWextEnabled == TRUE) {
- /*******search if in hidden ssid mode ****/
- {
- PKnownBSS pCurr = NULL;
- BYTE abyTmpDesireSSID[WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1];
- unsigned int ii, uSameBssidNum = 0;
-
- memcpy(abyTmpDesireSSID,pMgmt->abyDesireSSID,sizeof(abyTmpDesireSSID));
- pCurr = BSSpSearchBSSList(pDevice,
- NULL,
- abyTmpDesireSSID,
- pDevice->eConfigPHYMode
- );
-
- if (pCurr == NULL){
- PRINT_K("SIOCSIWESSID:hidden ssid site survey before associate.......\n");
- vResetCommandTimer((void *) pDevice);
- pMgmt->eScanType = WMAC_SCAN_ACTIVE;
- bScheduleCommand((void *) pDevice,
- WLAN_CMD_BSSID_SCAN,
- pMgmt->abyDesireSSID);
- bScheduleCommand((void *) pDevice,
- WLAN_CMD_SSID,
- pMgmt->abyDesireSSID);
- }
- else { //mike:to find out if that desired SSID is a hidden-ssid AP ,
- // by means of judging if there are two same BSSID exist in list ?
- for (ii = 0; ii < MAX_BSS_NUM; ii++) {
- if (pMgmt->sBSSList[ii].bActive &&
- !compare_ether_addr(pMgmt->sBSSList[ii].abyBSSID,
- pCurr->abyBSSID)) {
- uSameBssidNum++;
- }
- }
- if(uSameBssidNum >= 2) { //hit: desired AP is in hidden ssid mode!!!
- PRINT_K("SIOCSIWESSID:hidden ssid directly associate.......\n");
- vResetCommandTimer((void *) pDevice);
- pMgmt->eScanType = WMAC_SCAN_PASSIVE; //this scan type,you'll submit scan result!
- bScheduleCommand((void *) pDevice,
- WLAN_CMD_BSSID_SCAN,
- pMgmt->abyDesireSSID);
- bScheduleCommand((void *) pDevice,
- WLAN_CMD_SSID,
- pMgmt->abyDesireSSID);
- }
- }
- }
- return 0;
- }
- #endif
-
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set essid = %s \n", pItemSSID->abySSID);
- }
+ // Wext wil order another command of siwap to link
+ // with desired AP, so here need not associate??
+ if (pDevice->bWPASuppWextEnabled == TRUE) {
+ /*******search if in hidden ssid mode ****/
+ PKnownBSS pCurr = NULL;
+ BYTE abyTmpDesireSSID[WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1];
+ unsigned ii;
+ unsigned uSameBssidNum = 0;
+
+ memcpy(abyTmpDesireSSID, pMgmt->abyDesireSSID, sizeof(abyTmpDesireSSID));
+ pCurr = BSSpSearchBSSList(pDevice, NULL,
+ abyTmpDesireSSID,
+ pDevice->eConfigPHYMode);
+
+ if (pCurr == NULL) {
+ PRINT_K("SIOCSIWESSID:hidden ssid site survey before associate.......\n");
+ vResetCommandTimer((void *)pDevice);
+ pMgmt->eScanType = WMAC_SCAN_ACTIVE;
+ bScheduleCommand((void *)pDevice,
+ WLAN_CMD_BSSID_SCAN,
+ pMgmt->abyDesireSSID);
+ bScheduleCommand((void *)pDevice,
+ WLAN_CMD_SSID,
+ pMgmt->abyDesireSSID);
+ } else { // mike: to find out if that desired SSID is a
+ // hidden-ssid AP, by means of judging if there
+ // are two same BSSID exist in list ?
+ for (ii = 0; ii < MAX_BSS_NUM; ii++) {
+ if (pMgmt->sBSSList[ii].bActive &&
+ !compare_ether_addr(pMgmt->sBSSList[ii].abyBSSID,
+ pCurr->abyBSSID)) {
+ uSameBssidNum++;
+ }
+ }
+ if (uSameBssidNum >= 2) { // hit: desired AP is in hidden ssid mode!!!
+ PRINT_K("SIOCSIWESSID:hidden ssid directly associate.......\n");
+ vResetCommandTimer((void *)pDevice);
+ pMgmt->eScanType = WMAC_SCAN_PASSIVE; // this scan type, you'll submit scan result!
+ bScheduleCommand((void *)pDevice,
+ WLAN_CMD_BSSID_SCAN,
+ pMgmt->abyDesireSSID);
+ bScheduleCommand((void *)pDevice,
+ WLAN_CMD_SSID,
+ pMgmt->abyDesireSSID);
+ }
+ }
+ return 0;
+ }
+#endif
- if (pDevice->flags & DEVICE_FLAGS_OPENED) {
- pDevice->bCommit = TRUE;
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set essid = %s \n", pItemSSID->abySSID);
}
+ if (pDevice->flags & DEVICE_FLAGS_OPENED)
+ pDevice->bCommit = TRUE;
return 0;
}
-
/*
- * Wireless Handler : get essid
+ * Wireless Handler: get essid
*/
-void iwctl_giwessid(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+void iwctl_giwessid(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ PWLAN_IE_SSID pItemSSID;
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- PWLAN_IE_SSID pItemSSID;
-
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWESSID \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWESSID \n");
- // Note : if wrq->u.data.flags != 0, we should
- // get the relevant SSID from the SSID list...
+ // Note: if wrq->u.data.flags != 0, we should get the relevant
+ // SSID from the SSID list...
// Get the current SSID
- pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
- memcpy(extra, pItemSSID->abySSID , pItemSSID->len);
+ pItemSSID = (PWLAN_IE_SSID)pMgmt->abyCurrSSID;
+ memcpy(extra, pItemSSID->abySSID, pItemSSID->len);
extra[pItemSSID->len] = '\0';
wrq->length = pItemSSID->len;
}
/*
- * Wireless Handler : set data rate
+ * Wireless Handler: set data rate
*/
-
-int iwctl_siwrate(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_siwrate(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- int rc = 0;
- u8 brate = 0;
- int i;
- BYTE abySupportedRates[13]= {0x02, 0x04, 0x0B, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x90};
-
+ PSDevice pDevice = netdev_priv(dev);
+ int rc = 0;
+ u8 brate = 0;
+ int i;
+ BYTE abySupportedRates[13] = {
+ 0x02, 0x04, 0x0B, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48,
+ 0x60, 0x6C, 0x90
+ };
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWRATE \n");
- if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
- rc = -EINVAL;
- return rc;
- }
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWRATE \n");
+ if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
+ rc = -EINVAL;
+ return rc;
+ }
- // First : get a valid bit rate value
+ // First: get a valid bit rate value
// Which type of value
- if((wrq->value < 13) &&
- (wrq->value >= 0)) {
+ if ((wrq->value < 13) && (wrq->value >= 0)) {
// Setting by rate index
// Find value in the magic rate table
brate = wrq->value;
} else {
// Setting by frequency value
- u8 normvalue = (u8) (wrq->value/500000);
+ u8 normvalue = (u8)(wrq->value/500000);
// Check if rate is valid
- for (i = 0 ; i < 13 ; i++) {
- if(normvalue == abySupportedRates[i]) {
+ for (i = 0; i < 13; i++) {
+ if (normvalue == abySupportedRates[i]) {
brate = i;
break;
}
}
}
// -1 designed the max rate (mostly auto mode)
- if(wrq->value == -1) {
+ if (wrq->value == -1) {
// Get the highest available rate
- for (i = 0 ; i < 13 ; i++) {
- if(abySupportedRates[i] == 0)
+ for (i = 0; i < 13; i++) {
+ if (abySupportedRates[i] == 0)
break;
}
- if(i != 0)
+ if (i != 0)
brate = i - 1;
}
// Check that it is valid
// brate is index of abySupportedRates[]
- if(brate > 13 ) {
+ if (brate > 13 ) {
rc = -EINVAL;
return rc;
}
// Now, check if we want a fixed or auto value
- if(wrq->fixed != 0) {
+ if (wrq->fixed != 0) {
// Fixed mode
// One rate, fixed
pDevice->bFixRate = TRUE;
- if ((pDevice->byBBType == BB_TYPE_11B)&& (brate > 3)) {
- pDevice->uConnectionRate = 3;
- }
- else {
- pDevice->uConnectionRate = brate;
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Fixed to Rate %d \n", pDevice->uConnectionRate);
- }
-
+ if ((pDevice->byBBType == BB_TYPE_11B) && (brate > 3)) {
+ pDevice->uConnectionRate = 3;
+ } else {
+ pDevice->uConnectionRate = brate;
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Fixed to Rate %d \n", pDevice->uConnectionRate);
+ }
}
else {
- pDevice->bFixRate = FALSE;
- pDevice->uConnectionRate = 13;
- }
+ pDevice->bFixRate = FALSE;
+ pDevice->uConnectionRate = 13;
+ }
return rc;
}
/*
- * Wireless Handler : get data rate
+ * Wireless Handler: get data rate
*/
-void iwctl_giwrate(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+void iwctl_giwrate(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWRATE \n");
+ {
+ BYTE abySupportedRates[13] = {
+ 0x02, 0x04, 0x0B, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30,
+ 0x48, 0x60, 0x6C, 0x90
+ };
+ int brate = 0;
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWRATE \n");
- {
- BYTE abySupportedRates[13]= {0x02, 0x04, 0x0B, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x90};
- int brate = 0;
if (pDevice->uConnectionRate < 13) {
- brate = abySupportedRates[pDevice->uConnectionRate];
- }else {
- if (pDevice->byBBType == BB_TYPE_11B)
- brate = 0x16;
- if (pDevice->byBBType == BB_TYPE_11G)
- brate = 0x6C;
- if (pDevice->byBBType == BB_TYPE_11A)
- brate = 0x6C;
- }
-
- if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
- if (pDevice->byBBType == BB_TYPE_11B)
- brate = 0x16;
- if (pDevice->byBBType == BB_TYPE_11G)
- brate = 0x6C;
- if (pDevice->byBBType == BB_TYPE_11A)
- brate = 0x6C;
- }
+ brate = abySupportedRates[pDevice->uConnectionRate];
+ } else {
+ if (pDevice->byBBType == BB_TYPE_11B)
+ brate = 0x16;
+ if (pDevice->byBBType == BB_TYPE_11G)
+ brate = 0x6C;
+ if (pDevice->byBBType == BB_TYPE_11A)
+ brate = 0x6C;
+ }
+ if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
+ if (pDevice->byBBType == BB_TYPE_11B)
+ brate = 0x16;
+ if (pDevice->byBBType == BB_TYPE_11G)
+ brate = 0x6C;
+ if (pDevice->byBBType == BB_TYPE_11A)
+ brate = 0x6C;
+ }
if (pDevice->uConnectionRate == 13)
- brate = abySupportedRates[pDevice->wCurrentRate];
- wrq->value = brate * 500000;
- // If more than one rate, set auto
- if (pDevice->bFixRate == TRUE)
- wrq->fixed = TRUE;
- }
+ brate = abySupportedRates[pDevice->wCurrentRate];
+ wrq->value = brate * 500000;
+ // If more than one rate, set auto
+ if (pDevice->bFixRate == TRUE)
+ wrq->fixed = TRUE;
+ }
}
-
-
/*
- * Wireless Handler : set rts threshold
+ * Wireless Handler: set rts threshold
*/
-int iwctl_siwrts(struct net_device *dev,
- struct iw_param *wrq)
+int iwctl_siwrts(struct net_device *dev, struct iw_param *wrq)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
+ PSDevice pDevice = netdev_priv(dev);
if ((wrq->value < 0 || wrq->value > 2312) && !wrq->disabled)
return -EINVAL;
else if (wrq->disabled)
pDevice->wRTSThreshold = 2312;
-
else
pDevice->wRTSThreshold = wrq->value;
}
/*
- * Wireless Handler : get rts
+ * Wireless Handler: get rts
*/
-
-int iwctl_giwrts(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_giwrts(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
+ PSDevice pDevice = netdev_priv(dev);
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWRTS \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWRTS \n");
wrq->value = pDevice->wRTSThreshold;
wrq->disabled = (wrq->value >= 2312);
wrq->fixed = 1;
}
/*
- * Wireless Handler : set fragment threshold
+ * Wireless Handler: set fragment threshold
*/
-
-int iwctl_siwfrag(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_siwfrag(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- int rc = 0;
- int fthr = wrq->value;
-
-
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWFRAG \n");
+ PSDevice pDevice = netdev_priv(dev);
+ int rc = 0;
+ int fthr = wrq->value;
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWFRAG \n");
- if (wrq->disabled)
+ if (wrq->disabled)
fthr = 2312;
- if((fthr < 256) || (fthr > 2312)) {
+ if ((fthr < 256) || (fthr > 2312)) {
rc = -EINVAL;
- }else {
- fthr &= ~0x1; // Get an even value
- pDevice->wFragmentationThreshold = (u16)fthr;
- }
-
+ } else {
+ fthr &= ~0x1; // Get an even value
+ pDevice->wFragmentationThreshold = (u16)fthr;
+ }
return rc;
}
/*
- * Wireless Handler : get fragment threshold
+ * Wireless Handler: get fragment threshold
*/
-
-int iwctl_giwfrag(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_giwfrag(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
+ PSDevice pDevice = netdev_priv(dev);
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWFRAG \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWFRAG \n");
wrq->value = pDevice->wFragmentationThreshold;
wrq->disabled = (wrq->value >= 2312);
wrq->fixed = 1;
return 0;
}
-
-
/*
- * Wireless Handler : set retry threshold
+ * Wireless Handler: set retry threshold
*/
-int iwctl_siwretry(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_siwretry(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- int rc = 0;
-
+ PSDevice pDevice = netdev_priv(dev);
+ int rc = 0;
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWRETRY \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWRETRY \n");
if (wrq->disabled) {
rc = -EINVAL;
}
if (wrq->flags & IW_RETRY_LIMIT) {
- if(wrq->flags & IW_RETRY_MAX)
+ if (wrq->flags & IW_RETRY_MAX) {
pDevice->byLongRetryLimit = wrq->value;
- else if (wrq->flags & IW_RETRY_MIN)
+ } else if (wrq->flags & IW_RETRY_MIN) {
pDevice->byShortRetryLimit = wrq->value;
- else {
+ } else {
// No modifier : set both
pDevice->byShortRetryLimit = wrq->value;
pDevice->byLongRetryLimit = wrq->value;
}
}
- if (wrq->flags & IW_RETRY_LIFETIME) {
+ if (wrq->flags & IW_RETRY_LIFETIME)
pDevice->wMaxTransmitMSDULifetime = wrq->value;
- }
-
-
return rc;
}
/*
- * Wireless Handler : get retry threshold
+ * Wireless Handler: get retry threshold
*/
-int iwctl_giwretry(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_giwretry(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWRETRY \n");
- wrq->disabled = 0; // Can't be disabled
+ PSDevice pDevice = netdev_priv(dev);
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWRETRY \n");
+ wrq->disabled = 0; // Can't be disabled
- // Note : by default, display the min retry number
- if((wrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
+ // Note: by default, display the min retry number
+ if ((wrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
wrq->flags = IW_RETRY_LIFETIME;
- wrq->value = (int)pDevice->wMaxTransmitMSDULifetime; //ms
- } else if((wrq->flags & IW_RETRY_MAX)) {
+ wrq->value = (int)pDevice->wMaxTransmitMSDULifetime; // ms
+ } else if ((wrq->flags & IW_RETRY_MAX)) {
wrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
wrq->value = (int)pDevice->byLongRetryLimit;
} else {
wrq->flags = IW_RETRY_LIMIT;
wrq->value = (int)pDevice->byShortRetryLimit;
- if((int)pDevice->byShortRetryLimit != (int)pDevice->byLongRetryLimit)
+ if ((int)pDevice->byShortRetryLimit != (int)pDevice->byLongRetryLimit)
wrq->flags |= IW_RETRY_MIN;
}
-
-
return 0;
}
-
/*
- * Wireless Handler : set encode mode
+ * Wireless Handler: set encode mode
*/
-int iwctl_siwencode(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_siwencode(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
DWORD dwKeyIndex = (DWORD)(wrq->flags & IW_ENCODE_INDEX);
- int ii,uu, rc = 0;
+ int ii;
+ int uu;
+ int rc = 0;
int index = (wrq->flags & IW_ENCODE_INDEX);
-
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODE \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODE \n");
// Check the size of the key
if (wrq->length > WLAN_WEP232_KEYLEN) {
rc = -EINVAL;
- return rc;
+ return rc;
}
if (dwKeyIndex > WLAN_WEP_NKEYS) {
rc = -EINVAL;
- return rc;
- }
+ return rc;
+ }
- if (dwKeyIndex > 0)
+ if (dwKeyIndex > 0)
dwKeyIndex--;
// Send the key to the card
if (wrq->length > 0) {
- if (wrq->length == WLAN_WEP232_KEYLEN) {
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set 232 bit wep key\n");
- }
- else if (wrq->length == WLAN_WEP104_KEYLEN) {
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set 104 bit wep key\n");
- }
- else if (wrq->length == WLAN_WEP40_KEYLEN) {
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set 40 bit wep key, index= %d\n", (int)dwKeyIndex);
- }
- memset(pDevice->abyKey, 0, WLAN_WEP232_KEYLEN);
- memcpy(pDevice->abyKey, extra, wrq->length);
-
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"abyKey: ");
- for (ii = 0; ii < wrq->length; ii++) {
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", pDevice->abyKey[ii]);
- }
-
- if (pDevice->flags & DEVICE_FLAGS_OPENED) {
- spin_lock_irq(&pDevice->lock);
- KeybSetDefaultKey( pDevice,
- &(pDevice->sKey),
- dwKeyIndex | (1 << 31),
- wrq->length,
- NULL,
- pDevice->abyKey,
- KEY_CTL_WEP
- );
- spin_unlock_irq(&pDevice->lock);
- }
- pDevice->byKeyIndex = (BYTE)dwKeyIndex;
- pDevice->uKeyLength = wrq->length;
- pDevice->bTransmitKey = TRUE;
- pDevice->bEncryptionEnable = TRUE;
- pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
-
- // Do we want to just set the transmit key index ?
- if ( index < 4 ) {
- pDevice->byKeyIndex = index;
+ if (wrq->length == WLAN_WEP232_KEYLEN) {
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set 232 bit wep key\n");
+ } else if (wrq->length == WLAN_WEP104_KEYLEN) {
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set 104 bit wep key\n");
+ } else if (wrq->length == WLAN_WEP40_KEYLEN) {
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set 40 bit wep key, index= %d\n", (int)dwKeyIndex);
+ }
+ memset(pDevice->abyKey, 0, WLAN_WEP232_KEYLEN);
+ memcpy(pDevice->abyKey, extra, wrq->length);
+
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"abyKey: ");
+ for (ii = 0; ii < wrq->length; ii++)
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", pDevice->abyKey[ii]);
+
+ if (pDevice->flags & DEVICE_FLAGS_OPENED) {
+ spin_lock_irq(&pDevice->lock);
+ KeybSetDefaultKey(pDevice,
+ &(pDevice->sKey),
+ dwKeyIndex | (1 << 31),
+ wrq->length, NULL,
+ pDevice->abyKey,
+ KEY_CTL_WEP
+ );
+ spin_unlock_irq(&pDevice->lock);
+ }
+ pDevice->byKeyIndex = (BYTE)dwKeyIndex;
+ pDevice->uKeyLength = wrq->length;
+ pDevice->bTransmitKey = TRUE;
+ pDevice->bEncryptionEnable = TRUE;
+ pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
+
+ // Do we want to just set the transmit key index?
+ if (index < 4) {
+ pDevice->byKeyIndex = index;
} else if (!(wrq->flags & IW_ENCODE_MODE)) {
- rc = -EINVAL;
- return rc;
- }
+ rc = -EINVAL;
+ return rc;
+ }
}
// Read the flags
- if(wrq->flags & IW_ENCODE_DISABLED){
-
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disable WEP function\n");
+ if (wrq->flags & IW_ENCODE_DISABLED) {
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Disable WEP function\n");
pMgmt->bShareKeyAlgorithm = FALSE;
- pDevice->bEncryptionEnable = FALSE;
- pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
- if (pDevice->flags & DEVICE_FLAGS_OPENED) {
- spin_lock_irq(&pDevice->lock);
- for (uu = 0; uu < MAX_KEY_TABLE; uu++)
- MACvDisableKeyEntry(pDevice, uu);
- spin_unlock_irq(&pDevice->lock);
- }
+ pDevice->bEncryptionEnable = FALSE;
+ pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
+ if (pDevice->flags & DEVICE_FLAGS_OPENED) {
+ spin_lock_irq(&pDevice->lock);
+ for (uu = 0; uu < MAX_KEY_TABLE; uu++)
+ MACvDisableKeyEntry(pDevice, uu);
+ spin_unlock_irq(&pDevice->lock);
+ }
}
- if(wrq->flags & IW_ENCODE_RESTRICTED) {
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable WEP & ShareKey System\n");
+ if (wrq->flags & IW_ENCODE_RESTRICTED) {
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable WEP & ShareKey System\n");
pMgmt->bShareKeyAlgorithm = TRUE;
}
- if(wrq->flags & IW_ENCODE_OPEN) {
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable WEP & Open System\n");
+ if (wrq->flags & IW_ENCODE_OPEN) {
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Enable WEP & Open System\n");
pMgmt->bShareKeyAlgorithm = FALSE;
}
#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
- memset(pMgmt->abyDesireBSSID, 0xFF,6);
+ memset(pMgmt->abyDesireBSSID, 0xFF, 6);
#endif
-
return rc;
}
-int iwctl_giwencode(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_giwencode(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
char abyKey[WLAN_WEP232_KEYLEN];
- unsigned int index = (unsigned int)(wrq->flags & IW_ENCODE_INDEX);
- PSKeyItem pKey = NULL;
+ unsigned index = (unsigned)(wrq->flags & IW_ENCODE_INDEX);
+ PSKeyItem pKey = NULL;
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODE\n");
- if (index > WLAN_WEP_NKEYS) {
+ if (index > WLAN_WEP_NKEYS)
return -EINVAL;
+ if (index < 1) { // get default key
+ if (pDevice->byKeyIndex < WLAN_WEP_NKEYS)
+ index = pDevice->byKeyIndex;
+ else
+ index = 0;
+ } else {
+ index--;
}
- if(index<1){//get default key
- if(pDevice->byKeyIndex<WLAN_WEP_NKEYS){
- index=pDevice->byKeyIndex;
- } else
- index=0;
- }else
- index--;
memset(abyKey, 0, WLAN_WEP232_KEYLEN);
// Check encryption mode
wrq->flags = IW_ENCODE_NOKEY;
// Is WEP enabled ???
if (pDevice->bEncryptionEnable)
- wrq->flags |= IW_ENCODE_ENABLED;
+ wrq->flags |= IW_ENCODE_ENABLED;
else
- wrq->flags |= IW_ENCODE_DISABLED;
+ wrq->flags |= IW_ENCODE_DISABLED;
if (pMgmt->bShareKeyAlgorithm)
- wrq->flags |= IW_ENCODE_RESTRICTED;
+ wrq->flags |= IW_ENCODE_RESTRICTED;
else
- wrq->flags |= IW_ENCODE_OPEN;
- wrq->length=0;
-
- if((index==0)&&(pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled||
- pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled)){//get wpa pairwise key
- if (KeybGetKey(&(pDevice->sKey),pMgmt->abyCurrBSSID, 0xffffffff, &pKey)){
- wrq->length = pKey->uKeyLength;
- memcpy(abyKey, pKey->abyKey, pKey->uKeyLength);
- memcpy(extra, abyKey, WLAN_WEP232_KEYLEN);
- }
- }else if (KeybGetKey(&(pDevice->sKey), pDevice->abyBroadcastAddr, (BYTE)index , &pKey)){
+ wrq->flags |= IW_ENCODE_OPEN;
+ wrq->length = 0;
+
+ if ((index == 0) && (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled ||
+ pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled)){ // get wpa pairwise key
+ if (KeybGetKey(&(pDevice->sKey), pMgmt->abyCurrBSSID, 0xffffffff, &pKey)) {
wrq->length = pKey->uKeyLength;
- memcpy(abyKey, pKey->abyKey, pKey->uKeyLength);
- memcpy(extra, abyKey, WLAN_WEP232_KEYLEN);
+ memcpy(abyKey, pKey->abyKey, pKey->uKeyLength);
+ memcpy(extra, abyKey, WLAN_WEP232_KEYLEN);
+ }
+ } else if (KeybGetKey(&(pDevice->sKey), pDevice->abyBroadcastAddr, (BYTE)index, &pKey)) {
+ wrq->length = pKey->uKeyLength;
+ memcpy(abyKey, pKey->abyKey, pKey->uKeyLength);
+ memcpy(extra, abyKey, WLAN_WEP232_KEYLEN);
}
- wrq->flags |= index+1;
-
+ wrq->flags |= index + 1;
return 0;
}
-
/*
- * Wireless Handler : set power mode
+ * Wireless Handler: set power mode
*/
-int iwctl_siwpower(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_siwpower(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- int rc = 0;
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ int rc = 0;
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWPOWER \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWPOWER \n");
- if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
- rc = -EINVAL;
- return rc;
+ if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
+ rc = -EINVAL;
+ return rc;
}
if (wrq->disabled) {
return rc;
}
if ((wrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
- pDevice->ePSMode = WMAC_POWER_FAST;
- PSvEnablePowerSaving((void *) pDevice, pMgmt->wListenInterval);
+ pDevice->ePSMode = WMAC_POWER_FAST;
+ PSvEnablePowerSaving((void *)pDevice, pMgmt->wListenInterval);
} else if ((wrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
- pDevice->ePSMode = WMAC_POWER_FAST;
- PSvEnablePowerSaving((void *) pDevice, pMgmt->wListenInterval);
+ pDevice->ePSMode = WMAC_POWER_FAST;
+ PSvEnablePowerSaving((void *)pDevice, pMgmt->wListenInterval);
}
switch (wrq->flags & IW_POWER_MODE) {
case IW_POWER_UNICAST_R:
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWPOWER: IW_POWER_UNICAST_R \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWPOWER: IW_POWER_UNICAST_R \n");
rc = -EINVAL;
break;
case IW_POWER_ALL_R:
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWPOWER: IW_POWER_ALL_R \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWPOWER: IW_POWER_ALL_R \n");
rc = -EINVAL;
case IW_POWER_ON:
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWPOWER: IW_POWER_ON \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWPOWER: IW_POWER_ON \n");
break;
default:
rc = -EINVAL;
}
/*
- * Wireless Handler : get power mode
+ * Wireless Handler: get power mode
*/
-int iwctl_giwpower(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_giwpower(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- int mode = pDevice->ePSMode;
-
-
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPOWER \n");
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ int mode = pDevice->ePSMode;
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPOWER \n");
if ((wrq->disabled = (mode == WMAC_POWER_CAM)))
- return 0;
+ return 0;
if ((wrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
wrq->value = (int)((pMgmt->wListenInterval * pMgmt->wCurrBeaconPeriod) << 10);
wrq->flags = IW_POWER_PERIOD;
}
wrq->flags |= IW_POWER_ALL_R;
-
return 0;
}
-
/*
- * Wireless Handler : get Sensitivity
+ * Wireless Handler: get Sensitivity
*/
-int iwctl_giwsens(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_giwsens(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- long ldBm;
+ PSDevice pDevice = netdev_priv(dev);
+ long ldBm;
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSENS \n");
- if (pDevice->bLinkPass == TRUE) {
- RFvRSSITodBm(pDevice, (BYTE)(pDevice->uCurrRSSI), &ldBm);
- wrq->value = ldBm;
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSENS \n");
+ if (pDevice->bLinkPass == TRUE) {
+ RFvRSSITodBm(pDevice, (BYTE)(pDevice->uCurrRSSI), &ldBm);
+ wrq->value = ldBm;
+ } else {
+ wrq->value = 0;
}
- else {
- wrq->value = 0;
- };
wrq->disabled = (wrq->value == 0);
wrq->fixed = 1;
-
-
return 0;
}
#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
-int iwctl_siwauth(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_siwauth(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- int ret=0;
- static int wpa_version=0; //must be static to save the last value,einsn liu
- static int pairwise=0;
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ int ret = 0;
+ static int wpa_version = 0; // must be static to save the last value, einsn liu
+ static int pairwise = 0;
- DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
+ DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
switch (wrq->flags & IW_AUTH_INDEX) {
case IW_AUTH_WPA_VERSION:
wpa_version = wrq->value;
- if(wrq->value == IW_AUTH_WPA_VERSION_DISABLED) {
- PRINT_K("iwctl_siwauth:set WPADEV to disable at 1??????\n");
- }
- else if(wrq->value == IW_AUTH_WPA_VERSION_WPA) {
- PRINT_K("iwctl_siwauth:set WPADEV to WPA1******\n");
- }
- else {
- PRINT_K("iwctl_siwauth:set WPADEV to WPA2******\n");
+ if (wrq->value == IW_AUTH_WPA_VERSION_DISABLED) {
+ PRINT_K("iwctl_siwauth:set WPADEV to disable at 1??????\n");
+ } else if (wrq->value == IW_AUTH_WPA_VERSION_WPA) {
+ PRINT_K("iwctl_siwauth:set WPADEV to WPA1******\n");
+ } else {
+ PRINT_K("iwctl_siwauth:set WPADEV to WPA2******\n");
}
break;
case IW_AUTH_CIPHER_PAIRWISE:
pairwise = wrq->value;
- PRINT_K("iwctl_siwauth:set pairwise=%d\n",pairwise);
- if(pairwise == IW_AUTH_CIPHER_CCMP){
+ PRINT_K("iwctl_siwauth:set pairwise=%d\n", pairwise);
+ if (pairwise == IW_AUTH_CIPHER_CCMP){
pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
- }else if(pairwise == IW_AUTH_CIPHER_TKIP){
+ } else if (pairwise == IW_AUTH_CIPHER_TKIP) {
pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
} else if (pairwise == IW_AUTH_CIPHER_WEP40 ||
- pairwise == IW_AUTH_CIPHER_WEP104) {
+ pairwise == IW_AUTH_CIPHER_WEP104) {
pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
- }else if(pairwise == IW_AUTH_CIPHER_NONE){
- //do nothing,einsn liu
- }else pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
-
+ } else if (pairwise == IW_AUTH_CIPHER_NONE) {
+ // do nothing, einsn liu
+ } else {
+ pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
+ }
break;
case IW_AUTH_CIPHER_GROUP:
- PRINT_K("iwctl_siwauth:set GROUP=%d\n",wrq->value);
- if(wpa_version == IW_AUTH_WPA_VERSION_DISABLED)
+ PRINT_K("iwctl_siwauth:set GROUP=%d\n", wrq->value);
+ if (wpa_version == IW_AUTH_WPA_VERSION_DISABLED)
break;
- if(pairwise == IW_AUTH_CIPHER_NONE){
- if(wrq->value == IW_AUTH_CIPHER_CCMP){
+ if (pairwise == IW_AUTH_CIPHER_NONE) {
+ if (wrq->value == IW_AUTH_CIPHER_CCMP) {
pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
}else {
pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
}
break;
case IW_AUTH_KEY_MGMT:
- PRINT_K("iwctl_siwauth(wpa_version=%d):set KEY_MGMT=%d\n",wpa_version,wrq->value);
- if(wpa_version == IW_AUTH_WPA_VERSION_WPA2){
- if(wrq->value == IW_AUTH_KEY_MGMT_PSK)
+ PRINT_K("iwctl_siwauth(wpa_version=%d):set KEY_MGMT=%d\n", wpa_version,wrq->value);
+ if (wpa_version == IW_AUTH_WPA_VERSION_WPA2){
+ if (wrq->value == IW_AUTH_KEY_MGMT_PSK)
pMgmt->eAuthenMode = WMAC_AUTH_WPA2PSK;
else pMgmt->eAuthenMode = WMAC_AUTH_WPA2;
- }else if(wpa_version == IW_AUTH_WPA_VERSION_WPA){
- if(wrq->value == 0){
+ } else if (wpa_version == IW_AUTH_WPA_VERSION_WPA) {
+ if (wrq->value == 0){
pMgmt->eAuthenMode = WMAC_AUTH_WPANONE;
- }else if(wrq->value == IW_AUTH_KEY_MGMT_PSK)
+ } else if (wrq->value == IW_AUTH_KEY_MGMT_PSK)
pMgmt->eAuthenMode = WMAC_AUTH_WPAPSK;
- else pMgmt->eAuthenMode = WMAC_AUTH_WPA;
+ } else {
+ pMgmt->eAuthenMode = WMAC_AUTH_WPA;
}
-
break;
case IW_AUTH_TKIP_COUNTERMEASURES:
- break; /* FIXME */
+ break; /* FIXME */
case IW_AUTH_DROP_UNENCRYPTED:
break;
case IW_AUTH_80211_AUTH_ALG:
- PRINT_K("iwctl_siwauth:set AUTH_ALG=%d\n",wrq->value);
- if(wrq->value==IW_AUTH_ALG_OPEN_SYSTEM){
- pMgmt->bShareKeyAlgorithm=FALSE;
- }else if(wrq->value==IW_AUTH_ALG_SHARED_KEY){
- pMgmt->bShareKeyAlgorithm=TRUE;
- }
+ PRINT_K("iwctl_siwauth:set AUTH_ALG=%d\n", wrq->value);
+ if (wrq->value == IW_AUTH_ALG_OPEN_SYSTEM)
+ pMgmt->bShareKeyAlgorithm = FALSE;
+ else if (wrq->value == IW_AUTH_ALG_SHARED_KEY)
+ pMgmt->bShareKeyAlgorithm = TRUE;
break;
case IW_AUTH_WPA_ENABLED:
break;
break;
case IW_AUTH_PRIVACY_INVOKED:
pDevice->bEncryptionEnable = !!wrq->value;
- if(pDevice->bEncryptionEnable == FALSE){
+ if (pDevice->bEncryptionEnable == FALSE) {
wpa_version = 0;
pairwise = 0;
pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
pMgmt->bShareKeyAlgorithm = FALSE;
pMgmt->eAuthenMode = WMAC_AUTH_OPEN;
- PRINT_K("iwctl_siwauth:set WPADEV to disaable at 2?????\n");
+ PRINT_K("iwctl_siwauth:set WPADEV to disaable at 2?????\n");
}
-
break;
default:
ret = -EOPNOTSUPP;
break;
}
- return ret;
+ return ret;
}
-
-int iwctl_giwauth(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra)
+int iwctl_giwauth(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra)
{
return -EOPNOTSUPP;
}
-
-
-int iwctl_siwgenie(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_siwgenie(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- int ret=0;
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ int ret = 0;
- if(wrq->length){
- if ((wrq->length < 2) || (extra[1]+2 != wrq->length)) {
+ if (wrq->length){
+ if ((wrq->length < 2) || (extra[1] + 2 != wrq->length)) {
ret = -EINVAL;
goto out;
}
- if(wrq->length > MAX_WPA_IE_LEN){
+ if (wrq->length > MAX_WPA_IE_LEN){
ret = -ENOMEM;
goto out;
}
memset(pMgmt->abyWPAIE, 0, MAX_WPA_IE_LEN);
- if(copy_from_user(pMgmt->abyWPAIE, extra, wrq->length)){
+ if (copy_from_user(pMgmt->abyWPAIE, extra, wrq->length)){
ret = -EFAULT;
goto out;
}
pMgmt->wWPAIELen = 0;
}
- out://not completely ...not necessary in wpa_supplicant 0.5.8
+out: // not completely ...not necessary in wpa_supplicant 0.5.8
return ret;
}
-int iwctl_giwgenie(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_giwgenie(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
- int ret=0;
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ int ret = 0;
int space = wrq->length;
wrq->length = 0;
- if(pMgmt->wWPAIELen > 0){
+ if (pMgmt->wWPAIELen > 0) {
wrq->length = pMgmt->wWPAIELen;
- if(pMgmt->wWPAIELen <= space){
- if(copy_to_user(extra, pMgmt->abyWPAIE, pMgmt->wWPAIELen)){
+ if (pMgmt->wWPAIELen <= space) {
+ if (copy_to_user(extra, pMgmt->abyWPAIE, pMgmt->wWPAIELen)) {
ret = -EFAULT;
}
- }else
+ } else
ret = -E2BIG;
}
-
return ret;
}
-
-int iwctl_siwencodeext(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_siwencodeext(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
struct iw_encode_ext *ext = (struct iw_encode_ext*)extra;
- struct viawget_wpa_param *param=NULL;
-//original member
- wpa_alg alg_name;
- u8 addr[6];
- int key_idx, set_tx=0;
- u8 seq[IW_ENCODE_SEQ_MAX_SIZE];
- u8 key[64];
- size_t seq_len=0,key_len=0;
- u8 *buf;
- size_t blen;
- u8 key_array[64];
- int ret=0;
-
-PRINT_K("SIOCSIWENCODEEXT...... \n");
-
-blen = sizeof(*param);
-buf = kmalloc((int)blen, (int)GFP_KERNEL);
-if (buf == NULL)
- return -ENOMEM;
-memset(buf, 0, blen);
-param = (struct viawget_wpa_param *) buf;
-
-//recover alg_name
-switch (ext->alg) {
- case IW_ENCODE_ALG_NONE:
- alg_name = WPA_ALG_NONE;
+ struct viawget_wpa_param *param=NULL;
+// original member
+ wpa_alg alg_name;
+ u8 addr[6];
+ int key_idx;
+ int set_tx = 0;
+ u8 seq[IW_ENCODE_SEQ_MAX_SIZE];
+ u8 key[64];
+ size_t seq_len = 0;
+ size_t key_len = 0;
+ u8 *buf;
+ size_t blen;
+ u8 key_array[64];
+ int ret = 0;
+
+ PRINT_K("SIOCSIWENCODEEXT...... \n");
+
+ blen = sizeof(*param);
+ buf = kmalloc((int)blen, (int)GFP_KERNEL);
+ if (buf == NULL)
+ return -ENOMEM;
+ memset(buf, 0, blen);
+ param = (struct viawget_wpa_param *)buf;
+
+// recover alg_name
+ switch (ext->alg) {
+ case IW_ENCODE_ALG_NONE:
+ alg_name = WPA_ALG_NONE;
break;
- case IW_ENCODE_ALG_WEP:
- alg_name = WPA_ALG_WEP;
+ case IW_ENCODE_ALG_WEP:
+ alg_name = WPA_ALG_WEP;
break;
- case IW_ENCODE_ALG_TKIP:
- alg_name = WPA_ALG_TKIP;
+ case IW_ENCODE_ALG_TKIP:
+ alg_name = WPA_ALG_TKIP;
break;
- case IW_ENCODE_ALG_CCMP:
- alg_name = WPA_ALG_CCMP;
+ case IW_ENCODE_ALG_CCMP:
+ alg_name = WPA_ALG_CCMP;
break;
- default:
+ default:
PRINT_K("Unknown alg = %d\n",ext->alg);
ret= -ENOMEM;
goto error;
- }
-//recover addr
- memcpy(addr, ext->addr.sa_data, ETH_ALEN);
-//recover key_idx
- key_idx = (wrq->flags&IW_ENCODE_INDEX) - 1;
-//recover set_tx
-if(ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
- set_tx = 1;
-//recover seq,seq_len
- if(ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
- seq_len=IW_ENCODE_SEQ_MAX_SIZE;
- memcpy(seq, ext->rx_seq, seq_len);
- }
-//recover key,key_len
-if(ext->key_len) {
- key_len=ext->key_len;
- memcpy(key, &ext->key[0], key_len);
}
-
-memset(key_array, 0, 64);
-if ( key_len > 0) {
- memcpy(key_array, key, key_len);
- if (key_len == 32) {
- // notice ! the oder
- memcpy(&key_array[16], &key[24], 8);
- memcpy(&key_array[24], &key[16], 8);
+// recover addr
+ memcpy(addr, ext->addr.sa_data, ETH_ALEN);
+// recover key_idx
+ key_idx = (wrq->flags&IW_ENCODE_INDEX) - 1;
+// recover set_tx
+ if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
+ set_tx = 1;
+// recover seq,seq_len
+ if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
+ seq_len=IW_ENCODE_SEQ_MAX_SIZE;
+ memcpy(seq, ext->rx_seq, seq_len);
}
+// recover key,key_len
+ if (ext->key_len) {
+ key_len = ext->key_len;
+ memcpy(key, &ext->key[0], key_len);
+ }
+ memset(key_array, 0, 64);
+ if (key_len > 0) {
+ memcpy(key_array, key, key_len);
+ if (key_len == 32) {
+ // notice ! the oder
+ memcpy(&key_array[16], &key[24], 8);
+ memcpy(&key_array[24], &key[16], 8);
+ }
}
/**************Translate iw_encode_ext to viawget_wpa_param****************/
-memcpy(param->addr, addr, ETH_ALEN);
-param->u.wpa_key.alg_name = (int)alg_name;
-param->u.wpa_key.set_tx = set_tx;
-param->u.wpa_key.key_index = key_idx;
-param->u.wpa_key.key_len = key_len;
-param->u.wpa_key.key = (u8 *)key_array;
-param->u.wpa_key.seq = (u8 *)seq;
-param->u.wpa_key.seq_len = seq_len;
-
-//****set if current action is Network Manager count??
-//****this method is so foolish,but there is no other way???
-if(param->u.wpa_key.alg_name == WPA_ALG_NONE) {
- if(param->u.wpa_key.key_index ==0) {
- pDevice->bwextstep0 = TRUE;
- }
- if((pDevice->bwextstep0 = TRUE)&&(param->u.wpa_key.key_index ==1)) {
- pDevice->bwextstep0 = FALSE;
- pDevice->bwextstep1 = TRUE;
- }
- if((pDevice->bwextstep1 = TRUE)&&(param->u.wpa_key.key_index ==2)) {
- pDevice->bwextstep1 = FALSE;
- pDevice->bwextstep2 = TRUE;
+ memcpy(param->addr, addr, ETH_ALEN);
+ param->u.wpa_key.alg_name = (int)alg_name;
+ param->u.wpa_key.set_tx = set_tx;
+ param->u.wpa_key.key_index = key_idx;
+ param->u.wpa_key.key_len = key_len;
+ param->u.wpa_key.key = (u8 *)key_array;
+ param->u.wpa_key.seq = (u8 *)seq;
+ param->u.wpa_key.seq_len = seq_len;
+
+/****set if current action is Network Manager count?? */
+/****this method is so foolish,but there is no other way??? */
+ if (param->u.wpa_key.alg_name == WPA_ALG_NONE) {
+ if (param->u.wpa_key.key_index ==0) {
+ pDevice->bwextstep0 = TRUE;
+ }
+ if ((pDevice->bwextstep0 == TRUE) && (param->u.wpa_key.key_index == 1)) {
+ pDevice->bwextstep0 = FALSE;
+ pDevice->bwextstep1 = TRUE;
+ }
+ if ((pDevice->bwextstep1 == TRUE) && (param->u.wpa_key.key_index == 2)) {
+ pDevice->bwextstep1 = FALSE;
+ pDevice->bwextstep2 = TRUE;
+ }
+ if ((pDevice->bwextstep2 == TRUE) && (param->u.wpa_key.key_index == 3)) {
+ pDevice->bwextstep2 = FALSE;
+ pDevice->bwextstep3 = TRUE;
+ }
+ }
+ if (pDevice->bwextstep3 == TRUE) {
+ PRINT_K("SIOCSIWENCODEEXT:Enable WPA WEXT SUPPORT!!!!!\n");
+ pDevice->bwextstep0 = FALSE;
+ pDevice->bwextstep1 = FALSE;
+ pDevice->bwextstep2 = FALSE;
+ pDevice->bwextstep3 = FALSE;
+ pDevice->bWPASuppWextEnabled = TRUE;
+ memset(pMgmt->abyDesireBSSID, 0xFF, 6);
+ KeyvInitTable(pDevice, &pDevice->sKey);
}
- if((pDevice->bwextstep2 = TRUE)&&(param->u.wpa_key.key_index ==3)) {
- pDevice->bwextstep2 = FALSE;
- pDevice->bwextstep3 = TRUE;
- }
- }
-if(pDevice->bwextstep3 == TRUE) {
- PRINT_K("SIOCSIWENCODEEXT:Enable WPA WEXT SUPPORT!!!!!\n");
- pDevice->bwextstep0 = FALSE;
- pDevice->bwextstep1 = FALSE;
- pDevice->bwextstep2 = FALSE;
- pDevice->bwextstep3 = FALSE;
- pDevice->bWPASuppWextEnabled = TRUE;
- memset(pMgmt->abyDesireBSSID, 0xFF,6);
- KeyvInitTable(pDevice,&pDevice->sKey);
- }
-//******
-
- spin_lock_irq(&pDevice->lock);
- ret = wpa_set_keys(pDevice, param, TRUE);
- spin_unlock_irq(&pDevice->lock);
+/*******/
+ spin_lock_irq(&pDevice->lock);
+ ret = wpa_set_keys(pDevice, param, TRUE);
+ spin_unlock_irq(&pDevice->lock);
error:
-kfree(param);
+ kfree(param);
return ret;
}
-
-
-int iwctl_giwencodeext(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_giwencodeext(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- return -EOPNOTSUPP;
+ return -EOPNOTSUPP;
}
-int iwctl_siwmlme(struct net_device *dev,
- struct iw_request_info * info,
- struct iw_point *wrq,
- char *extra)
+int iwctl_siwmlme(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra)
{
- PSDevice pDevice = (PSDevice)netdev_priv(dev);
- PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
+ PSDevice pDevice = netdev_priv(dev);
+ PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
struct iw_mlme *mlme = (struct iw_mlme *)extra;
int ret = 0;
- if(memcmp(pMgmt->abyCurrBSSID, mlme->addr.sa_data, ETH_ALEN)){
+ if (memcmp(pMgmt->abyCurrBSSID, mlme->addr.sa_data, ETH_ALEN)) {
ret = -EINVAL;
return ret;
}
- switch(mlme->cmd){
+ switch (mlme->cmd){
case IW_MLME_DEAUTH:
case IW_MLME_DISASSOC:
- if(pDevice->bLinkPass == TRUE){
- PRINT_K("iwctl_siwmlme--->send DISASSOCIATE\n");
- bScheduleCommand((void *) pDevice,
- WLAN_CMD_DISASSOCIATE,
- NULL);
+ if (pDevice->bLinkPass == TRUE) {
+ PRINT_K("iwctl_siwmlme--->send DISASSOCIATE\n");
+ bScheduleCommand((void *)pDevice,
+ WLAN_CMD_DISASSOCIATE,
+ NULL);
}
break;
default:
ret = -EOPNOTSUPP;
}
-
return ret;
-
}
#endif
-static const iw_handler iwctl_handler[] =
-{
- (iw_handler) NULL, /* SIOCSIWCOMMIT */
- (iw_handler) NULL, // SIOCGIWNAME
- (iw_handler) NULL, // SIOCSIWNWID
- (iw_handler) NULL, // SIOCGIWNWID
- (iw_handler) NULL, // SIOCSIWFREQ
- (iw_handler) NULL, // SIOCGIWFREQ
- (iw_handler) NULL, // SIOCSIWMODE
- (iw_handler) NULL, // SIOCGIWMODE
- (iw_handler) NULL, // SIOCSIWSENS
- (iw_handler) NULL, // SIOCGIWSENS
- (iw_handler) NULL, // SIOCSIWRANGE
- (iw_handler) iwctl_giwrange, // SIOCGIWRANGE
- (iw_handler) NULL, // SIOCSIWPRIV
- (iw_handler) NULL, // SIOCGIWPRIV
- (iw_handler) NULL, // SIOCSIWSTATS
- (iw_handler) NULL, // SIOCGIWSTATS
- (iw_handler) NULL, // SIOCSIWSPY
- (iw_handler) NULL, // SIOCGIWSPY
- (iw_handler) NULL, // -- hole --
- (iw_handler) NULL, // -- hole --
- (iw_handler) NULL, // SIOCSIWAP
- (iw_handler) NULL, // SIOCGIWAP
- (iw_handler) NULL, // -- hole -- 0x16
- (iw_handler) NULL, // SIOCGIWAPLIST
- (iw_handler) iwctl_siwscan, // SIOCSIWSCAN
- (iw_handler) iwctl_giwscan, // SIOCGIWSCAN
- (iw_handler) NULL, // SIOCSIWESSID
- (iw_handler) NULL, // SIOCGIWESSID
- (iw_handler) NULL, // SIOCSIWNICKN
- (iw_handler) NULL, // SIOCGIWNICKN
- (iw_handler) NULL, // -- hole --
- (iw_handler) NULL, // -- hole --
- (iw_handler) NULL, // SIOCSIWRATE 0x20
- (iw_handler) NULL, // SIOCGIWRATE
- (iw_handler) NULL, // SIOCSIWRTS
- (iw_handler) NULL, // SIOCGIWRTS
- (iw_handler) NULL, // SIOCSIWFRAG
- (iw_handler) NULL, // SIOCGIWFRAG
- (iw_handler) NULL, // SIOCSIWTXPOW
- (iw_handler) NULL, // SIOCGIWTXPOW
- (iw_handler) NULL, // SIOCSIWRETRY
- (iw_handler) NULL, // SIOCGIWRETRY
- (iw_handler) NULL, // SIOCSIWENCODE
- (iw_handler) NULL, // SIOCGIWENCODE
- (iw_handler) NULL, // SIOCSIWPOWER
- (iw_handler) NULL, // SIOCGIWPOWER
- (iw_handler) NULL, // -- hole --
- (iw_handler) NULL, // -- hole --
- (iw_handler) NULL, // SIOCSIWGENIE
- (iw_handler) NULL, // SIOCGIWGENIE
- (iw_handler) NULL, // SIOCSIWAUTH
- (iw_handler) NULL, // SIOCGIWAUTH
- (iw_handler) NULL, // SIOCSIWENCODEEXT
- (iw_handler) NULL, // SIOCGIWENCODEEXT
- (iw_handler) NULL, // SIOCSIWPMKSA
- (iw_handler) NULL, // -- hole --
+static const iw_handler iwctl_handler[] = {
+ (iw_handler)NULL, // SIOCSIWCOMMIT
+ (iw_handler)NULL, // SIOCGIWNAME
+ (iw_handler)NULL, // SIOCSIWNWID
+ (iw_handler)NULL, // SIOCGIWNWID
+ (iw_handler)NULL, // SIOCSIWFREQ
+ (iw_handler)NULL, // SIOCGIWFREQ
+ (iw_handler)NULL, // SIOCSIWMODE
+ (iw_handler)NULL, // SIOCGIWMODE
+ (iw_handler)NULL, // SIOCSIWSENS
+ (iw_handler)NULL, // SIOCGIWSENS
+ (iw_handler)NULL, // SIOCSIWRANGE
+ (iw_handler)iwctl_giwrange, // SIOCGIWRANGE
+ (iw_handler)NULL, // SIOCSIWPRIV
+ (iw_handler)NULL, // SIOCGIWPRIV
+ (iw_handler)NULL, // SIOCSIWSTATS
+ (iw_handler)NULL, // SIOCGIWSTATS
+ (iw_handler)NULL, // SIOCSIWSPY
+ (iw_handler)NULL, // SIOCGIWSPY
+ (iw_handler)NULL, // -- hole --
+ (iw_handler)NULL, // -- hole --
+ (iw_handler)NULL, // SIOCSIWAP
+ (iw_handler)NULL, // SIOCGIWAP
+ (iw_handler)NULL, // -- hole -- 0x16
+ (iw_handler)NULL, // SIOCGIWAPLIST
+ (iw_handler)iwctl_siwscan, // SIOCSIWSCAN
+ (iw_handler)iwctl_giwscan, // SIOCGIWSCAN
+ (iw_handler)NULL, // SIOCSIWESSID
+ (iw_handler)NULL, // SIOCGIWESSID
+ (iw_handler)NULL, // SIOCSIWNICKN
+ (iw_handler)NULL, // SIOCGIWNICKN
+ (iw_handler)NULL, // -- hole --
+ (iw_handler)NULL, // -- hole --
+ (iw_handler)NULL, // SIOCSIWRATE 0x20
+ (iw_handler)NULL, // SIOCGIWRATE
+ (iw_handler)NULL, // SIOCSIWRTS
+ (iw_handler)NULL, // SIOCGIWRTS
+ (iw_handler)NULL, // SIOCSIWFRAG
+ (iw_handler)NULL, // SIOCGIWFRAG
+ (iw_handler)NULL, // SIOCSIWTXPOW
+ (iw_handler)NULL, // SIOCGIWTXPOW
+ (iw_handler)NULL, // SIOCSIWRETRY
+ (iw_handler)NULL, // SIOCGIWRETRY
+ (iw_handler)NULL, // SIOCSIWENCODE
+ (iw_handler)NULL, // SIOCGIWENCODE
+ (iw_handler)NULL, // SIOCSIWPOWER
+ (iw_handler)NULL, // SIOCGIWPOWER
+ (iw_handler)NULL, // -- hole --
+ (iw_handler)NULL, // -- hole --
+ (iw_handler)NULL, // SIOCSIWGENIE
+ (iw_handler)NULL, // SIOCGIWGENIE
+ (iw_handler)NULL, // SIOCSIWAUTH
+ (iw_handler)NULL, // SIOCGIWAUTH
+ (iw_handler)NULL, // SIOCSIWENCODEEXT
+ (iw_handler)NULL, // SIOCGIWENCODEEXT
+ (iw_handler)NULL, // SIOCSIWPMKSA
+ (iw_handler)NULL, // -- hole --
};
-
-static const iw_handler iwctl_private_handler[] =
-{
- NULL, // SIOCIWFIRSTPRIV
+static const iw_handler iwctl_private_handler[] = {
+ NULL, // SIOCIWFIRSTPRIV
};
-
struct iw_priv_args iwctl_private_args[] = {
-{ IOCTL_CMD_SET,
- IW_PRIV_TYPE_CHAR | 1024, 0,
- "set"},
+ { IOCTL_CMD_SET, IW_PRIV_TYPE_CHAR | 1024, 0, "set" },
};
-
-
-const struct iw_handler_def iwctl_handler_def =
-{
- .get_wireless_stats = &iwctl_get_wireless_stats,
- .num_standard = sizeof(iwctl_handler)/sizeof(iw_handler),
- .num_private = 0,
- .num_private_args = 0,
- .standard = (iw_handler *) iwctl_handler,
- .private = NULL,
- .private_args = NULL,
+const struct iw_handler_def iwctl_handler_def = {
+ .get_wireless_stats = &iwctl_get_wireless_stats,
+ .num_standard = sizeof(iwctl_handler) / sizeof(iw_handler),
+ .num_private = 0,
+ .num_private_args = 0,
+ .standard = (iw_handler *)iwctl_handler,
+ .private = NULL,
+ .private_args = NULL,
};
struct iw_statistics *iwctl_get_wireless_stats(struct net_device *dev);
-int iwctl_siwap(struct net_device *dev,
- struct iw_request_info *info,
- struct sockaddr *wrq,
- char *extra);
-
-void iwctl_giwrange(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-
-void iwctl_giwmode(struct net_device *dev,
- struct iw_request_info *info,
- __u32 *wmode,
- char *extra);
-
-int iwctl_siwmode(struct net_device *dev,
- struct iw_request_info *info,
- __u32 *wmode,
- char *extra);
-
-int iwctl_giwfreq(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_freq *wrq,
- char *extra);
-
-int iwctl_siwfreq(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_freq *wrq,
- char *extra);
-
-int iwctl_giwname(struct net_device *dev,
- struct iw_request_info *info,
- char *wrq,
- char *extra);
-
-int iwctl_giwsens(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_giwap(struct net_device *dev,
- struct iw_request_info *info,
- struct sockaddr *wrq,
- char *extra);
-
-int iwctl_giwaplist(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-int iwctl_siwessid(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-void iwctl_giwessid(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-int iwctl_siwrate(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-void iwctl_giwrate(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_siwrts(struct net_device *dev,
- struct iw_param *wrq);
-
-int iwctl_giwrts(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_siwfrag(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_giwfrag(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_siwretry(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_giwretry(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_siwencode(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-int iwctl_giwencode(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-int iwctl_siwpower(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_giwpower(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_giwscan(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-int iwctl_siwscan(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
+int iwctl_siwap(struct net_device *dev, struct iw_request_info *info,
+ struct sockaddr *wrq, char *extra);
+
+void iwctl_giwrange(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+void iwctl_giwmode(struct net_device *dev, struct iw_request_info *info,
+ __u32 *wmode, char *extra);
+
+int iwctl_siwmode(struct net_device *dev, struct iw_request_info *info,
+ __u32 *wmode, char *extra);
+
+int iwctl_giwfreq(struct net_device *dev, struct iw_request_info *info,
+ struct iw_freq *wrq, char *extra);
+
+int iwctl_siwfreq(struct net_device *dev, struct iw_request_info *info,
+ struct iw_freq *wrq, char *extra);
+
+int iwctl_giwname(struct net_device *dev, struct iw_request_info *info,
+ char *wrq, char *extra);
+
+int iwctl_giwsens(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_giwap(struct net_device *dev, struct iw_request_info *info,
+ struct sockaddr *wrq, char *extra);
+
+int iwctl_giwaplist(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+int iwctl_siwessid(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+void iwctl_giwessid(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+int iwctl_siwrate(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+void iwctl_giwrate(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_siwrts(struct net_device *dev, struct iw_param *wrq);
+
+int iwctl_giwrts(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_siwfrag(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_giwfrag(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_siwretry(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_giwretry(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_siwencode(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+int iwctl_giwencode(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+int iwctl_siwpower(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_giwpower(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_giwscan(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+int iwctl_siwscan(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
-int iwctl_siwauth(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_giwauth(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_param *wrq,
- char *extra);
-
-int iwctl_siwgenie(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-int iwctl_giwgenie(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-int iwctl_siwencodeext(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-int iwctl_giwencodeext(struct net_device *dev,
- struct iw_request_info *info,
- struct iw_point *wrq,
- char *extra);
-
-int iwctl_siwmlme(struct net_device *dev,
- struct iw_request_info * info,
- struct iw_point *wrq,
- char *extra);
+int iwctl_siwauth(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_giwauth(struct net_device *dev, struct iw_request_info *info,
+ struct iw_param *wrq, char *extra);
+
+int iwctl_siwgenie(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+int iwctl_giwgenie(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+int iwctl_siwencodeext(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+int iwctl_giwencodeext(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
+
+int iwctl_siwmlme(struct net_device *dev, struct iw_request_info *info,
+ struct iw_point *wrq, char *extra);
#endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
-extern const struct iw_handler_def iwctl_handler_def;
-extern const struct iw_priv_args iwctl_private_args;
+extern const struct iw_handler_def iwctl_handler_def;
+extern const struct iw_priv_args iwctl_private_args;
#endif /* __IWCTL_H__ */
/*
* ================================================================
- * Configration default value
+ * Configuration default value
* ================================================================
*/
#define DEFAULT_MULTICASTLISTMAX 32 /* standard */
/*
* Declare data rate table:
- * The following table will be changed at anytime if the opration rate
+ * The following table will be changed at anytime if the operation rate
* supported by AP don't match the table
*/
static u8 MTO_Data_Rate_Tbl[MTO_MAX_DATA_RATE_LEVELS] = {
// 800 us latency before FW switches to high power
MSF_WAIT(800); // MSF-defined function to wait n microseconds.
//OOR if ( ifbp->IFB_DSLinkStat & CFG_LINK_STAT_DS_OOR ) { // OutOfRange
-// printk( "<5>ACT_INT_OFF: Deepsleep phase terminated, enable and go to AwaitConnection\n" ); //;?remove me 1 day
+// printk(KERN_NOTICE "ACT_INT_OFF: Deepsleep phase terminated, enable and go to AwaitConnection\n" ); //;?remove me 1 day
// hcf_cntl( ifbp, HCF_CNTL_ENABLE );
// }
// ifbp->IFB_DSLinkStat &= ~( CFG_LINK_STAT_DS_IR | CFG_LINK_STAT_DS_OOR); //clear IR/OOR state
ltv.typ = CFG_DDS_TICK_TIME;
ltv.tick_time = ( ( ifbp->IFB_DSLinkStat & CFG_LINK_STAT_TIMER ) + 0x10 ) *64; //78 is more right
hcf_put_info( ifbp, (LTVP)<v );
- printk( "<5>Preparing for sleep, link_status: %04X, timer : %d\n",
+ printk(KERN_NOTICE "Preparing for sleep, link_status: %04X, timer : %d\n",
ifbp->IFB_DSLinkStat, ltv.tick_time );//;?remove me 1 day
ifbp->IFB_TickCnt++; //;?just to make sure we do not keep on printing above message
if ( ltv.tick_time < 300 * 125 ) ifbp->IFB_DSLinkStat += 0x0010;
// /*4*/ if ( info[1] == CFG_LINK_STAT ) {
// ifbp->IFB_DSLinkStat = IPW( HREG_DATA_1 ) | CFG_LINK_STAT_CHANGE; //corrupts BAP !! ;?
// ifbp->IFB_LinkStat = ifbp->IFB_DSLinkStat & CFG_LINK_STAT_FW; //;? to be obsoleted
-// printk( "<4>linkstatus: %04x\n", ifbp->IFB_DSLinkStat ); //;?remove me 1 day
+// printk(KERN_ERR "linkstatus: %04x\n", ifbp->IFB_DSLinkStat ); //;?remove me 1 day
// #if (HCF_SLEEP) & HCF_DDS
// if ( ( ifbp->IFB_DSLinkStat & CFG_LINK_STAT_CONNECTED ) == 0 ) { //even values are disconnected etc.
// ifbp->IFB_TickCnt = 0; //start 2 second period (with 1 tick uncertanty)
-// printk( "<5>isr_info: AwaitConnection phase started, IFB_TickCnt = 0\n" ); //;?remove me 1 day
+// printk(KERN_NOTICE "isr_info: AwaitConnection phase started, IFB_TickCnt = 0\n" ); //;?remove me 1 day
// }
// #endif // HCF_DDS
// }
lp->timer_oor.data = (unsigned long)lp;
lp->timer_oor.expires = RUN_AT( 3 * HZ );
add_timer( &lp->timer_oor );
- printk( "<5>wl_enable: %ld\n", jiffies ); //;?remove me 1 day
+ printk(KERN_NOTICE "wl_enable: %ld\n", jiffies ); //;?remove me 1 day
#endif //DN554
#ifdef DN554
/*******************************************************************************
DBG_ENTER( DbgInfo );
DBG_PARAM( DbgInfo, "arg", "0x%08lx", arg );
- printk( "<5>timer_oor: %ld 0x%04X\n", jiffies, lp->timer_oor_cnt ); //;?remove me 1 day
+ printk(KERN_NOTICE "timer_oor: %ld 0x%04X\n", jiffies, lp->timer_oor_cnt ); //;?remove me 1 day
lp->timer_oor_cnt += 10;
if ( (lp->timer_oor_cnt & ~DS_OOR) > 300 ) {
lp->timer_oor_cnt = 300;
}
/* Set Operation mode to the PORT TYPE RID */
- result = prism2_domibset_uint32(wlandev, DIDmib_p2_p2Static_p2CnfPortType, data);
+ result = prism2_domibset_uint32(wlandev,
+ DIDmib_p2_p2Static_p2CnfPortType,
+ data);
if (result)
err = -EFAULT;
if (request->n_ssids > 0) {
msg1.scantype.data = P80211ENUM_scantype_active;
msg1.ssid.data.len = request->ssids->ssid_len;
- memcpy(msg1.ssid.data.data, request->ssids->ssid, request->ssids->ssid_len);
+ memcpy(msg1.ssid.data.data,
+ request->ssids->ssid, request->ssids->ssid_len);
} else {
msg1.scantype.data = 0;
}
goto exit;
}
- result = prism2_domibset_pstr32(wlandev, did, sme->key_len, (u8 *) sme->key);
+ result = prism2_domibset_pstr32(wlandev,
+ did, sme->key_len,
+ (u8 *)sme->key);
if (result)
goto exit;
struct prism2_wiphy_private *priv = wiphy_priv(wiphy);
wlandevice_t *wlandev = priv->wlandev;
struct p80211msg_dot11req_mibget msg;
- p80211item_uint32_t *mibitem = (p80211item_uint32_t *) &msg.mibattribute.data;
+ p80211item_uint32_t *mibitem;
int result;
int err = 0;
+ mibitem = (p80211item_uint32_t *) &msg.mibattribute.data;
msg.msgcode = DIDmsg_dot11req_mibget;
mibitem->did =
DIDmib_dot11phy_dot11PhyTxPowerTable_dot11CurrentTxPowerLevel;
/* Interface callback functions, passing data back up to the cfg80211 layer */
void prism2_connect_result(wlandevice_t *wlandev, u8 failed)
{
- u16 status = failed ? WLAN_STATUS_UNSPECIFIED_FAILURE : WLAN_STATUS_SUCCESS;
+ u16 status = failed ?
+ WLAN_STATUS_UNSPECIFIED_FAILURE : WLAN_STATUS_SUCCESS;
cfg80211_connect_result(wlandev->netdev, wlandev->bssid,
NULL, 0, NULL, 0, status, GFP_KERNEL);
{
struct wiphy *wiphy;
struct prism2_wiphy_private *priv;
- wiphy = wiphy_new(&prism2_usb_cfg_ops, sizeof(struct prism2_wiphy_private));
+
+ wiphy = wiphy_new(&prism2_usb_cfg_ops, sizeof(*priv));
if (!wiphy)
return NULL;
static int mkpdrlist(struct pda *pda);
static int plugimage(struct imgchunk *fchunk, unsigned int nfchunks,
- struct s3plugrec *s3plug, unsigned int ns3plug, struct pda * pda);
+ struct s3plugrec *s3plug, unsigned int ns3plug, struct pda *pda);
static int crcimage(struct imgchunk *fchunk, unsigned int nfchunks,
struct s3crcrec *s3crc, unsigned int ns3crc);
printk(KERN_INFO "prism2_usb: Checking for firmware %s\n",
PRISM2_USB_FWFILE);
- if (request_ihex_firmware(&fw_entry, PRISM2_USB_FWFILE, &udev->dev) != 0) {
+ if (request_ihex_firmware(&fw_entry,
+ PRISM2_USB_FWFILE, &udev->dev) != 0) {
printk(KERN_INFO
"prism2_usb: Firmware not available, but not essential\n");
printk(KERN_INFO
le16_to_cpu(pda16[curroff + 1]) != HFA384x_PDR_END_OF_PDA) {
pda->rec[pda->nrec] = (hfa384x_pdrec_t *) &(pda16[curroff]);
- if (le16_to_cpu(pda->rec[pda->nrec]->code) == HFA384x_PDR_NICID) {
+ if (le16_to_cpu(pda->rec[pda->nrec]->code) ==
+ HFA384x_PDR_NICID) {
memcpy(&nicid, &pda->rec[pda->nrec]->data.nicid,
sizeof(nicid));
nicid.id = le16_to_cpu(nicid.id);
* ~0 failure
----------------------------------------------------------------*/
int plugimage(struct imgchunk *fchunk, unsigned int nfchunks,
- struct s3plugrec *s3plug, unsigned int ns3plug, struct pda * pda)
+ struct s3plugrec *s3plug, unsigned int ns3plug, struct pda *pda)
{
int result = 0;
int i; /* plug index */
unsigned int nfchunks)
{
int result = 0;
- struct p80211msg_p2req_ramdl_state rstatemsg;
- struct p80211msg_p2req_ramdl_write rwritemsg;
- struct p80211msg *msgp;
+ struct p80211msg_p2req_ramdl_state *rstmsg;
+ struct p80211msg_p2req_ramdl_write *rwrmsg;
u32 resultcode;
int i;
int j;
u32 currlen;
u32 currdaddr;
+ rstmsg = kmalloc(sizeof(*rstmsg), GFP_KERNEL);
+ rwrmsg = kmalloc(sizeof(*rwrmsg), GFP_KERNEL);
+ if (!rstmsg || !rwrmsg) {
+ kfree(rstmsg);
+ kfree(rwrmsg);
+ printk(KERN_ERR
+ "writeimage: no memory for firmware download, "
+ "aborting download\n");
+ return -ENOMEM;
+ }
+
/* Initialize the messages */
- memset(&rstatemsg, 0, sizeof(rstatemsg));
- strcpy(rstatemsg.devname, wlandev->name);
- rstatemsg.msgcode = DIDmsg_p2req_ramdl_state;
- rstatemsg.msglen = sizeof(rstatemsg);
- rstatemsg.enable.did = DIDmsg_p2req_ramdl_state_enable;
- rstatemsg.exeaddr.did = DIDmsg_p2req_ramdl_state_exeaddr;
- rstatemsg.resultcode.did = DIDmsg_p2req_ramdl_state_resultcode;
- rstatemsg.enable.status = P80211ENUM_msgitem_status_data_ok;
- rstatemsg.exeaddr.status = P80211ENUM_msgitem_status_data_ok;
- rstatemsg.resultcode.status = P80211ENUM_msgitem_status_no_value;
- rstatemsg.enable.len = sizeof(u32);
- rstatemsg.exeaddr.len = sizeof(u32);
- rstatemsg.resultcode.len = sizeof(u32);
-
- memset(&rwritemsg, 0, sizeof(rwritemsg));
- strcpy(rwritemsg.devname, wlandev->name);
- rwritemsg.msgcode = DIDmsg_p2req_ramdl_write;
- rwritemsg.msglen = sizeof(rwritemsg);
- rwritemsg.addr.did = DIDmsg_p2req_ramdl_write_addr;
- rwritemsg.len.did = DIDmsg_p2req_ramdl_write_len;
- rwritemsg.data.did = DIDmsg_p2req_ramdl_write_data;
- rwritemsg.resultcode.did = DIDmsg_p2req_ramdl_write_resultcode;
- rwritemsg.addr.status = P80211ENUM_msgitem_status_data_ok;
- rwritemsg.len.status = P80211ENUM_msgitem_status_data_ok;
- rwritemsg.data.status = P80211ENUM_msgitem_status_data_ok;
- rwritemsg.resultcode.status = P80211ENUM_msgitem_status_no_value;
- rwritemsg.addr.len = sizeof(u32);
- rwritemsg.len.len = sizeof(u32);
- rwritemsg.data.len = WRITESIZE_MAX;
- rwritemsg.resultcode.len = sizeof(u32);
+ memset(rstmsg, 0, sizeof(*rstmsg));
+ strcpy(rstmsg->devname, wlandev->name);
+ rstmsg->msgcode = DIDmsg_p2req_ramdl_state;
+ rstmsg->msglen = sizeof(*rstmsg);
+ rstmsg->enable.did = DIDmsg_p2req_ramdl_state_enable;
+ rstmsg->exeaddr.did = DIDmsg_p2req_ramdl_state_exeaddr;
+ rstmsg->resultcode.did = DIDmsg_p2req_ramdl_state_resultcode;
+ rstmsg->enable.status = P80211ENUM_msgitem_status_data_ok;
+ rstmsg->exeaddr.status = P80211ENUM_msgitem_status_data_ok;
+ rstmsg->resultcode.status = P80211ENUM_msgitem_status_no_value;
+ rstmsg->enable.len = sizeof(u32);
+ rstmsg->exeaddr.len = sizeof(u32);
+ rstmsg->resultcode.len = sizeof(u32);
+
+ memset(rwrmsg, 0, sizeof(*rwrmsg));
+ strcpy(rwrmsg->devname, wlandev->name);
+ rwrmsg->msgcode = DIDmsg_p2req_ramdl_write;
+ rwrmsg->msglen = sizeof(*rwrmsg);
+ rwrmsg->addr.did = DIDmsg_p2req_ramdl_write_addr;
+ rwrmsg->len.did = DIDmsg_p2req_ramdl_write_len;
+ rwrmsg->data.did = DIDmsg_p2req_ramdl_write_data;
+ rwrmsg->resultcode.did = DIDmsg_p2req_ramdl_write_resultcode;
+ rwrmsg->addr.status = P80211ENUM_msgitem_status_data_ok;
+ rwrmsg->len.status = P80211ENUM_msgitem_status_data_ok;
+ rwrmsg->data.status = P80211ENUM_msgitem_status_data_ok;
+ rwrmsg->resultcode.status = P80211ENUM_msgitem_status_no_value;
+ rwrmsg->addr.len = sizeof(u32);
+ rwrmsg->len.len = sizeof(u32);
+ rwrmsg->data.len = WRITESIZE_MAX;
+ rwrmsg->resultcode.len = sizeof(u32);
/* Send xxx_state(enable) */
pr_debug("Sending dl_state(enable) message.\n");
- rstatemsg.enable.data = P80211ENUM_truth_true;
- rstatemsg.exeaddr.data = startaddr;
+ rstmsg->enable.data = P80211ENUM_truth_true;
+ rstmsg->exeaddr.data = startaddr;
- msgp = (struct p80211msg *) &rstatemsg;
- result = prism2mgmt_ramdl_state(wlandev, msgp);
+ result = prism2mgmt_ramdl_state(wlandev, rstmsg);
if (result) {
printk(KERN_ERR
"writeimage state enable failed w/ result=%d, "
"aborting download\n", result);
- return result;
+ goto free_result;
}
- resultcode = rstatemsg.resultcode.data;
+ resultcode = rstmsg->resultcode.data;
if (resultcode != P80211ENUM_resultcode_success) {
printk(KERN_ERR
"writeimage()->xxxdl_state msg indicates failure, "
"w/ resultcode=%d, aborting download.\n", resultcode);
- return 1;
+ result = 1;
+ goto free_result;
}
/* Now, loop through the data chunks and send WRITESIZE_MAX data */
curroff = j * WRITESIZE_MAX;
currdaddr = fchunk[i].addr + curroff;
/* Setup the message */
- rwritemsg.addr.data = currdaddr;
- rwritemsg.len.data = currlen;
- memcpy(rwritemsg.data.data,
+ rwrmsg->addr.data = currdaddr;
+ rwrmsg->len.data = currlen;
+ memcpy(rwrmsg->data.data,
fchunk[i].data + curroff, currlen);
/* Send flashdl_write(pda) */
("Sending xxxdl_write message addr=%06x len=%d.\n",
currdaddr, currlen);
- msgp = (struct p80211msg *) &rwritemsg;
- result = prism2mgmt_ramdl_write(wlandev, msgp);
+ result = prism2mgmt_ramdl_write(wlandev, rwrmsg);
/* Check the results */
if (result) {
printk(KERN_ERR
"writeimage chunk write failed w/ result=%d, "
"aborting download\n", result);
- return result;
+ goto free_result;
}
- resultcode = rstatemsg.resultcode.data;
+ resultcode = rstmsg->resultcode.data;
if (resultcode != P80211ENUM_resultcode_success) {
printk(KERN_ERR
"writeimage()->xxxdl_write msg indicates failure, "
"w/ resultcode=%d, aborting download.\n",
resultcode);
- return 1;
+ result = 1;
+ goto free_result;
}
}
/* Send xxx_state(disable) */
pr_debug("Sending dl_state(disable) message.\n");
- rstatemsg.enable.data = P80211ENUM_truth_false;
- rstatemsg.exeaddr.data = 0;
+ rstmsg->enable.data = P80211ENUM_truth_false;
+ rstmsg->exeaddr.data = 0;
- msgp = (struct p80211msg *) &rstatemsg;
- result = prism2mgmt_ramdl_state(wlandev, msgp);
+ result = prism2mgmt_ramdl_state(wlandev, rstmsg);
if (result) {
printk(KERN_ERR
"writeimage state disable failed w/ result=%d, "
"aborting download\n", result);
- return result;
+ goto free_result;
}
- resultcode = rstatemsg.resultcode.data;
+ resultcode = rstmsg->resultcode.data;
if (resultcode != P80211ENUM_resultcode_success) {
printk(KERN_ERR
"writeimage()->xxxdl_state msg indicates failure, "
"w/ resultcode=%d, aborting download.\n", resultcode);
- return 1;
+ result = 1;
+ goto free_result;
}
+
+free_result:
+ kfree(rstmsg);
+ kfree(rwrmsg);
return result;
}
#ifndef _XGIFB_MAIN
#define _XGIFB_MAIN
-
-
/* ------------------- Constant Definitions ------------------------- */
-
-
#include "XGIfb.h"
-#include "vb_struct.h"
-#include "../../video/sis/sis.h"
#include "vb_def.h"
-#define XGIFAIL(x) do { printk(x "\n"); return -EINVAL; } while (0)
-
#ifndef PCI_DEVICE_ID_XGI_42
#define PCI_DEVICE_ID_XGI_42 0x042
#endif
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
-/* #include <linux/config.h> */
#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/kernel.h>
-#include <linux/spinlock.h>
-#include <linux/errno.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/tty.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-#include <linux/fb.h>
-#include <linux/console.h>
-#include <linux/selection.h>
-#include <linux/ioport.h>
-#include <linux/init.h>
-#include <linux/pci.h>
-#include <linux/vt_kern.h>
-#include <linux/capability.h>
-#include <linux/fs.h>
-#include <linux/types.h>
-#include <linux/proc_fs.h>
-
-#include <linux/io.h>
+
#ifdef CONFIG_MTRR
#include <asm/mtrr.h>
#endif
-#include "XGIfb.h"
-#include "vgatypes.h"
#include "XGI_main.h"
#include "vb_init.h"
#include "vb_util.h"
/* -------------------- Macro definitions ---------------------------- */
-#undef XGIFBDEBUG
-
-#ifdef XGIFBDEBUG
-#define DPRINTK(fmt, args...) pr_debug("%s: " fmt, __func__ , ## args)
-#else
-#define DPRINTK(fmt, args...)
-#endif
-
-#ifdef XGIFBDEBUG
+#ifdef DEBUG
static void dumpVGAReg(void)
{
u8 i, reg;
for (i = 0; i < 0x4f; i++) {
reg = xgifb_reg_get(XGISR, i);
- printk("\no 3c4 %x", i);
- printk("\ni 3c5 => %x", reg);
+ pr_debug("\no 3c4 %x", i);
+ pr_debug("\ni 3c5 => %x", reg);
}
for (i = 0; i < 0xF0; i++) {
reg = xgifb_reg_get(XGICR, i);
- printk("\no 3d4 %x", i);
- printk("\ni 3d5 => %x", reg);
+ pr_debug("\no 3d4 %x", i);
+ pr_debug("\ni 3d5 => %x", reg);
}
/*
xgifb_reg_set(XGIPART1,0x2F,1);
for (i=1; i < 0x50; i++) {
reg = xgifb_reg_get(XGIPART1, i);
- printk("\no d004 %x", i);
- printk("\ni d005 => %x", reg);
+ pr_debug("\no d004 %x", i);
+ pr_debug("\ni d005 => %x", reg);
}
for (i=0; i < 0x50; i++) {
reg = xgifb_reg_get(XGIPART2, i);
- printk("\no d010 %x", i);
- printk("\ni d011 => %x", reg);
+ pr_debug("\no d010 %x", i);
+ pr_debug("\ni d011 => %x", reg);
}
for (i=0; i < 0x50; i++) {
reg = xgifb_reg_get(XGIPART3, i);
- printk("\no d012 %x",i);
- printk("\ni d013 => %x",reg);
+ pr_debug("\no d012 %x",i);
+ pr_debug("\ni d013 => %x",reg);
}
for (i=0; i < 0x50; i++) {
reg = xgifb_reg_get(XGIPART4, i);
- printk("\no d014 %x",i);
- printk("\ni d015 => %x",reg);
+ pr_debug("\no d014 %x",i);
+ pr_debug("\ni d015 => %x",reg);
}
*/
}
}
#endif
-#if 1
-#define DEBUGPRN(x)
-#else
-#define DEBUGPRN(x) pr_info(x "\n");
-#endif
-
/* --------------- Hardware Access Routines -------------------------- */
static int XGIfb_mode_rate_to_dclock(struct vb_device_info *XGI_Pr,
break;
} else if (XGIfb_vrate[i].refresh > rate) {
if ((XGIfb_vrate[i].refresh - rate) <= 3) {
- DPRINTK("XGIfb: Adjusting rate from %d up to %d\n",
- rate, XGIfb_vrate[i].refresh);
+ pr_debug("XGIfb: Adjusting rate from %d up to %d\n",
+ rate, XGIfb_vrate[i].refresh);
xgifb_info->rate_idx =
XGIfb_vrate[i].idx;
xgifb_info->refresh_rate =
} else if (((rate - XGIfb_vrate[i - 1].refresh)
<= 2) && (XGIfb_vrate[i].idx
!= 1)) {
- DPRINTK("XGIfb: Adjusting rate from %d down to %d\n",
- rate, XGIfb_vrate[i-1].refresh);
+ pr_debug("XGIfb: Adjusting rate from %d down to %d\n",
+ rate, XGIfb_vrate[i-1].refresh);
xgifb_info->rate_idx =
XGIfb_vrate[i - 1].idx;
xgifb_info->refresh_rate =
}
break;
} else if ((rate - XGIfb_vrate[i].refresh) <= 2) {
- DPRINTK("XGIfb: Adjusting rate from %d down to %d\n",
- rate, XGIfb_vrate[i].refresh);
+ pr_debug("XGIfb: Adjusting rate from %d down to %d\n",
+ rate, XGIfb_vrate[i].refresh);
xgifb_info->rate_idx = XGIfb_vrate[i].idx;
break;
}
}
if ((filter >= 0) && (filter <= 7)) {
- DPRINTK("FilterTable[%d]-%d: %02x %02x %02x %02x\n",
- filter_tb, filter,
- XGI_TV_filter[filter_tb].
+ pr_debug("FilterTable[%d]-%d: %02x %02x %02x %02x\n",
+ filter_tb, filter,
+ XGI_TV_filter[filter_tb].
filter[filter][0],
- XGI_TV_filter[filter_tb].
+ XGI_TV_filter[filter_tb].
filter[filter][1],
- XGI_TV_filter[filter_tb].
+ XGI_TV_filter[filter_tb].
filter[filter][2],
- XGI_TV_filter[filter_tb].
+ XGI_TV_filter[filter_tb].
filter[filter][3]
);
xgifb_reg_set(
int old_mode;
/* unsigned char reg, reg1; */
- DEBUGPRN("Inside do_set_var");
- /* printk(KERN_DEBUG "XGIfb:var->yres=%d, var->upper_margin=%d, var->lower_margin=%d, var->vsync_len=%d\n", var->yres, var->upper_margin, var->lower_margin, var->vsync_len); */
-
info->var.xres_virtual = var->xres_virtual;
info->var.yres_virtual = var->yres_virtual;
info->var.bits_per_pixel = var->bits_per_pixel;
}
if (!htotal || !vtotal) {
- DPRINTK("XGIfb: Invalid 'var' information\n");
+ pr_debug("XGIfb: Invalid 'var' information\n");
return -EINVAL;
} pr_debug("var->pixclock=%d, htotal=%d, vtotal=%d\n",
var->pixclock, htotal, vtotal);
XGIfb_post_setmode(xgifb_info);
- DPRINTK("XGIfb: Set new mode: %dx%dx%d-%d\n",
- XGIbios_mode[xgifb_info->mode_idx].xres,
- XGIbios_mode[xgifb_info->mode_idx].yres,
- XGIbios_mode[xgifb_info->mode_idx].bpp,
- xgifb_info->refresh_rate);
+ pr_debug("XGIfb: Set new mode: %dx%dx%d-%d\n",
+ XGIbios_mode[xgifb_info->mode_idx].xres,
+ XGIbios_mode[xgifb_info->mode_idx].yres,
+ XGIbios_mode[xgifb_info->mode_idx].bpp,
+ xgifb_info->refresh_rate);
xgifb_info->video_bpp = XGIbios_mode[xgifb_info->mode_idx].bpp;
xgifb_info->video_vwidth = info->var.xres_virtual;
}
}
XGIfb_bpp_to_var(xgifb_info, var); /*update ARGB info*/
- DEBUGPRN("End of do_set_var");
dumpVGAReg();
return 0;
struct xgifb_video_info *xgifb_info = info->par;
unsigned int base;
- /* printk("Inside pan_var"); */
-
base = var->yoffset * info->var.xres_virtual + var->xoffset;
/* calculate base bpp dep. */
0x7F,
((base >> 24) & 0x01) << 7);
}
- /* printk("End of pan_var"); */
return 0;
}
{
struct xgifb_video_info *xgifb_info = info->par;
- DEBUGPRN("inside get_fix");
memset(fix, 0, sizeof(struct fb_fix_screeninfo));
- fix->smem_start = xgifb_info->video_base;
+ strncpy(fix->id, "XGI", sizeof(fix->id) - 1);
+ /* if register_framebuffer has been called, we must lock */
+ if (atomic_read(&info->count))
+ mutex_lock(&info->mm_lock);
+
+ fix->smem_start = xgifb_info->video_base;
fix->smem_len = xgifb_info->video_size;
+ /* if register_framebuffer has been called, we can unlock */
+ if (atomic_read(&info->count))
+ mutex_unlock(&info->mm_lock);
+
fix->type = FB_TYPE_PACKED_PIXELS;
fix->type_aux = 0;
if (xgifb_info->video_bpp == 8)
fix->mmio_len = xgifb_info->mmio_size;
fix->accel = FB_ACCEL_SIS_XABRE;
- DEBUGPRN("end of get_fix");
return 0;
}
{
int err;
- /* printk("XGIfb: inside set_par\n"); */
err = XGIfb_do_set_var(&info->var, 1, info);
if (err)
return err;
XGIfb_get_fix(&info->fix, -1, info);
- /* printk("XGIfb: end of set_par\n"); */
return 0;
}
int found_mode = 0;
int refresh_rate, search_idx;
- DEBUGPRN("Inside check_var");
-
if ((var->vmode & FB_VMODE_MASK) == FB_VMODE_NONINTERLACED) {
vtotal = var->upper_margin + var->yres + var->lower_margin
+ var->vsync_len;
vtotal = var->upper_margin + var->yres + var->lower_margin
+ var->vsync_len;
- if (!(htotal) || !(vtotal))
- XGIFAIL("XGIfb: no valid timing data");
+ if (!(htotal) || !(vtotal)) {
+ pr_debug("XGIfb: no valid timing data\n");
+ return -EINVAL;
+ }
if (var->pixclock && htotal && vtotal) {
drate = 1000000000 / var->pixclock;
var->blue.msb_right =
var->transp.offset = var->transp.length = var->transp.msb_right = 0;
- DEBUGPRN("end of check_var");
return 0;
}
{
int err;
- /* printk("\nInside pan_display:\n"); */
-
if (var->xoffset > (info->var.xres_virtual - info->var.xres))
return -EINVAL;
if (var->yoffset > (info->var.yres_virtual - info->var.yres))
else
info->var.vmode &= ~FB_VMODE_YWRAP;
- /* printk("End of pan_display\n"); */
return 0;
}
xgifb_info->mmio_base = pci_resource_start(pdev, 1);
xgifb_info->mmio_size = pci_resource_len(pdev, 1);
xgifb_info->vga_base = pci_resource_start(pdev, 2) + 0x30;
- pr_info("Relocate IO address: %Lx [%08lx]\n",
- (u64) pci_resource_start(pdev, 2),
- xgifb_info->vga_base);
+ dev_info(&pdev->dev, "Relocate IO address: %Lx [%08lx]\n",
+ (u64) pci_resource_start(pdev, 2),
+ xgifb_info->vga_base);
if (pci_enable_device(pdev)) {
ret = -EIO;
reg1 = xgifb_reg_get(XGISR, IND_SIS_PASSWORD);
if (reg1 != 0xa1) { /*I/O error */
- pr_err("I/O error!!!");
+ dev_err(&pdev->dev, "I/O error!!!");
ret = -EIO;
- goto error;
+ goto error_disable;
}
switch (xgifb_info->chip_id) {
break;
default:
ret = -ENODEV;
- goto error;
+ goto error_disable;
}
- pr_info("chipid = %x\n", xgifb_info->chip);
+ dev_info(&pdev->dev, "chipid = %x\n", xgifb_info->chip);
hw_info->jChipType = xgifb_info->chip;
if (XGIfb_get_dram_size(xgifb_info)) {
- pr_err("Fatal error: Unable to determine RAM size.\n");
+ dev_err(&pdev->dev,
+ "Fatal error: Unable to determine RAM size.\n");
ret = -ENODEV;
- goto error;
+ goto error_disable;
}
/* Enable PCI_LINEAR_ADDRESSING and MMIO_ENABLE */
if (!request_mem_region(xgifb_info->video_base,
xgifb_info->video_size,
"XGIfb FB")) {
- pr_err("unable request memory size %x\n",
+ dev_err(&pdev->dev, "unable request memory size %x\n",
xgifb_info->video_size);
- pr_err("Fatal error: Unable to reserve frame buffer memory\n");
- pr_err("Is there another framebuffer driver active?\n");
+ dev_err(&pdev->dev,
+ "Fatal error: Unable to reserve frame buffer memory. "
+ "Is there another framebuffer driver active?\n");
ret = -ENODEV;
- goto error;
+ goto error_disable;
}
if (!request_mem_region(xgifb_info->mmio_base,
xgifb_info->mmio_size,
"XGIfb MMIO")) {
- pr_err("Fatal error: Unable to reserve MMIO region\n");
+ dev_err(&pdev->dev,
+ "Fatal error: Unable to reserve MMIO region\n");
ret = -ENODEV;
goto error_0;
}
xgifb_info->mmio_vbase = ioremap(xgifb_info->mmio_base,
xgifb_info->mmio_size);
- pr_info("Framebuffer at 0x%Lx, mapped to 0x%p, size %dk\n",
- (u64) xgifb_info->video_base,
- xgifb_info->video_vbase,
- xgifb_info->video_size / 1024);
+ dev_info(&pdev->dev,
+ "Framebuffer at 0x%Lx, mapped to 0x%p, size %dk\n",
+ (u64) xgifb_info->video_base,
+ xgifb_info->video_vbase,
+ xgifb_info->video_size / 1024);
- pr_info("MMIO at 0x%Lx, mapped to 0x%p, size %ldk\n",
- (u64) xgifb_info->mmio_base, xgifb_info->mmio_vbase,
- xgifb_info->mmio_size / 1024);
+ dev_info(&pdev->dev,
+ "MMIO at 0x%Lx, mapped to 0x%p, size %ldk\n",
+ (u64) xgifb_info->mmio_base, xgifb_info->mmio_vbase,
+ xgifb_info->mmio_size / 1024);
pci_set_drvdata(pdev, xgifb_info);
if (!XGIInitNew(pdev))
- pr_err("XGIInitNew() failed!\n");
+ dev_err(&pdev->dev, "XGIInitNew() failed!\n");
xgifb_info->mtrr = (unsigned int) 0;
reg = xgifb_reg_get(XGIPART4, 0x01);
if (reg >= 0xE0) {
hw_info->ujVBChipID = VB_CHIP_302LV;
- pr_info("XGI302LV bridge detected (revision 0x%02x)\n", reg);
+ dev_info(&pdev->dev,
+ "XGI302LV bridge detected (revision 0x%02x)\n",
+ reg);
} else if (reg >= 0xD0) {
hw_info->ujVBChipID = VB_CHIP_301LV;
- pr_info("XGI301LV bridge detected (revision 0x%02x)\n", reg);
+ dev_info(&pdev->dev,
+ "XGI301LV bridge detected (revision 0x%02x)\n",
+ reg);
}
/* else if (reg >= 0xB0) {
hw_info->ujVBChipID = VB_CHIP_301B;
reg1 = xgifb_reg_get(XGIPART4, 0x23);
- printk("XGIfb: XGI301B bridge detected\n");
+ pr_debug("XGIfb: XGI301B bridge detected\n");
} */
else {
hw_info->ujVBChipID = VB_CHIP_301;
- pr_info("XGI301 bridge detected\n");
+ dev_info(&pdev->dev, "XGI301 bridge detected\n");
}
break;
case HASVB_302:
reg = xgifb_reg_get(XGIPART4, 0x01);
if (reg >= 0xE0) {
hw_info->ujVBChipID = VB_CHIP_302LV;
- pr_info("XGI302LV bridge detected (revision 0x%02x)\n", reg);
+ dev_info(&pdev->dev,
+ "XGI302LV bridge detected (revision 0x%02x)\n",
+ reg);
} else if (reg >= 0xD0) {
hw_info->ujVBChipID = VB_CHIP_301LV;
- pr_info("XGI302LV bridge detected (revision 0x%02x)\n", reg);
+ dev_info(&pdev->dev,
+ "XGI302LV bridge detected (revision 0x%02x)\n",
+ reg);
} else if (reg >= 0xB0) {
reg1 = xgifb_reg_get(XGIPART4, 0x23);
} else {
hw_info->ujVBChipID = VB_CHIP_302;
- pr_info("XGI302 bridge detected\n");
+ dev_info(&pdev->dev, "XGI302 bridge detected\n");
}
break;
case HASVB_LVDS:
hw_info->ulExternalChip = 0x1;
- pr_info("LVDS transmitter detected\n");
+ dev_info(&pdev->dev, "LVDS transmitter detected\n");
break;
case HASVB_TRUMPION:
hw_info->ulExternalChip = 0x2;
- pr_info("Trumpion Zurac LVDS scaler detected\n");
+ dev_info(&pdev->dev, "Trumpion Zurac LVDS scaler detected\n");
break;
case HASVB_CHRONTEL:
hw_info->ulExternalChip = 0x4;
- pr_info("Chrontel TV encoder detected\n");
+ dev_info(&pdev->dev, "Chrontel TV encoder detected\n");
break;
case HASVB_LVDS_CHRONTEL:
hw_info->ulExternalChip = 0x5;
- pr_info("LVDS transmitter and Chrontel TV encoder detected\n");
+ dev_info(&pdev->dev,
+ "LVDS transmitter and Chrontel TV encoder detected\n");
break;
default:
- pr_info("No or unknown bridge type detected\n");
+ dev_info(&pdev->dev, "No or unknown bridge type detected\n");
break;
}
}
- strncpy(fb_info->fix.id, "XGI", sizeof(fb_info->fix.id) - 1);
- fb_info->fix.type = FB_TYPE_PACKED_PIXELS;
- fb_info->fix.xpanstep = 1;
- fb_info->fix.ypanstep = 1;
-
fb_info->flags = FBINFO_FLAG_DEFAULT;
fb_info->screen_base = xgifb_info->video_vbase;
fb_info->fbops = &XGIfb_ops;
release_mem_region(xgifb_info->mmio_base, xgifb_info->mmio_size);
error_0:
release_mem_region(xgifb_info->video_base, xgifb_info->video_size);
+error_disable:
+ pci_disable_device(pdev);
error:
framebuffer_release(fb_info);
return ret;
iounmap(xgifb_info->video_vbase);
release_mem_region(xgifb_info->mmio_base, xgifb_info->mmio_size);
release_mem_region(xgifb_info->video_base, xgifb_info->video_size);
+ pci_disable_device(pdev);
framebuffer_release(fb_info);
pci_set_drvdata(pdev, NULL);
}
.remove = __devexit_p(xgifb_remove)
};
-static int __init xgifb_init(void)
-{
- char *option = NULL;
-
- if (forcecrt2type != NULL)
- XGIfb_search_crt2type(forcecrt2type);
- if (fb_get_options("xgifb", &option))
- return -ENODEV;
- XGIfb_setup(option);
-
- return pci_register_driver(&xgifb_driver);
-}
-module_init(xgifb_init);
/*****************************************************/
/* MODULE */
/*****************************************************/
-#ifdef MODULE
-
-MODULE_DESCRIPTION("Z7 Z9 Z9S Z11 framebuffer device driver");
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("XGITECH , Others");
-
module_param(mode, charp, 0);
-module_param(vesa, int, 0);
-module_param(filter, int, 0);
-module_param(forcecrt2type, charp, 0);
+MODULE_PARM_DESC(mode,
+ "Selects the desired default display mode in the format XxYxDepth "
+ "(eg. 1024x768x16).");
+module_param(forcecrt2type, charp, 0);
MODULE_PARM_DESC(forcecrt2type,
- "\nForce the second display output type. Possible values are NONE,\n"
- "LCD, TV, VGA, SVIDEO or COMPOSITE.\n");
-
-MODULE_PARM_DESC(mode,
- "\nSelects the desired default display mode in the format XxYxDepth,\n"
- "eg. 1024x768x16.\n");
+ "Force the second display output type. Possible values are NONE, "
+ "LCD, TV, VGA, SVIDEO or COMPOSITE.");
+module_param(vesa, int, 0);
MODULE_PARM_DESC(vesa,
- "\nSelects the desired default display mode by VESA mode number, eg.\n"
- "0x117.\n");
+ "Selects the desired default display mode by VESA mode number "
+ "(eg. 0x117).");
+module_param(filter, int, 0);
MODULE_PARM_DESC(filter,
- "\nSelects TV flicker filter type (only for systems with a SiS301 video bridge).\n"
- "(Possible values 0-7, default: [no filter])\n");
+ "Selects TV flicker filter type (only for systems with a SiS301 video bridge). "
+ "Possible values 0-7. Default: [no filter]).");
+
+static int __init xgifb_init(void)
+{
+ char *option = NULL;
+
+ if (forcecrt2type != NULL)
+ XGIfb_search_crt2type(forcecrt2type);
+ if (fb_get_options("xgifb", &option))
+ return -ENODEV;
+ XGIfb_setup(option);
+
+ return pci_register_driver(&xgifb_driver);
+}
static void __exit xgifb_remove_module(void)
{
pr_debug("Module unloaded\n");
}
+MODULE_DESCRIPTION("Z7 Z9 Z9S Z11 framebuffer device driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("XGITECH , Others");
+module_init(xgifb_init);
module_exit(xgifb_remove_module);
-
-#endif /* /MODULE */
#ifndef _LINUX_XGIFB
#define _LINUX_XGIFB
-#include <linux/ioctl.h>
-#include <linux/types.h>
-
#include "vgatypes.h"
#include "vb_struct.h"
#define RES1280x960x85 0x46
#define RES1280x960x120 0x47
+
+#define XG27_CR8F 0x0C
+#define XG27_SR36 0x30
+#define XG27_SR40 0x04
+#define XG27_SR41 0x00
+#define XG40_CRCF 0x13
+#define XGI330_CRT2Data_1_2 0
+#define XGI330_CRT2Data_4_D 0
+#define XGI330_CRT2Data_4_E 0
+#define XGI330_CRT2Data_4_10 0x80
+#define XGI330_SR07 0x18
+#define XGI330_SR1F 0
+#define XGI330_SR23 0xf6
+#define XGI330_SR24 0x0d
+#define XGI330_SR25 0
+#define XGI330_SR31 0xc0
+#define XGI330_SR32 0x11
+#define XGI330_SR33 0
+
#endif
-#include <linux/types.h>
#include <linux/delay.h> /* udelay */
-#include <linux/pci.h>
#include <linux/vmalloc.h>
#include "XGIfb.h"
-#include "vgatypes.h"
-
#include "vb_def.h"
-#include "vb_struct.h"
#include "vb_util.h"
#include "vb_setmode.h"
#include "vb_init.h"
-
-
-#include <linux/io.h>
-
-static const unsigned short XGINew_DDRDRAM_TYPE340[4][5] = {
- { 2, 13, 9, 64, 0x45},
- { 2, 12, 9, 32, 0x35},
- { 2, 12, 8, 16, 0x31},
- { 2, 11, 8, 8, 0x21} };
-
-static const unsigned short XGINew_DDRDRAM_TYPE20[12][5] = {
- { 2, 14, 11, 128, 0x5D},
- { 2, 14, 10, 64, 0x59},
- { 2, 13, 11, 64, 0x4D},
- { 2, 14, 9, 32, 0x55},
- { 2, 13, 10, 32, 0x49},
- { 2, 12, 11, 32, 0x3D},
- { 2, 14, 8, 16, 0x51},
- { 2, 13, 9, 16, 0x45},
- { 2, 12, 10, 16, 0x39},
- { 2, 13, 8, 8, 0x41},
- { 2, 12, 9, 8, 0x35},
- { 2, 12, 8, 4, 0x31} };
+static const unsigned short XGINew_DDRDRAM_TYPE340[4][2] = {
+ { 16, 0x45},
+ { 8, 0x35},
+ { 4, 0x31},
+ { 2, 0x21} };
+
+static const unsigned short XGINew_DDRDRAM_TYPE20[12][2] = {
+ { 128, 0x5D},
+ { 64, 0x59},
+ { 64, 0x4D},
+ { 32, 0x55},
+ { 32, 0x49},
+ { 32, 0x3D},
+ { 16, 0x51},
+ { 16, 0x45},
+ { 16, 0x39},
+ { 8, 0x41},
+ { 8, 0x35},
+ { 4, 0x31} };
#define XGIFB_ROM_SIZE 65536
unsigned char data, temp;
if (HwDeviceExtension->jChipType < XG20) {
- if (*pVBInfo->pSoftSetting & SoftDRAMType) {
- data = *pVBInfo->pSoftSetting & 0x07;
- return data;
- } else {
- data = xgifb_reg_get(pVBInfo->P3c4, 0x39) & 0x02;
- if (data == 0)
- data = (xgifb_reg_get(pVBInfo->P3c4, 0x3A) &
- 0x02) >> 1;
- return data;
- }
+ data = xgifb_reg_get(pVBInfo->P3c4, 0x39) & 0x02;
+ if (data == 0)
+ data = (xgifb_reg_get(pVBInfo->P3c4, 0x3A) &
+ 0x02) >> 1;
+ return data;
} else if (HwDeviceExtension->jChipType == XG27) {
- if (*pVBInfo->pSoftSetting & SoftDRAMType) {
- data = *pVBInfo->pSoftSetting & 0x07;
- return data;
- }
temp = xgifb_reg_get(pVBInfo->P3c4, 0x3B);
/* SR3B[7][3]MAA15 MAA11 (Power on Trapping) */
if (((temp & 0x88) == 0x80) || ((temp & 0x88) == 0x08))
xgifb_reg_set(P3c4, 0x16, 0x00);
xgifb_reg_set(P3c4, 0x16, 0x80);
- if (*pVBInfo->pXGINew_DRAMTypeDefinition != 0x0C) { /* Samsung F Die */
- mdelay(3);
- xgifb_reg_set(P3c4, 0x18, 0x00);
- xgifb_reg_set(P3c4, 0x19, 0x20);
- xgifb_reg_set(P3c4, 0x16, 0x00);
- xgifb_reg_set(P3c4, 0x16, 0x80);
- }
+ mdelay(3);
+ xgifb_reg_set(P3c4, 0x18, 0x00);
+ xgifb_reg_set(P3c4, 0x19, 0x20);
+ xgifb_reg_set(P3c4, 0x16, 0x00);
+ xgifb_reg_set(P3c4, 0x16, 0x80);
udelay(60);
xgifb_reg_set(P3c4,
/* Set Double Frequency */
/* xgifb_reg_set(P3d4, 0x97, 0x11); *//* CR97 */
- xgifb_reg_set(P3d4, 0x97, *pVBInfo->pXGINew_CR97); /* CR97 */
+ xgifb_reg_set(P3d4, 0x97, pVBInfo->XGINew_CR97); /* CR97 */
udelay(200);
pVBInfo->CR40[0][pVBInfo->ram_type]); /* CR41 */
if (HwDeviceExtension->jChipType == XG27)
- xgifb_reg_set(P3d4, 0x8F, *pVBInfo->pCR8F); /* CR8F */
+ xgifb_reg_set(P3d4, 0x8F, XG27_CR8F); /* CR8F */
for (j = 0; j <= 6; j++) /* CR90 - CR96 */
xgifb_reg_set(P3d4, (0x90 + j),
xgifb_reg_set(P3d4, 0x83, 0x09); /* CR83 */
xgifb_reg_set(P3d4, 0x87, 0x00); /* CR87 */
- xgifb_reg_set(P3d4, 0xCF, *pVBInfo->pCRCF); /* CRCF */
+ xgifb_reg_set(P3d4, 0xCF, XG40_CRCF); /* CRCF */
if (pVBInfo->ram_type) {
/* xgifb_reg_set(P3c4, 0x17, 0xC0); */ /* SR17 DDRII */
xgifb_reg_set(P3c4, 0x17, 0x80); /* SR17 DDRII */
pVBInfo->SR15[3][pVBInfo->ram_type]); /* SR1B */
}
-static void XGINew_SetDRAMSizingType(int index,
- const unsigned short DRAMTYPE_TABLE[][5],
- struct vb_device_info *pVBInfo)
-{
- unsigned short data;
-
- data = DRAMTYPE_TABLE[index][4];
- xgifb_reg_and_or(pVBInfo->P3c4, 0x13, 0x80, data);
- udelay(15);
- /* should delay 50 ns */
-}
-static unsigned short XGINew_SetDRAMSizeReg(int index,
- const unsigned short DRAMTYPE_TABLE[][5],
+static unsigned short XGINew_SetDRAMSize20Reg(
+ unsigned short dram_size,
struct vb_device_info *pVBInfo)
{
unsigned short data = 0, memsize = 0;
int RankSize;
unsigned char ChannelNo;
- RankSize = DRAMTYPE_TABLE[index][3] * pVBInfo->ram_bus / 32;
- data = xgifb_reg_get(pVBInfo->P3c4, 0x13);
- data &= 0x80;
-
- if (data == 0x80)
- RankSize *= 2;
-
- data = 0;
-
- if (pVBInfo->ram_channel == 3)
- ChannelNo = 4;
- else
- ChannelNo = pVBInfo->ram_channel;
-
- if (ChannelNo * RankSize <= 256) {
- while ((RankSize >>= 1) > 0)
- data += 0x10;
-
- memsize = data >> 4;
-
- /* [2004/03/25] Vicent, Fix DRAM Sizing Error */
- xgifb_reg_set(pVBInfo->P3c4,
- 0x14,
- (xgifb_reg_get(pVBInfo->P3c4, 0x14) & 0x0F) |
- (data & 0xF0));
-
- /* data |= pVBInfo->ram_channel << 2; */
- /* data |= (pVBInfo->ram_bus / 64) << 1; */
- /* xgifb_reg_set(pVBInfo->P3c4, 0x14, data); */
-
- /* should delay */
- /* XGINew_SetDRAMModeRegister340(pVBInfo); */
- }
- return memsize;
-}
-
-static unsigned short XGINew_SetDRAMSize20Reg(int index,
- const unsigned short DRAMTYPE_TABLE[][5],
- struct vb_device_info *pVBInfo)
-{
- unsigned short data = 0, memsize = 0;
- int RankSize;
- unsigned char ChannelNo;
-
- RankSize = DRAMTYPE_TABLE[index][3] * pVBInfo->ram_bus / 8;
+ RankSize = dram_size * pVBInfo->ram_bus / 8;
data = xgifb_reg_get(pVBInfo->P3c4, 0x13);
data &= 0x80;
static int XGINew_DDRSizing340(struct xgi_hw_device_info *HwDeviceExtension,
struct vb_device_info *pVBInfo)
{
- int i;
- unsigned short memsize, addr;
+ u8 i, size;
+ unsigned short memsize, start_addr;
+ const unsigned short (*dram_table)[2];
xgifb_reg_set(pVBInfo->P3c4, 0x15, 0x00); /* noninterleaving */
xgifb_reg_set(pVBInfo->P3c4, 0x1C, 0x00); /* nontiling */
XGINew_CheckChannel(HwDeviceExtension, pVBInfo);
if (HwDeviceExtension->jChipType >= XG20) {
- for (i = 0; i < 12; i++) {
- XGINew_SetDRAMSizingType(i,
- XGINew_DDRDRAM_TYPE20,
- pVBInfo);
- memsize = XGINew_SetDRAMSize20Reg(i,
- XGINew_DDRDRAM_TYPE20,
- pVBInfo);
- if (memsize == 0)
- continue;
-
- addr = memsize + (pVBInfo->ram_channel - 2) + 20;
- if ((HwDeviceExtension->ulVideoMemorySize - 1) <
- (unsigned long) (1 << addr))
- continue;
-
- if (XGINew_ReadWriteRest(addr, 5, pVBInfo) == 1)
- return 1;
- }
+ dram_table = XGINew_DDRDRAM_TYPE20;
+ size = ARRAY_SIZE(XGINew_DDRDRAM_TYPE20);
+ start_addr = 5;
} else {
- for (i = 0; i < 4; i++) {
- XGINew_SetDRAMSizingType(i,
- XGINew_DDRDRAM_TYPE340,
- pVBInfo);
- memsize = XGINew_SetDRAMSizeReg(i,
- XGINew_DDRDRAM_TYPE340,
- pVBInfo);
-
- if (memsize == 0)
- continue;
-
- addr = memsize + (pVBInfo->ram_channel - 2) + 20;
- if ((HwDeviceExtension->ulVideoMemorySize - 1) <
- (unsigned long) (1 << addr))
- continue;
-
- if (XGINew_ReadWriteRest(addr, 9, pVBInfo) == 1)
- return 1;
- }
+ dram_table = XGINew_DDRDRAM_TYPE340;
+ size = ARRAY_SIZE(XGINew_DDRDRAM_TYPE340);
+ start_addr = 9;
+ }
+
+ for (i = 0; i < size; i++) {
+ /* SetDRAMSizingType */
+ xgifb_reg_and_or(pVBInfo->P3c4, 0x13, 0x80, dram_table[i][1]);
+ udelay(15); /* should delay 50 ns */
+
+ memsize = XGINew_SetDRAMSize20Reg(dram_table[i][0], pVBInfo);
+
+ if (memsize == 0)
+ continue;
+
+ memsize += (pVBInfo->ram_channel - 2) + 20;
+ if ((HwDeviceExtension->ulVideoMemorySize - 1) <
+ (unsigned long) (1 << memsize))
+ continue;
+
+ if (XGINew_ReadWriteRest(memsize, start_addr, pVBInfo) == 1)
+ return 1;
}
return 0;
}
CR3CData = xgifb_reg_get(pVBInfo->P3d4, 0x3c);
if (!(CR3CData & DisplayDeviceFromCMOS)) {
tempcx = 0x1FF0;
- if (*pVBInfo->pSoftSetting & ModeSoftSetting)
- tempbx = 0x1FF0;
}
} else {
tempcx = 0x1FF0;
- if (*pVBInfo->pSoftSetting & ModeSoftSetting)
- tempbx = 0x1FF0;
}
tempbx &= tempcx;
/* Newdebugcode(0x99); */
if (pVBInfo->FBAddr == NULL) {
- printk("\n pVBInfo->FBAddr == 0 ");
+ dev_dbg(&pdev->dev, "pVBInfo->FBAddr == 0\n");
return 0;
}
- printk("1");
if (pVBInfo->BaseAddr == 0) {
- printk("\npVBInfo->BaseAddr == 0 ");
+ dev_dbg(&pdev->dev, "pVBInfo->BaseAddr == 0\n");
return 0;
}
- printk("2");
outb(0x67, (pVBInfo->BaseAddr + 0x12)); /* 3c2 <- 67 ,ynlai */
pVBInfo->ISXPDOS = 0;
- printk("3");
-
- printk("4");
/* VBIOSVersion[4] = 0x0; */
pVBInfo->Part3Port = pVBInfo->BaseAddr + SIS_CRT2_PORT_12;
pVBInfo->Part4Port = pVBInfo->BaseAddr + SIS_CRT2_PORT_14;
pVBInfo->Part5Port = pVBInfo->BaseAddr + SIS_CRT2_PORT_14 + 2;
- printk("5");
if (HwDeviceExtension->jChipType < XG20) /* kuku 2004/06/25 */
/* Run XGI_GetVBType before InitTo330Pointer */
/* 1.Openkey */
xgifb_reg_set(pVBInfo->P3c4, 0x05, 0x86);
- printk("6");
/* GetXG21Sense (GPIO) */
if (HwDeviceExtension->jChipType == XG21)
if (HwDeviceExtension->jChipType == XG27)
XGINew_GetXG27Sense(HwDeviceExtension, pVBInfo);
- printk("7");
-
/* 2.Reset Extended register */
for (i = 0x06; i < 0x20; i++)
/* for(i = 0x06; i <= 0x27; i++) */
/* xgifb_reg_set(pVBInfo->P3c4, i, 0); */
- printk("8");
-
for (i = 0x31; i <= 0x3B; i++)
xgifb_reg_set(pVBInfo->P3c4, i, 0);
- printk("9");
/* [Hsuan] 2004/08/20 Auto over driver for XG42 */
if (HwDeviceExtension->jChipType == XG42)
for (i = 0x79; i <= 0x7C; i++)
xgifb_reg_set(pVBInfo->P3d4, i, 0); /* shampoo 0208 */
- printk("10");
-
if (HwDeviceExtension->jChipType >= XG20)
- xgifb_reg_set(pVBInfo->P3d4, 0x97, *pVBInfo->pXGINew_CR97);
+ xgifb_reg_set(pVBInfo->P3d4, 0x97, pVBInfo->XGINew_CR97);
/* 3.SetMemoryClock
pVBInfo->ram_type = XGINew_GetXG20DRAMType(HwDeviceExtension, pVBInfo);
*/
- printk("11");
-
/* 4.SetDefExt1Regs begin */
- xgifb_reg_set(pVBInfo->P3c4, 0x07, *pVBInfo->pSR07);
+ xgifb_reg_set(pVBInfo->P3c4, 0x07, XGI330_SR07);
if (HwDeviceExtension->jChipType == XG27) {
- xgifb_reg_set(pVBInfo->P3c4, 0x40, *pVBInfo->pSR40);
- xgifb_reg_set(pVBInfo->P3c4, 0x41, *pVBInfo->pSR41);
+ xgifb_reg_set(pVBInfo->P3c4, 0x40, XG27_SR40);
+ xgifb_reg_set(pVBInfo->P3c4, 0x41, XG27_SR41);
}
xgifb_reg_set(pVBInfo->P3c4, 0x11, 0x0F);
- xgifb_reg_set(pVBInfo->P3c4, 0x1F, *pVBInfo->pSR1F);
+ xgifb_reg_set(pVBInfo->P3c4, 0x1F, XGI330_SR1F);
/* xgifb_reg_set(pVBInfo->P3c4, 0x20, 0x20); */
/* alan, 2001/6/26 Frame buffer can read/write SR20 */
xgifb_reg_set(pVBInfo->P3c4, 0x20, 0xA0);
/* Hsuan, 2006/01/01 H/W request for slow corner chip */
xgifb_reg_set(pVBInfo->P3c4, 0x36, 0x70);
if (HwDeviceExtension->jChipType == XG27) /* Alan 12/07/2006 */
- xgifb_reg_set(pVBInfo->P3c4, 0x36, *pVBInfo->pSR36);
+ xgifb_reg_set(pVBInfo->P3c4, 0x36, XG27_SR36);
/* SR11 = 0x0F; */
/* xgifb_reg_set(pVBInfo->P3c4, 0x11, SR11); */
- printk("12");
-
if (HwDeviceExtension->jChipType < XG20) { /* kuku 2004/06/25 */
u32 Temp;
}
*/
- printk("13");
-
/* Set AGP customize registers (in SetDefAGPRegs) Start */
for (i = 0x47; i <= 0x4C; i++)
xgifb_reg_set(pVBInfo->P3d4,
if (Temp == 1)
xgifb_reg_set(pVBInfo->P3d4, 0x48, 0x20); /* CR48 */
- printk("14");
} /* != XG20 */
/* Set PCI */
- xgifb_reg_set(pVBInfo->P3c4, 0x23, *pVBInfo->pSR23);
- xgifb_reg_set(pVBInfo->P3c4, 0x24, *pVBInfo->pSR24);
- xgifb_reg_set(pVBInfo->P3c4, 0x25, pVBInfo->SR25[0]);
- printk("15");
+ xgifb_reg_set(pVBInfo->P3c4, 0x23, XGI330_SR23);
+ xgifb_reg_set(pVBInfo->P3c4, 0x24, XGI330_SR24);
+ xgifb_reg_set(pVBInfo->P3c4, 0x25, XGI330_SR25);
if (HwDeviceExtension->jChipType < XG20) { /* kuku 2004/06/25 */
/* Set VB */
temp = (unsigned char) ((temp1 >> 4) & 0x0F);
xgifb_reg_set(pVBInfo->Part1Port,
- 0x02,
- (*pVBInfo->pCRT2Data_1_2));
-
- printk("16");
+ 0x02, XGI330_CRT2Data_1_2);
xgifb_reg_set(pVBInfo->Part1Port, 0x2E, 0x08); /* use VB */
} /* != XG20 */
/* Not DDR */
xgifb_reg_set(pVBInfo->P3c4,
0x31,
- (*pVBInfo->pSR31 & 0x3F) | 0x40);
+ (XGI330_SR31 & 0x3F) | 0x40);
xgifb_reg_set(pVBInfo->P3c4,
0x32,
- (*pVBInfo->pSR32 & 0xFC) | 0x01);
+ (XGI330_SR32 & 0xFC) | 0x01);
} else {
- xgifb_reg_set(pVBInfo->P3c4, 0x31, *pVBInfo->pSR31);
- xgifb_reg_set(pVBInfo->P3c4, 0x32, *pVBInfo->pSR32);
+ xgifb_reg_set(pVBInfo->P3c4, 0x31, XGI330_SR31);
+ xgifb_reg_set(pVBInfo->P3c4, 0x32, XGI330_SR32);
}
- xgifb_reg_set(pVBInfo->P3c4, 0x33, *pVBInfo->pSR33);
- printk("17");
+ xgifb_reg_set(pVBInfo->P3c4, 0x33, XGI330_SR33);
/*
SetPowerConsume (HwDeviceExtension, pVBInfo->P3c4); */
if (pVBInfo->IF_DEF_LVDS == 0) {
xgifb_reg_set(pVBInfo->Part2Port, 0x00, 0x1C);
xgifb_reg_set(pVBInfo->Part4Port,
- 0x0D,
- *pVBInfo->pCRT2Data_4_D);
+ 0x0D, XGI330_CRT2Data_4_D);
xgifb_reg_set(pVBInfo->Part4Port,
- 0x0E,
- *pVBInfo->pCRT2Data_4_E);
+ 0x0E, XGI330_CRT2Data_4_E);
xgifb_reg_set(pVBInfo->Part4Port,
- 0x10,
- *pVBInfo->pCRT2Data_4_10);
+ 0x10, XGI330_CRT2Data_4_10);
xgifb_reg_set(pVBInfo->Part4Port, 0x0F, 0x3F);
}
XGI_LockCRT2(HwDeviceExtension, pVBInfo);
}
} /* != XG20 */
- printk("18");
-
- printk("181");
-
- printk("182");
XGI_SenseCRT1(pVBInfo);
- printk("183");
/* XGINew_DetectMonitor(HwDeviceExtension); */
if (HwDeviceExtension->jChipType == XG21) {
- printk("186");
xgifb_reg_and_or(pVBInfo->P3d4,
0x32,
Monitor1Sense); /* Z9 default has CRT */
temp = GetXG21FPBits(pVBInfo);
xgifb_reg_and_or(pVBInfo->P3d4, 0x37, ~0x01, temp);
- printk("187");
}
if (HwDeviceExtension->jChipType == XG27) {
temp = GetXG27FPBits(pVBInfo);
xgifb_reg_and_or(pVBInfo->P3d4, 0x37, ~0x03, temp);
}
- printk("19");
pVBInfo->ram_type = XGINew_GetXG20DRAMType(HwDeviceExtension, pVBInfo);
pVBInfo->P3d4,
pVBInfo);
- printk("20");
XGINew_SetDRAMSize_340(xgifb_info, HwDeviceExtension, pVBInfo);
- printk("21");
-
- printk("22");
/* SetDefExt2Regs begin */
/*
AGP = 0;
if (AGP == 0)
- *pVBInfo->pSR21 &= 0xEF;
+ pVBInfo->SR21 &= 0xEF;
- xgifb_reg_set(pVBInfo->P3c4, 0x21, *pVBInfo->pSR21);
+ xgifb_reg_set(pVBInfo->P3c4, 0x21, pVBInfo->SR21);
if (AGP == 1)
- *pVBInfo->pSR22 &= 0x20;
- xgifb_reg_set(pVBInfo->P3c4, 0x22, *pVBInfo->pSR22);
+ pVBInfo->SR22 &= 0x20;
+ xgifb_reg_set(pVBInfo->P3c4, 0x22, pVBInfo->SR22);
*/
/* base = 0x80000000; */
/* OutPortLong(0xcf8, base); */
/* if (Temp == 0x1039) { */
xgifb_reg_set(pVBInfo->P3c4,
0x22,
- (unsigned char) ((*pVBInfo->pSR22) & 0xFE));
+ (unsigned char) ((pVBInfo->SR22) & 0xFE));
/* } else { */
- /* xgifb_reg_set(pVBInfo->P3c4, 0x22, *pVBInfo->pSR22); */
+ /* xgifb_reg_set(pVBInfo->P3c4, 0x22, pVBInfo->SR22); */
/* } */
- xgifb_reg_set(pVBInfo->P3c4, 0x21, *pVBInfo->pSR21);
-
- printk("23");
+ xgifb_reg_set(pVBInfo->P3c4, 0x21, pVBInfo->SR21);
XGINew_ChkSenseStatus(HwDeviceExtension, pVBInfo);
XGINew_SetModeScratch(HwDeviceExtension, pVBInfo);
- printk("24");
-
xgifb_reg_set(pVBInfo->P3d4, 0x8c, 0x87);
xgifb_reg_set(pVBInfo->P3c4, 0x14, 0x31);
- printk("25");
return 1;
} /* end of init */
-
-#include <linux/io.h>
#include <linux/delay.h>
-#include <linux/types.h>
#include "XGIfb.h"
-
#include "vb_def.h"
-#include "vgatypes.h"
-#include "vb_struct.h"
-#include "vb_init.h"
#include "vb_util.h"
#include "vb_table.h"
#include "vb_setmode.h"
-
#define IndexMask 0xff
+#define TVCLKBASE_315_25 (TVCLKBASE_315 + 25)
static const unsigned short XGINew_VGA_DAC[] = {
0x00, 0x10, 0x04, 0x14, 0x01, 0x11, 0x09, 0x15,
pVBInfo->ModeResInfo
= (struct SiS_ModeResInfo_S *) XGI330_ModeResInfo;
- pVBInfo->pOutputSelect = &XGI330_OutputSelect;
- pVBInfo->pSoftSetting = &XGI330_SoftSetting;
- pVBInfo->pSR07 = &XGI330_SR07;
pVBInfo->LCDResInfo = 0;
pVBInfo->LCDTypeInfo = 0;
pVBInfo->LCDInfo = 0;
pVBInfo->SR15 = XGI340_SR13;
pVBInfo->CR40 = XGI340_cr41;
- pVBInfo->SR25 = XGI330_sr25;
- pVBInfo->pSR31 = &XGI330_sr31;
- pVBInfo->pSR32 = &XGI330_sr32;
pVBInfo->CR6B = XGI340_CR6B;
pVBInfo->CR6E = XGI340_CR6E;
pVBInfo->CR6F = XGI340_CR6F;
pVBInfo->CR89 = XGI340_CR89;
pVBInfo->AGPReg = XGI340_AGPReg;
pVBInfo->SR16 = XGI340_SR16;
- pVBInfo->pCRCF = &XG40_CRCF;
- pVBInfo->pXGINew_DRAMTypeDefinition = &XG40_DRAMTypeDefinition;
-
- pVBInfo->CR49 = XGI330_CR49;
- pVBInfo->pSR1F = &XGI330_SR1F;
- pVBInfo->pSR21 = &XGI330_SR21;
- pVBInfo->pSR22 = &XGI330_SR22;
- pVBInfo->pSR23 = &XGI330_SR23;
- pVBInfo->pSR24 = &XGI330_SR24;
- pVBInfo->pSR33 = &XGI330_SR33;
-
- pVBInfo->pCRT2Data_1_2 = &XGI330_CRT2Data_1_2;
- pVBInfo->pCRT2Data_4_D = &XGI330_CRT2Data_4_D;
- pVBInfo->pCRT2Data_4_E = &XGI330_CRT2Data_4_E;
- pVBInfo->pCRT2Data_4_10 = &XGI330_CRT2Data_4_10;
- pVBInfo->pRGBSenseData = &XGI330_RGBSenseData;
- pVBInfo->pVideoSenseData = &XGI330_VideoSenseData;
- pVBInfo->pYCSenseData = &XGI330_YCSenseData;
- pVBInfo->pRGBSenseData2 = &XGI330_RGBSenseData2;
- pVBInfo->pVideoSenseData2 = &XGI330_VideoSenseData2;
- pVBInfo->pYCSenseData2 = &XGI330_YCSenseData2;
+
+ pVBInfo->SR21 = 0xa3;
+ pVBInfo->SR22 = 0xfb;
pVBInfo->NTSCTiming = XGI330_NTSCTiming;
pVBInfo->PALTiming = XGI330_PALTiming;
else
pVBInfo->LCDCapList = XGI_LCDCapList;
- pVBInfo->XGI_TVDelayList = XGI301TVDelayList;
- pVBInfo->XGI_TVDelayList2 = XGI301TVDelayList2;
-
- pVBInfo->pXGINew_I2CDefinition = &XG40_I2CDefinition;
-
if (ChipType >= XG20)
- pVBInfo->pXGINew_CR97 = &XG20_CR97;
+ pVBInfo->XGINew_CR97 = 0x10;
if (ChipType == XG27) {
unsigned char temp;
pVBInfo->MCLKData
= (struct SiS_MCLKData *) XGI27New_MCLKData;
pVBInfo->CR40 = XGI27_cr41;
- pVBInfo->pXGINew_CR97 = &XG27_CR97;
- pVBInfo->pSR36 = &XG27_SR36;
- pVBInfo->pCR8F = &XG27_CR8F;
- pVBInfo->pCRD0 = XG27_CRD0;
- pVBInfo->pCRDE = XG27_CRDE;
- pVBInfo->pSR40 = &XG27_SR40;
- pVBInfo->pSR41 = &XG27_SR41;
+ pVBInfo->XGINew_CR97 = 0xc1;
pVBInfo->SR15 = XG27_SR13;
/*Z11m DDR*/
temp = xgifb_reg_get(pVBInfo->P3c4, 0x3B);
/* SR3B[7][3]MAA15 MAA11 (Power on Trapping) */
if (((temp & 0x88) == 0x80) || ((temp & 0x88) == 0x08))
- pVBInfo->pXGINew_CR97 = &Z11m_CR97;
- }
-
- if (ChipType >= XG20) {
- pVBInfo->pDVOSetting = &XG21_DVOSetting;
- pVBInfo->pCR2E = &XG21_CR2E;
- pVBInfo->pCR2F = &XG21_CR2F;
- pVBInfo->pCR46 = &XG21_CR46;
- pVBInfo->pCR47 = &XG21_CR47;
+ pVBInfo->XGINew_CR97 = 0x80;
}
}
}
}
- if (((*pVBInfo->pDVOSetting) & 0xC0) == 0xC0) {
- xgifb_reg_set(pVBInfo->P3d4, 0x2E, *pVBInfo->pCR2E);
- xgifb_reg_set(pVBInfo->P3d4, 0x2F, *pVBInfo->pCR2F);
- xgifb_reg_set(pVBInfo->P3d4, 0x46, *pVBInfo->pCR46);
- xgifb_reg_set(pVBInfo->P3d4, 0x47, *pVBInfo->pCR47);
- }
-
if (chip_id == XG27) {
XGI_SetXG27FPBits(pVBInfo);
} else {
struct xgi_hw_device_info *HwDeviceExtension,
struct vb_device_info *pVBInfo)
{
- unsigned short LCDXlat1VCLK[4] = { VCLK65_315 + 2,
- VCLK65_315 + 2,
- VCLK65_315 + 2,
- VCLK65_315 + 2 };
- unsigned short LCDXlat2VCLK[4] = { VCLK108_2_315 + 5,
- VCLK108_2_315 + 5,
- VCLK108_2_315 + 5,
- VCLK108_2_315 + 5 };
- unsigned short LVDSXlat1VCLK[4] = { VCLK40, VCLK40, VCLK40, VCLK40 };
- unsigned short LVDSXlat2VCLK[4] = { VCLK65_315 + 2,
- VCLK65_315 + 2,
- VCLK65_315 + 2,
- VCLK65_315 + 2 };
- unsigned short LVDSXlat3VCLK[4] = { VCLK65_315 + 2,
- VCLK65_315 + 2,
- VCLK65_315 + 2,
- VCLK65_315 + 2 };
-
unsigned short CRT2Index, VCLKIndex;
unsigned short modeflag, resinfo;
CRT2Index = CRT2Index >> 6; /* for LCD */
if (pVBInfo->VBInfo & (SetCRT2ToLCD | XGI_SetCRT2ToLCDA)) { /*301b*/
if (pVBInfo->LCDResInfo != Panel_1024x768)
- VCLKIndex = LCDXlat2VCLK[CRT2Index];
+ VCLKIndex = VCLK108_2_315 + 5; /* LCDXlat2VCLK */
else
- VCLKIndex = LCDXlat1VCLK[CRT2Index];
+ VCLKIndex = VCLK65_315 + 2; /* LCDXlat1VCLK */
} else if (pVBInfo->VBInfo & SetCRT2ToHiVision) {
if (pVBInfo->SetFlag & RPLLDIV2XO) {
- VCLKIndex = TVCLKBASE_315 + HiTVVCLKDIV2;
- VCLKIndex += 25;
+ VCLKIndex = TVCLKBASE_315_25 + HiTVVCLKDIV2;
} else {
- VCLKIndex = TVCLKBASE_315 + HiTVVCLK;
- VCLKIndex += 25;
+ VCLKIndex = TVCLKBASE_315_25 + HiTVVCLK;
}
if (pVBInfo->SetFlag & TVSimuMode) {
if (modeflag & Charx8Dot) {
- VCLKIndex = TVCLKBASE_315 + HiTVSimuVCLK;
- VCLKIndex += 25;
+ VCLKIndex = TVCLKBASE_315_25 + HiTVSimuVCLK;
} else {
- VCLKIndex = TVCLKBASE_315 + HiTVTextVCLK;
- VCLKIndex += 25;
+ VCLKIndex = TVCLKBASE_315_25 + HiTVTextVCLK;
}
}
}
} else if (pVBInfo->VBInfo & SetCRT2ToTV) {
if (pVBInfo->SetFlag & RPLLDIV2XO) {
- VCLKIndex = TVCLKBASE_315 + TVVCLKDIV2;
- VCLKIndex += 25;
+ VCLKIndex = TVCLKBASE_315_25 + TVVCLKDIV2;
} else {
- VCLKIndex = TVCLKBASE_315 + TVVCLK;
- VCLKIndex += 25;
+ VCLKIndex = TVCLKBASE_315_25 + TVVCLK;
}
} else { /* for CRT2 */
/* di+Ext_CRTVCLK */
VCLKIndex &= IndexMask;
}
} else { /* LVDS */
- VCLKIndex = CRT2Index;
- VCLKIndex = VCLKIndex >> 6;
if ((pVBInfo->LCDResInfo == Panel_800x600) ||
(pVBInfo->LCDResInfo == Panel_320x480))
- VCLKIndex = LVDSXlat1VCLK[VCLKIndex];
- else if ((pVBInfo->LCDResInfo == Panel_1024x768) ||
- (pVBInfo->LCDResInfo == Panel_1024x768x75))
- VCLKIndex = LVDSXlat2VCLK[VCLKIndex];
+ VCLKIndex = VCLK40; /* LVDSXlat1VCLK */
else
- VCLKIndex = LVDSXlat3VCLK[VCLKIndex];
+ VCLKIndex = VCLK65_315 + 2; /* LVDSXlat2VCLK, LVDSXlat3VCLK */
}
return VCLKIndex;
struct vb_device_info *pVBInfo)
{
unsigned short tempbx;
- struct XGI330_LVDSDataStruct *LCDPtr = NULL;
+ struct SiS_LVDSData *LCDPtr = NULL;
tempbx = 2;
if (pVBInfo->VBInfo & (SetCRT2ToLCD | XGI_SetCRT2ToLCDA)) {
- LCDPtr = (struct XGI330_LVDSDataStruct *) XGI_GetLcdPtr(tempbx,
+ LCDPtr = (struct SiS_LVDSData *)XGI_GetLcdPtr(tempbx,
ModeNo, ModeIdIndex, RefreshRateTableIndex,
pVBInfo);
pVBInfo->VGAHT = LCDPtr->VGAHT;
static void XGI_SetDelayComp(struct vb_device_info *pVBInfo)
{
- unsigned short index;
-
unsigned char tempah, tempbl, tempbh;
if (pVBInfo->VBType & (VB_SIS301B | VB_SIS302B | VB_SIS301LV
| VB_SIS302LV | VB_XGI301C)) {
if (pVBInfo->VBInfo & (SetCRT2ToLCD | XGI_SetCRT2ToLCDA
| SetCRT2ToTV | SetCRT2ToRAMDAC)) {
- tempbl = 0;
tempbh = 0;
-
- index = XGI_GetTVPtrIndex(pVBInfo); /* Get TV Delay */
- tempbl = pVBInfo->XGI_TVDelayList[index];
-
- if (pVBInfo->VBType & (VB_SIS301B | VB_SIS302B
- | VB_SIS301LV | VB_SIS302LV
- | VB_XGI301C))
- tempbl = pVBInfo->XGI_TVDelayList2[index];
+ tempbl = XGI301TVDelay;
if (pVBInfo->VBInfo & SetCRT2ToDualEdge)
tempbl = tempbl >> 4;
if (pVBInfo->VBInfo & (SetCRT2ToLCD | XGI_SetCRT2ToLCDA)) {
- /* Get LCD Delay */
- index = XGI_GetLCDCapPtr(pVBInfo);
- tempbh = pVBInfo->LCDCapList[index].
- LCD_DelayCompensation;
+ tempbh = XGI301LCDDelay;
if (!(pVBInfo->VBInfo & XGI_SetCRT2ToLCDA))
tempbl = tempbh;
tempbl = 0;
tempbh = 0;
if (pVBInfo->VBInfo & SetCRT2ToLCD) {
- /* / Get LCD Delay */
- tempah = pVBInfo->LCDCapList[
- XGI_GetLCDCapPtr(pVBInfo)].
- LCD_DelayCompensation;
+ tempah = XGI301LCDDelay;
tempah &= 0x0f;
tempah = tempah << 4;
xgifb_reg_and_or(pVBInfo->Part1Port, 0x2D, 0x0f,
}
}
-static void XGI_CloseCRTC(struct xgi_hw_device_info *HwDeviceExtension,
- struct vb_device_info *pVBInfo)
-{
- unsigned short tempbx;
-
- tempbx = 0;
-
- if (pVBInfo->VBInfo & XGI_SetCRT2ToLCDA)
- tempbx = 0x08A0;
-
-}
void XGI_UnLockCRT2(struct xgi_hw_device_info *HwDeviceExtension,
struct vb_device_info *pVBInfo)
XGI_SetCRT2ModeRegs(ModeNo, HwDeviceExtension, pVBInfo);
XGI_OEM310Setting(ModeNo, ModeIdIndex, pVBInfo); /*0212*/
- XGI_CloseCRTC(HwDeviceExtension, pVBInfo);
XGI_EnableBridge(xgifb_info, HwDeviceExtension, pVBInfo);
} /* !XG20 */
else {
unsigned short DATAPTR;
};
-struct XGI330_LVDSDataStruct {
- unsigned short VGAHT;
- unsigned short VGAVT;
- unsigned short LCDHT;
- unsigned short LCDVT;
-};
-
struct XGI330_LCDDataDesStruct2 {
unsigned short LCDHDES;
unsigned short LCDHRS;
unsigned short LCDVSync;
};
-struct XGI330_LCDDataStruct {
- unsigned short RVBHCMAX;
- unsigned short RVBHCFACT;
- unsigned short VGAHT;
- unsigned short VGAVT;
- unsigned short LCDHT;
- unsigned short LCDVT;
-};
-
struct XGI330_TVDataStruct {
unsigned short RVBHCMAX;
};
-struct XGI330_CHTVDataStruct {
- unsigned short VGAHT;
- unsigned short VGAVT;
- unsigned short LCDHT;
- unsigned short LCDVT;
-};
-
struct XGI_TimingHStruct {
unsigned char data[8];
};
unsigned char LCD_ID;
unsigned short LCD_Capability;
unsigned char LCD_SetFlag;
- unsigned char LCD_DelayCompensation;
unsigned char LCD_HSyncWidth;
unsigned char LCD_VSyncWidth;
unsigned char LCD_VCLK;
};
-struct XGI330_VCLKDataStruct {
- unsigned char SR2B, SR2C;
- unsigned short CLOCK;
-};
-
struct XGI301C_Tap4TimingStruct {
unsigned short DE;
unsigned char Reg[64]; /* C0-FF */
unsigned char (*SR15)[8];
unsigned char (*CR40)[8];
- unsigned char *pSoftSetting;
- unsigned char *pOutputSelect;
-
- unsigned short *pRGBSenseData;
- unsigned short *pRGBSenseData2; /*301b*/
- unsigned short *pVideoSenseData;
- unsigned short *pVideoSenseData2;
- unsigned short *pYCSenseData;
- unsigned short *pYCSenseData2;
-
- unsigned char *pSR07;
- unsigned char *CR49;
- unsigned char *pSR1F;
unsigned char *AGPReg;
unsigned char *SR16;
- unsigned char *pSR21;
- unsigned char *pSR22;
- unsigned char *pSR23;
- unsigned char *pSR24;
- unsigned char *SR25;
- unsigned char *pSR31;
- unsigned char *pSR32;
- unsigned char *pSR33;
- unsigned char *pSR36; /* alan 12/07/2006 */
- unsigned char *pCRCF;
- unsigned char *pCRD0; /* alan 12/07/2006 */
- unsigned char *pCRDE; /* alan 12/07/2006 */
- unsigned char *pCR8F; /* alan 12/07/2006 */
- unsigned char *pSR40; /* alan 12/07/2006 */
- unsigned char *pSR41; /* alan 12/07/2006 */
- unsigned char *pDVOSetting;
- unsigned char *pCR2E;
- unsigned char *pCR2F;
- unsigned char *pCR46;
- unsigned char *pCR47;
- unsigned char *pCRT2Data_1_2;
- unsigned char *pCRT2Data_4_D;
- unsigned char *pCRT2Data_4_E;
- unsigned char *pCRT2Data_4_10;
+ unsigned char SR21;
+ unsigned char SR22;
+ unsigned char SR25;
struct SiS_MCLKData *MCLKData;
struct XGI_ECLKDataStruct *ECLKData;
- unsigned char *XGI_TVDelayList;
- unsigned char *XGI_TVDelayList2;
unsigned char *NTSCTiming;
unsigned char *PALTiming;
unsigned char *HiTVExtTiming;
unsigned char *Ren750pGroup3;
unsigned char *ScreenOffset;
unsigned char *pXGINew_DRAMTypeDefinition;
- unsigned char *pXGINew_I2CDefinition ;
- unsigned char *pXGINew_CR97 ;
+ unsigned char XGINew_CR97;
struct XGI330_LCDCapStruct *LCDCapList;
+#ifndef _VB_TABLE_
+#define _VB_TABLE_
/* yilin modify for xgi20 */
static struct SiS_MCLKData XGI340New_MCLKData[] = {
{0x16, 0x01, 0x01, 166},
static unsigned char XGI340_SR16[4] = {0x03, 0x83, 0x03, 0x83};
-static unsigned char XGI330_sr25[2];
-static unsigned char XGI330_sr31 = 0xc0;
-static unsigned char XGI330_sr32 = 0x11;
-static unsigned char XGI330_SR33;
-static unsigned char XG40_CRCF = 0x13;
-static unsigned char XG40_DRAMTypeDefinition = 0xFF ;
-
static struct XGI_ExtStruct XGI330_EModeIDTable[] = {
{0x2e, 0x0a1b, 0x0306, 0x06, 0x05, 0x06},
{0x2f, 0x0a1b, 0x0305, 0x05, 0x05, 0x05},
0xAD, 0xDB, 0xF6, 0xAC, 0xE0, 0x02};
/*add for new UNIVGABIOS*/
-static struct XGI330_LCDDataStruct XGI_StLCD1024x768Data[] = {
+static struct SiS_LCDData XGI_StLCD1024x768Data[] = {
{62, 25, 800, 546, 1344, 806},
{32, 15, 930, 546, 1344, 806},
{62, 25, 800, 546, 1344, 806}, /*chiawenfordot9->dot8*/
{1, 1, 1344, 806, 1344, 806}
};
-static struct XGI330_LCDDataStruct XGI_ExtLCD1024x768Data[] = {
+static struct SiS_LCDData XGI_ExtLCD1024x768Data[] = {
/* { 12, 5, 896, 512,1344, 806}, // alan 09/12/2003 */
{42, 25, 1536, 419, 1344, 806},
/* { 12, 5, 896, 510,1344, 806}, // alan 09/12/2003 */
{1, 1, 1344, 806, 1344, 806}
};
-static struct XGI330_LCDDataStruct XGI_CetLCD1024x768Data[] = {
+static struct SiS_LCDData XGI_CetLCD1024x768Data[] = {
{1, 1, 1344, 806, 1344, 806}, /* ; 00 (320x200,320x400,
640x200,640x400) */
{1, 1, 1344, 806, 1344, 806}, /* 01 (320x350,640x350) */
{1, 1, 1344, 806, 1344, 806} /* 06 (1024x768x60Hz) */
};
-static struct XGI330_LCDDataStruct XGI_StLCD1280x1024Data[] = {
+static struct SiS_LCDData XGI_StLCD1280x1024Data[] = {
{22, 5, 800, 510, 1650, 1088},
{22, 5, 800, 510, 1650, 1088},
{176, 45, 900, 510, 1650, 1088},
{1, 1, 1688, 1066, 1688, 1066}
};
-static struct XGI330_LCDDataStruct XGI_ExtLCD1280x1024Data[] = {
+static struct SiS_LCDData XGI_ExtLCD1280x1024Data[] = {
{211, 60, 1024, 501, 1688, 1066},
{211, 60, 1024, 508, 1688, 1066},
{211, 60, 1024, 501, 1688, 1066},
{1, 1, 1688, 1066, 1688, 1066}
};
-static struct XGI330_LCDDataStruct XGI_CetLCD1280x1024Data[] = {
+static struct SiS_LCDData XGI_CetLCD1280x1024Data[] = {
{1, 1, 1688, 1066, 1688, 1066}, /* 00 (320x200,320x400,
640x200,640x400) */
{1, 1, 1688, 1066, 1688, 1066}, /* 01 (320x350,640x350) */
{1, 1, 1688, 1066, 1688, 1066} /* 08 (1400x1050x60Hz) */
};
-static struct XGI330_LCDDataStruct xgifb_lcd_1400x1050[] = {
+static struct SiS_LCDData xgifb_lcd_1400x1050[] = {
{211, 100, 2100, 408, 1688, 1066}, /* 00 (320x200,320x400,
640x200,640x400) */
{211, 64, 1536, 358, 1688, 1066}, /* 01 (320x350,640x350) */
{1, 1, 1688, 1066, 1688, 1066} /* 08 (1400x1050x60Hz) */
};
-static struct XGI330_LCDDataStruct XGI_ExtLCD1600x1200Data[] = {
+static struct SiS_LCDData XGI_ExtLCD1600x1200Data[] = {
{4, 1, 1620, 420, 2160, 1250}, /* { 3,1,2160,425,2160,1250 },
// 00 (320x200,320x400,
// 640x200,640x400)
{1, 1, 2160, 1250, 2160, 1250} /* 09 (1600x1200x60Hz) ;302lv */
};
-static struct XGI330_LCDDataStruct XGI_StLCD1600x1200Data[] = {
+static struct SiS_LCDData XGI_StLCD1600x1200Data[] = {
{27, 4, 800, 500, 2160, 1250}, /* 00 (320x200,320x400,
640x200,640x400) */
{27, 4, 800, 500, 2160, 1250}, /* 01 (320x350,640x350) */
{1, 1, 2160, 1250, 2160, 1250} /* 09 (1600x1200) */
};
-static struct XGI330_LCDDataStruct XGI_CetLCD1400x1050Data[] = {
+static struct SiS_LCDData XGI_CetLCD1400x1050Data[] = {
{1, 1, 1688, 1066, 1688, 1066}, /* 00 (320x200,320x400,
640x200,640x400) */
{1, 1, 1688, 1066, 1688, 1066}, /* 01 (320x350,640x350) */
{1, 1, 1688, 1066, 1688, 1066} /* 08 (1400x1050x60Hz) */
};
-static struct XGI330_LCDDataStruct XGI_NoScalingData[] = {
+static struct SiS_LCDData XGI_NoScalingData[] = {
{1, 1, 800, 449, 800, 449},
{1, 1, 800, 449, 800, 449},
{1, 1, 900, 449, 900, 449},
{1, 1, 1688, 1066, 1688, 1066}
};
-static struct XGI330_LCDDataStruct XGI_ExtLCD1024x768x75Data[] = {
+static struct SiS_LCDData XGI_ExtLCD1024x768x75Data[] = {
{42, 25, 1536, 419, 1344, 806}, /* ; 00 (320x200,320x400,
640x200,640x400) */
{48, 25, 1536, 369, 1344, 806}, /* ; 01 (320x350,640x350) */
{1, 1, 1312, 800, 1312, 800} /* ; 06 (1024x768x75Hz) */
};
-static struct XGI330_LCDDataStruct XGI_CetLCD1024x768x75Data[] = {
+static struct SiS_LCDData XGI_CetLCD1024x768x75Data[] = {
{1, 1, 1312, 800, 1312, 800}, /* ; 00 (320x200,320x400,
640x200,640x400) */
{1, 1, 1312, 800, 1312, 800}, /* ; 01 (320x350,640x350) */
{1, 1, 1312, 800, 1312, 800} /* ; 06 (1024x768x75Hz) */
};
-static struct XGI330_LCDDataStruct xgifb_lcd_1280x1024x75[] = {
+static struct SiS_LCDData xgifb_lcd_1280x1024x75[] = {
{211, 60, 1024, 501, 1688, 1066}, /* ; 00 (320x200,320x400,
640x200,640x400) */
{211, 60, 1024, 508, 1688, 1066}, /* ; 01 (320x350,640x350) */
{1, 1, 1688, 1066, 1688, 1066} /* ; 07 (1280x1024x75Hz) */
};
-static struct XGI330_LCDDataStruct XGI_CetLCD1280x1024x75Data[] = {
+static struct SiS_LCDData XGI_CetLCD1280x1024x75Data[] = {
{1, 1, 1688, 1066, 1688, 1066}, /* ; 00 (320x200,320x400,
640x200,640x400) */
{1, 1, 1688, 1066, 1688, 1066}, /* ; 01 (320x350,640x350) */
{1, 1, 1688, 1066, 1688, 1066} /* ; 07 (1280x1024x75Hz) */
};
-static struct XGI330_LCDDataStruct XGI_NoScalingDatax75[] = {
+static struct SiS_LCDData XGI_NoScalingDatax75[] = {
{1, 1, 800, 449, 800, 449}, /* ; 00 (320x200, 320x400,
640x200, 640x400) */
{1, 1, 800, 449, 800, 449}, /* ; 01 (320x350, 640x350) */
0x18, 0x1D, 0x23, 0x28, 0x4C, 0xAA, 0x01
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1024x768Data_1[] = {
+static struct SiS_LVDSData XGI_LVDS1024x768Data_1[] = {
{ 960, 438, 1344, 806}, /* 00 (320x200,320x400,640x200,640x400) */
{ 960, 388, 1344, 806}, /* 01 (320x350,640x350) */
{1040, 438, 1344, 806}, /* 02 (360x400,720x400) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1024x768Data_2[] = {
+static struct SiS_LVDSData XGI_LVDS1024x768Data_2[] = {
{1344, 806, 1344, 806},
{1344, 806, 1344, 806},
{1344, 806, 1344, 806},
{800, 525, 1280, 813}
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1280x1024Data_1[] = {
+static struct SiS_LVDSData XGI_LVDS1280x1024Data_1[] = {
{1048, 442, 1688, 1066},
{1048, 392, 1688, 1066},
{1048, 442, 1688, 1066},
{1688, 1066, 1688, 1066}
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1280x1024Data_2[] = {
+static struct SiS_LVDSData XGI_LVDS1280x1024Data_2[] = {
{1344, 806, 1344, 806},
{1344, 806, 1344, 806},
{1344, 806, 1344, 806},
{800, 525, 1280, 813}
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1400x1050Data_1[] = {
+static struct SiS_LVDSData XGI_LVDS1400x1050Data_1[] = {
{928, 416, 1688, 1066},
{928, 366, 1688, 1066},
{928, 416, 1688, 1066},
{1688, 1066, 1688, 1066}
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1400x1050Data_2[] = {
+static struct SiS_LVDSData XGI_LVDS1400x1050Data_2[] = {
{1688, 1066, 1688, 1066},
{1688, 1066, 1688, 1066},
{1688, 1066, 1688, 1066},
};
/* ;;[ycchen] 12/05/02 LCDHTxLCDVT=2048x1320 */
-static struct XGI330_LVDSDataStruct XGI_LVDS1600x1200Data_1[] = {
+static struct SiS_LVDSData XGI_LVDS1600x1200Data_1[] = {
{1088, 520, 2048, 1320}, /* 00 (320x200,320x400,640x200,640x400) */
{1088, 470, 2048, 1320}, /* 01 (320x350,640x350) */
{1088, 520, 2048, 1320}, /* 02 (360x400,720x400) */
{2048, 1320, 2048, 1320} /* 09 (1600x1200) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDSNoScalingData[] = {
+static struct SiS_LVDSData XGI_LVDSNoScalingData[] = {
{ 800, 449, 800, 449}, /* 00 (320x200,320x400,640x200,640x400) */
{ 800, 449, 800, 449}, /* 01 (320x350,640x350) */
{ 800, 449, 800, 449}, /* 02 (360x400,720x400) */
{1688, 806, 1688, 806} /* 0A (1280x768x60Hz) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1024x768Data_1x75[] = {
+static struct SiS_LVDSData XGI_LVDS1024x768Data_1x75[] = {
{ 960, 438, 1312, 800}, /* 00 (320x200,320x400,640x200,640x400) */
{ 960, 388, 1312, 800}, /* 01 (320x350,640x350) */
{1040, 438, 1312, 800}, /* 02 (360x400,720x400) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1024x768Data_2x75[] = {
+static struct SiS_LVDSData XGI_LVDS1024x768Data_2x75[] = {
{1312, 800, 1312, 800}, /* ; 00 (320x200,320x400,640x200,640x400) */
{1312, 800, 1312, 800}, /* ; 01 (320x350,640x350) */
{1312, 800, 1312, 800}, /* ; 02 (360x400,720x400) */
{1312, 800, 1312, 800}, /* ; 06 (512x384,1024x768) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1280x1024Data_1x75[] = {
+static struct SiS_LVDSData XGI_LVDS1280x1024Data_1x75[] = {
{1048, 442, 1688, 1066 }, /* ; 00 (320x200,320x400,640x200,640x400) */
{1048, 392, 1688, 1066 }, /* ; 01 (320x350,640x350) */
{1128, 442, 1688, 1066 }, /* ; 02 (360x400,720x400) */
{1688, 1066, 1688, 1066 }, /* ; 06; 07 (640x512,1280x1024) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1280x1024Data_2x75[] = {
+static struct SiS_LVDSData XGI_LVDS1280x1024Data_2x75[] = {
{1688, 1066, 1688, 1066 }, /* ; 00 (320x200,320x400,640x200,640x400) */
{1688, 1066, 1688, 1066 }, /* ; 01 (320x350,640x350) */
{1688, 1066, 1688, 1066 }, /* ; 02 (360x400,720x400) */
{1688, 1066, 1688, 1066 }, /* ; 06; 07 (640x512,1280x1024) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDSNoScalingDatax75[] = {
+static struct SiS_LVDSData XGI_LVDSNoScalingDatax75[] = {
{ 800, 449, 800, 449}, /* ; 00 (320x200,320x400,640x200,640x400) */
{ 800, 449, 800, 449}, /* ; 01 (320x350,640x350) */
{ 900, 449, 900, 449}, /* ; 02 (360x400,720x400) */
{1688, 806, 1688, 806}, /* ; 0A (1280x768x75Hz) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1024x768Des_1[] = {
+static struct SiS_LVDSData XGI_LVDS1024x768Des_1[] = {
{0, 1048, 0, 771}, /* 00 (320x200,320x400,640x200,640x400) */
{0, 1048, 0, 771}, /* 01 (320x350,640x350) */
{0, 1048, 0, 771}, /* 02 (360x400,720x400) */
{0, 1048, 805, 770} /* 06 (1024x768x60Hz) */
} ;
-static struct XGI330_LVDSDataStruct XGI_LVDS1024x768Des_2[] = {
+static struct SiS_LVDSData XGI_LVDS1024x768Des_2[] = {
{1142, 856, 622, 587}, /* 00 (320x200,320x400,640x200,640x400) */
{1142, 856, 597, 562}, /* 01 (320x350,640x350) */
{1142, 856, 622, 587}, /* 02 (360x400,720x400) */
{ 0, 1048, 805, 771} /* 06 (1024x768x60Hz) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1024x768Des_3[] = {
+static struct SiS_LVDSData XGI_LVDS1024x768Des_3[] = {
{320, 24, 622, 587}, /* 00 (320x200,320x400,640x200,640x400) */
{320, 24, 597, 562}, /* 01 (320x350,640x350) */
{320, 24, 622, 587}, /* 02 (360x400,720x400) */
{320, 24, 722, 687} /* 04 (640x480x60Hz) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1280x1024Des_1[] = {
+static struct SiS_LVDSData XGI_LVDS1280x1024Des_1[] = {
{0, 1328, 0, 1025}, /* 00 (320x200,320x400,640x200,640x400) */
{0, 1328, 0, 1025}, /* 01 (320x350,640x350) */
{0, 1328, 0, 1025}, /* 02 (360x400,720x400) */
};
/* The Display setting for DE Mode Panel */
-static struct XGI330_LVDSDataStruct XGI_LVDS1280x1024Des_2[] = {
+static struct SiS_LVDSData XGI_LVDS1280x1024Des_2[] = {
{1368, 1008, 752, 711}, /* 00 (320x200,320x400,640x200,640x400) */
{1368, 1008, 729, 688}, /* 01 (320x350,640x350) */
{1408, 1048, 752, 711}, /* 02 (360x400,720x400) */
{0000, 1328, 0, 1025} /* 07 (1280x1024x60Hz) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1400x1050Des_1[] = {
+static struct SiS_LVDSData XGI_LVDS1400x1050Des_1[] = {
{0, 1448, 0, 1051}, /* 00 (320x200,320x400,640x200,640x400) */
{0, 1448, 0, 1051}, /* 01 (320x350,640x350) */
{0, 1448, 0, 1051}, /* 02 (360x400,720x400) */
{0, 1448, 0, 1051} /* 08 (1400x1050x60Hz) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1400x1050Des_2[] = {
+static struct SiS_LVDSData XGI_LVDS1400x1050Des_2[] = {
{1308, 1068, 781, 766}, /* 00 (320x200,320x400,640x200,640x400) */
{1308, 1068, 781, 766}, /* 01 (320x350,640x350) */
{1308, 1068, 781, 766}, /* 02 (360x400,720x400) */
{ 0, 1448, 0, 1051} /* 08 (1400x1050x60Hz) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1600x1200Des_1[] = {
+static struct SiS_LVDSData XGI_LVDS1600x1200Des_1[] = {
{0, 1664, 0, 1201}, /* 00 (320x200,320x400,640x200,640x400) */
{0, 1664, 0, 1201}, /* 01 (320x350,640x350) */
{0, 1664, 0, 1201}, /* 02 (360x400,720x400) */
};
/* ; 1024x768 Full-screen */
-static struct XGI330_LVDSDataStruct XGI_LVDS1024x768Des_1x75[] = {
+static struct SiS_LVDSData XGI_LVDS1024x768Des_1x75[] = {
{0, 1040, 0, 769}, /* ; 00 (320x200,320x400,640x200,640x400) */
{0, 1040, 0, 769}, /* ; 01 (320x350,640x350) */
{0, 1040, 0, 769}, /* ; 02 (360x400,720x400) */
};
/* ; 1024x768 center-screen (Enh. Mode) */
-static struct XGI330_LVDSDataStruct XGI_LVDS1024x768Des_2x75[] = {
+static struct SiS_LVDSData XGI_LVDS1024x768Des_2x75[] = {
{1142, 856, 622, 587}, /* 00 (320x200,320x400,640x200,640x400) */
{1142, 856, 597, 562}, /* 01 (320x350,640x350) */
{1142, 856, 622, 587}, /* 02 (360x400,720x400) */
};
/* ; 1024x768 center-screen (St.Mode) */
-static struct XGI330_LVDSDataStruct XGI_LVDS1024x768Des_3x75[] = {
+static struct SiS_LVDSData XGI_LVDS1024x768Des_3x75[] = {
{320, 24, 622, 587}, /* ; 00 (320x200,320x400,640x200,640x400) */
{320, 24, 597, 562}, /* ; 01 (320x350,640x350) */
{320, 24, 622, 587}, /* ; 02 (360x400,720x400) */
{320, 24, 722, 687} /* ; 04 (640x480x60Hz) */
};
-static struct XGI330_LVDSDataStruct XGI_LVDS1280x1024Des_1x75[] = {
+static struct SiS_LVDSData XGI_LVDS1280x1024Des_1x75[] = {
{0, 1296, 0, 1025}, /* ; 00 (320x200,320x400,640x200,640x400) */
{0, 1296, 0, 1025}, /* ; 01 (320x350,640x350) */
{0, 1296, 0, 1025}, /* ; 02 (360x400,720x400) */
/* The Display setting for DE Mode Panel */
/* [ycchen] 02/18/03 Set DE as default */
-static struct XGI330_LVDSDataStruct XGI_LVDS1280x1024Des_2x75[] = {
+static struct SiS_LVDSData XGI_LVDS1280x1024Des_2x75[] = {
{1368, 976, 752, 711}, /* ; 00 (320x200,320x400,640x200,640x400) */
{1368, 976, 729, 688}, /* ; 01 (320x350,640x350) */
{1408, 976, 752, 711}, /* ; 02 (360x400,720x400) */
{0, 1328, 0, 771, 112, 6} /* ; 0A (1280x768x75Hz) */
};
-static struct XGI330_CHTVDataStruct XGI_CHTVUNTSCData[] = {
+static struct SiS_LVDSData XGI_CHTVUNTSCData[] = {
{ 840, 600, 840, 600},
{ 840, 600, 840, 600},
{ 840, 600, 840, 600},
{1064, 750, 1064, 750}
};
-static struct XGI330_CHTVDataStruct XGI_CHTVONTSCData[] = {
+static struct SiS_LVDSData XGI_CHTVONTSCData[] = {
{ 840, 525, 840, 525},
{ 840, 525, 840, 525},
{ 840, 525, 840, 525},
{1040, 700, 1040, 700}
};
-static struct XGI330_CHTVDataStruct XGI_CHTVUPALData[] = {
+static struct SiS_LVDSData XGI_CHTVUPALData[] = {
{1008, 625, 1008, 625},
{1008, 625, 1008, 625},
{1008, 625, 1008, 625},
{ 936, 836, 936, 836}
};
-static struct XGI330_CHTVDataStruct XGI_CHTVOPALData[] = {
+static struct SiS_LVDSData XGI_CHTVOPALData[] = {
{1008, 625, 1008, 625},
{1008, 625, 1008, 625},
{1008, 625, 1008, 625},
/* Dual link only */
static struct XGI330_LCDCapStruct XGI_LCDDLCapList[] = {
/* LCDCap1024x768 */
- {Panel_1024x768, DefaultLCDCap, 0, 0x012, 0x88, 0x06, VCLK65_315,
+ {Panel_1024x768, DefaultLCDCap, 0, 0x88, 0x06, VCLK65_315,
0x6C, 0xC3, 0x35, 0x62, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x28, 0x10},
/* LCDCap1280x1024 */
{Panel_1280x1024, XGI_LCDDualLink+DefaultLCDCap, StLCDBToA,
- 0x012, 0x70, 0x03, VCLK108_2_315,
+ 0x70, 0x03, VCLK108_2_315,
0x70, 0x44, 0xF8, 0x2F, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x30, 0x10},
/* LCDCap1400x1050 */
{Panel_1400x1050, XGI_LCDDualLink+DefaultLCDCap, StLCDBToA,
- 0x012, 0x70, 0x03, VCLK108_2_315,
+ 0x70, 0x03, VCLK108_2_315,
0x70, 0x44, 0xF8, 0x2F, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x30, 0x10},
/* LCDCap1600x1200 */
{Panel_1600x1200, XGI_LCDDualLink+DefaultLCDCap, LCDToFull,
- 0x012, 0xC0, 0x03, VCLK162,
+ 0xC0, 0x03, VCLK162,
0x43, 0x22, 0x70, 0x24, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x30, 0x10},
/* LCDCap1024x768x75 */
- {Panel_1024x768x75, DefaultLCDCap, 0, 0x012, 0x60, 0, VCLK78_75,
+ {Panel_1024x768x75, DefaultLCDCap, 0, 0x60, 0, VCLK78_75,
0x2B, 0x61, 0x2B, 0x61, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x28, 0x10},
/* LCDCap1280x1024x75 */
{Panel_1280x1024x75, XGI_LCDDualLink+DefaultLCDCap, StLCDBToA,
- 0x012, 0x90, 0x03, VCLK135_5,
+ 0x90, 0x03, VCLK135_5,
0x54, 0x42, 0x4A, 0x61, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x30, 0x10},
/* LCDCapDefault */
- {0xFF, DefaultLCDCap, 0, 0x012, 0x88, 0x06, VCLK65_315,
+ {0xFF, DefaultLCDCap, 0, 0x88, 0x06, VCLK65_315,
0x6C, 0xC3, 0x35, 0x62, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x28, 0x10}
};
static struct XGI330_LCDCapStruct XGI_LCDCapList[] = {
/* LCDCap1024x768 */
- {Panel_1024x768, DefaultLCDCap, 0, 0x012, 0x88, 0x06, VCLK65_315,
+ {Panel_1024x768, DefaultLCDCap, 0, 0x88, 0x06, VCLK65_315,
0x6C, 0xC3, 0x35, 0x62, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x28, 0x10},
/* LCDCap1280x1024 */
{Panel_1280x1024, DefaultLCDCap, StLCDBToA,
- 0x012, 0x70, 0x03, VCLK108_2_315,
+ 0x70, 0x03, VCLK108_2_315,
0x70, 0x44, 0xF8, 0x2F, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x30, 0x10},
/* LCDCap1400x1050 */
{Panel_1400x1050, DefaultLCDCap, StLCDBToA,
- 0x012, 0x70, 0x03, VCLK108_2_315,
+ 0x70, 0x03, VCLK108_2_315,
0x70, 0x44, 0xF8, 0x2F, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x30, 0x10},
/* LCDCap1600x1200 */
{Panel_1600x1200, DefaultLCDCap, LCDToFull,
- 0x012, 0xC0, 0x03, VCLK162,
+ 0xC0, 0x03, VCLK162,
0x5A, 0x23, 0x5A, 0x23, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x30, 0x10},
/* LCDCap1024x768x75 */
- {Panel_1024x768x75, DefaultLCDCap, 0, 0x012, 0x60, 0, VCLK78_75,
+ {Panel_1024x768x75, DefaultLCDCap, 0, 0x60, 0, VCLK78_75,
0x2B, 0x61, 0x2B, 0x61, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x28, 0x10},
/* LCDCap1280x1024x75 */
{Panel_1280x1024x75, DefaultLCDCap, StLCDBToA,
- 0x012, 0x90, 0x03, VCLK135_5,
+ 0x90, 0x03, VCLK135_5,
0x54, 0x42, 0x4A, 0x61, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x30, 0x10},
/* LCDCapDefault */
- {0xFF, DefaultLCDCap, 0, 0x012, 0x88, 0x06, VCLK65_315,
+ {0xFF, DefaultLCDCap, 0, 0x88, 0x06, VCLK65_315,
0x6C, 0xC3, 0x35, 0x62, 0x02, 0x14, 0x0A, 0x02, 0x00,
0x30, 0x10, 0x5A, 0x10, 0x10, 0x0A, 0xC0, 0x28, 0x10}
};
{1152, 864, 8, 16}
};
-static unsigned char XGI330_OutputSelect = 0x40;
-static unsigned char XGI330_SoftSetting = 0x30;
-static unsigned char XGI330_SR07 = 0x18;
-
-static unsigned char XGI330_CR49[] = {0xaa, 0x88};
-static unsigned char XGI330_SR1F;
-static unsigned char XGI330_SR21 = 0xa3;
-static unsigned char XGI330_SR22 = 0xfb;
-static unsigned char XGI330_SR23 = 0xf6;
-static unsigned char XGI330_SR24 = 0xd;
-
-static unsigned char XGI330_CRT2Data_1_2;
-static unsigned char XGI330_CRT2Data_4_D;
-static unsigned char XGI330_CRT2Data_4_E;
-static unsigned char XGI330_CRT2Data_4_10 = 0x80;
-static unsigned short XGI330_RGBSenseData = 0xd1;
-static unsigned short XGI330_VideoSenseData = 0xb9;
-static unsigned short XGI330_YCSenseData = 0xb3;
-static unsigned short XGI330_RGBSenseData2 = 0x0190; /*301b*/
-static unsigned short XGI330_VideoSenseData2 = 0x0110;
-static unsigned short XGI330_YCSenseData2 = 0x016B;
-static unsigned char XG40_I2CDefinition;
-static unsigned char XG20_CR97 = 0x10 ;
-
-static unsigned char XG21_DVOSetting;
-static unsigned char XG21_CR2E;
-static unsigned char XG21_CR2F;
-static unsigned char XG21_CR46;
-static unsigned char XG21_CR47;
-
-static unsigned char XG27_CR97 = 0xC1 ;
-static unsigned char XG27_SR36 = 0x30 ;
-static unsigned char XG27_CR8F = 0x0C ;
-static unsigned char XG27_CRD0[] = {
- 0, 0, 0, 0, 0, 0, 0, 0x82, 0x00, 0x66, 0x01, 0x00
-};
-static unsigned char XG27_CRDE[2];
-static unsigned char XG27_SR40 = 0x04 ;
-static unsigned char XG27_SR41 = 0x00 ;
-
-static unsigned char Z11m_CR97 = 0x80 ;
-
-static struct XGI330_VCLKDataStruct XGI_VCLKData[] = {
+static struct SiS_VCLKData XGI_VCLKData[] = {
/* SR2B,SR2C,SR2D */
{0x1B, 0xE1, 25}, /* 00 (25.175MHz) */
{0x4E, 0xE4, 28}, /* 01 (28.322MHz) */
{0xFF, 0x00, 0} /* End mark */
};
-static struct XGI330_VCLKDataStruct XGI_VBVCLKData[] = {
+static struct SiS_VCLKData XGI_VBVCLKData[] = {
{0x1B, 0xE1, 25}, /* 00 (25.175MHz) */
{0x4E, 0xE4, 28}, /* 01 (28.322MHz) */
{0x57, 0xE4, 31}, /* 02 (31.500MHz) */
{0xFF, 0x00, 0} /* End mark */
};
-static unsigned char XGI301TVDelayList[] = {
- 0x22, /* ; 0 ExtNTSCDelay */
- 0x22, /* ; 1 StNTSCDelay */
- 0x22, /* ; 2 ExtPALDelay */
- 0x22, /* ; 3 StPALDelay */
- 0x88, /* ; 4 ExtHiTVDelay(1080i) */
- 0xBB, /* ; 5 StHiTVDelay(1080i) */
- 0x22, /* ; 6 ExtYPbPrDelay(525i) */
- 0x22, /* ; 7 StYPbPrDealy(525i) */
- 0x22, /* ; 8 ExtYPbPrDelay(525p) */
- 0x22, /* ; 9 StYPbPrDealy(525p) */
- 0x22, /* ; A ExtYPbPrDelay(750p) */
- 0x22 /* B StYPbPrDealy(750p) */
-};
-
-static unsigned char XGI301TVDelayList2[] = {
- 0x22, /* ; 0 ExtNTSCDelay */
- 0x22, /* ; 1 StNTSCDelay */
- 0x22, /* ; 2 ExtPALDelay */
- 0x22, /* ; 3 StPALDelay */
- 0x22, /* ; 4 ExtHiTVDelay */
- 0x22, /* ; 5 StHiTVDelay */
- 0x22, /* ; 6 ExtYPbPrDelay(525i) */
- 0x22, /* ; 7 StYPbPrDealy(525i) */
- 0x22, /* ; 8 ExtYPbPrDelay(525p) */
- 0x22, /* ; 9 StYPbPrDealy(525p) */
- 0x22, /* ; A ExtYPbPrDelay(750p) */
- 0x22 /* ; B StYPbPrDealy(750p) */
-};
-
+#define XGI301TVDelay 0x22
+#define XGI301LCDDelay 0x12
static unsigned char TVAntiFlickList[] = {/* NTSCAntiFlicker */
0x04, /* ; 0 Adaptive */
}
}
};
+#endif
-#include <linux/io.h>
-#include <linux/types.h>
-
-#include "vb_def.h"
#include "vgatypes.h"
-#include "vb_struct.h"
-
-#include "XGIfb.h"
-
#include "vb_util.h"
void xgifb_reg_set(unsigned long port, u8 index, u8 data)
#ifndef _VGATYPES_
#define _VGATYPES_
-#include <linux/ioctl.h>
#include <linux/fb.h> /* for struct fb_var_screeninfo for sis.h */
#include "../../video/sis/vgatypes.h"
#include "../../video/sis/sis.h" /* for LCD_TYPE */
config ZCACHE
bool "Dynamic compression of swap pages and clean pagecache pages"
- # X86 dependency is because zsmalloc uses non-portable pte/tlb
- # functions
- depends on (CLEANCACHE || FRONTSWAP) && CRYPTO=y && X86
- select ZSMALLOC
+ depends on (CLEANCACHE || FRONTSWAP) && CRYPTO=y && ZSMALLOC=y
select CRYPTO_LZO
default n
help
#include <linux/math64.h>
#include <linux/crypto.h>
#include <linux/string.h>
+#include <linux/idr.h>
#include "tmem.h"
#include "../zsmalloc/zsmalloc.h"
(__GFP_FS | __GFP_NORETRY | __GFP_NOWARN | __GFP_NOMEMALLOC)
#endif
-#define MAX_POOLS_PER_CLIENT 16
-
#define MAX_CLIENTS 16
#define LOCAL_CLIENT ((uint16_t)-1)
MODULE_LICENSE("GPL");
struct zcache_client {
- struct tmem_pool *tmem_pools[MAX_POOLS_PER_CLIENT];
+ struct idr tmem_pools;
struct zs_pool *zspool;
bool allocated;
atomic_t refcount;
static atomic_t zv_curr_dist_counts[NCHUNKS];
static atomic_t zv_cumul_dist_counts[NCHUNKS];
-static struct zv_hdr *zv_create(struct zs_pool *pool, uint32_t pool_id,
+static unsigned long zv_create(struct zs_pool *pool, uint32_t pool_id,
struct tmem_oid *oid, uint32_t index,
void *cdata, unsigned clen)
{
struct zv_hdr *zv;
u32 size = clen + sizeof(struct zv_hdr);
int chunks = (size + (CHUNK_SIZE - 1)) >> CHUNK_SHIFT;
- void *handle = NULL;
+ unsigned long handle = 0;
BUG_ON(!irqs_disabled());
BUG_ON(chunks >= NCHUNKS);
return handle;
}
-static void zv_free(struct zs_pool *pool, void *handle)
+static void zv_free(struct zs_pool *pool, unsigned long handle)
{
unsigned long flags;
struct zv_hdr *zv;
local_irq_restore(flags);
}
-static void zv_decompress(struct page *page, void *handle)
+static void zv_decompress(struct page *page, unsigned long handle)
{
unsigned int clen = PAGE_SIZE;
char *to_va;
goto out;
atomic_inc(&cli->refcount);
}
- if (poolid < MAX_POOLS_PER_CLIENT) {
- pool = cli->tmem_pools[poolid];
- if (pool != NULL)
- atomic_inc(&pool->refcount);
- }
+ pool = idr_find(&cli->tmem_pools, poolid);
+ if (pool != NULL)
+ atomic_inc(&pool->refcount);
out:
return pool;
}
cli->zspool = zs_create_pool("zcache", ZCACHE_GFP_MASK);
if (cli->zspool == NULL)
goto out;
+ idr_init(&cli->tmem_pools);
#endif
ret = 0;
out:
int ret = 0;
BUG_ON(is_ephemeral(pool));
- zv_decompress((struct page *)(data), pampd);
+ zv_decompress((struct page *)(data), (unsigned long)pampd);
return ret;
}
atomic_dec(&zcache_curr_eph_pampd_count);
BUG_ON(atomic_read(&zcache_curr_eph_pampd_count) < 0);
} else {
- zv_free(cli->zspool, pampd);
+ zv_free(cli->zspool, (unsigned long)pampd);
atomic_dec(&zcache_curr_pers_pampd_count);
BUG_ON(atomic_read(&zcache_curr_pers_pampd_count) < 0);
}
if (cli == NULL)
goto out;
atomic_inc(&cli->refcount);
- pool = cli->tmem_pools[pool_id];
+ pool = idr_find(&cli->tmem_pools, pool_id);
if (pool == NULL)
goto out;
- cli->tmem_pools[pool_id] = NULL;
+ idr_remove(&cli->tmem_pools, pool_id);
/* wait for pool activity on other cpus to quiesce */
while (atomic_read(&pool->refcount) != 0)
;
int poolid = -1;
struct tmem_pool *pool;
struct zcache_client *cli = NULL;
+ int r;
if (cli_id == LOCAL_CLIENT)
cli = &zcache_host;
goto out;
}
- for (poolid = 0; poolid < MAX_POOLS_PER_CLIENT; poolid++)
- if (cli->tmem_pools[poolid] == NULL)
- break;
- if (poolid >= MAX_POOLS_PER_CLIENT) {
- pr_info("zcache: pool creation failed: max exceeded\n");
+ do {
+ r = idr_pre_get(&cli->tmem_pools, GFP_ATOMIC);
+ if (r != 1) {
+ kfree(pool);
+ pr_info("zcache: pool creation failed: out of memory\n");
+ goto out;
+ }
+ r = idr_get_new(&cli->tmem_pools, pool, &poolid);
+ } while (r == -EAGAIN);
+ if (r) {
+ pr_info("zcache: pool creation failed: error %d\n", r);
kfree(pool);
- poolid = -1;
goto out;
}
+
atomic_set(&pool->refcount, 0);
pool->client = cli;
pool->pool_id = poolid;
tmem_new_pool(pool, flags);
- cli->tmem_pools[poolid] = pool;
pr_info("zcache: created %s tmem pool, id=%d, client=%d\n",
flags & TMEM_POOL_PERSIST ? "persistent" : "ephemeral",
poolid, cli_id);
config ZRAM
tristate "Compressed RAM block device support"
- # X86 dependency is because zsmalloc uses non-portable pte/tlb
- # functions
- depends on BLOCK && SYSFS && X86
- select ZSMALLOC
+ depends on BLOCK && SYSFS && ZSMALLOC
select LZO_COMPRESS
select LZO_DECOMPRESS
default n
static void zram_free_page(struct zram *zram, size_t index)
{
- void *handle = zram->table[index].handle;
+ unsigned long handle = zram->table[index].handle;
+ u16 size = zram->table[index].size;
if (unlikely(!handle)) {
/*
return;
}
- if (unlikely(zram_test_flag(zram, index, ZRAM_UNCOMPRESSED))) {
- __free_page(handle);
- zram_clear_flag(zram, index, ZRAM_UNCOMPRESSED);
- zram_stat_dec(&zram->stats.pages_expand);
- goto out;
- }
+ if (unlikely(size > max_zpage_size))
+ zram_stat_dec(&zram->stats.bad_compress);
zs_free(zram->mem_pool, handle);
- if (zram->table[index].size <= PAGE_SIZE / 2)
+ if (size <= PAGE_SIZE / 2)
zram_stat_dec(&zram->stats.good_compress);
-out:
zram_stat64_sub(zram, &zram->stats.compr_size,
zram->table[index].size);
zram_stat_dec(&zram->stats.pages_stored);
- zram->table[index].handle = NULL;
+ zram->table[index].handle = 0;
zram->table[index].size = 0;
}
flush_dcache_page(page);
}
-static void handle_uncompressed_page(struct zram *zram, struct bio_vec *bvec,
- u32 index, int offset)
-{
- struct page *page = bvec->bv_page;
- unsigned char *user_mem, *cmem;
-
- user_mem = kmap_atomic(page);
- cmem = kmap_atomic(zram->table[index].handle);
-
- memcpy(user_mem + bvec->bv_offset, cmem + offset, bvec->bv_len);
- kunmap_atomic(cmem);
- kunmap_atomic(user_mem);
-
- flush_dcache_page(page);
-}
-
static inline int is_partial_io(struct bio_vec *bvec)
{
return bvec->bv_len != PAGE_SIZE;
int ret;
size_t clen;
struct page *page;
- struct zobj_header *zheader;
unsigned char *user_mem, *cmem, *uncmem = NULL;
page = bvec->bv_page;
return 0;
}
- /* Page is stored uncompressed since it's incompressible */
- if (unlikely(zram_test_flag(zram, index, ZRAM_UNCOMPRESSED))) {
- handle_uncompressed_page(zram, bvec, index, offset);
- return 0;
- }
-
if (is_partial_io(bvec)) {
/* Use a temporary buffer to decompress the page */
uncmem = kmalloc(PAGE_SIZE, GFP_KERNEL);
cmem = zs_map_object(zram->mem_pool, zram->table[index].handle);
- ret = lzo1x_decompress_safe(cmem + sizeof(*zheader),
- zram->table[index].size,
+ ret = lzo1x_decompress_safe(cmem, zram->table[index].size,
uncmem, &clen);
if (is_partial_io(bvec)) {
{
int ret;
size_t clen = PAGE_SIZE;
- struct zobj_header *zheader;
unsigned char *cmem;
+ unsigned long handle = zram->table[index].handle;
- if (zram_test_flag(zram, index, ZRAM_ZERO) ||
- !zram->table[index].handle) {
+ if (zram_test_flag(zram, index, ZRAM_ZERO) || !handle) {
memset(mem, 0, PAGE_SIZE);
return 0;
}
- cmem = zs_map_object(zram->mem_pool, zram->table[index].handle);
-
- /* Page is stored uncompressed since it's incompressible */
- if (unlikely(zram_test_flag(zram, index, ZRAM_UNCOMPRESSED))) {
- memcpy(mem, cmem, PAGE_SIZE);
- kunmap_atomic(cmem);
- return 0;
- }
-
- ret = lzo1x_decompress_safe(cmem + sizeof(*zheader),
- zram->table[index].size,
+ cmem = zs_map_object(zram->mem_pool, handle);
+ ret = lzo1x_decompress_safe(cmem, zram->table[index].size,
mem, &clen);
- zs_unmap_object(zram->mem_pool, zram->table[index].handle);
+ zs_unmap_object(zram->mem_pool, handle);
/* Should NEVER happen. Return bio error if it does. */
if (unlikely(ret != LZO_E_OK)) {
int offset)
{
int ret;
- u32 store_offset;
size_t clen;
- void *handle;
- struct zobj_header *zheader;
- struct page *page, *page_store;
+ unsigned long handle;
+ struct page *page;
unsigned char *user_mem, *cmem, *src, *uncmem = NULL;
page = bvec->bv_page;
goto out;
}
- /*
- * Page is incompressible. Store it as-is (uncompressed)
- * since we do not want to return too many disk write
- * errors which has side effect of hanging the system.
- */
- if (unlikely(clen > max_zpage_size)) {
- clen = PAGE_SIZE;
- page_store = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
- if (unlikely(!page_store)) {
- pr_info("Error allocating memory for "
- "incompressible page: %u\n", index);
- ret = -ENOMEM;
- goto out;
- }
-
- store_offset = 0;
- zram_set_flag(zram, index, ZRAM_UNCOMPRESSED);
- zram_stat_inc(&zram->stats.pages_expand);
- handle = page_store;
- src = kmap_atomic(page);
- cmem = kmap_atomic(page_store);
- goto memstore;
- }
+ if (unlikely(clen > max_zpage_size))
+ zram_stat_inc(&zram->stats.bad_compress);
- handle = zs_malloc(zram->mem_pool, clen + sizeof(*zheader));
+ handle = zs_malloc(zram->mem_pool, clen);
if (!handle) {
pr_info("Error allocating memory for compressed "
"page: %u, size=%zu\n", index, clen);
}
cmem = zs_map_object(zram->mem_pool, handle);
-memstore:
-#if 0
- /* Back-reference needed for memory defragmentation */
- if (!zram_test_flag(zram, index, ZRAM_UNCOMPRESSED)) {
- zheader = (struct zobj_header *)cmem;
- zheader->table_idx = index;
- cmem += sizeof(*zheader);
- }
-#endif
-
memcpy(cmem, src, clen);
- if (unlikely(zram_test_flag(zram, index, ZRAM_UNCOMPRESSED))) {
- kunmap_atomic(cmem);
- kunmap_atomic(src);
- } else {
- zs_unmap_object(zram->mem_pool, handle);
- }
+ zs_unmap_object(zram->mem_pool, handle);
zram->table[index].handle = handle;
zram->table[index].size = clen;
/* Free all pages that are still in this zram device */
for (index = 0; index < zram->disksize >> PAGE_SHIFT; index++) {
- void *handle = zram->table[index].handle;
+ unsigned long handle = zram->table[index].handle;
if (!handle)
continue;
- if (unlikely(zram_test_flag(zram, index, ZRAM_UNCOMPRESSED)))
- __free_page(handle);
- else
- zs_free(zram->mem_pool, handle);
+ zs_free(zram->mem_pool, handle);
}
vfree(zram->table);
zram->disk = alloc_disk(1);
if (!zram->disk) {
blk_cleanup_queue(zram->queue);
- pr_warning("Error allocating disk structure for device %d\n",
+ pr_warn("Error allocating disk structure for device %d\n",
device_id);
ret = -ENOMEM;
goto out;
ret = sysfs_create_group(&disk_to_dev(zram->disk)->kobj,
&zram_disk_attr_group);
if (ret < 0) {
- pr_warning("Error creating sysfs group");
+ pr_warn("Error creating sysfs group");
goto out;
}
int ret, dev_id;
if (num_devices > max_num_devices) {
- pr_warning("Invalid value for num_devices: %u\n",
+ pr_warn("Invalid value for num_devices: %u\n",
num_devices);
ret = -EINVAL;
goto out;
zram_major = register_blkdev(0, "zram");
if (zram_major <= 0) {
- pr_warning("Unable to get major number\n");
+ pr_warn("Unable to get major number\n");
ret = -EBUSY;
goto out;
}
*/
static const unsigned max_num_devices = 32;
-/*
- * Stored at beginning of each compressed object.
- *
- * It stores back-reference to table entry which points to this
- * object. This is required to support memory defragmentation.
- */
-struct zobj_header {
-#if 0
- u32 table_idx;
-#endif
-};
-
/*-- Configurable parameters */
/* Default zram disk size: 25% of total RAM */
/* Flags for zram pages (table[page_no].flags) */
enum zram_pageflags {
- /* Page is stored uncompressed */
- ZRAM_UNCOMPRESSED,
-
/* Page consists entirely of zeros */
ZRAM_ZERO,
/* Allocated for each disk page */
struct table {
- void *handle;
+ unsigned long handle;
u16 size; /* object size (excluding header) */
u8 count; /* object ref count (not yet used) */
u8 flags;
-} __attribute__((aligned(4)));
+} __aligned(4);
struct zram_stats {
u64 compr_size; /* compressed size of pages stored */
u32 pages_zero; /* no. of zero filled pages */
u32 pages_stored; /* no. of pages currently stored */
u32 good_compress; /* % of pages with compression ratio<=50% */
- u32 pages_expand; /* % of incompressible pages */
+ u32 bad_compress; /* % of pages with compression ratio>=75% */
};
struct zram {
u64 val = 0;
struct zram *zram = dev_to_zram(dev);
- if (zram->init_done) {
- val = zs_get_total_size_bytes(zram->mem_pool) +
- ((u64)(zram->stats.pages_expand) << PAGE_SHIFT);
- }
+ if (zram->init_done)
+ val = zs_get_total_size_bytes(zram->mem_pool);
return sprintf(buf, "%llu\n", val);
}
* Released under the terms of GNU General Public License Version 2.0
*/
+
+/*
+ * This allocator is designed for use with zcache and zram. Thus, the
+ * allocator is supposed to work well under low memory conditions. In
+ * particular, it never attempts higher order page allocation which is
+ * very likely to fail under memory pressure. On the other hand, if we
+ * just use single (0-order) pages, it would suffer from very high
+ * fragmentation -- any object of size PAGE_SIZE/2 or larger would occupy
+ * an entire page. This was one of the major issues with its predecessor
+ * (xvmalloc).
+ *
+ * To overcome these issues, zsmalloc allocates a bunch of 0-order pages
+ * and links them together using various 'struct page' fields. These linked
+ * pages act as a single higher-order page i.e. an object can span 0-order
+ * page boundaries. The code refers to these linked pages as a single entity
+ * called zspage.
+ *
+ * Following is how we use various fields and flags of underlying
+ * struct page(s) to form a zspage.
+ *
+ * Usage of struct page fields:
+ * page->first_page: points to the first component (0-order) page
+ * page->index (union with page->freelist): offset of the first object
+ * starting in this page. For the first page, this is
+ * always 0, so we use this field (aka freelist) to point
+ * to the first free object in zspage.
+ * page->lru: links together all component pages (except the first page)
+ * of a zspage
+ *
+ * For _first_ page only:
+ *
+ * page->private (union with page->first_page): refers to the
+ * component page after the first page
+ * page->freelist: points to the first free object in zspage.
+ * Free objects are linked together using in-place
+ * metadata.
+ * page->objects: maximum number of objects we can store in this
+ * zspage (class->zspage_order * PAGE_SIZE / class->size)
+ * page->lru: links together first pages of various zspages.
+ * Basically forming list of zspages in a fullness group.
+ * page->mapping: class index and fullness group of the zspage
+ *
+ * Usage of struct page flags:
+ * PG_private: identifies the first component page
+ * PG_private2: identifies the last component page
+ *
+ */
+
#ifdef CONFIG_ZSMALLOC_DEBUG
#define DEBUG
#endif
}
/* Decode <page, obj_idx> pair from the given object handle */
-static void obj_handle_to_location(void *handle, struct page **page,
+static void obj_handle_to_location(unsigned long handle, struct page **page,
unsigned long *obj_idx)
{
- unsigned long hval = (unsigned long)handle;
-
- *page = pfn_to_page(hval >> OBJ_INDEX_BITS);
- *obj_idx = hval & OBJ_INDEX_MASK;
+ *page = pfn_to_page(handle >> OBJ_INDEX_BITS);
+ *obj_idx = handle & OBJ_INDEX_MASK;
}
static unsigned long obj_idx_to_offset(struct page *page,
static struct page *alloc_zspage(struct size_class *class, gfp_t flags)
{
int i, error;
- struct page *first_page = NULL;
+ struct page *first_page = NULL, *uninitialized_var(prev_page);
/*
* Allocate individual pages and link them together as:
*/
error = -ENOMEM;
for (i = 0; i < class->pages_per_zspage; i++) {
- struct page *page, *prev_page;
+ struct page *page;
page = alloc_page(flags);
if (!page)
}
-/*
- * If this becomes a separate module, register zs_init() with
- * module_init(), zs_exit with module_exit(), and remove zs_initialized
-*/
-static int zs_initialized;
-
static int zs_cpu_notifier(struct notifier_block *nb, unsigned long action,
void *pcpu)
{
struct zs_pool *zs_create_pool(const char *name, gfp_t flags)
{
- int i, error, ovhd_size;
+ int i, ovhd_size;
struct zs_pool *pool;
if (!name)
}
- /*
- * If this becomes a separate module, register zs_init with
- * module_init, and remove this block
- */
- if (!zs_initialized) {
- error = zs_init();
- if (error)
- goto cleanup;
- zs_initialized = 1;
- }
-
pool->flags = flags;
pool->name = name;
- error = 0; /* Success */
-
-cleanup:
- if (error) {
- zs_destroy_pool(pool);
- pool = NULL;
- }
-
return pool;
}
EXPORT_SYMBOL_GPL(zs_create_pool);
* @size: size of block to allocate
*
* On success, handle to the allocated object is returned,
- * otherwise NULL.
+ * otherwise 0.
* Allocation requests with size > ZS_MAX_ALLOC_SIZE will fail.
*/
-void *zs_malloc(struct zs_pool *pool, size_t size)
+unsigned long zs_malloc(struct zs_pool *pool, size_t size)
{
- void *obj;
+ unsigned long obj;
struct link_free *link;
int class_idx;
struct size_class *class;
unsigned long m_objidx, m_offset;
if (unlikely(!size || size > ZS_MAX_ALLOC_SIZE))
- return NULL;
+ return 0;
class_idx = get_size_class_index(size);
class = &pool->size_class[class_idx];
spin_unlock(&class->lock);
first_page = alloc_zspage(class, pool->flags);
if (unlikely(!first_page))
- return NULL;
+ return 0;
set_zspage_mapping(first_page, class->index, ZS_EMPTY);
spin_lock(&class->lock);
class->pages_allocated += class->pages_per_zspage;
}
- obj = first_page->freelist;
+ obj = (unsigned long)first_page->freelist;
obj_handle_to_location(obj, &m_page, &m_objidx);
m_offset = obj_idx_to_offset(m_page, m_objidx, class->size);
}
EXPORT_SYMBOL_GPL(zs_malloc);
-void zs_free(struct zs_pool *pool, void *obj)
+void zs_free(struct zs_pool *pool, unsigned long obj)
{
struct link_free *link;
struct page *first_page, *f_page;
+ f_offset);
link->next = first_page->freelist;
kunmap_atomic(link);
- first_page->freelist = obj;
+ first_page->freelist = (void *)obj;
first_page->inuse--;
fullness = fix_fullness_group(pool, first_page);
* this function. When done with the object, it must be unmapped using
* zs_unmap_object
*/
-void *zs_map_object(struct zs_pool *pool, void *handle)
+void *zs_map_object(struct zs_pool *pool, unsigned long handle)
{
struct page *page;
unsigned long obj_idx, off;
}
EXPORT_SYMBOL_GPL(zs_map_object);
-void zs_unmap_object(struct zs_pool *pool, void *handle)
+void zs_unmap_object(struct zs_pool *pool, unsigned long handle)
{
struct page *page;
unsigned long obj_idx, off;
return npages << PAGE_SHIFT;
}
EXPORT_SYMBOL_GPL(zs_get_total_size_bytes);
+
+module_init(zs_init);
+module_exit(zs_exit);
+
+MODULE_LICENSE("Dual BSD/GPL");
+MODULE_AUTHOR("Nitin Gupta <ngupta@vflare.org>");
struct zs_pool *zs_create_pool(const char *name, gfp_t flags);
void zs_destroy_pool(struct zs_pool *pool);
-void *zs_malloc(struct zs_pool *pool, size_t size);
-void zs_free(struct zs_pool *pool, void *obj);
+unsigned long zs_malloc(struct zs_pool *pool, size_t size);
+void zs_free(struct zs_pool *pool, unsigned long obj);
-void *zs_map_object(struct zs_pool *pool, void *handle);
-void zs_unmap_object(struct zs_pool *pool, void *handle);
+void *zs_map_object(struct zs_pool *pool, unsigned long handle);
+void zs_unmap_object(struct zs_pool *pool, unsigned long handle);
u64 zs_get_total_size_bytes(struct zs_pool *pool);
If you don't have a platform persistent store driver,
say N.
+config PSTORE_CONSOLE
+ bool "Log kernel console messages"
+ depends on PSTORE
+ help
+ When the option is enabled, pstore will log all kernel
+ messages, even if no oops or panic happened.
+
config PSTORE_RAM
tristate "Log panic/oops to a RAM buffer"
depends on PSTORE
case PSTORE_TYPE_DMESG:
sprintf(name, "dmesg-%s-%lld", psname, id);
break;
+ case PSTORE_TYPE_CONSOLE:
+ sprintf(name, "console-%s", psname);
+ break;
case PSTORE_TYPE_MCE:
sprintf(name, "mce-%s-%lld", psname, id);
break;
/*
* Persistent Storage - platform driver interface parts.
*
+ * Copyright (C) 2007-2008 Google, Inc.
* Copyright (C) 2010 Intel Corporation <tony.luck@intel.com>
*
* This program is free software; you can redistribute it and/or modify
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/kmsg_dump.h>
+#include <linux/console.h>
#include <linux/module.h>
#include <linux/pstore.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/hardirq.h>
+#include <linux/jiffies.h>
#include <linux/workqueue.h>
#include "internal.h"
* whether the system is actually still running well enough
* to let someone see the entry
*/
-#define PSTORE_INTERVAL (60 * HZ)
+static int pstore_update_ms = -1;
+module_param_named(update_ms, pstore_update_ms, int, 0600);
+MODULE_PARM_DESC(update_ms, "milliseconds before pstore updates its content "
+ "(default is -1, which means runtime updates are disabled; "
+ "enabling this option is not safe, it may lead to further "
+ "corruption on Oopses)");
static int pstore_new_entry;
.dump = pstore_dump,
};
+#ifdef CONFIG_PSTORE_CONSOLE
+static void pstore_console_write(struct console *con, const char *s, unsigned c)
+{
+ const char *e = s + c;
+
+ while (s < e) {
+ unsigned long flags;
+
+ if (c > psinfo->bufsize)
+ c = psinfo->bufsize;
+ spin_lock_irqsave(&psinfo->buf_lock, flags);
+ memcpy(psinfo->buf, s, c);
+ psinfo->write(PSTORE_TYPE_CONSOLE, 0, NULL, 0, c, psinfo);
+ spin_unlock_irqrestore(&psinfo->buf_lock, flags);
+ s += c;
+ c = e - s;
+ }
+}
+
+static struct console pstore_console = {
+ .name = "pstore",
+ .write = pstore_console_write,
+ .flags = CON_PRINTBUFFER | CON_ENABLED | CON_ANYTIME,
+ .index = -1,
+};
+
+static void pstore_register_console(void)
+{
+ register_console(&pstore_console);
+}
+#else
+static void pstore_register_console(void) {}
+#endif
+
/*
* platform specific persistent storage driver registers with
* us here. If pstore is already mounted, call the platform
pstore_get_records(0);
kmsg_dump_register(&pstore_dumper);
+ pstore_register_console();
- pstore_timer.expires = jiffies + PSTORE_INTERVAL;
- add_timer(&pstore_timer);
+ if (pstore_update_ms >= 0) {
+ pstore_timer.expires = jiffies +
+ msecs_to_jiffies(pstore_update_ms);
+ add_timer(&pstore_timer);
+ }
return 0;
}
schedule_work(&pstore_work);
}
- mod_timer(&pstore_timer, jiffies + PSTORE_INTERVAL);
+ mod_timer(&pstore_timer, jiffies + msecs_to_jiffies(pstore_update_ms));
}
module_param(backend, charp, 0444);
MODULE_PARM_DESC(record_size,
"size of each dump done on oops/panic");
+static ulong ramoops_console_size = MIN_MEM_SIZE;
+module_param_named(console_size, ramoops_console_size, ulong, 0400);
+MODULE_PARM_DESC(console_size, "size of kernel console log");
+
static ulong mem_address;
module_param(mem_address, ulong, 0400);
MODULE_PARM_DESC(mem_address,
struct ramoops_context {
struct persistent_ram_zone **przs;
+ struct persistent_ram_zone *cprz;
phys_addr_t phys_addr;
unsigned long size;
size_t record_size;
+ size_t console_size;
int dump_oops;
bool ecc;
- unsigned int count;
- unsigned int max_count;
- unsigned int read_count;
+ unsigned int max_dump_cnt;
+ unsigned int dump_write_cnt;
+ unsigned int dump_read_cnt;
+ unsigned int console_read_cnt;
struct pstore_info pstore;
};
{
struct ramoops_context *cxt = psi->data;
- cxt->read_count = 0;
+ cxt->dump_read_cnt = 0;
+ cxt->console_read_cnt = 0;
return 0;
}
+static struct persistent_ram_zone *
+ramoops_get_next_prz(struct persistent_ram_zone *przs[], uint *c, uint max,
+ u64 *id,
+ enum pstore_type_id *typep, enum pstore_type_id type,
+ bool update)
+{
+ struct persistent_ram_zone *prz;
+ int i = (*c)++;
+
+ if (i >= max)
+ return NULL;
+
+ prz = przs[i];
+
+ if (update) {
+ /* Update old/shadowed buffer. */
+ persistent_ram_save_old(prz);
+ if (!persistent_ram_old_size(prz))
+ return NULL;
+ }
+
+ *typep = type;
+ *id = i;
+
+ return prz;
+}
+
static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
struct timespec *time,
char **buf,
struct ramoops_context *cxt = psi->data;
struct persistent_ram_zone *prz;
- if (cxt->read_count >= cxt->max_count)
- return -EINVAL;
+ prz = ramoops_get_next_prz(cxt->przs, &cxt->dump_read_cnt,
+ cxt->max_dump_cnt, id, type,
+ PSTORE_TYPE_DMESG, 1);
+ if (!prz)
+ prz = ramoops_get_next_prz(&cxt->cprz, &cxt->console_read_cnt,
+ 1, id, type, PSTORE_TYPE_CONSOLE, 0);
+ if (!prz)
+ return 0;
- *id = cxt->read_count++;
- prz = cxt->przs[*id];
-
- /* Only supports dmesg output so far. */
- *type = PSTORE_TYPE_DMESG;
/* TODO(kees): Bogus time for the moment. */
time->tv_sec = 0;
time->tv_nsec = 0;
- /* Update old/shadowed buffer. */
- persistent_ram_save_old(prz);
size = persistent_ram_old_size(prz);
*buf = kmalloc(size, GFP_KERNEL);
if (*buf == NULL)
size_t size, struct pstore_info *psi)
{
struct ramoops_context *cxt = psi->data;
- struct persistent_ram_zone *prz = cxt->przs[cxt->count];
+ struct persistent_ram_zone *prz = cxt->przs[cxt->dump_write_cnt];
size_t hlen;
- /* Currently ramoops is designed to only store dmesg dumps. */
+ if (type == PSTORE_TYPE_CONSOLE) {
+ if (!cxt->cprz)
+ return -ENOMEM;
+ persistent_ram_write(cxt->cprz, cxt->pstore.buf, size);
+ return 0;
+ }
+
if (type != PSTORE_TYPE_DMESG)
return -EINVAL;
size = prz->buffer_size - hlen;
persistent_ram_write(prz, cxt->pstore.buf, size);
- cxt->count = (cxt->count + 1) % cxt->max_count;
+ cxt->dump_write_cnt = (cxt->dump_write_cnt + 1) % cxt->max_dump_cnt;
return 0;
}
struct pstore_info *psi)
{
struct ramoops_context *cxt = psi->data;
+ struct persistent_ram_zone *prz;
- if (id >= cxt->max_count)
+ switch (type) {
+ case PSTORE_TYPE_DMESG:
+ if (id >= cxt->max_dump_cnt)
+ return -EINVAL;
+ prz = cxt->przs[id];
+ break;
+ case PSTORE_TYPE_CONSOLE:
+ prz = cxt->cprz;
+ break;
+ default:
return -EINVAL;
+ }
- persistent_ram_free_old(cxt->przs[id]);
- persistent_ram_zap(cxt->przs[id]);
+ persistent_ram_free_old(prz);
+ persistent_ram_zap(prz);
return 0;
}
},
};
-static int __init ramoops_probe(struct platform_device *pdev)
+static void ramoops_free_przs(struct ramoops_context *cxt)
+{
+ int i;
+
+ if (!cxt->przs)
+ return;
+
+ for (i = 0; !IS_ERR_OR_NULL(cxt->przs[i]); i++)
+ persistent_ram_free(cxt->przs[i]);
+ kfree(cxt->przs);
+}
+
+static int ramoops_init_przs(struct device *dev, struct ramoops_context *cxt,
+ phys_addr_t *paddr, size_t dump_mem_sz)
+{
+ int err = -ENOMEM;
+ int i;
+
+ if (!cxt->record_size)
+ return 0;
+
+ cxt->max_dump_cnt = dump_mem_sz / cxt->record_size;
+ if (!cxt->max_dump_cnt)
+ return -ENOMEM;
+
+ cxt->przs = kzalloc(sizeof(*cxt->przs) * cxt->max_dump_cnt,
+ GFP_KERNEL);
+ if (!cxt->przs) {
+ dev_err(dev, "failed to initialize a prz array for dumps\n");
+ return -ENOMEM;
+ }
+
+ for (i = 0; i < cxt->max_dump_cnt; i++) {
+ size_t sz = cxt->record_size;
+
+ cxt->przs[i] = persistent_ram_new(*paddr, sz, cxt->ecc);
+ if (IS_ERR(cxt->przs[i])) {
+ err = PTR_ERR(cxt->przs[i]);
+ dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
+ sz, (unsigned long long)*paddr, err);
+ goto fail_prz;
+ }
+ *paddr += sz;
+ }
+
+ return 0;
+fail_prz:
+ ramoops_free_przs(cxt);
+ return err;
+}
+
+static int ramoops_init_prz(struct device *dev, struct ramoops_context *cxt,
+ struct persistent_ram_zone **prz,
+ phys_addr_t *paddr, size_t sz)
+{
+ if (!sz)
+ return 0;
+
+ if (*paddr + sz > *paddr + cxt->size)
+ return -ENOMEM;
+
+ *prz = persistent_ram_new(*paddr, sz, cxt->ecc);
+ if (IS_ERR(*prz)) {
+ int err = PTR_ERR(*prz);
+
+ dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
+ sz, (unsigned long long)*paddr, err);
+ return err;
+ }
+
+ persistent_ram_zap(*prz);
+
+ *paddr += sz;
+
+ return 0;
+}
+
+static int __devinit ramoops_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct ramoops_platform_data *pdata = pdev->dev.platform_data;
struct ramoops_context *cxt = &oops_cxt;
+ size_t dump_mem_sz;
+ phys_addr_t paddr;
int err = -EINVAL;
- int i;
/* Only a single ramoops area allowed at a time, so fail extra
* probes.
*/
- if (cxt->max_count)
+ if (cxt->max_dump_cnt)
goto fail_out;
- if (!pdata->mem_size || !pdata->record_size) {
- pr_err("The memory size and the record size must be "
+ if (!pdata->mem_size || (!pdata->record_size && !pdata->console_size)) {
+ pr_err("The memory size and the record/console size must be "
"non-zero\n");
goto fail_out;
}
pdata->mem_size = rounddown_pow_of_two(pdata->mem_size);
pdata->record_size = rounddown_pow_of_two(pdata->record_size);
+ pdata->console_size = rounddown_pow_of_two(pdata->console_size);
- /* Check for the minimum memory size */
- if (pdata->mem_size < MIN_MEM_SIZE &&
- pdata->record_size < MIN_MEM_SIZE) {
- pr_err("memory size too small, minimum is %lu\n",
- MIN_MEM_SIZE);
- goto fail_out;
- }
-
- if (pdata->mem_size < pdata->record_size) {
- pr_err("The memory size must be larger than the "
- "records size\n");
- goto fail_out;
- }
-
- cxt->max_count = pdata->mem_size / pdata->record_size;
- cxt->count = 0;
+ cxt->dump_read_cnt = 0;
cxt->size = pdata->mem_size;
cxt->phys_addr = pdata->mem_address;
cxt->record_size = pdata->record_size;
+ cxt->console_size = pdata->console_size;
cxt->dump_oops = pdata->dump_oops;
cxt->ecc = pdata->ecc;
- cxt->przs = kzalloc(sizeof(*cxt->przs) * cxt->max_count, GFP_KERNEL);
- if (!cxt->przs) {
- err = -ENOMEM;
- dev_err(dev, "failed to initialize a prz array\n");
+ paddr = cxt->phys_addr;
+
+ dump_mem_sz = cxt->size - cxt->console_size;
+ err = ramoops_init_przs(dev, cxt, &paddr, dump_mem_sz);
+ if (err)
goto fail_out;
- }
- for (i = 0; i < cxt->max_count; i++) {
- size_t sz = cxt->record_size;
- phys_addr_t start = cxt->phys_addr + sz * i;
+ err = ramoops_init_prz(dev, cxt, &cxt->cprz, &paddr, cxt->console_size);
+ if (err)
+ goto fail_init_cprz;
- cxt->przs[i] = persistent_ram_new(start, sz, cxt->ecc);
- if (IS_ERR(cxt->przs[i])) {
- err = PTR_ERR(cxt->przs[i]);
- dev_err(dev, "failed to request mem region (0x%zx@0x%llx): %d\n",
- sz, (unsigned long long)start, err);
- goto fail_przs;
- }
+ if (!cxt->przs && !cxt->cprz) {
+ pr_err("memory size too small, minimum is %lu\n",
+ cxt->console_size + cxt->record_size);
+ goto fail_cnt;
}
cxt->pstore.data = cxt;
- cxt->pstore.bufsize = cxt->przs[0]->buffer_size;
+ /*
+ * Console can handle any buffer size, so prefer dumps buffer
+ * size since usually it is smaller.
+ */
+ if (cxt->przs)
+ cxt->pstore.bufsize = cxt->przs[0]->buffer_size;
+ else
+ cxt->pstore.bufsize = cxt->cprz->buffer_size;
cxt->pstore.buf = kmalloc(cxt->pstore.bufsize, GFP_KERNEL);
spin_lock_init(&cxt->pstore.buf_lock);
if (!cxt->pstore.buf) {
record_size = pdata->record_size;
dump_oops = pdata->dump_oops;
- pr_info("attached 0x%lx@0x%llx (%ux0x%zx), ecc: %s\n",
+ pr_info("attached 0x%lx@0x%llx, ecc: %s\n",
cxt->size, (unsigned long long)cxt->phys_addr,
- cxt->max_count, cxt->record_size,
ramoops_ecc ? "on" : "off");
return 0;
kfree(cxt->pstore.buf);
fail_clear:
cxt->pstore.bufsize = 0;
- cxt->max_count = 0;
-fail_przs:
- for (i = 0; cxt->przs[i]; i++)
- persistent_ram_free(cxt->przs[i]);
- kfree(cxt->przs);
+ cxt->max_dump_cnt = 0;
+fail_cnt:
+ kfree(cxt->cprz);
+fail_init_cprz:
+ ramoops_free_przs(cxt);
fail_out:
return err;
}
iounmap(cxt->virt_addr);
release_mem_region(cxt->phys_addr, cxt->size);
- cxt->max_count = 0;
+ cxt->max_dump_cnt = 0;
/* TODO(kees): When pstore supports unregistering, call it here. */
kfree(cxt->pstore.buf);
}
static struct platform_driver ramoops_driver = {
+ .probe = ramoops_probe,
.remove = __exit_p(ramoops_remove),
.driver = {
.name = "ramoops",
},
};
-static int __init ramoops_init(void)
+static void ramoops_register_dummy(void)
{
- int ret;
- ret = platform_driver_probe(&ramoops_driver, ramoops_probe);
- if (ret == -ENODEV) {
- /*
- * If we didn't find a platform device, we use module parameters
- * building platform data on the fly.
- */
- pr_info("platform device not found, using module parameters\n");
- dummy_data = kzalloc(sizeof(struct ramoops_platform_data),
- GFP_KERNEL);
- if (!dummy_data)
- return -ENOMEM;
- dummy_data->mem_size = mem_size;
- dummy_data->mem_address = mem_address;
- dummy_data->record_size = record_size;
- dummy_data->dump_oops = dump_oops;
- dummy_data->ecc = ramoops_ecc;
- dummy = platform_create_bundle(&ramoops_driver, ramoops_probe,
- NULL, 0, dummy_data,
- sizeof(struct ramoops_platform_data));
-
- if (IS_ERR(dummy))
- ret = PTR_ERR(dummy);
- else
- ret = 0;
+ if (!mem_size)
+ return;
+
+ pr_info("using module parameters\n");
+
+ dummy_data = kzalloc(sizeof(*dummy_data), GFP_KERNEL);
+ if (!dummy_data) {
+ pr_info("could not allocate pdata\n");
+ return;
}
- return ret;
+ dummy_data->mem_size = mem_size;
+ dummy_data->mem_address = mem_address;
+ dummy_data->record_size = record_size;
+ dummy_data->console_size = ramoops_console_size;
+ dummy_data->dump_oops = dump_oops;
+ dummy_data->ecc = ramoops_ecc;
+
+ dummy = platform_device_register_data(NULL, "ramoops", -1,
+ dummy_data, sizeof(struct ramoops_platform_data));
+ if (IS_ERR(dummy)) {
+ pr_info("could not create platform device: %ld\n",
+ PTR_ERR(dummy));
+ }
}
+static int __init ramoops_init(void)
+{
+ ramoops_register_dummy();
+ return platform_driver_register(&ramoops_driver);
+}
+postcore_initcall(ramoops_init);
+
static void __exit ramoops_exit(void)
{
platform_driver_unregister(&ramoops_driver);
kfree(dummy_data);
}
-
-module_init(ramoops_init);
module_exit(ramoops_exit);
MODULE_LICENSE("GPL");
#define PERSISTENT_RAM_SIG (0x43474244) /* DBGC */
-static __initdata LIST_HEAD(persistent_ram_list);
-
static inline size_t buffer_size(struct persistent_ram_zone *prz)
{
return atomic_read(&prz->buffer->size);
}
}
-static int persistent_ram_init_ecc(struct persistent_ram_zone *prz,
- size_t buffer_size)
+static int persistent_ram_init_ecc(struct persistent_ram_zone *prz)
{
int numerr;
struct persistent_ram_buffer *buffer = prz->buffer;
int ecc_blocks;
+ size_t ecc_total;
if (!prz->ecc)
return 0;
prz->ecc_poly = 0x11d;
ecc_blocks = DIV_ROUND_UP(prz->buffer_size, prz->ecc_block_size);
- prz->buffer_size -= (ecc_blocks + 1) * prz->ecc_size;
-
- if (prz->buffer_size > buffer_size) {
- pr_err("persistent_ram: invalid size %zu, non-ecc datasize %zu\n",
- buffer_size, prz->buffer_size);
+ ecc_total = (ecc_blocks + 1) * prz->ecc_size;
+ if (ecc_total >= prz->buffer_size) {
+ pr_err("%s: invalid ecc_size %u (total %zu, buffer size %zu)\n",
+ __func__, prz->ecc_size, ecc_total, prz->buffer_size);
return -EINVAL;
}
+ prz->buffer_size -= ecc_total;
prz->par_buffer = buffer->data + prz->buffer_size;
prz->par_header = prz->par_buffer + ecc_blocks * prz->ecc_size;
return 0;
}
-static int __init persistent_ram_post_init(struct persistent_ram_zone *prz, bool ecc)
+static int __devinit persistent_ram_post_init(struct persistent_ram_zone *prz,
+ bool ecc)
{
int ret;
prz->ecc = ecc;
- ret = persistent_ram_init_ecc(prz, prz->buffer_size);
+ ret = persistent_ram_init_ecc(prz);
if (ret)
return ret;
" size %zu, start %zu\n",
buffer_size(prz), buffer_start(prz));
else {
- pr_info("persistent_ram: found existing buffer,"
+ pr_debug("persistent_ram: found existing buffer,"
" size %zu, start %zu\n",
buffer_size(prz), buffer_start(prz));
persistent_ram_save_old(prz);
return 0;
}
} else {
- pr_info("persistent_ram: no valid data in buffer"
+ pr_debug("persistent_ram: no valid data in buffer"
" (sig = 0x%08x)\n", prz->buffer->sig);
}
void persistent_ram_free(struct persistent_ram_zone *prz)
{
- if (pfn_valid(prz->paddr >> PAGE_SHIFT)) {
- vunmap(prz->vaddr);
- } else {
- iounmap(prz->vaddr);
- release_mem_region(prz->paddr, prz->size);
+ if (!prz)
+ return;
+
+ if (prz->vaddr) {
+ if (pfn_valid(prz->paddr >> PAGE_SHIFT)) {
+ vunmap(prz->vaddr);
+ } else {
+ iounmap(prz->vaddr);
+ release_mem_region(prz->paddr, prz->size);
+ }
+ prz->vaddr = NULL;
}
persistent_ram_free_old(prz);
kfree(prz);
}
-struct persistent_ram_zone * __init persistent_ram_new(phys_addr_t start,
- size_t size,
- bool ecc)
+struct persistent_ram_zone * __devinit persistent_ram_new(phys_addr_t start,
+ size_t size,
+ bool ecc)
{
struct persistent_ram_zone *prz;
int ret = -ENOMEM;
if (ret)
goto err;
- persistent_ram_post_init(prz, ecc);
-
- return prz;
-err:
- kfree(prz);
- return ERR_PTR(ret);
-}
-
-#ifndef MODULE
-static int __init persistent_ram_buffer_init(const char *name,
- struct persistent_ram_zone *prz)
-{
- int i;
- struct persistent_ram *ram;
- struct persistent_ram_descriptor *desc;
- phys_addr_t start;
-
- list_for_each_entry(ram, &persistent_ram_list, node) {
- start = ram->start;
- for (i = 0; i < ram->num_descs; i++) {
- desc = &ram->descs[i];
- if (!strcmp(desc->name, name))
- return persistent_ram_buffer_map(start,
- desc->size, prz);
- start += desc->size;
- }
- }
-
- return -EINVAL;
-}
-
-static __init
-struct persistent_ram_zone *__persistent_ram_init(struct device *dev, bool ecc)
-{
- struct persistent_ram_zone *prz;
- int ret = -ENOMEM;
-
- prz = kzalloc(sizeof(struct persistent_ram_zone), GFP_KERNEL);
- if (!prz) {
- pr_err("persistent_ram: failed to allocate persistent ram zone\n");
- goto err;
- }
-
- ret = persistent_ram_buffer_init(dev_name(dev), prz);
- if (ret) {
- pr_err("persistent_ram: failed to initialize buffer\n");
+ ret = persistent_ram_post_init(prz, ecc);
+ if (ret)
goto err;
- }
-
- persistent_ram_post_init(prz, ecc);
return prz;
err:
- kfree(prz);
+ persistent_ram_free(prz);
return ERR_PTR(ret);
}
-
-struct persistent_ram_zone * __init
-persistent_ram_init_ringbuffer(struct device *dev, bool ecc)
-{
- return __persistent_ram_init(dev, ecc);
-}
-
-int __init persistent_ram_early_init(struct persistent_ram *ram)
-{
- int ret;
-
- ret = memblock_reserve(ram->start, ram->size);
- if (ret) {
- pr_err("Failed to reserve persistent memory from %08lx-%08lx\n",
- (long)ram->start, (long)(ram->start + ram->size - 1));
- return ret;
- }
-
- list_add_tail(&ram->node, &persistent_ram_list);
-
- pr_info("Initialized persistent memory from %08lx-%08lx\n",
- (long)ram->start, (long)(ram->start + ram->size - 1));
-
- return 0;
-}
-#endif
header-y += if_pppol2tp.h
header-y += if_pppox.h
header-y += if_slip.h
-header-y += if_strip.h
header-y += if_team.h
header-y += if_tun.h
header-y += if_tunnel.h
+++ /dev/null
-/*
- * if_strip.h --
- *
- * Definitions for the STRIP interface
- *
- * Copyright 1996 The Board of Trustees of The Leland Stanford
- * Junior University. All Rights Reserved.
- *
- * Permission to use, copy, modify, and distribute this
- * software and its documentation for any purpose and without
- * fee is hereby granted, provided that the above copyright
- * notice appear in all copies. Stanford University
- * makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without
- * express or implied warranty.
- */
-
-#ifndef __LINUX_STRIP_H
-#define __LINUX_STRIP_H
-
-#include <linux/types.h>
-
-typedef struct {
- __u8 c[6];
-} MetricomAddress;
-
-#endif
}
static inline void iio_buffer_unregister(struct iio_dev *indio_dev)
-{};
+{}
#endif /* CONFIG_IIO_BUFFER */
--- /dev/null
+#ifndef __IIO_DAC_AD5421_H__
+#define __IIO_DAC_AD5421_H__
+
+/**
+ * enum ad5421_current_range - Current range the AD5421 is configured for.
+ * @AD5421_CURRENT_RANGE_4mA_20mA: 4 mA to 20 mA (RANGE1,0 pins = 00)
+ * @AD5421_CURRENT_RANGE_3mA8_21mA: 3.8 mA to 21 mA (RANGE1,0 pins = x1)
+ * @AD5421_CURRENT_RANGE_3mA2_24mA: 3.2 mA to 24 mA (RANGE1,0 pins = 10)
+ */
+
+enum ad5421_current_range {
+ AD5421_CURRENT_RANGE_4mA_20mA,
+ AD5421_CURRENT_RANGE_3mA8_21mA,
+ AD5421_CURRENT_RANGE_3mA2_24mA,
+};
+
+/**
+ * struct ad5421_platform_data - AD5421 DAC driver platform data
+ * @external_vref: whether an external reference voltage is used or not
+ * @current_range: Current range the AD5421 is configured for
+ */
+
+struct ad5421_platform_data {
+ bool external_vref;
+ enum ad5421_current_range current_range;
+};
+
+#endif
--- /dev/null
+/*
+ * AD5504 SPI DAC driver
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef SPI_AD5504_H_
+#define SPI_AD5504_H_
+
+struct ad5504_platform_data {
+ u16 vref_mv;
+};
+
+#endif /* SPI_AD5504_H_ */
--- /dev/null
+/*
+ * AD5791 SPI DAC driver
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef SPI_AD5791_H_
+#define SPI_AD5791_H_
+
+/**
+ * struct ad5791_platform_data - platform specific information
+ * @vref_pos_mv: Vdd Positive Analog Supply Volatge (mV)
+ * @vref_neg_mv: Vdd Negative Analog Supply Volatge (mV)
+ * @use_rbuf_gain2: ext. amplifier connected in gain of two configuration
+ */
+
+struct ad5791_platform_data {
+ u16 vref_pos_mv;
+ u16 vref_neg_mv;
+ bool use_rbuf_gain2;
+};
+
+#endif /* SPI_AD5791_H_ */
--- /dev/null
+/*
+ * MAX517 DAC driver
+ *
+ * Copyright 2011 Roland Stigge <stigge@antcom.de>
+ *
+ * Licensed under the GPL-2 or later.
+ */
+#ifndef IIO_DAC_MAX517_H_
+#define IIO_DAC_MAX517_H_
+
+struct max517_platform_data {
+ u16 vref_mv[2];
+};
+
+#endif /* IIO_DAC_MAX517_H_ */
--- /dev/null
+/*
+ * MCP4725 DAC driver
+ *
+ * Copyright (C) 2012 Peter Meerwald <pmeerw@pmeerw.net>
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#ifndef IIO_DAC_MCP4725_H_
+#define IIO_DAC_MCP4725_H_
+
+struct mcp4725_platform_data {
+ u16 vref_mv;
+};
+
+#endif /* IIO_DAC_MCP4725_H_ */
* @diff: Whether the event is for an differential channel or not.
* @modifier: Modifier for the channel. Should be one of enum iio_modifier.
* @direction: Direction of the event. One of enum iio_event_direction.
- * @type: Type of the event. Should be one enum iio_event_type.
+ * @type: Type of the event. Should be one of enum iio_event_type.
* @chan: Channel number for non-differential channels.
* @chan1: First channel number for differential channels.
* @chan2: Second channel number for differential channels.
* @chan_type: Type of the channel. Should be one of enum iio_chan_type.
* @number: Channel number.
* @modifier: Modifier for the channel. Should be one of enum iio_modifier.
- * @type: Type of the event. Should be one enum iio_event_type.
+ * @type: Type of the event. Should be one of enum iio_event_type.
* @direction: Direction of the event. One of enum iio_event_direction.
*/
* IIO_UNMOD_EVENT_CODE() - create event identifier for unmodified channels
* @chan_type: Type of the channel. Should be one of enum iio_chan_type.
* @number: Channel number.
- * @type: Type of the event. Should be one enum iio_event_type.
+ * @type: Type of the event. Should be one of enum iio_event_type.
* @direction: Direction of the event. One of enum iio_event_direction.
*/
--- /dev/null
+/*
+ * AD9523 SPI Low Jitter Clock Generator
+ *
+ * Copyright 2012 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef IIO_FREQUENCY_AD9523_H_
+#define IIO_FREQUENCY_AD9523_H_
+
+enum outp_drv_mode {
+ TRISTATE,
+ LVPECL_8mA,
+ LVDS_4mA,
+ LVDS_7mA,
+ HSTL0_16mA,
+ HSTL1_8mA,
+ CMOS_CONF1,
+ CMOS_CONF2,
+ CMOS_CONF3,
+ CMOS_CONF4,
+ CMOS_CONF5,
+ CMOS_CONF6,
+ CMOS_CONF7,
+ CMOS_CONF8,
+ CMOS_CONF9
+};
+
+enum ref_sel_mode {
+ NONEREVERTIVE_STAY_ON_REFB,
+ REVERT_TO_REFA,
+ SELECT_REFA,
+ SELECT_REFB,
+ EXT_REF_SEL
+};
+
+/**
+ * struct ad9523_channel_spec - Output channel configuration
+ *
+ * @channel_num: Output channel number.
+ * @divider_output_invert_en: Invert the polarity of the output clock.
+ * @sync_ignore_en: Ignore chip-level SYNC signal.
+ * @low_power_mode_en: Reduce power used in the differential output modes.
+ * @use_alt_clock_src: Channel divider uses alternative clk source.
+ * @output_dis: Disables, powers down the entire channel.
+ * @driver_mode: Output driver mode (logic level family).
+ * @divider_phase: Divider initial phase after a SYNC. Range 0..63
+ LSB = 1/2 of a period of the divider input clock.
+ * @channel_divider: 10-bit channel divider.
+ * @extended_name: Optional descriptive channel name.
+ */
+
+struct ad9523_channel_spec {
+ unsigned channel_num;
+ bool divider_output_invert_en;
+ bool sync_ignore_en;
+ bool low_power_mode_en;
+ /* CH0..CH3 VCXO, CH4..CH9 VCO2 */
+ bool use_alt_clock_src;
+ bool output_dis;
+ enum outp_drv_mode driver_mode;
+ unsigned char divider_phase;
+ unsigned short channel_divider;
+ char extended_name[16];
+};
+
+enum pll1_rzero_resistor {
+ RZERO_883_OHM,
+ RZERO_677_OHM,
+ RZERO_341_OHM,
+ RZERO_135_OHM,
+ RZERO_10_OHM,
+ RZERO_USE_EXT_RES = 8,
+};
+
+enum rpole2_resistor {
+ RPOLE2_900_OHM,
+ RPOLE2_450_OHM,
+ RPOLE2_300_OHM,
+ RPOLE2_225_OHM,
+};
+
+enum rzero_resistor {
+ RZERO_3250_OHM,
+ RZERO_2750_OHM,
+ RZERO_2250_OHM,
+ RZERO_2100_OHM,
+ RZERO_3000_OHM,
+ RZERO_2500_OHM,
+ RZERO_2000_OHM,
+ RZERO_1850_OHM,
+};
+
+enum cpole1_capacitor {
+ CPOLE1_0_PF,
+ CPOLE1_8_PF,
+ CPOLE1_16_PF,
+ CPOLE1_24_PF,
+ _CPOLE1_24_PF, /* place holder */
+ CPOLE1_32_PF,
+ CPOLE1_40_PF,
+ CPOLE1_48_PF,
+};
+
+/**
+ * struct ad9523_platform_data - platform specific information
+ *
+ * @vcxo_freq: External VCXO frequency in Hz
+ * @refa_diff_rcv_en: REFA differential/single-ended input selection.
+ * @refb_diff_rcv_en: REFB differential/single-ended input selection.
+ * @zd_in_diff_en: Zero Delay differential/single-ended input selection.
+ * @osc_in_diff_en: OSC differential/ single-ended input selection.
+ * @refa_cmos_neg_inp_en: REFA single-ended neg./pos. input enable.
+ * @refb_cmos_neg_inp_en: REFB single-ended neg./pos. input enable.
+ * @zd_in_cmos_neg_inp_en: Zero Delay single-ended neg./pos. input enable.
+ * @osc_in_cmos_neg_inp_en: OSC single-ended neg./pos. input enable.
+ * @refa_r_div: PLL1 10-bit REFA R divider.
+ * @refb_r_div: PLL1 10-bit REFB R divider.
+ * @pll1_feedback_div: PLL1 10-bit Feedback N divider.
+ * @pll1_charge_pump_current_nA: Magnitude of PLL1 charge pump current (nA).
+ * @zero_delay_mode_internal_en: Internal, external Zero Delay mode selection.
+ * @osc_in_feedback_en: PLL1 feedback path, local feedback from
+ * the OSC_IN receiver or zero delay mode
+ * @pll1_loop_filter_rzero: PLL1 Loop Filter Zero Resistor selection.
+ * @ref_mode: Reference selection mode.
+ * @pll2_charge_pump_current_nA: Magnitude of PLL2 charge pump current (nA).
+ * @pll2_ndiv_a_cnt: PLL2 Feedback N-divider, A Counter, range 0..4.
+ * @pll2_ndiv_b_cnt: PLL2 Feedback N-divider, B Counter, range 0..63.
+ * @pll2_freq_doubler_en: PLL2 frequency doubler enable.
+ * @pll2_r2_div: PLL2 R2 divider, range 0..31.
+ * @pll2_vco_diff_m1: VCO1 divider, range 3..5.
+ * @pll2_vco_diff_m2: VCO2 divider, range 3..5.
+ * @rpole2: PLL2 loop filter Rpole resistor value.
+ * @rzero: PLL2 loop filter Rzero resistor value.
+ * @cpole1: PLL2 loop filter Cpole capacitor value.
+ * @rzero_bypass_en: PLL2 loop filter Rzero bypass enable.
+ * @num_channels: Array size of struct ad9523_channel_spec.
+ * @channels: Pointer to channel array.
+ * @name: Optional alternative iio device name.
+ */
+
+struct ad9523_platform_data {
+ unsigned long vcxo_freq;
+
+ /* Differential/ Single-Ended Input Configuration */
+ bool refa_diff_rcv_en;
+ bool refb_diff_rcv_en;
+ bool zd_in_diff_en;
+ bool osc_in_diff_en;
+
+ /*
+ * Valid if differential input disabled
+ * if false defaults to pos input
+ */
+ bool refa_cmos_neg_inp_en;
+ bool refb_cmos_neg_inp_en;
+ bool zd_in_cmos_neg_inp_en;
+ bool osc_in_cmos_neg_inp_en;
+
+ /* PLL1 Setting */
+ unsigned short refa_r_div;
+ unsigned short refb_r_div;
+ unsigned short pll1_feedback_div;
+ unsigned short pll1_charge_pump_current_nA;
+ bool zero_delay_mode_internal_en;
+ bool osc_in_feedback_en;
+ enum pll1_rzero_resistor pll1_loop_filter_rzero;
+
+ /* Reference */
+ enum ref_sel_mode ref_mode;
+
+ /* PLL2 Setting */
+ unsigned int pll2_charge_pump_current_nA;
+ unsigned char pll2_ndiv_a_cnt;
+ unsigned char pll2_ndiv_b_cnt;
+ bool pll2_freq_doubler_en;
+ unsigned char pll2_r2_div;
+ unsigned char pll2_vco_diff_m1; /* 3..5 */
+ unsigned char pll2_vco_diff_m2; /* 3..5 */
+
+ /* Loop Filter PLL2 */
+ enum rpole2_resistor rpole2;
+ enum rzero_resistor rzero;
+ enum cpole1_capacitor cpole1;
+ bool rzero_bypass_en;
+
+ /* Output Channel Configuration */
+ int num_channels;
+ struct ad9523_channel_spec *channels;
+
+ char name[SPI_NAME_SIZE];
+};
+
+#endif /* IIO_FREQUENCY_AD9523_H_ */
--- /dev/null
+/*
+ * ADF4350/ADF4351 SPI PLL driver
+ *
+ * Copyright 2012 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef IIO_PLL_ADF4350_H_
+#define IIO_PLL_ADF4350_H_
+
+/* Registers */
+#define ADF4350_REG0 0
+#define ADF4350_REG1 1
+#define ADF4350_REG2 2
+#define ADF4350_REG3 3
+#define ADF4350_REG4 4
+#define ADF4350_REG5 5
+
+/* REG0 Bit Definitions */
+#define ADF4350_REG0_FRACT(x) (((x) & 0xFFF) << 3)
+#define ADF4350_REG0_INT(x) (((x) & 0xFFFF) << 15)
+
+/* REG1 Bit Definitions */
+#define ADF4350_REG1_MOD(x) (((x) & 0xFFF) << 3)
+#define ADF4350_REG1_PHASE(x) (((x) & 0xFFF) << 15)
+#define ADF4350_REG1_PRESCALER (1 << 27)
+
+/* REG2 Bit Definitions */
+#define ADF4350_REG2_COUNTER_RESET_EN (1 << 3)
+#define ADF4350_REG2_CP_THREESTATE_EN (1 << 4)
+#define ADF4350_REG2_POWER_DOWN_EN (1 << 5)
+#define ADF4350_REG2_PD_POLARITY_POS (1 << 6)
+#define ADF4350_REG2_LDP_6ns (1 << 7)
+#define ADF4350_REG2_LDP_10ns (0 << 7)
+#define ADF4350_REG2_LDF_FRACT_N (0 << 8)
+#define ADF4350_REG2_LDF_INT_N (1 << 8)
+#define ADF4350_REG2_CHARGE_PUMP_CURR_uA(x) (((((x)-312) / 312) & 0xF) << 9)
+#define ADF4350_REG2_DOUBLE_BUFF_EN (1 << 13)
+#define ADF4350_REG2_10BIT_R_CNT(x) ((x) << 14)
+#define ADF4350_REG2_RDIV2_EN (1 << 24)
+#define ADF4350_REG2_RMULT2_EN (1 << 25)
+#define ADF4350_REG2_MUXOUT(x) ((x) << 26)
+#define ADF4350_REG2_NOISE_MODE(x) ((x) << 29)
+#define ADF4350_MUXOUT_THREESTATE 0
+#define ADF4350_MUXOUT_DVDD 1
+#define ADF4350_MUXOUT_GND 2
+#define ADF4350_MUXOUT_R_DIV_OUT 3
+#define ADF4350_MUXOUT_N_DIV_OUT 4
+#define ADF4350_MUXOUT_ANALOG_LOCK_DETECT 5
+#define ADF4350_MUXOUT_DIGITAL_LOCK_DETECT 6
+
+/* REG3 Bit Definitions */
+#define ADF4350_REG3_12BIT_CLKDIV(x) ((x) << 3)
+#define ADF4350_REG3_12BIT_CLKDIV_MODE(x) ((x) << 16)
+#define ADF4350_REG3_12BIT_CSR_EN (1 << 18)
+#define ADF4351_REG3_CHARGE_CANCELLATION_EN (1 << 21)
+#define ADF4351_REG3_ANTI_BACKLASH_3ns_EN (1 << 22)
+#define ADF4351_REG3_BAND_SEL_CLOCK_MODE_HIGH (1 << 23)
+
+/* REG4 Bit Definitions */
+#define ADF4350_REG4_OUTPUT_PWR(x) ((x) << 3)
+#define ADF4350_REG4_RF_OUT_EN (1 << 5)
+#define ADF4350_REG4_AUX_OUTPUT_PWR(x) ((x) << 6)
+#define ADF4350_REG4_AUX_OUTPUT_EN (1 << 8)
+#define ADF4350_REG4_AUX_OUTPUT_FUND (1 << 9)
+#define ADF4350_REG4_AUX_OUTPUT_DIV (0 << 9)
+#define ADF4350_REG4_MUTE_TILL_LOCK_EN (1 << 10)
+#define ADF4350_REG4_VCO_PWRDOWN_EN (1 << 11)
+#define ADF4350_REG4_8BIT_BAND_SEL_CLKDIV(x) ((x) << 12)
+#define ADF4350_REG4_RF_DIV_SEL(x) ((x) << 20)
+#define ADF4350_REG4_FEEDBACK_DIVIDED (0 << 23)
+#define ADF4350_REG4_FEEDBACK_FUND (1 << 23)
+
+/* REG5 Bit Definitions */
+#define ADF4350_REG5_LD_PIN_MODE_LOW (0 << 22)
+#define ADF4350_REG5_LD_PIN_MODE_DIGITAL (1 << 22)
+#define ADF4350_REG5_LD_PIN_MODE_HIGH (3 << 22)
+
+/* Specifications */
+#define ADF4350_MAX_OUT_FREQ 4400000000ULL /* Hz */
+#define ADF4350_MIN_OUT_FREQ 137500000 /* Hz */
+#define ADF4351_MIN_OUT_FREQ 34375000 /* Hz */
+#define ADF4350_MIN_VCO_FREQ 2200000000ULL /* Hz */
+#define ADF4350_MAX_FREQ_45_PRESC 3000000000ULL /* Hz */
+#define ADF4350_MAX_FREQ_PFD 32000000 /* Hz */
+#define ADF4350_MAX_BANDSEL_CLK 125000 /* Hz */
+#define ADF4350_MAX_FREQ_REFIN 250000000 /* Hz */
+#define ADF4350_MAX_MODULUS 4095
+
+/**
+ * struct adf4350_platform_data - platform specific information
+ * @name: Optional device name.
+ * @clkin: REFin frequency in Hz.
+ * @channel_spacing: Channel spacing in Hz (influences MODULUS).
+ * @power_up_frequency: Optional, If set in Hz the PLL tunes to the desired
+ * frequency on probe.
+ * @ref_div_factor: Optional, if set the driver skips dynamic calculation
+ * and uses this default value instead.
+ * @ref_doubler_en: Enables reference doubler.
+ * @ref_div2_en: Enables reference divider.
+ * @r2_user_settings: User defined settings for ADF4350/1 REGISTER_2.
+ * @r3_user_settings: User defined settings for ADF4350/1 REGISTER_3.
+ * @r4_user_settings: User defined settings for ADF4350/1 REGISTER_4.
+ * @gpio_lock_detect: Optional, if set with a valid GPIO number,
+ * pll lock state is tested upon read.
+ * If not used - set to -1.
+ */
+
+struct adf4350_platform_data {
+ char name[32];
+ unsigned long clkin;
+ unsigned long channel_spacing;
+ unsigned long long power_up_frequency;
+
+ unsigned short ref_div_factor; /* 10-bit R counter */
+ bool ref_doubler_en;
+ bool ref_div2_en;
+
+ unsigned r2_user_settings;
+ unsigned r3_user_settings;
+ unsigned r4_user_settings;
+ int gpio_lock_detect;
+};
+
+#endif /* IIO_PLL_ADF4350_H_ */
uintptr_t private;
};
+/**
+ * struct iio_enum - Enum channel info attribute
+ * @items: An array of strings.
+ * @num_items: Length of the item array.
+ * @set: Set callback function, may be NULL.
+ * @get: Get callback function, may be NULL.
+ *
+ * The iio_enum struct can be used to implement enum style channel attributes.
+ * Enum style attributes are those which have a set of strings which map to
+ * unsigned integer values. The IIO enum helper code takes care of mapping
+ * between value and string as well as generating a "_available" file which
+ * contains a list of all available items. The set callback will be called when
+ * the attribute is updated. The last parameter is the index to the newly
+ * activated item. The get callback will be used to query the currently active
+ * item and is supposed to return the index for it.
+ */
+struct iio_enum {
+ const char * const *items;
+ unsigned int num_items;
+ int (*set)(struct iio_dev *, const struct iio_chan_spec *, unsigned int);
+ int (*get)(struct iio_dev *, const struct iio_chan_spec *);
+};
+
+ssize_t iio_enum_available_read(struct iio_dev *indio_dev,
+ uintptr_t priv, const struct iio_chan_spec *chan, char *buf);
+ssize_t iio_enum_read(struct iio_dev *indio_dev,
+ uintptr_t priv, const struct iio_chan_spec *chan, char *buf);
+ssize_t iio_enum_write(struct iio_dev *indio_dev,
+ uintptr_t priv, const struct iio_chan_spec *chan, const char *buf,
+ size_t len);
+
+/**
+ * IIO_ENUM() - Initialize enum extended channel attribute
+ * @_name: Attribute name
+ * @_shared: Whether the attribute is shared between all channels
+ * @_e: Pointer to a iio_enum struct
+ *
+ * This should usually be used together with IIO_ENUM_AVAILABLE()
+ */
+#define IIO_ENUM(_name, _shared, _e) \
+{ \
+ .name = (_name), \
+ .shared = (_shared), \
+ .read = iio_enum_read, \
+ .write = iio_enum_write, \
+ .private = (uintptr_t)(_e), \
+}
+
+/**
+ * IIO_ENUM_AVAILABLE() - Initialize enum available extended channel attribute
+ * @_name: Attribute name ("_available" will be appended to the name)
+ * @_e: Pointer to a iio_enum struct
+ *
+ * Creates a read only attribute which list all the available enum items in a
+ * space separated list. This should usually be used together with IIO_ENUM()
+ */
+#define IIO_ENUM_AVAILABLE(_name, _e) \
+{ \
+ .name = (_name "_available"), \
+ .shared = true, \
+ .read = iio_enum_available_read, \
+ .private = (uintptr_t)(_e), \
+}
+
/**
* struct iio_chan_spec - specification of a single channel
* @type: What type of measurement is the channel making.
- * @channel: What number or name do we wish to assign the channel.
+ * @channel: What number do we wish to assign the channel.
* @channel2: If there is a second number for a differential
* channel then this is it. If modified is set then the
* value here specifies the modifier.
* @address: Driver specific identifier.
- * @scan_index: Monotonic index to give ordering in scans when read
+ * @scan_index: Monotonic index to give ordering in scans when read
* from a buffer.
* @scan_type: Sign: 's' or 'u' to specify signed or unsigned
* realbits: Number of valid bits of data
* endianness: little or big endian
* @info_mask: What information is to be exported about this channel.
* This includes calibbias, scale etc.
- * @event_mask: What events can this channel produce.
+ * @event_mask: What events can this channel produce.
* @ext_info: Array of extended info attributes for this channel.
* The array is NULL terminated, the last element should
- * have it's name field set to NULL.
+ * have its name field set to NULL.
* @extend_name: Allows labeling of channel attributes with an
* informative name. Note this has no effect codes etc,
* unlike modifiers.
- * @datasheet_name: A name used in in kernel mapping of channels. It should
+ * @datasheet_name: A name used in in-kernel mapping of channels. It should
* correspond to the first name that the channel is referred
* to by in the datasheet (e.g. IND), or the nearest
* possible compound name (e.g. IND-INC).
* channel2. Examples are IIO_MOD_X for axial sensors about
* the 'x' axis.
* @indexed: Specify the channel has a numerical index. If not,
- * the value in channel will be suppressed for attribute
- * but not for event codes. Typically set it to 0 when
- * the index is false.
+ * the channel index number will be suppressed for sysfs
+ * attributes but not for event codes.
* @differential: Channel is differential.
*/
struct iio_chan_spec {
* @trig: [INTERN] current device trigger (buffer modes)
* @pollfunc: [DRIVER] function run on trigger being received
* @channels: [DRIVER] channel specification structure table
- * @num_channels: [DRIVER] number of chanels specified in @channels.
+ * @num_channels: [DRIVER] number of channels specified in @channels.
* @channel_attr_list: [INTERN] keep track of automatically created channel
* attributes
* @chan_attr_group: [INTERN] group for all attrs in base directory
/**
* iio_device_put() - reference counted deallocation of struct device
- * @dev: the iio_device containing the device
+ * @indio_dev: IIO device structure containing the device
**/
static inline void iio_device_put(struct iio_dev *indio_dev)
{
/**
* dev_to_iio_dev() - Get IIO device struct from a device struct
- * @dev: The device embedded in the IIO device
+ * @dev: The device embedded in the IIO device
*
* Note: The device must be a IIO device, otherwise the result is undefined.
*/
return container_of(dev, struct iio_dev, dev);
}
+/**
+ * iio_device_get() - increment reference count for the device
+ * @indio_dev: IIO device structure
+ *
+ * Returns: The passed IIO device
+ **/
+static inline struct iio_dev *iio_device_get(struct iio_dev *indio_dev)
+{
+ return indio_dev ? dev_to_iio_dev(get_device(&indio_dev->dev)) : NULL;
+}
+
/* Can we make this smaller? */
#define IIO_ALIGN L1_CACHE_BYTES
/**
* iio_device_alloc() - allocate an iio_dev from a driver
- * @sizeof_priv: Space to allocate for private structure.
+ * @sizeof_priv: Space to allocate for private structure.
**/
struct iio_dev *iio_device_alloc(int sizeof_priv);
/**
* iio_device_free() - free an iio_dev from a driver
- * @dev: the iio_dev associated with the device
+ * @indio_dev: the iio_dev associated with the device
**/
void iio_device_free(struct iio_dev *indio_dev);
/**
* iio_buffer_enabled() - helper function to test if the buffer is enabled
- * @indio_dev: IIO device info structure for device
+ * @indio_dev: IIO device structure for device
**/
static inline bool iio_buffer_enabled(struct iio_dev *indio_dev)
{
/**
* iio_get_debugfs_dentry() - helper function to get the debugfs_dentry
- * @indio_dev: IIO device info structure for device
+ * @indio_dev: IIO device structure for device
**/
#if defined(CONFIG_DEBUG_FS)
static inline struct dentry *iio_get_debugfs_dentry(struct iio_dev *indio_dev)
* This is matched against the datasheet_name element
* of struct iio_chan_spec.
* @consumer_dev_name: Name to uniquely identify the consumer device.
- * @consumer_channel: Unique name used to idenitify the channel on the
+ * @consumer_channel: Unique name used to identify the channel on the
* consumer side.
*/
struct iio_map {
#define IIO_DEV_ATTR_SAMP_FREQ_AVAIL(_show) \
IIO_DEVICE_ATTR(sampling_frequency_available, S_IRUGO, _show, NULL, 0)
/**
- * IIO_CONST_ATTR_AVAIL_SAMP_FREQ - list available sampling frequencies
+ * IIO_CONST_ATTR_SAMP_FREQ_AVAIL - list available sampling frequencies
* @_string: frequency string for the attribute
*
* Constant version
--- /dev/null
+#ifndef _LINUX_IIO_TRIGGERED_BUFFER_H_
+#define _LINUX_IIO_TRIGGERED_BUFFER_H_
+
+#include <linux/interrupt.h>
+
+struct iio_dev;
+struct iio_buffer_setup_ops;
+
+int iio_triggered_buffer_setup(struct iio_dev *indio_dev,
+ irqreturn_t (*pollfunc_bh)(int irq, void *p),
+ irqreturn_t (*pollfunc_th)(int irq, void *p),
+ const struct iio_buffer_setup_ops *setup_ops);
+void iio_triggered_buffer_cleanup(struct iio_dev *indio_dev);
+
+#endif
#define _IIO_TYPES_H_
enum iio_chan_type {
- /* real channel types */
IIO_VOLTAGE,
IIO_CURRENT,
IIO_POWER,
enum pstore_type_id {
PSTORE_TYPE_DMESG = 0,
PSTORE_TYPE_MCE = 1,
+ PSTORE_TYPE_CONSOLE = 2,
PSTORE_TYPE_UNKNOWN = 255
};
struct persistent_ram_buffer;
-struct persistent_ram_descriptor {
- const char *name;
- phys_addr_t size;
-};
-
-struct persistent_ram {
- phys_addr_t start;
- phys_addr_t size;
-
- int num_descs;
- struct persistent_ram_descriptor *descs;
-
- struct list_head node;
-};
-
struct persistent_ram_zone {
phys_addr_t paddr;
size_t size;
size_t old_log_size;
};
-int persistent_ram_early_init(struct persistent_ram *ram);
-
-struct persistent_ram_zone * __init persistent_ram_new(phys_addr_t start,
- size_t size,
- bool ecc);
+struct persistent_ram_zone * __devinit persistent_ram_new(phys_addr_t start,
+ size_t size,
+ bool ecc);
void persistent_ram_free(struct persistent_ram_zone *prz);
void persistent_ram_zap(struct persistent_ram_zone *prz);
-struct persistent_ram_zone *persistent_ram_init_ringbuffer(struct device *dev,
- bool ecc);
int persistent_ram_write(struct persistent_ram_zone *prz, const void *s,
unsigned int count);
unsigned long mem_size;
unsigned long mem_address;
unsigned long record_size;
+ unsigned long console_size;
int dump_oops;
bool ecc;
};
projects / deliverable / linux.git / commitdiff
