| /* |
| * Copyright (c) 2002-2013 The Linux Foundation. All rights reserved. |
| * |
| * Previously licensed under the ISC license by Qualcomm Atheros, Inc. |
| * |
| * |
| * Permission to use, copy, modify, and/or distribute this software for |
| * any purpose with or without fee is hereby granted, provided that the |
| * above copyright notice and this permission notice appear in all |
| * copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL |
| * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE |
| * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
| * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| * PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| /* |
| * This file was originally distributed by Qualcomm Atheros, Inc. |
| * under proprietary terms before Copyright ownership was assigned |
| * to the Linux Foundation. |
| */ |
| |
| /*=========================================================================== |
| |
| dfs_staggered.c |
| |
| OVERVIEW: |
| |
| Source code borrowed from QCA_MAIN DFS module |
| |
| DEPENDENCIES: |
| |
| Are listed for each API below. |
| |
| ===========================================================================*/ |
| |
| /*=========================================================================== |
| |
| EDIT HISTORY FOR FILE |
| |
| |
| This section contains comments describing changes made to the module. |
| Notice that changes are listed in reverse chronological order. |
| |
| |
| |
| when who what, where, why |
| ---------- --- -------------------------------------------------------- |
| |
| ===========================================================================*/ |
| |
| |
| #include "dfs.h" |
| /* TO DO DFS |
| #include <ieee80211_var.h> |
| */ |
| #ifdef ATH_SUPPORT_DFS |
| |
| static int is_pri_multiple(u_int32_t sample_pri, u_int32_t refpri) |
| { |
| #define MAX_ALLOWED_MISSED 3 |
| int i; |
| |
| if (sample_pri < refpri || (!refpri)) |
| return 0; |
| |
| for (i=1; i<= MAX_ALLOWED_MISSED; i++) { |
| if((sample_pri%(i*refpri) <= 5)) { |
| //printk("sample_pri=%d is a multiple of refpri=%d\n", sample_pri, refpri); |
| return 1; |
| } |
| } |
| return 0; |
| #undef MAX_ALLOWED_MISSED |
| } |
| |
| static int is_unique_pri(u_int32_t highestpri , u_int32_t midpri, |
| u_int32_t lowestpri , u_int32_t refpri ) |
| { |
| #define DFS_STAGGERED_PRI_MARGIN_MIN 20 |
| #define DFS_STAGGERED_PRI_MARGIN_MAX 400 |
| if ((DFS_DIFF(lowestpri, refpri) >= DFS_STAGGERED_PRI_MARGIN_MIN) && |
| (DFS_DIFF(midpri, refpri) >= DFS_STAGGERED_PRI_MARGIN_MIN) && |
| (DFS_DIFF(highestpri, refpri) >= DFS_STAGGERED_PRI_MARGIN_MIN)) { |
| return 1; |
| } else { |
| if ((is_pri_multiple(refpri, highestpri)) || (is_pri_multiple(refpri, lowestpri)) || |
| (is_pri_multiple(refpri, midpri))) |
| return 0; |
| } |
| return 0; |
| #undef DFS_STAGGERED_PRI_MARGIN_MIN |
| #undef DFS_STAGGERED_PRI_MARGIN_MAX |
| } |
| |
| |
| int dfs_staggered_check(struct ath_dfs *dfs, struct dfs_filter *rf, |
| u_int32_t deltaT, u_int32_t width) |
| { |
| u_int32_t refpri, refdur, searchpri=0, deltapri;//, averagerefpri; |
| u_int32_t n, i, primargin, durmargin; |
| int score[DFS_MAX_DL_SIZE], delayindex, dindex, found=0; |
| struct dfs_delayline *dl; |
| u_int32_t scoreindex, lowpriindex= 0, lowpri = 0xffff; |
| #if 0 |
| int numpulses=0; |
| #endif |
| int higherthan, lowerthan, numscores; |
| int numpulseshigh=0, numpulsesmid=0, numpulsestemp=0; |
| u_int32_t lowestscore=0, lowestscoreindex=0, lowestpri=0; |
| u_int32_t midscore=0, midscoreindex=0, midpri=0; |
| u_int32_t highestscore=0, highestscoreindex=0, highestpri=0; |
| |
| dl = &rf->rf_dl; |
| if( dl->dl_numelems < (rf->rf_threshold-1)) { |
| DFS_DPRINTK(dfs, ATH_DEBUG_DFS2, |
| "numelems %d < threshold for filter %d\n", |
| dl->dl_numelems, rf->rf_pulseid); |
| return 0; |
| } |
| if( deltaT > rf->rf_filterlen) { |
| DFS_DPRINTK(dfs, ATH_DEBUG_DFS2, |
| "numelems %d < threshold for filter %d\n", |
| dl->dl_numelems, rf->rf_pulseid); |
| return 0; |
| } |
| primargin = 6; |
| if(rf->rf_maxdur < 10) { |
| durmargin = 4; |
| } |
| else { |
| durmargin = 6; |
| } |
| |
| OS_MEMZERO(score, sizeof(int)*DFS_MAX_DL_SIZE); |
| /* find out the lowest pri */ |
| for (n=0;n<dl->dl_numelems; n++) { |
| delayindex = (dl->dl_firstelem + n) & DFS_MAX_DL_MASK; |
| refpri = dl->dl_elems[delayindex].de_time; |
| if( refpri == 0) |
| continue; |
| else if(refpri < lowpri) { |
| lowpri = dl->dl_elems[delayindex].de_time; |
| lowpriindex = n; |
| } |
| } |
| /* find out the each delay element's pri score */ |
| for (n=0;n<dl->dl_numelems; n++) { |
| delayindex = (dl->dl_firstelem + n) & DFS_MAX_DL_MASK; |
| refpri = dl->dl_elems[delayindex].de_time; |
| if( refpri == 0) { |
| continue; |
| } |
| |
| if ( (refpri > rf->rf_maxpri) || (refpri < rf->rf_minpri) ) { |
| score[n] = 0; |
| continue; |
| } |
| |
| for (i=0;i<dl->dl_numelems; i++) { |
| dindex = (dl->dl_firstelem + i) & DFS_MAX_DL_MASK; |
| searchpri = dl->dl_elems[dindex].de_time; |
| deltapri = DFS_DIFF(searchpri, refpri); |
| if( deltapri < primargin) |
| score[n]++; |
| } |
| } |
| for (n=0;n<dl->dl_numelems; n++) { |
| delayindex = (dl->dl_firstelem + n) & DFS_MAX_DL_MASK; |
| refdur = dl->dl_elems[delayindex].de_time; |
| DFS_DPRINTK(dfs, ATH_DEBUG_DFS2, "score[%d]=%d pri=%d\n", n, score[n], refdur); |
| } |
| |
| /* find out the 2 or 3 highest scorers */ |
| scoreindex = 0; |
| highestscore=0; |
| highestscoreindex=0; |
| highestpri=0; numscores=0; lowestscore=0; |
| |
| for (n=0;n<dl->dl_numelems; n++) { |
| higherthan=0; |
| lowerthan=0; |
| delayindex = (dl->dl_firstelem + n) & DFS_MAX_DL_MASK; |
| refpri = dl->dl_elems[delayindex].de_time; |
| |
| if ((score[n] >= highestscore) && |
| (is_unique_pri(highestpri, midpri, lowestpri, refpri))) { |
| lowestscore = midscore; |
| lowestpri = midpri; |
| lowestscoreindex = midscoreindex; |
| midscore = highestscore; |
| midpri = highestpri; |
| midscoreindex = highestscoreindex; |
| highestscore = score[n]; |
| highestpri = refpri; |
| highestscoreindex = n; |
| } else { |
| if ((score[n] >= midscore) && |
| (is_unique_pri(highestpri, midpri, lowestpri, refpri))) { |
| lowestscore = midscore; |
| lowestpri = midpri; |
| lowestscoreindex = midscoreindex; |
| midscore = score[n]; |
| midpri = refpri; |
| midscoreindex = n; |
| } else if ((score[n] >= lowestscore) && |
| (is_unique_pri(highestpri, midpri, lowestpri, refpri))) { |
| lowestscore = score[n]; |
| lowestpri = refpri; |
| lowestscoreindex = n; |
| } |
| } |
| |
| } |
| |
| if (midscore == 0) { |
| // This means we have only 1 pulse type. It can not be staggered! |
| return 0; |
| } |
| |
| DFS_DPRINTK(dfs, ATH_DEBUG_DFS1, |
| "FINAL highestscore=%d highestscoreindex=%d highestpri=%d\n", |
| highestscore, highestscoreindex, highestpri); |
| DFS_DPRINTK(dfs, ATH_DEBUG_DFS1, |
| "FINAL lowestscore=%d lowestscoreindex=%d lowpri=%d\n", |
| lowestscore, lowestscoreindex, lowestpri); |
| DFS_DPRINTK(dfs, ATH_DEBUG_DFS1, |
| "FINAL midscore=%d midscoreindex=%d midpri=%d\n", |
| midscore, midscoreindex, midpri); |
| |
| |
| delayindex = (dl->dl_firstelem + highestscoreindex) & DFS_MAX_DL_MASK; |
| refdur = dl->dl_elems[delayindex].de_dur; |
| refpri = dl->dl_elems[delayindex].de_time; |
| DFS_DPRINTK(dfs, ATH_DEBUG_DFS1, |
| "highscoreindex=%d refdur=%d refpri=%d\n", |
| highestscoreindex, refdur, refpri); |
| |
| numpulsestemp = dfs_bin_pri_check(dfs, rf, dl, highestscore, refpri, refdur,0, highestpri); |
| numpulseshigh = numpulsestemp; |
| numpulsestemp = dfs_bin_pri_check(dfs, rf, dl, highestscore, refpri, refdur,0, highestpri + midpri); |
| if (numpulsestemp > numpulseshigh) { |
| numpulseshigh = numpulsestemp; |
| } |
| numpulsestemp = dfs_bin_pri_check(dfs, rf, dl, highestscore, refpri, refdur,0, highestpri + midpri + lowestpri); |
| if (numpulsestemp > numpulseshigh) { |
| numpulseshigh = numpulsestemp; |
| } |
| |
| |
| delayindex = (dl->dl_firstelem + midscoreindex) & DFS_MAX_DL_MASK; |
| refdur = dl->dl_elems[delayindex].de_dur; |
| refpri = dl->dl_elems[delayindex].de_time; |
| DFS_DPRINTK(dfs, ATH_DEBUG_DFS1, |
| "midscoreindex=%d refdur=%d refpri=%d\n", |
| midscoreindex, refdur, refpri); |
| |
| //numpulsesmid = dfs_bin_pri_check(dfs, rf, dl, midscore, refpri, refdur,0, 1); |
| numpulsestemp = dfs_bin_pri_check(dfs, rf, dl, midscore, refpri, refdur,0, midpri); |
| numpulsesmid = numpulsestemp; |
| numpulsestemp = dfs_bin_pri_check(dfs, rf, dl, midscore, refpri, refdur,0, highestpri + midpri); |
| if (numpulsestemp > numpulsesmid) { |
| numpulsesmid = numpulsestemp; |
| } |
| numpulsestemp = dfs_bin_pri_check(dfs, rf, dl, midscore, refpri, refdur,0, highestpri + midpri + lowestpri); |
| if (numpulsestemp > numpulsesmid) { |
| numpulsesmid = numpulsestemp; |
| } |
| |
| |
| /*delayindex = (dl->dl_firstelem + lowestscoreindex) & DFS_MAX_DL_MASK; |
| refdur = dl->dl_elems[delayindex].de_dur; |
| refpri = dl->dl_elems[delayindex].de_time; |
| DFS_DPRINTK(ic, ATH_DEBUG_DFS1, "lowestscoreindex=%d refdur=%d refpri=%d\n", lowestscoreindex, refdur, refpri); |
| |
| numpulseslow = dfs_bin_pri_check(dfs, rf, dl, lowestscore, refpri, refdur,0, 1); |
| */ |
| DFS_DPRINTK(dfs, ATH_DEBUG_DFS2, |
| "numpulseshigh=%d, numpulsesmid=%d\n", |
| numpulseshigh, numpulsesmid); |
| // printf("numpulseshigh=%d, numpulsesmid=%d, numpulseslow %d\n",numpulseshigh, numpulsesmid, numpulseslow); |
| |
| if ( (numpulseshigh >= rf->rf_threshold) && (numpulsesmid >= rf->rf_threshold) ) { |
| /*if (numpulses >= rf->rf_threshold) {*/ |
| found = 1; |
| DFS_DPRINTK(dfs, ATH_DEBUG_DFS2, "MATCH filter=%u numpulseshigh=%u numpulsesmid= %u thresh=%u\n", rf->rf_pulseid, numpulseshigh, numpulsesmid, rf->rf_threshold); |
| } |
| return found; |
| } |
| |
| #endif /* ATH_SUPPORT_DFS */ |
