Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rtl871x_ioctl_rtl.c
Go to the documentation of this file.
1 /******************************************************************************
2  * rtl871x_ioctl_rtl.c
3  *
4  * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
5  * Linux device driver for RTL8192SU
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of version 2 of the GNU General Public License as
9  * published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License along with
17  * this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19  *
20  * Modifications for inclusion into the Linux staging tree are
21  * Copyright(c) 2010 Larry Finger. All rights reserved.
22  *
23  * Contact information:
24  * WLAN FAE <[email protected]>
25  * Larry Finger <[email protected]>
26  *
27  ******************************************************************************/
28 
29 #define _RTL871X_IOCTL_RTL_C_
30 
31 #include "osdep_service.h"
32 #include "drv_types.h"
33 #include "wlan_bssdef.h"
34 #include "wifi.h"
35 #include "rtl871x_ioctl.h"
36 #include "rtl871x_ioctl_set.h"
37 #include "rtl871x_ioctl_rtl.h"
38 #include "mp_custom_oid.h"
39 #include "rtl871x_mp.h"
40 #include "rtl871x_mp_ioctl.h"
41 
42 uint oid_rt_get_signal_quality_hdl(struct oid_par_priv *poid_par_priv)
43 {
44  if (poid_par_priv->type_of_oid != QUERY_OID)
45  return NDIS_STATUS_NOT_ACCEPTED;
46  return NDIS_STATUS_SUCCESS;
47 }
48 
49 uint oid_rt_get_small_packet_crc_hdl(struct oid_par_priv *poid_par_priv)
50 {
51  struct _adapter *padapter = (struct _adapter *)
52  (poid_par_priv->adapter_context);
53 
54  if (poid_par_priv->type_of_oid != QUERY_OID)
55  return NDIS_STATUS_NOT_ACCEPTED;
56  if (poid_par_priv->information_buf_len >= sizeof(u32)) {
57  *(u32 *)poid_par_priv->information_buf =
58  padapter->recvpriv.rx_smallpacket_crcerr;
59  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
60  } else
61  return NDIS_STATUS_INVALID_LENGTH;
62  return NDIS_STATUS_SUCCESS;
63 }
64 
65 uint oid_rt_get_middle_packet_crc_hdl(struct oid_par_priv *poid_par_priv)
66 {
67  struct _adapter *padapter = (struct _adapter *)
68  (poid_par_priv->adapter_context);
69 
70  if (poid_par_priv->type_of_oid != QUERY_OID)
71  return NDIS_STATUS_NOT_ACCEPTED;
72  if (poid_par_priv->information_buf_len >= sizeof(u32)) {
73  *(u32 *)poid_par_priv->information_buf =
74  padapter->recvpriv.rx_middlepacket_crcerr;
75  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
76  } else
77  return NDIS_STATUS_INVALID_LENGTH;
78  return NDIS_STATUS_SUCCESS;
79 }
80 
81 uint oid_rt_get_large_packet_crc_hdl(struct oid_par_priv *poid_par_priv)
82 {
83  struct _adapter *padapter = (struct _adapter *)
84  (poid_par_priv->adapter_context);
85 
86  if (poid_par_priv->type_of_oid != QUERY_OID)
87  return NDIS_STATUS_NOT_ACCEPTED;
88  if (poid_par_priv->information_buf_len >= sizeof(u32)) {
89  *(u32 *)poid_par_priv->information_buf =
90  padapter->recvpriv.rx_largepacket_crcerr;
91  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
92  } else
93  return NDIS_STATUS_INVALID_LENGTH;
94  return NDIS_STATUS_SUCCESS;
95 }
96 
97 uint oid_rt_get_tx_retry_hdl(struct oid_par_priv *poid_par_priv)
98 {
99  if (poid_par_priv->type_of_oid != QUERY_OID)
100  return NDIS_STATUS_NOT_ACCEPTED;
101  return NDIS_STATUS_SUCCESS;
102 }
103 
104 uint oid_rt_get_rx_retry_hdl(struct oid_par_priv *poid_par_priv)
105 {
106  if (poid_par_priv->type_of_oid != QUERY_OID)
107  return NDIS_STATUS_NOT_ACCEPTED;
108  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
109  return NDIS_STATUS_SUCCESS;
110 }
111 
112 uint oid_rt_get_rx_total_packet_hdl(struct oid_par_priv *poid_par_priv)
113 {
114  struct _adapter *padapter = (struct _adapter *)
115  (poid_par_priv->adapter_context);
116 
117  if (poid_par_priv->type_of_oid != QUERY_OID)
118  return NDIS_STATUS_NOT_ACCEPTED;
119  if (poid_par_priv->information_buf_len >= sizeof(u32)) {
120  *(u32 *)poid_par_priv->information_buf =
121  padapter->recvpriv.rx_pkts +
122  padapter->recvpriv.rx_drop;
123  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
124  } else
125  return NDIS_STATUS_INVALID_LENGTH;
126  return NDIS_STATUS_SUCCESS;
127 }
128 
129 uint oid_rt_get_tx_beacon_ok_hdl(struct oid_par_priv *poid_par_priv)
130 {
131  if (poid_par_priv->type_of_oid != QUERY_OID)
132  return NDIS_STATUS_NOT_ACCEPTED;
133  return NDIS_STATUS_SUCCESS;
134 }
135 
136 uint oid_rt_get_tx_beacon_err_hdl(struct oid_par_priv *poid_par_priv)
137 {
138  if (poid_par_priv->type_of_oid != QUERY_OID)
139  return NDIS_STATUS_NOT_ACCEPTED;
140  return NDIS_STATUS_SUCCESS;
141 }
142 
143 uint oid_rt_get_rx_icv_err_hdl(struct oid_par_priv *poid_par_priv)
144 {
145  struct _adapter *padapter = (struct _adapter *)
146  (poid_par_priv->adapter_context);
147 
148  if (poid_par_priv->type_of_oid != QUERY_OID)
149  return NDIS_STATUS_NOT_ACCEPTED;
150  if (poid_par_priv->information_buf_len >= sizeof(u32)) {
151  *(uint *)poid_par_priv->information_buf =
152  padapter->recvpriv.rx_icv_err;
153  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
154  } else
155  return NDIS_STATUS_INVALID_LENGTH ;
156  return NDIS_STATUS_SUCCESS;
157 }
158 
159 uint oid_rt_set_encryption_algorithm_hdl(struct oid_par_priv
160  *poid_par_priv)
161 {
162  if (poid_par_priv->type_of_oid != SET_OID)
163  return NDIS_STATUS_NOT_ACCEPTED;
164  return NDIS_STATUS_SUCCESS;
165 }
166 
167 uint oid_rt_get_preamble_mode_hdl(struct oid_par_priv *poid_par_priv)
168 {
169  struct _adapter *padapter = (struct _adapter *)
170  (poid_par_priv->adapter_context);
171  u32 preamblemode = 0 ;
172 
173  if (poid_par_priv->type_of_oid != QUERY_OID)
174  return NDIS_STATUS_NOT_ACCEPTED;
175  if (poid_par_priv->information_buf_len >= sizeof(u32)) {
176  if (padapter->registrypriv.preamble == PREAMBLE_LONG)
177  preamblemode = 0;
178  else if (padapter->registrypriv.preamble == PREAMBLE_AUTO)
179  preamblemode = 1;
180  else if (padapter->registrypriv.preamble == PREAMBLE_SHORT)
181  preamblemode = 2;
182  *(u32 *)poid_par_priv->information_buf = preamblemode;
183  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
184  } else
185  return NDIS_STATUS_INVALID_LENGTH;
186  return NDIS_STATUS_SUCCESS;
187 }
188 
189 uint oid_rt_get_ap_ip_hdl(struct oid_par_priv *poid_par_priv)
190 {
191  if (poid_par_priv->type_of_oid != QUERY_OID)
192  return NDIS_STATUS_NOT_ACCEPTED;
193  return NDIS_STATUS_SUCCESS;
194 }
195 
196 uint oid_rt_get_channelplan_hdl(struct oid_par_priv *poid_par_priv)
197 {
198  struct _adapter *padapter = (struct _adapter *)
199  (poid_par_priv->adapter_context);
200  struct eeprom_priv *peeprompriv = &padapter->eeprompriv;
201 
202  if (poid_par_priv->type_of_oid != QUERY_OID)
203  return NDIS_STATUS_NOT_ACCEPTED;
204  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
205  *(u16 *)poid_par_priv->information_buf = peeprompriv->channel_plan;
206  return NDIS_STATUS_SUCCESS;
207 }
208 
209 uint oid_rt_set_channelplan_hdl(struct oid_par_priv
210  *poid_par_priv)
211 {
212  struct _adapter *padapter = (struct _adapter *)
213  (poid_par_priv->adapter_context);
214  struct eeprom_priv *peeprompriv = &padapter->eeprompriv;
215 
216  if (poid_par_priv->type_of_oid != SET_OID)
217  return NDIS_STATUS_NOT_ACCEPTED;
218  peeprompriv->channel_plan = *(u16 *)poid_par_priv->information_buf;
219  return NDIS_STATUS_SUCCESS;
220 }
221 
222 uint oid_rt_set_preamble_mode_hdl(struct oid_par_priv
223  *poid_par_priv)
224 {
225  struct _adapter *padapter = (struct _adapter *)
226  (poid_par_priv->adapter_context);
227  u32 preamblemode = 0;
228 
229  if (poid_par_priv->type_of_oid != SET_OID)
230  return NDIS_STATUS_NOT_ACCEPTED;
231  if (poid_par_priv->information_buf_len >= sizeof(u32)) {
232  preamblemode = *(u32 *)poid_par_priv->information_buf;
233  if (preamblemode == 0)
234  padapter->registrypriv.preamble = PREAMBLE_LONG;
235  else if (preamblemode == 1)
236  padapter->registrypriv.preamble = PREAMBLE_AUTO;
237  else if (preamblemode == 2)
238  padapter->registrypriv.preamble = PREAMBLE_SHORT;
239  *(u32 *)poid_par_priv->information_buf = preamblemode;
240  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
241  } else
242  return NDIS_STATUS_INVALID_LENGTH;
243  return NDIS_STATUS_SUCCESS;
244 }
245 
246 uint oid_rt_set_bcn_intvl_hdl(struct oid_par_priv *poid_par_priv)
247 {
248  if (poid_par_priv->type_of_oid != SET_OID)
249  return NDIS_STATUS_NOT_ACCEPTED;
250  return NDIS_STATUS_SUCCESS;
251 }
252 
253 uint oid_rt_dedicate_probe_hdl(struct oid_par_priv
254  *poid_par_priv)
255 {
256  return NDIS_STATUS_SUCCESS;
257 }
258 
259 uint oid_rt_get_total_tx_bytes_hdl(struct oid_par_priv
260  *poid_par_priv)
261 {
262  struct _adapter *padapter = (struct _adapter *)
263  (poid_par_priv->adapter_context);
264 
265  if (poid_par_priv->type_of_oid != QUERY_OID)
266  return NDIS_STATUS_NOT_ACCEPTED;
267  if (poid_par_priv->information_buf_len >= sizeof(u32)) {
268  *(u32 *)poid_par_priv->information_buf =
269  padapter->xmitpriv.tx_bytes;
270  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
271  } else
272  return NDIS_STATUS_INVALID_LENGTH;
273  return NDIS_STATUS_SUCCESS;
274 }
275 
276 uint oid_rt_get_total_rx_bytes_hdl(struct oid_par_priv
277  *poid_par_priv)
278 {
279  struct _adapter *padapter = (struct _adapter *)
280  (poid_par_priv->adapter_context);
281 
282  if (poid_par_priv->type_of_oid != QUERY_OID)
283  return NDIS_STATUS_NOT_ACCEPTED;
284  if (poid_par_priv->information_buf_len >= sizeof(u32)) {
285  *(u32 *)poid_par_priv->information_buf =
286  padapter->recvpriv.rx_bytes;
287  *poid_par_priv->bytes_rw = poid_par_priv->
288  information_buf_len;
289  } else
290  return NDIS_STATUS_INVALID_LENGTH;
291  return NDIS_STATUS_SUCCESS;
292 }
293 
294 uint oid_rt_current_tx_power_level_hdl(struct oid_par_priv
295  *poid_par_priv)
296 {
297  return NDIS_STATUS_SUCCESS;
298 }
299 
300 uint oid_rt_get_enc_key_mismatch_count_hdl(struct oid_par_priv
301  *poid_par_priv)
302 {
303  if (poid_par_priv->type_of_oid != QUERY_OID)
304  return NDIS_STATUS_NOT_ACCEPTED;
305  return NDIS_STATUS_SUCCESS;
306 }
307 
308 uint oid_rt_get_enc_key_match_count_hdl(struct oid_par_priv
309  *poid_par_priv)
310 {
311  if (poid_par_priv->type_of_oid != QUERY_OID)
312  return NDIS_STATUS_NOT_ACCEPTED;
313  return NDIS_STATUS_SUCCESS;
314 }
315 
316 uint oid_rt_get_channel_hdl(struct oid_par_priv *poid_par_priv)
317 {
318  struct _adapter *padapter = (struct _adapter *)
319  (poid_par_priv->adapter_context);
320  struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
321  struct NDIS_802_11_CONFIGURATION *pnic_Config;
322  u32 channelnum;
323 
324  if (poid_par_priv->type_of_oid != QUERY_OID)
325  return NDIS_STATUS_NOT_ACCEPTED;
326  if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) ||
327  (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true))
328  pnic_Config = &pmlmepriv->cur_network.network.Configuration;
329  else
330  pnic_Config = &padapter->registrypriv.dev_network.
331  Configuration;
332  channelnum = pnic_Config->DSConfig;
333  *(u32 *)poid_par_priv->information_buf = channelnum;
334  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
335  return NDIS_STATUS_SUCCESS;
336 }
337 
338 uint oid_rt_get_hardware_radio_off_hdl(struct oid_par_priv
339  *poid_par_priv)
340 {
341  if (poid_par_priv->type_of_oid != QUERY_OID)
342  return NDIS_STATUS_NOT_ACCEPTED;
343  return NDIS_STATUS_SUCCESS;
344 }
345 
346 uint oid_rt_get_key_mismatch_hdl(struct oid_par_priv *poid_par_priv)
347 {
348  if (poid_par_priv->type_of_oid != QUERY_OID)
349  return NDIS_STATUS_NOT_ACCEPTED;
350  return NDIS_STATUS_SUCCESS;
351 }
352 
353 uint oid_rt_supported_wireless_mode_hdl(struct oid_par_priv
354  *poid_par_priv)
355 {
356  u32 ulInfo = 0;
357 
358  if (poid_par_priv->type_of_oid != QUERY_OID)
359  return NDIS_STATUS_NOT_ACCEPTED;
360  if (poid_par_priv->information_buf_len >= sizeof(u32)) {
361  ulInfo |= 0x0100; /* WIRELESS_MODE_B */
362  ulInfo |= 0x0200; /* WIRELESS_MODE_G */
363  ulInfo |= 0x0400; /* WIRELESS_MODE_A */
364  *(u32 *) poid_par_priv->information_buf = ulInfo;
365  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
366  } else
367  return NDIS_STATUS_INVALID_LENGTH;
368  return NDIS_STATUS_SUCCESS;
369 }
370 
371 uint oid_rt_get_channel_list_hdl(struct oid_par_priv *poid_par_priv)
372 {
373  if (poid_par_priv->type_of_oid != QUERY_OID)
374  return NDIS_STATUS_NOT_ACCEPTED;
375  return NDIS_STATUS_SUCCESS;
376 }
377 
378 uint oid_rt_get_scan_in_progress_hdl(struct oid_par_priv *poid_par_priv)
379 {
380  if (poid_par_priv->type_of_oid != QUERY_OID)
381  return NDIS_STATUS_NOT_ACCEPTED;
382  return NDIS_STATUS_SUCCESS;
383 }
384 
385 
386 uint oid_rt_forced_data_rate_hdl(struct oid_par_priv *poid_par_priv)
387 {
388  return NDIS_STATUS_SUCCESS;
389 }
390 
391 uint oid_rt_wireless_mode_for_scan_list_hdl(struct oid_par_priv
392  *poid_par_priv)
393 {
394  return NDIS_STATUS_SUCCESS;
395 }
396 
397 uint oid_rt_get_bss_wireless_mode_hdl(struct oid_par_priv
398  *poid_par_priv)
399 {
400  if (poid_par_priv->type_of_oid != QUERY_OID)
401  return NDIS_STATUS_NOT_ACCEPTED;
402  return NDIS_STATUS_SUCCESS;
403 }
404 
405 uint oid_rt_scan_with_magic_packet_hdl(struct oid_par_priv
406  *poid_par_priv)
407 {
408  return NDIS_STATUS_SUCCESS;
409 }
410 
411 uint oid_rt_ap_get_associated_station_list_hdl(struct oid_par_priv
412  *poid_par_priv)
413 {
414  if (poid_par_priv->type_of_oid != QUERY_OID)
415  return NDIS_STATUS_NOT_ACCEPTED;
416  return NDIS_STATUS_SUCCESS;
417 }
418 
419 uint oid_rt_ap_switch_into_ap_mode_hdl(struct oid_par_priv*
420  poid_par_priv)
421 {
422  return NDIS_STATUS_SUCCESS;
423 }
424 
425 uint oid_rt_ap_supported_hdl(struct oid_par_priv *poid_par_priv)
426 {
427  return NDIS_STATUS_SUCCESS;
428 }
429 
430 uint oid_rt_ap_set_passphrase_hdl(struct oid_par_priv *poid_par_priv)
431 {
432  if (poid_par_priv->type_of_oid != SET_OID)
433  return NDIS_STATUS_NOT_ACCEPTED;
434  return NDIS_STATUS_SUCCESS;
435 }
436 
437 uint oid_rt_pro_rf_write_registry_hdl(struct oid_par_priv*
438  poid_par_priv)
439 {
440  uint status = NDIS_STATUS_SUCCESS;
441  struct _adapter *Adapter = (struct _adapter *)
442  (poid_par_priv->adapter_context);
443 
444  if (poid_par_priv->type_of_oid != SET_OID) /* QUERY_OID */
445  return NDIS_STATUS_NOT_ACCEPTED;
446  if (poid_par_priv->information_buf_len ==
447  (sizeof(unsigned long) * 3)) {
448  if (!r8712_setrfreg_cmd(Adapter,
449  *(unsigned char *)poid_par_priv->information_buf,
450  (unsigned long)(*((unsigned long *)
451  poid_par_priv->information_buf + 2))))
452  status = NDIS_STATUS_NOT_ACCEPTED;
453  } else
454  status = NDIS_STATUS_INVALID_LENGTH;
455  return status;
456 }
457 
458 uint oid_rt_pro_rf_read_registry_hdl(struct oid_par_priv *poid_par_priv)
459 {
460  uint status = NDIS_STATUS_SUCCESS;
461  struct _adapter *Adapter = (struct _adapter *)
462  (poid_par_priv->adapter_context);
463 
464  if (poid_par_priv->type_of_oid != SET_OID) /* QUERY_OID */
465  return NDIS_STATUS_NOT_ACCEPTED;
466  if (poid_par_priv->information_buf_len == (sizeof(unsigned long)*3)) {
467  if (Adapter->mppriv.act_in_progress == true)
468  status = NDIS_STATUS_NOT_ACCEPTED;
469  else {
470  /* init workparam */
471  Adapter->mppriv.act_in_progress = true;
472  Adapter->mppriv.workparam.bcompleted = false;
473  Adapter->mppriv.workparam.act_type = MPT_READ_RF;
474  Adapter->mppriv.workparam.io_offset = *(unsigned long *)
475  poid_par_priv->information_buf;
476  Adapter->mppriv.workparam.io_value = 0xcccccccc;
477 
478  /* RegOffsetValue - The offset of RF register to read.
479  * RegDataWidth - The data width of RF register to read.
480  * RegDataValue - The value to read.
481  * RegOffsetValue = *((unsigned long *)InformationBuffer);
482  * RegDataWidth = *((unsigned long *)InformationBuffer+1);
483  * RegDataValue = *((unsigned long *)InformationBuffer+2);
484  */
485  if (!r8712_getrfreg_cmd(Adapter,
486  *(unsigned char *)poid_par_priv->information_buf,
487  (unsigned char *)&Adapter->mppriv.workparam.
488  io_value))
489  status = NDIS_STATUS_NOT_ACCEPTED;
490  }
491  } else
492  status = NDIS_STATUS_INVALID_LENGTH;
493  return status;
494 }
495 
496 enum _CONNECT_STATE_ {
497  CHECKINGSTATUS,
498  ASSOCIATED,
499  ADHOCMODE,
500  NOTASSOCIATED
501 };
502 
503 uint oid_rt_get_connect_state_hdl(struct oid_par_priv *poid_par_priv)
504 {
505  struct _adapter *padapter = (struct _adapter *)
506  (poid_par_priv->adapter_context);
507  struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
508  u32 ulInfo;
509 
510  if (poid_par_priv->type_of_oid != QUERY_OID)
511  return NDIS_STATUS_NOT_ACCEPTED;
512  /* nStatus==0 CheckingStatus
513  * nStatus==1 Associated
514  * nStatus==2 AdHocMode
515  * nStatus==3 NotAssociated
516  */
517  if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true)
518  ulInfo = CHECKINGSTATUS;
519  else if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
520  ulInfo = ASSOCIATED;
521  else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)
522  ulInfo = ADHOCMODE;
523  else
524  ulInfo = NOTASSOCIATED ;
525  *(u32 *)poid_par_priv->information_buf = ulInfo;
526  *poid_par_priv->bytes_rw = poid_par_priv->information_buf_len;
527  return NDIS_STATUS_SUCCESS;
528 }
529 
530 uint oid_rt_set_default_key_id_hdl(struct oid_par_priv *poid_par_priv)
531 {
532  if (poid_par_priv->type_of_oid != SET_OID)
533  return NDIS_STATUS_NOT_ACCEPTED;
534  return NDIS_STATUS_SUCCESS;
535 }
Generated on Thu Jan 10 2013 14:31:11 for Linux Kernel by   doxygen 1.8.2