projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
refresh generic 2.6.24 patches to match upstream style
[openwrt.git] / package / libertas / src / 11d.c
1 /**
2 * This file contains functions for 802.11D.
3 */
4 #include <linux/ctype.h>
5 #include <linux/kernel.h>
6 #include <linux/wireless.h>
7
8 #include "host.h"
9 #include "decl.h"
10 #include "11d.h"
11 #include "dev.h"
12 #include "wext.h"
13
14 #define TX_PWR_DEFAULT 10
15
16 static struct region_code_mapping region_code_mapping[] = {
17 {"US ", 0x10}, /* US FCC */
18 {"CA ", 0x10}, /* IC Canada */
19 {"SG ", 0x10}, /* Singapore */
20 {"EU ", 0x30}, /* ETSI */
21 {"AU ", 0x30}, /* Australia */
22 {"KR ", 0x30}, /* Republic Of Korea */
23 {"ES ", 0x31}, /* Spain */
24 {"FR ", 0x32}, /* France */
25 {"JP ", 0x40}, /* Japan */
26 };
27
28 /* Following 2 structure defines the supported channels */
29 static struct chan_freq_power channel_freq_power_UN_BG[] = {
30 {1, 2412, TX_PWR_DEFAULT},
31 {2, 2417, TX_PWR_DEFAULT},
32 {3, 2422, TX_PWR_DEFAULT},
33 {4, 2427, TX_PWR_DEFAULT},
34 {5, 2432, TX_PWR_DEFAULT},
35 {6, 2437, TX_PWR_DEFAULT},
36 {7, 2442, TX_PWR_DEFAULT},
37 {8, 2447, TX_PWR_DEFAULT},
38 {9, 2452, TX_PWR_DEFAULT},
39 {10, 2457, TX_PWR_DEFAULT},
40 {11, 2462, TX_PWR_DEFAULT},
41 {12, 2467, TX_PWR_DEFAULT},
42 {13, 2472, TX_PWR_DEFAULT},
43 {14, 2484, TX_PWR_DEFAULT}
44 };
45
46 static u8 lbs_region_2_code(u8 *region)
47 {
48 u8 i;
49 u8 size = sizeof(region_code_mapping)/
50 sizeof(struct region_code_mapping);
51
52 for (i = 0; region[i] && i < COUNTRY_CODE_LEN; i++)
53 region[i] = toupper(region[i]);
54
55 for (i = 0; i < size; i++) {
56 if (!memcmp(region, region_code_mapping[i].region,
57 COUNTRY_CODE_LEN))
58 return (region_code_mapping[i].code);
59 }
60
61 /* default is US */
62 return (region_code_mapping[0].code);
63 }
64
65 static u8 *lbs_code_2_region(u8 code)
66 {
67 u8 i;
68 u8 size = sizeof(region_code_mapping)
69 / sizeof(struct region_code_mapping);
70 for (i = 0; i < size; i++) {
71 if (region_code_mapping[i].code == code)
72 return (region_code_mapping[i].region);
73 }
74 /* default is US */
75 return (region_code_mapping[0].region);
76 }
77
78 /**
79 * @brief This function finds the nrchan-th chan after the firstchan
80 * @param band band
81 * @param firstchan first channel number
82 * @param nrchan number of channels
83 * @return the nrchan-th chan number
84 */
85 static u8 lbs_get_chan_11d(u8 band, u8 firstchan, u8 nrchan, u8 *chan)
86 /*find the nrchan-th chan after the firstchan*/
87 {
88 u8 i;
89 struct chan_freq_power *cfp;
90 u8 cfp_no;
91
92 cfp = channel_freq_power_UN_BG;
93 cfp_no = sizeof(channel_freq_power_UN_BG) /
94 sizeof(struct chan_freq_power);
95
96 for (i = 0; i < cfp_no; i++) {
97 if ((cfp + i)->channel == firstchan) {
98 lbs_deb_11d("firstchan found\n");
99 break;
100 }
101 }
102
103 if (i < cfp_no) {
104 /*if beyond the boundary */
105 if (i + nrchan < cfp_no) {
106 *chan = (cfp + i + nrchan)->channel;
107 return 1;
108 }
109 }
110
111 return 0;
112 }
113
114 /**
115 * @brief This function Checks if chan txpwr is learned from AP/IBSS
116 * @param chan chan number
117 * @param parsed_region_chan pointer to parsed_region_chan_11d
118 * @return TRUE; FALSE
119 */
120 static u8 lbs_channel_known_11d(u8 chan,
121 struct parsed_region_chan_11d * parsed_region_chan)
122 {
123 struct chan_power_11d *chanpwr = parsed_region_chan->chanpwr;
124 u8 nr_chan = parsed_region_chan->nr_chan;
125 u8 i = 0;
126
127 lbs_deb_hex(LBS_DEB_11D, "parsed_region_chan", (char *)chanpwr,
128 sizeof(struct chan_power_11d) * nr_chan);
129
130 for (i = 0; i < nr_chan; i++) {
131 if (chan == chanpwr[i].chan) {
132 lbs_deb_11d("found chan %d\n", chan);
133 return 1;
134 }
135 }
136
137 lbs_deb_11d("chan %d not found\n", chan);
138 return 0;
139 }
140
141 u32 lbs_chan_2_freq(u8 chan, u8 band)
142 {
143 struct chan_freq_power *cf;
144 u16 cnt;
145 u16 i;
146 u32 freq = 0;
147
148 cf = channel_freq_power_UN_BG;
149 cnt =
150 sizeof(channel_freq_power_UN_BG) /
151 sizeof(struct chan_freq_power);
152
153 for (i = 0; i < cnt; i++) {
154 if (chan == cf[i].channel)
155 freq = cf[i].freq;
156 }
157
158 return freq;
159 }
160
161 static int generate_domain_info_11d(struct parsed_region_chan_11d
162 *parsed_region_chan,
163 struct lbs_802_11d_domain_reg *domaininfo)
164 {
165 u8 nr_subband = 0;
166
167 u8 nr_chan = parsed_region_chan->nr_chan;
168 u8 nr_parsedchan = 0;
169
170 u8 firstchan = 0, nextchan = 0, maxpwr = 0;
171
172 u8 i, flag = 0;
173
174 memcpy(domaininfo->countrycode, parsed_region_chan->countrycode,
175 COUNTRY_CODE_LEN);
176
177 lbs_deb_11d("nrchan %d\n", nr_chan);
178 lbs_deb_hex(LBS_DEB_11D, "parsed_region_chan", (char *)parsed_region_chan,
179 sizeof(struct parsed_region_chan_11d));
180
181 for (i = 0; i < nr_chan; i++) {
182 if (!flag) {
183 flag = 1;
184 nextchan = firstchan =
185 parsed_region_chan->chanpwr[i].chan;
186 maxpwr = parsed_region_chan->chanpwr[i].pwr;
187 nr_parsedchan = 1;
188 continue;
189 }
190
191 if (parsed_region_chan->chanpwr[i].chan == nextchan + 1 &&
192 parsed_region_chan->chanpwr[i].pwr == maxpwr) {
193 nextchan++;
194 nr_parsedchan++;
195 } else {
196 domaininfo->subband[nr_subband].firstchan = firstchan;
197 domaininfo->subband[nr_subband].nrchan =
198 nr_parsedchan;
199 domaininfo->subband[nr_subband].maxtxpwr = maxpwr;
200 nr_subband++;
201 nextchan = firstchan =
202 parsed_region_chan->chanpwr[i].chan;
203 maxpwr = parsed_region_chan->chanpwr[i].pwr;
204 }
205 }
206
207 if (flag) {
208 domaininfo->subband[nr_subband].firstchan = firstchan;
209 domaininfo->subband[nr_subband].nrchan = nr_parsedchan;
210 domaininfo->subband[nr_subband].maxtxpwr = maxpwr;
211 nr_subband++;
212 }
213 domaininfo->nr_subband = nr_subband;
214
215 lbs_deb_11d("nr_subband=%x\n", domaininfo->nr_subband);
216 lbs_deb_hex(LBS_DEB_11D, "domaininfo", (char *)domaininfo,
217 COUNTRY_CODE_LEN + 1 +
218 sizeof(struct ieeetypes_subbandset) * nr_subband);
219 return 0;
220 }
221
222 /**
223 * @brief This function generates parsed_region_chan from Domain Info learned from AP/IBSS
224 * @param region_chan pointer to struct region_channel
225 * @param *parsed_region_chan pointer to parsed_region_chan_11d
226 * @return N/A
227 */
228 static void lbs_generate_parsed_region_chan_11d(struct region_channel *region_chan,
229 struct parsed_region_chan_11d *
230 parsed_region_chan)
231 {
232 u8 i;
233 struct chan_freq_power *cfp;
234
235 if (region_chan == NULL) {
236 lbs_deb_11d("region_chan is NULL\n");
237 return;
238 }
239
240 cfp = region_chan->CFP;
241 if (cfp == NULL) {
242 lbs_deb_11d("cfp is NULL \n");
243 return;
244 }
245
246 parsed_region_chan->band = region_chan->band;
247 parsed_region_chan->region = region_chan->region;
248 memcpy(parsed_region_chan->countrycode,
249 lbs_code_2_region(region_chan->region), COUNTRY_CODE_LEN);
250
251 lbs_deb_11d("region 0x%x, band %d\n", parsed_region_chan->region,
252 parsed_region_chan->band);
253
254 for (i = 0; i < region_chan->nrcfp; i++, cfp++) {
255 parsed_region_chan->chanpwr[i].chan = cfp->channel;
256 parsed_region_chan->chanpwr[i].pwr = cfp->maxtxpower;
257 lbs_deb_11d("chan %d, pwr %d\n",
258 parsed_region_chan->chanpwr[i].chan,
259 parsed_region_chan->chanpwr[i].pwr);
260 }
261 parsed_region_chan->nr_chan = region_chan->nrcfp;
262
263 lbs_deb_11d("nrchan %d\n", parsed_region_chan->nr_chan);
264
265 return;
266 }
267
268 /**
269 * @brief generate parsed_region_chan from Domain Info learned from AP/IBSS
270 * @param region region ID
271 * @param band band
272 * @param chan chan
273 * @return TRUE;FALSE
274 */
275 static u8 lbs_region_chan_supported_11d(u8 region, u8 band, u8 chan)
276 {
277 struct chan_freq_power *cfp;
278 int cfp_no;
279 u8 idx;
280 int ret = 0;
281
282 lbs_deb_enter(LBS_DEB_11D);
283
284 cfp = lbs_get_region_cfp_table(region, band, &cfp_no);
285 if (cfp == NULL)
286 return 0;
287
288 for (idx = 0; idx < cfp_no; idx++) {
289 if (chan == (cfp + idx)->channel) {
290 /* If Mrvl Chip Supported? */
291 if ((cfp + idx)->unsupported) {
292 ret = 0;
293 } else {
294 ret = 1;
295 }
296 goto done;
297 }
298 }
299
300 /*chan is not in the region table */
301
302 done:
303 lbs_deb_leave_args(LBS_DEB_11D, "ret %d", ret);
304 return ret;
305 }
306
307 /**
308 * @brief This function checks if chan txpwr is learned from AP/IBSS
309 * @param chan chan number
310 * @param parsed_region_chan pointer to parsed_region_chan_11d
311 * @return 0
312 */
313 static int parse_domain_info_11d(struct ieeetypes_countryinfofullset*
314 countryinfo,
315 u8 band,
316 struct parsed_region_chan_11d *
317 parsed_region_chan)
318 {
319 u8 nr_subband, nrchan;
320 u8 lastchan, firstchan;
321 u8 region;
322 u8 curchan = 0;
323
324 u8 idx = 0; /*chan index in parsed_region_chan */
325
326 u8 j, i;
327
328 lbs_deb_enter(LBS_DEB_11D);
329
330 /*validation Rules:
331 1. valid region Code
332 2. First Chan increment
333 3. channel range no overlap
334 4. channel is valid?
335 5. channel is supported by region?
336 6. Others
337 */
338
339 lbs_deb_hex(LBS_DEB_11D, "countryinfo", (u8 *) countryinfo, 30);
340
341 if ((*(countryinfo->countrycode)) == 0
342 || (countryinfo->len <= COUNTRY_CODE_LEN)) {
343 /* No region Info or Wrong region info: treat as No 11D info */
344 goto done;
345 }
346
347 /*Step1: check region_code */
348 parsed_region_chan->region = region =
349 lbs_region_2_code(countryinfo->countrycode);
350
351 lbs_deb_11d("regioncode=%x\n", (u8) parsed_region_chan->region);
352 lbs_deb_hex(LBS_DEB_11D, "countrycode", (char *)countryinfo->countrycode,
353 COUNTRY_CODE_LEN);
354
355 parsed_region_chan->band = band;
356
357 memcpy(parsed_region_chan->countrycode, countryinfo->countrycode,
358 COUNTRY_CODE_LEN);
359
360 nr_subband = (countryinfo->len - COUNTRY_CODE_LEN) /
361 sizeof(struct ieeetypes_subbandset);
362
363 for (j = 0, lastchan = 0; j < nr_subband; j++) {
364
365 if (countryinfo->subband[j].firstchan <= lastchan) {
366 /*Step2&3. Check First Chan Num increment and no overlap */
367 lbs_deb_11d("chan %d>%d, overlap\n",
368 countryinfo->subband[j].firstchan, lastchan);
369 continue;
370 }
371
372 firstchan = countryinfo->subband[j].firstchan;
373 nrchan = countryinfo->subband[j].nrchan;
374
375 for (i = 0; idx < MAX_NO_OF_CHAN && i < nrchan; i++) {
376 /*step4: channel is supported? */
377
378 if (!lbs_get_chan_11d(band, firstchan, i, &curchan)) {
379 /* Chan is not found in UN table */
380 lbs_deb_11d("chan is not supported: %d \n", i);
381 break;
382 }
383
384 lastchan = curchan;
385
386 if (lbs_region_chan_supported_11d
387 (region, band, curchan)) {
388 /*step5: Check if curchan is supported by mrvl in region */
389 parsed_region_chan->chanpwr[idx].chan = curchan;
390 parsed_region_chan->chanpwr[idx].pwr =
391 countryinfo->subband[j].maxtxpwr;
392 idx++;
393 } else {
394 /*not supported and ignore the chan */
395 lbs_deb_11d(
396 "i %d, chan %d unsupported in region %x, band %d\n",
397 i, curchan, region, band);
398 }
399 }
400
401 /*Step6: Add other checking if any */
402
403 }
404
405 parsed_region_chan->nr_chan = idx;
406
407 lbs_deb_11d("nrchan=%x\n", parsed_region_chan->nr_chan);
408 lbs_deb_hex(LBS_DEB_11D, "parsed_region_chan", (u8 *) parsed_region_chan,
409 2 + COUNTRY_CODE_LEN + sizeof(struct parsed_region_chan_11d) * idx);
410
411 done:
412 lbs_deb_enter(LBS_DEB_11D);
413 return 0;
414 }
415
416 /**
417 * @brief This function calculates the scan type for channels
418 * @param chan chan number
419 * @param parsed_region_chan pointer to parsed_region_chan_11d
420 * @return PASSIVE if chan is unknown; ACTIVE if chan is known
421 */
422 u8 lbs_get_scan_type_11d(u8 chan,
423 struct parsed_region_chan_11d * parsed_region_chan)
424 {
425 u8 scan_type = CMD_SCAN_TYPE_PASSIVE;
426
427 lbs_deb_enter(LBS_DEB_11D);
428
429 if (lbs_channel_known_11d(chan, parsed_region_chan)) {
430 lbs_deb_11d("found, do active scan\n");
431 scan_type = CMD_SCAN_TYPE_ACTIVE;
432 } else {
433 lbs_deb_11d("not found, do passive scan\n");
434 }
435
436 lbs_deb_leave_args(LBS_DEB_11D, "ret scan_type %d", scan_type);
437 return scan_type;
438
439 }
440
441 void lbs_init_11d(struct lbs_private *priv)
442 {
443 priv->enable11d = 0;
444 memset(&(priv->parsed_region_chan), 0,
445 sizeof(struct parsed_region_chan_11d));
446 return;
447 }
448
449 /**
450 * @brief This function sets DOMAIN INFO to FW
451 * @param priv pointer to struct lbs_private
452 * @return 0; -1
453 */
454 static int set_domain_info_11d(struct lbs_private *priv)
455 {
456 int ret;
457
458 if (!priv->enable11d) {
459 lbs_deb_11d("dnld domain Info with 11d disabled\n");
460 return 0;
461 }
462
463 ret = lbs_prepare_and_send_command(priv, CMD_802_11D_DOMAIN_INFO,
464 CMD_ACT_SET,
465 CMD_OPTION_WAITFORRSP, 0, NULL);
466 if (ret)
467 lbs_deb_11d("fail to dnld domain info\n");
468
469 return ret;
470 }
471
472 /**
473 * @brief This function setups scan channels
474 * @param priv pointer to struct lbs_private
475 * @param band band
476 * @return 0
477 */
478 int lbs_set_universaltable(struct lbs_private *priv, u8 band)
479 {
480 u16 size = sizeof(struct chan_freq_power);
481 u16 i = 0;
482
483 memset(priv->universal_channel, 0,
484 sizeof(priv->universal_channel));
485
486 priv->universal_channel[i].nrcfp =
487 sizeof(channel_freq_power_UN_BG) / size;
488 lbs_deb_11d("BG-band nrcfp %d\n",
489 priv->universal_channel[i].nrcfp);
490
491 priv->universal_channel[i].CFP = channel_freq_power_UN_BG;
492 priv->universal_channel[i].valid = 1;
493 priv->universal_channel[i].region = UNIVERSAL_REGION_CODE;
494 priv->universal_channel[i].band = band;
495 i++;
496
497 return 0;
498 }
499
500 /**
501 * @brief This function implements command CMD_802_11D_DOMAIN_INFO
502 * @param priv pointer to struct lbs_private
503 * @param cmd pointer to cmd buffer
504 * @param cmdno cmd ID
505 * @param cmdOption cmd action
506 * @return 0
507 */
508 int lbs_cmd_802_11d_domain_info(struct lbs_private *priv,
509 struct cmd_ds_command *cmd, u16 cmdno,
510 u16 cmdoption)
511 {
512 struct cmd_ds_802_11d_domain_info *pdomaininfo =
513 &cmd->params.domaininfo;
514 struct mrvlietypes_domainparamset *domain = &pdomaininfo->domain;
515 u8 nr_subband = priv->domainreg.nr_subband;
516
517 lbs_deb_enter(LBS_DEB_11D);
518
519 lbs_deb_11d("nr_subband=%x\n", nr_subband);
520
521 cmd->command = cpu_to_le16(cmdno);
522 pdomaininfo->action = cpu_to_le16(cmdoption);
523 if (cmdoption == CMD_ACT_GET) {
524 cmd->size =
525 cpu_to_le16(sizeof(pdomaininfo->action) + S_DS_GEN);
526 lbs_deb_hex(LBS_DEB_11D, "802_11D_DOMAIN_INFO", (u8 *) cmd,
527 le16_to_cpu(cmd->size));
528 goto done;
529 }
530
531 domain->header.type = cpu_to_le16(TLV_TYPE_DOMAIN);
532 memcpy(domain->countrycode, priv->domainreg.countrycode,
533 sizeof(domain->countrycode));
534
535 domain->header.len =
536 cpu_to_le16(nr_subband * sizeof(struct ieeetypes_subbandset) +
537 sizeof(domain->countrycode));
538
539 if (nr_subband) {
540 memcpy(domain->subband, priv->domainreg.subband,
541 nr_subband * sizeof(struct ieeetypes_subbandset));
542
543 cmd->size = cpu_to_le16(sizeof(pdomaininfo->action) +
544 le16_to_cpu(domain->header.len) +
545 sizeof(struct mrvlietypesheader) +
546 S_DS_GEN);
547 } else {
548 cmd->size =
549 cpu_to_le16(sizeof(pdomaininfo->action) + S_DS_GEN);
550 }
551
552 lbs_deb_hex(LBS_DEB_11D, "802_11D_DOMAIN_INFO", (u8 *) cmd, le16_to_cpu(cmd->size));
553
554 done:
555 lbs_deb_enter(LBS_DEB_11D);
556 return 0;
557 }
558
559 /**
560 * @brief This function parses countryinfo from AP and download country info to FW
561 * @param priv pointer to struct lbs_private
562 * @param resp pointer to command response buffer
563 * @return 0; -1
564 */
565 int lbs_ret_802_11d_domain_info(struct lbs_private *priv,
566 struct cmd_ds_command *resp)
567 {
568 struct cmd_ds_802_11d_domain_info *domaininfo = &resp->params.domaininforesp;
569 struct mrvlietypes_domainparamset *domain = &domaininfo->domain;
570 u16 action = le16_to_cpu(domaininfo->action);
571 s16 ret = 0;
572 u8 nr_subband = 0;
573
574 lbs_deb_enter(LBS_DEB_11D);
575
576 lbs_deb_hex(LBS_DEB_11D, "domain info resp", (u8 *) resp,
577 (int)le16_to_cpu(resp->size));
578
579 nr_subband = (le16_to_cpu(domain->header.len) - COUNTRY_CODE_LEN) /
580 sizeof(struct ieeetypes_subbandset);
581
582 lbs_deb_11d("domain info resp: nr_subband %d\n", nr_subband);
583
584 if (nr_subband > MRVDRV_MAX_SUBBAND_802_11D) {
585 lbs_deb_11d("Invalid Numrer of Subband returned!!\n");
586 return -1;
587 }
588
589 switch (action) {
590 case CMD_ACT_SET: /*Proc Set action */
591 break;
592
593 case CMD_ACT_GET:
594 break;
595 default:
596 lbs_deb_11d("Invalid action:%d\n", domaininfo->action);
597 ret = -1;
598 break;
599 }
600
601 lbs_deb_leave_args(LBS_DEB_11D, "ret %d", ret);
602 return ret;
603 }
604
605 /**
606 * @brief This function parses countryinfo from AP and download country info to FW
607 * @param priv pointer to struct lbs_private
608 * @return 0; -1
609 */
610 int lbs_parse_dnld_countryinfo_11d(struct lbs_private *priv,
611 struct bss_descriptor * bss)
612 {
613 int ret;
614
615 lbs_deb_enter(LBS_DEB_11D);
616 if (priv->enable11d) {
617 memset(&priv->parsed_region_chan, 0,
618 sizeof(struct parsed_region_chan_11d));
619 ret = parse_domain_info_11d(&bss->countryinfo, 0,
620 &priv->parsed_region_chan);
621
622 if (ret == -1) {
623 lbs_deb_11d("error parsing domain_info from AP\n");
624 goto done;
625 }
626
627 memset(&priv->domainreg, 0,
628 sizeof(struct lbs_802_11d_domain_reg));
629 generate_domain_info_11d(&priv->parsed_region_chan,
630 &priv->domainreg);
631
632 ret = set_domain_info_11d(priv);
633
634 if (ret) {
635 lbs_deb_11d("error setting domain info\n");
636 goto done;
637 }
638 }
639 ret = 0;
640
641 done:
642 lbs_deb_leave_args(LBS_DEB_11D, "ret %d", ret);
643 return ret;
644 }
645
646 /**
647 * @brief This function generates 11D info from user specified regioncode and download to FW
648 * @param priv pointer to struct lbs_private
649 * @return 0; -1
650 */
651 int lbs_create_dnld_countryinfo_11d(struct lbs_private *priv)
652 {
653 int ret;
654 struct region_channel *region_chan;
655 u8 j;
656
657 lbs_deb_enter(LBS_DEB_11D);
658 lbs_deb_11d("curbssparams.band %d\n", priv->curbssparams.band);
659
660 if (priv->enable11d) {
661 /* update parsed_region_chan_11; dnld domaininf to FW */
662
663 for (j = 0; j < ARRAY_SIZE(priv->region_channel); j++) {
664 region_chan = &priv->region_channel[j];
665
666 lbs_deb_11d("%d region_chan->band %d\n", j,
667 region_chan->band);
668
669 if (!region_chan || !region_chan->valid
670 || !region_chan->CFP)
671 continue;
672 if (region_chan->band != priv->curbssparams.band)
673 continue;
674 break;
675 }
676
677 if (j >= ARRAY_SIZE(priv->region_channel)) {
678 lbs_deb_11d("region_chan not found, band %d\n",
679 priv->curbssparams.band);
680 ret = -1;
681 goto done;
682 }
683
684 memset(&priv->parsed_region_chan, 0,
685 sizeof(struct parsed_region_chan_11d));
686 lbs_generate_parsed_region_chan_11d(region_chan,
687 &priv->
688 parsed_region_chan);
689
690 memset(&priv->domainreg, 0,
691 sizeof(struct lbs_802_11d_domain_reg));
692 generate_domain_info_11d(&priv->parsed_region_chan,
693 &priv->domainreg);
694
695 ret = set_domain_info_11d(priv);
696
697 if (ret) {
698 lbs_deb_11d("error setting domain info\n");
699 goto done;
700 }
701
702 }
703 ret = 0;
704
705 done:
706 lbs_deb_leave_args(LBS_DEB_11D, "ret %d", ret);
707 return ret;
708 }
Personal OpenWRT clone
This page took 0.103703 seconds and 5 git commands to generate.