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* info@linux-wlan.com
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
82struct 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
95static 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
102static 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
108static 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
114static 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
121static 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
128static 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
135static 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
142static 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
148static 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
260int 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
345done:
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
374static 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
424static 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
471static 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
528static 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
578static 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	if (wlandev->hostwep & HOSTWEP_DECRYPT) {
586		if (wlandev->hostwep & HOSTWEP_DECRYPT)
587			mib->parm2 |= HFA384x_WEPFLAGS_DISABLE_RXCRYPT;
588		if (wlandev->hostwep & HOSTWEP_ENCRYPT)
589			mib->parm2 |= HFA384x_WEPFLAGS_DISABLE_TXCRYPT;
590	}
591
592	return prism2mib_flag(mib, isget, wlandev, hw, msg, data);
593}
594
595/*----------------------------------------------------------------
596* prism2mib_excludeunencrypted
597*
598* Get/set the dot11ExcludeUnencrypted value.
599*
600* MIB record parameters:
601*       parm1    Prism2 RID value.
602*       parm2    Bit value for ExcludeUnencrypted flag.
603*       parm3    Not used.
604*
605* Arguments:
606*       mib      MIB record.
607*       isget    MIBGET/MIBSET flag.
608*       wlandev  wlan device structure.
609*       priv     "priv" structure.
610*       hw       "hw" structure.
611*       msg      Message structure.
612*       data     Data buffer.
613*
614* Returns:
615*       0   - Success.
616*       ~0  - Error.
617*
618----------------------------------------------------------------*/
619
620static int prism2mib_excludeunencrypted(struct mibrec *mib,
621					int isget,
622					wlandevice_t *wlandev,
623					hfa384x_t *hw,
624					struct p80211msg_dot11req_mibset *msg,
625					void *data)
626{
627
628	return prism2mib_flag(mib, isget, wlandev, hw, msg, data);
629}
630
631/*----------------------------------------------------------------
632* prism2mib_fragmentationthreshold
633*
634* Get/set the fragmentation threshold.
635*
636* MIB record parameters:
637*       parm1    Prism2 RID value.
638*       parm2    Not used.
639*       parm3    Not used.
640*
641* Arguments:
642*       mib      MIB record.
643*       isget    MIBGET/MIBSET flag.
644*       wlandev  wlan device structure.
645*       priv     "priv" structure.
646*       hw       "hw" structure.
647*       msg      Message structure.
648*       data     Data buffer.
649*
650* Returns:
651*       0   - Success.
652*       ~0  - Error.
653*
654----------------------------------------------------------------*/
655
656static int prism2mib_fragmentationthreshold(struct mibrec *mib,
657					    int isget,
658					    wlandevice_t *wlandev,
659					    hfa384x_t *hw,
660					    struct p80211msg_dot11req_mibset *msg,
661					    void *data)
662{
663	int result;
664	u32 *uint32 = (u32 *) data;
665
666	if (!isget)
667		if ((*uint32) % 2) {
668			netdev_warn(wlandev->netdev,
669				    "Attempt to set odd number FragmentationThreshold\n");
670			msg->resultcode.data =
671			    P80211ENUM_resultcode_not_supported;
672			return 0;
673		}
674
675	result = prism2mib_uint32(mib, isget, wlandev, hw, msg, data);
676
677	return result;
678}
679
680/*----------------------------------------------------------------
681* prism2mib_priv
682*
683* Get/set values in the "priv" data structure.
684*
685* MIB record parameters:
686*       parm1    Not used.
687*       parm2    Not used.
688*       parm3    Not used.
689*
690* Arguments:
691*       mib      MIB record.
692*       isget    MIBGET/MIBSET flag.
693*       wlandev  wlan device structure.
694*       priv     "priv" structure.
695*       hw       "hw" structure.
696*       msg      Message structure.
697*       data     Data buffer.
698*
699* Returns:
700*       0   - Success.
701*       ~0  - Error.
702*
703----------------------------------------------------------------*/
704
705static int prism2mib_priv(struct mibrec *mib,
706			  int isget,
707			  wlandevice_t *wlandev,
708			  hfa384x_t *hw,
709			  struct p80211msg_dot11req_mibset *msg, void *data)
710{
711	p80211pstrd_t *pstr = (p80211pstrd_t *) data;
712
713	switch (mib->did) {
714	case DIDmib_lnx_lnxConfigTable_lnxRSNAIE:{
715			hfa384x_WPAData_t wpa;
716
717			if (isget) {
718				hfa384x_drvr_getconfig(hw,
719						       HFA384x_RID_CNFWPADATA,
720						       (u8 *) &wpa,
721						       sizeof(wpa));
722				pstr->len = le16_to_cpu(wpa.datalen);
723				memcpy(pstr->data, wpa.data, pstr->len);
724			} else {
725				wpa.datalen = cpu_to_le16(pstr->len);
726				memcpy(wpa.data, pstr->data, pstr->len);
727
728				hfa384x_drvr_setconfig(hw,
729						       HFA384x_RID_CNFWPADATA,
730						       (u8 *) &wpa,
731						       sizeof(wpa));
732			}
733			break;
734		}
735	default:
736		netdev_err(wlandev->netdev, "Unhandled DID 0x%08x\n", mib->did);
737	}
738
739	return 0;
740}
741
742/*----------------------------------------------------------------
743* prism2mgmt_pstr2bytestr
744*
745* Convert the pstr data in the WLAN message structure into an hfa384x
746* byte string format.
747*
748* Arguments:
749*	bytestr		hfa384x byte string data type
750*	pstr		wlan message data
751*
752* Returns:
753*	Nothing
754*
755----------------------------------------------------------------*/
756
757void prism2mgmt_pstr2bytestr(struct hfa384x_bytestr *bytestr,
758			     p80211pstrd_t *pstr)
759{
760	bytestr->len = cpu_to_le16((u16) (pstr->len));
761	memcpy(bytestr->data, pstr->data, pstr->len);
762}
763
764/*----------------------------------------------------------------
765* prism2mgmt_pstr2bytearea
766*
767* Convert the pstr data in the WLAN message structure into an hfa384x
768* byte area format.
769*
770* Arguments:
771*	bytearea	hfa384x byte area data type
772*	pstr		wlan message data
773*
774* Returns:
775*	Nothing
776*
777----------------------------------------------------------------*/
778
779void prism2mgmt_pstr2bytearea(u8 *bytearea, p80211pstrd_t *pstr)
780{
781	memcpy(bytearea, pstr->data, pstr->len);
782}
783
784/*----------------------------------------------------------------
785* prism2mgmt_bytestr2pstr
786*
787* Convert the data in an hfa384x byte string format into a
788* pstr in the WLAN message.
789*
790* Arguments:
791*	bytestr		hfa384x byte string data type
792*	msg		wlan message
793*
794* Returns:
795*	Nothing
796*
797----------------------------------------------------------------*/
798
799void prism2mgmt_bytestr2pstr(struct hfa384x_bytestr *bytestr,
800			     p80211pstrd_t *pstr)
801{
802	pstr->len = (u8) (le16_to_cpu((u16) (bytestr->len)));
803	memcpy(pstr->data, bytestr->data, pstr->len);
804}
805
806/*----------------------------------------------------------------
807* prism2mgmt_bytearea2pstr
808*
809* Convert the data in an hfa384x byte area format into a pstr
810* in the WLAN message.
811*
812* Arguments:
813*	bytearea	hfa384x byte area data type
814*	msg		wlan message
815*
816* Returns:
817*	Nothing
818*
819----------------------------------------------------------------*/
820
821void prism2mgmt_bytearea2pstr(u8 *bytearea, p80211pstrd_t *pstr, int len)
822{
823	pstr->len = (u8) len;
824	memcpy(pstr->data, bytearea, len);
825}
826