release/src/router/shared/wl.c

   1 /*
   2  * Wireless network adapter utilities
   3  *
   4  * Copyright 2005, Broadcom Corporation
   5  * All Rights Reserved.
   6  *
   7  * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
   8  * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
   9  * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
  10  * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
  11  *
  12  * $Id: wl.c,v 1.1.1.9 2005/03/07 07:31:20 kanki Exp $
  13  */
  14 #include <string.h>
  15 #include <stdio.h>
  16 #include <unistd.h>
  17 #include <errno.h>
  18 #include <sys/ioctl.h>
  19 #include <net/if.h>
  20
  21 #include <typedefs.h>
  22 #include <bcmutils.h>
  23 #include <wlutils.h>
  24 #include <wlioctl.h>
  25
  26 #include "shared.h"
  27
  28 // xref: nas,wlconf
  29 int wl_probe(char *name)
  30 {
  31         int ret, val;
  32
  33 #if defined(linux)
  34         char buf[DEV_TYPE_LEN];
  35         if ((ret = wl_get_dev_type(name, buf, DEV_TYPE_LEN)) < 0)
  36                 return ret;
  37         /* Check interface */
  38         if (strncmp(buf, "wl", 2))
  39                 return -1;
  40 #else
  41         /* Check interface */
  42         if ((ret = wl_ioctl(name, WLC_GET_MAGIC, &val, sizeof(val))))
  43                 return ret;
  44 #endif
  45         if ((ret = wl_ioctl(name, WLC_GET_VERSION, &val, sizeof(val))))
  46                 return ret;
  47         if (val > WLC_IOCTL_VERSION)
  48                 return -1;
  49
  50         return ret;
  51 }
  52
  53 // xref: nas,wlconf,
  54 int wl_set_val(char *name, char *var, void *val, int len)
  55 {
  56         char buf[WLC_IOCTL_SMLEN];
  57         int buf_len;
  58
  59         /* check for overflow */
  60         if ((buf_len = strlen(var)) + 1 + len > sizeof(buf))
  61                 return -1;
  62
  63         strcpy(buf, var);
  64         buf_len += 1;
  65
  66         /* append int value onto the end of the name string */
  67         memcpy(&buf[buf_len], val, len);
  68         buf_len += len;
  69
  70         return wl_ioctl(name, WLC_SET_VAR, buf, buf_len);
  71 }
  72
  73 // xref: nas,wlconf,
  74 int wl_get_val(char *name, char *var, void *val, int len)
  75 {
  76         char buf[WLC_IOCTL_SMLEN];
  77         int ret;
  78
  79         /* check for overflow */
  80         if (strlen(var) + 1 > sizeof(buf) || len > sizeof(buf))
  81                 return -1;
  82
  83         strcpy(buf, var);
  84         if ((ret = wl_ioctl(name, WLC_GET_VAR, buf, sizeof(buf))))
  85                 return ret;
  86
  87         memcpy(val, buf, len);
  88         return 0;
  89 }
  90
  91 // xref: wlconf,
  92 int wl_set_int(char *name, char *var, int val)
  93 {
  94         return wl_set_val(name, var, &val, sizeof(val));
  95 }
  96
  97 #if 0   // not used
  98 int wl_get_int(char *name, char *var, int *val)
  99 {
 100         return wl_get_val(name, var, val, sizeof(*val));
 101 }
 102 #endif
 103
 104
 105 #ifndef WL_BSS_INFO_VERSION
 106 #error WL_BSS_INFO_VERSION
 107 #endif
 108
 109 #if WL_BSS_INFO_VERSION >= 108
 110 int
 111 wl_iovar_getbuf(char *ifname, char *iovar, void *param, int paramlen, void *bufptr, int buflen)
 112 {
 113         int err;
 114         uint namelen;
 115         uint iolen;
 116
 117         namelen = strlen(iovar) + 1;     /* length of iovar name plus null */
 118         iolen = namelen + paramlen;
 119
 120         /* check for overflow */
 121         if (iolen > buflen)
 122                 return (BCME_BUFTOOSHORT);
 123
 124         memcpy(bufptr, iovar, namelen); /* copy iovar name including null */
 125         memcpy((int8*)bufptr + namelen, param, paramlen);
 126
 127         err = wl_ioctl(ifname, WLC_GET_VAR, bufptr, buflen);
 128
 129         return (err);
 130 }
 131
 132 int
 133 wl_iovar_setbuf(char *ifname, char *iovar, void *param, int paramlen, void *bufptr, int buflen)
 134 {
 135         uint namelen;
 136         uint iolen;
 137
 138         namelen = strlen(iovar) + 1;     /* length of iovar name plus null */
 139         iolen = namelen + paramlen;
 140
 141         /* check for overflow */
 142         if (iolen > buflen)
 143                 return (BCME_BUFTOOSHORT);
 144
 145         memcpy(bufptr, iovar, namelen); /* copy iovar name including null */
 146         memcpy((int8*)bufptr + namelen, param, paramlen);
 147
 148         return wl_ioctl(ifname, WLC_SET_VAR, bufptr, iolen);
 149 }
 150
 151 int
 152 wl_iovar_set(char *ifname, char *iovar, void *param, int paramlen)
 153 {
 154         char smbuf[WLC_IOCTL_SMLEN];
 155
 156         return wl_iovar_setbuf(ifname, iovar, param, paramlen, smbuf, sizeof(smbuf));
 157 }
 158
 159 int
 160 wl_iovar_get(char *ifname, char *iovar, void *bufptr, int buflen)
 161 {
 162         char smbuf[WLC_IOCTL_SMLEN];
 163         int ret;
 164
 165         /* use the return buffer if it is bigger than what we have on the stack */
 166         if (buflen > sizeof(smbuf)) {
 167                 ret = wl_iovar_getbuf(ifname, iovar, NULL, 0, bufptr, buflen);
 168         } else {
 169                 ret = wl_iovar_getbuf(ifname, iovar, NULL, 0, smbuf, sizeof(smbuf));
 170                 if (ret == 0)
 171                         memcpy(bufptr, smbuf, buflen);
 172         }
 173
 174         return ret;
 175 }
 176
 177 /*
 178  * set named driver variable to int value
 179  * calling example: wl_iovar_setint(ifname, "arate", rate)
 180 */
 181 int
 182 wl_iovar_setint(char *ifname, char *iovar, int val)
 183 {
 184         return wl_iovar_set(ifname, iovar, &val, sizeof(val));
 185 }
 186
 187 /*
 188  * get named driver variable to int value and return error indication
 189  * calling example: wl_iovar_getint(ifname, "arate", &rate)
 190  */
 191 int
 192 wl_iovar_getint(char *ifname, char *iovar, int *val)
 193 {
 194         return wl_iovar_get(ifname, iovar, val, sizeof(int));
 195 }
 196
 197 /*
 198  * format a bsscfg indexed iovar buffer
 199  */
 200 static int
 201 wl_bssiovar_mkbuf(char *iovar, int bssidx, void *param, int paramlen, void *bufptr, int buflen, int *plen)
 202 {
 203         char *prefix = "bsscfg:";
 204         int8* p;
 205         uint prefixlen;
 206         uint namelen;
 207         uint iolen;
 208
 209         prefixlen = strlen(prefix);     /* length of bsscfg prefix */
 210         namelen = strlen(iovar) + 1;    /* length of iovar name + null */
 211         iolen = prefixlen + namelen + sizeof(int) + paramlen;
 212
 213         /* check for overflow */
 214         if (buflen < 0 || iolen > (uint)buflen) {
 215                 *plen = 0;
 216                 return BCME_BUFTOOSHORT;
 217         }
 218
 219         p = (int8*)bufptr;
 220
 221         /* copy prefix, no null */
 222         memcpy(p, prefix, prefixlen);
 223         p += prefixlen;
 224
 225         /* copy iovar name including null */
 226         memcpy(p, iovar, namelen);
 227         p += namelen;
 228
 229         /* bss config index as first param */
 230         memcpy(p, &bssidx, sizeof(int32));
 231         p += sizeof(int32);
 232
 233         /* parameter buffer follows */
 234         if (paramlen)
 235                 memcpy(p, param, paramlen);
 236
 237         *plen = iolen;
 238
 239         // bufptr = bsscfg:<iovar>0<bssidx><param>
 240         return 0;
 241 }
 242
 243 /*
 244  * set named & bss indexed driver variable to buffer value
 245  */
 246 int
 247 wl_bssiovar_setbuf(char *ifname, char *iovar, int bssidx, void *param, int paramlen, void *bufptr, int buflen)
 248 {
 249         int err;
 250         uint iolen;
 251
 252         err = wl_bssiovar_mkbuf(iovar, bssidx, param, paramlen, bufptr, buflen, &iolen);
 253         if (err)
 254                 return err;
 255
 256         return wl_ioctl(ifname, WLC_SET_VAR, bufptr, iolen);
 257 }
 258
 259 /*
 260  * get named & bss indexed driver variable buffer value
 261  */
 262 int
 263 wl_bssiovar_getbuf(char *ifname, char *iovar, int bssidx, void *param, int paramlen, void *bufptr, int buflen)
 264 {
 265         int err;
 266         uint iolen;
 267
 268         err = wl_bssiovar_mkbuf(iovar, bssidx, param, paramlen, bufptr, buflen, &iolen);
 269         if (err)
 270                 return err;
 271
 272         return wl_ioctl(ifname, WLC_GET_VAR, bufptr, buflen);
 273 }
 274
 275
 276 /*
 277  * set named & bss indexed driver variable to buffer value
 278  */
 279 int
 280 wl_bssiovar_set(char *ifname, char *iovar, int bssidx, void *param, int paramlen)
 281 {
 282         char smbuf[WLC_IOCTL_SMLEN];
 283
 284         return wl_bssiovar_setbuf(ifname, iovar, bssidx, param, paramlen, smbuf, sizeof(smbuf));
 285 }
 286
 287 /*
 288  * get named & bss indexed driver variable buffer value
 289  */
 290 int
 291 wl_bssiovar_get(char *ifname, char *iovar, int bssidx, void *outbuf, int len)
 292 {
 293         char smbuf[WLC_IOCTL_SMLEN];
 294         int err;
 295
 296         /* use the return buffer if it is bigger than what we have on the stack */
 297         if (len > (int)sizeof(smbuf)) {
 298                 err = wl_bssiovar_getbuf(ifname, iovar, bssidx, NULL, 0, outbuf, len);
 299         } else {
 300                 memset(smbuf, 0, sizeof(smbuf));
 301                 err = wl_bssiovar_getbuf(ifname, iovar, bssidx, NULL, 0, smbuf, sizeof(smbuf));
 302                 if (err == 0)
 303                         memcpy(outbuf, smbuf, len);
 304         }
 305
 306         return err;
 307 }
 308
 309 /*
 310  * set named & bss indexed driver variable to int value
 311  */
 312 int
 313 wl_bssiovar_setint(char *ifname, char *iovar, int bssidx, int val)
 314 {
 315         return wl_bssiovar_set(ifname, iovar, bssidx, &val, sizeof(int));
 316 }
 317 #endif  // WL_BSS_INFO_VERSION >= 108