Skip to content

R
raspberrypi-kernel

openeuler / raspberrypi-kernel

通知 13
Star 1
Fork 0
R
raspberrypi-kernel
提交 52b0e80e 编写于 作者: B Brett Rudley 提交者： Greg Kroah-Hartman
浏览文件
操作

staging: brcm80211: bcmutils.[ch]: purge unused funcs 

Get rid of unused functions in bcmutils.[ch]. Note that bcmutils.h is shared between
fullmac and softmac
Signed-off-by: NBrett Rudley <brudley@broadcom.com>
Signed-off-by: NGreg Kroah-Hartman <gregkh@suse.de>
上级 673e1f31
隐藏空白更改
内联 并排
Showing with 35 addition and 800 deletion
drivers/staging/brcm80211/include/bcmutils.h
浏览文件 @ 52b0e80e
......@@ -151,12 +151,16 @@ extern "C" {
extern void pktq_pflush(osl_t *osh, struct pktq *pq, int prec,
bool dir, ifpkt_cb_t fn, int arg);
#endif
#ifdef BRCM_FULLMAC
/* Remove a specified packet from its queue */
extern bool pktq_pdel(struct pktq *pq, void *p, int prec);
#endif /* BRCM_FULLMAC */
/* operations on a set of precedences in packet queue */
#ifdef BRCM_FULLMAC
extern int pktq_mlen(struct pktq *pq, uint prec_bmp);
#endif /* BRCM_FULLMAC */
extern void *pktq_mdeq(struct pktq *pq, uint prec_bmp, int *prec_out);
/* operations on packet queue as a whole */
......@@ -176,9 +180,11 @@ extern "C" {
extern void pktq_init(struct pktq *pq, int num_prec, int max_len);
/* prec_out may be NULL if caller is not interested in return value */
#ifdef BRCM_FULLMAC
extern void *pktq_deq(struct pktq *pq, int *prec_out);
extern void *pktq_deq_tail(struct pktq *pq, int *prec_out);
extern void *pktq_peek(struct pktq *pq, int *prec_out);
#endif /* BRCM_FULLMAC */
extern void *pktq_peek_tail(struct pktq *pq, int *prec_out);
#ifdef BRCM_FULLMAC
extern void pktq_flush(osl_t *osh, struct pktq *pq, bool dir);
......@@ -189,13 +195,15 @@ extern "C" {
/* externs */
/* packet */
#ifdef BRCM_FULLMAC
extern uint pktcopy(osl_t *osh, void *p, uint offset, int len,
unsigned char *buf);
extern uint pktfrombuf(osl_t *osh, void *p, uint offset, int len,
unsigned char *buf);
extern uint pkttotlen(osl_t *osh, void *p);
extern void *pktlast(osl_t *osh, void *p);
extern uint pktsegcnt(osl_t *osh, void *p);
#endif /* BRCM_FULLMAC */
extern uint pkttotlen(osl_t *osh, void *p);
/* Get priority from a packet and pass it back in scb (or equiv) */
extern uint pktsetprio(void *pkt, bool update_vtag);
......@@ -226,13 +234,17 @@ extern "C" {
struct ipv4_addr;
extern char *bcm_ip_ntoa(struct ipv4_addr *ia, char *buf);
#ifdef BRCM_FULLMAC
/* delay */
extern void bcm_mdelay(uint ms);
#endif
/* variable access */
extern char *getvar(char *vars, const char *name);
extern int getintvar(char *vars, const char *name);
#ifdef BRCM_FULLMAC
extern int getintvararray(char *vars, const char *name, u8 index);
extern uint getgpiopin(char *vars, char *pin_name, uint def_pin);
#endif
#ifdef BCMDBG
extern void prpkt(const char *msg, osl_t *osh, void *p0);
#endif /* BCMDBG */
......@@ -246,8 +258,10 @@ extern "C" {
#define bcmprinttslogs()
#define bcmprinttstamp(us)
#ifdef BRCM_FULLLMAC
extern char *bcm_nvram_vars(uint *length);
extern int bcm_nvram_cache(void *sih);
#endif
/* Support for sharing code across in-driver iovar implementations.
* The intent is that a driver use this structure to map iovar names
......@@ -279,14 +293,18 @@ extern "C" {
/* flags are per-driver based on driver attributes */
#ifdef BRCM_FULLMAC
extern const bcm_iovar_t *bcm_iovar_lookup(const bcm_iovar_t *table,
const char *name);
#endif
extern int bcm_iovar_lencheck(const bcm_iovar_t *table, void *arg,
int len, bool set);
#ifdef BRCM_FULLMAC
#if defined(BCMDBG)
extern int bcm_format_ssid(char *buf, const unsigned char ssid[],
uint ssid_len);
#endif
#endif /* BRCM_FULLMAC */
/* Base type definitions */
#define IOVT_VOID 0 /* no value (implictly set only) */
......@@ -558,25 +576,32 @@ extern "C" {
char *buf, int len);
extern int bcm_format_hex(char *str, const void *bytes, int len);
#endif
#ifdef BRCM_FULLMAC
#ifdef BCMDBG
extern void deadbeef(void *p, uint len);
#endif
extern const char *bcm_crypto_algo_name(uint algo);
#endif /* BRCM_FULLMAC */
extern char *bcm_chipname(uint chipid, char *buf, uint len);
#ifdef BRCM_FULLMAC
extern char *bcm_brev_str(uint32 brev, char *buf);
extern void printbig(char *buf);
#endif /* BRCM_FULLMAC */
extern void prhex(const char *msg, unsigned char *buf, uint len);
#ifdef BRCM_FULLMAC
/* IE parsing */
extern bcm_tlv_t *BCMROMFN(bcm_next_tlv) (bcm_tlv_t *elt, int *buflen);
extern bcm_tlv_t *BCMROMFN(bcm_parse_tlvs) (void *buf, int buflen,
uint key);
extern bcm_tlv_t *BCMROMFN(bcm_parse_ordered_tlvs) (void *buf,
int buflen,
uint key);
#endif
extern bcm_tlv_t *BCMROMFN(bcm_parse_tlvs) (void *buf, int buflen,
uint key);
#ifdef BRCM_FULLMAC
/* bcmerror */
extern const char *bcmerrorstr(int bcmerror);
#endif
/* multi-bool data type: set of bools, mbool is true if any is set */
typedef uint32 mbool;
......@@ -585,9 +610,11 @@ extern "C" {
#define mboolisset(mb, bit) (((mb) & (bit)) != 0) /* TRUE if one bool is set */
#define mboolmaskset(mb, mask, val) ((mb) = (((mb) & ~(mask)) | (val)))
#ifdef BRCM_FULLMAC
/* power conversion */
extern uint16 BCMROMFN(bcm_qdbm_to_mw) (u8 qdbm);
extern u8 BCMROMFN(bcm_mw_to_qdbm) (uint16 mw);
#endif
/* generic datastruct to help dump routines */
struct fielddesc {
......@@ -596,20 +623,24 @@ extern "C" {
uint32 len;
};
#ifdef BRCM_FULLMAC
extern void bcm_binit(struct bcmstrbuf *b, char *buf, uint size);
extern int bcm_bprintf(struct bcmstrbuf *b, const char *fmt, ...);
extern void bcm_inc_bytes(unsigned char *num, int num_bytes, u8 amount);
extern int bcm_cmp_bytes(unsigned char *arg1, unsigned char *arg2, u8 nbytes);
extern void bcm_print_bytes(char *name, const unsigned char *cdata, int len);
#endif
typedef uint32(*bcmutl_rdreg_rtn) (void *arg0, uint arg1,
uint32 offset);
#ifdef BRCM_FULLMAC
extern uint bcmdumpfields(bcmutl_rdreg_rtn func_ptr, void *arg0,
uint arg1, struct fielddesc *str, char *buf,
uint32 bufsize);
extern uint bcm_mkiovar(char *name, char *data, uint datalen, char *buf,
uint len);
#endif
extern uint BCMROMFN(bcm_bitcount) (u8 *bitmap, uint bytelength);
#ifdef __cplusplus
......
drivers/staging/brcm80211/util/bcmutils.c
浏览文件 @ 52b0e80e
......@@ -31,70 +31,6 @@
#include <proto/802.1d.h>
#include <proto/802.11.h>
#ifdef WLC_LOW
/* nvram vars cache */
static char *nvram_vars;
static int vars_len = -1;
#endif /* WLC_LOW */
/* copy a pkt buffer chain into a buffer */
uint pktcopy(osl_t *osh, void *p, uint offset, int len, unsigned char *buf)
{
uint n, ret = 0;
if (len < 0)
len = 4096; /* "infinite" */
/* skip 'offset' bytes */
for (; p && offset; p = PKTNEXT(p)) {
if (offset < (uint) PKTLEN(p))
break;
offset -= PKTLEN(p);
}
if (!p)
return 0;
/* copy the data */
for (; p && len; p = PKTNEXT(p)) {
n = MIN((uint) PKTLEN(p) - offset, (uint) len);
bcopy(PKTDATA(p) + offset, buf, n);
buf += n;
len -= n;
ret += n;
offset = 0;
}
return ret;
}
/* copy a buffer into a pkt buffer chain */
uint pktfrombuf(osl_t *osh, void *p, uint offset, int len, unsigned char *buf)
{
uint n, ret = 0;
/* skip 'offset' bytes */
for (; p && offset; p = PKTNEXT(p)) {
if (offset < (uint) PKTLEN(p))
break;
offset -= PKTLEN(p);
}
if (!p)
return 0;
/* copy the data */
for (; p && len; p = PKTNEXT(p)) {
n = MIN((uint) PKTLEN(p) - offset, (uint) len);
bcopy(buf, PKTDATA(p) + offset, n);
buf += n;
len -= n;
ret += n;
offset = 0;
}
return ret;
}
/* return total length of buffer chain */
uint BCMFASTPATH pkttotlen(osl_t *osh, void *p)
......@@ -107,26 +43,6 @@ uint BCMFASTPATH pkttotlen(osl_t *osh, void *p)
return total;
}
/* return the last buffer of chained pkt */
void *pktlast(osl_t *osh, void *p)
{
for (; PKTNEXT(p); p = PKTNEXT(p))
;
return p;
}
/* count segments of a chained packet */
uint BCMFASTPATH pktsegcnt(osl_t *osh, void *p)
{
uint cnt;
for (cnt = 0; p; p = PKTNEXT(p))
cnt++;
return cnt;
}
/*
* osl multiple-precedence packet queue
* hi_prec is always >= the number of the highest non-empty precedence
......@@ -274,39 +190,6 @@ pktq_pflush(osl_t *osh, struct pktq *pq, int prec, bool dir, ifpkt_cb_t fn,
}
}
bool BCMFASTPATH pktq_pdel(struct pktq *pq, void *pktbuf, int prec)
{
struct pktq_prec *q;
void *p;
ASSERT(prec >= 0 && prec < pq->num_prec);
if (!pktbuf)
return FALSE;
q = &pq->q[prec];
if (q->head == pktbuf) {
q->head = PKTLINK(pktbuf);
if (q->head == NULL)
q->tail = NULL;
} else {
for (p = q->head; p && PKTLINK(p) != pktbuf; p = PKTLINK(p))
;
if (p == NULL)
return FALSE;
PKTSETLINK(p, PKTLINK(pktbuf));
if (q->tail == pktbuf)
q->tail = p;
}
q->len--;
pq->len--;
PKTSETLINK(pktbuf, NULL);
return TRUE;
}
void pktq_init(struct pktq *pq, int num_prec, int max_len)
{
int prec;
......@@ -325,96 +208,6 @@ void pktq_init(struct pktq *pq, int num_prec, int max_len)
pq->q[prec].max = pq->max;
}
void *BCMFASTPATH pktq_deq(struct pktq *pq, int *prec_out)
{
struct pktq_prec *q;
void *p;
int prec;
if (pq->len == 0)
return NULL;
while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
pq->hi_prec--;
q = &pq->q[prec];
p = q->head;
if (p == NULL)
return NULL;
q->head = PKTLINK(p);
if (q->head == NULL)
q->tail = NULL;
q->len--;
pq->len--;
if (prec_out)
*prec_out = prec;
PKTSETLINK(p, NULL);
return p;
}
void *BCMFASTPATH pktq_deq_tail(struct pktq *pq, int *prec_out)
{
struct pktq_prec *q;
void *p, *prev;
int prec;
if (pq->len == 0)
return NULL;
for (prec = 0; prec < pq->hi_prec; prec++)
if (pq->q[prec].head)
break;
q = &pq->q[prec];
p = q->head;
if (p == NULL)
return NULL;
for (prev = NULL; p != q->tail; p = PKTLINK(p))
prev = p;
if (prev)
PKTSETLINK(prev, NULL);
else
q->head = NULL;
q->tail = prev;
q->len--;
pq->len--;
if (prec_out)
*prec_out = prec;
PKTSETLINK(p, NULL);
return p;
}
void *pktq_peek(struct pktq *pq, int *prec_out)
{
int prec;
if (pq->len == 0)
return NULL;
while ((prec = pq->hi_prec) > 0 && pq->q[prec].head == NULL)
pq->hi_prec--;
if (prec_out)
*prec_out = prec;
return pq->q[prec].head;
}
void *pktq_peek_tail(struct pktq *pq, int *prec_out)
{
int prec;
......@@ -441,20 +234,6 @@ void pktq_flush(osl_t *osh, struct pktq *pq, bool dir, ifpkt_cb_t fn, int arg)
ASSERT(pq->len == 0);
}
/* Return sum of lengths of a specific set of precedences */
int pktq_mlen(struct pktq *pq, uint prec_bmp)
{
int prec, len;
len = 0;
for (prec = 0; prec <= pq->hi_prec; prec++)
if (prec_bmp & (1 << prec))
len += pq->q[prec].len;
return len;
}
/* Priority dequeue from a specific set of precedences */
void *BCMFASTPATH pktq_mdeq(struct pktq *pq, uint prec_bmp, int *prec_out)
{
......@@ -514,15 +293,6 @@ char *bcm_ether_ntoa(const struct ether_addr *ea, char *buf)
return buf;
}
void bcm_mdelay(uint ms)
{
uint i;
for (i = 0; i < ms; i++) {
OSL_DELAY(1000);
}
}
/*
* Search the name=value vars for a specific one and return its value.
* Returns NULL if not found.
......@@ -567,84 +337,6 @@ int getintvar(char *vars, const char *name)
return simple_strtoul(val, NULL, 0);
}
int getintvararray(char *vars, const char *name, u8 index)
{
char *buf, *endp;
int i = 0;
int val = 0;
buf = getvar(vars, name);
if (buf == NULL) {
return 0;
}
/* table values are always separated by "," or " " */
while (*buf != '\0') {
val = simple_strtoul(buf, &endp, 0);
if (i == index) {
return val;
}
buf = endp;
/* delimiter is ',' */
if (*buf == ',')
buf++;
i++;
}
return 0;
}
/* Search for token in comma separated token-string */
static int findmatch(char *string, char *name)
{
uint len;
char *c;
len = strlen(name);
while ((c = strchr(string, ',')) != NULL) {
if (len == (uint) (c - string) && !strncmp(string, name, len))
return 1;
string = c + 1;
}
return !strcmp(string, name);
}
/* Return gpio pin number assigned to the named pin
*
* Variable should be in format:
*
* gpio<N>=pin_name,pin_name
*
* This format allows multiple features to share the gpio with mutual
* understanding.
*
* 'def_pin' is returned if a specific gpio is not defined for the requested functionality
* and if def_pin is not used by others.
*/
uint getgpiopin(char *vars, char *pin_name, uint def_pin)
{
char name[] = "gpioXXXX";
char *val;
uint pin;
/* Go thru all possibilities till a match in pin name */
for (pin = 0; pin < GPIO_NUMPINS; pin++) {
snprintf(name, sizeof(name), "gpio%d", pin);
val = getvar(vars, name);
if (val && findmatch(val, pin_name))
return pin;
}
if (def_pin != GPIO_PIN_NOTDEFINED) {
/* make sure the default pin is not used by someone else */
snprintf(name, sizeof(name), "gpio%d", def_pin);
if (getvar(vars, name)) {
def_pin = GPIO_PIN_NOTDEFINED;
}
}
return def_pin;
}
#if defined(BCMDBG)
/* pretty hex print a pkt buffer chain */
void prpkt(const char *msg, osl_t *osh, void *p0)
......@@ -659,135 +351,6 @@ void prpkt(const char *msg, osl_t *osh, void *p0)
}
#endif /* defined(BCMDBG) */
static char bcm_undeferrstr[32];
static const char *bcmerrorstrtable[] = BCMERRSTRINGTABLE;
/* Convert the error codes into related error strings */
const char *bcmerrorstr(int bcmerror)
{
/* check if someone added a bcmerror code but forgot to add errorstring */
ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(bcmerrorstrtable) - 1));
if (bcmerror > 0 || bcmerror < BCME_LAST) {
snprintf(bcm_undeferrstr, sizeof(bcm_undeferrstr),
"Undefined error %d", bcmerror);
return bcm_undeferrstr;
}
ASSERT(strlen(bcmerrorstrtable[-bcmerror]) < BCME_STRLEN);
return bcmerrorstrtable[-bcmerror];
}
#ifdef WLC_LOW
static void BCMINITFN(bcm_nvram_refresh) (char *flash)
{
int i;
int ret = 0;
ASSERT(flash != NULL);
/* default "empty" vars cache */
bzero(flash, 2);
ret = nvram_getall(flash, NVRAM_SPACE);
if (ret)
return;
/* determine nvram length */
for (i = 0; i < NVRAM_SPACE; i++) {
if (flash[i] == '\0' && flash[i + 1] == '\0')
break;
}
if (i > 1)
vars_len = i + 2;
else
vars_len = 0;
}
char *bcm_nvram_vars(uint *length)
{
#ifndef BCMNVRAMR
/* cache may be stale if nvram is read/write */
if (nvram_vars) {
ASSERT(!bcmreclaimed);
bcm_nvram_refresh(nvram_vars);
}
#endif
if (length)
*length = vars_len;
return nvram_vars;
}
/* copy nvram vars into locally-allocated multi-string array */
int BCMINITFN(bcm_nvram_cache) (void *sih)
{
int ret = 0;
void *osh;
char *flash = NULL;
if (vars_len >= 0) {
#ifndef BCMNVRAMR
bcm_nvram_refresh(nvram_vars);
#endif
return 0;
}
osh = si_osh((si_t *) sih);
/* allocate memory and read in flash */
flash = MALLOC(osh, NVRAM_SPACE);
if (!flash) {
ret = BCME_NOMEM;
goto exit;
}
bcm_nvram_refresh(flash);
#ifdef BCMNVRAMR
if (vars_len > 3) {
/* copy into a properly-sized buffer */
nvram_vars = MALLOC(osh, vars_len);
if (!nvram_vars) {
ret = BCME_NOMEM;
} else
bcopy(flash, nvram_vars, vars_len);
}
MFREE(osh, flash, NVRAM_SPACE);
#else
/* cache must be full size of nvram if read/write */
nvram_vars = flash;
#endif /* BCMNVRAMR */
exit:
return ret;
}
#endif /* WLC_LOW */
/* iovar table lookup */
const bcm_iovar_t *bcm_iovar_lookup(const bcm_iovar_t *table, const char *name)
{
const bcm_iovar_t *vi;
const char *lookup_name;
/* skip any ':' delimited option prefixes */
lookup_name = strrchr(name, ':');
if (lookup_name != NULL)
lookup_name++;
else
lookup_name = name;
ASSERT(table != NULL);
for (vi = table; vi->name; vi++) {
if (!strcmp(vi->name, lookup_name))
return vi;
}
/* ran to end of table */
return NULL; /* var name not found */
}
int bcm_iovar_lencheck(const bcm_iovar_t *vi, void *arg, int len, bool set)
{
int bcmerror = 0;
......@@ -972,34 +535,6 @@ uint16 BCMROMFN(hndcrc16) (u8 *pdata, /* pointer to array of data to process */
return crc;
}
/*
* Advance from the current 1-byte tag/1-byte length/variable-length value
* triple, to the next, returning a pointer to the next.
* If the current or next TLV is invalid (does not fit in given buffer length),
* NULL is returned.
* *buflen is not modified if the TLV elt parameter is invalid, or is decremented
* by the TLV parameter's length if it is valid.
*/
bcm_tlv_t *BCMROMFN(bcm_next_tlv) (bcm_tlv_t *elt, int *buflen)
{
int len;
/* validate current elt */
if (!bcm_valid_tlv(elt, *buflen))
return NULL;
/* advance to next elt */
len = elt->len;
elt = (bcm_tlv_t *) (elt->data + len);
*buflen -= (2 + len);
/* validate next elt */
if (!bcm_valid_tlv(elt, *buflen))
return NULL;
return elt;
}
/*
* Traverse a string of 1-byte tag/1-byte length/variable-length value
* triples, returning a pointer to the substring whose first element
......@@ -1028,38 +563,6 @@ bcm_tlv_t *BCMROMFN(bcm_parse_tlvs) (void *buf, int buflen, uint key)
return NULL;
}
/*
* Traverse a string of 1-byte tag/1-byte length/variable-length value
* triples, returning a pointer to the substring whose first element
* matches tag. Stop parsing when we see an element whose ID is greater
* than the target key.
*/
bcm_tlv_t *BCMROMFN(bcm_parse_ordered_tlvs) (void *buf, int buflen, uint key)
{
bcm_tlv_t *elt;
int totlen;
elt = (bcm_tlv_t *) buf;
totlen = buflen;
/* find tagged parameter */
while (totlen >= 2) {
uint id = elt->id;
int len = elt->len;
/* Punt if we start seeing IDs > than target key */
if (id > key)
return NULL;
/* validate remaining totlen */
if ((id == key) && (totlen >= (len + 2)))
return elt;
elt = (bcm_tlv_t *) ((u8 *) elt + (len + 2));
totlen -= (len + 2);
}
return NULL;
}
#if defined(BCMDBG)
int
......@@ -1166,36 +669,6 @@ void prhex(const char *msg, unsigned char *buf, uint nbytes)
printf("%s\n", line);
}
static const char *crypto_algo_names[] = {
"NONE",
"WEP1",
"TKIP",
"WEP128",
"AES_CCM",
"NALG" "UNDEF",
"UNDEF",
"UNDEF",
"UNDEF"
};
const char *bcm_crypto_algo_name(uint algo)
{
return (algo <
ARRAYSIZE(crypto_algo_names)) ? crypto_algo_names[algo] : "ERR";
}
#ifdef BCMDBG
void deadbeef(void *p, uint len)
{
static u8 meat[] = { 0xde, 0xad, 0xbe, 0xef };
while (len-- > 0) {
*(u8 *) p = meat[((uintptr) p) & 3];
p = (u8 *) p + 1;
}
}
#endif /* BCMDBG */
char *bcm_chipname(uint chipid, char *buf, uint len)
{
const char *fmt;
......@@ -1205,174 +678,6 @@ char *bcm_chipname(uint chipid, char *buf, uint len)
return buf;
}
/* Produce a human-readable string for boardrev */
char *bcm_brev_str(uint32 brev, char *buf)
{
if (brev < 0x100)
snprintf(buf, 8, "%d.%d", (brev & 0xf0) >> 4, brev & 0xf);
else
snprintf(buf, 8, "%c%03x",
((brev & 0xf000) == 0x1000) ? 'P' : 'A', brev & 0xfff);
return buf;
}
#define BUFSIZE_TODUMP_ATONCE 512 /* Buffer size */
/* dump large strings to console */
void printbig(char *buf)
{
uint len, max_len;
char c;
len = strlen(buf);
max_len = BUFSIZE_TODUMP_ATONCE;
while (len > max_len) {
c = buf[max_len];
buf[max_len] = '\0';
printf("%s", buf);
buf[max_len] = c;
buf += max_len;
len -= max_len;
}
/* print the remaining string */
printf("%s\n", buf);
return;
}
/* routine to dump fields in a fileddesc structure */
uint
bcmdumpfields(bcmutl_rdreg_rtn read_rtn, void *arg0, uint arg1,
struct fielddesc *fielddesc_array, char *buf, uint32 bufsize)
{
uint filled_len;
int len;
struct fielddesc *cur_ptr;
filled_len = 0;
cur_ptr = fielddesc_array;
while (bufsize > 1) {
if (cur_ptr->nameandfmt == NULL)
break;
len = snprintf(buf, bufsize, cur_ptr->nameandfmt,
read_rtn(arg0, arg1, cur_ptr->offset));
/* check for snprintf overflow or error */
if (len < 0 || (uint32) len >= bufsize)
len = bufsize - 1;
buf += len;
bufsize -= len;
filled_len += len;
cur_ptr++;
}
return filled_len;
}
uint bcm_mkiovar(char *name, char *data, uint datalen, char *buf, uint buflen)
{
uint len;
len = strlen(name) + 1;
if ((len + datalen) > buflen)
return 0;
strncpy(buf, name, buflen);
/* append data onto the end of the name string */
memcpy(&buf[len], data, datalen);
len += datalen;
return len;
}
/* Quarter dBm units to mW
* Table starts at QDBM_OFFSET, so the first entry is mW for qdBm=153
* Table is offset so the last entry is largest mW value that fits in
* a uint16.
*/
#define QDBM_OFFSET 153 /* Offset for first entry */
#define QDBM_TABLE_LEN 40 /* Table size */
/* Smallest mW value that will round up to the first table entry, QDBM_OFFSET.
* Value is ( mW(QDBM_OFFSET - 1) + mW(QDBM_OFFSET) ) / 2
*/
#define QDBM_TABLE_LOW_BOUND 6493 /* Low bound */
/* Largest mW value that will round down to the last table entry,
* QDBM_OFFSET + QDBM_TABLE_LEN-1.
* Value is ( mW(QDBM_OFFSET + QDBM_TABLE_LEN - 1) + mW(QDBM_OFFSET + QDBM_TABLE_LEN) ) / 2.
*/
#define QDBM_TABLE_HIGH_BOUND 64938 /* High bound */
static const uint16 nqdBm_to_mW_map[QDBM_TABLE_LEN] = {
/* qdBm: +0 +1 +2 +3 +4 +5 +6 +7 */
/* 153: */ 6683, 7079, 7499, 7943, 8414, 8913, 9441, 10000,
/* 161: */ 10593, 11220, 11885, 12589, 13335, 14125, 14962, 15849,
/* 169: */ 16788, 17783, 18836, 19953, 21135, 22387, 23714, 25119,
/* 177: */ 26607, 28184, 29854, 31623, 33497, 35481, 37584, 39811,
/* 185: */ 42170, 44668, 47315, 50119, 53088, 56234, 59566, 63096
};
uint16 BCMROMFN(bcm_qdbm_to_mw) (u8 qdbm)
{
uint factor = 1;
int idx = qdbm - QDBM_OFFSET;
if (idx >= QDBM_TABLE_LEN) {
/* clamp to max uint16 mW value */
return 0xFFFF;
}
/* scale the qdBm index up to the range of the table 0-40
* where an offset of 40 qdBm equals a factor of 10 mW.
*/
while (idx < 0) {
idx += 40;
factor *= 10;
}
/* return the mW value scaled down to the correct factor of 10,
* adding in factor/2 to get proper rounding.
*/
return (nqdBm_to_mW_map[idx] + factor / 2) / factor;
}
u8 BCMROMFN(bcm_mw_to_qdbm) (uint16 mw)
{
u8 qdbm;
int offset;
uint mw_uint = mw;
uint boundary;
/* handle boundary case */
if (mw_uint <= 1)
return 0;
offset = QDBM_OFFSET;
/* move mw into the range of the table */
while (mw_uint < QDBM_TABLE_LOW_BOUND) {
mw_uint *= 10;
offset -= 40;
}
for (qdbm = 0; qdbm < QDBM_TABLE_LEN - 1; qdbm++) {
boundary = nqdBm_to_mW_map[qdbm] + (nqdBm_to_mW_map[qdbm + 1] -
nqdBm_to_mW_map[qdbm]) / 2;
if (mw_uint < boundary)
break;
}
qdbm += (u8) offset;
return qdbm;
}
uint BCMROMFN(bcm_bitcount) (u8 *bitmap, uint length)
{
uint bitcount = 0, i;
......@@ -1386,104 +691,3 @@ uint BCMROMFN(bcm_bitcount) (u8 *bitmap, uint length)
}
return bitcount;
}
/* Initialization of bcmstrbuf structure */
void bcm_binit(struct bcmstrbuf *b, char *buf, uint size)
{
b->origsize = b->size = size;
b->origbuf = b->buf = buf;
}
/* Buffer sprintf wrapper to guard against buffer overflow */
int bcm_bprintf(struct bcmstrbuf *b, const char *fmt, ...)
{
va_list ap;
int r;
va_start(ap, fmt);
r = vsnprintf(b->buf, b->size, fmt, ap);
/* Non Ansi C99 compliant returns -1,
* Ansi compliant return r >= b->size,
* bcmstdlib returns 0, handle all
*/
if ((r == -1) || (r >= (int)b->size) || (r == 0)) {
b->size = 0;
} else {
b->size -= r;
b->buf += r;
}
va_end(ap);
return r;
}
void bcm_inc_bytes(unsigned char *num, int num_bytes, u8 amount)
{
int i;
for (i = 0; i < num_bytes; i++) {
num[i] += amount;
if (num[i] >= amount)
break;
amount = 1;
}
}
int bcm_cmp_bytes(unsigned char *arg1, unsigned char *arg2, u8 nbytes)
{
int i;
for (i = nbytes - 1; i >= 0; i--) {
if (arg1[i] != arg2[i])
return arg1[i] - arg2[i];
}
return 0;
}
void bcm_print_bytes(char *name, const unsigned char *data, int len)
{
int i;
int per_line = 0;
printf("%s: %d\n", name ? name : "", len);
for (i = 0; i < len; i++) {
printf("%02x ", *data++);
per_line++;
if (per_line == 16) {
per_line = 0;
printf("\n");
}
}
printf("\n");
}
#if defined(BCMDBG)
#define SSID_FMT_BUF_LEN ((4 * DOT11_MAX_SSID_LEN) + 1)
int bcm_format_ssid(char *buf, const unsigned char ssid[], uint ssid_len)
{
uint i, c;
char *p = buf;
char *endp = buf + SSID_FMT_BUF_LEN;
if (ssid_len > DOT11_MAX_SSID_LEN)
ssid_len = DOT11_MAX_SSID_LEN;
for (i = 0; i < ssid_len; i++) {
c = (uint) ssid[i];
if (c == '\\') {
*p++ = '\\';
*p++ = '\\';
} else if (isprint((unsigned char) c)) {
*p++ = (char)c;
} else {
p += snprintf(p, (endp - p), "\\x%02X", c);
}
}
*p = '\0';
ASSERT(p < endp);
return (int)(p - buf);
}
#endif /* defined(BCMDBG) */
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或