Loading...
1/**
2@file HandleControlPacket.c
3This file contains the routines to deal with
4sending and receiving of control packets.
5*/
6#include "headers.h"
7
8/**
9When a control packet is received, analyze the
10"status" and call appropriate response function.
11Enqueue the control packet for Application.
12@return None
13*/
14static VOID handle_rx_control_packet(PMINI_ADAPTER Adapter, struct sk_buff *skb)
15{
16 PPER_TARANG_DATA pTarang = NULL;
17 BOOLEAN HighPriorityMessage = FALSE;
18 struct sk_buff * newPacket = NULL;
19 CHAR cntrl_msg_mask_bit = 0;
20 BOOLEAN drop_pkt_flag = TRUE ;
21 USHORT usStatus = *(PUSHORT)(skb->data);
22
23 if (netif_msg_pktdata(Adapter))
24 print_hex_dump(KERN_DEBUG, PFX "rx control: ", DUMP_PREFIX_NONE,
25 16, 1, skb->data, skb->len, 0);
26
27 switch(usStatus)
28 {
29 case CM_RESPONSES: // 0xA0
30 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "MAC Version Seems to be Non Multi-Classifier, rejected by Driver");
31 HighPriorityMessage = TRUE ;
32 break;
33 case CM_CONTROL_NEWDSX_MULTICLASSIFIER_RESP:
34 HighPriorityMessage = TRUE ;
35 if(Adapter->LinkStatus==LINKUP_DONE)
36 {
37 CmControlResponseMessage(Adapter,(skb->data +sizeof(USHORT)));
38 }
39 break;
40 case LINK_CONTROL_RESP: //0xA2
41 case STATUS_RSP: //0xA1
42 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL,"LINK_CONTROL_RESP");
43 HighPriorityMessage = TRUE ;
44 LinkControlResponseMessage(Adapter,(skb->data + sizeof(USHORT)));
45 break;
46 case STATS_POINTER_RESP: //0xA6
47 HighPriorityMessage = TRUE ;
48 StatisticsResponse(Adapter, (skb->data + sizeof(USHORT)));
49 break;
50 case IDLE_MODE_STATUS: //0xA3
51 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL,"IDLE_MODE_STATUS Type Message Got from F/W");
52 InterfaceIdleModeRespond(Adapter, (PUINT)(skb->data +
53 sizeof(USHORT)));
54 HighPriorityMessage = TRUE ;
55 break;
56
57 case AUTH_SS_HOST_MSG:
58 HighPriorityMessage = TRUE ;
59 break;
60
61 default:
62 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL,"Got Default Response");
63 /* Let the Application Deal with This Packet */
64 break;
65 }
66
67 //Queue The Control Packet to The Application Queues
68 down(&Adapter->RxAppControlQueuelock);
69
70 for (pTarang = Adapter->pTarangs; pTarang; pTarang = pTarang->next)
71 {
72 if(Adapter->device_removed)
73 {
74 break;
75 }
76
77 drop_pkt_flag = TRUE ;
78 /*
79 There are cntrl msg from A0 to AC. It has been mapped to 0 to C bit in the cntrl mask.
80 Also, by default AD to BF has been masked to the rest of the bits... which wil be ON by default.
81 if mask bit is enable to particular pkt status, send it out to app else stop it.
82 */
83 cntrl_msg_mask_bit = (usStatus & 0x1F);
84 //printk("\ninew msg mask bit which is disable in mask:%X", cntrl_msg_mask_bit);
85 if(pTarang->RxCntrlMsgBitMask & (1<<cntrl_msg_mask_bit))
86 drop_pkt_flag = FALSE;
87
88 if ((drop_pkt_flag == TRUE) || (pTarang->AppCtrlQueueLen > MAX_APP_QUEUE_LEN) ||
89 ((pTarang->AppCtrlQueueLen > MAX_APP_QUEUE_LEN/2) && (HighPriorityMessage == FALSE)))
90 {
91 /*
92 Assumption:-
93 1. every tarang manages it own dropped pkt statitistics
94 2. Total packet dropped per tarang will be equal to the sum of all types of dropped
95 pkt by that tarang only.
96
97 */
98 switch(*(PUSHORT)skb->data)
99 {
100 case CM_RESPONSES:
101 pTarang->stDroppedAppCntrlMsgs.cm_responses++;
102 break;
103 case CM_CONTROL_NEWDSX_MULTICLASSIFIER_RESP:
104 pTarang->stDroppedAppCntrlMsgs.cm_control_newdsx_multiclassifier_resp++;
105 break;
106 case LINK_CONTROL_RESP:
107 pTarang->stDroppedAppCntrlMsgs.link_control_resp++;
108 break;
109 case STATUS_RSP:
110 pTarang->stDroppedAppCntrlMsgs.status_rsp++;
111 break;
112 case STATS_POINTER_RESP:
113 pTarang->stDroppedAppCntrlMsgs.stats_pointer_resp++;
114 break;
115 case IDLE_MODE_STATUS:
116 pTarang->stDroppedAppCntrlMsgs.idle_mode_status++ ;
117 break;
118 case AUTH_SS_HOST_MSG:
119 pTarang->stDroppedAppCntrlMsgs.auth_ss_host_msg++ ;
120 break;
121 default:
122 pTarang->stDroppedAppCntrlMsgs.low_priority_message++ ;
123 break;
124 }
125
126 continue;
127 }
128
129 newPacket = skb_clone(skb, GFP_KERNEL);
130 if (!newPacket)
131 break;
132 ENQUEUEPACKET(pTarang->RxAppControlHead,pTarang->RxAppControlTail,
133 newPacket);
134 pTarang->AppCtrlQueueLen++;
135 }
136 up(&Adapter->RxAppControlQueuelock);
137 wake_up(&Adapter->process_read_wait_queue);
138 dev_kfree_skb(skb);
139 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "After wake_up_interruptible");
140}
141
142/**
143@ingroup ctrl_pkt_functions
144Thread to handle control pkt reception
145*/
146int control_packet_handler (PMINI_ADAPTER Adapter /**< pointer to adapter object*/
147 )
148{
149 struct sk_buff *ctrl_packet= NULL;
150 unsigned long flags = 0;
151 //struct timeval tv ;
152 //int *puiBuffer = NULL ;
153 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "Entering to make thread wait on control packet event!");
154 while(1)
155 {
156 wait_event_interruptible(Adapter->process_rx_cntrlpkt,
157 atomic_read(&Adapter->cntrlpktCnt) ||
158 Adapter->bWakeUpDevice ||
159 kthread_should_stop()
160 );
161
162
163 if(kthread_should_stop())
164 {
165 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "Exiting \n");
166 return 0;
167 }
168 if(TRUE == Adapter->bWakeUpDevice)
169 {
170 Adapter->bWakeUpDevice = FALSE;
171 if((FALSE == Adapter->bTriedToWakeUpFromlowPowerMode) &&
172 ((TRUE == Adapter->IdleMode)|| (TRUE == Adapter->bShutStatus)))
173 {
174 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "Calling InterfaceAbortIdlemode\n");
175 // Adapter->bTriedToWakeUpFromlowPowerMode = TRUE;
176 InterfaceIdleModeWakeup (Adapter);
177 }
178 continue;
179 }
180
181 while(atomic_read(&Adapter->cntrlpktCnt))
182 {
183 spin_lock_irqsave(&Adapter->control_queue_lock, flags);
184 ctrl_packet = Adapter->RxControlHead;
185 if(ctrl_packet)
186 {
187 DEQUEUEPACKET(Adapter->RxControlHead,Adapter->RxControlTail);
188// Adapter->RxControlHead=ctrl_packet->next;
189 }
190
191 spin_unlock_irqrestore (&Adapter->control_queue_lock, flags);
192 handle_rx_control_packet(Adapter, ctrl_packet);
193 atomic_dec(&Adapter->cntrlpktCnt);
194 }
195
196 SetUpTargetDsxBuffers(Adapter);
197 }
198 return STATUS_SUCCESS;
199}
200
201INT flushAllAppQ(void)
202{
203 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
204 PPER_TARANG_DATA pTarang = NULL;
205 struct sk_buff *PacketToDrop = NULL;
206 for(pTarang = Adapter->pTarangs; pTarang; pTarang = pTarang->next)
207 {
208 while(pTarang->RxAppControlHead != NULL)
209 {
210 PacketToDrop=pTarang->RxAppControlHead;
211 DEQUEUEPACKET(pTarang->RxAppControlHead,pTarang->RxAppControlTail);
212 dev_kfree_skb(PacketToDrop);
213 }
214 pTarang->AppCtrlQueueLen = 0;
215 //dropped contrl packet statistics also should be reset.
216 memset((PVOID)&pTarang->stDroppedAppCntrlMsgs, 0, sizeof(S_MIBS_DROPPED_APP_CNTRL_MESSAGES));
217
218 }
219 return STATUS_SUCCESS ;
220}
221
222
1/**
2 * @file HandleControlPacket.c
3 * This file contains the routines to deal with
4 * sending and receiving of control packets.
5 */
6#include "headers.h"
7
8/**
9 * When a control packet is received, analyze the
10 * "status" and call appropriate response function.
11 * Enqueue the control packet for Application.
12 * @return None
13 */
14static VOID handle_rx_control_packet(struct bcm_mini_adapter *Adapter, struct sk_buff *skb)
15{
16 struct bcm_tarang_data *pTarang = NULL;
17 bool HighPriorityMessage = false;
18 struct sk_buff *newPacket = NULL;
19 CHAR cntrl_msg_mask_bit = 0;
20 bool drop_pkt_flag = TRUE;
21 USHORT usStatus = *(PUSHORT)(skb->data);
22
23 if (netif_msg_pktdata(Adapter))
24 print_hex_dump(KERN_DEBUG, PFX "rx control: ", DUMP_PREFIX_NONE,
25 16, 1, skb->data, skb->len, 0);
26
27 switch (usStatus) {
28 case CM_RESPONSES: /* 0xA0 */
29 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CP_CTRL_PKT,
30 DBG_LVL_ALL,
31 "MAC Version Seems to be Non Multi-Classifier, rejected by Driver");
32 HighPriorityMessage = TRUE;
33 break;
34 case CM_CONTROL_NEWDSX_MULTICLASSIFIER_RESP:
35 HighPriorityMessage = TRUE;
36 if (Adapter->LinkStatus == LINKUP_DONE)
37 CmControlResponseMessage(Adapter,
38 (skb->data + sizeof(USHORT)));
39 break;
40 case LINK_CONTROL_RESP: /* 0xA2 */
41 case STATUS_RSP: /* 0xA1 */
42 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CP_CTRL_PKT,
43 DBG_LVL_ALL, "LINK_CONTROL_RESP");
44 HighPriorityMessage = TRUE;
45 LinkControlResponseMessage(Adapter,
46 (skb->data + sizeof(USHORT)));
47 break;
48 case STATS_POINTER_RESP: /* 0xA6 */
49 HighPriorityMessage = TRUE;
50 StatisticsResponse(Adapter, (skb->data + sizeof(USHORT)));
51 break;
52 case IDLE_MODE_STATUS: /* 0xA3 */
53 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CP_CTRL_PKT,
54 DBG_LVL_ALL,
55 "IDLE_MODE_STATUS Type Message Got from F/W");
56 InterfaceIdleModeRespond(Adapter, (PUINT)(skb->data +
57 sizeof(USHORT)));
58 HighPriorityMessage = TRUE;
59 break;
60
61 case AUTH_SS_HOST_MSG:
62 HighPriorityMessage = TRUE;
63 break;
64
65 default:
66 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CP_CTRL_PKT,
67 DBG_LVL_ALL, "Got Default Response");
68 /* Let the Application Deal with This Packet */
69 break;
70 }
71
72 /* Queue The Control Packet to The Application Queues */
73 down(&Adapter->RxAppControlQueuelock);
74
75 for (pTarang = Adapter->pTarangs; pTarang; pTarang = pTarang->next) {
76 if (Adapter->device_removed)
77 break;
78
79 drop_pkt_flag = TRUE;
80 /*
81 * There are cntrl msg from A0 to AC. It has been mapped to 0 to
82 * C bit in the cntrl mask.
83 * Also, by default AD to BF has been masked to the rest of the
84 * bits... which wil be ON by default.
85 * if mask bit is enable to particular pkt status, send it out
86 * to app else stop it.
87 */
88 cntrl_msg_mask_bit = (usStatus & 0x1F);
89 /*
90 * printk("\ninew msg mask bit which is disable in mask:%X",
91 * cntrl_msg_mask_bit);
92 */
93 if (pTarang->RxCntrlMsgBitMask & (1 << cntrl_msg_mask_bit))
94 drop_pkt_flag = false;
95
96 if ((drop_pkt_flag == TRUE) ||
97 (pTarang->AppCtrlQueueLen > MAX_APP_QUEUE_LEN)
98 || ((pTarang->AppCtrlQueueLen >
99 MAX_APP_QUEUE_LEN / 2) &&
100 (HighPriorityMessage == false))) {
101 /*
102 * Assumption:-
103 * 1. every tarang manages it own dropped pkt
104 * statitistics
105 * 2. Total packet dropped per tarang will be equal to
106 * the sum of all types of dropped pkt by that
107 * tarang only.
108 */
109 switch (*(PUSHORT)skb->data) {
110 case CM_RESPONSES:
111 pTarang->stDroppedAppCntrlMsgs.cm_responses++;
112 break;
113 case CM_CONTROL_NEWDSX_MULTICLASSIFIER_RESP:
114 pTarang->stDroppedAppCntrlMsgs.cm_control_newdsx_multiclassifier_resp++;
115 break;
116 case LINK_CONTROL_RESP:
117 pTarang->stDroppedAppCntrlMsgs.link_control_resp++;
118 break;
119 case STATUS_RSP:
120 pTarang->stDroppedAppCntrlMsgs.status_rsp++;
121 break;
122 case STATS_POINTER_RESP:
123 pTarang->stDroppedAppCntrlMsgs.stats_pointer_resp++;
124 break;
125 case IDLE_MODE_STATUS:
126 pTarang->stDroppedAppCntrlMsgs.idle_mode_status++;
127 break;
128 case AUTH_SS_HOST_MSG:
129 pTarang->stDroppedAppCntrlMsgs.auth_ss_host_msg++;
130 break;
131 default:
132 pTarang->stDroppedAppCntrlMsgs.low_priority_message++;
133 break;
134 }
135
136 continue;
137 }
138
139 newPacket = skb_clone(skb, GFP_KERNEL);
140 if (!newPacket)
141 break;
142 ENQUEUEPACKET(pTarang->RxAppControlHead,
143 pTarang->RxAppControlTail, newPacket);
144 pTarang->AppCtrlQueueLen++;
145 }
146 up(&Adapter->RxAppControlQueuelock);
147 wake_up(&Adapter->process_read_wait_queue);
148 dev_kfree_skb(skb);
149 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL,
150 "After wake_up_interruptible");
151}
152
153/**
154 * @ingroup ctrl_pkt_functions
155 * Thread to handle control pkt reception
156 */
157int control_packet_handler(struct bcm_mini_adapter *Adapter /* pointer to adapter object*/)
158{
159 struct sk_buff *ctrl_packet = NULL;
160 unsigned long flags = 0;
161 /* struct timeval tv; */
162 /* int *puiBuffer = NULL; */
163 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL,
164 "Entering to make thread wait on control packet event!");
165 while (1) {
166 wait_event_interruptible(Adapter->process_rx_cntrlpkt,
167 atomic_read(&Adapter->cntrlpktCnt) ||
168 Adapter->bWakeUpDevice ||
169 kthread_should_stop());
170
171
172 if (kthread_should_stop()) {
173 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, CP_CTRL_PKT,
174 DBG_LVL_ALL, "Exiting\n");
175 return 0;
176 }
177 if (TRUE == Adapter->bWakeUpDevice) {
178 Adapter->bWakeUpDevice = false;
179 if ((false == Adapter->bTriedToWakeUpFromlowPowerMode)
180 && ((TRUE == Adapter->IdleMode) ||
181 (TRUE == Adapter->bShutStatus))) {
182 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS,
183 CP_CTRL_PKT, DBG_LVL_ALL,
184 "Calling InterfaceAbortIdlemode\n");
185 /*
186 * Adapter->bTriedToWakeUpFromlowPowerMode
187 * = TRUE;
188 */
189 InterfaceIdleModeWakeup(Adapter);
190 }
191 continue;
192 }
193
194 while (atomic_read(&Adapter->cntrlpktCnt)) {
195 spin_lock_irqsave(&Adapter->control_queue_lock, flags);
196 ctrl_packet = Adapter->RxControlHead;
197 if (ctrl_packet) {
198 DEQUEUEPACKET(Adapter->RxControlHead,
199 Adapter->RxControlTail);
200 /* Adapter->RxControlHead=ctrl_packet->next; */
201 }
202
203 spin_unlock_irqrestore(&Adapter->control_queue_lock,
204 flags);
205 handle_rx_control_packet(Adapter, ctrl_packet);
206 atomic_dec(&Adapter->cntrlpktCnt);
207 }
208
209 SetUpTargetDsxBuffers(Adapter);
210 }
211 return STATUS_SUCCESS;
212}
213
214INT flushAllAppQ(void)
215{
216 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
217 struct bcm_tarang_data *pTarang = NULL;
218 struct sk_buff *PacketToDrop = NULL;
219 for (pTarang = Adapter->pTarangs; pTarang; pTarang = pTarang->next) {
220 while (pTarang->RxAppControlHead != NULL) {
221 PacketToDrop = pTarang->RxAppControlHead;
222 DEQUEUEPACKET(pTarang->RxAppControlHead,
223 pTarang->RxAppControlTail);
224 dev_kfree_skb(PacketToDrop);
225 }
226 pTarang->AppCtrlQueueLen = 0;
227 /* dropped contrl packet statistics also should be reset. */
228 memset((PVOID)&pTarang->stDroppedAppCntrlMsgs, 0,
229 sizeof(struct bcm_mibs_dropped_cntrl_msg));
230
231 }
232 return STATUS_SUCCESS;
233}
234
235