release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/usb/Beceem_driver/src/Common/HandleControlPacket.c

   1 /*
   2 * HandleControlPacket.c
   3 *
   4 *Copyright (C) 2010 Beceem Communications, Inc.
   5 *
   6 *This program is free software: you can redistribute it and/or modify
   7 *it under the terms of the GNU General Public License version 2 as
   8 *published by the Free Software Foundation.
   9 *
  10 *This program is distributed in the hope that it will be useful,but
  11 *WITHOUT ANY WARRANTY; without even the implied warranty of
  12 *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13 *See the GNU General Public License for more details.
  14 *
  15 *You should have received a copy of the GNU General Public License
  16 *along with this program. If not, write to the Free Software Foundation, Inc.,
  17 *51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18 *
  19 */
  20
  21 /************************************************************
  22 *       This file contains the routines to deal with
  23 *      sending and receiving of control packets.
  24 ************************************************************/
  25
  26
  27 #include<headers.h>
  28
  29 /**
  30 When a control packet is received, analyze the
  31 "status" and call appropriate response function.
  32 Enqueue the control packet for Application.
  33 @return None
  34 */
  35 VOID handle_rx_control_packet(PMINI_ADAPTER Adapter,    /**<Pointer to the Adapter structure*/
  36                                                                 struct sk_buff *skb)                            /**<Pointer to the socket buffer*/
  37 {
  38         PPER_TARANG_DATA        pTarang = NULL;
  39         BOOLEAN HighPriorityMessage = FALSE;
  40         struct sk_buff * newPacket = NULL;
  41         CHAR cntrl_msg_mask_bit = 0;
  42         BOOLEAN drop_pkt_flag = TRUE ;
  43         USHORT usStatus = *(PUSHORT)(skb->data);
  44         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "=====>");
  45         /* Get the Leader field */
  46
  47         switch(usStatus)
  48         {
  49                 case CM_RESPONSES:               // 0xA0
  50                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "MAC Version Seems to be Non Multi-Classifier, rejected by Driver");
  51                         HighPriorityMessage = TRUE ;
  52                         break;
  53                 case CM_CONTROL_NEWDSX_MULTICLASSIFIER_RESP:
  54                         HighPriorityMessage = TRUE ;
  55                         if(Adapter->LinkStatus==LINKUP_DONE)
  56                         {
  57                                 CmControlResponseMessage(Adapter,(skb->data +sizeof(USHORT)));
  58                         }
  59                         break;
  60                 case LINK_CONTROL_RESP:          //0xA2
  61                 case STATUS_RSP:          //0xA1
  62                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL,"LINK_CONTROL_RESP");
  63                         HighPriorityMessage = TRUE ;
  64                         LinkControlResponseMessage(Adapter,(skb->data + sizeof(USHORT)));
  65                         break;
  66                 case STATS_POINTER_RESP:       //0xA6
  67                         HighPriorityMessage = TRUE ;
  68                         StatisticsResponse(Adapter, (skb->data + sizeof(USHORT)));
  69                         break;
  70                 case IDLE_MODE_STATUS:                  //0xA3
  71                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL,"IDLE_MODE_STATUS Type Message Got from F/W");
  72                         InterfaceIdleModeRespond(Adapter, (PUINT)(skb->data +
  73                                                 sizeof(USHORT)));
  74                         HighPriorityMessage = TRUE ;
  75                         break;
  76
  77                 case AUTH_SS_HOST_MSG:
  78                         HighPriorityMessage = TRUE ;
  79                         break;
  80
  81                 default:
  82                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL,"Got Default Response");
  83                         /* Let the Application Deal with This Packet */
  84                         break;
  85         }
  86
  87         //Queue The Control Packet to The Application Queues
  88         down(&Adapter->RxAppControlQueuelock);
  89
  90         for (pTarang = Adapter->pTarangs; pTarang; pTarang = pTarang->next)
  91     {
  92         if(Adapter->device_removed)
  93                 {
  94                         break;
  95                 }
  96
  97                 drop_pkt_flag = TRUE ;
  98                 /*
  99                         There are cntrl msg from A0 to AC. It has been mapped to 0 to C bit in the cntrl mask.
 100                         Also, by default AD to BF has been masked to the rest of the bits... which wil be ON by default.
 101                         if mask bit is enable to particular pkt status, send it out to app else stop it.
 102                 */
 103                 cntrl_msg_mask_bit = (usStatus & 0x1F);
 104                 //printk("\ninew  msg  mask bit which is disable in mask:%X", cntrl_msg_mask_bit);
 105                 if(pTarang->RxCntrlMsgBitMask & (1<<cntrl_msg_mask_bit))
 106                                 drop_pkt_flag = FALSE;
 107
 108                 if ((drop_pkt_flag == TRUE)  || (pTarang->AppCtrlQueueLen > MAX_APP_QUEUE_LEN) ||
 109                                         ((pTarang->AppCtrlQueueLen > MAX_APP_QUEUE_LEN/2) && (HighPriorityMessage == FALSE)))
 110                 {
 111                         /*
 112                                 Assumption:-
 113                                 1. every tarang manages it own dropped pkt statitistics
 114                                 2. Total packet dropped per tarang will be equal to the sum of all types of dropped
 115                                         pkt by that tarang only.
 116
 117                         */
 118                         switch(*(PUSHORT)skb->data)
 119                         {
 120                                 case CM_RESPONSES:
 121                                         pTarang->stDroppedAppCntrlMsgs.cm_responses++;
 122                                         break;
 123                                 case CM_CONTROL_NEWDSX_MULTICLASSIFIER_RESP:
 124                                  pTarang->stDroppedAppCntrlMsgs.cm_control_newdsx_multiclassifier_resp++;
 125                                          break;
 126                                 case LINK_CONTROL_RESP:
 127                                         pTarang->stDroppedAppCntrlMsgs.link_control_resp++;
 128                                         break;
 129                                 case STATUS_RSP:
 130                                         pTarang->stDroppedAppCntrlMsgs.status_rsp++;
 131                                         break;
 132                                 case STATS_POINTER_RESP:
 133                                         pTarang->stDroppedAppCntrlMsgs.stats_pointer_resp++;
 134                                         break;
 135                                 case IDLE_MODE_STATUS:
 136                                         pTarang->stDroppedAppCntrlMsgs.idle_mode_status++ ;
 137                                         break;
 138                                 case AUTH_SS_HOST_MSG:
 139                                         pTarang->stDroppedAppCntrlMsgs.auth_ss_host_msg++ ;
 140                                         break;
 141                         default:
 142                                         pTarang->stDroppedAppCntrlMsgs.low_priority_message++ ;
 143                                         break;
 144                         }
 145
 146                         continue;
 147                 }
 148
 149         newPacket = skb_clone(skb, GFP_KERNEL);
 150         if (!newPacket)
 151            break;
 152         ENQUEUEPACKET(pTarang->RxAppControlHead,pTarang->RxAppControlTail,
 153                                 newPacket);
 154         pTarang->AppCtrlQueueLen++;
 155     }
 156         up(&Adapter->RxAppControlQueuelock);
 157     wake_up(&Adapter->process_read_wait_queue);
 158     bcm_kfree_skb(skb);
 159         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "After wake_up_interruptible");
 160 }
 161
 162 /**
 163 @ingroup ctrl_pkt_functions
 164 Thread to handle control pkt reception
 165 */
 166 int control_packet_handler  (PMINI_ADAPTER Adapter  /**< pointer to adapter object*/
 167                                                 )
 168 {
 169         struct sk_buff *ctrl_packet= NULL;
 170         unsigned long flags = 0;
 171         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "Entering to make thread wait on control packet event!");
 172         while(1)
 173         {
 174                 wait_event_interruptible_timeout(Adapter->process_rx_cntrlpkt,
 175                                                                  atomic_read(&Adapter->cntrlpktCnt) ||
 176                                                                  Adapter->bWakeUpDevice ||
 177                                                                  kthread_should_stop(),
 178                                                                  msecs_to_jiffies(10)
 179                                                                 );
 180
 181                 if(kthread_should_stop())
 182                 {
 183                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "Exiting \n");
 184             Adapter->control_packet_handler = NULL;
 185                         return 0;
 186                 }
 187 #ifndef BCM_SHM_INTERFACE
 188        shiftDetect(Adapter);
 189 #endif
 190
 191                 if(TRUE == Adapter->bWakeUpDevice)
 192                 {
 193                         Adapter->bWakeUpDevice = FALSE;
 194                         if((FALSE == Adapter->bTriedToWakeUpFromlowPowerMode) &&
 195                                 ((TRUE == Adapter->IdleMode)|| (TRUE == Adapter->bShutStatus)))
 196                         {
 197                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "Calling InterfaceAbortIdlemode\n");
 198         //                      Adapter->bTriedToWakeUpFromlowPowerMode = TRUE;
 199                                 InterfaceIdleModeWakeup (Adapter);
 200                         }
 201                         continue;
 202                 }
 203
 204                 while(atomic_read(&Adapter->cntrlpktCnt))
 205                 {
 206                         spin_lock_irqsave(&Adapter->control_queue_lock, flags);
 207                         ctrl_packet = Adapter->RxControlHead;
 208                         if(ctrl_packet)
 209                         {
 210                                 DEQUEUEPACKET(Adapter->RxControlHead,Adapter->RxControlTail);
 211 //                              Adapter->RxControlHead=ctrl_packet->next;
 212                                 ((PLINUX_DEP_DATA)Adapter->pvOsDepData)->netstats.rx_packets++;
 213                                 ((PLINUX_DEP_DATA)Adapter->pvOsDepData)->netstats.rx_bytes+=
 214                                 ((PLEADER)ctrl_packet->data)->PLength;
 215                         }
 216                         #if 0  //Idle mode debug profiling...
 217                         if(*(PUSHORT)ctrl_packet->data == IDLE_MODE_STATUS)
 218                         {
 219                                 puiBuffer = (PUINT)(ctrl_packet->data +sizeof(USHORT));
 220                                 if((ntohl(*puiBuffer) == GO_TO_IDLE_MODE_PAYLOAD))
 221                                 {
 222                                         memset(&tv, 0, sizeof(tv));
 223                                         do_gettimeofday(&tv);
 224                                         if((ntohl(*(puiBuffer+1)) == 0))
 225                                         {
 226                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "IdleMode Wake-up Msg from f/w at time :%ld ms", tv.tv_sec *1000 + tv.tv_usec /1000);
 227                                         }
 228                                         else
 229                                         {
 230                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "IdleMode req Msg from f/w at time :%ld ms", tv.tv_sec *1000 + tv.tv_usec /1000);
 231                                         }
 232                                 }
 233                                 else if((ntohl(*puiBuffer) == IDLE_MODE_SF_UPDATE_MSG))
 234                                 {
 235                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, CP_CTRL_PKT, DBG_LVL_ALL, "GOT IDLE_MODE_SF_UPDATE MSG at time :%ld ms", tv.tv_sec *1000 + tv.tv_usec /1000);
 236                                 }
 237                         }
 238                         #endif
 239
 240                         spin_unlock_irqrestore (&Adapter->control_queue_lock, flags);
 241                         handle_rx_control_packet(Adapter, ctrl_packet);
 242                         atomic_dec(&Adapter->cntrlpktCnt);
 243                 }
 244
 245         }
 246         return STATUS_SUCCESS;
 247 }
 248
 249 INT flushAllAppQ()
 250 {
 251         PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
 252         PPER_TARANG_DATA        pTarang = NULL;
 253         struct sk_buff *PacketToDrop = NULL;
 254         for(pTarang = Adapter->pTarangs; pTarang; pTarang = pTarang->next)
 255         {
 256                 while(pTarang->RxAppControlHead != NULL)
 257                 {
 258                         PacketToDrop=pTarang->RxAppControlHead;
 259                         DEQUEUEPACKET(pTarang->RxAppControlHead,pTarang->RxAppControlTail);
 260                         bcm_kfree_skb(PacketToDrop);
 261                 }
 262                 pTarang->AppCtrlQueueLen = 0;
 263                 //dropped contrl packet statistics also should be reset.
 264                 memset((PVOID)&pTarang->stDroppedAppCntrlMsgs, 0, sizeof(S_MIBS_DROPPED_APP_CNTRL_MESSAGES));
 265
 266         }
 267         return STATUS_SUCCESS ;
 268 }
 269
 270