1 ################################################################################
2 # This file is part of OpenELEC - http://www.openelec.tv
3 # Copyright (C) 2009-2014 Stephan Raue (stephan@openelec.tv)
5 # OpenELEC is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation, either version 2 of the License, or
8 # (at your option) any later version.
10 # OpenELEC 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. See the
13 # GNU General Public License for more details.
15 # You should have received a copy of the GNU General Public License
16 # along with OpenELEC. If not, see <http://www.gnu.org/licenses/>.
17 ################################################################################
18 commit 710c9ba0aab6c2d50b046b22f1405b12b7ebbff3
19 Author: hschang <chang@dev3>
20 Date: Tue Feb 25 16:49:51 2014 +0900
22 patch for lastest kernel(>= 3.10.0)
24 diff --git a/core/rtw_debug.c b/core/rtw_debug.c
25 index 04e472d..d4f6e7d 100644
26 --- a/core/rtw_debug.c
27 +++ b/core/rtw_debug.c
29 #ifdef CONFIG_PROC_DEBUG
30 #include <rtw_version.h>
32 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
33 int proc_get_drv_version(char *page, char **start,
34 off_t offset, int count,
36 @@ -75,7 +76,15 @@ int proc_get_drv_version(char *page, char **start,
41 +int proc_get_drv_version(struct seq_file *m, void* data)
43 + seq_printf(m, "%s\n", DRIVERVERSION);
48 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
49 int proc_get_write_reg(char *page, char **start,
50 off_t offset, int count,
52 @@ -83,7 +92,14 @@ int proc_get_write_reg(char *page, char **start,
57 +int proc_get_write_reg(struct seq_file *m, void* data)
63 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
64 int proc_set_write_reg(struct file *file, const char *buffer,
65 unsigned long count, void *data)
67 @@ -128,10 +144,59 @@ int proc_set_write_reg(struct file *file, const char *buffer,
72 +int proc_set_write_reg_open(struct seq_file *m, void* data)
77 +ssize_t proc_set_write_reg(struct file *file, const char *buffer, size_t count, loff_t *pos)
79 + struct net_device *dev = (struct net_device *)pos;
80 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
86 + DBG_8192C("argument size is less than 3\n");
89 + len = min(count, sizeof(tmp)-1);
90 + if (buffer && !copy_from_user(tmp, buffer, len)) {
93 + if(sscanf(tmp, "%x %x %x", &addr, &val, &len)!=3) {
94 + DBG_8192C("invalid write_reg parameter!\n");
101 + rtw_write8(padapter, addr, (u8)val);
104 + rtw_write16(padapter, addr, (u16)val);
107 + rtw_write32(padapter, addr, val);
110 + DBG_8192C("error write length=%d", len);
120 static u32 proc_get_read_addr=0xeeeeeeee;
121 static u32 proc_get_read_len=0x4;
123 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
124 int proc_get_read_reg(char *page, char **start,
125 off_t offset, int count,
126 int *eof, void *data)
127 @@ -199,7 +264,77 @@ int proc_set_read_reg(struct file *file, const char *buffer,
132 +int proc_get_read_reg(struct seq_file *m, void* data)
134 + struct net_device *dev = m->private;
135 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
137 + if(proc_get_read_addr==0xeeeeeeee)
142 + switch(proc_get_read_len)
145 + seq_printf(m, "rtw_read8(0x%x)=0x%x\n", proc_get_read_addr, rtw_read8(padapter, proc_get_read_addr));
148 + seq_printf(m, "rtw_read16(0x%x)=0x%x\n", proc_get_read_addr, rtw_read16(padapter, proc_get_read_addr));
151 + seq_printf(m, "rtw_read32(0x%x)=0x%x\n", proc_get_read_addr, rtw_read32(padapter, proc_get_read_addr));
154 + seq_printf(m, "error read length=%d\n", proc_get_read_len);
160 +ssize_t proc_set_read_reg(struct file *file, const char *buf,
161 + size_t count, loff_t *pos)
163 + struct net_device *dev = (struct net_device *)pos;
164 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
166 + char *cmd, *buffer;
168 + u32 addr, len, num;
172 + DBG_8192C("argument size is less than 2\n");
175 + cmd = kmalloc(count+1, GFP_KERNEL);
178 + if(!copy_from_user(cmd, buf, count)) {
183 + num = sscanf(buffer, "%x %x", &addr, &len);
186 + DBG_8192C("invalid read_reg parameter!\n");
190 + proc_get_read_addr = addr;
191 + proc_get_read_len = len;
201 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
202 int proc_get_fwstate(char *page, char **start,
203 off_t offset, int count,
204 int *eof, void *data)
205 @@ -215,7 +350,18 @@ int proc_get_fwstate(char *page, char **start,
210 +int proc_get_fwstate(struct seq_file *m, void* data)
212 + struct net_device *dev = m->private;
213 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
214 + struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
215 + seq_printf(m, "fwstate=0x%x\n",get_fwstate(pmlmepriv));
220 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
221 int proc_get_sec_info(char *page, char **start,
222 off_t offset, int count,
223 int *eof, void *data)
224 @@ -233,7 +379,20 @@ int proc_get_sec_info(char *page, char **start,
229 +int proc_get_sec_info(struct seq_file *m, void* data)
231 + struct net_device *dev = m->private;
232 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
233 + struct security_priv *psecuritypriv = &padapter->securitypriv;
234 + seq_printf(m, "auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
235 + psecuritypriv->dot11AuthAlgrthm, psecuritypriv->dot11PrivacyAlgrthm,
236 + psecuritypriv->ndisauthtype, psecuritypriv->ndisencryptstatus);
241 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
242 int proc_get_mlmext_state(char *page, char **start,
243 off_t offset, int count,
244 int *eof, void *data)
245 @@ -250,7 +409,19 @@ int proc_get_mlmext_state(char *page, char **start,
250 +int proc_get_mlmext_state(struct seq_file *m, void *data)
252 + struct net_device *dev = m->private;
253 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
254 + struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
255 + struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
256 + seq_printf(m, "pmlmeinfo->state=0x%x\n", pmlmeinfo->state);
261 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
262 int proc_get_qos_option(char *page, char **start,
263 off_t offset, int count,
264 int *eof, void *data)
265 @@ -267,7 +438,18 @@ int proc_get_qos_option(char *page, char **start,
270 +int proc_get_qos_option(struct seq_file *m, void *data)
272 + struct net_device *dev = m->private;
273 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
274 + struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
275 + seq_printf(m, "qos_option=%d\n", pmlmepriv->qospriv.qos_option);
280 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
281 int proc_get_ht_option(char *page, char **start,
282 off_t offset, int count,
283 int *eof, void *data)
284 @@ -283,7 +465,18 @@ int proc_get_ht_option(char *page, char **start,
289 +int proc_get_ht_option(struct seq_file *m, void *data)
291 + struct net_device *dev = m->private;
292 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
293 + struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
294 + seq_printf(m, "ht_option=%d\n", pmlmepriv->htpriv.ht_option);
299 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
300 int proc_get_rf_info(char *page, char **start,
301 off_t offset, int count,
302 int *eof, void *data)
303 @@ -301,7 +494,19 @@ int proc_get_rf_info(char *page, char **start,
308 +int proc_get_rf_info(struct seq_file *m, void *data)
310 + struct net_device *dev = m->private;
311 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
312 + struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
313 + seq_printf(m, "cur_ch=%d, cur_bw=%d, cur_ch_offet=%d\n",
314 + pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
319 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
320 int proc_get_ap_info(char *page, char **start,
321 off_t offset, int count,
322 int *eof, void *data)
323 @@ -350,7 +555,53 @@ int proc_get_ap_info(char *page, char **start,
328 +int proc_get_ap_info(struct seq_file *m, void *data)
330 + struct sta_info *psta;
331 + struct net_device *dev = m->private;
332 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
333 + struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
334 + struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
335 + struct wlan_network *cur_network = &(pmlmepriv->cur_network);
336 + struct sta_priv *pstapriv = &padapter->stapriv;
339 + psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
343 + struct recv_reorder_ctrl *preorder_ctrl;
345 + seq_printf(m, "SSID=%s\n", cur_network->network.Ssid.Ssid);
346 + seq_printf(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
347 + seq_printf(m, "cur_channel=%d, cur_bwmode=%d, cur_ch_offset=%d\n", pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
348 + seq_printf(m, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
349 + seq_printf(m, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
350 + seq_printf(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
351 + seq_printf(m, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi);
352 + seq_printf(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
353 + seq_printf(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
357 + preorder_ctrl = &psta->recvreorder_ctrl[i];
358 + if(preorder_ctrl->enable)
360 + seq_printf(m, "tid=%d, indicate_seq=%d\n", i, preorder_ctrl->indicate_seq);
367 + seq_printf(m, "can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
373 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
374 int proc_get_adapter_state(char *page, char **start,
375 off_t offset, int count,
376 int *eof, void *data)
377 @@ -366,7 +617,18 @@ int proc_get_adapter_state(char *page, char **start,
383 +int proc_get_adapter_state(struct seq_file *m, void *data)
385 + struct net_device *dev = m->private;
386 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
387 + seq_printf(m, "bSurpriseRemoved=%d, bDriverStopped=%d\n",
388 + padapter->bSurpriseRemoved, padapter->bDriverStopped);
393 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
394 int proc_get_trx_info(char *page, char **start,
395 off_t offset, int count,
396 int *eof, void *data)
397 @@ -387,8 +649,23 @@ int proc_get_trx_info(char *page, char **start,
404 +int proc_get_trx_info(struct seq_file *m, void *data)
406 + struct net_device *dev = m->private;
407 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
408 + struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
409 + struct recv_priv *precvpriv = &padapter->recvpriv;
410 + seq_printf(m, "free_xmitbuf_cnt=%d, free_xmitframe_cnt=%d, free_ext_xmitbuf_cnt=%d, free_recvframe_cnt=%d\n",
411 + pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt,pxmitpriv->free_xmit_extbuf_cnt, precvpriv->free_recvframe_cnt);
412 +#ifdef CONFIG_USB_HCI
413 + seq_printf(m, "rx_urb_pending_cn=%d\n", precvpriv->rx_pending_cnt);
419 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
420 int proc_get_rx_signal(char *page, char **start,
421 off_t offset, int count,
422 int *eof, void *data)
423 @@ -452,7 +729,62 @@ int proc_set_rx_signal(struct file *file, const char *buffer,
428 +int proc_get_rx_signal(struct seq_file *m, void *data)
430 + struct net_device *dev = m->private;
431 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
432 + struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
436 + "signal_strength:%u\n"
439 + padapter->recvpriv.rssi,
440 + padapter->recvpriv.rxpwdb,
441 + padapter->recvpriv.signal_strength,
442 + padapter->recvpriv.signal_qual,
443 + padapter->recvpriv.noise
448 +ssize_t proc_set_rx_signal(struct file *file, const char *buffer, size_t count, loff_t *pos)
450 + struct net_device *dev = (struct net_device *)pos;
451 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
453 + u32 is_signal_dbg, signal_strength;
458 + if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
460 + int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength);
462 + is_signal_dbg = is_signal_dbg==0?0:1;
464 + if(is_signal_dbg && num!=2)
467 + signal_strength = signal_strength>100?100:signal_strength;
468 + signal_strength = signal_strength<0?0:signal_strength;
470 + padapter->recvpriv.is_signal_dbg = is_signal_dbg;
471 + padapter->recvpriv.signal_strength_dbg=signal_strength;
474 + DBG_871X("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
476 + DBG_871X("set %s\n", "HW_SIGNAL_STRENGTH");
482 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
483 int proc_get_ampdu_enable(char *page, char **start,
484 off_t offset, int count,
485 int *eof, void *data)
486 @@ -499,7 +831,46 @@ int proc_set_ampdu_enable(struct file *file, const char *buffer,
491 +int proc_get_ampdu_enable(struct seq_file *m, void *data)
493 + struct net_device *dev = m->private;
494 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
495 + struct registry_priv *pregpriv = &padapter->registrypriv;
499 + pregpriv->ampdu_enable
504 +ssize_t proc_set_ampdu_enable(struct file *file, const char *buffer, size_t count, loff_t *pos)
506 + struct net_device *dev = (struct net_device *)pos;
507 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
508 + struct registry_priv *pregpriv = &padapter->registrypriv;
515 + if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
517 + int num = sscanf(tmp, "%d ", &mode);
519 + if( pregpriv && mode >= 0 && mode < 3 )
521 + pregpriv->ampdu_enable= mode;
522 + printk("ampdu_enable=%d\n", mode);
529 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
530 int proc_get_rssi_disp(char *page, char **start,
531 off_t offset, int count,
532 int *eof, void *data)
533 @@ -547,10 +918,52 @@ int proc_set_rssi_disp(struct file *file, const char *buffer,
538 +int proc_get_rssi_disp(struct seq_file *m, void *data)
543 +ssize_t proc_set_rssi_disp(struct file *file, const char *buffer, size_t count, loff_t *pos)
545 + struct net_device *dev = (struct net_device *)pos;
546 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
552 + DBG_8192C("argument size is less than 1\n");
556 + if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
558 + int num = sscanf(tmp, "%x", &enable);
561 + DBG_8192C("invalid set_rssi_disp parameter!\n");
567 + DBG_8192C("Turn On Rx RSSI Display Function\n");
568 + padapter->bRxRSSIDisplay = enable ;
572 + DBG_8192C("Turn Off Rx RSSI Display Function\n");
573 + padapter->bRxRSSIDisplay = 0 ;
580 #ifdef CONFIG_AP_MODE
582 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
583 int proc_get_all_sta_info(char *page, char **start,
584 off_t offset, int count,
585 int *eof, void *data)
586 @@ -620,14 +1033,74 @@ int proc_get_all_sta_info(char *page, char **start,
593 +int proc_get_all_sta_info(struct seq_file *m, void *data)
596 + struct sta_info *psta;
597 + struct net_device *dev = m->private;
598 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
599 + struct sta_priv *pstapriv = &padapter->stapriv;
601 + _list *plist, *phead;
602 + struct recv_reorder_ctrl *preorder_ctrl;
603 + seq_printf(m, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
605 + _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
607 + for(i=0; i< NUM_STA; i++)
609 + phead = &(pstapriv->sta_hash[i]);
610 + plist = get_next(phead);
612 + while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
614 + psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
616 + plist = get_next(plist);
618 + //if(extra_arg == psta->aid)
620 + seq_printf(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->hwaddr));
621 + seq_printf(m, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
622 + seq_printf(m, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
623 + seq_printf(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n", psta->state, psta->aid, psta->mac_id, psta->raid);
624 + seq_printf(m, "bwmode=%d, ch_offset=%d, sgi=%d\n", psta->htpriv.bwmode, psta->htpriv.ch_offset, psta->htpriv.sgi);
625 + seq_printf(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
626 + seq_printf(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
627 + seq_printf(m, "sleepq_len=%d\n", psta->sleepq_len);
628 + seq_printf(m, "capability=0x%x\n", psta->capability);
629 + seq_printf(m, "flags=0x%x\n", psta->flags);
630 + seq_printf(m, "wpa_psk=0x%x\n", psta->wpa_psk);
631 + seq_printf(m, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
632 + seq_printf(m, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
633 + seq_printf(m, "qos_info=0x%x\n", psta->qos_info);
634 + seq_printf(m, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
638 + preorder_ctrl = &psta->recvreorder_ctrl[j];
639 + if(preorder_ctrl->enable)
641 + seq_printf(m, "tid=%d, indicate_seq=%d\n", j, preorder_ctrl->indicate_seq);
647 + _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
654 #ifdef DBG_MEMORY_LEAK
655 #include <asm/atomic.h>
656 extern atomic_t _malloc_cnt;;
657 extern atomic_t _malloc_size;;
659 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
660 int proc_get_malloc_cnt(char *page, char **start,
661 off_t offset, int count,
662 int *eof, void *data)
663 @@ -641,9 +1114,20 @@ int proc_get_malloc_cnt(char *page, char **start,
668 +int proc_get_malloc_cnt(struct seq_file *m, void *data)
670 + seq_printf(m, "_malloc_cnt=%d\n", atomic_read(&_malloc_cnt));
671 + seq_printf(m, "_malloc_size=%d\n", atomic_read(&_malloc_size));
676 #endif /* DBG_MEMORY_LEAK */
678 #ifdef CONFIG_FIND_BEST_CHANNEL
680 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
681 int proc_get_best_channel(char *page, char **start,
682 off_t offset, int count,
683 int *eof, void *data)
684 @@ -703,6 +1187,61 @@ int proc_get_best_channel(char *page, char **start,
689 +int proc_get_best_channel(struct seq_file *m, void *data)
691 + struct net_device *dev = m->private;
692 + _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
693 + struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
694 + u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
696 + for (i=0; pmlmeext->channel_set[i].ChannelNum !=0; i++) {
697 + if ( pmlmeext->channel_set[i].ChannelNum == 1)
699 + if ( pmlmeext->channel_set[i].ChannelNum == 36)
703 + for (i=0; pmlmeext->channel_set[i].ChannelNum !=0; i++) {
705 + if ( pmlmeext->channel_set[i].ChannelNum == 6 ) {
706 + if ( pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_24G].rx_count ) {
708 + best_channel_24G = pmlmeext->channel_set[i].ChannelNum;
713 + if ( pmlmeext->channel_set[i].ChannelNum >= 36
714 + && pmlmeext->channel_set[i].ChannelNum < 140 ) {
715 + // Find primary channel
716 + if ( (( pmlmeext->channel_set[i].ChannelNum - 36) % 8 == 0)
717 + && (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count) ) {
719 + best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
723 + if ( pmlmeext->channel_set[i].ChannelNum >= 149
724 + && pmlmeext->channel_set[i].ChannelNum < 165) {
725 + // find primary channel
726 + if ( (( pmlmeext->channel_set[i].ChannelNum - 149) % 8 == 0)
727 + && (pmlmeext->channel_set[i].rx_count < pmlmeext->channel_set[index_5G].rx_count) ) {
729 + best_channel_5G = pmlmeext->channel_set[i].ChannelNum;
733 + seq_printf(m, "The rx cnt of channel %3d = %d\n",
734 + pmlmeext->channel_set[i].ChannelNum, pmlmeext->channel_set[i].rx_count);
737 + seq_printf(m, "best_channel_5G = %d\n", best_channel_5G);
738 + seq_printf(m, "best_channel_24G = %d\n", best_channel_24G);
743 #endif /* CONFIG_FIND_BEST_CHANNEL */
746 diff --git a/core/rtw_mp.c b/core/rtw_mp.c
747 index 0cdc094..bb76dae 100644
750 @@ -1140,8 +1140,7 @@ void SetPacketTx(PADAPTER padapter)
751 _rtw_memset(ptr, payload, pkt_end - ptr);
754 - pmp_priv->tx.PktTxThread = kernel_thread(mp_xmit_packet_thread, pmp_priv, CLONE_FS|CLONE_FILES);
755 - if(pmp_priv->tx.PktTxThread < 0)
756 + if(!start_kthread(&pmp_priv->tx.PktTxThread, mp_xmit_packet_thread, pmp_priv, "8192cu-mp-xmit"))
757 DBG_871X("Create PktTx Thread Fail !!!!!\n");
760 diff --git a/hal/rtl8192c/usb/usb_halinit.c b/hal/rtl8192c/usb/usb_halinit.c
761 index eb5ea29..6cac2d5 100644
762 --- a/hal/rtl8192c/usb/usb_halinit.c
763 +++ b/hal/rtl8192c/usb/usb_halinit.c
764 @@ -3786,6 +3786,8 @@ _ReadIDs(
765 pHalData->CustomerID = RT_CID_DLINK;
766 else if((pHalData->EEPROMVID == 0x2001) && (pHalData->EEPROMPID == 0x330a))
767 pHalData->CustomerID = RT_CID_DLINK;
768 + else if((pHalData->EEPROMVID == 0x2001) && (pHalData->EEPROMPID == 0x330d))
769 + pHalData->CustomerID = RT_CID_DLINK;
771 case EEPROM_CID_WHQL:
773 diff --git a/include/osdep_service.h b/include/osdep_service.h
774 index 2802187..6fedff4 100644
775 --- a/include/osdep_service.h
776 +++ b/include/osdep_service.h
778 #include <linux/pci.h>
781 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
782 + #include <linux/kthread.h>
785 #ifdef CONFIG_USB_HCI
786 typedef struct urb * PURB;
789 typedef unsigned long _irqL;
790 typedef struct net_device * _nic_hdl;
793 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0))
794 typedef pid_t _thread_hdl_;
796 + typedef struct task_struct * _thread_hdl_;
798 typedef int thread_return;
799 typedef void* thread_context;
801 @@ -572,7 +579,7 @@ __inline static void thread_enter(void *context)
802 #ifdef PLATFORM_LINUX
803 //struct net_device *pnetdev = (struct net_device *)context;
804 //daemonize("%s", pnetdev->name);
805 - daemonize("%s", "RTKTHREAD");
806 + //daemonize("%s", "RTKTHREAD");
807 allow_signal(SIGTERM);
810 @@ -827,4 +834,8 @@ extern u64 rtw_division64(u64 x, u64 y);
814 +#ifdef PLATFORM_LINUX
815 +extern int start_kthread(_thread_hdl_ *t_hdl, int (*threadfn)(void *data),
816 + void *data, const char *name);
819 diff --git a/include/rtw_debug.h b/include/rtw_debug.h
820 index eca6692..624add6 100644
821 --- a/include/rtw_debug.h
822 +++ b/include/rtw_debug.h
824 #include <osdep_service.h>
825 #include <drv_types.h>
828 #define _drv_emerg_ 1
829 #define _drv_alert_ 2
833 #define _drv_debug_ 9
836 #define _module_rtl871x_xmit_c_ BIT(0)
837 #define _module_xmit_osdep_c_ BIT(1)
838 #define _module_rtl871x_recv_c_ BIT(2)
839 @@ -179,7 +177,6 @@ extern void rtl871x_cedbg(const char *fmt, ...);
841 #endif /* CONFIG_DEBUG_RTL871X */
844 #if defined (_dbgdump) && defined (_MODULE_DEFINE_)
847 @@ -193,7 +190,6 @@ extern void rtl871x_cedbg(const char *fmt, ...);
852 #if defined (_dbgdump)
855 @@ -231,7 +227,6 @@ extern void rtl871x_cedbg(const char *fmt, ...);
860 #ifdef CONFIG_DEBUG_RTL819X
861 #ifdef PLATFORM_WINDOWS
863 @@ -281,10 +276,9 @@ extern void rtl871x_cedbg(const char *fmt, ...);
864 #define ERR_8192C _dbgdump
869 #ifdef CONFIG_PROC_DEBUG
871 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
872 int proc_get_drv_version(char *page, char **start,
873 off_t offset, int count,
874 int *eof, void *data);
875 @@ -293,8 +287,8 @@ extern void rtl871x_cedbg(const char *fmt, ...);
876 off_t offset, int count,
877 int *eof, void *data);
879 - int proc_set_write_reg(struct file *file, const char *buffer,
880 - unsigned long count, void *data);
881 + int proc_set_write_reg(struct file *file, const char *buffer,
882 + unsigned long count, void *data);
884 int proc_get_read_reg(char *page, char **start,
885 off_t offset, int count,
886 @@ -303,7 +297,6 @@ extern void rtl871x_cedbg(const char *fmt, ...);
887 int proc_set_read_reg(struct file *file, const char *buffer,
888 unsigned long count, void *data);
891 int proc_get_fwstate(char *page, char **start,
892 off_t offset, int count,
893 int *eof, void *data);
894 @@ -339,28 +332,75 @@ extern void rtl871x_cedbg(const char *fmt, ...);
895 int proc_get_trx_info(char *page, char **start,
896 off_t offset, int count,
897 int *eof, void *data);
899 + int proc_get_drv_version(struct seq_file *m, void *data);
901 + int proc_get_write_reg(struct seq_file *m, void *data);
903 + ssize_t proc_set_write_reg(struct file *file, const char *buffer,
904 + size_t count, loff_t *pos);
906 + int proc_get_read_reg(struct seq_file *m, void *data);
908 + ssize_t proc_set_read_reg(struct file *file, const char *buffer,
909 + size_t count, loff_t *pos);
911 + int proc_get_fwstate(struct seq_file *m, void *data);
913 + int proc_get_sec_info(struct seq_file *m, void *data);
915 + int proc_get_mlmext_state(struct seq_file *m, void *data);
917 + int proc_get_qos_option(struct seq_file *m, void *data);
919 + int proc_get_ht_option(struct seq_file *m, void *data);
921 + int proc_get_rf_info(struct seq_file *m, void *data);
923 + int proc_get_ap_info(struct seq_file *m, void *data);
925 + int proc_get_adapter_state(struct seq_file *m, void *data);
927 + int proc_get_trx_info(struct seq_file *m, void *data);
930 #ifdef CONFIG_AP_MODE
932 +# if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
933 int proc_get_all_sta_info(char *page, char **start,
934 off_t offset, int count,
935 int *eof, void *data);
937 + int proc_get_all_sta_info(struct seq_file *m, void *data);
942 #ifdef DBG_MEMORY_LEAK
944 +# if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
945 int proc_get_malloc_cnt(char *page, char **start,
946 off_t offset, int count,
947 int *eof, void *data);
949 + int proc_get_malloc_cnt(struct seq_file *m, void *data);
954 #ifdef CONFIG_FIND_BEST_CHANNEL
956 +# if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
957 int proc_get_best_channel(char *page, char **start,
958 off_t offset, int count,
959 int *eof, void *data);
961 + int proc_get_best_channel(struct seq_file *m, void *data);
966 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
967 int proc_get_rx_signal(char *page, char **start,
968 off_t offset, int count,
969 int *eof, void *data);
970 @@ -381,7 +421,22 @@ extern void rtl871x_cedbg(const char *fmt, ...);
972 int proc_set_rssi_disp(struct file *file, const char *buffer,
973 unsigned long count, void *data);
976 + int proc_get_rx_signal(struct seq_file *m, void *data);
978 + ssize_t proc_set_rx_signal(struct file *file, const char *buffer,
979 + size_t count, loff_t *pos);
981 + int proc_get_ampdu_enable(struct seq_file *m, void *data);
983 + ssize_t proc_set_ampdu_enable(struct file *file, const char *buffer,
984 + size_t count, loff_t *pos);
986 + int proc_get_rssi_disp(struct seq_file *m, void *data);
988 + ssize_t proc_set_rssi_disp(struct file *file, const char *buffer,
989 + size_t count, loff_t *pos);
992 #endif //CONFIG_PROC_DEBUG
994 diff --git a/include/rtw_recv.h b/include/rtw_recv.h
995 index a88f505..e204ef3 100644
996 --- a/include/rtw_recv.h
997 +++ b/include/rtw_recv.h
998 @@ -623,8 +623,9 @@ __inline static union recv_frame *rxmem_to_recvframe(u8 *rxmem)
999 //from any given member of recv_frame.
1000 // rxmem indicates the any member/address in recv_frame
1002 - return (union recv_frame*)(((uint)rxmem>>RXFRAME_ALIGN) <<RXFRAME_ALIGN) ;
1004 + //return (union recv_frame*)(((uint)rxmem>>RXFRAME_ALIGN) <<RXFRAME_ALIGN) ;
1005 + //return (union recv_frame*)(((SIZE_PTR)rxmem >> RXFRAME_ALIGN) << RXFRAME_ALIGN);
1006 + return (union recv_frame*)(((ulong)rxmem>>RXFRAME_ALIGN) <<RXFRAME_ALIGN) ;
1009 __inline static union recv_frame *pkt_to_recvframe(_pkt *pkt)
1010 diff --git a/os_dep/linux/os_intfs.c b/os_dep/linux/os_intfs.c
1011 index 4d057a6..d3b662c 100644
1012 --- a/os_dep/linux/os_intfs.c
1013 +++ b/os_dep/linux/os_intfs.c
1014 @@ -255,6 +255,246 @@ static char rtw_proc_name[IFNAMSIZ];
1015 static struct proc_dir_entry *rtw_proc = NULL;
1016 static int rtw_proc_cnt = 0;
1019 + * seq_file wrappers for procfile show routines, kernel >= 3.10
1021 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
1023 +static int proc_get_drv_version_open(struct inode *inode, struct file *file){
1024 + return single_open(file, proc_get_drv_version, PDE_DATA(inode));
1027 +static const struct file_operations proc_get_drv_version_fops = {
1028 + .owner = THIS_MODULE,
1029 + .open = proc_get_drv_version_open,
1031 + .llseek = seq_lseek,
1032 + .release = single_release,
1035 +static int proc_get_write_reg_open(struct inode *inode, struct file *file){
1036 + return single_open(file, proc_get_write_reg, PDE_DATA(inode));
1039 +static const struct file_operations proc_get_write_reg_fops = {
1040 + .owner = THIS_MODULE,
1041 + .open = proc_get_write_reg_open,
1043 + .llseek = seq_lseek,
1044 + .write = proc_set_write_reg,
1045 + .release = seq_release,
1048 +static int proc_get_read_reg_open(struct inode *inode, struct file *file){
1049 + return single_open(file, proc_get_read_reg, PDE_DATA(inode));
1052 +static const struct file_operations proc_get_read_reg_fops = {
1053 + .owner = THIS_MODULE,
1054 + .open = proc_get_read_reg_open,
1056 + .llseek = seq_lseek,
1057 + .write = proc_set_read_reg,
1058 + .release = seq_release,
1061 +static int proc_get_rssi_disp_open(struct inode *inode, struct file *file){
1062 + return single_open(file, proc_get_rssi_disp, PDE_DATA(inode));
1065 +static const struct file_operations proc_get_rssi_disp_fops = {
1066 + .owner = THIS_MODULE,
1067 + .open = proc_get_rssi_disp_open,
1069 + .llseek = seq_lseek,
1070 + .write = proc_set_rssi_disp,
1071 + .release = seq_release,
1074 +static int proc_get_ampdu_enable_open(struct inode *inode, struct file *file){
1075 + return single_open(file, proc_get_ampdu_enable, PDE_DATA(inode));
1078 +static const struct file_operations proc_get_ampdu_enable_fops = {
1079 + .owner = THIS_MODULE,
1080 + .open = proc_get_ampdu_enable_open,
1082 + .llseek = seq_lseek,
1083 + .write = proc_set_ampdu_enable,
1084 + .release = seq_release,
1087 +static int proc_get_rx_signal_open(struct inode *inode, struct file *file){
1088 + return single_open(file, proc_get_rx_signal, PDE_DATA(inode));
1091 +static const struct file_operations proc_get_rx_signal_fops = {
1092 + .owner = THIS_MODULE,
1093 + .open = proc_get_rx_signal_open,
1095 + .llseek = seq_lseek,
1096 + .write = proc_set_rx_signal,
1097 + .release = seq_release,
1100 +static int proc_get_fwstate_open(struct inode *inode, struct file *file){
1101 + return single_open(file, proc_get_fwstate, PDE_DATA(inode));
1104 +static const struct file_operations proc_get_fwstate_fops = {
1105 + .owner = THIS_MODULE,
1106 + .open = proc_get_fwstate_open,
1108 + .llseek = seq_lseek,
1109 + .release = single_release,
1112 +static int proc_get_mlmext_state_open(struct inode *inode, struct file *file){
1113 + return single_open(file, proc_get_mlmext_state, PDE_DATA(inode));
1116 +static const struct file_operations proc_get_mlmext_state_fops = {
1117 + .owner = THIS_MODULE,
1118 + .open = proc_get_mlmext_state_open,
1120 + .llseek = seq_lseek,
1121 + .release = single_release,
1124 +static int proc_get_qos_option_open(struct inode *inode, struct file *file){
1125 + return single_open(file, proc_get_qos_option, PDE_DATA(inode));
1128 +static const struct file_operations proc_get_qos_option_fops = {
1129 + .owner = THIS_MODULE,
1130 + .open = proc_get_qos_option_open,
1132 + .llseek = seq_lseek,
1133 + .release = single_release,
1136 +static int proc_get_ht_option_open(struct inode *inode, struct file *file){
1137 + return single_open(file, proc_get_ht_option, PDE_DATA(inode));
1140 +static const struct file_operations proc_get_ht_option_fops = {
1141 + .owner = THIS_MODULE,
1142 + .open = proc_get_ht_option_open,
1144 + .llseek = seq_lseek,
1145 + .release = single_release,
1148 +static int proc_get_rf_info_open(struct inode *inode, struct file *file){
1149 + return single_open(file, proc_get_rf_info, PDE_DATA(inode));
1152 +static const struct file_operations proc_get_rf_info_fops = {
1153 + .owner = THIS_MODULE,
1154 + .open = proc_get_rf_info_open,
1156 + .llseek = seq_lseek,
1157 + .release = single_release,
1160 +static int proc_get_ap_info_open(struct inode *inode, struct file *file){
1161 + return single_open(file, proc_get_ap_info, PDE_DATA(inode));
1164 +static const struct file_operations proc_get_ap_info_fops = {
1165 + .owner = THIS_MODULE,
1166 + .open = proc_get_ap_info_open,
1168 + .llseek = seq_lseek,
1169 + .release = single_release,
1172 +static int proc_get_adapter_state_open(struct inode *inode, struct file *file){
1173 + return single_open(file, proc_get_adapter_state, PDE_DATA(inode));
1176 +static const struct file_operations proc_get_adapter_state_fops = {
1177 + .owner = THIS_MODULE,
1178 + .open = proc_get_adapter_state_open,
1180 + .llseek = seq_lseek,
1181 + .release = single_release,
1184 +static int proc_get_trx_info_open(struct inode *inode, struct file *file){
1185 + return single_open(file, proc_get_trx_info, PDE_DATA(inode));
1188 +static const struct file_operations proc_get_trx_info_fops = {
1189 + .owner = THIS_MODULE,
1190 + .open = proc_get_trx_info_open,
1192 + .llseek = seq_lseek,
1193 + .release = single_release,
1196 +static int proc_get_sec_info_open(struct inode *inode, struct file *file){
1197 + return single_open(file, proc_get_sec_info, PDE_DATA(inode));
1200 +static const struct file_operations proc_get_sec_info_fops = {
1201 + .owner = THIS_MODULE,
1202 + .open = proc_get_sec_info_open,
1204 + .llseek = seq_lseek,
1205 + .release = single_release,
1208 +# ifdef CONFIG_AP_MODE
1210 +static int proc_get_all_sta_info_open(struct inode *inode, struct file *file){
1211 + return single_open(file, proc_get_all_sta_info, PDE_DATA(inode));
1214 +static const struct file_operations proc_get_all_sta_info_fops = {
1215 + .owner = THIS_MODULE,
1216 + .open = proc_get_all_sta_info_open,
1218 + .llseek = seq_lseek,
1219 + .release = single_release,
1224 +# ifdef DBG_MEMORY_LEAK
1226 +static int proc_get_malloc_cnt_open(struct inode *inode, struct file *file){
1227 + return single_open(file, proc_get_malloc_cnt, PDE_DATA(inode));
1230 +static const struct file_operations proc_get_malloc_cnt_fops = {
1231 + .owner = THIS_MODULE,
1232 + .open = proc_get_malloc_cnt_open,
1234 + .llseek = seq_lseek,
1235 + .release = single_release,
1240 +# ifdef CONFIG_FIND_BEST_CHANNEL
1242 +static int proc_get_best_channel_open(struct inode *inode, struct file *file){
1243 + return single_open(file, proc_get_best_channel, PDE_DATA(inode));
1246 +static const struct file_operations proc_get_best_channel_fops = {
1247 + .owner = THIS_MODULE,
1248 + .open = proc_get_best_channel_open,
1250 + .llseek = seq_lseek,
1251 + .release = single_release,
1258 void rtw_proc_init_one(struct net_device *dev)
1260 struct proc_dir_entry *dir_dev = NULL;
1261 @@ -275,28 +515,37 @@ void rtw_proc_init_one(struct net_device *dev)
1262 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
1263 rtw_proc=create_proc_entry(rtw_proc_name, S_IFDIR, proc_net);
1265 +# if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1266 rtw_proc=create_proc_entry(rtw_proc_name, S_IFDIR, init_net.proc_net);
1268 + rtw_proc=proc_mkdir(rtw_proc_name, init_net.proc_net);
1271 if (rtw_proc == NULL) {
1272 DBG_8192C(KERN_ERR "Unable to create rtw_proc directory\n");
1276 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1277 entry = create_proc_read_entry("ver_info", S_IFREG | S_IRUGO, rtw_proc, proc_get_drv_version, dev);
1279 + entry = proc_create_data("ver_info", S_IFREG | S_IRUGO, rtw_proc, &proc_get_drv_version_fops, dev);
1282 DBG_871X("Unable to create_proc_read_entry!\n");
1289 if(padapter->dir_dev == NULL)
1291 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1292 padapter->dir_dev = create_proc_entry(dev->name,
1293 S_IFDIR | S_IRUGO | S_IXUGO,
1297 + padapter->dir_dev = proc_mkdir(dev->name,rtw_proc);
1299 dir_dev = padapter->dir_dev;
1302 @@ -324,84 +573,127 @@ void rtw_proc_init_one(struct net_device *dev)
1306 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1307 entry = create_proc_read_entry("write_reg", S_IFREG | S_IRUGO,
1308 dir_dev, proc_get_write_reg, dev);
1310 + entry = proc_create_data("write_reg", S_IFREG | S_IRUGO,
1311 + dir_dev, &proc_get_write_reg_fops, dev);
1314 DBG_871X("Unable to create_proc_read_entry!\n");
1317 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1318 entry->write_proc = proc_set_write_reg;
1320 entry = create_proc_read_entry("read_reg", S_IFREG | S_IRUGO,
1321 dir_dev, proc_get_read_reg, dev);
1323 + entry = proc_create_data("read_reg", S_IFREG | S_IRUGO,
1324 + dir_dev, &proc_get_read_reg_fops, dev);
1327 DBG_871X("Unable to create_proc_read_entry!\n");
1330 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1331 entry->write_proc = proc_set_read_reg;
1334 entry = create_proc_read_entry("fwstate", S_IFREG | S_IRUGO,
1335 dir_dev, proc_get_fwstate, dev);
1337 + entry = proc_create_data("fwstate", S_IFREG | S_IRUGO,
1338 + dir_dev, &proc_get_fwstate_fops, dev);
1341 DBG_871X("Unable to create_proc_read_entry!\n");
1346 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1347 entry = create_proc_read_entry("sec_info", S_IFREG | S_IRUGO,
1348 dir_dev, proc_get_sec_info, dev);
1350 + entry = proc_create_data("sec_info", S_IFREG | S_IRUGO,
1351 + dir_dev, &proc_get_sec_info_fops, dev);
1354 DBG_871X("Unable to create_proc_read_entry!\n");
1359 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1360 entry = create_proc_read_entry("mlmext_state", S_IFREG | S_IRUGO,
1361 dir_dev, proc_get_mlmext_state, dev);
1363 + entry = proc_create_data("mlmext_state", S_IFREG | S_IRUGO,
1364 + dir_dev, &proc_get_mlmext_state_fops, dev);
1367 DBG_871X("Unable to create_proc_read_entry!\n");
1372 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1373 entry = create_proc_read_entry("qos_option", S_IFREG | S_IRUGO,
1374 dir_dev, proc_get_qos_option, dev);
1376 + entry = proc_create_data("qos_option", S_IFREG | S_IRUGO,
1377 + dir_dev, &proc_get_qos_option_fops, dev);
1380 DBG_871X("Unable to create_proc_read_entry!\n");
1384 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1385 entry = create_proc_read_entry("ht_option", S_IFREG | S_IRUGO,
1386 dir_dev, proc_get_ht_option, dev);
1388 + entry = proc_create_data("ht_option", S_IFREG | S_IRUGO,
1389 + dir_dev, &proc_get_ht_option_fops, dev);
1392 DBG_871X("Unable to create_proc_read_entry!\n");
1396 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1397 entry = create_proc_read_entry("rf_info", S_IFREG | S_IRUGO,
1398 dir_dev, proc_get_rf_info, dev);
1400 + entry = proc_create_data("rf_info", S_IFREG | S_IRUGO,
1401 + dir_dev, &proc_get_rf_info_fops, dev);
1404 DBG_871X("Unable to create_proc_read_entry!\n");
1408 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1409 entry = create_proc_read_entry("ap_info", S_IFREG | S_IRUGO,
1410 dir_dev, proc_get_ap_info, dev);
1412 + entry = proc_create_data("ap_info", S_IFREG | S_IRUGO,
1413 + dir_dev, &proc_get_ap_info_fops, dev);
1416 DBG_871X("Unable to create_proc_read_entry!\n");
1420 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1421 entry = create_proc_read_entry("adapter_state", S_IFREG | S_IRUGO,
1422 dir_dev, proc_get_adapter_state, dev);
1424 + entry = proc_create_data("adapter_state", S_IFREG | S_IRUGO,
1425 + dir_dev, &proc_get_adapter_state_fops, dev);
1428 DBG_871X("Unable to create_proc_read_entry!\n");
1432 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1433 entry = create_proc_read_entry("trx_info", S_IFREG | S_IRUGO,
1434 dir_dev, proc_get_trx_info, dev);
1436 + entry = proc_create_data("trx_info", S_IFREG | S_IRUGO,
1437 + dir_dev, &proc_get_trx_info_fops, dev);
1440 DBG_871X("Unable to create_proc_read_entry!\n");
1442 @@ -409,56 +701,93 @@ void rtw_proc_init_one(struct net_device *dev)
1444 #ifdef CONFIG_AP_MODE
1446 +# if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1447 entry = create_proc_read_entry("all_sta_info", S_IFREG | S_IRUGO,
1448 dir_dev, proc_get_all_sta_info, dev);
1450 + entry = proc_create_data("all_sta_info", S_IFREG | S_IRUGO,
1451 + dir_dev, &proc_get_all_sta_info_fops, dev);
1454 DBG_871X("Unable to create_proc_read_entry!\n");
1460 #ifdef DBG_MEMORY_LEAK
1462 +# if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1463 entry = create_proc_read_entry("_malloc_cnt", S_IFREG | S_IRUGO,
1464 dir_dev, proc_get_malloc_cnt, dev);
1466 + entry = proc_create_data("_malloc_cnt", S_IFREG | S_IRUGO,
1467 + dir_dev, &proc_get_malloc_cnt_fops, dev);
1470 DBG_871X("Unable to create_proc_read_entry!\n");
1476 #ifdef CONFIG_FIND_BEST_CHANNEL
1478 +# if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1479 entry = create_proc_read_entry("best_channel", S_IFREG | S_IRUGO,
1480 dir_dev, proc_get_best_channel, dev);
1482 + entry = proc_create_data("best_channel", S_IFREG | S_IRUGO,
1483 + dir_dev, &proc_get_best_channel_fops, dev);
1486 DBG_871X("Unable to create_proc_read_entry!\n");
1492 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1493 entry = create_proc_read_entry("rx_signal", S_IFREG | S_IRUGO,
1494 dir_dev, proc_get_rx_signal, dev);
1496 + entry = proc_create_data("rx_signal", S_IFREG | S_IRUGO,
1497 + dir_dev, &proc_get_rx_signal_fops, dev);
1500 DBG_871X("Unable to create_proc_read_entry!\n");
1503 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1504 entry->write_proc = proc_set_rx_signal;
1506 entry = create_proc_read_entry("ampdu_enable", S_IFREG | S_IRUGO,
1507 dir_dev, proc_get_ampdu_enable, dev);
1509 + entry = proc_create_data("ampdu_enable", S_IFREG | S_IRUGO,
1510 + dir_dev, &proc_get_ampdu_enable_fops, dev);
1513 DBG_871X("Unable to create_proc_read_entry!\n");
1517 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1518 entry->write_proc = proc_set_ampdu_enable;
1520 entry = create_proc_read_entry("rssi_disp", S_IFREG | S_IRUGO,
1521 dir_dev, proc_get_rssi_disp, dev);
1523 + entry = proc_create_data("rssi_disp", S_IFREG | S_IRUGO,
1524 + dir_dev, &proc_get_rssi_disp_fops, dev);
1527 DBG_871X("Unable to create_proc_read_entry!\n");
1530 +#if LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)
1531 entry->write_proc = proc_set_rssi_disp;
1536 void rtw_proc_remove_one(struct net_device *dev)
1537 @@ -797,27 +1126,22 @@ u32 rtw_start_drv_threads(_adapter *padapter)
1538 RT_TRACE(_module_os_intfs_c_,_drv_info_,("+rtw_start_drv_threads\n"));
1540 #ifdef CONFIG_SDIO_HCI
1541 - padapter->xmitThread = kernel_thread(rtw_xmit_thread, padapter, CLONE_FS|CLONE_FILES);
1542 - if(padapter->xmitThread < 0)
1543 + if(!start_kthread(&padapter->xmitThread, rtw_xmit_thread, padapter, "8192cu-xmit"))
1547 #ifdef CONFIG_RECV_THREAD_MODE
1548 - padapter->recvThread = kernel_thread(recv_thread, padapter, CLONE_FS|CLONE_FILES);
1549 - if(padapter->recvThread < 0)
1550 + if(!start_kthread(&padapter->recvThread, recv_thread, padapter, "8192cu-recv"))
1554 - padapter->cmdThread = kernel_thread(rtw_cmd_thread, padapter, CLONE_FS|CLONE_FILES);
1555 - if(padapter->cmdThread < 0)
1556 + if(!start_kthread(&padapter->cmdThread, rtw_cmd_thread, padapter, "8192cu-cmd"))
1559 _rtw_down_sema(&padapter->cmdpriv.terminate_cmdthread_sema); //wait for cmd_thread to run
1562 #ifdef CONFIG_EVENT_THREAD_MODE
1563 - padapter->evtThread = kernel_thread(event_thread, padapter, CLONE_FS|CLONE_FILES);
1564 - if(padapter->evtThread < 0)
1565 + if(!start_kthread(&padapter->evtThread, event_thread, padapter, "8192cu-evt"))
1569 diff --git a/os_dep/linux/usb_intf.c b/os_dep/linux/usb_intf.c
1570 index 134acdc..f9a01e9 100644
1571 --- a/os_dep/linux/usb_intf.c
1572 +++ b/os_dep/linux/usb_intf.c
1573 @@ -99,7 +99,9 @@ static struct usb_device_id rtw_usb_id_tbl[] ={
1574 {USB_DEVICE(0x2019, 0xED17)},//PCI - Edimax
1575 {USB_DEVICE(0x0DF6, 0x0052)},//Sitecom - Edimax
1576 {USB_DEVICE(0x7392, 0x7811)},//Edimax - Edimax
1577 + {USB_DEVICE(0x07B8, 0x8188)},//Abocom - Abocom
1578 {USB_DEVICE(0x07B8, 0x8189)},//Abocom - Abocom
1579 + {USB_DEVICE(0x0846, 0x9041)},//NetGear WNA1000M
1580 {USB_DEVICE(0x0EB0, 0x9071)},//NO Brand - Etop
1581 {USB_DEVICE(0x06F8, 0xE033)},//Hercules - Edimax
1582 {USB_DEVICE(0x103C, 0x1629)},//HP - Lite-On ,8188CUS Slim Combo
1583 @@ -137,6 +139,7 @@ static struct usb_device_id rtw_usb_id_tbl[] ={
1584 {USB_DEVICE(0x2001, 0x3307)},//D-Link - Cameo
1585 {USB_DEVICE(0x2001, 0x330A)},//D-Link - Alpha
1586 {USB_DEVICE(0x2001, 0x3309)},//D-Link - Alpha
1587 + {USB_DEVICE(0x2001, 0x330D)},//D-Link - Alpha(?)
1588 {USB_DEVICE(0x0586, 0x341F)},//Zyxel - Abocom
1589 {USB_DEVICE(0x7392, 0x7822)},//Edimax - Edimax
1590 {USB_DEVICE(0x2019, 0xAB2B)},//Planex - Abocom
1591 diff --git a/os_dep/osdep_service.c b/os_dep/osdep_service.c
1592 index 04cb35f..343cd82 100644
1593 --- a/os_dep/osdep_service.c
1594 +++ b/os_dep/osdep_service.c
1595 @@ -1553,3 +1553,19 @@ u64 rtw_division64(u64 x, u64 y)
1599 +#ifdef PLATFORM_LINUX
1600 +int start_kthread(_thread_hdl_ *t_hdl, int (*threadfn)(void *data),
1601 + void *data, const char *name)
1603 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0))
1604 + *t_hdl = kernel_thread(threadfn, data, CLONE_FS|CLONE_FILES);
1607 + *t_hdl = kthread_run(threadfn, data, name);
1608 + if(IS_ERR(*t_hdl))