Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
prism2mib.c
Go to the documentation of this file.
1 /* src/prism2/driver/prism2mib.c
2 *
3 * Management request for mibset/mibget
4 *
5 * Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved.
6 * --------------------------------------------------------------------
7 *
8 * linux-wlan
9 *
10 * The contents of this file are subject to the Mozilla Public
11 * License Version 1.1 (the "License"); you may not use this file
12 * except in compliance with the License. You may obtain a copy of
13 * the License at http://www.mozilla.org/MPL/
14 *
15 * Software distributed under the License is distributed on an "AS
16 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
17 * implied. See the License for the specific language governing
18 * rights and limitations under the License.
19 *
20 * Alternatively, the contents of this file may be used under the
21 * terms of the GNU Public License version 2 (the "GPL"), in which
22 * case the provisions of the GPL are applicable instead of the
23 * above. If you wish to allow the use of your version of this file
24 * only under the terms of the GPL and not to allow others to use
25 * your version of this file under the MPL, indicate your decision
26 * by deleting the provisions above and replace them with the notice
27 * and other provisions required by the GPL. If you do not delete
28 * the provisions above, a recipient may use your version of this
29 * file under either the MPL or the GPL.
30 *
31 * --------------------------------------------------------------------
32 *
33 * Inquiries regarding the linux-wlan Open Source project can be
34 * made directly to:
35 *
36 * AbsoluteValue Systems Inc.
37 * [email protected]
38 * http://www.linux-wlan.com
39 *
40 * --------------------------------------------------------------------
41 *
42 * Portions of the development of this software were funded by
43 * Intersil Corporation as part of PRISM(R) chipset product development.
44 *
45 * --------------------------------------------------------------------
46 *
47 * The functions in this file handle the mibset/mibget management
48 * functions.
49 *
50 * --------------------------------------------------------------------
51 */
52 
53 #include <linux/module.h>
54 #include <linux/kernel.h>
55 #include <linux/sched.h>
56 #include <linux/types.h>
57 #include <linux/wireless.h>
58 #include <linux/netdevice.h>
59 #include <linux/io.h>
60 #include <linux/delay.h>
61 #include <asm/byteorder.h>
62 #include <linux/usb.h>
63 #include <linux/bitops.h>
64 
65 #include "p80211types.h"
66 #include "p80211hdr.h"
67 #include "p80211mgmt.h"
68 #include "p80211conv.h"
69 #include "p80211msg.h"
70 #include "p80211netdev.h"
71 #include "p80211metadef.h"
72 #include "p80211metastruct.h"
73 #include "hfa384x.h"
74 #include "prism2mgmt.h"
75 
76 #define MIB_TMP_MAXLEN 200 /* Max length of RID record (in bytes). */
77 
78 #define F_STA 0x1 /* MIB is supported on stations. */
79 #define F_READ 0x2 /* MIB may be read. */
80 #define F_WRITE 0x4 /* MIB may be written. */
81 
82 struct mibrec {
83  u32 did;
84  u16 flag;
85  u16 parm1;
86  u16 parm2;
87  u16 parm3;
88  int (*func) (struct mibrec *mib,
89  int isget,
90  wlandevice_t *wlandev,
91  hfa384x_t *hw,
92  struct p80211msg_dot11req_mibset *msg, void *data);
93 };
94 
95 static int prism2mib_bytearea2pstr(struct mibrec *mib,
96  int isget,
97  wlandevice_t *wlandev,
98  hfa384x_t *hw,
99  struct p80211msg_dot11req_mibset *msg,
100  void *data);
101 
102 static int prism2mib_uint32(struct mibrec *mib,
103  int isget,
104  wlandevice_t *wlandev,
105  hfa384x_t *hw,
106  struct p80211msg_dot11req_mibset *msg, void *data);
107 
108 static int prism2mib_flag(struct mibrec *mib,
109  int isget,
110  wlandevice_t *wlandev,
111  hfa384x_t *hw,
112  struct p80211msg_dot11req_mibset *msg, void *data);
113 
114 static int prism2mib_wepdefaultkey(struct mibrec *mib,
115  int isget,
116  wlandevice_t *wlandev,
117  hfa384x_t *hw,
118  struct p80211msg_dot11req_mibset *msg,
119  void *data);
120 
121 static int prism2mib_privacyinvoked(struct mibrec *mib,
122  int isget,
123  wlandevice_t *wlandev,
124  hfa384x_t *hw,
125  struct p80211msg_dot11req_mibset *msg,
126  void *data);
127 
128 static int prism2mib_excludeunencrypted(struct mibrec *mib,
129  int isget,
130  wlandevice_t *wlandev,
131  hfa384x_t *hw,
132  struct p80211msg_dot11req_mibset *msg,
133  void *data);
134 
135 static int prism2mib_fragmentationthreshold(struct mibrec *mib,
136  int isget,
137  wlandevice_t *wlandev,
138  hfa384x_t *hw,
139  struct p80211msg_dot11req_mibset *msg,
140  void *data);
141 
142 static int prism2mib_priv(struct mibrec *mib,
143  int isget,
144  wlandevice_t *wlandev,
145  hfa384x_t *hw,
146  struct p80211msg_dot11req_mibset *msg, void *data);
147 
148 static struct mibrec mibtab[] = {
149 
150  /* dot11smt MIB's */
151  {DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey0,
152  F_STA | F_WRITE,
153  HFA384x_RID_CNFWEPDEFAULTKEY0, 0, 0,
154  prism2mib_wepdefaultkey},
155  {DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey1,
156  F_STA | F_WRITE,
157  HFA384x_RID_CNFWEPDEFAULTKEY1, 0, 0,
158  prism2mib_wepdefaultkey},
159  {DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey2,
160  F_STA | F_WRITE,
161  HFA384x_RID_CNFWEPDEFAULTKEY2, 0, 0,
162  prism2mib_wepdefaultkey},
163  {DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey3,
164  F_STA | F_WRITE,
165  HFA384x_RID_CNFWEPDEFAULTKEY3, 0, 0,
166  prism2mib_wepdefaultkey},
167  {DIDmib_dot11smt_dot11PrivacyTable_dot11PrivacyInvoked,
168  F_STA | F_READ | F_WRITE,
169  HFA384x_RID_CNFWEPFLAGS, HFA384x_WEPFLAGS_PRIVINVOKED, 0,
170  prism2mib_privacyinvoked},
171  {DIDmib_dot11smt_dot11PrivacyTable_dot11WEPDefaultKeyID,
172  F_STA | F_READ | F_WRITE,
173  HFA384x_RID_CNFWEPDEFAULTKEYID, 0, 0,
174  prism2mib_uint32},
175  {DIDmib_dot11smt_dot11PrivacyTable_dot11ExcludeUnencrypted,
176  F_STA | F_READ | F_WRITE,
177  HFA384x_RID_CNFWEPFLAGS, HFA384x_WEPFLAGS_EXCLUDE, 0,
178  prism2mib_excludeunencrypted},
179 
180  /* dot11mac MIB's */
181 
182  {DIDmib_dot11mac_dot11OperationTable_dot11MACAddress,
183  F_STA | F_READ | F_WRITE,
184  HFA384x_RID_CNFOWNMACADDR, HFA384x_RID_CNFOWNMACADDR_LEN, 0,
185  prism2mib_bytearea2pstr},
186  {DIDmib_dot11mac_dot11OperationTable_dot11RTSThreshold,
187  F_STA | F_READ | F_WRITE,
188  HFA384x_RID_RTSTHRESH, 0, 0,
189  prism2mib_uint32},
190  {DIDmib_dot11mac_dot11OperationTable_dot11ShortRetryLimit,
191  F_STA | F_READ,
192  HFA384x_RID_SHORTRETRYLIMIT, 0, 0,
193  prism2mib_uint32},
194  {DIDmib_dot11mac_dot11OperationTable_dot11LongRetryLimit,
195  F_STA | F_READ,
196  HFA384x_RID_LONGRETRYLIMIT, 0, 0,
197  prism2mib_uint32},
198  {DIDmib_dot11mac_dot11OperationTable_dot11FragmentationThreshold,
199  F_STA | F_READ | F_WRITE,
200  HFA384x_RID_FRAGTHRESH, 0, 0,
201  prism2mib_fragmentationthreshold},
202  {DIDmib_dot11mac_dot11OperationTable_dot11MaxTransmitMSDULifetime,
203  F_STA | F_READ,
204  HFA384x_RID_MAXTXLIFETIME, 0, 0,
205  prism2mib_uint32},
206 
207  /* dot11phy MIB's */
208 
209  {DIDmib_dot11phy_dot11PhyDSSSTable_dot11CurrentChannel,
210  F_STA | F_READ,
211  HFA384x_RID_CURRENTCHANNEL, 0, 0,
212  prism2mib_uint32},
213  {DIDmib_dot11phy_dot11PhyTxPowerTable_dot11CurrentTxPowerLevel,
214  F_STA | F_READ | F_WRITE,
215  HFA384x_RID_TXPOWERMAX, 0, 0,
216  prism2mib_uint32},
217 
218  /* p2Static MIB's */
219 
220  {DIDmib_p2_p2Static_p2CnfPortType,
221  F_STA | F_READ | F_WRITE,
222  HFA384x_RID_CNFPORTTYPE, 0, 0,
223  prism2mib_uint32},
224 
225  /* p2MAC MIB's */
226 
227  {DIDmib_p2_p2MAC_p2CurrentTxRate,
228  F_STA | F_READ,
229  HFA384x_RID_CURRENTTXRATE, 0, 0,
230  prism2mib_uint32},
231 
232  /* And finally, lnx mibs */
233  {DIDmib_lnx_lnxConfigTable_lnxRSNAIE,
234  F_STA | F_READ | F_WRITE,
235  HFA384x_RID_CNFWPADATA, 0, 0,
236  prism2mib_priv},
237  {0, 0, 0, 0, 0, NULL}
238 };
239 
240 /*----------------------------------------------------------------
241 * prism2mgmt_mibset_mibget
242 *
243 * Set the value of a mib item.
244 *
245 * Arguments:
246 * wlandev wlan device structure
247 * msgp ptr to msg buffer
248 *
249 * Returns:
250 * 0 success and done
251 * <0 success, but we're waiting for something to finish.
252 * >0 an error occurred while handling the message.
253 * Side effects:
254 *
255 * Call context:
256 * process thread (usually)
257 * interrupt
258 ----------------------------------------------------------------*/
259 
260 int prism2mgmt_mibset_mibget(wlandevice_t *wlandev, void *msgp)
261 {
262  hfa384x_t *hw = wlandev->priv;
263  int result, isget;
264  struct mibrec *mib;
265 
266  u16 which;
267 
268  struct p80211msg_dot11req_mibset *msg = msgp;
269  p80211itemd_t *mibitem;
270 
271  msg->resultcode.status = P80211ENUM_msgitem_status_data_ok;
272  msg->resultcode.data = P80211ENUM_resultcode_success;
273 
274  /*
275  ** Determine if this is an Access Point or a station.
276  */
277 
278  which = F_STA;
279 
280  /*
281  ** Find the MIB in the MIB table. Note that a MIB may be in the
282  ** table twice...once for an AP and once for a station. Make sure
283  ** to get the correct one. Note that DID=0 marks the end of the
284  ** MIB table.
285  */
286 
287  mibitem = (p80211itemd_t *) msg->mibattribute.data;
288 
289  for (mib = mibtab; mib->did != 0; mib++)
290  if (mib->did == mibitem->did && (mib->flag & which))
291  break;
292 
293  if (mib->did == 0) {
294  msg->resultcode.data = P80211ENUM_resultcode_not_supported;
295  goto done;
296  }
297 
298  /*
299  ** Determine if this is a "mibget" or a "mibset". If this is a
300  ** "mibget", then make sure that the MIB may be read. Otherwise,
301  ** this is a "mibset" so make make sure that the MIB may be written.
302  */
303 
304  isget = (msg->msgcode == DIDmsg_dot11req_mibget);
305 
306  if (isget) {
307  if (!(mib->flag & F_READ)) {
308  msg->resultcode.data =
309  P80211ENUM_resultcode_cant_get_writeonly_mib;
310  goto done;
311  }
312  } else {
313  if (!(mib->flag & F_WRITE)) {
314  msg->resultcode.data =
315  P80211ENUM_resultcode_cant_set_readonly_mib;
316  goto done;
317  }
318  }
319 
320  /*
321  ** Execute the MIB function. If things worked okay, then make
322  ** sure that the MIB function also worked okay. If so, and this
323  ** is a "mibget", then the status value must be set for both the
324  ** "mibattribute" parameter and the mib item within the data
325  ** portion of the "mibattribute".
326  */
327 
328  result = mib->func(mib, isget, wlandev, hw, msg, (void *)mibitem->data);
329 
330  if (msg->resultcode.data == P80211ENUM_resultcode_success) {
331  if (result != 0) {
332  pr_debug("get/set failure, result=%d\n", result);
333  msg->resultcode.data =
334  P80211ENUM_resultcode_implementation_failure;
335  } else {
336  if (isget) {
337  msg->mibattribute.status =
338  P80211ENUM_msgitem_status_data_ok;
339  mibitem->status =
340  P80211ENUM_msgitem_status_data_ok;
341  }
342  }
343  }
344 
345 done:
346  return 0;
347 }
348 
349 /*----------------------------------------------------------------
350 * prism2mib_bytearea2pstr
351 *
352 * Get/set pstr data to/from a byte area.
353 *
354 * MIB record parameters:
355 * parm1 Prism2 RID value.
356 * parm2 Number of bytes of RID data.
357 * parm3 Not used.
358 *
359 * Arguments:
360 * mib MIB record.
361 * isget MIBGET/MIBSET flag.
362 * wlandev wlan device structure.
363 * priv "priv" structure.
364 * hw "hw" structure.
365 * msg Message structure.
366 * data Data buffer.
367 *
368 * Returns:
369 * 0 - Success.
370 * ~0 - Error.
371 *
372 ----------------------------------------------------------------*/
373 
374 static int prism2mib_bytearea2pstr(struct mibrec *mib,
375  int isget,
376  wlandevice_t *wlandev,
377  hfa384x_t *hw,
378  struct p80211msg_dot11req_mibset *msg,
379  void *data)
380 {
381  int result;
382  p80211pstrd_t *pstr = (p80211pstrd_t *) data;
383  u8 bytebuf[MIB_TMP_MAXLEN];
384 
385  if (isget) {
386  result =
387  hfa384x_drvr_getconfig(hw, mib->parm1, bytebuf, mib->parm2);
388  prism2mgmt_bytearea2pstr(bytebuf, pstr, mib->parm2);
389  } else {
390  memset(bytebuf, 0, mib->parm2);
391  prism2mgmt_pstr2bytearea(bytebuf, pstr);
392  result =
393  hfa384x_drvr_setconfig(hw, mib->parm1, bytebuf, mib->parm2);
394  }
395 
396  return result;
397 }
398 
399 /*----------------------------------------------------------------
400 * prism2mib_uint32
401 *
402 * Get/set uint32 data.
403 *
404 * MIB record parameters:
405 * parm1 Prism2 RID value.
406 * parm2 Not used.
407 * parm3 Not used.
408 *
409 * Arguments:
410 * mib MIB record.
411 * isget MIBGET/MIBSET flag.
412 * wlandev wlan device structure.
413 * priv "priv" structure.
414 * hw "hw" structure.
415 * msg Message structure.
416 * data Data buffer.
417 *
418 * Returns:
419 * 0 - Success.
420 * ~0 - Error.
421 *
422 ----------------------------------------------------------------*/
423 
424 static int prism2mib_uint32(struct mibrec *mib,
425  int isget,
426  wlandevice_t *wlandev,
427  hfa384x_t *hw,
428  struct p80211msg_dot11req_mibset *msg, void *data)
429 {
430  int result;
431  u32 *uint32 = (u32 *) data;
432  u8 bytebuf[MIB_TMP_MAXLEN];
433  u16 *wordbuf = (u16 *) bytebuf;
434 
435  if (isget) {
436  result = hfa384x_drvr_getconfig16(hw, mib->parm1, wordbuf);
437  *uint32 = *wordbuf;
438  } else {
439  *wordbuf = *uint32;
440  result = hfa384x_drvr_setconfig16(hw, mib->parm1, *wordbuf);
441  }
442 
443  return result;
444 }
445 
446 /*----------------------------------------------------------------
447 * prism2mib_flag
448 *
449 * Get/set a flag.
450 *
451 * MIB record parameters:
452 * parm1 Prism2 RID value.
453 * parm2 Bit to get/set.
454 * parm3 Not used.
455 *
456 * Arguments:
457 * mib MIB record.
458 * isget MIBGET/MIBSET flag.
459 * wlandev wlan device structure.
460 * priv "priv" structure.
461 * hw "hw" structure.
462 * msg Message structure.
463 * data Data buffer.
464 *
465 * Returns:
466 * 0 - Success.
467 * ~0 - Error.
468 *
469 ----------------------------------------------------------------*/
470 
471 static int prism2mib_flag(struct mibrec *mib,
472  int isget,
473  wlandevice_t *wlandev,
474  hfa384x_t *hw,
475  struct p80211msg_dot11req_mibset *msg, void *data)
476 {
477  int result;
478  u32 *uint32 = (u32 *) data;
479  u8 bytebuf[MIB_TMP_MAXLEN];
480  u16 *wordbuf = (u16 *) bytebuf;
481  u32 flags;
482 
483  result = hfa384x_drvr_getconfig16(hw, mib->parm1, wordbuf);
484  if (result == 0) {
485  flags = *wordbuf;
486  if (isget) {
487  *uint32 = (flags & mib->parm2) ?
488  P80211ENUM_truth_true : P80211ENUM_truth_false;
489  } else {
490  if ((*uint32) == P80211ENUM_truth_true)
491  flags |= mib->parm2;
492  else
493  flags &= ~mib->parm2;
494  *wordbuf = flags;
495  result =
496  hfa384x_drvr_setconfig16(hw, mib->parm1, *wordbuf);
497  }
498  }
499 
500  return result;
501 }
502 
503 /*----------------------------------------------------------------
504 * prism2mib_wepdefaultkey
505 *
506 * Get/set WEP default keys.
507 *
508 * MIB record parameters:
509 * parm1 Prism2 RID value.
510 * parm2 Number of bytes of RID data.
511 * parm3 Not used.
512 *
513 * Arguments:
514 * mib MIB record.
515 * isget MIBGET/MIBSET flag.
516 * wlandev wlan device structure.
517 * priv "priv" structure.
518 * hw "hw" structure.
519 * msg Message structure.
520 * data Data buffer.
521 *
522 * Returns:
523 * 0 - Success.
524 * ~0 - Error.
525 *
526 ----------------------------------------------------------------*/
527 
528 static int prism2mib_wepdefaultkey(struct mibrec *mib,
529  int isget,
530  wlandevice_t *wlandev,
531  hfa384x_t *hw,
532  struct p80211msg_dot11req_mibset *msg,
533  void *data)
534 {
535  int result;
536  p80211pstrd_t *pstr = (p80211pstrd_t *) data;
537  u8 bytebuf[MIB_TMP_MAXLEN];
538  u16 len;
539 
540  if (isget) {
541  result = 0; /* Should never happen. */
542  } else {
543  len = (pstr->len > 5) ? HFA384x_RID_CNFWEP128DEFAULTKEY_LEN :
544  HFA384x_RID_CNFWEPDEFAULTKEY_LEN;
545  memset(bytebuf, 0, len);
546  prism2mgmt_pstr2bytearea(bytebuf, pstr);
547  result = hfa384x_drvr_setconfig(hw, mib->parm1, bytebuf, len);
548  }
549 
550  return result;
551 }
552 
553 /*----------------------------------------------------------------
554 * prism2mib_privacyinvoked
555 *
556 * Get/set the dot11PrivacyInvoked value.
557 *
558 * MIB record parameters:
559 * parm1 Prism2 RID value.
560 * parm2 Bit value for PrivacyInvoked flag.
561 * parm3 Not used.
562 *
563 * Arguments:
564 * mib MIB record.
565 * isget MIBGET/MIBSET flag.
566 * wlandev wlan device structure.
567 * priv "priv" structure.
568 * hw "hw" structure.
569 * msg Message structure.
570 * data Data buffer.
571 *
572 * Returns:
573 * 0 - Success.
574 * ~0 - Error.
575 *
576 ----------------------------------------------------------------*/
577 
578 static int prism2mib_privacyinvoked(struct mibrec *mib,
579  int isget,
580  wlandevice_t *wlandev,
581  hfa384x_t *hw,
582  struct p80211msg_dot11req_mibset *msg,
583  void *data)
584 {
585  int result;
586 
587  if (wlandev->hostwep & HOSTWEP_DECRYPT) {
588  if (wlandev->hostwep & HOSTWEP_DECRYPT)
589  mib->parm2 |= HFA384x_WEPFLAGS_DISABLE_RXCRYPT;
590  if (wlandev->hostwep & HOSTWEP_ENCRYPT)
591  mib->parm2 |= HFA384x_WEPFLAGS_DISABLE_TXCRYPT;
592  }
593 
594  result = prism2mib_flag(mib, isget, wlandev, hw, msg, data);
595 
596  return result;
597 }
598 
599 /*----------------------------------------------------------------
600 * prism2mib_excludeunencrypted
601 *
602 * Get/set the dot11ExcludeUnencrypted value.
603 *
604 * MIB record parameters:
605 * parm1 Prism2 RID value.
606 * parm2 Bit value for ExcludeUnencrypted flag.
607 * parm3 Not used.
608 *
609 * Arguments:
610 * mib MIB record.
611 * isget MIBGET/MIBSET flag.
612 * wlandev wlan device structure.
613 * priv "priv" structure.
614 * hw "hw" structure.
615 * msg Message structure.
616 * data Data buffer.
617 *
618 * Returns:
619 * 0 - Success.
620 * ~0 - Error.
621 *
622 ----------------------------------------------------------------*/
623 
624 static int prism2mib_excludeunencrypted(struct mibrec *mib,
625  int isget,
626  wlandevice_t *wlandev,
627  hfa384x_t *hw,
628  struct p80211msg_dot11req_mibset *msg,
629  void *data)
630 {
631  int result;
632 
633  result = prism2mib_flag(mib, isget, wlandev, hw, msg, data);
634 
635  return result;
636 }
637 
638 /*----------------------------------------------------------------
639 * prism2mib_fragmentationthreshold
640 *
641 * Get/set the fragmentation threshold.
642 *
643 * MIB record parameters:
644 * parm1 Prism2 RID value.
645 * parm2 Not used.
646 * parm3 Not used.
647 *
648 * Arguments:
649 * mib MIB record.
650 * isget MIBGET/MIBSET flag.
651 * wlandev wlan device structure.
652 * priv "priv" structure.
653 * hw "hw" structure.
654 * msg Message structure.
655 * data Data buffer.
656 *
657 * Returns:
658 * 0 - Success.
659 * ~0 - Error.
660 *
661 ----------------------------------------------------------------*/
662 
663 static int prism2mib_fragmentationthreshold(struct mibrec *mib,
664  int isget,
665  wlandevice_t *wlandev,
666  hfa384x_t *hw,
667  struct p80211msg_dot11req_mibset *msg,
668  void *data)
669 {
670  int result;
671  u32 *uint32 = (u32 *) data;
672 
673  if (!isget)
674  if ((*uint32) % 2) {
675  printk(KERN_WARNING "Attempt to set odd number "
676  "FragmentationThreshold\n");
677  msg->resultcode.data =
678  P80211ENUM_resultcode_not_supported;
679  return 0;
680  }
681 
682  result = prism2mib_uint32(mib, isget, wlandev, hw, msg, data);
683 
684  return result;
685 }
686 
687 /*----------------------------------------------------------------
688 * prism2mib_priv
689 *
690 * Get/set values in the "priv" data structure.
691 *
692 * MIB record parameters:
693 * parm1 Not used.
694 * parm2 Not used.
695 * parm3 Not used.
696 *
697 * Arguments:
698 * mib MIB record.
699 * isget MIBGET/MIBSET flag.
700 * wlandev wlan device structure.
701 * priv "priv" structure.
702 * hw "hw" structure.
703 * msg Message structure.
704 * data Data buffer.
705 *
706 * Returns:
707 * 0 - Success.
708 * ~0 - Error.
709 *
710 ----------------------------------------------------------------*/
711 
712 static int prism2mib_priv(struct mibrec *mib,
713  int isget,
714  wlandevice_t *wlandev,
715  hfa384x_t *hw,
716  struct p80211msg_dot11req_mibset *msg, void *data)
717 {
718  p80211pstrd_t *pstr = (p80211pstrd_t *) data;
719 
720  int result;
721 
722  switch (mib->did) {
723  case DIDmib_lnx_lnxConfigTable_lnxRSNAIE:{
724  hfa384x_WPAData_t wpa;
725  if (isget) {
726  hfa384x_drvr_getconfig(hw,
727  HFA384x_RID_CNFWPADATA,
728  (u8 *) &wpa,
729  sizeof(wpa));
730  pstr->len = le16_to_cpu(wpa.datalen);
731  memcpy(pstr->data, wpa.data, pstr->len);
732  } else {
733  wpa.datalen = cpu_to_le16(pstr->len);
734  memcpy(wpa.data, pstr->data, pstr->len);
735 
736  result =
737  hfa384x_drvr_setconfig(hw,
738  HFA384x_RID_CNFWPADATA,
739  (u8 *) &wpa,
740  sizeof(wpa));
741  }
742  break;
743  }
744  default:
745  printk(KERN_ERR "Unhandled DID 0x%08x\n", mib->did);
746  }
747 
748  return 0;
749 }
750 
751 /*----------------------------------------------------------------
752 * prism2mgmt_pstr2bytestr
753 *
754 * Convert the pstr data in the WLAN message structure into an hfa384x
755 * byte string format.
756 *
757 * Arguments:
758 * bytestr hfa384x byte string data type
759 * pstr wlan message data
760 *
761 * Returns:
762 * Nothing
763 *
764 ----------------------------------------------------------------*/
765 
766 void prism2mgmt_pstr2bytestr(hfa384x_bytestr_t *bytestr, p80211pstrd_t *pstr)
767 {
768  bytestr->len = cpu_to_le16((u16) (pstr->len));
769  memcpy(bytestr->data, pstr->data, pstr->len);
770 }
771 
772 /*----------------------------------------------------------------
773 * prism2mgmt_pstr2bytearea
774 *
775 * Convert the pstr data in the WLAN message structure into an hfa384x
776 * byte area format.
777 *
778 * Arguments:
779 * bytearea hfa384x byte area data type
780 * pstr wlan message data
781 *
782 * Returns:
783 * Nothing
784 *
785 ----------------------------------------------------------------*/
786 
787 void prism2mgmt_pstr2bytearea(u8 *bytearea, p80211pstrd_t *pstr)
788 {
789  memcpy(bytearea, pstr->data, pstr->len);
790 }
791 
792 /*----------------------------------------------------------------
793 * prism2mgmt_bytestr2pstr
794 *
795 * Convert the data in an hfa384x byte string format into a
796 * pstr in the WLAN message.
797 *
798 * Arguments:
799 * bytestr hfa384x byte string data type
800 * msg wlan message
801 *
802 * Returns:
803 * Nothing
804 *
805 ----------------------------------------------------------------*/
806 
807 void prism2mgmt_bytestr2pstr(hfa384x_bytestr_t *bytestr, p80211pstrd_t *pstr)
808 {
809  pstr->len = (u8) (le16_to_cpu((u16) (bytestr->len)));
810  memcpy(pstr->data, bytestr->data, pstr->len);
811 }
812 
813 /*----------------------------------------------------------------
814 * prism2mgmt_bytearea2pstr
815 *
816 * Convert the data in an hfa384x byte area format into a pstr
817 * in the WLAN message.
818 *
819 * Arguments:
820 * bytearea hfa384x byte area data type
821 * msg wlan message
822 *
823 * Returns:
824 * Nothing
825 *
826 ----------------------------------------------------------------*/
827 
828 void prism2mgmt_bytearea2pstr(u8 *bytearea, p80211pstrd_t *pstr, int len)
829 {
830  pstr->len = (u8) len;
831  memcpy(pstr->data, bytearea, len);
832 }
Generated on Thu Jan 10 2013 14:32:55 for Linux Kernel by   doxygen 1.8.2