Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging-2.6
* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging-2.6: (42 commits) Staging: usbip: fix build warning on 64bit kernels Staging: me4000: remove some compiler warnings Staging: wbusb: fix a bunch of compiler warnings Staging: w35und: module init cleanup Staging: w35und: use gotos for error handling Staging: w35und: remove spinlock wrappers Staging: sxg: fix compiler warnings. Staging: sxg: fix up unused function warnings Staging: sxg: clean up C99 comments Staging: Lindent the echo driver Staging: SLICOSS: Free multicast list at driver exit Staging: PCC-ACPI: Fix all checkpatch errors Staging: pcc-acpi: update to latest version Staging: Clean up sxg driver Staging: remove remaining uses of __FUNCTION__ Staging: add poch driver Staging: wlan-ng: fix build error if wireless networking is not enabled Staging: echo: remove annoying "end of function" markers Staging: echo: remove __cplusplus macro magic Staging: echo: remove dead code ...
This commit is contained in:
commit
45432371b4
|
@ -43,4 +43,8 @@ source "drivers/staging/echo/Kconfig"
|
|||
|
||||
source "drivers/staging/at76_usb/Kconfig"
|
||||
|
||||
source "drivers/staging/pcc-acpi/Kconfig"
|
||||
|
||||
source "drivers/staging/poch/Kconfig"
|
||||
|
||||
endif # STAGING
|
||||
|
|
|
@ -13,3 +13,5 @@ obj-$(CONFIG_W35UND) += winbond/
|
|||
obj-$(CONFIG_PRISM2_USB) += wlan-ng/
|
||||
obj-$(CONFIG_ECHO) += echo/
|
||||
obj-$(CONFIG_USB_ATMEL) += at76_usb/
|
||||
obj-$(CONFIG_PCC_ACPI) += pcc-acpi/
|
||||
obj-$(CONFIG_POCH) += poch/
|
||||
|
|
|
@ -2319,9 +2319,11 @@ static int at76_iw_handler_get_scan(struct net_device *netdev,
|
|||
if (!iwe)
|
||||
return -ENOMEM;
|
||||
|
||||
if (priv->scan_state != SCAN_COMPLETED)
|
||||
if (priv->scan_state != SCAN_COMPLETED) {
|
||||
/* scan not yet finished */
|
||||
kfree(iwe);
|
||||
return -EAGAIN;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&priv->bss_list_spinlock, flags);
|
||||
|
||||
|
|
|
@ -30,10 +30,6 @@
|
|||
#if !defined(_BIT_OPERATIONS_H_)
|
||||
#define _BIT_OPERATIONS_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if defined(__i386__) || defined(__x86_64__)
|
||||
/*! \brief Find the bit position of the highest set bit in a word
|
||||
\param bits The word to be searched
|
||||
|
@ -46,10 +42,10 @@ static __inline__ int top_bit(unsigned int bits)
|
|||
" decl %[res];\n"
|
||||
" bsrl %[bits],%[res]\n"
|
||||
:[res] "=&r" (res)
|
||||
: [bits] "rm" (bits));
|
||||
:[bits] "rm"(bits)
|
||||
);
|
||||
return res;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
/*! \brief Find the bit position of the lowest set bit in a word
|
||||
\param bits The word to be searched
|
||||
|
@ -62,10 +58,10 @@ static __inline__ int bottom_bit(unsigned int bits)
|
|||
" decl %[res];\n"
|
||||
" bsfl %[bits],%[res]\n"
|
||||
:[res] "=&r" (res)
|
||||
: [bits] "rm" (bits));
|
||||
:[bits] "rm"(bits)
|
||||
);
|
||||
return res;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
#else
|
||||
static __inline__ int top_bit(unsigned int bits)
|
||||
{
|
||||
|
@ -74,34 +70,28 @@ static __inline__ int top_bit(unsigned int bits)
|
|||
if (bits == 0)
|
||||
return -1;
|
||||
i = 0;
|
||||
if (bits & 0xFFFF0000)
|
||||
{
|
||||
if (bits & 0xFFFF0000) {
|
||||
bits &= 0xFFFF0000;
|
||||
i += 16;
|
||||
}
|
||||
if (bits & 0xFF00FF00)
|
||||
{
|
||||
if (bits & 0xFF00FF00) {
|
||||
bits &= 0xFF00FF00;
|
||||
i += 8;
|
||||
}
|
||||
if (bits & 0xF0F0F0F0)
|
||||
{
|
||||
if (bits & 0xF0F0F0F0) {
|
||||
bits &= 0xF0F0F0F0;
|
||||
i += 4;
|
||||
}
|
||||
if (bits & 0xCCCCCCCC)
|
||||
{
|
||||
if (bits & 0xCCCCCCCC) {
|
||||
bits &= 0xCCCCCCCC;
|
||||
i += 2;
|
||||
}
|
||||
if (bits & 0xAAAAAAAA)
|
||||
{
|
||||
if (bits & 0xAAAAAAAA) {
|
||||
bits &= 0xAAAAAAAA;
|
||||
i += 1;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
static __inline__ int bottom_bit(unsigned int bits)
|
||||
{
|
||||
|
@ -110,34 +100,28 @@ static __inline__ int bottom_bit(unsigned int bits)
|
|||
if (bits == 0)
|
||||
return -1;
|
||||
i = 32;
|
||||
if (bits & 0x0000FFFF)
|
||||
{
|
||||
if (bits & 0x0000FFFF) {
|
||||
bits &= 0x0000FFFF;
|
||||
i -= 16;
|
||||
}
|
||||
if (bits & 0x00FF00FF)
|
||||
{
|
||||
if (bits & 0x00FF00FF) {
|
||||
bits &= 0x00FF00FF;
|
||||
i -= 8;
|
||||
}
|
||||
if (bits & 0x0F0F0F0F)
|
||||
{
|
||||
if (bits & 0x0F0F0F0F) {
|
||||
bits &= 0x0F0F0F0F;
|
||||
i -= 4;
|
||||
}
|
||||
if (bits & 0x33333333)
|
||||
{
|
||||
if (bits & 0x33333333) {
|
||||
bits &= 0x33333333;
|
||||
i -= 2;
|
||||
}
|
||||
if (bits & 0x55555555)
|
||||
{
|
||||
if (bits & 0x55555555) {
|
||||
bits &= 0x55555555;
|
||||
i -= 1;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
#endif
|
||||
|
||||
/*! \brief Bit reverse a byte.
|
||||
|
@ -147,7 +131,8 @@ static __inline__ uint8_t bit_reverse8(uint8_t x)
|
|||
{
|
||||
#if defined(__i386__) || defined(__x86_64__)
|
||||
/* If multiply is fast */
|
||||
return ((x*0x0802U & 0x22110U) | (x*0x8020U & 0x88440U))*0x10101U >> 16;
|
||||
return ((x * 0x0802U & 0x22110U) | (x * 0x8020U & 0x88440U)) *
|
||||
0x10101U >> 16;
|
||||
#else
|
||||
/* If multiply is slow, but we have a barrel shifter */
|
||||
x = (x >> 4) | (x << 4);
|
||||
|
@ -155,7 +140,6 @@ static __inline__ uint8_t bit_reverse8(uint8_t x)
|
|||
return ((x & 0xAA) >> 1) | ((x & 0x55) << 1);
|
||||
#endif
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
/*! \brief Bit reverse a 16 bit word.
|
||||
\param data The word to be reversed.
|
||||
|
@ -195,7 +179,6 @@ static __inline__ uint32_t least_significant_one32(uint32_t x)
|
|||
{
|
||||
return (x & (-(int32_t) x));
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
/*! \brief Find the most significant one in a word, and return a word
|
||||
with just that bit set.
|
||||
|
@ -210,7 +193,6 @@ static __inline__ uint32_t most_significant_one32(uint32_t x)
|
|||
return (x ^ (x >> 1));
|
||||
#endif
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
/*! \brief Find the parity of a byte.
|
||||
\param x The byte to be checked.
|
||||
|
@ -220,7 +202,6 @@ static __inline__ int parity8(uint8_t x)
|
|||
x = (x ^ (x >> 4)) & 0x0F;
|
||||
return (0x6996 >> x) & 1;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
/*! \brief Find the parity of a 16 bit word.
|
||||
\param x The word to be checked.
|
||||
|
@ -231,7 +212,6 @@ static __inline__ int parity16(uint16_t x)
|
|||
x = (x ^ (x >> 4)) & 0x0F;
|
||||
return (0x6996 >> x) & 1;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
/*! \brief Find the parity of a 32 bit word.
|
||||
\param x The word to be checked.
|
||||
|
@ -243,11 +223,6 @@ static __inline__ int parity32(uint32_t x)
|
|||
x = (x ^ (x >> 4)) & 0x0F;
|
||||
return (0x6996 >> x) & 1;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
/*- End of file ------------------------------------------------------------*/
|
||||
|
|
|
@ -74,7 +74,6 @@
|
|||
|
||||
Steve also has some nice notes on echo cancellers in echo.h
|
||||
|
||||
|
||||
References:
|
||||
|
||||
[1] Ochiai, Areseki, and Ogihara, "Echo Canceller with Two Echo
|
||||
|
@ -109,8 +108,6 @@
|
|||
#include <linux/module.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/slab.h>
|
||||
#define malloc(a) kmalloc((a), GFP_KERNEL)
|
||||
#define free(a) kfree(a)
|
||||
|
||||
#include "bit_operations.h"
|
||||
#include "echo.h"
|
||||
|
@ -126,9 +123,9 @@
|
|||
|
||||
/* adapting coeffs using the traditional stochastic descent (N)LMS algorithm */
|
||||
|
||||
|
||||
#ifdef __BLACKFIN_ASM__
|
||||
static void __inline__ lms_adapt_bg(echo_can_state_t *ec, int clean, int shift)
|
||||
#ifdef __bfin__
|
||||
static void __inline__ lms_adapt_bg(struct oslec_state *ec, int clean,
|
||||
int shift)
|
||||
{
|
||||
int i, j;
|
||||
int offset1;
|
||||
|
@ -153,8 +150,7 @@ static void __inline__ lms_adapt_bg(echo_can_state_t *ec, int clean, int shift)
|
|||
|
||||
//asm("st:");
|
||||
n = ec->taps;
|
||||
for (i = 0, j = offset2; i < n; i++, j++)
|
||||
{
|
||||
for (i = 0, j = offset2; i < n; i++, j++) {
|
||||
exp = *phist++ * factor;
|
||||
ec->fir_taps16[1][i] += (int16_t) ((exp + (1 << 14)) >> 15);
|
||||
}
|
||||
|
@ -200,7 +196,8 @@ static void __inline__ lms_adapt_bg(echo_can_state_t *ec, int clean, int shift)
|
|||
*/
|
||||
|
||||
#else
|
||||
static __inline__ void lms_adapt_bg(echo_can_state_t *ec, int clean, int shift)
|
||||
static __inline__ void lms_adapt_bg(struct oslec_state *ec, int clean,
|
||||
int shift)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
@ -219,64 +216,50 @@ static __inline__ void lms_adapt_bg(echo_can_state_t *ec, int clean, int shift)
|
|||
offset2 = ec->curr_pos;
|
||||
offset1 = ec->taps - offset2;
|
||||
|
||||
for (i = ec->taps - 1; i >= offset1; i--)
|
||||
{
|
||||
for (i = ec->taps - 1; i >= offset1; i--) {
|
||||
exp = (ec->fir_state_bg.history[i - offset1] * factor);
|
||||
ec->fir_taps16[1][i] += (int16_t) ((exp + (1 << 14)) >> 15);
|
||||
}
|
||||
for ( ; i >= 0; i--)
|
||||
{
|
||||
for (; i >= 0; i--) {
|
||||
exp = (ec->fir_state_bg.history[i + offset2] * factor);
|
||||
ec->fir_taps16[1][i] += (int16_t) ((exp + (1 << 14)) >> 15);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
echo_can_state_t *echo_can_create(int len, int adaption_mode)
|
||||
struct oslec_state *oslec_create(int len, int adaption_mode)
|
||||
{
|
||||
echo_can_state_t *ec;
|
||||
struct oslec_state *ec;
|
||||
int i;
|
||||
int j;
|
||||
|
||||
ec = kmalloc(sizeof(*ec), GFP_KERNEL);
|
||||
if (ec == NULL)
|
||||
ec = kzalloc(sizeof(*ec), GFP_KERNEL);
|
||||
if (!ec)
|
||||
return NULL;
|
||||
memset(ec, 0, sizeof(*ec));
|
||||
|
||||
ec->taps = len;
|
||||
ec->log2taps = top_bit(len);
|
||||
ec->curr_pos = ec->taps - 1;
|
||||
|
||||
for (i = 0; i < 2; i++)
|
||||
{
|
||||
if ((ec->fir_taps16[i] = (int16_t *) malloc((ec->taps)*sizeof(int16_t))) == NULL)
|
||||
{
|
||||
for (j = 0; j < i; j++)
|
||||
kfree(ec->fir_taps16[j]);
|
||||
kfree(ec);
|
||||
return NULL;
|
||||
}
|
||||
memset(ec->fir_taps16[i], 0, (ec->taps)*sizeof(int16_t));
|
||||
for (i = 0; i < 2; i++) {
|
||||
ec->fir_taps16[i] =
|
||||
kcalloc(ec->taps, sizeof(int16_t), GFP_KERNEL);
|
||||
if (!ec->fir_taps16[i])
|
||||
goto error_oom;
|
||||
}
|
||||
|
||||
fir16_create(&ec->fir_state,
|
||||
ec->fir_taps16[0],
|
||||
ec->taps);
|
||||
fir16_create(&ec->fir_state_bg,
|
||||
ec->fir_taps16[1],
|
||||
ec->taps);
|
||||
fir16_create(&ec->fir_state, ec->fir_taps16[0], ec->taps);
|
||||
fir16_create(&ec->fir_state_bg, ec->fir_taps16[1], ec->taps);
|
||||
|
||||
for (i = 0; i < 5; i++) {
|
||||
ec->xvtx[i] = ec->yvtx[i] = ec->xvrx[i] = ec->yvrx[i] = 0;
|
||||
}
|
||||
|
||||
ec->cng_level = 1000;
|
||||
echo_can_adaption_mode(ec, adaption_mode);
|
||||
oslec_adaption_mode(ec, adaption_mode);
|
||||
|
||||
ec->snapshot = (int16_t*)malloc(ec->taps*sizeof(int16_t));
|
||||
memset(ec->snapshot, 0, sizeof(int16_t)*ec->taps);
|
||||
ec->snapshot = kcalloc(ec->taps, sizeof(int16_t), GFP_KERNEL);
|
||||
if (!ec->snapshot)
|
||||
goto error_oom;
|
||||
|
||||
ec->cond_met = 0;
|
||||
ec->Pstates = 0;
|
||||
|
@ -288,10 +271,18 @@ echo_can_state_t *echo_can_create(int len, int adaption_mode)
|
|||
ec->Lbgn_upper_acc = ec->Lbgn_upper << 13;
|
||||
|
||||
return ec;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
void echo_can_free(echo_can_state_t *ec)
|
||||
error_oom:
|
||||
for (i = 0; i < 2; i++)
|
||||
kfree(ec->fir_taps16[i]);
|
||||
|
||||
kfree(ec);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL_GPL(oslec_create);
|
||||
|
||||
void oslec_free(struct oslec_state *ec)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
@ -302,15 +293,17 @@ void echo_can_free(echo_can_state_t *ec)
|
|||
kfree(ec->snapshot);
|
||||
kfree(ec);
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
void echo_can_adaption_mode(echo_can_state_t *ec, int adaption_mode)
|
||||
EXPORT_SYMBOL_GPL(oslec_free);
|
||||
|
||||
void oslec_adaption_mode(struct oslec_state *ec, int adaption_mode)
|
||||
{
|
||||
ec->adaption_mode = adaption_mode;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
void echo_can_flush(echo_can_state_t *ec)
|
||||
EXPORT_SYMBOL_GPL(oslec_adaption_mode);
|
||||
|
||||
void oslec_flush(struct oslec_state *ec)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
@ -334,16 +327,19 @@ void echo_can_flush(echo_can_state_t *ec)
|
|||
ec->curr_pos = ec->taps - 1;
|
||||
ec->Pstates = 0;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
void echo_can_snapshot(echo_can_state_t *ec) {
|
||||
EXPORT_SYMBOL_GPL(oslec_flush);
|
||||
|
||||
void oslec_snapshot(struct oslec_state *ec)
|
||||
{
|
||||
memcpy(ec->snapshot, ec->fir_taps16[0], ec->taps * sizeof(int16_t));
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
EXPORT_SYMBOL_GPL(oslec_snapshot);
|
||||
|
||||
/* Dual Path Echo Canceller ------------------------------------------------*/
|
||||
|
||||
int16_t echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx)
|
||||
int16_t oslec_update(struct oslec_state *ec, int16_t tx, int16_t rx)
|
||||
{
|
||||
int32_t echo_value;
|
||||
int clean_bg;
|
||||
|
@ -353,7 +349,8 @@ int16_t echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx)
|
|||
starts clipping. Another possible way to handle this would be the
|
||||
filter coefficent scaling. */
|
||||
|
||||
ec->tx = tx; ec->rx = rx;
|
||||
ec->tx = tx;
|
||||
ec->rx = rx;
|
||||
tx >>= 1;
|
||||
rx >>= 1;
|
||||
|
||||
|
@ -386,8 +383,10 @@ int16_t echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx)
|
|||
/* hard limit filter to prevent clipping. Note that at this stage
|
||||
rx should be limited to +/- 16383 due to right shift above */
|
||||
tmp1 = ec->rx_1 >> 15;
|
||||
if (tmp1 > 16383) tmp1 = 16383;
|
||||
if (tmp1 < -16383) tmp1 = -16383;
|
||||
if (tmp1 > 16383)
|
||||
tmp1 = 16383;
|
||||
if (tmp1 < -16383)
|
||||
tmp1 = -16383;
|
||||
rx = tmp1;
|
||||
ec->rx_2 = tmp;
|
||||
}
|
||||
|
@ -404,8 +403,10 @@ int16_t echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx)
|
|||
new = (int)tx *(int)tx;
|
||||
old = (int)ec->fir_state.history[ec->fir_state.curr_pos] *
|
||||
(int)ec->fir_state.history[ec->fir_state.curr_pos];
|
||||
ec->Pstates += ((new - old) + (1<<ec->log2taps)) >> ec->log2taps;
|
||||
if (ec->Pstates < 0) ec->Pstates = 0;
|
||||
ec->Pstates +=
|
||||
((new - old) + (1 << ec->log2taps)) >> ec->log2taps;
|
||||
if (ec->Pstates < 0)
|
||||
ec->Pstates = 0;
|
||||
}
|
||||
|
||||
/* Calculate short term average levels using simple single pole IIRs */
|
||||
|
@ -498,34 +499,31 @@ int16_t echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx)
|
|||
|
||||
if ((ec->adaption_mode & ECHO_CAN_USE_ADAPTION) &&
|
||||
(ec->nonupdate_dwell == 0) &&
|
||||
(8*ec->Lclean_bg < 7*ec->Lclean) /* (ec->Lclean_bg < 0.875*ec->Lclean) */ &&
|
||||
(8*ec->Lclean_bg < ec->Ltx) /* (ec->Lclean_bg < 0.125*ec->Ltx) */ )
|
||||
{
|
||||
(8 * ec->Lclean_bg <
|
||||
7 * ec->Lclean) /* (ec->Lclean_bg < 0.875*ec->Lclean) */ &&
|
||||
(8 * ec->Lclean_bg <
|
||||
ec->Ltx) /* (ec->Lclean_bg < 0.125*ec->Ltx) */ ) {
|
||||
if (ec->cond_met == 6) {
|
||||
/* BG filter has had better results for 6 consecutive samples */
|
||||
ec->adapt = 1;
|
||||
memcpy(ec->fir_taps16[0], ec->fir_taps16[1], ec->taps*sizeof(int16_t));
|
||||
}
|
||||
else
|
||||
memcpy(ec->fir_taps16[0], ec->fir_taps16[1],
|
||||
ec->taps * sizeof(int16_t));
|
||||
} else
|
||||
ec->cond_met++;
|
||||
}
|
||||
else
|
||||
} else
|
||||
ec->cond_met = 0;
|
||||
|
||||
/* Non-Linear Processing --------------------------------------------------- */
|
||||
|
||||
ec->clean_nlp = ec->clean;
|
||||
if (ec->adaption_mode & ECHO_CAN_USE_NLP)
|
||||
{
|
||||
if (ec->adaption_mode & ECHO_CAN_USE_NLP) {
|
||||
/* Non-linear processor - a fancy way to say "zap small signals, to avoid
|
||||
residual echo due to (uLaw/ALaw) non-linearity in the channel.". */
|
||||
|
||||
if ((16*ec->Lclean < ec->Ltx))
|
||||
{
|
||||
if ((16 * ec->Lclean < ec->Ltx)) {
|
||||
/* Our e/c has improved echo by at least 24 dB (each factor of 2 is 6dB,
|
||||
so 2*2*2*2=16 is the same as 6+6+6+6=24dB) */
|
||||
if (ec->adaption_mode & ECHO_CAN_USE_CNG)
|
||||
{
|
||||
if (ec->adaption_mode & ECHO_CAN_USE_CNG) {
|
||||
ec->cng_level = ec->Lbgn;
|
||||
|
||||
/* Very elementary comfort noise generation. Just random
|
||||
|
@ -536,27 +534,26 @@ int16_t echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx)
|
|||
high level or look at spectrum.
|
||||
*/
|
||||
|
||||
ec->cng_rndnum = 1664525U*ec->cng_rndnum + 1013904223U;
|
||||
ec->cng_filter = ((ec->cng_rndnum & 0xFFFF) - 32768 + 5*ec->cng_filter) >> 3;
|
||||
ec->clean_nlp = (ec->cng_filter*ec->cng_level*8) >> 14;
|
||||
ec->cng_rndnum =
|
||||
1664525U * ec->cng_rndnum + 1013904223U;
|
||||
ec->cng_filter =
|
||||
((ec->cng_rndnum & 0xFFFF) - 32768 +
|
||||
5 * ec->cng_filter) >> 3;
|
||||
ec->clean_nlp =
|
||||
(ec->cng_filter * ec->cng_level * 8) >> 14;
|
||||
|
||||
}
|
||||
else if (ec->adaption_mode & ECHO_CAN_USE_CLIP)
|
||||
{
|
||||
} else if (ec->adaption_mode & ECHO_CAN_USE_CLIP) {
|
||||
/* This sounds much better than CNG */
|
||||
if (ec->clean_nlp > ec->Lbgn)
|
||||
ec->clean_nlp = ec->Lbgn;
|
||||
if (ec->clean_nlp < -ec->Lbgn)
|
||||
ec->clean_nlp = -ec->Lbgn;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
/* just mute the residual, doesn't sound very good, used mainly
|
||||
in G168 tests */
|
||||
ec->clean_nlp = 0;
|
||||
}
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
/* Background noise estimator. I tried a few algorithms
|
||||
here without much luck. This very simple one seems to
|
||||
work best, we just average the level using a slow (1 sec
|
||||
|
@ -585,7 +582,7 @@ int16_t echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx)
|
|||
return (int16_t) ec->clean_nlp << 1;
|
||||
}
|
||||
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
EXPORT_SYMBOL_GPL(oslec_update);
|
||||
|
||||
/* This function is seperated from the echo canceller is it is usually called
|
||||
as part of the tx process. See rx HP (DC blocking) filter above, it's
|
||||
|
@ -608,7 +605,8 @@ int16_t echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx)
|
|||
precision, which noise shapes things, giving very clean DC removal.
|
||||
*/
|
||||
|
||||
int16_t echo_can_hpf_tx(echo_can_state_t *ec, int16_t tx) {
|
||||
int16_t oslec_hpf_tx(struct oslec_state * ec, int16_t tx)
|
||||
{
|
||||
int tmp, tmp1;
|
||||
|
||||
if (ec->adaption_mode & ECHO_CAN_USE_TX_HPF) {
|
||||
|
@ -622,11 +620,20 @@ int16_t echo_can_hpf_tx(echo_can_state_t *ec, int16_t tx) {
|
|||
#endif
|
||||
ec->tx_1 += -(ec->tx_1 >> DC_LOG2BETA) + tmp - ec->tx_2;
|
||||
tmp1 = ec->tx_1 >> 15;
|
||||
if (tmp1 > 32767) tmp1 = 32767;
|
||||
if (tmp1 < -32767) tmp1 = -32767;
|
||||
if (tmp1 > 32767)
|
||||
tmp1 = 32767;
|
||||
if (tmp1 < -32767)
|
||||
tmp1 = -32767;
|
||||
tx = tmp1;
|
||||
ec->tx_2 = tmp;
|
||||
}
|
||||
|
||||
return tx;
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL_GPL(oslec_hpf_tx);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_AUTHOR("David Rowe");
|
||||
MODULE_DESCRIPTION("Open Source Line Echo Canceller");
|
||||
MODULE_VERSION("0.3.0");
|
||||
|
|
|
@ -118,22 +118,13 @@ a minor burden.
|
|||
*/
|
||||
|
||||
#include "fir.h"
|
||||
|
||||
/* Mask bits for the adaption mode */
|
||||
#define ECHO_CAN_USE_ADAPTION 0x01
|
||||
#define ECHO_CAN_USE_NLP 0x02
|
||||
#define ECHO_CAN_USE_CNG 0x04
|
||||
#define ECHO_CAN_USE_CLIP 0x08
|
||||
#define ECHO_CAN_USE_TX_HPF 0x10
|
||||
#define ECHO_CAN_USE_RX_HPF 0x20
|
||||
#define ECHO_CAN_DISABLE 0x40
|
||||
#include "oslec.h"
|
||||
|
||||
/*!
|
||||
G.168 echo canceller descriptor. This defines the working state for a line
|
||||
echo canceller.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
struct oslec_state {
|
||||
int16_t tx, rx;
|
||||
int16_t clean;
|
||||
int16_t clean_nlp;
|
||||
|
@ -176,45 +167,6 @@ typedef struct
|
|||
|
||||
/* snapshot sample of coeffs used for development */
|
||||
int16_t *snapshot;
|
||||
} echo_can_state_t;
|
||||
|
||||
/*! Create a voice echo canceller context.
|
||||
\param len The length of the canceller, in samples.
|
||||
\return The new canceller context, or NULL if the canceller could not be created.
|
||||
*/
|
||||
echo_can_state_t *echo_can_create(int len, int adaption_mode);
|
||||
|
||||
/*! Free a voice echo canceller context.
|
||||
\param ec The echo canceller context.
|
||||
*/
|
||||
void echo_can_free(echo_can_state_t *ec);
|
||||
|
||||
/*! Flush (reinitialise) a voice echo canceller context.
|
||||
\param ec The echo canceller context.
|
||||
*/
|
||||
void echo_can_flush(echo_can_state_t *ec);
|
||||
|
||||
/*! Set the adaption mode of a voice echo canceller context.
|
||||
\param ec The echo canceller context.
|
||||
\param adapt The mode.
|
||||
*/
|
||||
void echo_can_adaption_mode(echo_can_state_t *ec, int adaption_mode);
|
||||
|
||||
void echo_can_snapshot(echo_can_state_t *ec);
|
||||
|
||||
/*! Process a sample through a voice echo canceller.
|
||||
\param ec The echo canceller context.
|
||||
\param tx The transmitted audio sample.
|
||||
\param rx The received audio sample.
|
||||
\return The clean (echo cancelled) received sample.
|
||||
*/
|
||||
int16_t echo_can_update(echo_can_state_t *ec, int16_t tx, int16_t rx);
|
||||
|
||||
/*! Process to high pass filter the tx signal.
|
||||
\param ec The echo canceller context.
|
||||
\param tx The transmitted auio sample.
|
||||
\return The HP filtered transmit sample, send this to your D/A.
|
||||
*/
|
||||
int16_t echo_can_hpf_tx(echo_can_state_t *ec, int16_t tx);
|
||||
};
|
||||
|
||||
#endif /* __ECHO_H */
|
||||
|
|
|
@ -72,8 +72,7 @@
|
|||
16 bit integer FIR descriptor. This defines the working state for a single
|
||||
instance of an FIR filter using 16 bit integer coefficients.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
typedef struct {
|
||||
int taps;
|
||||
int curr_pos;
|
||||
const int16_t *coeffs;
|
||||
|
@ -85,8 +84,7 @@ typedef struct
|
|||
instance of an FIR filter using 32 bit integer coefficients, and filtering
|
||||
16 bit integer data.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
typedef struct {
|
||||
int taps;
|
||||
int curr_pos;
|
||||
const int32_t *coeffs;
|
||||
|
@ -97,62 +95,49 @@ typedef struct
|
|||
Floating point FIR descriptor. This defines the working state for a single
|
||||
instance of an FIR filter using floating point coefficients and data.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
typedef struct {
|
||||
int taps;
|
||||
int curr_pos;
|
||||
const float *coeffs;
|
||||
float *history;
|
||||
} fir_float_state_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
static __inline__ const int16_t *fir16_create(fir16_state_t * fir,
|
||||
const int16_t *coeffs,
|
||||
int taps)
|
||||
const int16_t * coeffs, int taps)
|
||||
{
|
||||
fir->taps = taps;
|
||||
fir->curr_pos = taps - 1;
|
||||
fir->coeffs = coeffs;
|
||||
#if defined(USE_MMX) || defined(USE_SSE2) || defined(__BLACKFIN_ASM__)
|
||||
if ((fir->history = malloc(2*taps*sizeof(int16_t))))
|
||||
memset(fir->history, 0, 2*taps*sizeof(int16_t));
|
||||
#if defined(USE_MMX) || defined(USE_SSE2) || defined(__bfin__)
|
||||
fir->history = kcalloc(2 * taps, sizeof(int16_t), GFP_KERNEL);
|
||||
#else
|
||||
if ((fir->history = (int16_t *) malloc(taps*sizeof(int16_t))))
|
||||
memset(fir->history, 0, taps*sizeof(int16_t));
|
||||
fir->history = kcalloc(taps, sizeof(int16_t), GFP_KERNEL);
|
||||
#endif
|
||||
return fir->history;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
static __inline__ void fir16_flush(fir16_state_t * fir)
|
||||
{
|
||||
#if defined(USE_MMX) || defined(USE_SSE2) || defined(__BLACKFIN_ASM__)
|
||||
#if defined(USE_MMX) || defined(USE_SSE2) || defined(__bfin__)
|
||||
memset(fir->history, 0, 2 * fir->taps * sizeof(int16_t));
|
||||
#else
|
||||
memset(fir->history, 0, fir->taps * sizeof(int16_t));
|
||||
#endif
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
static __inline__ void fir16_free(fir16_state_t * fir)
|
||||
{
|
||||
free(fir->history);
|
||||
kfree(fir->history);
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
#ifdef __BLACKFIN_ASM__
|
||||
#ifdef __bfin__
|
||||
static inline int32_t dot_asm(short *x, short *y, int len)
|
||||
{
|
||||
int dot;
|
||||
|
||||
len--;
|
||||
|
||||
__asm__
|
||||
(
|
||||
"I0 = %1;\n\t"
|
||||
__asm__("I0 = %1;\n\t"
|
||||
"I1 = %2;\n\t"
|
||||
"A0 = 0;\n\t"
|
||||
"R0.L = W[I0++] || R1.L = W[I1++];\n\t"
|
||||
|
@ -171,7 +156,6 @@ static inline int32_t dot_asm(short *x, short *y, int len)
|
|||
return dot;
|
||||
}
|
||||
#endif
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
static __inline__ int16_t fir16(fir16_state_t * fir, int16_t sample)
|
||||
{
|
||||
|
@ -189,8 +173,7 @@ static __inline__ int16_t fir16(fir16_state_t *fir, int16_t sample)
|
|||
i = fir->taps;
|
||||
pxor_r2r(mm4, mm4);
|
||||
/* 8 samples per iteration, so the filter must be a multiple of 8 long. */
|
||||
while (i > 0)
|
||||
{
|
||||
while (i > 0) {
|
||||
movq_m2r(mmx_coeffs[0], mm0);
|
||||
movq_m2r(mmx_coeffs[1], mm2);
|
||||
movq_m2r(mmx_hist[0], mm1);
|
||||
|
@ -221,8 +204,7 @@ static __inline__ int16_t fir16(fir16_state_t *fir, int16_t sample)
|
|||
i = fir->taps;
|
||||
pxor_r2r(xmm4, xmm4);
|
||||
/* 16 samples per iteration, so the filter must be a multiple of 16 long. */
|
||||
while (i > 0)
|
||||
{
|
||||
while (i > 0) {
|
||||
movdqu_m2r(xmm_coeffs[0], xmm0);
|
||||
movdqu_m2r(xmm_coeffs[1], xmm2);
|
||||
movdqu_m2r(xmm_hist[0], xmm1);
|
||||
|
@ -242,10 +224,11 @@ static __inline__ int16_t fir16(fir16_state_t *fir, int16_t sample)
|
|||
psrldq_i2r(4, xmm0);
|
||||
paddd_r2r(xmm0, xmm4);
|
||||
movd_r2m(xmm4, y);
|
||||
#elif defined(__BLACKFIN_ASM__)
|
||||
#elif defined(__bfin__)
|
||||
fir->history[fir->curr_pos] = sample;
|
||||
fir->history[fir->curr_pos + fir->taps] = sample;
|
||||
y = dot_asm((int16_t*)fir->coeffs, &fir->history[fir->curr_pos], fir->taps);
|
||||
y = dot_asm((int16_t *) fir->coeffs, &fir->history[fir->curr_pos],
|
||||
fir->taps);
|
||||
#else
|
||||
int i;
|
||||
int offset1;
|
||||
|
@ -266,33 +249,26 @@ static __inline__ int16_t fir16(fir16_state_t *fir, int16_t sample)
|
|||
fir->curr_pos--;
|
||||
return (int16_t) (y >> 15);
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
static __inline__ const int16_t *fir32_create(fir32_state_t * fir,
|
||||
const int32_t *coeffs,
|
||||
int taps)
|
||||
const int32_t * coeffs, int taps)
|
||||
{
|
||||
fir->taps = taps;
|
||||
fir->curr_pos = taps - 1;
|
||||
fir->coeffs = coeffs;
|
||||
fir->history = (int16_t *) malloc(taps*sizeof(int16_t));
|
||||
if (fir->history)
|
||||
memset(fir->history, '\0', taps*sizeof(int16_t));
|
||||
fir->history = kcalloc(taps, sizeof(int16_t), GFP_KERNEL);
|
||||
return fir->history;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
static __inline__ void fir32_flush(fir32_state_t * fir)
|
||||
{
|
||||
memset(fir->history, 0, fir->taps * sizeof(int16_t));
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
static __inline__ void fir32_free(fir32_state_t * fir)
|
||||
{
|
||||
free(fir->history);
|
||||
kfree(fir->history);
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
static __inline__ int16_t fir32(fir32_state_t * fir, int16_t sample)
|
||||
{
|
||||
|
@ -314,56 +290,6 @@ static __inline__ int16_t fir32(fir32_state_t *fir, int16_t sample)
|
|||
fir->curr_pos--;
|
||||
return (int16_t) (y >> 15);
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
#ifndef __KERNEL__
|
||||
static __inline__ const float *fir_float_create(fir_float_state_t *fir,
|
||||
const float *coeffs,
|
||||
int taps)
|
||||
{
|
||||
fir->taps = taps;
|
||||
fir->curr_pos = taps - 1;
|
||||
fir->coeffs = coeffs;
|
||||
fir->history = (float *) malloc(taps*sizeof(float));
|
||||
if (fir->history)
|
||||
memset(fir->history, '\0', taps*sizeof(float));
|
||||
return fir->history;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
static __inline__ void fir_float_free(fir_float_state_t *fir)
|
||||
{
|
||||
free(fir->history);
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
|
||||
static __inline__ int16_t fir_float(fir_float_state_t *fir, int16_t sample)
|
||||
{
|
||||
int i;
|
||||
float y;
|
||||
int offset1;
|
||||
int offset2;
|
||||
|
||||
fir->history[fir->curr_pos] = sample;
|
||||
|
||||
offset2 = fir->curr_pos;
|
||||
offset1 = fir->taps - offset2;
|
||||
y = 0;
|
||||
for (i = fir->taps - 1; i >= offset1; i--)
|
||||
y += fir->coeffs[i]*fir->history[i - offset1];
|
||||
for ( ; i >= 0; i--)
|
||||
y += fir->coeffs[i]*fir->history[i + offset2];
|
||||
if (fir->curr_pos <= 0)
|
||||
fir->curr_pos = fir->taps;
|
||||
fir->curr_pos--;
|
||||
return (int16_t) y;
|
||||
}
|
||||
/*- End of function --------------------------------------------------------*/
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
/*- End of file ------------------------------------------------------------*/
|
||||
|
|
|
@ -44,7 +44,6 @@ typedef union {
|
|||
char b[16];
|
||||
} xmm_t;
|
||||
|
||||
|
||||
#define mmx_i2r(op,imm,reg) \
|
||||
__asm__ __volatile__ (#op " %0, %%" #reg \
|
||||
: /* nothing */ \
|
||||
|
@ -63,7 +62,6 @@ typedef union {
|
|||
#define mmx_r2r(op,regs,regd) \
|
||||
__asm__ __volatile__ (#op " %" #regs ", %" #regd)
|
||||
|
||||
|
||||
#define emms() __asm__ __volatile__ ("emms")
|
||||
|
||||
#define movd_m2r(var,reg) mmx_m2r (movd, var, reg)
|
||||
|
@ -192,16 +190,13 @@ typedef union {
|
|||
#define pxor_m2r(var,reg) mmx_m2r (pxor, var, reg)
|
||||
#define pxor_r2r(regs,regd) mmx_r2r (pxor, regs, regd)
|
||||
|
||||
|
||||
/* 3DNOW extensions */
|
||||
|
||||
#define pavgusb_m2r(var,reg) mmx_m2r (pavgusb, var, reg)
|
||||
#define pavgusb_r2r(regs,regd) mmx_r2r (pavgusb, regs, regd)
|
||||
|
||||
|
||||
/* AMD MMX extensions - also available in intel SSE */
|
||||
|
||||
|
||||
#define mmx_m2ri(op,mem,reg,imm) \
|
||||
__asm__ __volatile__ (#op " %1, %0, %%" #reg \
|
||||
: /* nothing */ \
|
||||
|
@ -216,7 +211,6 @@ typedef union {
|
|||
: /* nothing */ \
|
||||
: "m" (mem))
|
||||
|
||||
|
||||
#define maskmovq(regs,maskreg) mmx_r2ri (maskmovq, regs, maskreg)
|
||||
|
||||
#define movntq_r2m(mmreg,var) mmx_r2m (movntq, mmreg, var)
|
||||
|
@ -284,5 +278,4 @@ typedef union {
|
|||
#define punpcklqdq_r2r(regs,regd) mmx_r2r (punpcklqdq, regs, regd)
|
||||
#define punpckhqdq_r2r(regs,regd) mmx_r2r (punpckhqdq, regs, regd)
|
||||
|
||||
|
||||
#endif /* AVCODEC_I386MMX_H */
|
||||
|
|
86
drivers/staging/echo/oslec.h
Normal file
86
drivers/staging/echo/oslec.h
Normal file
|
@ -0,0 +1,86 @@
|
|||
/*
|
||||
* OSLEC - A line echo canceller. This code is being developed
|
||||
* against and partially complies with G168. Using code from SpanDSP
|
||||
*
|
||||
* Written by Steve Underwood <steveu@coppice.org>
|
||||
* and David Rowe <david_at_rowetel_dot_com>
|
||||
*
|
||||
* Copyright (C) 2001 Steve Underwood and 2007-2008 David Rowe
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
* 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, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __OSLEC_H
|
||||
#define __OSLEC_H
|
||||
|
||||
/* TODO: document interface */
|
||||
|
||||
/* Mask bits for the adaption mode */
|
||||
#define ECHO_CAN_USE_ADAPTION 0x01
|
||||
#define ECHO_CAN_USE_NLP 0x02
|
||||
#define ECHO_CAN_USE_CNG 0x04
|
||||
#define ECHO_CAN_USE_CLIP 0x08
|
||||
#define ECHO_CAN_USE_TX_HPF 0x10
|
||||
#define ECHO_CAN_USE_RX_HPF 0x20
|
||||
#define ECHO_CAN_DISABLE 0x40
|
||||
|
||||
/*!
|
||||
G.168 echo canceller descriptor. This defines the working state for a line
|
||||
echo canceller.
|
||||
*/
|
||||
struct oslec_state;
|
||||
|
||||
/*! Create a voice echo canceller context.
|
||||
\param len The length of the canceller, in samples.
|
||||
\return The new canceller context, or NULL if the canceller could not be created.
|
||||
*/
|
||||
struct oslec_state *oslec_create(int len, int adaption_mode);
|
||||
|
||||
/*! Free a voice echo canceller context.
|
||||
\param ec The echo canceller context.
|
||||
*/
|
||||
void oslec_free(struct oslec_state *ec);
|
||||
|
||||
/*! Flush (reinitialise) a voice echo canceller context.
|
||||
\param ec The echo canceller context.
|
||||
*/
|
||||
void oslec_flush(struct oslec_state *ec);
|
||||
|
||||
/*! Set the adaption mode of a voice echo canceller context.
|
||||
\param ec The echo canceller context.
|
||||
\param adapt The mode.
|
||||
*/
|
||||
void oslec_adaption_mode(struct oslec_state *ec, int adaption_mode);
|
||||
|
||||
void oslec_snapshot(struct oslec_state *ec);
|
||||
|
||||
/*! Process a sample through a voice echo canceller.
|
||||
\param ec The echo canceller context.
|
||||
\param tx The transmitted audio sample.
|
||||
\param rx The received audio sample.
|
||||
\return The clean (echo cancelled) received sample.
|
||||
*/
|
||||
int16_t oslec_update(struct oslec_state *ec, int16_t tx, int16_t rx);
|
||||
|
||||
/*! Process to high pass filter the tx signal.
|
||||
\param ec The echo canceller context.
|
||||
\param tx The transmitted auio sample.
|
||||
\return The HP filtered transmit sample, send this to your D/A.
|
||||
*/
|
||||
int16_t oslec_hpf_tx(struct oslec_state *ec, int16_t tx);
|
||||
|
||||
#endif /* __OSLEC_H */
|
|
@ -84,7 +84,6 @@
|
|||
#include <linux/if_arp.h>
|
||||
#include <linux/ioport.h>
|
||||
#include <linux/random.h>
|
||||
#include <linux/delay.h>
|
||||
|
||||
#include "et1310_phy.h"
|
||||
#include "et1310_pm.h"
|
||||
|
@ -95,7 +94,6 @@
|
|||
#include "et131x_initpci.h"
|
||||
|
||||
#include "et1310_address_map.h"
|
||||
#include "et1310_jagcore.h"
|
||||
#include "et1310_tx.h"
|
||||
#include "et1310_rx.h"
|
||||
#include "et1310_mac.h"
|
||||
|
|
|
@ -97,7 +97,6 @@
|
|||
#include "et131x_isr.h"
|
||||
|
||||
#include "et1310_address_map.h"
|
||||
#include "et1310_jagcore.h"
|
||||
#include "et1310_tx.h"
|
||||
#include "et1310_rx.h"
|
||||
#include "et1310_mac.h"
|
||||
|
|
|
@ -97,7 +97,6 @@
|
|||
#include "et131x_isr.h"
|
||||
|
||||
#include "et1310_address_map.h"
|
||||
#include "et1310_jagcore.h"
|
||||
#include "et1310_tx.h"
|
||||
#include "et1310_rx.h"
|
||||
#include "et1310_mac.h"
|
||||
|
|
|
@ -16,7 +16,6 @@
|
|||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/sched.h>
|
||||
|
|
|
@ -26,7 +26,6 @@
|
|||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/time.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/device.h>
|
||||
|
|
|
@ -15,7 +15,6 @@
|
|||
* Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#include <linux/version.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/delay.h>
|
||||
|
|
|
@ -16,7 +16,6 @@
|
|||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/wait.h>
|
||||
|
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/moduleparam.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/spinlock.h>
|
||||
|
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/videodev2.h>
|
||||
|
||||
|
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/videodev2.h>
|
||||
#include <linux/ioctl.h>
|
||||
|
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/videodev2.h>
|
||||
#include <linux/ioctl.h>
|
||||
|
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/videodev2.h>
|
||||
#include <media/tuner.h>
|
||||
|
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/videodev2.h>
|
||||
#include <linux/ioctl.h>
|
||||
|
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/videodev2.h>
|
||||
#include <linux/ioctl.h>
|
||||
|
|
|
@ -17,7 +17,6 @@
|
|||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/version.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/videodev2.h>
|
||||
#include <media/tvaudio.h>
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -329,46 +329,46 @@
|
|||
Circular buffer used for analog input/output reads/writes.
|
||||
===========================================================================*/
|
||||
|
||||
typedef struct me4000_circ_buf {
|
||||
struct me4000_circ_buf {
|
||||
s16 *buf;
|
||||
int volatile head;
|
||||
int volatile tail;
|
||||
} me4000_circ_buf_t;
|
||||
};
|
||||
|
||||
/*=============================================================================
|
||||
Information about the hardware capabilities
|
||||
===========================================================================*/
|
||||
|
||||
typedef struct me4000_ao_info {
|
||||
struct me4000_ao_info {
|
||||
int count;
|
||||
int fifo_count;
|
||||
} me4000_ao_info_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_ai_info {
|
||||
struct me4000_ai_info {
|
||||
int count;
|
||||
int sh_count;
|
||||
int diff_count;
|
||||
int ex_trig_analog;
|
||||
} me4000_ai_info_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_dio_info {
|
||||
struct me4000_dio_info {
|
||||
int count;
|
||||
} me4000_dio_info_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_cnt_info {
|
||||
struct me4000_cnt_info {
|
||||
int count;
|
||||
} me4000_cnt_info_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_board {
|
||||
struct me4000_board {
|
||||
u16 vendor_id;
|
||||
u16 device_id;
|
||||
me4000_ao_info_t ao;
|
||||
me4000_ai_info_t ai;
|
||||
me4000_dio_info_t dio;
|
||||
me4000_cnt_info_t cnt;
|
||||
} me4000_board_t;
|
||||
struct me4000_ao_info ao;
|
||||
struct me4000_ai_info ai;
|
||||
struct me4000_dio_info dio;
|
||||
struct me4000_cnt_info cnt;
|
||||
};
|
||||
|
||||
static me4000_board_t me4000_boards[] = {
|
||||
static struct me4000_board me4000_boards[] = {
|
||||
{PCI_VENDOR_ID_MEILHAUS, 0x4610, {0, 0}, {16, 0, 0, 0}, {4}, {3}},
|
||||
|
||||
{PCI_VENDOR_ID_MEILHAUS, 0x4650, {0, 0}, {16, 0, 0, 0}, {4}, {0}},
|
||||
|
@ -391,8 +391,6 @@ static me4000_board_t me4000_boards[] = {
|
|||
{0},
|
||||
};
|
||||
|
||||
#define ME4000_BOARD_VERSIONS (sizeof(me4000_boards) / sizeof(me4000_board_t) - 1)
|
||||
|
||||
/*=============================================================================
|
||||
PCI device table.
|
||||
This is used by modprobe to translate PCI IDs to drivers.
|
||||
|
@ -427,19 +425,19 @@ MODULE_DEVICE_TABLE(pci, me4000_pci_table);
|
|||
Global board and subdevice information structures
|
||||
===========================================================================*/
|
||||
|
||||
typedef struct me4000_info {
|
||||
struct me4000_info {
|
||||
struct list_head list; // List of all detected boards
|
||||
int board_count; // Index of the board after detection
|
||||
|
||||
unsigned long plx_regbase; // PLX configuration space base address
|
||||
unsigned long me4000_regbase; // Base address of the ME4000
|
||||
unsigned long timer_regbase; // Base address of the timer circuit
|
||||
unsigned long program_regbase; // Base address to set the program pin for the xilinx
|
||||
resource_size_t me4000_regbase; // Base address of the ME4000
|
||||
resource_size_t timer_regbase; // Base address of the timer circuit
|
||||
resource_size_t program_regbase; // Base address to set the program pin for the xilinx
|
||||
|
||||
unsigned long plx_regbase_size; // PLX register set space
|
||||
unsigned long me4000_regbase_size; // ME4000 register set space
|
||||
unsigned long timer_regbase_size; // Timer circuit register set space
|
||||
unsigned long program_regbase_size; // Size of program base address of the ME4000
|
||||
resource_size_t me4000_regbase_size; // ME4000 register set space
|
||||
resource_size_t timer_regbase_size; // Timer circuit register set space
|
||||
resource_size_t program_regbase_size; // Size of program base address of the ME4000
|
||||
|
||||
unsigned int serial_no; // Serial number of the board
|
||||
unsigned char hw_revision; // Hardware revision of the board
|
||||
|
@ -451,7 +449,7 @@ typedef struct me4000_info {
|
|||
int pci_func_no; // PCI function number
|
||||
struct pci_dev *pci_dev_p; // General PCI information
|
||||
|
||||
me4000_board_t *board_p; // Holds the board capabilities
|
||||
struct me4000_board *board_p; // Holds the board capabilities
|
||||
|
||||
unsigned int irq; // IRQ assigned from the PCI BIOS
|
||||
unsigned int irq_count; // Count of external interrupts
|
||||
|
@ -464,18 +462,18 @@ typedef struct me4000_info {
|
|||
struct me4000_dio_context *dio_context; // Digital I/O specific context
|
||||
struct me4000_cnt_context *cnt_context; // Counter specific context
|
||||
struct me4000_ext_int_context *ext_int_context; // External interrupt specific context
|
||||
} me4000_info_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_ao_context {
|
||||
struct me4000_ao_context {
|
||||
struct list_head list; // linked list of me4000_ao_context_t
|
||||
int index; // Index in the list
|
||||
int mode; // Indicates mode (0 = single, 1 = wraparound, 2 = continous)
|
||||
int dac_in_use; // Indicates if already opend
|
||||
spinlock_t use_lock; // Guards in_use
|
||||
spinlock_t int_lock; // Used when locking out interrupts
|
||||
me4000_circ_buf_t circ_buf; // Circular buffer
|
||||
struct me4000_circ_buf circ_buf; // Circular buffer
|
||||
wait_queue_head_t wait_queue; // Wait queue to sleep while blocking write
|
||||
me4000_info_t *board_info;
|
||||
struct me4000_info *board_info;
|
||||
unsigned int irq; // The irq associated with this ADC
|
||||
int volatile pipe_flag; // Indicates broken pipe set from me4000_ao_isr()
|
||||
unsigned long ctrl_reg;
|
||||
|
@ -486,9 +484,9 @@ typedef struct me4000_ao_context {
|
|||
unsigned long irq_status_reg;
|
||||
unsigned long preload_reg;
|
||||
struct fasync_struct *fasync_p; // Queue for asynchronous notification
|
||||
} me4000_ao_context_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_ai_context {
|
||||
struct me4000_ai_context {
|
||||
struct list_head list; // linked list of me4000_ai_info_t
|
||||
int mode; // Indicates mode
|
||||
int in_use; // Indicates if already opend
|
||||
|
@ -496,9 +494,9 @@ typedef struct me4000_ai_context {
|
|||
spinlock_t int_lock; // Used when locking out interrupts
|
||||
int number; // Number of the DAC
|
||||
unsigned int irq; // The irq associated with this ADC
|
||||
me4000_circ_buf_t circ_buf; // Circular buffer
|
||||
struct me4000_circ_buf circ_buf; // Circular buffer
|
||||
wait_queue_head_t wait_queue; // Wait queue to sleep while blocking read
|
||||
me4000_info_t *board_info;
|
||||
struct me4000_info *board_info;
|
||||
|
||||
struct fasync_struct *fasync_p; // Queue for asynchronous notification
|
||||
|
||||
|
@ -523,48 +521,48 @@ typedef struct me4000_ai_context {
|
|||
unsigned long channel_list_count;
|
||||
unsigned long sample_counter;
|
||||
int sample_counter_reload;
|
||||
} me4000_ai_context_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_dio_context {
|
||||
struct me4000_dio_context {
|
||||
struct list_head list; // linked list of me4000_dio_context_t
|
||||
int in_use; // Indicates if already opend
|
||||
spinlock_t use_lock; // Guards in_use
|
||||
int number;
|
||||
int dio_count;
|
||||
me4000_info_t *board_info;
|
||||
struct me4000_info *board_info;
|
||||
unsigned long dir_reg;
|
||||
unsigned long ctrl_reg;
|
||||
unsigned long port_0_reg;
|
||||
unsigned long port_1_reg;
|
||||
unsigned long port_2_reg;
|
||||
unsigned long port_3_reg;
|
||||
} me4000_dio_context_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_cnt_context {
|
||||
struct me4000_cnt_context {
|
||||
struct list_head list; // linked list of me4000_dio_context_t
|
||||
int in_use; // Indicates if already opend
|
||||
spinlock_t use_lock; // Guards in_use
|
||||
int number;
|
||||
int cnt_count;
|
||||
me4000_info_t *board_info;
|
||||
struct me4000_info *board_info;
|
||||
unsigned long ctrl_reg;
|
||||
unsigned long counter_0_reg;
|
||||
unsigned long counter_1_reg;
|
||||
unsigned long counter_2_reg;
|
||||
} me4000_cnt_context_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_ext_int_context {
|
||||
struct me4000_ext_int_context {
|
||||
struct list_head list; // linked list of me4000_dio_context_t
|
||||
int in_use; // Indicates if already opend
|
||||
spinlock_t use_lock; // Guards in_use
|
||||
int number;
|
||||
me4000_info_t *board_info;
|
||||
struct me4000_info *board_info;
|
||||
unsigned int irq;
|
||||
unsigned long int_count;
|
||||
struct fasync_struct *fasync_ptr;
|
||||
unsigned long ctrl_reg;
|
||||
unsigned long irq_status_reg;
|
||||
} me4000_ext_int_context_t;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -745,12 +743,12 @@ typedef struct me4000_ext_int_context {
|
|||
General type definitions
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct me4000_user_info {
|
||||
struct me4000_user_info {
|
||||
int board_count; // Index of the board after detection
|
||||
unsigned long plx_regbase; // PLX configuration space base address
|
||||
unsigned long me4000_regbase; // Base address of the ME4000
|
||||
resource_size_t me4000_regbase; // Base address of the ME4000
|
||||
unsigned long plx_regbase_size; // PLX register set space
|
||||
unsigned long me4000_regbase_size; // ME4000 register set space
|
||||
resource_size_t me4000_regbase_size; // ME4000 register set space
|
||||
unsigned long serial_no; // Serial number of the board
|
||||
unsigned char hw_revision; // Hardware revision of the board
|
||||
unsigned short vendor_id; // Meilhaus vendor id (0x1402)
|
||||
|
@ -773,62 +771,62 @@ typedef struct me4000_user_info {
|
|||
int dio_count; // Count of digital I/O ports
|
||||
|
||||
int cnt_count; // Count of counters
|
||||
} me4000_user_info_t;
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Type definitions for analog output
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct me4000_ao_channel_list {
|
||||
struct me4000_ao_channel_list {
|
||||
unsigned long count;
|
||||
unsigned long *list;
|
||||
} me4000_ao_channel_list_t;
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Type definitions for analog input
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct me4000_ai_channel_list {
|
||||
struct me4000_ai_channel_list {
|
||||
unsigned long count;
|
||||
unsigned long *list;
|
||||
} me4000_ai_channel_list_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_ai_timer {
|
||||
struct me4000_ai_timer {
|
||||
unsigned long pre_chan;
|
||||
unsigned long chan;
|
||||
unsigned long scan_low;
|
||||
unsigned long scan_high;
|
||||
} me4000_ai_timer_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_ai_config {
|
||||
me4000_ai_timer_t timer;
|
||||
me4000_ai_channel_list_t channel_list;
|
||||
struct me4000_ai_config {
|
||||
struct me4000_ai_timer timer;
|
||||
struct me4000_ai_channel_list channel_list;
|
||||
int sh;
|
||||
} me4000_ai_config_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_ai_single {
|
||||
struct me4000_ai_single {
|
||||
int channel;
|
||||
int range;
|
||||
int mode;
|
||||
short value;
|
||||
unsigned long timeout;
|
||||
} me4000_ai_single_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_ai_trigger {
|
||||
struct me4000_ai_trigger {
|
||||
int mode;
|
||||
int edge;
|
||||
} me4000_ai_trigger_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_ai_sc {
|
||||
struct me4000_ai_sc {
|
||||
unsigned long value;
|
||||
int reload;
|
||||
} me4000_ai_sc_t;
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Type definitions for eeprom
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct me4000_eeprom {
|
||||
struct me4000_eeprom {
|
||||
unsigned long date;
|
||||
short uni_10_offset;
|
||||
short uni_10_fullscale;
|
||||
|
@ -842,45 +840,45 @@ typedef struct me4000_eeprom {
|
|||
short diff_10_fullscale;
|
||||
short diff_2_5_offset;
|
||||
short diff_2_5_fullscale;
|
||||
} me4000_eeprom_t;
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Type definitions for digital I/O
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct me4000_dio_config {
|
||||
struct me4000_dio_config {
|
||||
int port;
|
||||
int mode;
|
||||
int function;
|
||||
} me4000_dio_config_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_dio_byte {
|
||||
struct me4000_dio_byte {
|
||||
int port;
|
||||
unsigned char byte;
|
||||
} me4000_dio_byte_t;
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Type definitions for counters
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct me4000_cnt {
|
||||
struct me4000_cnt {
|
||||
int counter;
|
||||
unsigned short value;
|
||||
} me4000_cnt_t;
|
||||
};
|
||||
|
||||
typedef struct me4000_cnt_config {
|
||||
struct me4000_cnt_config {
|
||||
int counter;
|
||||
int mode;
|
||||
} me4000_cnt_config_t;
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
Type definitions for external interrupt
|
||||
----------------------------------------------------------------------------*/
|
||||
|
||||
typedef struct {
|
||||
struct me4000_int {
|
||||
int int1_count;
|
||||
int int2_count;
|
||||
} me4000_int_type;
|
||||
};
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
The ioctls of the board
|
||||
|
@ -888,7 +886,8 @@ typedef struct {
|
|||
|
||||
#define ME4000_IOCTL_MAXNR 50
|
||||
#define ME4000_MAGIC 'y'
|
||||
#define ME4000_GET_USER_INFO _IOR (ME4000_MAGIC, 0, me4000_user_info_t)
|
||||
#define ME4000_GET_USER_INFO _IOR (ME4000_MAGIC, 0, \
|
||||
struct me4000_user_info)
|
||||
|
||||
#define ME4000_AO_START _IOW (ME4000_MAGIC, 1, unsigned long)
|
||||
#define ME4000_AO_STOP _IO (ME4000_MAGIC, 2)
|
||||
|
@ -904,25 +903,35 @@ typedef struct {
|
|||
#define ME4000_AO_DISABLE_DO _IO (ME4000_MAGIC, 12)
|
||||
#define ME4000_AO_FSM_STATE _IOR (ME4000_MAGIC, 13, int)
|
||||
|
||||
#define ME4000_AI_SINGLE _IOR (ME4000_MAGIC, 14, me4000_ai_single_t)
|
||||
#define ME4000_AI_SINGLE _IOR (ME4000_MAGIC, 14, \
|
||||
struct me4000_ai_single)
|
||||
#define ME4000_AI_START _IOW (ME4000_MAGIC, 15, unsigned long)
|
||||
#define ME4000_AI_STOP _IO (ME4000_MAGIC, 16)
|
||||
#define ME4000_AI_IMMEDIATE_STOP _IO (ME4000_MAGIC, 17)
|
||||
#define ME4000_AI_EX_TRIG_ENABLE _IO (ME4000_MAGIC, 18)
|
||||
#define ME4000_AI_EX_TRIG_DISABLE _IO (ME4000_MAGIC, 19)
|
||||
#define ME4000_AI_EX_TRIG_SETUP _IOW (ME4000_MAGIC, 20, me4000_ai_trigger_t)
|
||||
#define ME4000_AI_CONFIG _IOW (ME4000_MAGIC, 21, me4000_ai_config_t)
|
||||
#define ME4000_AI_SC_SETUP _IOW (ME4000_MAGIC, 22, me4000_ai_sc_t)
|
||||
#define ME4000_AI_EX_TRIG_SETUP _IOW (ME4000_MAGIC, 20, \
|
||||
struct me4000_ai_trigger)
|
||||
#define ME4000_AI_CONFIG _IOW (ME4000_MAGIC, 21, \
|
||||
struct me4000_ai_config)
|
||||
#define ME4000_AI_SC_SETUP _IOW (ME4000_MAGIC, 22, \
|
||||
struct me4000_ai_sc)
|
||||
#define ME4000_AI_FSM_STATE _IOR (ME4000_MAGIC, 23, int)
|
||||
|
||||
#define ME4000_DIO_CONFIG _IOW (ME4000_MAGIC, 24, me4000_dio_config_t)
|
||||
#define ME4000_DIO_GET_BYTE _IOR (ME4000_MAGIC, 25, me4000_dio_byte_t)
|
||||
#define ME4000_DIO_SET_BYTE _IOW (ME4000_MAGIC, 26, me4000_dio_byte_t)
|
||||
#define ME4000_DIO_CONFIG _IOW (ME4000_MAGIC, 24, \
|
||||
struct me4000_dio_config)
|
||||
#define ME4000_DIO_GET_BYTE _IOR (ME4000_MAGIC, 25, \
|
||||
struct me4000_dio_byte)
|
||||
#define ME4000_DIO_SET_BYTE _IOW (ME4000_MAGIC, 26, \
|
||||
struct me4000_dio_byte)
|
||||
#define ME4000_DIO_RESET _IO (ME4000_MAGIC, 27)
|
||||
|
||||
#define ME4000_CNT_READ _IOR (ME4000_MAGIC, 28, me4000_cnt_t)
|
||||
#define ME4000_CNT_WRITE _IOW (ME4000_MAGIC, 29, me4000_cnt_t)
|
||||
#define ME4000_CNT_CONFIG _IOW (ME4000_MAGIC, 30, me4000_cnt_config_t)
|
||||
#define ME4000_CNT_READ _IOR (ME4000_MAGIC, 28, \
|
||||
struct me4000_cnt)
|
||||
#define ME4000_CNT_WRITE _IOW (ME4000_MAGIC, 29, \
|
||||
struct me4000_cnt)
|
||||
#define ME4000_CNT_CONFIG _IOW (ME4000_MAGIC, 30, \
|
||||
struct me4000_cnt_config)
|
||||
#define ME4000_CNT_RESET _IO (ME4000_MAGIC, 31)
|
||||
|
||||
#define ME4000_EXT_INT_DISABLE _IO (ME4000_MAGIC, 32)
|
||||
|
@ -934,13 +943,16 @@ typedef struct {
|
|||
#define ME4000_AI_FULLSCALE_ENABLE _IO (ME4000_MAGIC, 37)
|
||||
#define ME4000_AI_FULLSCALE_DISABLE _IO (ME4000_MAGIC, 38)
|
||||
|
||||
#define ME4000_AI_EEPROM_READ _IOR (ME4000_MAGIC, 39, me4000_eeprom_t)
|
||||
#define ME4000_AI_EEPROM_WRITE _IOW (ME4000_MAGIC, 40, me4000_eeprom_t)
|
||||
#define ME4000_AI_EEPROM_READ _IOR (ME4000_MAGIC, 39, \
|
||||
struct me4000_eeprom)
|
||||
#define ME4000_AI_EEPROM_WRITE _IOW (ME4000_MAGIC, 40, \
|
||||
struct me4000_eeprom)
|
||||
|
||||
#define ME4000_AO_SIMULTANEOUS_EX_TRIG _IO (ME4000_MAGIC, 41)
|
||||
#define ME4000_AO_SIMULTANEOUS_SW _IO (ME4000_MAGIC, 42)
|
||||
#define ME4000_AO_SIMULTANEOUS_DISABLE _IO (ME4000_MAGIC, 43)
|
||||
#define ME4000_AO_SIMULTANEOUS_UPDATE _IOW (ME4000_MAGIC, 44, me4000_ao_channel_list_t)
|
||||
#define ME4000_AO_SIMULTANEOUS_UPDATE _IOW (ME4000_MAGIC, 44, \
|
||||
struct me4000_ao_channel_list)
|
||||
|
||||
#define ME4000_AO_SYNCHRONOUS_EX_TRIG _IO (ME4000_MAGIC, 45)
|
||||
#define ME4000_AO_SYNCHRONOUS_SW _IO (ME4000_MAGIC, 46)
|
||||
|
|
11
drivers/staging/pcc-acpi/Kconfig
Normal file
11
drivers/staging/pcc-acpi/Kconfig
Normal file
|
@ -0,0 +1,11 @@
|
|||
config PCC_ACPI
|
||||
tristate "Panasonic ACPI Hotkey support"
|
||||
depends on ACPI
|
||||
default n
|
||||
---help---
|
||||
This driver provides support for Panasonic hotkeys through the
|
||||
ACPI interface. This works for the Panasonic R1 (N variant),
|
||||
R2, R3, T2, W2, and Y2 laptops.
|
||||
|
||||
To compile this driver as a module, choose M here. The module
|
||||
will be called pcc-acpi.
|
1
drivers/staging/pcc-acpi/Makefile
Normal file
1
drivers/staging/pcc-acpi/Makefile
Normal file
|
@ -0,0 +1 @@
|
|||
obj-$(CONFIG_PCC_ACPI) += pcc-acpi.o
|
7
drivers/staging/pcc-acpi/TODO
Normal file
7
drivers/staging/pcc-acpi/TODO
Normal file
|
@ -0,0 +1,7 @@
|
|||
TODO:
|
||||
- Lindent fixes
|
||||
- checkpatch.pl fixes
|
||||
- verify that the acpi interface is correct
|
||||
- remove /proc dependancy if needed (not sure yet.)
|
||||
|
||||
Please send any patches for this driver to Greg Kroah-Hartman <greg@kroah.com>
|
1111
drivers/staging/pcc-acpi/pcc-acpi.c
Normal file
1111
drivers/staging/pcc-acpi/pcc-acpi.c
Normal file
File diff suppressed because it is too large
Load diff
6
drivers/staging/poch/Kconfig
Normal file
6
drivers/staging/poch/Kconfig
Normal file
|
@ -0,0 +1,6 @@
|
|||
config POCH
|
||||
tristate "Redrapids Pocket Change CardBus support"
|
||||
depends on PCI && UIO
|
||||
default N
|
||||
---help---
|
||||
Enable support for Redrapids Pocket Change CardBus devices.
|
1
drivers/staging/poch/Makefile
Normal file
1
drivers/staging/poch/Makefile
Normal file
|
@ -0,0 +1 @@
|
|||
obj-$(CONFIG_POCH) += poch.o
|
7
drivers/staging/poch/README
Normal file
7
drivers/staging/poch/README
Normal file
|
@ -0,0 +1,7 @@
|
|||
TODO:
|
||||
- fix transmit overflows
|
||||
- audit userspace interfaces
|
||||
- get reserved major/minor if needed
|
||||
|
||||
Please send patches to Greg Kroah-Hartman <greg@kroah.com> and
|
||||
Vijay Kumar <vijaykumar@bravegnu.org> and Jaya Kumar <jayakumar.lkml@gmail.com>
|
1425
drivers/staging/poch/poch.c
Normal file
1425
drivers/staging/poch/poch.c
Normal file
File diff suppressed because it is too large
Load diff
29
drivers/staging/poch/poch.h
Normal file
29
drivers/staging/poch/poch.h
Normal file
|
@ -0,0 +1,29 @@
|
|||
/*
|
||||
* User-space DMA and UIO based Redrapids Pocket Change CardBus driver
|
||||
*
|
||||
* Copyright 2008 Vijay Kumar <vijaykumar@bravegnu.org>
|
||||
*
|
||||
* Part of userspace API. Should be moved to a header file in
|
||||
* include/linux for final version.
|
||||
*
|
||||
*/
|
||||
struct poch_cbuf_header {
|
||||
__s32 group_size_bytes;
|
||||
__s32 group_count;
|
||||
__s32 group_offsets[0];
|
||||
};
|
||||
|
||||
struct poch_counters {
|
||||
__u32 fifo_empty;
|
||||
__u32 fifo_overflow;
|
||||
__u32 pll_unlock;
|
||||
};
|
||||
|
||||
#define POCH_IOC_NUM '9'
|
||||
|
||||
#define POCH_IOC_TRANSFER_START _IO(POCH_IOC_NUM, 0)
|
||||
#define POCH_IOC_TRANSFER_STOP _IO(POCH_IOC_NUM, 1)
|
||||
#define POCH_IOC_GET_COUNTERS _IOR(POCH_IOC_NUM, 2, \
|
||||
struct poch_counters)
|
||||
#define POCH_IOC_SYNC_GROUP_FOR_USER _IO(POCH_IOC_NUM, 3)
|
||||
#define POCH_IOC_SYNC_GROUP_FOR_DEVICE _IO(POCH_IOC_NUM, 4)
|
|
@ -54,7 +54,6 @@
|
|||
* IS-NIC driver.
|
||||
*/
|
||||
|
||||
#include <linux/version.h>
|
||||
|
||||
#define SLIC_DUMP_ENABLED 0
|
||||
#define KLUDGE_FOR_4GB_BOUNDARY 1
|
||||
|
@ -96,17 +95,9 @@
|
|||
#include <linux/moduleparam.h>
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/pci.h>
|
||||
#include <linux/dma-mapping.h>
|
||||
#include <linux/netdevice.h>
|
||||
#include <linux/etherdevice.h>
|
||||
#include <linux/mii.h>
|
||||
#include <linux/if_vlan.h>
|
||||
#include <linux/skbuff.h>
|
||||
#include <linux/string.h>
|
||||
#include <asm/unaligned.h>
|
||||
|
||||
#include <linux/ethtool.h>
|
||||
|
@ -275,7 +266,6 @@ static void slic_dbg_register_trace(struct adapter *adapter,
|
|||
card->reg_value[i], card->reg_valueh[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static void slic_init_adapter(struct net_device *netdev,
|
||||
|
@ -606,6 +596,7 @@ static void __devexit slic_entry_remove(struct pci_dev *pcidev)
|
|||
uint mmio_len = 0;
|
||||
struct adapter *adapter = (struct adapter *) netdev_priv(dev);
|
||||
struct sliccard *card;
|
||||
struct mcast_address *mcaddr, *mlist;
|
||||
|
||||
ASSERT(adapter);
|
||||
DBG_MSG("slicoss: %s ENTER dev[%p] adapter[%p]\n", __func__, dev,
|
||||
|
@ -625,6 +616,13 @@ static void __devexit slic_entry_remove(struct pci_dev *pcidev)
|
|||
DBG_MSG("slicoss: %s iounmap dev->base_addr[%x]\n", __func__,
|
||||
(uint) dev->base_addr);
|
||||
iounmap((void __iomem *)dev->base_addr);
|
||||
/* free multicast addresses */
|
||||
mlist = adapter->mcastaddrs;
|
||||
while (mlist) {
|
||||
mcaddr = mlist;
|
||||
mlist = mlist->next;
|
||||
kfree(mcaddr);
|
||||
}
|
||||
ASSERT(adapter->card);
|
||||
card = adapter->card;
|
||||
ASSERT(card->adapters_allocated);
|
||||
|
|
|
@ -7,6 +7,7 @@ TODO:
|
|||
- remove wrappers
|
||||
- checkpatch.pl cleanups
|
||||
- new functionality that the card needs
|
||||
- remove reliance on x86
|
||||
|
||||
Please send patches to:
|
||||
Greg Kroah-Hartman <gregkh@suse.de>
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -44,7 +44,6 @@
|
|||
#define FALSE (0)
|
||||
#define TRUE (1)
|
||||
|
||||
|
||||
typedef struct _LIST_ENTRY {
|
||||
struct _LIST_ENTRY *nle_flink;
|
||||
struct _LIST_ENTRY *nle_blink;
|
||||
|
@ -69,8 +68,7 @@ typedef struct _LIST_ENTRY {
|
|||
|
||||
/* These two have to be inlined since they return things. */
|
||||
|
||||
static __inline PLIST_ENTRY
|
||||
RemoveHeadList(list_entry *l)
|
||||
static __inline PLIST_ENTRY RemoveHeadList(list_entry * l)
|
||||
{
|
||||
list_entry *f;
|
||||
list_entry *e;
|
||||
|
@ -83,8 +81,7 @@ RemoveHeadList(list_entry *l)
|
|||
return (e);
|
||||
}
|
||||
|
||||
static __inline PLIST_ENTRY
|
||||
RemoveTailList(list_entry *l)
|
||||
static __inline PLIST_ENTRY RemoveTailList(list_entry * l)
|
||||
{
|
||||
list_entry *b;
|
||||
list_entry *e;
|
||||
|
@ -97,7 +94,6 @@ RemoveTailList(list_entry *l)
|
|||
return (e);
|
||||
}
|
||||
|
||||
|
||||
#define InsertTailList(l, e) \
|
||||
do { \
|
||||
list_entry *b; \
|
||||
|
@ -120,7 +116,6 @@ RemoveTailList(list_entry *l)
|
|||
(l)->nle_flink = (e); \
|
||||
} while (0)
|
||||
|
||||
|
||||
#define ATK_DEBUG 1
|
||||
|
||||
#if ATK_DEBUG
|
||||
|
@ -133,7 +128,6 @@ RemoveTailList(list_entry *l)
|
|||
#define SLIC_TIMESTAMP(value)
|
||||
#endif
|
||||
|
||||
|
||||
/****************** SXG DEFINES *****************************************/
|
||||
|
||||
#ifdef ATKDBG
|
||||
|
@ -151,4 +145,3 @@ RemoveTailList(list_entry *l)
|
|||
#define READ_REG(reg,value) (value) = readl((void __iomem *)(®))
|
||||
|
||||
#endif /* _SLIC_OS_SPECIFIC_H_ */
|
||||
|
||||
|
|
|
@ -58,7 +58,7 @@
|
|||
{ \
|
||||
if (!(a)) { \
|
||||
DBG_ERROR("ASSERT() Failure: file %s, function %s line %d\n",\
|
||||
__FILE__, __FUNCTION__, __LINE__); \
|
||||
__FILE__, __func__, __LINE__); \
|
||||
} \
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -368,7 +368,6 @@ typedef struct _SXG_EVENT_RING {
|
|||
&(_TcpObject)->CompBuffer->Frame.HasVlan.TcpIp6.Ip : \
|
||||
&(_TcpObject)->CompBuffer->Frame.NoVlan.TcpIp6.Ip
|
||||
|
||||
|
||||
#if DBG
|
||||
// Horrible kludge to distinguish dumb-nic, slowpath, and
|
||||
// fastpath traffic. Decrement the HopLimit by one
|
||||
|
@ -760,7 +759,6 @@ typedef struct _SXG_RCV_NBL_RESERVED {
|
|||
#define SXG_MIN_SGL_BUFFERS 2048 // Minimum amount and when to get more
|
||||
#define SXG_MAX_SGL_BUFFERS 16384 // Maximum to allocate (note ADAPT:ushort)
|
||||
|
||||
|
||||
// Self identifying structure type
|
||||
typedef enum _SXG_SGL_TYPE {
|
||||
SXG_SGL_DUMB, // Dumb NIC SGL
|
||||
|
@ -814,7 +812,6 @@ typedef struct _SCATTER_GATHER_ELEMENT {
|
|||
u64 Reserved; // u32 * in wdm.h. Force to 8 bytes
|
||||
} SCATTER_GATHER_ELEMENT, *PSCATTER_GATHER_ELEMENT;
|
||||
|
||||
|
||||
typedef struct _SCATTER_GATHER_LIST {
|
||||
u32 NumberOfElements;
|
||||
u32 *Reserved;
|
||||
|
@ -858,4 +855,3 @@ typedef struct _SXG_SCATTER_GATHER {
|
|||
#else
|
||||
Stop Compilation;
|
||||
#endif
|
||||
|
||||
|
|
|
@ -13,11 +13,11 @@
|
|||
/*******************************************************************************
|
||||
* Configuration space
|
||||
*******************************************************************************/
|
||||
// PCI Vendor ID
|
||||
#define SXG_VENDOR_ID 0x139A // Alacritech's Vendor ID
|
||||
/* PCI Vendor ID */
|
||||
#define SXG_VENDOR_ID 0x139A /* Alacritech's Vendor ID */
|
||||
|
||||
// PCI Device ID
|
||||
#define SXG_DEVICE_ID 0x0009 // Sahara Device ID
|
||||
#define SXG_DEVICE_ID 0x0009 /* Sahara Device ID */
|
||||
|
||||
//
|
||||
// Subsystem IDs.
|
||||
|
@ -623,48 +623,48 @@ typedef struct _RCV_BUF_HDR {
|
|||
* Queue definitions
|
||||
*****************************************************************************/
|
||||
|
||||
// Ingress (read only) queue numbers
|
||||
#define PXY_BUF_Q 0 // Proxy Buffer Queue
|
||||
#define HST_EVT_Q 1 // Host Event Queue
|
||||
#define XMT_BUF_Q 2 // Transmit Buffer Queue
|
||||
#define SKT_EVL_Q 3 // RcvSqr Socket Event Low Priority Queue
|
||||
#define RCV_EVL_Q 4 // RcvSqr Rcv Event Low Priority Queue
|
||||
#define SKT_EVH_Q 5 // RcvSqr Socket Event High Priority Queue
|
||||
#define RCV_EVH_Q 6 // RcvSqr Rcv Event High Priority Queue
|
||||
#define DMA_RSP_Q 7 // Dma Response Queue - one per CPU context
|
||||
// Local (read/write) queue numbers
|
||||
#define LOCAL_A_Q 8 // Spare local Queue
|
||||
#define LOCAL_B_Q 9 // Spare local Queue
|
||||
#define LOCAL_C_Q 10 // Spare local Queue
|
||||
#define FSM_EVT_Q 11 // Finite-State-Machine Event Queue
|
||||
#define SBF_PAL_Q 12 // System Buffer Physical Address (low) Queue
|
||||
#define SBF_PAH_Q 13 // System Buffer Physical Address (high) Queue
|
||||
#define SBF_VAL_Q 14 // System Buffer Virtual Address (low) Queue
|
||||
#define SBF_VAH_Q 15 // System Buffer Virtual Address (high) Queue
|
||||
// Egress (write only) queue numbers
|
||||
#define H2G_CMD_Q 16 // Host to GlbRam DMA Command Queue
|
||||
#define H2D_CMD_Q 17 // Host to DRAM DMA Command Queue
|
||||
#define G2H_CMD_Q 18 // GlbRam to Host DMA Command Queue
|
||||
#define G2D_CMD_Q 19 // GlbRam to DRAM DMA Command Queue
|
||||
#define D2H_CMD_Q 20 // DRAM to Host DMA Command Queue
|
||||
#define D2G_CMD_Q 21 // DRAM to GlbRam DMA Command Queue
|
||||
#define D2D_CMD_Q 22 // DRAM to DRAM DMA Command Queue
|
||||
#define PXL_CMD_Q 23 // Low Priority Proxy Command Queue
|
||||
#define PXH_CMD_Q 24 // High Priority Proxy Command Queue
|
||||
#define RSQ_CMD_Q 25 // Receive Sequencer Command Queue
|
||||
#define RCV_BUF_Q 26 // Receive Buffer Queue
|
||||
/* Ingress (read only) queue numbers */
|
||||
#define PXY_BUF_Q 0 /* Proxy Buffer Queue */
|
||||
#define HST_EVT_Q 1 /* Host Event Queue */
|
||||
#define XMT_BUF_Q 2 /* Transmit Buffer Queue */
|
||||
#define SKT_EVL_Q 3 /* RcvSqr Socket Event Low Priority Queue */
|
||||
#define RCV_EVL_Q 4 /* RcvSqr Rcv Event Low Priority Queue */
|
||||
#define SKT_EVH_Q 5 /* RcvSqr Socket Event High Priority Queue */
|
||||
#define RCV_EVH_Q 6 /* RcvSqr Rcv Event High Priority Queue */
|
||||
#define DMA_RSP_Q 7 /* Dma Response Queue - one per CPU context */
|
||||
/* Local (read/write) queue numbers */
|
||||
#define LOCAL_A_Q 8 /* Spare local Queue */
|
||||
#define LOCAL_B_Q 9 /* Spare local Queue */
|
||||
#define LOCAL_C_Q 10 /* Spare local Queue */
|
||||
#define FSM_EVT_Q 11 /* Finite-State-Machine Event Queue */
|
||||
#define SBF_PAL_Q 12 /* System Buffer Physical Address (low) Queue */
|
||||
#define SBF_PAH_Q 13 /* System Buffer Physical Address (high) Queue */
|
||||
#define SBF_VAL_Q 14 /* System Buffer Virtual Address (low) Queue */
|
||||
#define SBF_VAH_Q 15 /* System Buffer Virtual Address (high) Queue */
|
||||
/* Egress (write only) queue numbers */
|
||||
#define H2G_CMD_Q 16 /* Host to GlbRam DMA Command Queue */
|
||||
#define H2D_CMD_Q 17 /* Host to DRAM DMA Command Queue */
|
||||
#define G2H_CMD_Q 18 /* GlbRam to Host DMA Command Queue */
|
||||
#define G2D_CMD_Q 19 /* GlbRam to DRAM DMA Command Queue */
|
||||
#define D2H_CMD_Q 20 /* DRAM to Host DMA Command Queue */
|
||||
#define D2G_CMD_Q 21 /* DRAM to GlbRam DMA Command Queue */
|
||||
#define D2D_CMD_Q 22 /* DRAM to DRAM DMA Command Queue */
|
||||
#define PXL_CMD_Q 23 /* Low Priority Proxy Command Queue */
|
||||
#define PXH_CMD_Q 24 /* High Priority Proxy Command Queue */
|
||||
#define RSQ_CMD_Q 25 /* Receive Sequencer Command Queue */
|
||||
#define RCV_BUF_Q 26 /* Receive Buffer Queue */
|
||||
|
||||
// Bit definitions for the Proxy Command queues (PXL_CMD_Q and PXH_CMD_Q)
|
||||
#define PXY_COPY_EN 0x00200000 // enable copy of xmt descriptor to xmt command queue
|
||||
#define PXY_SIZE_16 0x00000000 // copy 16 bytes
|
||||
#define PXY_SIZE_32 0x00100000 // copy 32 bytes
|
||||
/* Bit definitions for the Proxy Command queues (PXL_CMD_Q and PXH_CMD_Q) */
|
||||
#define PXY_COPY_EN 0x00200000 /* enable copy of xmt descriptor to xmt command queue */
|
||||
#define PXY_SIZE_16 0x00000000 /* copy 16 bytes */
|
||||
#define PXY_SIZE_32 0x00100000 /* copy 32 bytes */
|
||||
|
||||
/*****************************************************************************
|
||||
* SXG EEPROM/Flash Configuration Definitions
|
||||
*****************************************************************************/
|
||||
#pragma pack(push, 1)
|
||||
|
||||
//
|
||||
/* */
|
||||
typedef struct _HW_CFG_DATA {
|
||||
ushort Addr;
|
||||
union {
|
||||
|
@ -673,22 +673,22 @@ typedef struct _HW_CFG_DATA {
|
|||
};
|
||||
} HW_CFG_DATA, *PHW_CFG_DATA;
|
||||
|
||||
//
|
||||
/* */
|
||||
#define NUM_HW_CFG_ENTRIES ((128/sizeof(HW_CFG_DATA)) - 4)
|
||||
|
||||
// MAC address
|
||||
/* MAC address */
|
||||
typedef struct _SXG_CONFIG_MAC {
|
||||
unsigned char MacAddr[6]; // MAC Address
|
||||
unsigned char MacAddr[6]; /* MAC Address */
|
||||
} SXG_CONFIG_MAC, *PSXG_CONFIG_MAC;
|
||||
|
||||
//
|
||||
/* */
|
||||
typedef struct _ATK_FRU {
|
||||
unsigned char PartNum[6];
|
||||
unsigned char Revision[2];
|
||||
unsigned char Serial[14];
|
||||
} ATK_FRU, *PATK_FRU;
|
||||
|
||||
// OEM FRU Format types
|
||||
/* OEM FRU Format types */
|
||||
#define ATK_FRU_FORMAT 0x0000
|
||||
#define CPQ_FRU_FORMAT 0x0001
|
||||
#define DELL_FRU_FORMAT 0x0002
|
||||
|
@ -697,24 +697,24 @@ typedef struct _ATK_FRU {
|
|||
#define EMC_FRU_FORMAT 0x0005
|
||||
#define NO_FRU_FORMAT 0xFFFF
|
||||
|
||||
// EEPROM/Flash Format
|
||||
/* EEPROM/Flash Format */
|
||||
typedef struct _SXG_CONFIG {
|
||||
//
|
||||
// Section 1 (128 bytes)
|
||||
//
|
||||
ushort MagicWord; // EEPROM/FLASH Magic code 'A5A5'
|
||||
ushort SpiClks; // SPI bus clock dividers
|
||||
/* */
|
||||
/* Section 1 (128 bytes) */
|
||||
/* */
|
||||
ushort MagicWord; /* EEPROM/FLASH Magic code 'A5A5' */
|
||||
ushort SpiClks; /* SPI bus clock dividers */
|
||||
HW_CFG_DATA HwCfg[NUM_HW_CFG_ENTRIES];
|
||||
//
|
||||
//
|
||||
//
|
||||
ushort Version; // EEPROM format version
|
||||
SXG_CONFIG_MAC MacAddr[4]; // space for 4 MAC addresses
|
||||
ATK_FRU AtkFru; // FRU information
|
||||
ushort OemFruFormat; // OEM FRU format type
|
||||
unsigned char OemFru[76]; // OEM FRU information (optional)
|
||||
ushort Checksum; // Checksum of section 2
|
||||
// CS info XXXTODO
|
||||
/* */
|
||||
/* */
|
||||
/* */
|
||||
ushort Version; /* EEPROM format version */
|
||||
SXG_CONFIG_MAC MacAddr[4]; /* space for 4 MAC addresses */
|
||||
ATK_FRU AtkFru; /* FRU information */
|
||||
ushort OemFruFormat; /* OEM FRU format type */
|
||||
unsigned char OemFru[76]; /* OEM FRU information (optional) */
|
||||
ushort Checksum; /* Checksum of section 2 */
|
||||
/* CS info XXXTODO */
|
||||
} SXG_CONFIG, *PSXG_CONFIG;
|
||||
#pragma pack(pop)
|
||||
|
||||
|
|
|
@ -221,7 +221,7 @@ static void usbip_dump_request_type(__u8 rt)
|
|||
static void usbip_dump_usb_ctrlrequest(struct usb_ctrlrequest *cmd)
|
||||
{
|
||||
if (!cmd) {
|
||||
printk(" %s : null pointer\n", __FUNCTION__);
|
||||
printk(" %s : null pointer\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
@ -202,7 +202,7 @@ static void vhci_rx_pdu(struct usbip_device *ud)
|
|||
ret = usbip_xmit(0, ud->tcp_socket, (char *) &pdu, sizeof(pdu), 0);
|
||||
if (ret != sizeof(pdu)) {
|
||||
uerr("receiving pdu failed! size is %d, should be %d\n",
|
||||
ret, sizeof(pdu));
|
||||
ret, (unsigned int)sizeof(pdu));
|
||||
usbip_event_add(ud, VDEV_EVENT_ERROR_TCP);
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
config W35UND
|
||||
tristate "Winbond driver"
|
||||
depends on MAC80211 && WLAN_80211 && EXPERIMENTAL && !4KSTACKS
|
||||
depends on MAC80211 && WLAN_80211 && USB && EXPERIMENTAL && !4KSTACKS
|
||||
default n
|
||||
---help---
|
||||
This is highly experimental driver for winbond wifi card on some Kohjinsha notebooks
|
||||
|
|
|
@ -5,6 +5,7 @@ TODO:
|
|||
- remove typedefs
|
||||
- remove unused ioctls
|
||||
- use cfg80211 for regulatory stuff
|
||||
- fix 4k stack problems
|
||||
|
||||
Please send patches to Greg Kroah-Hartman <greg@kroah.com> and
|
||||
Pavel Machek <pavel@suse.cz>
|
||||
|
|
|
@ -24,7 +24,7 @@ void DesiredRate2InfoElement(PWB32_ADAPTER Adapter, u8 *addr, u16 *iFildOffset,
|
|||
u8 *pBasicRateSet, u8 BasicRateCount,
|
||||
u8 *pOperationRateSet, u8 OperationRateCount);
|
||||
void BSSAddIBSSdata(PWB32_ADAPTER Adapter, PWB_BSSDESCRIPTION psDesData);
|
||||
unsigned char boCmpMacAddr( PUCHAR, PUCHAR );
|
||||
unsigned char boCmpMacAddr( u8 *, u8 *);
|
||||
unsigned char boCmpSSID(struct SSID_Element *psSSID1, struct SSID_Element *psSSID2);
|
||||
u16 wBSSfindSSID(PWB32_ADAPTER Adapter, struct SSID_Element *psSsid);
|
||||
u16 wRoamingQuery(PWB32_ADAPTER Adapter);
|
||||
|
@ -42,11 +42,11 @@ void RateReSortForSRate(PWB32_ADAPTER Adapter, u8 *RateArray, u8 num);
|
|||
void Assemble_IE(PWB32_ADAPTER Adapter, u16 wBssIdx);
|
||||
void SetMaxTxRate(PWB32_ADAPTER Adapter);
|
||||
|
||||
void CreateWpaIE(PWB32_ADAPTER Adapter, u16* iFildOffset, PUCHAR msg, struct Management_Frame* msgHeader,
|
||||
void CreateWpaIE(PWB32_ADAPTER Adapter, u16* iFildOffset, u8 *msg, struct Management_Frame* msgHeader,
|
||||
struct Association_Request_Frame_Body* msgBody, u16 iMSindex); //added by WS 05/14/05
|
||||
|
||||
#ifdef _WPA2_
|
||||
void CreateRsnIE(PWB32_ADAPTER Adapter, u16* iFildOffset, PUCHAR msg, struct Management_Frame* msgHeader,
|
||||
void CreateRsnIE(PWB32_ADAPTER Adapter, u16* iFildOffset, u8 *msg, struct Management_Frame* msgHeader,
|
||||
struct Association_Request_Frame_Body* msgBody, u16 iMSindex);//added by WS 05/14/05
|
||||
|
||||
u16 SearchPmkid(PWB32_ADAPTER Adapter, struct Management_Frame* msgHeader,
|
||||
|
|
|
@ -25,9 +25,9 @@ typedef struct tkip
|
|||
s32 bytes_in_M; // # bytes in M
|
||||
} tkip_t;
|
||||
|
||||
//void _append_data( PUCHAR pData, u16 size, tkip_t *p );
|
||||
void Mds_MicGet( void* Adapter, void* pRxLayer1, PUCHAR pKey, PUCHAR pMic );
|
||||
void Mds_MicFill( void* Adapter, void* pDes, PUCHAR XmitBufAddress );
|
||||
//void _append_data( u8 *pData, u16 size, tkip_t *p );
|
||||
void Mds_MicGet( void* Adapter, void* pRxLayer1, u8 *pKey, u8 *pMic );
|
||||
void Mds_MicFill( void* Adapter, void* pDes, u8 *XmitBufAddress );
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -39,14 +39,6 @@
|
|||
// Common type definition
|
||||
//===============================================================
|
||||
|
||||
typedef u8* PUCHAR;
|
||||
typedef s8* PCHAR;
|
||||
typedef u8* PBOOLEAN;
|
||||
typedef u16* PUSHORT;
|
||||
typedef u32* PULONG;
|
||||
typedef s16* PSHORT;
|
||||
|
||||
|
||||
//===========================================
|
||||
#define IGNORE 2
|
||||
#define SUCCESS 1
|
||||
|
@ -110,16 +102,9 @@ typedef struct urb * PURB;
|
|||
#define OS_ATOMIC_READ( _A, _V ) _V
|
||||
#define OS_ATOMIC_INC( _A, _V ) EncapAtomicInc( _A, (void*)_V )
|
||||
#define OS_ATOMIC_DEC( _A, _V ) EncapAtomicDec( _A, (void*)_V )
|
||||
#define OS_MEMORY_CLEAR( _A, _S ) memset( (PUCHAR)_A,0,_S)
|
||||
#define OS_MEMORY_CLEAR( _A, _S ) memset( (u8 *)_A,0,_S)
|
||||
#define OS_MEMORY_COMPARE( _A, _B, _S ) (memcmp(_A,_B,_S)? 0 : 1) // Definition is reverse with Ndis 1: the same 0: different
|
||||
|
||||
|
||||
#define OS_SPIN_LOCK spinlock_t
|
||||
#define OS_SPIN_LOCK_ALLOCATE( _S ) spin_lock_init( _S );
|
||||
#define OS_SPIN_LOCK_FREE( _S )
|
||||
#define OS_SPIN_LOCK_ACQUIRED( _S ) spin_lock_irq( _S )
|
||||
#define OS_SPIN_LOCK_RELEASED( _S ) spin_unlock_irq( _S );
|
||||
|
||||
#define OS_TIMER struct timer_list
|
||||
#define OS_TIMER_INITIAL( _T, _F, _P ) \
|
||||
{ \
|
||||
|
|
|
@ -10,7 +10,7 @@ extern void phy_calibration_winbond(hw_data_t *phw_data, u32 frequency);
|
|||
// Flag : AUTO_INCREMENT - RegisterNo will auto increment 4
|
||||
// NO_INCREMENT - Function will write data into the same register
|
||||
unsigned char
|
||||
Wb35Reg_BurstWrite(phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterData, u8 NumberOfData, u8 Flag)
|
||||
Wb35Reg_BurstWrite(phw_data_t pHwData, u16 RegisterNo, u32 * pRegisterData, u8 NumberOfData, u8 Flag)
|
||||
{
|
||||
PWB35REG pWb35Reg = &pHwData->Wb35Reg;
|
||||
PURB pUrb = NULL;
|
||||
|
@ -30,13 +30,13 @@ Wb35Reg_BurstWrite(phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterData, u8
|
|||
if( pUrb && pRegQueue ) {
|
||||
pRegQueue->DIRECT = 2;// burst write register
|
||||
pRegQueue->INDEX = RegisterNo;
|
||||
pRegQueue->pBuffer = (PULONG)((PUCHAR)pRegQueue + sizeof(REG_QUEUE));
|
||||
pRegQueue->pBuffer = (u32 *)((u8 *)pRegQueue + sizeof(REG_QUEUE));
|
||||
memcpy( pRegQueue->pBuffer, pRegisterData, DataSize );
|
||||
//the function for reversing register data from little endian to big endian
|
||||
for( i=0; i<NumberOfData ; i++ )
|
||||
pRegQueue->pBuffer[i] = cpu_to_le32( pRegQueue->pBuffer[i] );
|
||||
|
||||
dr = (struct usb_ctrlrequest *)((PUCHAR)pRegQueue + sizeof(REG_QUEUE) + DataSize);
|
||||
dr = (struct usb_ctrlrequest *)((u8 *)pRegQueue + sizeof(REG_QUEUE) + DataSize);
|
||||
dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE;
|
||||
dr->bRequest = 0x04; // USB or vendor-defined request code, burst mode
|
||||
dr->wValue = cpu_to_le16( Flag ); // 0: Register number auto-increment, 1: No auto increment
|
||||
|
@ -46,14 +46,14 @@ Wb35Reg_BurstWrite(phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterData, u8
|
|||
pRegQueue->pUsbReq = dr;
|
||||
pRegQueue->pUrb = pUrb;
|
||||
|
||||
OS_SPIN_LOCK_ACQUIRED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_lock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
if (pWb35Reg->pRegFirst == NULL)
|
||||
pWb35Reg->pRegFirst = pRegQueue;
|
||||
else
|
||||
pWb35Reg->pRegLast->Next = pRegQueue;
|
||||
pWb35Reg->pRegLast = pRegQueue;
|
||||
|
||||
OS_SPIN_LOCK_RELEASED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_unlock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
|
||||
// Start EP0VM
|
||||
Wb35Reg_EP0VM_start(pHwData);
|
||||
|
@ -181,7 +181,7 @@ Wb35Reg_Write( phw_data_t pHwData, u16 RegisterNo, u32 RegisterValue )
|
|||
pRegQueue->INDEX = RegisterNo;
|
||||
pRegQueue->VALUE = cpu_to_le32(RegisterValue);
|
||||
pRegQueue->RESERVED_VALID = FALSE;
|
||||
dr = (struct usb_ctrlrequest *)((PUCHAR)pRegQueue + sizeof(REG_QUEUE));
|
||||
dr = (struct usb_ctrlrequest *)((u8 *)pRegQueue + sizeof(REG_QUEUE));
|
||||
dr->bRequestType = USB_TYPE_VENDOR|USB_DIR_OUT |USB_RECIP_DEVICE;
|
||||
dr->bRequest = 0x03; // USB or vendor-defined request code, burst mode
|
||||
dr->wValue = cpu_to_le16(0x0);
|
||||
|
@ -193,14 +193,14 @@ Wb35Reg_Write( phw_data_t pHwData, u16 RegisterNo, u32 RegisterValue )
|
|||
pRegQueue->pUsbReq = dr;
|
||||
pRegQueue->pUrb = pUrb;
|
||||
|
||||
OS_SPIN_LOCK_ACQUIRED(&pWb35Reg->EP0VM_spin_lock );
|
||||
spin_lock_irq(&pWb35Reg->EP0VM_spin_lock );
|
||||
if (pWb35Reg->pRegFirst == NULL)
|
||||
pWb35Reg->pRegFirst = pRegQueue;
|
||||
else
|
||||
pWb35Reg->pRegLast->Next = pRegQueue;
|
||||
pWb35Reg->pRegLast = pRegQueue;
|
||||
|
||||
OS_SPIN_LOCK_RELEASED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_unlock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
|
||||
// Start EP0VM
|
||||
Wb35Reg_EP0VM_start(pHwData);
|
||||
|
@ -220,7 +220,7 @@ Wb35Reg_Write( phw_data_t pHwData, u16 RegisterNo, u32 RegisterValue )
|
|||
// FALSE : register not support
|
||||
unsigned char
|
||||
Wb35Reg_WriteWithCallbackValue( phw_data_t pHwData, u16 RegisterNo, u32 RegisterValue,
|
||||
PCHAR pValue, s8 Len)
|
||||
s8 *pValue, s8 Len)
|
||||
{
|
||||
PWB35REG pWb35Reg = &pHwData->Wb35Reg;
|
||||
struct usb_ctrlrequest *dr;
|
||||
|
@ -243,7 +243,7 @@ Wb35Reg_WriteWithCallbackValue( phw_data_t pHwData, u16 RegisterNo, u32 Register
|
|||
//NOTE : Users must guarantee the size of value will not exceed the buffer size.
|
||||
memcpy(pRegQueue->RESERVED, pValue, Len);
|
||||
pRegQueue->RESERVED_VALID = TRUE;
|
||||
dr = (struct usb_ctrlrequest *)((PUCHAR)pRegQueue + sizeof(REG_QUEUE));
|
||||
dr = (struct usb_ctrlrequest *)((u8 *)pRegQueue + sizeof(REG_QUEUE));
|
||||
dr->bRequestType = USB_TYPE_VENDOR|USB_DIR_OUT |USB_RECIP_DEVICE;
|
||||
dr->bRequest = 0x03; // USB or vendor-defined request code, burst mode
|
||||
dr->wValue = cpu_to_le16(0x0);
|
||||
|
@ -254,14 +254,14 @@ Wb35Reg_WriteWithCallbackValue( phw_data_t pHwData, u16 RegisterNo, u32 Register
|
|||
pRegQueue->Next = NULL;
|
||||
pRegQueue->pUsbReq = dr;
|
||||
pRegQueue->pUrb = pUrb;
|
||||
OS_SPIN_LOCK_ACQUIRED (&pWb35Reg->EP0VM_spin_lock );
|
||||
spin_lock_irq (&pWb35Reg->EP0VM_spin_lock );
|
||||
if( pWb35Reg->pRegFirst == NULL )
|
||||
pWb35Reg->pRegFirst = pRegQueue;
|
||||
else
|
||||
pWb35Reg->pRegLast->Next = pRegQueue;
|
||||
pWb35Reg->pRegLast = pRegQueue;
|
||||
|
||||
OS_SPIN_LOCK_RELEASED ( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_unlock_irq ( &pWb35Reg->EP0VM_spin_lock );
|
||||
|
||||
// Start EP0VM
|
||||
Wb35Reg_EP0VM_start(pHwData);
|
||||
|
@ -278,10 +278,10 @@ Wb35Reg_WriteWithCallbackValue( phw_data_t pHwData, u16 RegisterNo, u32 Register
|
|||
// FALSE : register not support
|
||||
// pRegisterValue : It must be a resident buffer due to asynchronous read register.
|
||||
unsigned char
|
||||
Wb35Reg_ReadSync( phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterValue )
|
||||
Wb35Reg_ReadSync( phw_data_t pHwData, u16 RegisterNo, u32 * pRegisterValue )
|
||||
{
|
||||
PWB35REG pWb35Reg = &pHwData->Wb35Reg;
|
||||
PULONG pltmp = pRegisterValue;
|
||||
u32 * pltmp = pRegisterValue;
|
||||
int ret = -1;
|
||||
|
||||
// Module shutdown
|
||||
|
@ -327,7 +327,7 @@ Wb35Reg_ReadSync( phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterValue
|
|||
// FALSE : register not support
|
||||
// pRegisterValue : It must be a resident buffer due to asynchronous read register.
|
||||
unsigned char
|
||||
Wb35Reg_Read(phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterValue )
|
||||
Wb35Reg_Read(phw_data_t pHwData, u16 RegisterNo, u32 * pRegisterValue )
|
||||
{
|
||||
PWB35REG pWb35Reg = &pHwData->Wb35Reg;
|
||||
struct usb_ctrlrequest * dr;
|
||||
|
@ -348,7 +348,7 @@ Wb35Reg_Read(phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterValue )
|
|||
pRegQueue->DIRECT = 0;// read register
|
||||
pRegQueue->INDEX = RegisterNo;
|
||||
pRegQueue->pBuffer = pRegisterValue;
|
||||
dr = (struct usb_ctrlrequest *)((PUCHAR)pRegQueue + sizeof(REG_QUEUE));
|
||||
dr = (struct usb_ctrlrequest *)((u8 *)pRegQueue + sizeof(REG_QUEUE));
|
||||
dr->bRequestType = USB_TYPE_VENDOR|USB_RECIP_DEVICE|USB_DIR_IN;
|
||||
dr->bRequest = 0x01; // USB or vendor-defined request code, burst mode
|
||||
dr->wValue = cpu_to_le16(0x0);
|
||||
|
@ -359,14 +359,14 @@ Wb35Reg_Read(phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterValue )
|
|||
pRegQueue->Next = NULL;
|
||||
pRegQueue->pUsbReq = dr;
|
||||
pRegQueue->pUrb = pUrb;
|
||||
OS_SPIN_LOCK_ACQUIRED ( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_lock_irq ( &pWb35Reg->EP0VM_spin_lock );
|
||||
if( pWb35Reg->pRegFirst == NULL )
|
||||
pWb35Reg->pRegFirst = pRegQueue;
|
||||
else
|
||||
pWb35Reg->pRegLast->Next = pRegQueue;
|
||||
pWb35Reg->pRegLast = pRegQueue;
|
||||
|
||||
OS_SPIN_LOCK_RELEASED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_unlock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
|
||||
// Start EP0VM
|
||||
Wb35Reg_EP0VM_start( pHwData );
|
||||
|
@ -399,7 +399,7 @@ Wb35Reg_EP0VM(phw_data_t pHwData )
|
|||
PWB35REG pWb35Reg = &pHwData->Wb35Reg;
|
||||
PURB pUrb;
|
||||
struct usb_ctrlrequest *dr;
|
||||
PULONG pBuffer;
|
||||
u32 * pBuffer;
|
||||
int ret = -1;
|
||||
PREG_QUEUE pRegQueue;
|
||||
|
||||
|
@ -411,9 +411,9 @@ Wb35Reg_EP0VM(phw_data_t pHwData )
|
|||
goto cleanup;
|
||||
|
||||
// Get the register data and send to USB through Irp
|
||||
OS_SPIN_LOCK_ACQUIRED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_lock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
pRegQueue = pWb35Reg->pRegFirst;
|
||||
OS_SPIN_LOCK_RELEASED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_unlock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
|
||||
if (!pRegQueue)
|
||||
goto cleanup;
|
||||
|
@ -429,7 +429,7 @@ Wb35Reg_EP0VM(phw_data_t pHwData )
|
|||
|
||||
usb_fill_control_urb( pUrb, pHwData->WbUsb.udev,
|
||||
REG_DIRECTION(pHwData->WbUsb.udev,pRegQueue),
|
||||
(PUCHAR)dr,pBuffer,cpu_to_le16(dr->wLength),
|
||||
(u8 *)dr,pBuffer,cpu_to_le16(dr->wLength),
|
||||
Wb35Reg_EP0VM_complete, (void*)pHwData);
|
||||
|
||||
pWb35Reg->EP0vm_state = VM_RUNNING;
|
||||
|
@ -468,12 +468,12 @@ Wb35Reg_EP0VM_complete(PURB pUrb)
|
|||
OS_ATOMIC_DEC( pHwData->Adapter, &pWb35Reg->RegFireCount );
|
||||
} else {
|
||||
// Complete to send, remove the URB from the first
|
||||
OS_SPIN_LOCK_ACQUIRED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_lock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
pRegQueue = pWb35Reg->pRegFirst;
|
||||
if (pRegQueue == pWb35Reg->pRegLast)
|
||||
pWb35Reg->pRegLast = NULL;
|
||||
pWb35Reg->pRegFirst = pWb35Reg->pRegFirst->Next;
|
||||
OS_SPIN_LOCK_RELEASED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_unlock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
|
||||
if (pWb35Reg->EP0VM_status) {
|
||||
#ifdef _PE_REG_DUMP_
|
||||
|
@ -513,7 +513,7 @@ Wb35Reg_destroy(phw_data_t pHwData)
|
|||
OS_SLEEP(10000); // Delay for waiting function enter 940623.1.b
|
||||
|
||||
// Release all the data in RegQueue
|
||||
OS_SPIN_LOCK_ACQUIRED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_lock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
pRegQueue = pWb35Reg->pRegFirst;
|
||||
while (pRegQueue) {
|
||||
if (pRegQueue == pWb35Reg->pRegLast)
|
||||
|
@ -521,7 +521,7 @@ Wb35Reg_destroy(phw_data_t pHwData)
|
|||
pWb35Reg->pRegFirst = pWb35Reg->pRegFirst->Next;
|
||||
|
||||
pUrb = pRegQueue->pUrb;
|
||||
OS_SPIN_LOCK_RELEASED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_unlock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
if (pUrb) {
|
||||
usb_free_urb(pUrb);
|
||||
kfree(pRegQueue);
|
||||
|
@ -530,14 +530,11 @@ Wb35Reg_destroy(phw_data_t pHwData)
|
|||
WBDEBUG(("EP0 queue release error\n"));
|
||||
#endif
|
||||
}
|
||||
OS_SPIN_LOCK_ACQUIRED( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_lock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
|
||||
pRegQueue = pWb35Reg->pRegFirst;
|
||||
}
|
||||
OS_SPIN_LOCK_RELEASED( &pWb35Reg->EP0VM_spin_lock );
|
||||
|
||||
// Free resource
|
||||
OS_SPIN_LOCK_FREE( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_unlock_irq( &pWb35Reg->EP0VM_spin_lock );
|
||||
}
|
||||
|
||||
//====================================================================================
|
||||
|
@ -550,7 +547,7 @@ unsigned char Wb35Reg_initial(phw_data_t pHwData)
|
|||
u32 SoftwareSet, VCO_trim, TxVga, Region_ScanInterval;
|
||||
|
||||
// Spin lock is acquired for read and write IRP command
|
||||
OS_SPIN_LOCK_ALLOCATE( &pWb35Reg->EP0VM_spin_lock );
|
||||
spin_lock_init( &pWb35Reg->EP0VM_spin_lock );
|
||||
|
||||
// Getting RF module type from EEPROM ------------------------------------
|
||||
Wb35Reg_WriteSync( pHwData, 0x03b4, 0x080d0000 ); // Start EEPROM access + Read + address(0x0d)
|
||||
|
@ -655,7 +652,7 @@ unsigned char Wb35Reg_initial(phw_data_t pHwData)
|
|||
// version in _GENREQ.ASM of the DWB NE1000/2000 driver.
|
||||
//==================================================================================
|
||||
u32
|
||||
CardComputeCrc(PUCHAR Buffer, u32 Length)
|
||||
CardComputeCrc(u8 * Buffer, u32 Length)
|
||||
{
|
||||
u32 Crc, Carry;
|
||||
u32 i, j;
|
||||
|
|
|
@ -29,16 +29,16 @@ void EEPROMTxVgaAdjust( phw_data_t pHwData ); // 20060619.5 Add
|
|||
|
||||
void Wb35Reg_destroy( phw_data_t pHwData );
|
||||
|
||||
unsigned char Wb35Reg_Read( phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterValue );
|
||||
unsigned char Wb35Reg_ReadSync( phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterValue );
|
||||
unsigned char Wb35Reg_Read( phw_data_t pHwData, u16 RegisterNo, u32 * pRegisterValue );
|
||||
unsigned char Wb35Reg_ReadSync( phw_data_t pHwData, u16 RegisterNo, u32 * pRegisterValue );
|
||||
unsigned char Wb35Reg_Write( phw_data_t pHwData, u16 RegisterNo, u32 RegisterValue );
|
||||
unsigned char Wb35Reg_WriteSync( phw_data_t pHwData, u16 RegisterNo, u32 RegisterValue );
|
||||
unsigned char Wb35Reg_WriteWithCallbackValue( phw_data_t pHwData,
|
||||
u16 RegisterNo,
|
||||
u32 RegisterValue,
|
||||
PCHAR pValue,
|
||||
s8 *pValue,
|
||||
s8 Len);
|
||||
unsigned char Wb35Reg_BurstWrite( phw_data_t pHwData, u16 RegisterNo, PULONG pRegisterData, u8 NumberOfData, u8 Flag );
|
||||
unsigned char Wb35Reg_BurstWrite( phw_data_t pHwData, u16 RegisterNo, u32 * pRegisterData, u8 NumberOfData, u8 Flag );
|
||||
|
||||
void Wb35Reg_EP0VM( phw_data_t pHwData );
|
||||
void Wb35Reg_EP0VM_start( phw_data_t pHwData );
|
||||
|
@ -47,7 +47,7 @@ void Wb35Reg_EP0VM_complete( PURB pUrb );
|
|||
u32 BitReverse( u32 dwData, u32 DataLength);
|
||||
|
||||
void CardGetMulticastBit( u8 Address[MAC_ADDR_LENGTH], u8 *Byte, u8 *Value );
|
||||
u32 CardComputeCrc( PUCHAR Buffer, u32 Length );
|
||||
u32 CardComputeCrc( u8 * Buffer, u32 Length );
|
||||
|
||||
void Wb35Reg_phy_calibration( phw_data_t pHwData );
|
||||
void Wb35Reg_Update( phw_data_t pHwData, u16 RegisterNo, u32 RegisterValue );
|
||||
|
|
|
@ -75,7 +75,7 @@ typedef struct _REG_QUEUE
|
|||
union
|
||||
{
|
||||
u32 VALUE;
|
||||
PULONG pBuffer;
|
||||
u32 * pBuffer;
|
||||
};
|
||||
u8 RESERVED[4];// space reserved for communication
|
||||
|
||||
|
@ -143,7 +143,7 @@ typedef struct _WB35REG
|
|||
//-------------------
|
||||
// VM
|
||||
//-------------------
|
||||
OS_SPIN_LOCK EP0VM_spin_lock; // 4B
|
||||
spinlock_t EP0VM_spin_lock; // 4B
|
||||
u32 EP0VM_status;//$$
|
||||
PREG_QUEUE pRegFirst;
|
||||
PREG_QUEUE pRegLast;
|
||||
|
|
|
@ -27,7 +27,7 @@ void Wb35Rx_start(phw_data_t pHwData)
|
|||
void Wb35Rx( phw_data_t pHwData )
|
||||
{
|
||||
PWB35RX pWb35Rx = &pHwData->Wb35Rx;
|
||||
PUCHAR pRxBufferAddress;
|
||||
u8 * pRxBufferAddress;
|
||||
PURB pUrb = (PURB)pWb35Rx->RxUrb;
|
||||
int retv;
|
||||
u32 RxBufferId;
|
||||
|
@ -35,12 +35,11 @@ void Wb35Rx( phw_data_t pHwData )
|
|||
//
|
||||
// Issuing URB
|
||||
//
|
||||
do {
|
||||
if (pHwData->SurpriseRemove || pHwData->HwStop)
|
||||
break;
|
||||
goto error;
|
||||
|
||||
if (pWb35Rx->rx_halt)
|
||||
break;
|
||||
goto error;
|
||||
|
||||
// Get RxBuffer's ID
|
||||
RxBufferId = pWb35Rx->RxBufferId;
|
||||
|
@ -49,7 +48,7 @@ void Wb35Rx( phw_data_t pHwData )
|
|||
#ifdef _PE_RX_DUMP_
|
||||
WBDEBUG(("Rx driver fifo unavailable\n"));
|
||||
#endif
|
||||
break;
|
||||
goto error;
|
||||
}
|
||||
|
||||
// Update buffer point, then start to bulkin the data from USB
|
||||
|
@ -60,7 +59,7 @@ void Wb35Rx( phw_data_t pHwData )
|
|||
|
||||
if (1 != OS_MEMORY_ALLOC((void* *)&pWb35Rx->pDRx, MAX_USB_RX_BUFFER)) {
|
||||
printk("w35und: Rx memory alloc failed\n");
|
||||
break;
|
||||
goto error;
|
||||
}
|
||||
pRxBufferAddress = pWb35Rx->pDRx;
|
||||
|
||||
|
@ -75,11 +74,11 @@ void Wb35Rx( phw_data_t pHwData )
|
|||
|
||||
if (retv != 0) {
|
||||
printk("Rx URB sending error\n");
|
||||
break;
|
||||
goto error;
|
||||
}
|
||||
return;
|
||||
} while(FALSE);
|
||||
|
||||
error:
|
||||
// VM stop
|
||||
pWb35Rx->EP3vm_state = VM_STOP;
|
||||
OS_ATOMIC_DEC( pHwData->Adapter, &pWb35Rx->RxFireCounter );
|
||||
|
@ -89,7 +88,7 @@ void Wb35Rx_Complete(PURB pUrb)
|
|||
{
|
||||
phw_data_t pHwData = pUrb->context;
|
||||
PWB35RX pWb35Rx = &pHwData->Wb35Rx;
|
||||
PUCHAR pRxBufferAddress;
|
||||
u8 * pRxBufferAddress;
|
||||
u32 SizeCheck;
|
||||
u16 BulkLength;
|
||||
u32 RxBufferId;
|
||||
|
@ -99,7 +98,6 @@ void Wb35Rx_Complete(PURB pUrb)
|
|||
pWb35Rx->EP3vm_state = VM_COMPLETED;
|
||||
pWb35Rx->EP3VM_status = pUrb->status;//Store the last result of Irp
|
||||
|
||||
do {
|
||||
RxBufferId = pWb35Rx->CurrentRxBufferId;
|
||||
|
||||
pRxBufferAddress = pWb35Rx->pDRx;
|
||||
|
@ -109,14 +107,14 @@ void Wb35Rx_Complete(PURB pUrb)
|
|||
pWb35Rx->EP3vm_state = VM_COMPLETED;
|
||||
|
||||
if (pHwData->SurpriseRemove || pHwData->HwStop) // Must be here, or RxBufferId is invalid
|
||||
break;
|
||||
goto error;
|
||||
|
||||
if (pWb35Rx->rx_halt)
|
||||
break;
|
||||
goto error;
|
||||
|
||||
// Start to process the data only in successful condition
|
||||
pWb35Rx->RxOwner[ RxBufferId ] = 0; // Set the owner to driver
|
||||
R00.value = le32_to_cpu(*(PULONG)pRxBufferAddress);
|
||||
R00.value = le32_to_cpu(*(u32 *)pRxBufferAddress);
|
||||
|
||||
// The URB is completed, check the result
|
||||
if (pWb35Rx->EP3VM_status != 0) {
|
||||
|
@ -125,7 +123,7 @@ void Wb35Rx_Complete(PURB pUrb)
|
|||
DebugUsbdStatusInformation( pWb35Rx->EP3VM_status );
|
||||
#endif
|
||||
pWb35Rx->EP3vm_state = VM_STOP;
|
||||
break;
|
||||
goto error;
|
||||
}
|
||||
|
||||
// 20060220 For recovering. check if operating in single USB mode
|
||||
|
@ -156,8 +154,7 @@ void Wb35Rx_Complete(PURB pUrb)
|
|||
Wb35Rx(pHwData);
|
||||
return;
|
||||
|
||||
} while(FALSE);
|
||||
|
||||
error:
|
||||
pWb35Rx->RxOwner[ RxBufferId ] = 1; // Set the owner to hardware
|
||||
OS_ATOMIC_DEC( pHwData->Adapter, &pWb35Rx->RxFireCounter );
|
||||
pWb35Rx->EP3vm_state = VM_STOP;
|
||||
|
@ -223,7 +220,7 @@ void Wb35Rx_reset_descriptor( phw_data_t pHwData )
|
|||
|
||||
void Wb35Rx_adjust(PDESCRIPTOR pRxDes)
|
||||
{
|
||||
PULONG pRxBufferAddress;
|
||||
u32 * pRxBufferAddress;
|
||||
u32 DecryptionMethod;
|
||||
u32 i;
|
||||
u16 BufferSize;
|
||||
|
@ -264,7 +261,7 @@ u16 Wb35Rx_indicate(phw_data_t pHwData)
|
|||
{
|
||||
DESCRIPTOR RxDes;
|
||||
PWB35RX pWb35Rx = &pHwData->Wb35Rx;
|
||||
PUCHAR pRxBufferAddress;
|
||||
u8 * pRxBufferAddress;
|
||||
u16 PacketSize;
|
||||
u16 stmp, BufferSize, stmp2 = 0;
|
||||
u32 RxBufferId;
|
||||
|
@ -283,13 +280,13 @@ u16 Wb35Rx_indicate(phw_data_t pHwData)
|
|||
|
||||
// Parse the bulkin buffer
|
||||
while (BufferSize >= 4) {
|
||||
if ((cpu_to_le32(*(PULONG)pRxBufferAddress) & 0x0fffffff) == RX_END_TAG) //Is ending? 921002.9.a
|
||||
if ((cpu_to_le32(*(u32 *)pRxBufferAddress) & 0x0fffffff) == RX_END_TAG) //Is ending? 921002.9.a
|
||||
break;
|
||||
|
||||
// Get the R00 R01 first
|
||||
RxDes.R00.value = le32_to_cpu(*(PULONG)pRxBufferAddress);
|
||||
RxDes.R00.value = le32_to_cpu(*(u32 *)pRxBufferAddress);
|
||||
PacketSize = (u16)RxDes.R00.R00_receive_byte_count;
|
||||
RxDes.R01.value = le32_to_cpu(*((PULONG)(pRxBufferAddress+4)));
|
||||
RxDes.R01.value = le32_to_cpu(*((u32 *)(pRxBufferAddress+4)));
|
||||
// For new DMA 4k
|
||||
if ((PacketSize & 0x03) > 0)
|
||||
PacketSize -= 4;
|
||||
|
|
|
@ -41,7 +41,7 @@ typedef struct _WB35RX
|
|||
u32 Ep3ErrorCount2; // 20060625.1 Usbd for Rx DMA error count
|
||||
|
||||
int EP3VM_status;
|
||||
PUCHAR pDRx;
|
||||
u8 * pDRx;
|
||||
|
||||
} WB35RX, *PWB35RX;
|
||||
|
||||
|
|
|
@ -12,7 +12,7 @@
|
|||
|
||||
|
||||
unsigned char
|
||||
Wb35Tx_get_tx_buffer(phw_data_t pHwData, PUCHAR *pBuffer )
|
||||
Wb35Tx_get_tx_buffer(phw_data_t pHwData, u8 **pBuffer)
|
||||
{
|
||||
PWB35TX pWb35Tx = &pHwData->Wb35Tx;
|
||||
|
||||
|
@ -37,7 +37,7 @@ void Wb35Tx(phw_data_t pHwData)
|
|||
{
|
||||
PWB35TX pWb35Tx = &pHwData->Wb35Tx;
|
||||
PADAPTER Adapter = pHwData->Adapter;
|
||||
PUCHAR pTxBufferAddress;
|
||||
u8 *pTxBufferAddress;
|
||||
PMDS pMds = &Adapter->Mds;
|
||||
struct urb * pUrb = (struct urb *)pWb35Tx->Tx4Urb;
|
||||
int retv;
|
||||
|
@ -100,25 +100,24 @@ void Wb35Tx_complete(struct urb * pUrb)
|
|||
pWb35Tx->TxSendIndex++;
|
||||
pWb35Tx->TxSendIndex %= MAX_USB_TX_BUFFER_NUMBER;
|
||||
|
||||
do {
|
||||
if (pHwData->SurpriseRemove || pHwData->HwStop) // Let WbWlanHalt to handle surprise remove
|
||||
break;
|
||||
goto error;
|
||||
|
||||
if (pWb35Tx->tx_halt)
|
||||
break;
|
||||
goto error;
|
||||
|
||||
// The URB is completed, check the result
|
||||
if (pWb35Tx->EP4VM_status != 0) {
|
||||
printk("URB submission failed\n");
|
||||
pWb35Tx->EP4vm_state = VM_STOP;
|
||||
break; // Exit while(FALSE);
|
||||
goto error;
|
||||
}
|
||||
|
||||
Mds_Tx(Adapter);
|
||||
Wb35Tx(pHwData);
|
||||
return;
|
||||
} while(FALSE);
|
||||
|
||||
error:
|
||||
OS_ATOMIC_DEC( pHwData->Adapter, &pWb35Tx->TxFireCounter );
|
||||
pWb35Tx->EP4vm_state = VM_STOP;
|
||||
}
|
||||
|
@ -225,15 +224,14 @@ void Wb35Tx_EP2VM(phw_data_t pHwData)
|
|||
{
|
||||
PWB35TX pWb35Tx = &pHwData->Wb35Tx;
|
||||
struct urb * pUrb = (struct urb *)pWb35Tx->Tx2Urb;
|
||||
PULONG pltmp = (PULONG)pWb35Tx->EP2_buf;
|
||||
u32 * pltmp = (u32 *)pWb35Tx->EP2_buf;
|
||||
int retv;
|
||||
|
||||
do {
|
||||
if (pHwData->SurpriseRemove || pHwData->HwStop)
|
||||
break;
|
||||
goto error;
|
||||
|
||||
if (pWb35Tx->tx_halt)
|
||||
break;
|
||||
goto error;
|
||||
|
||||
//
|
||||
// Issuing URB
|
||||
|
@ -248,13 +246,11 @@ void Wb35Tx_EP2VM(phw_data_t pHwData)
|
|||
#ifdef _PE_TX_DUMP_
|
||||
WBDEBUG(("EP2 Tx Irp sending error\n"));
|
||||
#endif
|
||||
break;
|
||||
goto error;
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
} while(FALSE);
|
||||
|
||||
error:
|
||||
pWb35Tx->EP2vm_state = VM_STOP;
|
||||
OS_ATOMIC_DEC( pHwData->Adapter, &pWb35Tx->TxResultCount );
|
||||
}
|
||||
|
@ -266,7 +262,7 @@ void Wb35Tx_EP2VM_complete(struct urb * pUrb)
|
|||
T02_DESCRIPTOR T02, TSTATUS;
|
||||
PADAPTER Adapter = (PADAPTER)pHwData->Adapter;
|
||||
PWB35TX pWb35Tx = &pHwData->Wb35Tx;
|
||||
PULONG pltmp = (PULONG)pWb35Tx->EP2_buf;
|
||||
u32 * pltmp = (u32 *)pWb35Tx->EP2_buf;
|
||||
u32 i;
|
||||
u16 InterruptInLength;
|
||||
|
||||
|
@ -275,19 +271,18 @@ void Wb35Tx_EP2VM_complete(struct urb * pUrb)
|
|||
pWb35Tx->EP2vm_state = VM_COMPLETED;
|
||||
pWb35Tx->EP2VM_status = pUrb->status;
|
||||
|
||||
do {
|
||||
// For Linux 2.4. Interrupt will always trigger
|
||||
if (pHwData->SurpriseRemove || pHwData->HwStop) // Let WbWlanHalt to handle surprise remove
|
||||
break;
|
||||
goto error;
|
||||
|
||||
if (pWb35Tx->tx_halt)
|
||||
break;
|
||||
goto error;
|
||||
|
||||
//The Urb is completed, check the result
|
||||
if (pWb35Tx->EP2VM_status != 0) {
|
||||
WBDEBUG(("EP2 IoCompleteRoutine return error\n"));
|
||||
pWb35Tx->EP2vm_state= VM_STOP;
|
||||
break; // Exit while(FALSE);
|
||||
goto error;
|
||||
}
|
||||
|
||||
// Update the Tx result
|
||||
|
@ -305,8 +300,7 @@ void Wb35Tx_EP2VM_complete(struct urb * pUrb)
|
|||
}
|
||||
|
||||
return;
|
||||
} while(FALSE);
|
||||
|
||||
error:
|
||||
OS_ATOMIC_DEC( pHwData->Adapter, &pWb35Tx->TxResultCount );
|
||||
pWb35Tx->EP2vm_state = VM_STOP;
|
||||
}
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
//====================================
|
||||
unsigned char Wb35Tx_initial( phw_data_t pHwData );
|
||||
void Wb35Tx_destroy( phw_data_t pHwData );
|
||||
unsigned char Wb35Tx_get_tx_buffer( phw_data_t pHwData, PUCHAR *pBuffer );
|
||||
unsigned char Wb35Tx_get_tx_buffer( phw_data_t pHwData, u8 **pBuffer );
|
||||
|
||||
void Wb35Tx_EP2VM( phw_data_t pHwData );
|
||||
void Wb35Tx_EP2VM_start( phw_data_t pHwData );
|
||||
|
|
|
@ -6,18 +6,12 @@
|
|||
#include "sysdef.h"
|
||||
#include <net/mac80211.h>
|
||||
|
||||
|
||||
MODULE_AUTHOR(DRIVER_AUTHOR);
|
||||
MODULE_DESCRIPTION(DRIVER_DESC);
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_VERSION("0.1");
|
||||
|
||||
|
||||
//============================================================
|
||||
// vendor ID and product ID can into here for others
|
||||
//============================================================
|
||||
static struct usb_device_id Id_Table[] =
|
||||
{
|
||||
static struct usb_device_id wb35_table[] __devinitdata = {
|
||||
{USB_DEVICE(0x0416, 0x0035)},
|
||||
{USB_DEVICE(0x18E8, 0x6201)},
|
||||
{USB_DEVICE(0x18E8, 0x6206)},
|
||||
|
@ -25,23 +19,16 @@ static struct usb_device_id Id_Table[] =
|
|||
{USB_DEVICE(0x18E8, 0x6230)},
|
||||
{USB_DEVICE(0x18E8, 0x6233)},
|
||||
{USB_DEVICE(0x1131, 0x2035)},
|
||||
{ }
|
||||
{ 0, }
|
||||
};
|
||||
|
||||
MODULE_DEVICE_TABLE(usb, Id_Table);
|
||||
MODULE_DEVICE_TABLE(usb, wb35_table);
|
||||
|
||||
static struct usb_driver wb35_driver = {
|
||||
.name = "w35und",
|
||||
.probe = wb35_probe,
|
||||
.disconnect = wb35_disconnect,
|
||||
.id_table = Id_Table,
|
||||
};
|
||||
|
||||
static const struct ieee80211_rate wbsoft_rates[] = {
|
||||
static struct ieee80211_rate wbsoft_rates[] = {
|
||||
{ .bitrate = 10, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
|
||||
};
|
||||
|
||||
static const struct ieee80211_channel wbsoft_channels[] = {
|
||||
static struct ieee80211_channel wbsoft_channels[] = {
|
||||
{ .center_freq = 2412},
|
||||
};
|
||||
|
||||
|
@ -62,9 +49,22 @@ static void wbsoft_remove_interface(struct ieee80211_hw *dev,
|
|||
printk("wbsoft_remove interface called\n");
|
||||
}
|
||||
|
||||
static int wbsoft_nop(void)
|
||||
static void wbsoft_stop(struct ieee80211_hw *hw)
|
||||
{
|
||||
printk("wbsoft_nop called\n");
|
||||
printk(KERN_INFO "%s called\n", __func__);
|
||||
}
|
||||
|
||||
static int wbsoft_get_stats(struct ieee80211_hw *hw,
|
||||
struct ieee80211_low_level_stats *stats)
|
||||
{
|
||||
printk(KERN_INFO "%s called\n", __func__);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wbsoft_get_tx_stats(struct ieee80211_hw *hw,
|
||||
struct ieee80211_tx_queue_stats *stats)
|
||||
{
|
||||
printk(KERN_INFO "%s called\n", __func__);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -105,8 +105,7 @@ static void wbsoft_configure_filter(struct ieee80211_hw *dev,
|
|||
*total_flags = new_flags;
|
||||
}
|
||||
|
||||
static int wbsoft_tx(struct ieee80211_hw *dev, struct sk_buff *skb,
|
||||
struct ieee80211_tx_control *control)
|
||||
static int wbsoft_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
|
||||
{
|
||||
char *buffer = kmalloc(skb->len, GFP_ATOMIC);
|
||||
printk("Sending frame %d bytes\n", skb->len);
|
||||
|
@ -136,7 +135,7 @@ static int wbsoft_config(struct ieee80211_hw *dev, struct ieee80211_conf *conf)
|
|||
hal_set_current_channel(&my_adapter->sHwData, ch);
|
||||
hal_set_beacon_period(&my_adapter->sHwData, conf->beacon_int);
|
||||
// hal_set_cap_info(&my_adapter->sHwData, ?? );
|
||||
// hal_set_ssid(phw_data_t pHwData, PUCHAR pssid, u8 ssid_len); ??
|
||||
// hal_set_ssid(phw_data_t pHwData, u8 * pssid, u8 ssid_len); ??
|
||||
hal_set_accept_broadcast(&my_adapter->sHwData, 1);
|
||||
hal_set_accept_promiscuous(&my_adapter->sHwData, 1);
|
||||
hal_set_accept_multicast(&my_adapter->sHwData, 1);
|
||||
|
@ -148,7 +147,7 @@ static int wbsoft_config(struct ieee80211_hw *dev, struct ieee80211_conf *conf)
|
|||
|
||||
// hal_start_bss(&my_adapter->sHwData, WLAN_BSSTYPE_INFRASTRUCTURE); ??
|
||||
|
||||
//void hal_set_rates(phw_data_t pHwData, PUCHAR pbss_rates,
|
||||
//void hal_set_rates(phw_data_t pHwData, u8 * pbss_rates,
|
||||
// u8 length, unsigned char basic_rate_set)
|
||||
|
||||
return 0;
|
||||
|
@ -171,14 +170,14 @@ static u64 wbsoft_get_tsf(struct ieee80211_hw *dev)
|
|||
static const struct ieee80211_ops wbsoft_ops = {
|
||||
.tx = wbsoft_tx,
|
||||
.start = wbsoft_start, /* Start can be pretty much empty as we do WbWLanInitialize() during probe? */
|
||||
.stop = wbsoft_nop,
|
||||
.stop = wbsoft_stop,
|
||||
.add_interface = wbsoft_add_interface,
|
||||
.remove_interface = wbsoft_remove_interface,
|
||||
.config = wbsoft_config,
|
||||
.config_interface = wbsoft_config_interface,
|
||||
.configure_filter = wbsoft_configure_filter,
|
||||
.get_stats = wbsoft_nop,
|
||||
.get_tx_stats = wbsoft_nop,
|
||||
.get_stats = wbsoft_get_stats,
|
||||
.get_tx_stats = wbsoft_get_tx_stats,
|
||||
.get_tsf = wbsoft_get_tsf,
|
||||
// conf_tx: hal_set_cwmin()/hal_set_cwmax;
|
||||
};
|
||||
|
@ -187,21 +186,6 @@ struct wbsoft_priv {
|
|||
};
|
||||
|
||||
|
||||
int __init wb35_init(void)
|
||||
{
|
||||
printk("[w35und]driver init\n");
|
||||
return usb_register(&wb35_driver);
|
||||
}
|
||||
|
||||
void __exit wb35_exit(void)
|
||||
{
|
||||
printk("[w35und]driver exit\n");
|
||||
usb_deregister( &wb35_driver );
|
||||
}
|
||||
|
||||
module_init(wb35_init);
|
||||
module_exit(wb35_exit);
|
||||
|
||||
// Usb kernel subsystem will call this function when a new device is plugged into.
|
||||
int wb35_probe(struct usb_interface *intf, const struct usb_device_id *id_table)
|
||||
{
|
||||
|
@ -210,7 +194,7 @@ int wb35_probe(struct usb_interface *intf, const struct usb_device_id *id_table)
|
|||
PWBUSB pWbUsb;
|
||||
struct usb_host_interface *interface;
|
||||
struct usb_endpoint_descriptor *endpoint;
|
||||
int i, ret = -1;
|
||||
int ret = -1;
|
||||
u32 ltmp;
|
||||
struct usb_device *udev = interface_to_usbdev(intf);
|
||||
|
||||
|
@ -218,32 +202,16 @@ int wb35_probe(struct usb_interface *intf, const struct usb_device_id *id_table)
|
|||
|
||||
printk("[w35und]wb35_probe ->\n");
|
||||
|
||||
do {
|
||||
for (i=0; i<(sizeof(Id_Table)/sizeof(struct usb_device_id)); i++ ) {
|
||||
if ((udev->descriptor.idVendor == Id_Table[i].idVendor) &&
|
||||
(udev->descriptor.idProduct == Id_Table[i].idProduct)) {
|
||||
printk("[w35und]Found supported hardware\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ((i == (sizeof(Id_Table)/sizeof(struct usb_device_id)))) {
|
||||
#ifdef _PE_USB_INI_DUMP_
|
||||
WBDEBUG(("[w35und] This is not the one we are interested about\n"));
|
||||
#endif
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
// 20060630.2 Check the device if it already be opened
|
||||
ret = usb_control_msg(udev, usb_rcvctrlpipe( udev, 0 ),
|
||||
0x01, USB_TYPE_VENDOR|USB_RECIP_DEVICE|USB_DIR_IN,
|
||||
0x0, 0x400, <mp, 4, HZ*100 );
|
||||
if (ret < 0)
|
||||
break;
|
||||
goto error;
|
||||
|
||||
ltmp = cpu_to_le32(ltmp);
|
||||
if (ltmp) // Is already initialized?
|
||||
break;
|
||||
|
||||
goto error;
|
||||
|
||||
Adapter = kzalloc(sizeof(ADAPTER), GFP_KERNEL);
|
||||
|
||||
|
@ -262,12 +230,13 @@ int wb35_probe(struct usb_interface *intf, const struct usb_device_id *id_table)
|
|||
|
||||
if (!WbWLanInitialize(Adapter)) {
|
||||
printk("[w35und]WbWLanInitialize fail\n");
|
||||
break;
|
||||
goto error;
|
||||
}
|
||||
|
||||
{
|
||||
struct wbsoft_priv *priv;
|
||||
struct ieee80211_hw *dev;
|
||||
static struct ieee80211_supported_band band;
|
||||
int res;
|
||||
|
||||
dev = ieee80211_alloc_hw(sizeof(*priv), &wbsoft_ops);
|
||||
|
@ -296,8 +265,6 @@ int wb35_probe(struct usb_interface *intf, const struct usb_device_id *id_table)
|
|||
|
||||
dev->queues = 1;
|
||||
|
||||
static struct ieee80211_supported_band band;
|
||||
|
||||
band.channels = wbsoft_channels;
|
||||
band.n_channels = ARRAY_SIZE(wbsoft_channels);
|
||||
band.bitrates = wbsoft_rates;
|
||||
|
@ -323,9 +290,7 @@ int wb35_probe(struct usb_interface *intf, const struct usb_device_id *id_table)
|
|||
|
||||
printk("[w35und] _probe OK\n");
|
||||
return 0;
|
||||
|
||||
} while(FALSE);
|
||||
|
||||
error:
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
|
@ -401,4 +366,22 @@ void wb35_disconnect(struct usb_interface *intf)
|
|||
|
||||
}
|
||||
|
||||
static struct usb_driver wb35_driver = {
|
||||
.name = "w35und",
|
||||
.id_table = wb35_table,
|
||||
.probe = wb35_probe,
|
||||
.disconnect = wb35_disconnect,
|
||||
};
|
||||
|
||||
static int __init wb35_init(void)
|
||||
{
|
||||
return usb_register(&wb35_driver);
|
||||
}
|
||||
|
||||
static void __exit wb35_exit(void)
|
||||
{
|
||||
usb_deregister(&wb35_driver);
|
||||
}
|
||||
|
||||
module_init(wb35_init);
|
||||
module_exit(wb35_exit);
|
||||
|
|
|
@ -40,7 +40,7 @@ Mds_Tx(PADAPTER Adapter)
|
|||
PMDS pMds = &Adapter->Mds;
|
||||
DESCRIPTOR TxDes;
|
||||
PDESCRIPTOR pTxDes = &TxDes;
|
||||
PUCHAR XmitBufAddress;
|
||||
u8 *XmitBufAddress;
|
||||
u16 XmitBufSize, PacketSize, stmp, CurrentSize, FragmentThreshold;
|
||||
u8 FillIndex, TxDesIndex, FragmentCount, FillCount;
|
||||
unsigned char BufferFilled = FALSE, MICAdd = 0;
|
||||
|
@ -90,7 +90,7 @@ Mds_Tx(PADAPTER Adapter)
|
|||
BufferFilled = TRUE;
|
||||
|
||||
/* Leaves first u8 intact */
|
||||
memset((PUCHAR)pTxDes + 1, 0, sizeof(DESCRIPTOR) - 1);
|
||||
memset((u8 *)pTxDes + 1, 0, sizeof(DESCRIPTOR) - 1);
|
||||
|
||||
TxDesIndex = pMds->TxDesIndex;//Get the current ID
|
||||
pTxDes->Descriptor_ID = TxDesIndex;
|
||||
|
@ -229,10 +229,10 @@ Mds_SendComplete(PADAPTER Adapter, PT02_DESCRIPTOR pT02)
|
|||
}
|
||||
|
||||
void
|
||||
Mds_HeaderCopy(PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer)
|
||||
Mds_HeaderCopy(PADAPTER Adapter, PDESCRIPTOR pDes, u8 *TargetBuffer)
|
||||
{
|
||||
PMDS pMds = &Adapter->Mds;
|
||||
PUCHAR src_buffer = pDes->buffer_address[0];//931130.5.g
|
||||
u8 *src_buffer = pDes->buffer_address[0];//931130.5.g
|
||||
PT00_DESCRIPTOR pT00;
|
||||
PT01_DESCRIPTOR pT01;
|
||||
u16 stmp;
|
||||
|
@ -276,7 +276,7 @@ Mds_HeaderCopy(PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer)
|
|||
//
|
||||
// Set tx rate
|
||||
//
|
||||
stmp = *(PUSHORT)(TargetBuffer+30); // 2n alignment address
|
||||
stmp = *(u16 *)(TargetBuffer+30); // 2n alignment address
|
||||
|
||||
//Use basic rate
|
||||
ctmp1 = ctmpf = CURRENT_TX_RATE_FOR_MNG;
|
||||
|
@ -326,11 +326,13 @@ Mds_HeaderCopy(PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer)
|
|||
|
||||
// The function return the 4n size of usb pk
|
||||
u16
|
||||
Mds_BodyCopy(PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer)
|
||||
Mds_BodyCopy(PADAPTER Adapter, PDESCRIPTOR pDes, u8 *TargetBuffer)
|
||||
{
|
||||
PT00_DESCRIPTOR pT00;
|
||||
PMDS pMds = &Adapter->Mds;
|
||||
PUCHAR buffer, src_buffer, pctmp;
|
||||
u8 *buffer;
|
||||
u8 *src_buffer;
|
||||
u8 *pctmp;
|
||||
u16 Size = 0;
|
||||
u16 SizeLeft, CopySize, CopyLeft, stmp;
|
||||
u8 buf_index, FragmentCount = 0;
|
||||
|
@ -354,7 +356,7 @@ Mds_BodyCopy(PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer)
|
|||
SizeLeft -= CopySize;
|
||||
|
||||
// 1 Byte operation
|
||||
pctmp = (PUCHAR)( buffer + 8 + DOT_11_SEQUENCE_OFFSET );
|
||||
pctmp = (u8 *)( buffer + 8 + DOT_11_SEQUENCE_OFFSET );
|
||||
*pctmp &= 0xf0;
|
||||
*pctmp |= FragmentCount;//931130.5.m
|
||||
if( !FragmentCount )
|
||||
|
@ -379,7 +381,7 @@ Mds_BodyCopy(PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer)
|
|||
buf_index++;
|
||||
buf_index %= MAX_DESCRIPTOR_BUFFER_INDEX;
|
||||
} else {
|
||||
PUCHAR pctmp = pDes->buffer_address[buf_index];
|
||||
u8 *pctmp = pDes->buffer_address[buf_index];
|
||||
pctmp += CopySize;
|
||||
pDes->buffer_address[buf_index] = pctmp;
|
||||
pDes->buffer_size[buf_index] -= CopySize;
|
||||
|
@ -419,7 +421,7 @@ Mds_BodyCopy(PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer)
|
|||
|
||||
pT00->T00_last_mpdu = 1;
|
||||
pT00->T00_IsLastMpdu = 1;
|
||||
buffer = (PUCHAR)pT00 + 8; // +8 for USB hdr
|
||||
buffer = (u8 *)pT00 + 8; // +8 for USB hdr
|
||||
buffer[1] &= ~0x04; // Clear more frag bit of 802.11 frame control
|
||||
pDes->FragmentCount = FragmentCount; // Update the correct fragment number
|
||||
return Size;
|
||||
|
@ -427,7 +429,7 @@ Mds_BodyCopy(PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer)
|
|||
|
||||
|
||||
void
|
||||
Mds_DurationSet( PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR buffer )
|
||||
Mds_DurationSet( PADAPTER Adapter, PDESCRIPTOR pDes, u8 *buffer )
|
||||
{
|
||||
PT00_DESCRIPTOR pT00;
|
||||
PT01_DESCRIPTOR pT01;
|
||||
|
@ -435,7 +437,7 @@ Mds_DurationSet( PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR buffer )
|
|||
u8 Rate, i;
|
||||
unsigned char CTS_on = FALSE, RTS_on = FALSE;
|
||||
PT00_DESCRIPTOR pNextT00;
|
||||
u16 BodyLen;
|
||||
u16 BodyLen = 0;
|
||||
unsigned char boGroupAddr = FALSE;
|
||||
|
||||
|
||||
|
@ -574,7 +576,7 @@ Mds_DurationSet( PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR buffer )
|
|||
DEFAULT_SIFSTIME*3 );
|
||||
}
|
||||
|
||||
((PUSHORT)buffer)[5] = cpu_to_le16(Duration);// 4 USHOR for skip 8B USB, 2USHORT=FC + Duration
|
||||
((u16 *)buffer)[5] = cpu_to_le16(Duration);// 4 USHOR for skip 8B USB, 2USHORT=FC + Duration
|
||||
|
||||
//----20061009 add by anson's endian
|
||||
pNextT00->value = cpu_to_le32(pNextT00->value);
|
||||
|
@ -615,7 +617,7 @@ Mds_DurationSet( PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR buffer )
|
|||
}
|
||||
}
|
||||
|
||||
((PUSHORT)buffer)[5] = cpu_to_le16(Duration);// 4 USHOR for skip 8B USB, 2USHORT=FC + Duration
|
||||
((u16 *)buffer)[5] = cpu_to_le16(Duration);// 4 USHOR for skip 8B USB, 2USHORT=FC + Duration
|
||||
pT00->value = cpu_to_le32(pT00->value);
|
||||
pT01->value = cpu_to_le32(pT01->value);
|
||||
//--end 20061009 add
|
||||
|
|
|
@ -1,9 +1,9 @@
|
|||
unsigned char Mds_initial( PADAPTER Adapter );
|
||||
void Mds_Destroy( PADAPTER Adapter );
|
||||
void Mds_Tx( PADAPTER Adapter );
|
||||
void Mds_HeaderCopy( PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer );
|
||||
u16 Mds_BodyCopy( PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer );
|
||||
void Mds_DurationSet( PADAPTER Adapter, PDESCRIPTOR pDes, PUCHAR TargetBuffer );
|
||||
void Mds_HeaderCopy( PADAPTER Adapter, PDESCRIPTOR pDes, u8 *TargetBuffer );
|
||||
u16 Mds_BodyCopy( PADAPTER Adapter, PDESCRIPTOR pDes, u8 *TargetBuffer );
|
||||
void Mds_DurationSet( PADAPTER Adapter, PDESCRIPTOR pDes, u8 *TargetBuffer );
|
||||
void Mds_SendComplete( PADAPTER Adapter, PT02_DESCRIPTOR pT02 );
|
||||
void Mds_MpduProcess( PADAPTER Adapter, PDESCRIPTOR pRxDes );
|
||||
void Mds_reset_descriptor( PADAPTER Adapter );
|
||||
|
|
|
@ -86,7 +86,7 @@ typedef struct _MDS
|
|||
{
|
||||
// For Tx usage
|
||||
u8 TxOwner[ ((MAX_USB_TX_BUFFER_NUMBER + 3) & ~0x03) ];
|
||||
PUCHAR pTxBuffer;
|
||||
u8 *pTxBuffer;
|
||||
u16 TxBufferSize[ ((MAX_USB_TX_BUFFER_NUMBER + 1) & ~0x01) ];
|
||||
u8 TxDesFrom[ ((MAX_USB_TX_DESCRIPTOR + 3) & ~0x03) ];//931130.4.u // 1: MLME 2: NDIS control 3: NDIS data
|
||||
u8 TxCountInBuffer[ ((MAX_USB_TX_DESCRIPTOR + 3) & ~0x03) ]; // 20060928
|
||||
|
@ -103,7 +103,7 @@ typedef struct _MDS
|
|||
u16 TxResult[ ((MAX_USB_TX_DESCRIPTOR + 1) & ~0x01) ];//Collect the sending result of Mpdu
|
||||
|
||||
u8 MicRedundant[8]; // For tmp use
|
||||
PUCHAR MicWriteAddress[2]; //The start address to fill the Mic, use 2 point due to Mic maybe fragment
|
||||
u8 *MicWriteAddress[2]; //The start address to fill the Mic, use 2 point due to Mic maybe fragment
|
||||
|
||||
u16 MicWriteSize[2]; //931130.4.x
|
||||
|
||||
|
@ -144,7 +144,7 @@ typedef struct _MDS
|
|||
|
||||
typedef struct _RxBuffer
|
||||
{
|
||||
PUCHAR pBufferAddress; // Pointer the received data buffer.
|
||||
u8 * pBufferAddress; // Pointer the received data buffer.
|
||||
u16 BufferSize;
|
||||
u8 RESERVED;
|
||||
u8 BufferIndex;// Only 1 byte
|
||||
|
@ -176,7 +176,7 @@ typedef struct _RXLAYER1
|
|||
/////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// For brand-new Rx system
|
||||
u8 ReservedBuffer[ 2400 ];//If Buffer ID is reserved one, it must copy the data into this area
|
||||
PUCHAR ReservedBufferPoint;// Point to the next availabe address of reserved buffer
|
||||
u8 *ReservedBufferPoint;// Point to the next availabe address of reserved buffer
|
||||
|
||||
}RXLAYER1, * PRXLAYER1;
|
||||
|
||||
|
|
|
@ -125,12 +125,12 @@
|
|||
typedef struct _MLME_FRAME
|
||||
{
|
||||
//NDIS_PACKET MLME_Packet;
|
||||
PCHAR pMMPDU;
|
||||
s8 * pMMPDU;
|
||||
u16 len;
|
||||
u8 DataType;
|
||||
u8 IsInUsed;
|
||||
|
||||
OS_SPIN_LOCK MLMESpinLock;
|
||||
spinlock_t MLMESpinLock;
|
||||
|
||||
u8 TxMMPDU[MAX_NUM_TX_MMPDU][MAX_MMPDU_SIZE];
|
||||
u8 TxMMPDUInUse[ (MAX_NUM_TX_MMPDU+3) & ~0x03 ];
|
||||
|
|
|
@ -113,13 +113,13 @@ MLME_GetNextPacket(PADAPTER Adapter, PDESCRIPTOR pDes)
|
|||
pDes->Type = Adapter->sMlmeFrame.DataType;
|
||||
}
|
||||
|
||||
void MLMEfreeMMPDUBuffer(PWB32_ADAPTER Adapter, PCHAR pData)
|
||||
void MLMEfreeMMPDUBuffer(PWB32_ADAPTER Adapter, s8 *pData)
|
||||
{
|
||||
int i;
|
||||
|
||||
// Reclaim the data buffer
|
||||
for (i = 0; i < MAX_NUM_TX_MMPDU; i++) {
|
||||
if (pData == (PCHAR)&(Adapter->sMlmeFrame.TxMMPDU[i]))
|
||||
if (pData == (s8 *)&(Adapter->sMlmeFrame.TxMMPDU[i]))
|
||||
break;
|
||||
}
|
||||
if (Adapter->sMlmeFrame.TxMMPDUInUse[i])
|
||||
|
|
|
@ -20,7 +20,7 @@ MLMEGetMMPDUBuffer(
|
|||
PWB32_ADAPTER Adapter
|
||||
);
|
||||
|
||||
void MLMEfreeMMPDUBuffer( PWB32_ADAPTER Adapter, PCHAR pData);
|
||||
void MLMEfreeMMPDUBuffer( PWB32_ADAPTER Adapter, s8 * pData);
|
||||
|
||||
void MLME_GetNextPacket( PADAPTER Adapter, PDESCRIPTOR pDes );
|
||||
u8 MLMESendFrame( PWB32_ADAPTER Adapter,
|
||||
|
@ -42,7 +42,7 @@ MLMERcvFrame(
|
|||
void
|
||||
MLMEReturnPacket(
|
||||
PWB32_ADAPTER Adapter,
|
||||
PUCHAR pRxBufer
|
||||
u8 * pRxBufer
|
||||
);
|
||||
#ifdef _IBSS_BEACON_SEQ_STICK_
|
||||
s8 SendBCNullData(PWB32_ADAPTER Adapter, u16 wIdx);
|
||||
|
|
|
@ -922,16 +922,16 @@ Uxx_ReadEthernetAddress( phw_data_t pHwData )
|
|||
// Only unplug and plug again can make hardware read EEPROM again. 20060727
|
||||
Wb35Reg_WriteSync( pHwData, 0x03b4, 0x08000000 ); // Start EEPROM access + Read + address(0x0d)
|
||||
Wb35Reg_ReadSync( pHwData, 0x03b4, <mp );
|
||||
*(PUSHORT)pHwData->PermanentMacAddress = cpu_to_le16((u16)ltmp); //20060926 anson's endian
|
||||
*(u16 *)pHwData->PermanentMacAddress = cpu_to_le16((u16)ltmp); //20060926 anson's endian
|
||||
Wb35Reg_WriteSync( pHwData, 0x03b4, 0x08010000 ); // Start EEPROM access + Read + address(0x0d)
|
||||
Wb35Reg_ReadSync( pHwData, 0x03b4, <mp );
|
||||
*(PUSHORT)(pHwData->PermanentMacAddress + 2) = cpu_to_le16((u16)ltmp); //20060926 anson's endian
|
||||
*(u16 *)(pHwData->PermanentMacAddress + 2) = cpu_to_le16((u16)ltmp); //20060926 anson's endian
|
||||
Wb35Reg_WriteSync( pHwData, 0x03b4, 0x08020000 ); // Start EEPROM access + Read + address(0x0d)
|
||||
Wb35Reg_ReadSync( pHwData, 0x03b4, <mp );
|
||||
*(PUSHORT)(pHwData->PermanentMacAddress + 4) = cpu_to_le16((u16)ltmp); //20060926 anson's endian
|
||||
*(PUSHORT)(pHwData->PermanentMacAddress + 6) = 0;
|
||||
Wb35Reg_WriteSync( pHwData, 0x03e8, cpu_to_le32(*(PULONG)pHwData->PermanentMacAddress) ); //20060926 anson's endian
|
||||
Wb35Reg_WriteSync( pHwData, 0x03ec, cpu_to_le32(*(PULONG)(pHwData->PermanentMacAddress+4)) ); //20060926 anson's endian
|
||||
*(u16 *)(pHwData->PermanentMacAddress + 4) = cpu_to_le16((u16)ltmp); //20060926 anson's endian
|
||||
*(u16 *)(pHwData->PermanentMacAddress + 6) = 0;
|
||||
Wb35Reg_WriteSync( pHwData, 0x03e8, cpu_to_le32(*(u32 *)pHwData->PermanentMacAddress) ); //20060926 anson's endian
|
||||
Wb35Reg_WriteSync( pHwData, 0x03ec, cpu_to_le32(*(u32 *)(pHwData->PermanentMacAddress+4)) ); //20060926 anson's endian
|
||||
}
|
||||
|
||||
|
||||
|
@ -1038,7 +1038,7 @@ void
|
|||
RFSynthesizer_initial(phw_data_t pHwData)
|
||||
{
|
||||
u32 altmp[32];
|
||||
PULONG pltmp = altmp;
|
||||
u32 * pltmp = altmp;
|
||||
u32 ltmp;
|
||||
u8 number=0x00; // The number of register vale
|
||||
u8 i;
|
||||
|
@ -2358,11 +2358,11 @@ void Mxx_initial( phw_data_t pHwData )
|
|||
pltmp[2] = pWb35Reg->M2C_MacControl;
|
||||
|
||||
// M30 BSSID
|
||||
pltmp[3] = *(PULONG)pHwData->bssid;
|
||||
pltmp[3] = *(u32 *)pHwData->bssid;
|
||||
|
||||
// M34
|
||||
pHwData->AID = DEFAULT_AID;
|
||||
tmp = *(PUSHORT)(pHwData->bssid+4);
|
||||
tmp = *(u16 *)(pHwData->bssid+4);
|
||||
tmp |= DEFAULT_AID << 16;
|
||||
pltmp[4] = tmp;
|
||||
|
||||
|
@ -2428,7 +2428,7 @@ void GetTxVgaFromEEPROM( phw_data_t pHwData )
|
|||
{
|
||||
u32 i, j, ltmp;
|
||||
u16 Value[MAX_TXVGA_EEPROM];
|
||||
PUCHAR pctmp;
|
||||
u8 *pctmp;
|
||||
u8 ctmp=0;
|
||||
|
||||
// Get the entire TxVga setting in EEPROM
|
||||
|
@ -2441,7 +2441,7 @@ void GetTxVgaFromEEPROM( phw_data_t pHwData )
|
|||
}
|
||||
|
||||
// Adjust the filed which fills with reserved value.
|
||||
pctmp = (PUCHAR)Value;
|
||||
pctmp = (u8 *)Value;
|
||||
for( i=0; i<(MAX_TXVGA_EEPROM*2); i++ )
|
||||
{
|
||||
if( pctmp[i] != 0xff )
|
||||
|
@ -2480,7 +2480,7 @@ void GetTxVgaFromEEPROM( phw_data_t pHwData )
|
|||
// This function will use default TxVgaSettingInEEPROM data to calculate new TxVga.
|
||||
void EEPROMTxVgaAdjust( phw_data_t pHwData ) // 20060619.5 Add
|
||||
{
|
||||
PUCHAR pTxVga = pHwData->TxVgaSettingInEEPROM;
|
||||
u8 * pTxVga = pHwData->TxVgaSettingInEEPROM;
|
||||
s16 i, stmp;
|
||||
|
||||
//-- 2.4G -- 20060704.2 Request from Tiger
|
||||
|
|
|
@ -10,4 +10,5 @@
|
|||
s8 sme_get_rssi(void *pcore_data, s32 *prssi)
|
||||
{
|
||||
BUG();
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -208,7 +208,7 @@ s8 sme_set_tx_antenna(void *pcore_data, u32 TxAntenna);
|
|||
s8 sme_set_IBSS_chan(void *pcore_data, ChanInfo chan);
|
||||
|
||||
//20061108 WPS
|
||||
s8 sme_set_IE_append(void *pcore_data, PUCHAR buffer, u16 buf_len);
|
||||
s8 sme_set_IE_append(void *pcore_data, u8 *buffer, u16 buf_len);
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -1,13 +1,13 @@
|
|||
#include "os_common.h"
|
||||
|
||||
void hal_get_ethernet_address( phw_data_t pHwData, PUCHAR current_address )
|
||||
void hal_get_ethernet_address( phw_data_t pHwData, u8 *current_address )
|
||||
{
|
||||
if( pHwData->SurpriseRemove ) return;
|
||||
|
||||
memcpy( current_address, pHwData->CurrentMacAddress, ETH_LENGTH_OF_ADDRESS );
|
||||
}
|
||||
|
||||
void hal_set_ethernet_address( phw_data_t pHwData, PUCHAR current_address )
|
||||
void hal_set_ethernet_address( phw_data_t pHwData, u8 *current_address )
|
||||
{
|
||||
u32 ltmp[2];
|
||||
|
||||
|
@ -15,13 +15,13 @@ void hal_set_ethernet_address( phw_data_t pHwData, PUCHAR current_address )
|
|||
|
||||
memcpy( pHwData->CurrentMacAddress, current_address, ETH_LENGTH_OF_ADDRESS );
|
||||
|
||||
ltmp[0]= cpu_to_le32( *(PULONG)pHwData->CurrentMacAddress );
|
||||
ltmp[1]= cpu_to_le32( *(PULONG)(pHwData->CurrentMacAddress + 4) ) & 0xffff;
|
||||
ltmp[0]= cpu_to_le32( *(u32 *)pHwData->CurrentMacAddress );
|
||||
ltmp[1]= cpu_to_le32( *(u32 *)(pHwData->CurrentMacAddress + 4) ) & 0xffff;
|
||||
|
||||
Wb35Reg_BurstWrite( pHwData, 0x03e8, ltmp, 2, AUTO_INCREMENT );
|
||||
}
|
||||
|
||||
void hal_get_permanent_address( phw_data_t pHwData, PUCHAR pethernet_address )
|
||||
void hal_get_permanent_address( phw_data_t pHwData, u8 *pethernet_address )
|
||||
{
|
||||
if( pHwData->SurpriseRemove ) return;
|
||||
|
||||
|
@ -89,7 +89,7 @@ void hal_halt(phw_data_t pHwData, void *ppa_data)
|
|||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------------
|
||||
void hal_set_rates(phw_data_t pHwData, PUCHAR pbss_rates,
|
||||
void hal_set_rates(phw_data_t pHwData, u8 *pbss_rates,
|
||||
u8 length, unsigned char basic_rate_set)
|
||||
{
|
||||
PWB35REG pWb35Reg = &pHwData->Wb35Reg;
|
||||
|
@ -158,13 +158,13 @@ void hal_set_rates(phw_data_t pHwData, PUCHAR pbss_rates,
|
|||
// Fill data into support rate until buffer full
|
||||
//---20060926 add by anson's endian
|
||||
for (i=0; i<4; i++)
|
||||
*(PULONG)(SupportedRate+(i<<2)) = cpu_to_le32( *(PULONG)(SupportedRate+(i<<2)) );
|
||||
*(u32 *)(SupportedRate+(i<<2)) = cpu_to_le32( *(u32 *)(SupportedRate+(i<<2)) );
|
||||
//--- end 20060926 add by anson's endian
|
||||
Wb35Reg_BurstWrite( pHwData,0x087c, (PULONG)SupportedRate, 4, AUTO_INCREMENT );
|
||||
pWb35Reg->M7C_MacControl = ((PULONG)SupportedRate)[0];
|
||||
pWb35Reg->M80_MacControl = ((PULONG)SupportedRate)[1];
|
||||
pWb35Reg->M84_MacControl = ((PULONG)SupportedRate)[2];
|
||||
pWb35Reg->M88_MacControl = ((PULONG)SupportedRate)[3];
|
||||
Wb35Reg_BurstWrite( pHwData,0x087c, (u32 *)SupportedRate, 4, AUTO_INCREMENT );
|
||||
pWb35Reg->M7C_MacControl = ((u32 *)SupportedRate)[0];
|
||||
pWb35Reg->M80_MacControl = ((u32 *)SupportedRate)[1];
|
||||
pWb35Reg->M84_MacControl = ((u32 *)SupportedRate)[2];
|
||||
pWb35Reg->M88_MacControl = ((u32 *)SupportedRate)[3];
|
||||
|
||||
// Fill length
|
||||
tmp = Count1<<28 | Count2<<24;
|
||||
|
@ -206,7 +206,7 @@ void hal_set_current_channel_ex( phw_data_t pHwData, ChanInfo channel )
|
|||
pWb35Reg->M28_MacControl &= ~0xff; // Clean channel information field
|
||||
pWb35Reg->M28_MacControl |= channel.ChanNo;
|
||||
Wb35Reg_WriteWithCallbackValue( pHwData, 0x0828, pWb35Reg->M28_MacControl,
|
||||
(PCHAR)&channel, sizeof(ChanInfo));
|
||||
(s8 *)&channel, sizeof(ChanInfo));
|
||||
}
|
||||
//---------------------------------------------------------------------------------------------------
|
||||
void hal_set_current_channel( phw_data_t pHwData, ChanInfo channel )
|
||||
|
@ -277,7 +277,7 @@ void hal_set_accept_beacon( phw_data_t pHwData, u8 enable )
|
|||
Wb35Reg_Write( pHwData, 0x0800, pWb35Reg->M00_MacControl );
|
||||
}
|
||||
//---------------------------------------------------------------------------------------------------
|
||||
void hal_set_multicast_address( phw_data_t pHwData, PUCHAR address, u8 number )
|
||||
void hal_set_multicast_address( phw_data_t pHwData, u8 *address, u8 number )
|
||||
{
|
||||
PWB35REG pWb35Reg = &pHwData->Wb35Reg;
|
||||
u8 Byte, Bit;
|
||||
|
@ -297,7 +297,7 @@ void hal_set_multicast_address( phw_data_t pHwData, PUCHAR address, u8 number )
|
|||
}
|
||||
|
||||
// Updating register
|
||||
Wb35Reg_BurstWrite( pHwData, 0x0804, (PULONG)pWb35Reg->Multicast, 2, AUTO_INCREMENT );
|
||||
Wb35Reg_BurstWrite( pHwData, 0x0804, (u32 *)pWb35Reg->Multicast, 2, AUTO_INCREMENT );
|
||||
}
|
||||
//---------------------------------------------------------------------------------------------------
|
||||
u8 hal_get_accept_beacon( phw_data_t pHwData )
|
||||
|
@ -806,7 +806,7 @@ u8 hal_get_hw_radio_off( phw_data_t pHwData )
|
|||
}
|
||||
}
|
||||
|
||||
unsigned char hal_get_dxx_reg( phw_data_t pHwData, u16 number, PULONG pValue )
|
||||
unsigned char hal_get_dxx_reg( phw_data_t pHwData, u16 number, u32 * pValue )
|
||||
{
|
||||
if( number < 0x1000 )
|
||||
number += 0x1000;
|
||||
|
|
|
@ -16,23 +16,23 @@
|
|||
//====================================================================================
|
||||
// Function declaration
|
||||
//====================================================================================
|
||||
void hal_remove_mapping_key( phw_data_t pHwData, PUCHAR pmac_addr );
|
||||
void hal_remove_mapping_key( phw_data_t pHwData, u8 *pmac_addr );
|
||||
void hal_remove_default_key( phw_data_t pHwData, u32 index );
|
||||
unsigned char hal_set_mapping_key( phw_data_t Adapter, PUCHAR pmac_addr, u8 null_key, u8 wep_on, PUCHAR ptx_tsc, PUCHAR prx_tsc, u8 key_type, u8 key_len, PUCHAR pkey_data );
|
||||
unsigned char hal_set_default_key( phw_data_t Adapter, u8 index, u8 null_key, u8 wep_on, PUCHAR ptx_tsc, PUCHAR prx_tsc, u8 key_type, u8 key_len, PUCHAR pkey_data );
|
||||
unsigned char hal_set_mapping_key( phw_data_t Adapter, u8 *pmac_addr, u8 null_key, u8 wep_on, u8 *ptx_tsc, u8 *prx_tsc, u8 key_type, u8 key_len, u8 *pkey_data );
|
||||
unsigned char hal_set_default_key( phw_data_t Adapter, u8 index, u8 null_key, u8 wep_on, u8 *ptx_tsc, u8 *prx_tsc, u8 key_type, u8 key_len, u8 *pkey_data );
|
||||
void hal_clear_all_default_key( phw_data_t pHwData );
|
||||
void hal_clear_all_group_key( phw_data_t pHwData );
|
||||
void hal_clear_all_mapping_key( phw_data_t pHwData );
|
||||
void hal_clear_all_key( phw_data_t pHwData );
|
||||
void hal_get_ethernet_address( phw_data_t pHwData, PUCHAR current_address );
|
||||
void hal_set_ethernet_address( phw_data_t pHwData, PUCHAR current_address );
|
||||
void hal_get_permanent_address( phw_data_t pHwData, PUCHAR pethernet_address );
|
||||
void hal_get_ethernet_address( phw_data_t pHwData, u8 *current_address );
|
||||
void hal_set_ethernet_address( phw_data_t pHwData, u8 *current_address );
|
||||
void hal_get_permanent_address( phw_data_t pHwData, u8 *pethernet_address );
|
||||
unsigned char hal_init_hardware( phw_data_t pHwData, PADAPTER Adapter );
|
||||
void hal_set_power_save_mode( phw_data_t pHwData, unsigned char power_save, unsigned char wakeup, unsigned char dtim );
|
||||
void hal_get_power_save_mode( phw_data_t pHwData, PBOOLEAN pin_pwr_save );
|
||||
void hal_get_power_save_mode( phw_data_t pHwData, u8 *pin_pwr_save );
|
||||
void hal_set_slot_time( phw_data_t pHwData, u8 type );
|
||||
#define hal_set_atim_window( _A, _ATM )
|
||||
void hal_set_rates( phw_data_t pHwData, PUCHAR pbss_rates, u8 length, unsigned char basic_rate_set );
|
||||
void hal_set_rates( phw_data_t pHwData, u8 *pbss_rates, u8 length, unsigned char basic_rate_set );
|
||||
#define hal_set_basic_rates( _A, _R, _L ) hal_set_rates( _A, _R, _L, TRUE )
|
||||
#define hal_set_op_rates( _A, _R, _L ) hal_set_rates( _A, _R, _L, FALSE )
|
||||
void hal_start_bss( phw_data_t pHwData, u8 mac_op_mode );
|
||||
|
@ -40,19 +40,19 @@ void hal_join_request( phw_data_t pHwData, u8 bss_type ); // 0:BSS STA 1:IBSS
|
|||
void hal_stop_sync_bss( phw_data_t pHwData );
|
||||
void hal_resume_sync_bss( phw_data_t pHwData);
|
||||
void hal_set_aid( phw_data_t pHwData, u16 aid );
|
||||
void hal_set_bssid( phw_data_t pHwData, PUCHAR pbssid );
|
||||
void hal_get_bssid( phw_data_t pHwData, PUCHAR pbssid );
|
||||
void hal_set_bssid( phw_data_t pHwData, u8 *pbssid );
|
||||
void hal_get_bssid( phw_data_t pHwData, u8 *pbssid );
|
||||
void hal_set_beacon_period( phw_data_t pHwData, u16 beacon_period );
|
||||
void hal_set_listen_interval( phw_data_t pHwData, u16 listen_interval );
|
||||
void hal_set_cap_info( phw_data_t pHwData, u16 capability_info );
|
||||
void hal_set_ssid( phw_data_t pHwData, PUCHAR pssid, u8 ssid_len );
|
||||
void hal_set_ssid( phw_data_t pHwData, u8 *pssid, u8 ssid_len );
|
||||
void hal_set_current_channel( phw_data_t pHwData, ChanInfo channel );
|
||||
void hal_set_current_channel_ex( phw_data_t pHwData, ChanInfo channel );
|
||||
void hal_get_current_channel( phw_data_t pHwData, ChanInfo *channel );
|
||||
void hal_set_accept_broadcast( phw_data_t pHwData, u8 enable );
|
||||
void hal_set_accept_multicast( phw_data_t pHwData, u8 enable );
|
||||
void hal_set_accept_beacon( phw_data_t pHwData, u8 enable );
|
||||
void hal_set_multicast_address( phw_data_t pHwData, PUCHAR address, u8 number );
|
||||
void hal_set_multicast_address( phw_data_t pHwData, u8 *address, u8 number );
|
||||
u8 hal_get_accept_beacon( phw_data_t pHwData );
|
||||
void hal_stop( phw_data_t pHwData );
|
||||
void hal_halt( phw_data_t pHwData, void *ppa_data );
|
||||
|
@ -97,7 +97,7 @@ void hal_surprise_remove( phw_data_t pHwData );
|
|||
|
||||
|
||||
void hal_rate_change( phw_data_t pHwData ); // Notify the HAL rate is changing 20060613.1
|
||||
unsigned char hal_get_dxx_reg( phw_data_t pHwData, u16 number, PULONG pValue );
|
||||
unsigned char hal_get_dxx_reg( phw_data_t pHwData, u16 number, u32 * pValue );
|
||||
unsigned char hal_set_dxx_reg( phw_data_t pHwData, u16 number, u32 value );
|
||||
#define hal_get_time_count( _P ) (_P->time_count/10) // return 100ms count
|
||||
#define hal_detect_error( _P ) (_P->WbUsb.DetectCount)
|
||||
|
@ -116,7 +116,7 @@ unsigned char hal_idle( phw_data_t pHwData );
|
|||
#define pa_stall_execution( _A ) //OS_SLEEP( 1 )
|
||||
#define hw_get_cxx_reg( _A, _B, _C )
|
||||
#define hw_set_cxx_reg( _A, _B, _C )
|
||||
#define hw_get_dxx_reg( _A, _B, _C ) hal_get_dxx_reg( _A, _B, (PULONG)_C )
|
||||
#define hw_get_dxx_reg( _A, _B, _C ) hal_get_dxx_reg( _A, _B, (u32 *)_C )
|
||||
#define hw_set_dxx_reg( _A, _B, _C ) hal_set_dxx_reg( _A, _B, (u32)_C )
|
||||
|
||||
|
||||
|
|
|
@ -461,7 +461,7 @@ typedef struct _HW_DATA_T
|
|||
//=====================================================================
|
||||
// Definition for 802.11
|
||||
//=====================================================================
|
||||
PUCHAR bssid_pointer; // Used by hal_get_bssid for return value
|
||||
u8 *bssid_pointer; // Used by hal_get_bssid for return value
|
||||
u8 bssid[8];// Only 6 byte will be used. 8 byte is required for read buffer
|
||||
u8 ssid[32];// maximum ssid length is 32 byte
|
||||
|
||||
|
@ -486,7 +486,7 @@ typedef struct _HW_DATA_T
|
|||
u32 CurrentRadioSw; // 20060320.2 0:On 1:Off
|
||||
u32 CurrentRadioHw; // 20060825 0:On 1:Off
|
||||
|
||||
PUCHAR power_save_point; // Used by hal_get_power_save_mode for return value
|
||||
u8 *power_save_point; // Used by hal_get_power_save_mode for return value
|
||||
u8 cwmin;
|
||||
u8 desired_power_save;
|
||||
u8 dtim;// Is running dtim
|
||||
|
|
|
@ -25,11 +25,11 @@ EncapAtomicInc(PADAPTER Adapter, void* pAtomic)
|
|||
{
|
||||
PWBLINUX pWbLinux = &Adapter->WbLinux;
|
||||
u32 ltmp;
|
||||
PULONG pltmp = (PULONG)pAtomic;
|
||||
OS_SPIN_LOCK_ACQUIRED( &pWbLinux->AtomicSpinLock );
|
||||
u32 * pltmp = (u32 *)pAtomic;
|
||||
spin_lock_irq( &pWbLinux->AtomicSpinLock );
|
||||
(*pltmp)++;
|
||||
ltmp = (*pltmp);
|
||||
OS_SPIN_LOCK_RELEASED( &pWbLinux->AtomicSpinLock );
|
||||
spin_unlock_irq( &pWbLinux->AtomicSpinLock );
|
||||
return ltmp;
|
||||
}
|
||||
|
||||
|
@ -38,11 +38,11 @@ EncapAtomicDec(PADAPTER Adapter, void* pAtomic)
|
|||
{
|
||||
PWBLINUX pWbLinux = &Adapter->WbLinux;
|
||||
u32 ltmp;
|
||||
PULONG pltmp = (PULONG)pAtomic;
|
||||
OS_SPIN_LOCK_ACQUIRED( &pWbLinux->AtomicSpinLock );
|
||||
u32 * pltmp = (u32 *)pAtomic;
|
||||
spin_lock_irq( &pWbLinux->AtomicSpinLock );
|
||||
(*pltmp)--;
|
||||
ltmp = (*pltmp);
|
||||
OS_SPIN_LOCK_RELEASED( &pWbLinux->AtomicSpinLock );
|
||||
spin_unlock_irq( &pWbLinux->AtomicSpinLock );
|
||||
return ltmp;
|
||||
}
|
||||
|
||||
|
@ -51,8 +51,8 @@ WBLINUX_Initial(PADAPTER Adapter)
|
|||
{
|
||||
PWBLINUX pWbLinux = &Adapter->WbLinux;
|
||||
|
||||
OS_SPIN_LOCK_ALLOCATE( &pWbLinux->SpinLock );
|
||||
OS_SPIN_LOCK_ALLOCATE( &pWbLinux->AtomicSpinLock );
|
||||
spin_lock_init( &pWbLinux->SpinLock );
|
||||
spin_lock_init( &pWbLinux->AtomicSpinLock );
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
@ -79,7 +79,6 @@ void
|
|||
WBLINUX_Destroy(PADAPTER Adapter)
|
||||
{
|
||||
WBLINUX_stop( Adapter );
|
||||
OS_SPIN_LOCK_FREE( &pWbNdis->SpinLock );
|
||||
#ifdef _PE_USB_INI_DUMP_
|
||||
WBDEBUG(("[w35und] unregister_netdev!\n"));
|
||||
#endif
|
||||
|
@ -142,12 +141,12 @@ unsigned char
|
|||
WbWLanInitialize(PADAPTER Adapter)
|
||||
{
|
||||
phw_data_t pHwData;
|
||||
PUCHAR pMacAddr, pMacAddr2;
|
||||
u8 *pMacAddr;
|
||||
u8 *pMacAddr2;
|
||||
u32 InitStep = 0;
|
||||
u8 EEPROM_region;
|
||||
u8 HwRadioOff;
|
||||
|
||||
do {
|
||||
//
|
||||
// Setting default value for Linux
|
||||
//
|
||||
|
@ -170,7 +169,7 @@ WbWLanInitialize(PADAPTER Adapter)
|
|||
#ifdef _PE_USB_INI_DUMP_
|
||||
WBDEBUG(("[w35und]WBNDIS initialization failed\n"));
|
||||
#endif
|
||||
break;
|
||||
goto error;
|
||||
}
|
||||
|
||||
// Initial Software variable
|
||||
|
@ -185,7 +184,7 @@ WbWLanInitialize(PADAPTER Adapter)
|
|||
InitStep = 1;
|
||||
pHwData = &Adapter->sHwData;
|
||||
if (!hal_init_hardware(pHwData, Adapter))
|
||||
break;
|
||||
goto error;
|
||||
|
||||
EEPROM_region = hal_get_region_from_EEPROM( pHwData );
|
||||
if (EEPROM_region != REGION_AUTO)
|
||||
|
@ -252,9 +251,8 @@ WbWLanInitialize(PADAPTER Adapter)
|
|||
//set a tx power for reference.....
|
||||
// sme_set_tx_power_level(Adapter, 12); FIXME?
|
||||
return TRUE;
|
||||
}
|
||||
while(FALSE);
|
||||
|
||||
error:
|
||||
switch (InitStep) {
|
||||
case 5:
|
||||
case 4:
|
||||
|
|
|
@ -24,8 +24,8 @@
|
|||
|
||||
typedef struct _WBLINUX
|
||||
{
|
||||
OS_SPIN_LOCK AtomicSpinLock;
|
||||
OS_SPIN_LOCK SpinLock;
|
||||
spinlock_t AtomicSpinLock;
|
||||
spinlock_t SpinLock;
|
||||
u32 shutdown;
|
||||
|
||||
OS_ATOMIC ThreadCount;
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
config PRISM2_USB
|
||||
tristate "Prism2.5 USB driver"
|
||||
depends on USB
|
||||
depends on WLAN_80211 && USB
|
||||
default n
|
||||
---help---
|
||||
This is the wlan-ng prism 2.5 USB driver for a wide range of
|
||||
|
|
|
@ -824,7 +824,7 @@ PD Record codes
|
|||
#define HFA384x_CMD_MACPORT_SET(value) ((UINT16)HFA384x_CMD_AINFO_SET(value))
|
||||
#define HFA384x_CMD_ISRECL(value) ((UINT16)(HFA384x_CMD_AINFO_GET((UINT16)(value) & HFA384x_CMD_RECL)))
|
||||
#define HFA384x_CMD_RECL_SET(value) ((UINT16)HFA384x_CMD_AINFO_SET(value))
|
||||
#define HFA384x_CMD_QOS_GET(value) ((UINT16((((UINT16)(value))&((UINT16)0x3000)) >> 12))
|
||||
#define HFA384x_CMD_QOS_GET(value) ((UINT16)((((UINT16)(value))&((UINT16)0x3000)) >> 12))
|
||||
#define HFA384x_CMD_QOS_SET(value) ((UINT16)((((UINT16)(value)) << 12) & 0x3000))
|
||||
#define HFA384x_CMD_ISWRITE(value) ((UINT16)(HFA384x_CMD_AINFO_GET((UINT16)(value) & HFA384x_CMD_WRITE)))
|
||||
#define HFA384x_CMD_WRITE_SET(value) ((UINT16)HFA384x_CMD_AINFO_SET((UINT16)value))
|
||||
|
|
|
@ -64,7 +64,6 @@
|
|||
/*================================================================*/
|
||||
/* Project Includes */
|
||||
|
||||
#include "version.h"
|
||||
#include "p80211hdr.h"
|
||||
#include "p80211types.h"
|
||||
#include "p80211msg.h"
|
||||
|
|
|
@ -90,8 +90,6 @@
|
|||
#include <linux/usb.h>
|
||||
//#endif
|
||||
|
||||
#include "wlan_compat.h"
|
||||
|
||||
/*================================================================*/
|
||||
/* Project Includes */
|
||||
|
||||
|
|
|
@ -245,11 +245,11 @@ typedef int64_t INT64;
|
|||
# define preempt_count() (0UL)
|
||||
#endif
|
||||
|
||||
#define WLAN_LOG_ERROR(x,args...) printk(KERN_ERR "%s: " x , __FUNCTION__ , ##args);
|
||||
#define WLAN_LOG_ERROR(x,args...) printk(KERN_ERR "%s: " x , __func__ , ##args);
|
||||
|
||||
#define WLAN_LOG_WARNING(x,args...) printk(KERN_WARNING "%s: " x , __FUNCTION__ , ##args);
|
||||
#define WLAN_LOG_WARNING(x,args...) printk(KERN_WARNING "%s: " x , __func__ , ##args);
|
||||
|
||||
#define WLAN_LOG_NOTICE(x,args...) printk(KERN_NOTICE "%s: " x , __FUNCTION__ , ##args);
|
||||
#define WLAN_LOG_NOTICE(x,args...) printk(KERN_NOTICE "%s: " x , __func__ , ##args);
|
||||
|
||||
#define WLAN_LOG_INFO(args... ) printk(KERN_INFO args)
|
||||
|
||||
|
@ -265,7 +265,7 @@ typedef int64_t INT64;
|
|||
#define DBFENTER { if ( WLAN_DBVAR >= 5 ){ WLAN_LOG_DEBUG(3,"---->\n"); } }
|
||||
#define DBFEXIT { if ( WLAN_DBVAR >= 5 ){ WLAN_LOG_DEBUG(3,"<----\n"); } }
|
||||
|
||||
#define WLAN_LOG_DEBUG(l,x,args...) if ( WLAN_DBVAR >= (l)) printk(KERN_DEBUG "%s(%lu): " x , __FUNCTION__, (preempt_count() & PREEMPT_MASK), ##args );
|
||||
#define WLAN_LOG_DEBUG(l,x,args...) if ( WLAN_DBVAR >= (l)) printk(KERN_DEBUG "%s(%lu): " x , __func__, (preempt_count() & PREEMPT_MASK), ##args );
|
||||
#else
|
||||
#define WLAN_ASSERT(c)
|
||||
#define WLAN_HEX_DUMP( l, s, p, n)
|
||||
|
|
Loading…
Reference in a new issue