samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: Fix the coding convention issues in Spectral target_if layer

Browse Source 
Current target_if spectral layer code is not following coding
convention rules in some places.

Change-Id: I1c0e78c6cdbe97db657c341d74582567a29a86b0
CRs-Fixed: 2151555
This commit is contained in:
Shiva Krishna Pittala
2018-01-25 20:17:18 +05:30
committed by snandini
parent 6273adc01a
commit 318d20fc69
6 changed files with 3140 additions and 2452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

256
spectral/dispatcher/inc/wlan_spectral_public_structs.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2011,2017 The Linux Foundation. All rights reserved. * Copyright (c) 2011,2017-2018 The Linux Foundation. All rights reserved.
* *
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
@@ -68,7 +68,7 @@
#define SPECTRAL_PARAM_STOP (22) #define SPECTRAL_PARAM_STOP (22)
#define SPECTRAL_PARAM_ENABLE (23) #define SPECTRAL_PARAM_ENABLE (23)
#ifdef ATH_SPECTRAL_USE_EMU_DEFAULTS #ifdef SPECTRAL_USE_EMU_DEFAULTS
/* Use defaults from emulation */ /* Use defaults from emulation */
#define SPECTRAL_SCAN_ACTIVE_DEFAULT (0x0) #define SPECTRAL_SCAN_ACTIVE_DEFAULT (0x0)
#define SPECTRAL_SCAN_ENABLE_DEFAULT (0x0) #define SPECTRAL_SCAN_ENABLE_DEFAULT (0x0)
@@ -91,7 +91,8 @@
#define SPECTRAL_SCAN_DBM_ADJ_DEFAULT (0x0) #define SPECTRAL_SCAN_DBM_ADJ_DEFAULT (0x0)
#define SPECTRAL_SCAN_CHN_MASK_DEFAULT (0x1) #define SPECTRAL_SCAN_CHN_MASK_DEFAULT (0x1)
#else #else
/* Static default values for spectral state and configuration. /*
* Static default values for spectral state and configuration.
* These definitions should be treated as temporary. Ideally, * These definitions should be treated as temporary. Ideally,
* we should get the defaults from firmware - this will be discussed. * we should get the defaults from firmware - this will be discussed.
* *
@@ -118,12 +119,27 @@
#define SPECTRAL_SCAN_BIN_SCALE_DEFAULT (1) #define SPECTRAL_SCAN_BIN_SCALE_DEFAULT (1)
#define SPECTRAL_SCAN_DBM_ADJ_DEFAULT (1) #define SPECTRAL_SCAN_DBM_ADJ_DEFAULT (1)
#define SPECTRAL_SCAN_CHN_MASK_DEFAULT (1) #define SPECTRAL_SCAN_CHN_MASK_DEFAULT (1)
#endif /* ATH_SPECTRAL_USE_EMU_DEFAULTS */ #endif /* SPECTRAL_USE_EMU_DEFAULTS */
/* The below two definitions apply only to pre-11ac chipsets */ /* The below two definitions apply only to pre-11ac chipsets */
#define SPECTRAL_SCAN_SHORT_REPORT_DEFAULT (1) #define SPECTRAL_SCAN_SHORT_REPORT_DEFAULT (1)
#define SPECTRAL_SCAN_FFT_PERIOD_DEFAULT (1) #define SPECTRAL_SCAN_FFT_PERIOD_DEFAULT (1)
/**
* enum wlan_cfg80211_spectral_vendorcmd_handler_idx - Indices to cfg80211
* spectral vendor command handlers
* @SPECTRAL_SCAN_START_HANDLER_IDX: Index to SPECTRAL_SCAN_START handler
* @SPECTRAL_SCAN_STOP_HANDLER_IDX: Index to SPECTRAL_SCAN_STOP handler
* @SPECTRAL_SCAN_GET_CONFIG_HANDLER_IDX: Index to SPECTRAL_SCAN_GET_CONFIG
* handler
* @SPECTRAL_SCAN_GET_DIAG_STATS_HANDLER_IDX: Index to
* SPECTRAL_SCAN_GET_DIAG_STATS handler
* @SPECTRAL_SCAN_GET_CAP_HANDLER_IDX: Index to SPECTRAL_SCAN_GET_CAP handler
* @SPECTRAL_SCAN_GET_STATUS_HANDLER_IDX: Index to SPECTRAL_SCAN_GET_STATUS
* handler
* @SPECTRAL_SCAN_VENDOR_CMD_HANDLER_MAX: Number of cfg80211 spectral
* vendor command handlers supported
*/
enum wlan_cfg80211_spectral_vendorcmd_handler_idx { enum wlan_cfg80211_spectral_vendorcmd_handler_idx {
SPECTRAL_SCAN_START_HANDLER_IDX, SPECTRAL_SCAN_START_HANDLER_IDX,
SPECTRAL_SCAN_STOP_HANDLER_IDX, SPECTRAL_SCAN_STOP_HANDLER_IDX,
@@ -136,33 +152,33 @@ enum wlan_cfg80211_spectral_vendorcmd_handler_idx {
/** /**
* enum spectral_debug - Spectral debug level * enum spectral_debug - Spectral debug level
* @ATH_DEBUG_SPECTRAL: Minimal SPECTRAL debug * @DEBUG_SPECTRAL: Minimal SPECTRAL debug
* @ATH_DEBUG_SPECTRAL1: Normal SPECTRAL debug * @DEBUG_SPECTRAL1: Normal SPECTRAL debug
* @ATH_DEBUG_SPECTRAL2: Maximal SPECTRAL debug * @DEBUG_SPECTRAL2: Maximal SPECTRAL debug
* @ATH_DEBUG_SPECTRAL3: Matched filterID display * @DEBUG_SPECTRAL3: Matched filterID display
* @ATH_DEBUG_SPECTRAL4: One time dump of FFT report * @DEBUG_SPECTRAL4: One time dump of FFT report
*/ */
enum spectral_debug { enum spectral_debug {
ATH_DEBUG_SPECTRAL = 0x00000100, DEBUG_SPECTRAL = 0x00000100,
ATH_DEBUG_SPECTRAL1 = 0x00000200, DEBUG_SPECTRAL1 = 0x00000200,
ATH_DEBUG_SPECTRAL2 = 0x00000400, DEBUG_SPECTRAL2 = 0x00000400,
ATH_DEBUG_SPECTRAL3 = 0x00000800, DEBUG_SPECTRAL3 = 0x00000800,
ATH_DEBUG_SPECTRAL4 = 0x00001000, DEBUG_SPECTRAL4 = 0x00001000,
}; };
/** /**
* enum SPECTRAL_CAPABILITY_TYPE - Spectral capability type * enum spectral_capability_type - Spectral capability type
* @SPECTRAL_CAP_PHYDIAG: Phydiag capability * @SPECTRAL_CAP_PHYDIAG: Phydiag capability
* @SPECTRAL_CAP_RADAR: Radar detection capability * @SPECTRAL_CAP_RADAR: Radar detection capability
* @SPECTRAL_CAP_SPECTRAL_SCAN: Spectral capability * @SPECTRAL_CAP_SPECTRAL_SCAN: Spectral capability
* @SPECTRAL_CAP_ADVNCD_SPECTRAL_SCAN: Advanced spectral capability * @SPECTRAL_CAP_ADVNCD_SPECTRAL_SCAN: Advanced spectral capability
*/ */
typedef enum { enum spectral_capability_type {
SPECTRAL_CAP_PHYDIAG, SPECTRAL_CAP_PHYDIAG,
SPECTRAL_CAP_RADAR, SPECTRAL_CAP_RADAR,
SPECTRAL_CAP_SPECTRAL_SCAN, SPECTRAL_CAP_SPECTRAL_SCAN,
SPECTRAL_CAP_ADVNCD_SPECTRAL_SCAN, SPECTRAL_CAP_ADVNCD_SPECTRAL_SCAN,
} SPECTRAL_CAPABILITY_TYPE; };
/** /**
* struct spectral_chan_stats - channel status info * struct spectral_chan_stats - channel status info
@@ -176,14 +192,14 @@ typedef enum {
* @maxregpower_sec80: Max regulatory power of secondary 80 Mhz * @maxregpower_sec80: Max regulatory power of secondary 80 Mhz
*/ */
struct spectral_chan_stats { struct spectral_chan_stats {
int cycle_count; int cycle_count;
int channel_load; int channel_load;
int per; int per;
int noisefloor; int noisefloor;
u_int16_t comp_usablity; uint16_t comp_usablity;
int8_t maxregpower; int8_t maxregpower;
u_int16_t comp_usablity_sec80; uint16_t comp_usablity_sec80;
int8_t maxregpower_sec80; int8_t maxregpower_sec80;
}; };
/** /**
@@ -199,11 +215,11 @@ struct spectral_chan_stats {
* mismatches in Search FFT report * mismatches in Search FFT report
*/ */
struct spectral_diag_stats { struct spectral_diag_stats {
u_int64_t spectral_mismatch; uint64_t spectral_mismatch;
u_int64_t spectral_sec80_sfft_insufflen; uint64_t spectral_sec80_sfft_insufflen;
u_int64_t spectral_no_sec80_sfft; uint64_t spectral_no_sec80_sfft;
u_int64_t spectral_vhtseg1id_mismatch; uint64_t spectral_vhtseg1id_mismatch;
u_int64_t spectral_vhtseg2id_mismatch; uint64_t spectral_vhtseg2id_mismatch;
}; };
/** /**
@@ -214,14 +230,14 @@ struct spectral_diag_stats {
* @advncd_spectral_cap: Advanced spectral capability * @advncd_spectral_cap: Advanced spectral capability
*/ */
struct spectral_caps { struct spectral_caps {
u_int8_t phydiag_cap; uint8_t phydiag_cap;
u_int8_t radar_cap; uint8_t radar_cap;
u_int8_t spectral_cap; uint8_t spectral_cap;
u_int8_t advncd_spectral_cap; uint8_t advncd_spectral_cap;
}; };
/** /**
* struct spectral_config * struct spectral_config - spectral config parameters
* @ss_fft_period: Skip interval for FFT reports * @ss_fft_period: Skip interval for FFT reports
* @ss_period: Spectral scan period * @ss_period: Spectral scan period
* @ss_count: # of reports to return from ss_active * @ss_count: # of reports to return from ss_active
@@ -279,30 +295,30 @@ struct spectral_caps {
* @ss_nf_temp_data: temperature data taken during nf scan * @ss_nf_temp_data: temperature data taken during nf scan
*/ */
struct spectral_config { struct spectral_config {
u_int16_t ss_fft_period; uint16_t ss_fft_period;
u_int16_t ss_period; uint16_t ss_period;
u_int16_t ss_count; uint16_t ss_count;
u_int16_t ss_short_report; uint16_t ss_short_report;
u_int8_t radar_bin_thresh_sel; uint8_t radar_bin_thresh_sel;
u_int16_t ss_spectral_pri; uint16_t ss_spectral_pri;
u_int16_t ss_fft_size; uint16_t ss_fft_size;
u_int16_t ss_gc_ena; uint16_t ss_gc_ena;
u_int16_t ss_restart_ena; uint16_t ss_restart_ena;
u_int16_t ss_noise_floor_ref; uint16_t ss_noise_floor_ref;
u_int16_t ss_init_delay; uint16_t ss_init_delay;
u_int16_t ss_nb_tone_thr; uint16_t ss_nb_tone_thr;
u_int16_t ss_str_bin_thr; uint16_t ss_str_bin_thr;
u_int16_t ss_wb_rpt_mode; uint16_t ss_wb_rpt_mode;
u_int16_t ss_rssi_rpt_mode; uint16_t ss_rssi_rpt_mode;
u_int16_t ss_rssi_thr; uint16_t ss_rssi_thr;
u_int16_t ss_pwr_format; uint16_t ss_pwr_format;
u_int16_t ss_rpt_mode; uint16_t ss_rpt_mode;
u_int16_t ss_bin_scale; uint16_t ss_bin_scale;
u_int16_t ss_dbm_adj; uint16_t ss_dbm_adj;
u_int16_t ss_chn_mask; uint16_t ss_chn_mask;
int8_t ss_nf_cal[AH_MAX_CHAINS * 2]; int8_t ss_nf_cal[AH_MAX_CHAINS * 2];
int8_t ss_nf_pwr[AH_MAX_CHAINS * 2]; int8_t ss_nf_pwr[AH_MAX_CHAINS * 2];
int32_t ss_nf_temp_data; int32_t ss_nf_temp_data;
}; };
/** /**
@@ -315,11 +331,17 @@ struct spectral_scan_state {
uint8_t is_enabled; uint8_t is_enabled;
}; };
typedef enum _dcs_int_type { /**
* enum dcs_int_type - Interference type indicated by DCS
* @SPECTRAL_DCS_INT_NONE: No interference
* @SPECTRAL_DCS_INT_CW: CW interference
* @SPECTRAL_DCS_INT_WIFI: WLAN interference
*/
enum dcs_int_type {
SPECTRAL_DCS_INT_NONE, SPECTRAL_DCS_INT_NONE,
SPECTRAL_DCS_INT_CW, SPECTRAL_DCS_INT_CW,
SPECTRAL_DCS_INT_WIFI SPECTRAL_DCS_INT_WIFI
} DCS_INT_TYPE; };
/** /**
* struct INTERF_RSP - Interference record * struct INTERF_RSP - Interference record
@@ -331,9 +353,9 @@ typedef enum _dcs_int_type {
* @advncd_spectral_cap: Advanced spectral capability * @advncd_spectral_cap: Advanced spectral capability
*/ */
struct INTERF_RSP { struct INTERF_RSP {
u_int8_t interf_type; uint8_t interf_type;
u_int16_t interf_min_freq; uint16_t interf_min_freq;
u_int16_t interf_max_freq; uint16_t interf_max_freq;
} __ATTRIB_PACKED; } __ATTRIB_PACKED;
/** /**
@@ -342,25 +364,25 @@ struct INTERF_RSP {
* @interf: Array of interference records * @interf: Array of interference records
*/ */
struct INTERF_SRC_RSP { struct INTERF_SRC_RSP {
u_int16_t count; uint16_t count;
struct INTERF_RSP interf[MAX_INTERF]; struct INTERF_RSP interf[MAX_INTERF];
} __ATTRIB_PACKED; } __ATTRIB_PACKED;
/** /**
* struct spectral_classifier_params - * struct spectral_classifier_params - spectral classifier parameters
* @spectral_20_40_mode: Is AP in 20/40 mode? * @spectral_20_40_mode: Is AP in 20/40 mode?
* @spectral_dc_index: DC index * @spectral_dc_index: DC index
* @spectral_dc_in_mhz: DC in MHz * @spectral_dc_in_mhz: DC in MHz
* @upper_chan_in_mhz: Upper channel in MHz * @upper_chan_in_mhz: Upper channel in MHz
* @lower_chan_in_mhz: Lower channel in MHz * @lower_chan_in_mhz: Lower channel in MHz
*/ */
typedef struct spectral_classifier_params { struct spectral_classifier_params {
int spectral_20_40_mode; int spectral_20_40_mode;
int spectral_dc_index; int spectral_dc_index;
int spectral_dc_in_mhz; int spectral_dc_in_mhz;
int upper_chan_in_mhz; int upper_chan_in_mhz;
int lower_chan_in_mhz; int lower_chan_in_mhz;
} __ATTRIB_PACKED SPECTRAL_CLASSIFIER_PARAMS; } __ATTRIB_PACKED;
/** /**
* struct spectral_samp_data - Spectral Analysis Messaging Protocol Data format * struct spectral_samp_data - Spectral Analysis Messaging Protocol Data format
@@ -403,32 +425,33 @@ typedef struct spectral_classifier_params {
* segment * segment
* @ch_width: Channel width 20/40/80/160 MHz * @ch_width: Channel width 20/40/80/160 MHz
*/ */
typedef struct spectral_samp_data { struct spectral_samp_data {
int16_t spectral_data_len; int16_t spectral_data_len;
int16_t spectral_data_len_sec80; int16_t spectral_data_len_sec80;
int16_t spectral_rssi; int16_t spectral_rssi;
int16_t spectral_rssi_sec80; int16_t spectral_rssi_sec80;
int8_t spectral_combined_rssi; int8_t spectral_combined_rssi;
int8_t spectral_upper_rssi; int8_t spectral_upper_rssi;
int8_t spectral_lower_rssi; int8_t spectral_lower_rssi;
int8_t spectral_chain_ctl_rssi[MAX_SPECTRAL_CHAINS]; int8_t spectral_chain_ctl_rssi[MAX_SPECTRAL_CHAINS];
int8_t spectral_chain_ext_rssi[MAX_SPECTRAL_CHAINS]; int8_t spectral_chain_ext_rssi[MAX_SPECTRAL_CHAINS];
u_int8_t spectral_max_scale; uint8_t spectral_max_scale;
int16_t spectral_bwinfo; int16_t spectral_bwinfo;
int32_t spectral_tstamp; int32_t spectral_tstamp;
int16_t spectral_max_index; int16_t spectral_max_index;
int16_t spectral_max_index_sec80; int16_t spectral_max_index_sec80;
int16_t spectral_max_mag; int16_t spectral_max_mag;
int16_t spectral_max_mag_sec80; int16_t spectral_max_mag_sec80;
u_int8_t spectral_max_exp; uint8_t spectral_max_exp;
int32_t spectral_last_tstamp; int32_t spectral_last_tstamp;
int16_t spectral_upper_max_index; int16_t spectral_upper_max_index;
int16_t spectral_lower_max_index; int16_t spectral_lower_max_index;
u_int8_t spectral_nb_upper; uint8_t spectral_nb_upper;
u_int8_t spectral_nb_lower; uint8_t spectral_nb_lower;
struct spectral_classifier_params classifier_params; struct spectral_classifier_params classifier_params;
u_int16_t bin_pwr_count; uint16_t bin_pwr_count;
/* For 11ac chipsets prior to AR900B version 2.0, a max of 512 bins are /*
* For 11ac chipsets prior to AR900B version 2.0, a max of 512 bins are
* delivered. However, there can be additional bins reported for * delivered. However, there can be additional bins reported for
* AR900B version 2.0 and QCA9984 as described next: * AR900B version 2.0 and QCA9984 as described next:
* *
@@ -444,16 +467,16 @@ typedef struct spectral_samp_data {
* then 8 more bins (4 more on left side and 4 more on right side) * then 8 more bins (4 more on left side and 4 more on right side)
* are added. * are added.
*/ */
u_int8_t lb_edge_extrabins; uint8_t lb_edge_extrabins;
u_int8_t rb_edge_extrabins; uint8_t rb_edge_extrabins;
u_int16_t bin_pwr_count_sec80; uint16_t bin_pwr_count_sec80;
u_int8_t bin_pwr[MAX_NUM_BINS]; uint8_t bin_pwr[MAX_NUM_BINS];
u_int8_t bin_pwr_sec80[MAX_NUM_BINS]; uint8_t bin_pwr_sec80[MAX_NUM_BINS];
struct INTERF_SRC_RSP interf_list; struct INTERF_SRC_RSP interf_list;
int16_t noise_floor; int16_t noise_floor;
int16_t noise_floor_sec80; int16_t noise_floor_sec80;
u_int32_t ch_width; uint32_t ch_width;
} __ATTRIB_PACKED SPECTRAL_SAMP_DATA; } __ATTRIB_PACKED;
/** /**
* struct spectral_samp_msg - Spectral SAMP message * struct spectral_samp_msg - Spectral SAMP message
@@ -467,17 +490,17 @@ typedef struct spectral_samp_data {
* @macaddr: Indicates the device interface * @macaddr: Indicates the device interface
* @samp_data: SAMP Data * @samp_data: SAMP Data
*/ */
typedef struct spectral_samp_msg { struct spectral_samp_msg {
u_int32_t signature; uint32_t signature;
u_int16_t freq; uint16_t freq;
u_int16_t vhtop_ch_freq_seg1; uint16_t vhtop_ch_freq_seg1;
u_int16_t vhtop_ch_freq_seg2; uint16_t vhtop_ch_freq_seg2;
u_int16_t freq_loading; uint16_t freq_loading;
u_int16_t dcs_enabled; uint16_t dcs_enabled;
DCS_INT_TYPE int_type; enum dcs_int_type int_type;
u_int8_t macaddr[6]; uint8_t macaddr[6];
SPECTRAL_SAMP_DATA samp_data; struct spectral_samp_data samp_data;
} __ATTRIB_PACKED SPECTRAL_SAMP_MSG; } __ATTRIB_PACKED;
#ifdef WIN32 #ifdef WIN32
#pragma pack(pop, spectral) #pragma pack(pop, spectral)
@@ -486,5 +509,4 @@ typedef struct spectral_samp_msg {
#undef __ATTRIB_PACKED #undef __ATTRIB_PACKED
#endif #endif
#endif /* _WLAN_SPECTRAL_PUBLIC_STRUCTS_H_ */ #endif /* _WLAN_SPECTRAL_PUBLIC_STRUCTS_H_ */

2163
target_if/spectral/target_if_spectral.c
View File

File diff suppressed because it is too large Load Diff

731
target_if/spectral/target_if_spectral.h
View File

File diff suppressed because it is too large Load Diff

703
target_if/spectral/target_if_spectral_netlink.c
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2011,2017 The Linux Foundation. All rights reserved. * Copyright (c) 2011,2017-2018 The Linux Foundation. All rights reserved.
* *
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
@@ -27,83 +27,134 @@
#include <wlan_osif_priv.h> #include <wlan_osif_priv.h>
#include <reg_services_public_struct.h> #include <reg_services_public_struct.h>
#ifdef SPECTRAL_USE_NETLINK_SOCKETS #ifdef SPECTRAL_USE_NETLINK_SOCKETS
struct sock *target_if_spectral_nl_sock; struct sock *target_if_spectral_nl_sock;
static atomic_t spectral_nl_users = ATOMIC_INIT(0); static atomic_t spectral_nl_users = ATOMIC_INIT(0);
#if (KERNEL_VERSION(2, 6, 31) > LINUX_VERSION_CODE) #if (KERNEL_VERSION(2, 6, 31) > LINUX_VERSION_CODE)
void target_if_spectral_nl_data_ready(struct sock *sk, int len) void
target_if_spectral_nl_data_ready(struct sock *sk, int len)
{ {
qdf_print("%s %d\n", __func__, __LINE__); qdf_print("%s %d\n", __func__, __LINE__);
} }
#else #else
void target_if_spectral_nl_data_ready(struct sk_buff *skb) void
target_if_spectral_nl_data_ready(struct sk_buff *skb)
{ {
qdf_print("%s %d\n", __func__, __LINE__); qdf_print("%s %d\n", __func__, __LINE__);
} }
#endif /* VERSION */
#endif /* VERSION */ /**
* target_if_spectral_init_nl_cfg() - Initialize netlink kernel
int target_if_spectral_init_netlink(struct target_if_spectral *spectral) * configuration parameters
{ * @spectral : Pointer to netlink_kernel_cfg
*
* Initialize netlink kernel configuration parameters required
* for spectral module
*
* Return: None
*/
#if KERNEL_VERSION(3, 6, 0) <= LINUX_VERSION_CODE #if KERNEL_VERSION(3, 6, 0) <= LINUX_VERSION_CODE
static void
struct netlink_kernel_cfg cfg = { target_if_spectral_init_nl_cfg(struct netlink_kernel_cfg *cfg)
.groups = 1, {
.input = target_if_spectral_nl_data_ready, cfg->groups = 1;
}; cfg->input = target_if_spectral_nl_data_ready;
}
#else
static void
target_if_spectral_init_nl_cfg(struct netlink_kernel_cfg *cfg)
{
}
#endif #endif
/**
* target_if_spectral_create_nl_sock() - Create Netlink socket
* @spectral : Pointer to netlink_kernel_cfg
*
* Create Netlink socket required for spectral module
*
* Return: None
*/
#if KERNEL_VERSION(3, 7, 0) <= LINUX_VERSION_CODE
static void
target_if_spectral_create_nl_sock(struct netlink_kernel_cfg *cfg)
{
target_if_spectral_nl_sock =
(struct sock *)netlink_kernel_create(&init_net,
NETLINK_ATHEROS, cfg);
}
#elif KERNEL_VERSION(3, 6, 0) <= LINUX_VERSION_CODE
static void
target_if_spectral_create_nl_sock(struct netlink_kernel_cfg *cfg)
{
target_if_spectral_nl_sock =
(struct sock *)netlink_kernel_create(&init_net,
NETLINK_ATHEROS,
THIS_MODULE, cfg);
}
#elif (KERNEL_VERSION(2, 6, 31) > LINUX_VERSION_CODE)
static void
target_if_spectral_create_nl_sock(struct netlink_kernel_cfg *cfg)
{
target_if_spectral_nl_sock =
(struct sock *)netlink_kernel_create(
NETLINK_ATHEROS, 1,
&target_if_spectral_nl_data_ready,
THIS_MODULE);
}
#else
#if (KERNEL_VERSION(3, 10, 0) <= LINUX_VERSION_CODE)
static void
target_if_spectral_create_nl_sock(struct netlink_kernel_cfg *cfg)
{
memset(cfg, 0, sizeof(*cfg));
cfg->groups = 1;
cfg->input = &target_if_spectral_nl_data_ready;
target_if_spectral_nl_sock =
(struct sock *)netlink_kernel_create(&init_net,
NETLINK_ATHEROS, cfg);
}
#else
static void
target_if_spectral_create_nl_sock(struct netlink_kernel_cfg *cfg)
{
target_if_spectral_nl_sock =
(struct sock *)netlink_kernel_create(
&init_net,
NETLINK_ATHEROS, 1,
&target_if_spectral_nl_data_ready,
NULL, THIS_MODULE);
}
#endif
#endif
int
target_if_spectral_init_netlink(struct target_if_spectral *spectral)
{
struct netlink_kernel_cfg cfg;
memset(&cfg, 0, sizeof(cfg));
target_if_spectral_init_nl_cfg(&cfg);
if (!spectral) { if (!spectral) {
qdf_print("%s: sc_spectral is NULL\n", __func__); qdf_print("%s: sc_spectral is NULL\n", __func__);
return -EIO; return -EIO;
} }
spectral->spectral_sent_msg = 0; spectral->spectral_sent_msg = 0;
if (!target_if_spectral_nl_sock) { if (!target_if_spectral_nl_sock) {
#if KERNEL_VERSION(3, 7, 0) <= LINUX_VERSION_CODE target_if_spectral_create_nl_sock(&cfg);
target_if_spectral_nl_sock = (struct sock *)netlink_kernel_create(
&init_net,
NETLINK_ATHEROS,
&cfg);
#elif KERNEL_VERSION(3, 6, 0) <= LINUX_VERSION_CODE
target_if_spectral_nl_sock = (struct sock *)netlink_kernel_create(
&init_net,
NETLINK_ATHEROS,
THIS_MODULE,
&cfg);
#elif (KERNEL_VERSION(2, 6, 31) > LINUX_VERSION_CODE)
target_if_spectral_nl_sock = (
struct sock *)netlink_kernel_create(NETLINK_ATHEROS,
1,
&target_if_spectral_nl_data_ready,
THIS_MODULE);
#else
#if (KERNEL_VERSION(3, 10, 0) <= LINUX_VERSION_CODE)
struct netlink_kernel_cfg cfg;
memset(&cfg, 0, sizeof(cfg)); if (!target_if_spectral_nl_sock) {
cfg.groups = 1; qdf_print("%s NETLINK_KERNEL_CREATE FAILED\n",
cfg.input = &target_if_spectral_nl_data_ready; __func__);
target_if_spectral_nl_sock = (struct sock *)netlink_kernel_create( return -ENODEV;
&init_net, NETLINK_ATHEROS, &cfg); }
#else
target_if_spectral_nl_sock = (struct sock *)netlink_kernel_create(
&init_net,
NETLINK_ATHEROS,
1,
&target_if_spectral_nl_data_ready,
NULL,
THIS_MODULE);
#endif
#endif
if (!target_if_spectral_nl_sock) {
qdf_print("%s NETLINK_KERNEL_CREATE FAILED\n", __func__);
return -ENODEV;
}
} }
atomic_inc(&spectral_nl_users); atomic_inc(&spectral_nl_users);
spectral->spectral_sock = target_if_spectral_nl_sock; spectral->spectral_sock = target_if_spectral_nl_sock;
@@ -119,38 +170,26 @@ int target_if_spectral_init_netlink(struct target_if_spectral *spectral)
return 0; return 0;
} }
int target_if_spectral_destroy_netlink(struct target_if_spectral *spectral) int
target_if_spectral_destroy_netlink(struct target_if_spectral *spectral)
{ {
spectral->spectral_sock = NULL; spectral->spectral_sock = NULL;
if (atomic_dec_and_test(&spectral_nl_users)) { if (atomic_dec_and_test(&spectral_nl_users)) {
sock_release(target_if_spectral_nl_sock->sk_socket); sock_release(target_if_spectral_nl_sock->sk_socket);
target_if_spectral_nl_sock = NULL; target_if_spectral_nl_sock = NULL;
} }
return 0; return 0;
} }
#endif /* SPECTRAL_USE_NETLINK_SOCKETS */ #endif /* SPECTRAL_USE_NETLINK_SOCKETS */
static void spectral_process_noise_pwr_report( static void
target_if_spectral_process_noise_pwr_report(
struct target_if_spectral *spectral, struct target_if_spectral *spectral,
const SPECTRAL_SAMP_MSG *spec_samp_msg) const struct spectral_samp_msg *spec_samp_msg)
{ {
int i, done; int i, done;
/*
* qdf_print(
* "%s: #%d/%d datalen=%d tstamp=%x last_tstamp=%x "
* "rssi=%d nb_lower=%d peak=%d\n",
* __func__, spectral->noise_pwr_reports_recv,
* spectral->noise_pwr_reports_reqd,
* spec_samp_msg->samp_data.spectral_data_len,
* spec_samp_msg->samp_data.spectral_tstamp,
* spec_samp_msg->samp_data.spectral_last_tstamp,
* spec_samp_msg->samp_data.spectral_lower_rssi,
* spec_samp_msg->samp_data.spectral_nb_lower,
* spec_samp_msg->samp_data.spectral_lower_max_index);
*/
qdf_spin_lock(&spectral->noise_pwr_reports_lock); qdf_spin_lock(&spectral->noise_pwr_reports_lock);
if (!spectral->noise_pwr_reports_reqd) { if (!spectral->noise_pwr_reports_reqd) {
@@ -159,55 +198,41 @@ static void spectral_process_noise_pwr_report(
} }
if (spectral->noise_pwr_reports_recv < if (spectral->noise_pwr_reports_recv <
spectral->noise_pwr_reports_reqd) { spectral->noise_pwr_reports_reqd) {
spectral->noise_pwr_reports_recv++; spectral->noise_pwr_reports_recv++;
/* for (i = 0; i < HOST_MAX_ANTENNA; i++) {
* qdf_print( uint32_t index;
* "#%d/%d: rssi=%3d,%3d,%3d %3d,%3d,%3d\n",
* spectral->noise_pwr_reports_recv,
* spectral->noise_pwr_reports_reqd,
* spec_samp_msg->samp_data.spectral_chain_ctl_rssi[0],
* spec_samp_msg->samp_data.spectral_chain_ctl_rssi[1],
* spec_samp_msg->samp_data.spectral_chain_ctl_rssi[2],
* spec_samp_msg->samp_data.spectral_chain_ext_rssi[0],
* spec_samp_msg->samp_data.spectral_chain_ext_rssi[1],
* spec_samp_msg->samp_data.spectral_chain_ext_rssi[2]);
*/
for (i = 0; i < ATH_HOST_MAX_ANTENNA; i++) { if (spectral->noise_pwr_chain_ctl[i]) {
uint32_t index; index =
spectral->noise_pwr_chain_ctl[i]->
if (spectral->noise_pwr_chain_ctl[i]) { rptcount++;
index = spectral->noise_pwr_chain_ctl[i]->rptcount++; spectral->noise_pwr_chain_ctl[i]->pwr[index] =
spectral->noise_pwr_chain_ctl[i]->pwr[index] = spec_samp_msg->samp_data.
spec_samp_msg->samp_data.spectral_chain_ctl_rssi[i]; spectral_chain_ctl_rssi[i];
}
if (spectral->noise_pwr_chain_ext[i]) {
index =
spectral->noise_pwr_chain_ext[i]->
rptcount++;
spectral->noise_pwr_chain_ext[i]->pwr[index] =
spec_samp_msg->samp_data.
spectral_chain_ext_rssi[i];
}
} }
if (spectral->noise_pwr_chain_ext[i]) {
index = spectral->noise_pwr_chain_ext[i]->rptcount++;
spectral->noise_pwr_chain_ext[i]->pwr[index] =
spec_samp_msg->samp_data.spectral_chain_ext_rssi[i];
}
}
} }
done = (spectral->noise_pwr_reports_recv >= done = (spectral->noise_pwr_reports_recv >=
spectral->noise_pwr_reports_reqd); spectral->noise_pwr_reports_reqd);
qdf_spin_unlock(&spectral->noise_pwr_reports_lock); qdf_spin_unlock(&spectral->noise_pwr_reports_lock);
if (done) { if (done) {
qdf_spin_lock(&spectral->ath_spectral_lock); qdf_spin_lock(&spectral->spectral_lock);
target_if_stop_spectral_scan(spectral->pdev_obj); target_if_stop_spectral_scan(spectral->pdev_obj);
spectral->sc_spectral_scan = 0; spectral->sc_spectral_scan = 0;
qdf_spin_unlock(&spectral->ath_spectral_lock); qdf_spin_unlock(&spectral->spectral_lock);
/*
* qdf_print(
* "%s: done: %d/%d recv - set sc_spectral_scan = 0\n",
* __func__, spectral->noise_pwr_reports_recv,
* spectral->noise_pwr_reports_reqd);
*/
} }
} }
@@ -219,89 +244,102 @@ static void spectral_process_noise_pwr_report(
* *
*/ */
void target_if_spectral_create_samp_msg( #ifdef SPECTRAL_CLASSIFIER_IN_KERNEL
struct target_if_spectral *spectral, static void
struct target_if_samp_msg_params *params) target_if_spectral_init_interf_list(
struct spectral_samp_data *data,
struct target_if_samp_msg_params *params)
{
if (params->interf_list.count)
OS_MEMCPY(&data->interf_list,
&params->interf_list, sizeof(struct INTERF_SRC_RSP));
else
data->interf_list.count = 0;
}
#else
static void
target_if_spectral_init_interf_list(
struct spectral_samp_data *data,
struct target_if_samp_msg_params *params)
{
data->interf_list.count = 0;
}
#endif
void
target_if_spectral_create_samp_msg(struct target_if_spectral *spectral,
struct target_if_samp_msg_params *params)
{ {
/* /*
* XXX : Non-Rentrant. Will be an issue with dual concurrent * XXX : Non-Rentrant. Will be an issue with dual concurrent
* operation on multi-processor system * operation on multi-processor system
*/ */
int temp_samp_msg_len = 0; int temp_samp_msg_len = 0;
static SPECTRAL_SAMP_MSG spec_samp_msg; static struct spectral_samp_msg spec_samp_msg;
SPECTRAL_SAMP_MSG *msg = NULL; struct spectral_samp_msg *msg = NULL;
SPECTRAL_SAMP_DATA *data = NULL; struct spectral_samp_data *data = NULL;
u_int8_t *bin_pwr_data = NULL; uint8_t *bin_pwr_data = NULL;
SPECTRAL_CLASSIFIER_PARAMS *cp = NULL; struct spectral_classifier_params *cp = NULL;
SPECTRAL_CLASSIFIER_PARAMS *pcp = NULL; struct spectral_classifier_params *pcp = NULL;
struct target_if_spectral_ops *p_sops = NULL; struct target_if_spectral_ops *p_sops = NULL;
struct target_if_spectral_skb_event *sp_skb_event = NULL; struct target_if_spectral_skb_event *sp_skb_event = NULL;
#ifdef SPECTRAL_USE_NETLINK_SOCKETS #ifdef SPECTRAL_USE_NETLINK_SOCKETS
static int samp_msg_index; static int samp_msg_index;
#endif #endif
p_sops = GET_TIF_SPECTRAL_OPS(spectral); p_sops = GET_TARGET_IF_SPECTRAL_OPS(spectral);
temp_samp_msg_len = sizeof(SPECTRAL_SAMP_MSG) - temp_samp_msg_len = sizeof(struct spectral_samp_msg) -
(MAX_NUM_BINS * sizeof(u_int8_t)); (MAX_NUM_BINS * sizeof(uint8_t));
temp_samp_msg_len += (params->pwr_count * sizeof(u_int8_t)); temp_samp_msg_len += (params->pwr_count * sizeof(uint8_t));
if (spectral->ch_width == CH_WIDTH_160MHZ) if (spectral->ch_width == CH_WIDTH_160MHZ)
temp_samp_msg_len += temp_samp_msg_len +=
(params->pwr_count_sec80 * sizeof(u_int8_t)); (params->pwr_count_sec80 * sizeof(uint8_t));
bin_pwr_data = params->bin_pwr_data; bin_pwr_data = params->bin_pwr_data;
memset(&spec_samp_msg, 0, sizeof(SPECTRAL_SAMP_MSG)); memset(&spec_samp_msg, 0, sizeof(struct spectral_samp_msg));
data = &spec_samp_msg.samp_data; data = &spec_samp_msg.samp_data;
spec_samp_msg.signature = SPECTRAL_SIGNATURE; spec_samp_msg.signature = SPECTRAL_SIGNATURE;
spec_samp_msg.freq = params->freq; spec_samp_msg.freq = params->freq;
spec_samp_msg.freq_loading = params->freq_loading; spec_samp_msg.freq_loading = params->freq_loading;
spec_samp_msg.samp_data.spectral_data_len = params->datalen; spec_samp_msg.samp_data.spectral_data_len = params->datalen;
spec_samp_msg.samp_data.spectral_rssi = params->rssi; spec_samp_msg.samp_data.spectral_rssi = params->rssi;
spec_samp_msg.samp_data.ch_width = spectral->ch_width; spec_samp_msg.samp_data.ch_width = spectral->ch_width;
spec_samp_msg.samp_data.spectral_combined_rssi = spec_samp_msg.samp_data.spectral_combined_rssi =
(u_int8_t)params->rssi; (uint8_t)params->rssi;
spec_samp_msg.samp_data.spectral_upper_rssi = params->upper_rssi; spec_samp_msg.samp_data.spectral_upper_rssi = params->upper_rssi;
spec_samp_msg.samp_data.spectral_lower_rssi = params->lower_rssi; spec_samp_msg.samp_data.spectral_lower_rssi = params->lower_rssi;
OS_MEMCPY( OS_MEMCPY(spec_samp_msg.samp_data.spectral_chain_ctl_rssi,
spec_samp_msg.samp_data.spectral_chain_ctl_rssi, params->chain_ctl_rssi, sizeof(params->chain_ctl_rssi));
params->chain_ctl_rssi, OS_MEMCPY(spec_samp_msg.samp_data.spectral_chain_ext_rssi,
sizeof(params->chain_ctl_rssi)); params->chain_ext_rssi, sizeof(params->chain_ext_rssi));
OS_MEMCPY(
spec_samp_msg.samp_data.spectral_chain_ext_rssi,
params->chain_ext_rssi,
sizeof(params->chain_ext_rssi));
spec_samp_msg.samp_data.spectral_bwinfo = params->bwinfo; spec_samp_msg.samp_data.spectral_bwinfo = params->bwinfo;
spec_samp_msg.samp_data.spectral_tstamp = params->tstamp; spec_samp_msg.samp_data.spectral_tstamp = params->tstamp;
spec_samp_msg.samp_data.spectral_max_index = params->max_index; spec_samp_msg.samp_data.spectral_max_index = params->max_index;
/* Classifier in user space needs access to these */ /* Classifier in user space needs access to these */
spec_samp_msg.samp_data.spectral_lower_max_index = spec_samp_msg.samp_data.spectral_lower_max_index =
params->max_lower_index; params->max_lower_index;
spec_samp_msg.samp_data.spectral_upper_max_index = spec_samp_msg.samp_data.spectral_upper_max_index =
params->max_upper_index; params->max_upper_index;
spec_samp_msg.samp_data.spectral_nb_lower = spec_samp_msg.samp_data.spectral_nb_lower = params->nb_lower;
params->nb_lower; spec_samp_msg.samp_data.spectral_nb_upper = params->nb_upper;
spec_samp_msg.samp_data.spectral_nb_upper = params->nb_upper; spec_samp_msg.samp_data.spectral_last_tstamp = params->last_tstamp;
spec_samp_msg.samp_data.spectral_last_tstamp = spec_samp_msg.samp_data.spectral_max_mag = params->max_mag;
params->last_tstamp; spec_samp_msg.samp_data.bin_pwr_count = params->pwr_count;
spec_samp_msg.samp_data.spectral_max_mag = params->max_mag; spec_samp_msg.samp_data.lb_edge_extrabins = spectral->lb_edge_extrabins;
spec_samp_msg.samp_data.bin_pwr_count = spec_samp_msg.samp_data.rb_edge_extrabins = spectral->rb_edge_extrabins;
params->pwr_count; spec_samp_msg.samp_data.spectral_combined_rssi = params->rssi;
spec_samp_msg.samp_data.lb_edge_extrabins = spec_samp_msg.samp_data.spectral_max_scale = params->max_exp;
spectral->lb_edge_extrabins;
spec_samp_msg.samp_data.rb_edge_extrabins =
spectral->rb_edge_extrabins;
spec_samp_msg.samp_data.spectral_combined_rssi = params->rssi;
spec_samp_msg.samp_data.spectral_max_scale = params->max_exp;
#ifdef SPECTRAL_USE_NETLINK_SOCKETS #ifdef SPECTRAL_USE_NETLINK_SOCKETS
@@ -320,201 +358,222 @@ void target_if_spectral_create_samp_msg(
*/ */
spec_samp_msg.samp_data.noise_floor = params->noise_floor; spec_samp_msg.samp_data.noise_floor = params->noise_floor;
#endif /* SPECTRAL_USE_NETLINK_SOCKETS */ #endif /* SPECTRAL_USE_NETLINK_SOCKETS */
/* Classifier in user space needs access to these */ /* Classifier in user space needs access to these */
cp = &spec_samp_msg.samp_data.classifier_params; cp = &spec_samp_msg.samp_data.classifier_params;
pcp = &params->classifier_params; pcp = &params->classifier_params;
OS_MEMCPY(cp, pcp, sizeof(SPECTRAL_CLASSIFIER_PARAMS)); OS_MEMCPY(cp, pcp, sizeof(struct spectral_classifier_params));
SPECTRAL_MSG_COPY_CHAR_ARRAY( SPECTRAL_MESSAGE_COPY_CHAR_ARRAY(&data->bin_pwr[0],
&data->bin_pwr[0], bin_pwr_data, params->pwr_count);
bin_pwr_data,
params->pwr_count);
#ifdef SPECTRAL_USE_NETLINK_SOCKETS #ifdef SPECTRAL_USE_NETLINK_SOCKETS
spec_samp_msg.vhtop_ch_freq_seg1 = spec_samp_msg.vhtop_ch_freq_seg1 = params->vhtop_ch_freq_seg1;
params->vhtop_ch_freq_seg1; spec_samp_msg.vhtop_ch_freq_seg2 = params->vhtop_ch_freq_seg2;
spec_samp_msg.vhtop_ch_freq_seg2 =
params->vhtop_ch_freq_seg2;
if (spectral->ch_width == CH_WIDTH_160MHZ) { if (spectral->ch_width == CH_WIDTH_160MHZ) {
spec_samp_msg.samp_data.spectral_rssi_sec80 = params->rssi_sec80; spec_samp_msg.samp_data.spectral_rssi_sec80 =
spec_samp_msg.samp_data.noise_floor_sec80 = params->noise_floor_sec80; params->rssi_sec80;
spec_samp_msg.samp_data.noise_floor_sec80 =
params->noise_floor_sec80;
spec_samp_msg.samp_data.spectral_data_len_sec80 = spec_samp_msg.samp_data.spectral_data_len_sec80 =
params->datalen_sec80; params->datalen_sec80;
spec_samp_msg.samp_data.spectral_max_index_sec80 = spec_samp_msg.samp_data.spectral_max_index_sec80 =
params->max_index_sec80; params->max_index_sec80;
spec_samp_msg.samp_data.spectral_max_mag_sec80 = spec_samp_msg.samp_data.spectral_max_mag_sec80 =
params->max_mag_sec80; params->max_mag_sec80;
spec_samp_msg.samp_data.bin_pwr_count_sec80 = spec_samp_msg.samp_data.bin_pwr_count_sec80 =
params->pwr_count_sec80; params->pwr_count_sec80;
SPECTRAL_MSG_COPY_CHAR_ARRAY(&data->bin_pwr_sec80[0], SPECTRAL_MESSAGE_COPY_CHAR_ARRAY(&data->bin_pwr_sec80[0],
(params->bin_pwr_data_sec80), (params->bin_pwr_data_sec80),
params->pwr_count_sec80); params->pwr_count_sec80);
/* Note: REVERSE_ORDER is not a known use case for secondary 80 data at /*
* this point. * Note: REVERSE_ORDER is not a known use case for
*/ * secondary 80 data at this point.
*/
} }
#endif /* SPECTRAL_USE_NETLINK_SOCKETS */ #endif /* SPECTRAL_USE_NETLINK_SOCKETS */
#ifdef SPECTRAL_CLASSIFIER_IN_KERNEL target_if_spectral_init_interf_list(data, params);
if (params->interf_list.count)
OS_MEMCPY(
&data->interf_list,
&params->interf_list,
sizeof(struct INTERF_SRC_RSP));
else
#endif
data->interf_list.count = 0;
#ifdef SPECTRAL_USE_NETLINK_SOCKETS #ifdef SPECTRAL_USE_NETLINK_SOCKETS
target_if_spectral_prep_skb(spectral); target_if_spectral_prep_skb(spectral);
if (spectral->spectral_skb) { if (spectral->spectral_skb) {
p_sops->get_mac_address(spectral, spec_samp_msg.macaddr); p_sops->get_mac_address(spectral, spec_samp_msg.macaddr);
spectral->spectral_nlh = spectral->spectral_nlh =
(struct nlmsghdr *)spectral->spectral_skb->data; (struct nlmsghdr *)spectral->spectral_skb->data;
memcpy(NLMSG_DATA(spectral->spectral_nlh), memcpy(NLMSG_DATA(spectral->spectral_nlh),
&spec_samp_msg, &spec_samp_msg, sizeof(struct spectral_samp_msg));
sizeof(SPECTRAL_SAMP_MSG)); msg = (struct spectral_samp_msg *)NLMSG_DATA(
msg = (SPECTRAL_SAMP_MSG *)NLMSG_DATA(spectral->spectral_nlh); spectral->spectral_nlh);
/* Broadcast spectral data only if it is a edma supported device */ /*
if (!spectral->sc_spectral_non_edma) * Broadcast spectral data only
target_if_spectral_bcast_msg(spectral); * if it is a edma supported device
samp_msg_index++; */
if (!spectral->sc_spectral_non_edma)
target_if_spectral_bcast_msg(spectral);
samp_msg_index++;
} }
/* Check if the device is non-edma and follow the required broadcast /*
* Check if the device is non-edma and follow the required broadcast
* path if true * path if true
*/ */
if (spectral->sc_spectral_non_edma) { if (spectral->sc_spectral_non_edma) {
/* Allocating memory for the queue entity to hold the spectral socket /*
* buffer * Allocating memory for the queue entity to
*/ * hold the spectral socket buffer
sp_skb_event = (struct target_if_spectral_skb_event
*)qdf_mem_malloc(sizeof(struct target_if_spectral_skb_event));
if (sp_skb_event) {
OS_MEMZERO(
sp_skb_event,
sizeof(struct target_if_spectral_skb_event));
sp_skb_event->sp_skb = spectral->spectral_skb;
sp_skb_event->sp_nlh = spectral->spectral_nlh;
spectral->spectral_skb = NULL;
spectral->spectral_nlh = NULL;
/* Queue spectral socket buffers to be broadcasted outside irq
* lock
*/ */
qdf_spin_lock(&spectral->spectral_skbqlock); sp_skb_event = (struct target_if_spectral_skb_event
STAILQ_INSERT_TAIL( *)qdf_mem_malloc(
&spectral->spectral_skbq, sizeof(
sp_skb_event, struct target_if_spectral_skb_event));
spectral_skb_list);
qdf_spin_unlock(&spectral->spectral_skbqlock); if (sp_skb_event) {
} OS_MEMZERO(sp_skb_event,
sizeof(struct target_if_spectral_skb_event));
sp_skb_event->sp_skb = spectral->spectral_skb;
sp_skb_event->sp_nlh = spectral->spectral_nlh;
spectral->spectral_skb = NULL;
spectral->spectral_nlh = NULL;
/*
* Queue spectral socket buffers to be broadcasted
* outside irq lock
*/
qdf_spin_lock(&spectral->spectral_skbqlock);
STAILQ_INSERT_TAIL(&spectral->spectral_skbq,
sp_skb_event, spectral_skb_list);
qdf_spin_unlock(&spectral->spectral_skbqlock);
}
} }
#else #else
/* /*
* call the indicate function to pass the data to the net layer * call the indicate function to pass the data to the net layer
* Windows will pass to a spectral WIN32 service * Windows will pass to a spectral WIN32 service
*/ */
msg = (SPECTRAL_SAMP_MSG *)qdf_mem_malloc(sizeof(SPECTRAL_SAMP_MSG)); msg = (struct spectral_samp_msg *)qdf_mem_malloc(
sizeof(struct spectral_samp_msg));
if (msg) { if (msg) {
OS_MEMCPY(msg, &spec_samp_msg, sizeof(SPECTRAL_SAMP_MSG)); OS_MEMCPY(msg, &spec_samp_msg,
ath_spectral_indicate( sizeof(struct spectral_samp_msg));
params->sc, ath_spectral_indicate(params->sc, (void *)msg,
(void *)msg, sizeof(struct spectral_samp_msg));
sizeof(SPECTRAL_SAMP_MSG)); OS_FREE(msg);
OS_FREE(msg); msg = NULL;
msg = NULL;
} else { } else {
qdf_print("No buffer\n"); qdf_print("No buffer\n");
} }
#endif /* SPECTRAL_USE_NETLINK_SOCKETS */ #endif /* SPECTRAL_USE_NETLINK_SOCKETS */
if (spectral->sc_spectral_noise_pwr_cal) if (spectral->sc_spectral_noise_pwr_cal)
spectral_process_noise_pwr_report(spectral, &spec_samp_msg); target_if_spectral_process_noise_pwr_report(
spectral, &spec_samp_msg);
} }
#ifdef SPECTRAL_USE_NETLINK_SOCKETS #ifdef SPECTRAL_USE_NETLINK_SOCKETS
void target_if_spectral_prep_skb(struct target_if_spectral *spectral) void
target_if_spectral_prep_skb(struct target_if_spectral *spectral)
{ {
spectral->spectral_skb = dev_alloc_skb(MAX_SPECTRAL_PAYLOAD); spectral->spectral_skb = dev_alloc_skb(MAX_SPECTRAL_PAYLOAD);
if (spectral->spectral_skb) { if (spectral->spectral_skb) {
skb_put(spectral->spectral_skb, MAX_SPECTRAL_PAYLOAD); skb_put(spectral->spectral_skb, MAX_SPECTRAL_PAYLOAD);
spectral->spectral_nlh = spectral->spectral_nlh =
(struct nlmsghdr *)spectral->spectral_skb->data; (struct nlmsghdr *)spectral->spectral_skb->data;
OS_MEMZERO(spectral->spectral_nlh, sizeof(*spectral->spectral_nlh)); OS_MEMZERO(spectral->spectral_nlh,
sizeof(*spectral->spectral_nlh));
/* Possible bug that size of SPECTRAL_SAMP_MSG and SPECTRAL_MSG /*
* differ by 3 bytes so we miss 3 bytes * Possible bug that size of struct spectral_samp_msg and
*/ * SPECTRAL_MSG differ by 3 bytes so we miss 3 bytes
*/
spectral->spectral_nlh->nlmsg_len = spectral->spectral_nlh->nlmsg_len =
NLMSG_SPACE(sizeof(SPECTRAL_SAMP_MSG)); NLMSG_SPACE(sizeof(struct spectral_samp_msg));
spectral->spectral_nlh->nlmsg_pid = 0; spectral->spectral_nlh->nlmsg_pid = 0;
spectral->spectral_nlh->nlmsg_flags = 0; spectral->spectral_nlh->nlmsg_flags = 0;
} else { } else {
spectral->spectral_skb = NULL; spectral->spectral_skb = NULL;
spectral->spectral_nlh = NULL; spectral->spectral_nlh = NULL;
} }
} }
void target_if_spectral_unicast_msg(struct target_if_spectral *spectral) #if (KERNEL_VERSION(2, 6, 31) > LINUX_VERSION_CODE)
static inline void
target_if_init_spectral_skb_dst_pid(
struct target_if_spectral *spectral)
{
NETLINK_CB(spectral->spectral_skb).dst_pid =
spectral->spectral_pid;
}
#else
static inline void
target_if_init_spectral_skb_dst_pid(
struct target_if_spectral *spectral)
{
}
#endif /* VERSION - field depracated by newer kernel */
#if KERNEL_VERSION(3, 7, 0) > LINUX_VERSION_CODE
static inline void
target_if_init_spectral_skb_pid_portid(
struct target_if_spectral *spectral)
{
NETLINK_CB(spectral->spectral_skb).pid = 0; /* from kernel */
}
#else
static inline void
target_if_init_spectral_skb_pid_portid(
struct target_if_spectral *spectral)
{
NETLINK_CB(spectral->spectral_skb).portid = 0; /* from kernel */
}
#endif
void
target_if_spectral_unicast_msg(struct target_if_spectral *spectral)
{ {
if (!spectral) { if (!spectral) {
qdf_print("%s Spectral is NULL\n", __func__); qdf_print("%s Spectral is NULL\n", __func__);
return; return;
} }
if (!spectral->spectral_sock) { if (!spectral->spectral_sock) {
qdf_print("%s Spectral Socket is invalid\n", __func__); qdf_print("%s Spectral Socket is invalid\n", __func__);
dev_kfree_skb(spectral->spectral_skb); dev_kfree_skb(spectral->spectral_skb);
spectral->spectral_skb = NULL; spectral->spectral_skb = NULL;
return; return;
} }
if (spectral->spectral_skb) { if (spectral->spectral_skb) {
#if (KERNEL_VERSION(2, 6, 31) > LINUX_VERSION_CODE) target_if_init_spectral_skb_dst_pid(spectral);
NETLINK_CB(spectral->spectral_skb).dst_pid = spectral->spectral_pid;
#endif /* VERSION - field depracated by newer kernel */
#if KERNEL_VERSION(3, 7, 0) > LINUX_VERSION_CODE
NETLINK_CB(spectral->spectral_skb).pid = 0; /* from kernel */
#else
NETLINK_CB(spectral->spectral_skb).portid = 0; /* from kernel */
#endif
/* to mcast group 1<<0 */
NETLINK_CB(spectral->spectral_skb).dst_group = 0;
netlink_unicast( target_if_init_spectral_skb_pid_portid(spectral);
spectral->spectral_sock,
spectral->spectral_skb, /* to mcast group 1<<0 */
spectral->spectral_pid, NETLINK_CB(spectral->spectral_skb).dst_group = 0;
MSG_DONTWAIT);
netlink_unicast(spectral->spectral_sock,
spectral->spectral_skb,
spectral->spectral_pid, MSG_DONTWAIT);
} }
} }
/* void
* Function : target_if_spectral_bcast_msg target_if_spectral_bcast_msg(struct target_if_spectral *spectral)
* Description : Passes the Spectral Message to Host
* Input : Pointer to spectral
* Output : Void
*
*/
void target_if_spectral_bcast_msg(struct target_if_spectral *spectral)
{ {
#if (KERNEL_VERSION(2, 6, 31) >= LINUX_VERSION_CODE) #if (KERNEL_VERSION(2, 6, 31) >= LINUX_VERSION_CODE)
fd_set write_set; fd_set write_set;
#endif #endif
SPECTRAL_SAMP_MSG *msg = NULL; struct spectral_samp_msg *msg = NULL;
struct nlmsghdr *nlh = NULL; struct nlmsghdr *nlh = NULL;
int status; int status;
#if (KERNEL_VERSION(2, 6, 31) >= LINUX_VERSION_CODE) #if (KERNEL_VERSION(2, 6, 31) >= LINUX_VERSION_CODE)
@@ -522,7 +581,7 @@ void target_if_spectral_bcast_msg(struct target_if_spectral *spectral)
#endif #endif
if (!spectral) if (!spectral)
return; return;
if (!spectral->spectral_sock) { if (!spectral->spectral_sock) {
dev_kfree_skb(spectral->spectral_skb); dev_kfree_skb(spectral->spectral_skb);
@@ -531,15 +590,13 @@ void target_if_spectral_bcast_msg(struct target_if_spectral *spectral)
} }
if (!spectral->spectral_skb) if (!spectral->spectral_skb)
return; return;
nlh = (struct nlmsghdr *)spectral->spectral_skb->data; nlh = (struct nlmsghdr *)spectral->spectral_skb->data;
msg = (SPECTRAL_SAMP_MSG *)NLMSG_DATA(spectral->spectral_nlh); msg = (struct spectral_samp_msg *)NLMSG_DATA(spectral->spectral_nlh);
/* print_samp_msg (msg, sc); */ status = target_if_send_phydata(spectral->pdev_obj,
status = target_if_send_phydata( spectral->spectral_sock,
spectral->pdev_obj, spectral->spectral_skb);
spectral->spectral_sock,
spectral->spectral_skb);
if (status == 0) if (status == 0)
spectral->spectral_sent_msg++; spectral->spectral_sent_msg++;
@@ -548,31 +605,29 @@ void target_if_spectral_bcast_msg(struct target_if_spectral *spectral)
spectral->spectral_skb = NULL; spectral->spectral_skb = NULL;
} }
void target_if_spectral_skb_dequeue(unsigned long data) void
target_if_spectral_skb_dequeue(void *data)
{ {
struct target_if_spectral *spectral = struct target_if_spectral *spectral = (struct target_if_spectral *)data;
(struct target_if_spectral *)data;
struct target_if_spectral_skb_event *sp_skb_event = NULL; struct target_if_spectral_skb_event *sp_skb_event = NULL;
qdf_spin_lock(&spectral->spectral_skbqlock); qdf_spin_lock(&spectral->spectral_skbqlock);
/* Deque all the spectral socket buffers queued */ /* Deque all the spectral socket buffers queued */
while (!STAILQ_EMPTY(&spectral->spectral_skbq)) { while (!STAILQ_EMPTY(&spectral->spectral_skbq)) {
sp_skb_event = STAILQ_FIRST(&spectral->spectral_skbq); sp_skb_event = STAILQ_FIRST(&spectral->spectral_skbq);
if (sp_skb_event) { if (sp_skb_event) {
spectral->spectral_skb = sp_skb_event->sp_skb; spectral->spectral_skb = sp_skb_event->sp_skb;
spectral->spectral_nlh = sp_skb_event->sp_nlh; spectral->spectral_nlh = sp_skb_event->sp_nlh;
STAILQ_REMOVE_HEAD( STAILQ_REMOVE_HEAD(&spectral->spectral_skbq,
&spectral->spectral_skbq, spectral_skb_list);
spectral_skb_list); qdf_spin_unlock(&spectral->spectral_skbqlock);
qdf_spin_unlock(&spectral->spectral_skbqlock); OS_FREE(sp_skb_event);
OS_FREE(sp_skb_event); /* Broadcast spectral data after dequeing */
/* Broadcast spectral data after dequeing */ target_if_spectral_bcast_msg(spectral);
target_if_spectral_bcast_msg(spectral); qdf_spin_lock(&spectral->spectral_skbqlock);
qdf_spin_lock(&spectral->spectral_skbqlock); }
}
} }
qdf_spin_unlock(&spectral->spectral_skbqlock); qdf_spin_unlock(&spectral->spectral_skbqlock);
} }
#endif /* SPECTRAL_USE_NETLINK_SOCKETS */ #endif /* SPECTRAL_USE_NETLINK_SOCKETS */

1735
target_if/spectral/target_if_spectral_phyerr.c
View File

File diff suppressed because it is too large Load Diff

4
target_if/spectral/target_if_spectral_sim.c
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015,2017 The Linux Foundation. All rights reserved. * Copyright (c) 2015,2017-2018 The Linux Foundation. All rights reserved.
* *
* *
* Permission to use, copy, modify, and/or distribute this software for * Permission to use, copy, modify, and/or distribute this software for
@@ -541,7 +541,7 @@ OS_TIMER_FUNC(spectral_sim_phyerrdelivery_handler)
OS_GET_TIMER_ARG(spectral, struct target_if_spectral *); OS_GET_TIMER_ARG(spectral, struct target_if_spectral *);
qdf_assert_always(spectral); qdf_assert_always(spectral);
p_sops = GET_TIF_SPECTRAL_OPS(spectral); p_sops = GET_TARGET_IF_SPECTRAL_OPS(spectral);
qdf_assert_always(spectral); qdf_assert_always(spectral);
simctx = (ath_spectralsim_context *)spectral->simctx; simctx = (ath_spectralsim_context *)spectral->simctx;