utils: fix segfault in iwinfo_hardware_id_from_mtd()
[project/iwinfo.git] / iwinfo_wl.c
1 /*
2  * iwinfo - Wireless Information Library - Broadcom wl.o Backend
3  *
4  *   Copyright (C) 2009 Jo-Philipp Wich <xm@subsignal.org>
5  *
6  * The iwinfo library is free software: you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License version 2
8  * as published by the Free Software Foundation.
9  *
10  * The iwinfo library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13  * See the GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with the iwinfo library. If not, see http://www.gnu.org/licenses/.
17  *
18  * This code is based on the wlc.c utility published by OpenWrt.org .
19  */
20
21 #include "iwinfo.h"
22 #include "api/broadcom.h"
23
24 static int wl_ioctl(const char *name, int cmd, void *buf, int len)
25 {
26         struct ifreq ifr;
27         wl_ioctl_t ioc;
28
29         /* do it */
30         ioc.cmd = cmd;
31         ioc.buf = buf;
32         ioc.len = len;
33
34         strncpy(ifr.ifr_name, name, IFNAMSIZ);
35         ifr.ifr_data = (caddr_t) &ioc;
36
37         return iwinfo_ioctl(SIOCDEVPRIVATE, &ifr);
38 }
39
40 static int wl_iovar(const char *name, const char *cmd, const char *arg,
41                                         int arglen, void *buf, int buflen)
42 {
43         int cmdlen = strlen(cmd) + 1;
44
45         memcpy(buf, cmd, cmdlen);
46
47         if (arg && arglen > 0)
48                 memcpy(buf + cmdlen, arg, arglen);
49
50         return wl_ioctl(name, WLC_GET_VAR, buf, buflen);
51 }
52
53 static struct wl_maclist * wl_read_assoclist(const char *ifname)
54 {
55         struct wl_maclist *macs;
56         int maclen = 4 + WL_MAX_STA_COUNT * 6;
57
58         if (strstr(ifname, "wds"))
59                 return NULL;
60
61         if ((macs = (struct wl_maclist *) malloc(maclen)) != NULL)
62         {
63                 memset(macs, 0, maclen);
64                 macs->count = WL_MAX_STA_COUNT;
65
66                 if (!wl_ioctl(ifname, WLC_GET_ASSOCLIST, macs, maclen))
67                         return macs;
68
69                 free(macs);
70         }
71
72         return NULL;
73 }
74
75
76 static int wl_probe(const char *ifname)
77 {
78         int magic;
79         return (!wl_ioctl(ifname, WLC_GET_MAGIC, &magic, sizeof(magic)) &&
80                         (magic == WLC_IOCTL_MAGIC));
81 }
82
83 static void wl_close(void)
84 {
85         /* Nop */
86 }
87
88 static int wl_get_mode(const char *ifname, int *buf)
89 {
90         int ret = -1;
91         int ap, infra, passive;
92
93         if ((ret = wl_ioctl(ifname, WLC_GET_AP, &ap, sizeof(ap))))
94                 return ret;
95
96         if ((ret = wl_ioctl(ifname, WLC_GET_INFRA, &infra, sizeof(infra))))
97                 return ret;
98
99         if ((ret = wl_ioctl(ifname, WLC_GET_PASSIVE, &passive, sizeof(passive))))
100                 return ret;
101
102         if (passive)
103                 *buf = IWINFO_OPMODE_MONITOR;
104         else if (!infra)
105                 *buf = IWINFO_OPMODE_ADHOC;
106         else if (ap)
107                 *buf = IWINFO_OPMODE_MASTER;
108         else
109                 *buf = IWINFO_OPMODE_CLIENT;
110
111         return 0;
112 }
113
114 static int wl_get_ssid(const char *ifname, char *buf)
115 {
116         int ret = -1;
117         wlc_ssid_t ssid;
118
119         if (!(ret = wl_ioctl(ifname, WLC_GET_SSID, &ssid, sizeof(ssid))))
120                 memcpy(buf, ssid.ssid, ssid.ssid_len);
121
122         return ret;
123 }
124
125 static int wl_get_bssid(const char *ifname, char *buf)
126 {
127         int ret = -1;
128         char bssid[6];
129
130         if (!(ret = wl_ioctl(ifname, WLC_GET_BSSID, bssid, 6)))
131                 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
132                         (uint8_t)bssid[0], (uint8_t)bssid[1], (uint8_t)bssid[2],
133                         (uint8_t)bssid[3], (uint8_t)bssid[4], (uint8_t)bssid[5]
134                 );
135
136         return ret;
137 }
138
139 static int wl_get_channel(const char *ifname, int *buf)
140 {
141         return wl_ioctl(ifname, WLC_GET_CHANNEL, buf, sizeof(buf));
142 }
143
144 static int wl_get_frequency(const char *ifname, int *buf)
145 {
146         return wext_ops.frequency(ifname, buf);
147 }
148
149 static int wl_get_txpower(const char *ifname, int *buf)
150 {
151         /* WLC_GET_VAR "qtxpower" */
152         return wext_ops.txpower(ifname, buf);
153 }
154
155 static int wl_get_bitrate(const char *ifname, int *buf)
156 {
157         int ret = -1;
158         int rate = 0;
159
160         if( !(ret = wl_ioctl(ifname, WLC_GET_RATE, &rate, sizeof(rate))) && (rate > 0))
161                 *buf = ((rate / 2) * 1000) + ((rate & 1) ? 500 : 0);
162
163         return ret;
164 }
165
166 static int wl_get_signal(const char *ifname, int *buf)
167 {
168         unsigned int ap, rssi, i, rssi_count;
169         int ioctl_req_version = 0x2000;
170         char tmp[WLC_IOCTL_MAXLEN];
171         struct wl_maclist *macs = NULL;
172         wl_sta_rssi_t starssi;
173
174         memset(tmp, 0, WLC_IOCTL_MAXLEN);
175         memcpy(tmp, &ioctl_req_version, sizeof(ioctl_req_version));
176
177         wl_ioctl(ifname, WLC_GET_BSS_INFO, tmp, WLC_IOCTL_MAXLEN);
178
179         if (!wl_ioctl(ifname, WLC_GET_AP, &ap, sizeof(ap)) && !ap)
180         {
181                 *buf = tmp[WL_BSS_RSSI_OFFSET];
182         }
183         else
184         {
185                 rssi = rssi_count = 0;
186
187                 /* Calculate average rssi from conntected stations */
188                 if ((macs = wl_read_assoclist(ifname)) != NULL)
189                 {
190                         for (i = 0; i < macs->count; i++)
191                         {
192                                 memcpy(starssi.mac, &macs->ea[i], 6);
193
194                                 if (!wl_ioctl(ifname, WLC_GET_RSSI, &starssi, 12))
195                                 {
196                                         rssi -= starssi.rssi;
197                                         rssi_count++;
198                                 }
199                         }
200
201                         free(macs);
202                 }
203
204                 *buf = (rssi == 0 || rssi_count == 0) ? 1 : -(rssi / rssi_count);
205         }
206
207         return 0;
208 }
209
210 static int wl_get_noise(const char *ifname, int *buf)
211 {
212         unsigned int ap, noise;
213         int ioctl_req_version = 0x2000;
214         char tmp[WLC_IOCTL_MAXLEN];
215
216         memset(tmp, 0, WLC_IOCTL_MAXLEN);
217         memcpy(tmp, &ioctl_req_version, sizeof(ioctl_req_version));
218
219         wl_ioctl(ifname, WLC_GET_BSS_INFO, tmp, WLC_IOCTL_MAXLEN);
220
221         if ((wl_ioctl(ifname, WLC_GET_AP, &ap, sizeof(ap)) < 0) || ap)
222         {
223                 if (wl_ioctl(ifname, WLC_GET_PHY_NOISE, &noise, sizeof(noise)) < 0)
224                         noise = 0;
225         }
226         else
227         {
228                 noise = tmp[WL_BSS_NOISE_OFFSET];
229         }
230
231         *buf = noise;
232
233         return 0;
234 }
235
236 static int wl_get_quality(const char *ifname, int *buf)
237 {
238         return wext_ops.quality(ifname, buf);
239 }
240
241 static int wl_get_quality_max(const char *ifname, int *buf)
242 {
243         return wext_ops.quality_max(ifname, buf);
244 }
245
246 static int wl_get_encryption(const char *ifname, char *buf)
247 {
248         uint32_t wsec, wauth, wpa;
249         struct iwinfo_crypto_entry *c = (struct iwinfo_crypto_entry *)buf;
250
251         if( wl_ioctl(ifname, WLC_GET_WPA_AUTH, &wpa,   sizeof(uint32_t)) ||
252             wl_ioctl(ifname, WLC_GET_WSEC,     &wsec,  sizeof(uint32_t)) ||
253                 wl_ioctl(ifname, WLC_GET_AUTH,     &wauth, sizeof(uint32_t)) )
254                         return -1;
255
256         switch(wsec)
257         {
258                 case 2:
259                         c->pair_ciphers |= IWINFO_CIPHER_TKIP;
260                         break;
261
262                 case 4:
263                         c->pair_ciphers |= IWINFO_CIPHER_CCMP;
264                         break;
265
266                 case 6:
267                         c->pair_ciphers |= IWINFO_CIPHER_TKIP;
268                         c->pair_ciphers |= IWINFO_CIPHER_CCMP;
269                         break;
270         }
271
272         switch(wpa)
273         {
274                 case 0:
275                         if (wsec && !wauth)
276                                 c->auth_algs |= IWINFO_AUTH_OPEN;
277
278                         else if (wsec && wauth)
279                                 c->auth_algs |= IWINFO_AUTH_SHARED;
280
281                         /* ToDo: evaluate WEP key lengths */
282                         c->pair_ciphers = IWINFO_CIPHER_WEP40 | IWINFO_CIPHER_WEP104;
283                         c->auth_suites |= IWINFO_KMGMT_NONE;
284                         break;
285
286                 case 2:
287                         c->wpa_version = 1;
288                         c->auth_suites |= IWINFO_KMGMT_8021x;
289                         break;
290
291                 case 4:
292                         c->wpa_version = 1;
293                         c->auth_suites |= IWINFO_KMGMT_PSK;
294                         break;
295
296                 case 32:
297                 case 64:
298                         c->wpa_version = 2;
299                         c->auth_suites |= IWINFO_KMGMT_8021x;
300                         break;
301
302                 case 66:
303                         c->wpa_version = 3;
304                         c->auth_suites |= IWINFO_KMGMT_8021x;
305                         break;
306
307                 case 128:
308                         c->wpa_version = 2;
309                         c->auth_suites |= IWINFO_KMGMT_PSK;
310                         break;
311
312                 case 132:
313                         c->wpa_version = 3;
314                         c->auth_suites |= IWINFO_KMGMT_PSK;
315                         break;
316
317                 default:
318                         break;
319         }
320
321         c->enabled = (c->wpa_version || c->auth_algs) ? 1 : 0;
322         c->group_ciphers = c->pair_ciphers;
323
324         return 0;
325 }
326
327 static int wl_get_phyname(const char *ifname, char *buf)
328 {
329         char *p;
330
331         strcpy(buf, ifname);
332
333         if ((p = strchr(buf, '.')) != NULL)
334                 *p = 0;
335
336         return 0;
337 }
338
339 static int wl_get_enctype(const char *ifname, char *buf)
340 {
341         uint32_t wsec, wpa;
342         char algo[11];
343
344         if( wl_ioctl(ifname, WLC_GET_WPA_AUTH, &wpa, sizeof(uint32_t)) ||
345             wl_ioctl(ifname, WLC_GET_WSEC, &wsec, sizeof(uint32_t)) )
346                         return -1;
347
348         switch(wsec)
349         {
350                 case 2:
351                         sprintf(algo, "TKIP");
352                         break;
353
354                 case 4:
355                         sprintf(algo, "CCMP");
356                         break;
357
358                 case 6:
359                         sprintf(algo, "TKIP, CCMP");
360                         break;
361         }
362
363         switch(wpa)
364         {
365                 case 0:
366                         sprintf(buf, "%s", wsec ? "WEP" : "None");
367                         break;
368
369                 case 2:
370                         sprintf(buf, "WPA 802.1X (%s)", algo);
371                         break;
372
373                 case 4:
374                         sprintf(buf, "WPA PSK (%s)", algo);
375                         break;
376
377                 case 32:
378                         sprintf(buf, "802.1X (%s)", algo);
379                         break;
380
381                 case 64:
382                         sprintf(buf, "WPA2 802.1X (%s)", algo);
383                         break;
384
385                 case 66:
386                         sprintf(buf, "mixed WPA/WPA2 802.1X (%s)", algo);
387                         break;
388
389                 case 128:
390                         sprintf(buf, "WPA2 PSK (%s)", algo);
391                         break;
392
393                 case 132:
394                         sprintf(buf, "mixed WPA/WPA2 PSK (%s)", algo);
395                         break;
396
397                 default:
398                         sprintf(buf, "Unknown");
399         }
400
401         return 0;
402 }
403
404 static void wl_get_assoclist_cb(const char *ifname,
405                                                             struct iwinfo_assoclist_entry *e)
406 {
407         wl_sta_info_t sta = { 0 };
408
409         if (!wl_iovar(ifname, "sta_info", e->mac, 6, &sta, sizeof(sta)) &&
410                 (sta.ver >= 2))
411         {
412                 e->inactive     = sta.idle * 1000;
413                 e->rx_packets   = sta.rx_ucast_pkts;
414                 e->tx_packets   = sta.tx_pkts;
415                 e->rx_rate.rate = sta.rx_rate;
416                 e->tx_rate.rate = sta.tx_rate;
417
418                 /* ToDo: 11n */
419                 e->rx_rate.mcs = -1;
420                 e->tx_rate.mcs = -1;
421         }
422 }
423
424 static int wl_get_assoclist(const char *ifname, char *buf, int *len)
425 {
426         int i, j, noise;
427         int ap, infra, passive;
428         char line[128];
429         char macstr[18];
430         char devstr[IFNAMSIZ];
431         struct wl_maclist *macs;
432         struct wl_sta_rssi rssi;
433         struct iwinfo_assoclist_entry entry;
434         FILE *arp;
435
436         ap = infra = passive = 0;
437
438         wl_ioctl(ifname, WLC_GET_AP, &ap, sizeof(ap));
439         wl_ioctl(ifname, WLC_GET_INFRA, &infra, sizeof(infra));
440         wl_ioctl(ifname, WLC_GET_PASSIVE, &passive, sizeof(passive));
441
442         if (wl_get_noise(ifname, &noise))
443                 noise = 0;
444
445         if ((ap || infra || passive) && ((macs = wl_read_assoclist(ifname)) != NULL))
446         {
447                 for (i = 0, j = 0; i < macs->count; i++, j += sizeof(struct iwinfo_assoclist_entry))
448                 {
449                         memset(&entry, 0, sizeof(entry));
450                         memcpy(rssi.mac, &macs->ea[i], 6);
451
452                         if (!wl_ioctl(ifname, WLC_GET_RSSI, &rssi, sizeof(struct wl_sta_rssi)))
453                                 entry.signal = (rssi.rssi - 0x100);
454                         else
455                                 entry.signal = 0;
456
457                         entry.noise = noise;
458                         memcpy(entry.mac, &macs->ea[i], 6);
459                         wl_get_assoclist_cb(ifname, &entry);
460
461                         memcpy(&buf[j], &entry, sizeof(entry));
462                 }
463
464                 *len = j;
465                 free(macs);
466                 return 0;
467         }
468         else if ((arp = fopen("/proc/net/arp", "r")) != NULL)
469         {
470                 j = 0;
471
472                 while (fgets(line, sizeof(line), arp) != NULL)
473                 {
474                         if (sscanf(line, "%*s 0x%*d 0x%*d %17s %*s %s", macstr, devstr) && !strcmp(devstr, ifname))
475                         {
476                                 rssi.mac[0] = strtol(&macstr[0],  NULL, 16);
477                                 rssi.mac[1] = strtol(&macstr[3],  NULL, 16);
478                                 rssi.mac[2] = strtol(&macstr[6],  NULL, 16);
479                                 rssi.mac[3] = strtol(&macstr[9],  NULL, 16);
480                                 rssi.mac[4] = strtol(&macstr[12], NULL, 16);
481                                 rssi.mac[5] = strtol(&macstr[15], NULL, 16);
482
483                                 if (!wl_ioctl(ifname, WLC_GET_RSSI, &rssi, sizeof(struct wl_sta_rssi)))
484                                         entry.signal = (rssi.rssi - 0x100);
485                                 else
486                                         entry.signal = 0;
487
488                                 entry.noise = noise;
489                                 memcpy(entry.mac, rssi.mac, 6);
490                                 memcpy(&buf[j], &entry, sizeof(entry));
491
492                                 j += sizeof(entry);
493                         }
494                 }
495
496                 *len = j;
497                 (void) fclose(arp);
498                 return 0;
499         }
500
501         return -1;
502 }
503
504 static int wl_get_txpwrlist(const char *ifname, char *buf, int *len)
505 {
506         struct iwinfo_txpwrlist_entry entry;
507         uint8_t dbm[11] = { 0, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24 };
508         uint8_t mw[11]  = { 1, 3, 6, 10, 15, 25, 39, 63, 100, 158, 251 };
509         int i;
510
511         for (i = 0; i < 11; i++)
512         {
513                 entry.dbm = dbm[i];
514                 entry.mw  = mw[i];
515                 memcpy(&buf[i*sizeof(entry)], &entry, sizeof(entry));
516         }
517
518         *len = 11 * sizeof(entry);
519         return 0;
520 }
521
522 static int wl_get_scanlist(const char *ifname, char *buf, int *len)
523 {
524         return wext_ops.scanlist(ifname, buf, len);
525 }
526
527 static int wl_get_freqlist(const char *ifname, char *buf, int *len)
528 {
529         return wext_ops.freqlist(ifname, buf, len);
530 }
531
532 static int wl_get_country(const char *ifname, char *buf)
533 {
534         char ccode[WLC_CNTRY_BUF_SZ];
535
536         if (!wl_ioctl(ifname, WLC_GET_COUNTRY, ccode, WLC_CNTRY_BUF_SZ))
537         {
538                 /* IL0 -> World */
539                 if (!strcmp(ccode, "IL0"))
540                         sprintf(buf, "00");
541
542                 /* YU -> RS */
543                 else if (!strcmp(ccode, "YU"))
544                         sprintf(buf, "RS");
545
546                 else
547                         memcpy(buf, ccode, 2);
548
549                 return 0;
550         }
551
552         return -1;
553 }
554
555 static int wl_get_countrylist(const char *ifname, char *buf, int *len)
556 {
557         int i, count;
558         char cdata[WLC_IOCTL_MAXLEN];
559         struct iwinfo_country_entry *c = (struct iwinfo_country_entry *)buf;
560         wl_country_list_t *cl = (wl_country_list_t *)cdata;
561
562         cl->buflen = sizeof(cdata);
563
564         if (!wl_ioctl(ifname, WLC_GET_COUNTRY_LIST, cl, cl->buflen))
565         {
566                 for (i = 0, count = 0; i < cl->count; i++, c++)
567                 {
568                         snprintf(c->ccode, sizeof(c->ccode), "%s", &cl->country_abbrev[i * WLC_CNTRY_BUF_SZ]);
569                         c->iso3166 = c->ccode[0] * 256 + c->ccode[1];
570
571                         /* IL0 -> World */
572                         if (!strcmp(c->ccode, "IL0"))
573                                 c->iso3166 = 0x3030;
574
575                         /* YU -> RS */
576                         else if (!strcmp(c->ccode, "YU"))
577                                 c->iso3166 = 0x5253;
578                 }
579
580                 *len = (i * sizeof(struct iwinfo_country_entry));
581                 return 0;
582         }
583
584         return -1;
585 }
586
587 static int wl_get_hwmodelist(const char *ifname, int *buf)
588 {
589         int phytype;
590         uint i, band[WLC_BAND_ALL], bands;
591
592         if (!wl_ioctl(ifname, WLC_GET_PHYTYPE, &phytype, sizeof(phytype)) &&
593                 !wl_ioctl(ifname, WLC_GET_BANDLIST, band, sizeof(band)))
594         {
595                 *buf = 0;
596                 switch (phytype)
597                 {
598                         case WLC_PHY_TYPE_A:
599                                 *buf = IWINFO_80211_A;
600                                 break;
601                         case WLC_PHY_TYPE_B:
602                                 *buf = IWINFO_80211_B;
603                                 break;
604                         case WLC_PHY_TYPE_AC:
605                                 *buf |= IWINFO_80211_AC;
606                         case WLC_PHY_TYPE_HT:
607                         case WLC_PHY_TYPE_N:
608                                 *buf |= IWINFO_80211_N;
609                         case WLC_PHY_TYPE_LP:
610                         case WLC_PHY_TYPE_G:
611                                 bands = 0;
612                                 for (i = 1; i <= band[0]; i++)
613                                 {
614                                         bands |= band[i];
615                                 }
616                                 if (bands & WLC_BAND_5G)
617                                         *buf |= IWINFO_80211_A;
618                                 if (bands & WLC_BAND_2G)
619                                 {
620                                         *buf |= IWINFO_80211_B;
621                                         *buf |= IWINFO_80211_G;
622                                 }
623                                 break;
624                         default:
625                                 return -1;
626                                 break;
627                 }
628                         return 0;
629         }
630         return -1;
631 }
632
633 static int wl_get_htmodelist(const char *ifname, int *buf)
634 {
635         int modes;
636
637         if (!wl_get_hwmodelist(ifname, &modes))
638         {
639                 *buf = 0;
640
641                 /* FIXME: determine real capabilities */
642
643                 if (modes & IWINFO_80211_N)
644                         *buf |= IWINFO_HTMODE_HT20 | IWINFO_HTMODE_HT40;
645
646                 if (modes & IWINFO_80211_AC)
647                         *buf |= IWINFO_HTMODE_VHT20 | IWINFO_HTMODE_VHT40 |
648                                 IWINFO_HTMODE_VHT80;
649
650                 return 0;
651         }
652
653         return -1;
654 }
655
656 static int wl_get_mbssid_support(const char *ifname, int *buf)
657 {
658         wlc_rev_info_t revinfo;
659
660         /* Multi bssid support only works on corerev >= 9 */
661         if (!wl_ioctl(ifname, WLC_GET_REVINFO, &revinfo, sizeof(revinfo)))
662         {
663                 if (revinfo.corerev >= 9)
664                 {
665                         *buf = 1;
666                         return 0;
667                 }
668         }
669
670         return -1;
671 }
672
673 static int wl_get_hardware_id(const char *ifname, char *buf)
674 {
675         wlc_rev_info_t revinfo;
676         struct iwinfo_hardware_id *ids = (struct iwinfo_hardware_id *)buf;
677
678         if (wl_ioctl(ifname, WLC_GET_REVINFO, &revinfo, sizeof(revinfo)))
679                 return -1;
680
681         ids->vendor_id = revinfo.vendorid;
682         ids->device_id = revinfo.deviceid;
683         ids->subsystem_vendor_id = revinfo.boardvendor;
684         ids->subsystem_device_id = revinfo.boardid;
685
686         return 0;
687 }
688
689 static int wl_get_hardware_name(const char *ifname, char *buf)
690 {
691         struct iwinfo_hardware_id ids;
692
693         if (wl_get_hardware_id(ifname, (char *)&ids))
694                 return -1;
695
696         sprintf(buf, "Broadcom BCM%04X", ids.device_id);
697
698         return 0;
699 }
700
701 static int wl_get_txpower_offset(const char *ifname, int *buf)
702 {
703         FILE *p;
704         char off[8];
705
706         *buf = 0;
707
708         if ((p = popen("/usr/sbin/nvram get opo", "r")) != NULL)
709         {
710                 if (fread(off, 1, sizeof(off), p))
711                         *buf = strtoul(off, NULL, 16);
712
713                 pclose(p);
714         }
715
716         return 0;
717 }
718
719 static int wl_get_frequency_offset(const char *ifname, int *buf)
720 {
721         /* Stub */
722         *buf = 0;
723         return -1;
724 }
725
726 const struct iwinfo_ops wl_ops = {
727         .name             = "wl",
728         .probe            = wl_probe,
729         .channel          = wl_get_channel,
730         .frequency        = wl_get_frequency,
731         .frequency_offset = wl_get_frequency_offset,
732         .txpower          = wl_get_txpower,
733         .txpower_offset   = wl_get_txpower_offset,
734         .bitrate          = wl_get_bitrate,
735         .signal           = wl_get_signal,
736         .noise            = wl_get_noise,
737         .quality          = wl_get_quality,
738         .quality_max      = wl_get_quality_max,
739         .mbssid_support   = wl_get_mbssid_support,
740         .hwmodelist       = wl_get_hwmodelist,
741         .htmodelist       = wl_get_htmodelist,
742         .mode             = wl_get_mode,
743         .ssid             = wl_get_ssid,
744         .bssid            = wl_get_bssid,
745         .country          = wl_get_country,
746         .hardware_id      = wl_get_hardware_id,
747         .hardware_name    = wl_get_hardware_name,
748         .encryption       = wl_get_encryption,
749         .phyname          = wl_get_phyname,
750         .assoclist        = wl_get_assoclist,
751         .txpwrlist        = wl_get_txpwrlist,
752         .scanlist         = wl_get_scanlist,
753         .freqlist         = wl_get_freqlist,
754         .countrylist      = wl_get_countrylist,
755         .close            = wl_close
756 };