drivers/staging/bcm/Misc.c

   1 #include "headers.h"
   2
   3 static int BcmFileDownload(struct bcm_mini_adapter *Adapter, const char *path, unsigned int loc);
   4 static void doPowerAutoCorrection(struct bcm_mini_adapter *psAdapter);
   5 static void HandleShutDownModeRequest(struct bcm_mini_adapter *Adapter, PUCHAR pucBuffer);
   6 static int bcm_parse_target_params(struct bcm_mini_adapter *Adapter);
   7 static void beceem_protocol_reset(struct bcm_mini_adapter *Adapter);
   8
   9 static void default_wimax_protocol_initialize(struct bcm_mini_adapter *Adapter)
  10 {
  11         unsigned int uiLoopIndex;
  12
  13         for (uiLoopIndex = 0; uiLoopIndex < NO_OF_QUEUES-1; uiLoopIndex++) {
  14                 Adapter->PackInfo[uiLoopIndex].uiThreshold = TX_PACKET_THRESHOLD;
  15                 Adapter->PackInfo[uiLoopIndex].uiMaxAllowedRate = MAX_ALLOWED_RATE;
  16                 Adapter->PackInfo[uiLoopIndex].uiMaxBucketSize = 20*1024*1024;
  17         }
  18
  19         Adapter->BEBucketSize = BE_BUCKET_SIZE;
  20         Adapter->rtPSBucketSize = rtPS_BUCKET_SIZE;
  21         Adapter->LinkStatus = SYNC_UP_REQUEST;
  22         Adapter->TransferMode = IP_PACKET_ONLY_MODE;
  23         Adapter->usBestEffortQueueIndex = -1;
  24 }
  25
  26 int InitAdapter(struct bcm_mini_adapter *psAdapter)
  27 {
  28         int i = 0;
  29         int Status = STATUS_SUCCESS;
  30
  31         BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Initialising Adapter = %p", psAdapter);
  32
  33         if (psAdapter == NULL) {
  34                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Adapter is NULL");
  35                 return -EINVAL;
  36         }
  37
  38         sema_init(&psAdapter->NVMRdmWrmLock, 1);
  39         sema_init(&psAdapter->rdmwrmsync, 1);
  40         spin_lock_init(&psAdapter->control_queue_lock);
  41         spin_lock_init(&psAdapter->txtransmitlock);
  42         sema_init(&psAdapter->RxAppControlQueuelock, 1);
  43         sema_init(&psAdapter->fw_download_sema, 1);
  44         sema_init(&psAdapter->LowPowerModeSync, 1);
  45
  46         for (i = 0; i < NO_OF_QUEUES; i++)
  47                 spin_lock_init(&psAdapter->PackInfo[i].SFQueueLock);
  48         i = 0;
  49
  50         init_waitqueue_head(&psAdapter->process_rx_cntrlpkt);
  51         init_waitqueue_head(&psAdapter->tx_packet_wait_queue);
  52         init_waitqueue_head(&psAdapter->process_read_wait_queue);
  53         init_waitqueue_head(&psAdapter->ioctl_fw_dnld_wait_queue);
  54         init_waitqueue_head(&psAdapter->lowpower_mode_wait_queue);
  55         psAdapter->waiting_to_fw_download_done = TRUE;
  56         psAdapter->fw_download_done = false;
  57
  58         default_wimax_protocol_initialize(psAdapter);
  59         for (i = 0; i < MAX_CNTRL_PKTS; i++) {
  60                 psAdapter->txctlpacket[i] = kmalloc(MAX_CNTL_PKT_SIZE, GFP_KERNEL);
  61                 if (!psAdapter->txctlpacket[i]) {
  62                         BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "No More Cntl pkts got, max got is %d", i);
  63                         return -ENOMEM;
  64                 }
  65         }
  66
  67         if (AllocAdapterDsxBuffer(psAdapter)) {
  68                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Failed to allocate DSX buffers");
  69                 return -EINVAL;
  70         }
  71
  72         /* Initialize PHS interface */
  73         if (phs_init(&psAdapter->stBCMPhsContext, psAdapter) != 0) {
  74                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "%s:%s:%d:Error PHS Init Failed=====>\n", __FILE__, __func__, __LINE__);
  75                 return -ENOMEM;
  76         }
  77
  78         Status = BcmAllocFlashCSStructure(psAdapter);
  79         if (Status) {
  80                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Memory Allocation for Flash structure failed");
  81                 return Status;
  82         }
  83
  84         Status = vendorextnInit(psAdapter);
  85
  86         if (STATUS_SUCCESS != Status) {
  87                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Vendor Init Failed");
  88                 return Status;
  89         }
  90
  91         BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Adapter initialised");
  92
  93         return STATUS_SUCCESS;
  94 }
  95
  96 void AdapterFree(struct bcm_mini_adapter *Adapter)
  97 {
  98         int count;
  99
 100         beceem_protocol_reset(Adapter);
 101         vendorextnExit(Adapter);
 102
 103         if (Adapter->control_packet_handler && !IS_ERR(Adapter->control_packet_handler))
 104                 kthread_stop(Adapter->control_packet_handler);
 105
 106         if (Adapter->transmit_packet_thread && !IS_ERR(Adapter->transmit_packet_thread))
 107                 kthread_stop(Adapter->transmit_packet_thread);
 108
 109         wake_up(&Adapter->process_read_wait_queue);
 110
 111         if (Adapter->LEDInfo.led_thread_running & (BCM_LED_THREAD_RUNNING_ACTIVELY | BCM_LED_THREAD_RUNNING_INACTIVELY))
 112                 kthread_stop(Adapter->LEDInfo.led_cntrl_threadid);
 113
 114         unregister_networkdev(Adapter);
 115
 116         /* FIXME: use proper wait_event and refcounting */
 117         while (atomic_read(&Adapter->ApplicationRunning)) {
 118                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Waiting for Application to close.. %d\n", atomic_read(&Adapter->ApplicationRunning));
 119                 msleep(100);
 120         }
 121         unregister_control_device_interface(Adapter);
 122         kfree(Adapter->pstargetparams);
 123
 124         for (count = 0; count < MAX_CNTRL_PKTS; count++)
 125                 kfree(Adapter->txctlpacket[count]);
 126
 127         FreeAdapterDsxBuffer(Adapter);
 128         kfree(Adapter->pvInterfaceAdapter);
 129
 130         /* Free the PHS Interface */
 131         PhsCleanup(&Adapter->stBCMPhsContext);
 132
 133         BcmDeAllocFlashCSStructure(Adapter);
 134
 135         free_netdev(Adapter->dev);
 136 }
 137
 138 static int create_worker_threads(struct bcm_mini_adapter *psAdapter)
 139 {
 140         /* Rx Control Packets Processing */
 141         psAdapter->control_packet_handler = kthread_run((int (*)(void *))
 142                                                         control_packet_handler, psAdapter, "%s-rx", DRV_NAME);
 143         if (IS_ERR(psAdapter->control_packet_handler)) {
 144                 pr_notice(DRV_NAME ": could not create control thread\n");
 145                 return PTR_ERR(psAdapter->control_packet_handler);
 146         }
 147
 148         /* Tx Thread */
 149         psAdapter->transmit_packet_thread = kthread_run((int (*)(void *))
 150                                                         tx_pkt_handler, psAdapter, "%s-tx", DRV_NAME);
 151         if (IS_ERR(psAdapter->transmit_packet_thread)) {
 152                 pr_notice(DRV_NAME ": could not creat transmit thread\n");
 153                 kthread_stop(psAdapter->control_packet_handler);
 154                 return PTR_ERR(psAdapter->transmit_packet_thread);
 155         }
 156         return 0;
 157 }
 158
 159 static struct file *open_firmware_file(struct bcm_mini_adapter *Adapter, const char *path)
 160 {
 161         struct file *flp = filp_open(path, O_RDONLY, S_IRWXU);
 162
 163         if (IS_ERR(flp)) {
 164                 pr_err(DRV_NAME "Unable To Open File %s, err %ld", path, PTR_ERR(flp));
 165                 flp = NULL;
 166         }
 167
 168         if (Adapter->device_removed)
 169                 flp = NULL;
 170
 171         return flp;
 172 }
 173
 174 /* Arguments:
 175  * Logical Adapter
 176  * Path to image file
 177  * Download Address on the chip
 178  */
 179 static int BcmFileDownload(struct bcm_mini_adapter *Adapter, const char *path, unsigned int loc)
 180 {
 181         int errorno = 0;
 182         struct file *flp = NULL;
 183         struct timeval tv = {0};
 184
 185         flp = open_firmware_file(Adapter, path);
 186         if (!flp) {
 187                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Unable to Open %s\n", path);
 188                 return -ENOENT;
 189         }
 190         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Opened file is = %s and length =0x%lx to be downloaded at =0x%x", path, (unsigned long)file_inode(flp)->i_size, loc);
 191         do_gettimeofday(&tv);
 192
 193         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "download start %lx", ((tv.tv_sec * 1000) + (tv.tv_usec / 1000)));
 194         if (Adapter->bcm_file_download(Adapter->pvInterfaceAdapter, flp, loc)) {
 195                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Failed to download the firmware with error %x!!!", -EIO);
 196                 errorno = -EIO;
 197                 goto exit_download;
 198         }
 199         vfs_llseek(flp, 0, 0);
 200         if (Adapter->bcm_file_readback_from_chip(Adapter->pvInterfaceAdapter, flp, loc)) {
 201                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Failed to read back firmware!");
 202                 errorno = -EIO;
 203                 goto exit_download;
 204         }
 205
 206 exit_download:
 207         filp_close(flp, NULL);
 208         return errorno;
 209 }
 210
 211 /**
 212  * @ingroup ctrl_pkt_functions
 213  * This function copies the contents of given buffer
 214  * to the control packet and queues it for transmission.
 215  * @note Do not acquire the spinlock, as it it already acquired.
 216  * @return  SUCCESS/FAILURE.
 217  * Arguments:
 218  * Logical Adapter
 219  * Control Packet Buffer
 220  */
 221 int CopyBufferToControlPacket(struct bcm_mini_adapter *Adapter, void *ioBuffer)
 222 {
 223         struct bcm_leader *pLeader = NULL;
 224         int Status = 0;
 225         unsigned char *ctrl_buff;
 226         unsigned int pktlen = 0;
 227         struct bcm_link_request *pLinkReq = NULL;
 228         PUCHAR pucAddIndication = NULL;
 229
 230         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "======>");
 231         if (!ioBuffer) {
 232                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Got Null Buffer\n");
 233                 return -EINVAL;
 234         }
 235
 236         pLinkReq = (struct bcm_link_request *)ioBuffer;
 237         pLeader = (struct bcm_leader *)ioBuffer; /* ioBuffer Contains sw_Status and Payload */
 238
 239         if (Adapter->bShutStatus == TRUE &&
 240                 pLinkReq->szData[0] == LINK_DOWN_REQ_PAYLOAD &&
 241                 pLinkReq->szData[1] == LINK_SYNC_UP_SUBTYPE) {
 242
 243                 /* Got sync down in SHUTDOWN..we could not process this. */
 244                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "SYNC DOWN Request in Shut Down Mode..\n");
 245                 return STATUS_FAILURE;
 246         }
 247
 248         if ((pLeader->Status == LINK_UP_CONTROL_REQ) &&
 249                 ((pLinkReq->szData[0] == LINK_UP_REQ_PAYLOAD &&
 250                         (pLinkReq->szData[1] == LINK_SYNC_UP_SUBTYPE)) || /* Sync Up Command */
 251                         pLinkReq->szData[0] == NETWORK_ENTRY_REQ_PAYLOAD)) /* Net Entry Command */ {
 252
 253                 if (Adapter->LinkStatus > PHY_SYNC_ACHIVED) {
 254                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "LinkStatus is Greater than PHY_SYN_ACHIEVED");
 255                         return STATUS_FAILURE;
 256                 }
 257
 258                 if (Adapter->bShutStatus == TRUE) {
 259                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "SYNC UP IN SHUTDOWN..Device WakeUp\n");
 260                         if (Adapter->bTriedToWakeUpFromlowPowerMode == false) {
 261                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Waking up for the First Time..\n");
 262                                 Adapter->usIdleModePattern = ABORT_SHUTDOWN_MODE; /* change it to 1 for current support. */
 263                                 Adapter->bWakeUpDevice = TRUE;
 264                                 wake_up(&Adapter->process_rx_cntrlpkt);
 265                                 Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue, !Adapter->bShutStatus, (5 * HZ));
 266
 267                                 if (Status == -ERESTARTSYS)
 268                                         return Status;
 269
 270                                 if (Adapter->bShutStatus) {
 271                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Shutdown Mode Wake up Failed - No Wake Up Received\n");
 272                                         return STATUS_FAILURE;
 273                                 }
 274                         } else {
 275                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Wakeup has been tried already...\n");
 276                         }
 277                 }
 278         }
 279
 280         if (Adapter->IdleMode == TRUE) {
 281                 /* BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is in Idle mode ... hence\n"); */
 282                 if (pLeader->Status == LINK_UP_CONTROL_REQ || pLeader->Status == 0x80 ||
 283                         pLeader->Status == CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ) {
 284
 285                         if ((pLeader->Status == LINK_UP_CONTROL_REQ) && (pLinkReq->szData[0] == LINK_DOWN_REQ_PAYLOAD)) {
 286                                 if (pLinkReq->szData[1] == LINK_SYNC_DOWN_SUBTYPE) {
 287                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Link Down Sent in Idle Mode\n");
 288                                         Adapter->usIdleModePattern = ABORT_IDLE_SYNCDOWN; /* LINK DOWN sent in Idle Mode */
 289                                 } else {
 290                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "ABORT_IDLE_MODE pattern is being written\n");
 291                                         Adapter->usIdleModePattern = ABORT_IDLE_REG;
 292                                 }
 293                         } else {
 294                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "ABORT_IDLE_MODE pattern is being written\n");
 295                                 Adapter->usIdleModePattern = ABORT_IDLE_MODE;
 296                         }
 297
 298                         /*Setting bIdleMode_tx_from_host to TRUE to indicate LED control thread to represent
 299                          *  the wake up from idlemode is from host
 300                          */
 301                         /* Adapter->LEDInfo.bIdleMode_tx_from_host = TRUE; */
 302                         Adapter->bWakeUpDevice = TRUE;
 303                         wake_up(&Adapter->process_rx_cntrlpkt);
 304
 305                         /* We should not send DREG message down while in idlemode. */
 306                         if (LINK_DOWN_REQ_PAYLOAD == pLinkReq->szData[0])
 307                                 return STATUS_SUCCESS;
 308
 309                         Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue, !Adapter->IdleMode, (5 * HZ));
 310
 311                         if (Status == -ERESTARTSYS)
 312                                 return Status;
 313
 314                         if (Adapter->IdleMode) {
 315                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Idle Mode Wake up Failed - No Wake Up Received\n");
 316                                 return STATUS_FAILURE;
 317                         }
 318                 } else {
 319                         return STATUS_SUCCESS;
 320                 }
 321         }
 322
 323         /* The Driver has to send control messages with a particular VCID */
 324         pLeader->Vcid = VCID_CONTROL_PACKET; /* VCID for control packet. */
 325
 326         /* Allocate skb for Control Packet */
 327         pktlen = pLeader->PLength;
 328         ctrl_buff = (char *)Adapter->txctlpacket[atomic_read(&Adapter->index_wr_txcntrlpkt)%MAX_CNTRL_PKTS];
 329
 330         if (!ctrl_buff) {
 331                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "mem allocation Failed");
 332                 return -ENOMEM;
 333         }
 334
 335         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Control packet to be taken =%d and address is =%pincoming address is =%p and packet len=%x",
 336                         atomic_read(&Adapter->index_wr_txcntrlpkt), ctrl_buff, ioBuffer, pktlen);
 337
 338         if (pLeader) {
 339                 if ((pLeader->Status == 0x80) ||
 340                         (pLeader->Status == CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ)) {
 341                         /*
 342                          * Restructure the DSX message to handle Multiple classifier Support
 343                          * Write the Service Flow param Structures directly to the target
 344                          * and embed the pointers in the DSX messages sent to target.
 345                          */
 346                         /* Lets store the current length of the control packet we are transmitting */
 347                         pucAddIndication = (PUCHAR)ioBuffer + LEADER_SIZE;
 348                         pktlen = pLeader->PLength;
 349                         Status = StoreCmControlResponseMessage(Adapter, pucAddIndication, &pktlen);
 350                         if (Status != 1) {
 351                                 ClearTargetDSXBuffer(Adapter, ((struct bcm_add_indication_alt *)pucAddIndication)->u16TID, false);
 352                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, " Error Restoring The DSX Control Packet. Dsx Buffers on Target may not be Setup Properly ");
 353                                 return STATUS_FAILURE;
 354                         }
 355                         /*
 356                          * update the leader to use the new length
 357                          * The length of the control packet is length of message being sent + Leader length
 358                          */
 359                         pLeader->PLength = pktlen;
 360                 }
 361         }
 362
 363         if (pktlen + LEADER_SIZE > MAX_CNTL_PKT_SIZE)
 364                 return -EINVAL;
 365
 366         memset(ctrl_buff, 0, pktlen+LEADER_SIZE);
 367         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Copying the Control Packet Buffer with length=%d\n", pLeader->PLength);
 368         *(struct bcm_leader *)ctrl_buff = *pLeader;
 369         memcpy(ctrl_buff + LEADER_SIZE, ((PUCHAR)ioBuffer + LEADER_SIZE), pLeader->PLength);
 370         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Enqueuing the Control Packet");
 371
 372         /* Update the statistics counters */
 373         spin_lock_bh(&Adapter->PackInfo[HiPriority].SFQueueLock);
 374         Adapter->PackInfo[HiPriority].uiCurrentBytesOnHost += pLeader->PLength;
 375         Adapter->PackInfo[HiPriority].uiCurrentPacketsOnHost++;
 376         atomic_inc(&Adapter->TotalPacketCount);
 377         spin_unlock_bh(&Adapter->PackInfo[HiPriority].SFQueueLock);
 378         Adapter->PackInfo[HiPriority].bValid = TRUE;
 379
 380         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "CurrBytesOnHost: %x bValid: %x",
 381                         Adapter->PackInfo[HiPriority].uiCurrentBytesOnHost,
 382                         Adapter->PackInfo[HiPriority].bValid);
 383         Status = STATUS_SUCCESS;
 384         /*Queue the packet for transmission */
 385         atomic_inc(&Adapter->index_wr_txcntrlpkt);
 386         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Calling transmit_packets");
 387         atomic_set(&Adapter->TxPktAvail, 1);
 388         wake_up(&Adapter->tx_packet_wait_queue);
 389
 390         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "<====");
 391         return Status;
 392 }
 393
 394 /******************************************************************
 395 * Function    - LinkMessage()
 396 *
 397 * Description - This function builds the Sync-up and Link-up request
 398 * packet messages depending on the device Link status.
 399 *
 400 * Parameters  - Adapter:        Pointer to the Adapter structure.
 401 *
 402 * Returns     - None.
 403 *******************************************************************/
 404 void LinkMessage(struct bcm_mini_adapter *Adapter)
 405 {
 406         struct bcm_link_request *pstLinkRequest = NULL;
 407
 408         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "=====>");
 409         if (Adapter->LinkStatus == SYNC_UP_REQUEST && Adapter->AutoSyncup) {
 410                 pstLinkRequest = kzalloc(sizeof(struct bcm_link_request), GFP_ATOMIC);
 411                 if (!pstLinkRequest) {
 412                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Can not allocate memory for Link request!");
 413                         return;
 414                 }
 415                 /* sync up request... */
 416                 Adapter->LinkStatus = WAIT_FOR_SYNC; /* current link status */
 417                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Requesting For SyncUp...");
 418                 pstLinkRequest->szData[0] = LINK_UP_REQ_PAYLOAD;
 419                 pstLinkRequest->szData[1] = LINK_SYNC_UP_SUBTYPE;
 420                 pstLinkRequest->Leader.Status = LINK_UP_CONTROL_REQ;
 421                 pstLinkRequest->Leader.PLength = sizeof(ULONG);
 422                 Adapter->bSyncUpRequestSent = TRUE;
 423
 424         } else if (Adapter->LinkStatus == PHY_SYNC_ACHIVED && Adapter->AutoLinkUp) {
 425                 pstLinkRequest = kzalloc(sizeof(struct bcm_link_request), GFP_ATOMIC);
 426                 if (!pstLinkRequest) {
 427                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Can not allocate memory for Link request!");
 428                         return;
 429                 }
 430                 /* LINK_UP_REQUEST */
 431                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Requesting For LinkUp...");
 432                 pstLinkRequest->szData[0] = LINK_UP_REQ_PAYLOAD;
 433                 pstLinkRequest->szData[1] = LINK_NET_ENTRY;
 434                 pstLinkRequest->Leader.Status = LINK_UP_CONTROL_REQ;
 435                 pstLinkRequest->Leader.PLength = sizeof(ULONG);
 436         }
 437         if (pstLinkRequest) {
 438                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Calling CopyBufferToControlPacket");
 439                 CopyBufferToControlPacket(Adapter, pstLinkRequest);
 440                 kfree(pstLinkRequest);
 441         }
 442         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "LinkMessage <=====");
 443         return;
 444 }
 445
 446 /**********************************************************************
 447 * Function    - StatisticsResponse()
 448 *
 449 * Description - This function handles the Statistics response packet.
 450 *
 451 * Parameters  - Adapter : Pointer to the Adapter structure.
 452 * - pvBuffer: Starting address of Statistic response data.
 453 *
 454 * Returns     - None.
 455 ************************************************************************/
 456 void StatisticsResponse(struct bcm_mini_adapter *Adapter, void *pvBuffer)
 457 {
 458         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "%s====>", __func__);
 459         Adapter->StatisticsPointer = ntohl(*(__be32 *)pvBuffer);
 460         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Stats at %x", (unsigned int)Adapter->StatisticsPointer);
 461         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "%s <====", __func__);
 462 }
 463
 464 /**********************************************************************
 465 * Function    - LinkControlResponseMessage()
 466 *
 467 * Description - This function handles the Link response packets.
 468 *
 469 * Parameters  - Adapter  : Pointer to the Adapter structure.
 470 * - pucBuffer: Starting address of Link response data.
 471 *
 472 * Returns     - None.
 473 ***********************************************************************/
 474 void LinkControlResponseMessage(struct bcm_mini_adapter *Adapter, PUCHAR pucBuffer)
 475 {
 476         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "=====>");
 477
 478         if (*pucBuffer == LINK_UP_ACK) {
 479                 switch (*(pucBuffer+1)) {
 480                 case PHY_SYNC_ACHIVED: /* SYNCed UP */
 481                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "PHY_SYNC_ACHIVED");
 482
 483                                 if (Adapter->LinkStatus == LINKUP_DONE)
 484                                         beceem_protocol_reset(Adapter);
 485
 486                                 Adapter->usBestEffortQueueIndex = INVALID_QUEUE_INDEX;
 487                                 Adapter->LinkStatus = PHY_SYNC_ACHIVED;
 488
 489                                 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
 490                                         Adapter->DriverState = NO_NETWORK_ENTRY;
 491                                         wake_up(&Adapter->LEDInfo.notify_led_event);
 492                                 }
 493
 494                                 LinkMessage(Adapter);
 495                                 break;
 496
 497                 case LINKUP_DONE:
 498                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "LINKUP_DONE");
 499                         Adapter->LinkStatus = LINKUP_DONE;
 500                         Adapter->bPHSEnabled = *(pucBuffer+3);
 501                         Adapter->bETHCSEnabled = *(pucBuffer+4) & ETH_CS_MASK;
 502                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "PHS Support Status Received In LinkUp Ack : %x\n", Adapter->bPHSEnabled);
 503
 504                         if ((false == Adapter->bShutStatus) && (false == Adapter->IdleMode)) {
 505                                 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
 506                                         Adapter->DriverState = NORMAL_OPERATION;
 507                                         wake_up(&Adapter->LEDInfo.notify_led_event);
 508                                 }
 509                         }
 510                         LinkMessage(Adapter);
 511                         break;
 512
 513                 case WAIT_FOR_SYNC:
 514                         /*
 515                          * Driver to ignore the DREG_RECEIVED
 516                          * WiMAX Application should handle this Message
 517                          */
 518                         /* Adapter->liTimeSinceLastNetEntry = 0; */
 519                         Adapter->LinkUpStatus = 0;
 520                         Adapter->LinkStatus = 0;
 521                         Adapter->usBestEffortQueueIndex = INVALID_QUEUE_INDEX;
 522                         Adapter->bTriedToWakeUpFromlowPowerMode = false;
 523                         Adapter->IdleMode = false;
 524                         beceem_protocol_reset(Adapter);
 525
 526                         break;
 527                 case LINK_SHUTDOWN_REQ_FROM_FIRMWARE:
 528                 case COMPLETE_WAKE_UP_NOTIFICATION_FRM_FW:
 529                 {
 530                         HandleShutDownModeRequest(Adapter, pucBuffer);
 531                 }
 532                 break;
 533                 default:
 534                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "default case:LinkResponse %x", *(pucBuffer + 1));
 535                         break;
 536                 }
 537         } else if (SET_MAC_ADDRESS_RESPONSE == *pucBuffer) {
 538                 PUCHAR puMacAddr = (pucBuffer + 1);
 539
 540                 Adapter->LinkStatus = SYNC_UP_REQUEST;
 541                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "MAC address response, sending SYNC_UP");
 542                 LinkMessage(Adapter);
 543                 memcpy(Adapter->dev->dev_addr, puMacAddr, MAC_ADDRESS_SIZE);
 544         }
 545         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "%s <=====", __func__);
 546 }
 547
 548 void SendIdleModeResponse(struct bcm_mini_adapter *Adapter)
 549 {
 550         int status = 0, NVMAccess = 0, lowPwrAbortMsg = 0;
 551         struct timeval tv;
 552         struct bcm_link_request stIdleResponse = {{0} };
 553
 554         memset(&tv, 0, sizeof(tv));
 555         stIdleResponse.Leader.Status = IDLE_MESSAGE;
 556         stIdleResponse.Leader.PLength = IDLE_MODE_PAYLOAD_LENGTH;
 557         stIdleResponse.szData[0] = GO_TO_IDLE_MODE_PAYLOAD;
 558         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, " ============>");
 559
 560         /*********************************
 561          *down_trylock -
 562          * if [ semaphore is available ]
 563          *               acquire semaphone and return value 0 ;
 564          *   else
 565          *               return non-zero value ;
 566          *
 567          ***********************************/
 568
 569         NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
 570         lowPwrAbortMsg = down_trylock(&Adapter->LowPowerModeSync);
 571
 572
 573         if ((NVMAccess || lowPwrAbortMsg || atomic_read(&Adapter->TotalPacketCount)) &&
 574                 (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE)) {
 575
 576                 if (!NVMAccess)
 577                         up(&Adapter->NVMRdmWrmLock);
 578
 579                 if (!lowPwrAbortMsg)
 580                         up(&Adapter->LowPowerModeSync);
 581
 582                 stIdleResponse.szData[1] = TARGET_CAN_NOT_GO_TO_IDLE_MODE; /* NACK- device access is going on. */
 583                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "HOST IS NACKING Idle mode To F/W!!!!!!!!");
 584                 Adapter->bPreparingForLowPowerMode = false;
 585         } else {
 586                 stIdleResponse.szData[1] = TARGET_CAN_GO_TO_IDLE_MODE; /* 2; Idle ACK */
 587                 Adapter->StatisticsPointer = 0;
 588
 589                 /* Wait for the LED to TURN OFF before sending ACK response */
 590                 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
 591                         int iRetVal = 0;
 592
 593                         /* Wake the LED Thread with IDLEMODE_ENTER State */
 594                         Adapter->DriverState = LOWPOWER_MODE_ENTER;
 595                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "LED Thread is Running..Hence Setting LED Event as IDLEMODE_ENTER jiffies:%ld", jiffies);
 596                         wake_up(&Adapter->LEDInfo.notify_led_event);
 597
 598                         /* Wait for 1 SEC for LED to OFF */
 599                         iRetVal = wait_event_timeout(Adapter->LEDInfo.idleModeSyncEvent, Adapter->LEDInfo.bIdle_led_off, msecs_to_jiffies(1000));
 600
 601                         /* If Timed Out to Sync IDLE MODE Enter, do IDLE mode Exit and Send NACK to device */
 602                         if (iRetVal <= 0) {
 603                                 stIdleResponse.szData[1] = TARGET_CAN_NOT_GO_TO_IDLE_MODE; /* NACK- device access is going on. */
 604                                 Adapter->DriverState = NORMAL_OPERATION;
 605                                 wake_up(&Adapter->LEDInfo.notify_led_event);
 606                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "NACKING Idle mode as time out happen from LED side!!!!!!!!");
 607                         }
 608                 }
 609
 610                 if (stIdleResponse.szData[1] == TARGET_CAN_GO_TO_IDLE_MODE) {
 611                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "ACKING IDLE MODE !!!!!!!!!");
 612                         down(&Adapter->rdmwrmsync);
 613                         Adapter->bPreparingForLowPowerMode = TRUE;
 614                         up(&Adapter->rdmwrmsync);
 615                         /* Killing all URBS. */
 616                         if (Adapter->bDoSuspend == TRUE)
 617                                 Bcm_kill_all_URBs((struct bcm_interface_adapter *)(Adapter->pvInterfaceAdapter));
 618                 } else {
 619                         Adapter->bPreparingForLowPowerMode = false;
 620                 }
 621
 622                 if (!NVMAccess)
 623                         up(&Adapter->NVMRdmWrmLock);
 624
 625                 if (!lowPwrAbortMsg)
 626                         up(&Adapter->LowPowerModeSync);
 627         }
 628
 629         status = CopyBufferToControlPacket(Adapter, &stIdleResponse);
 630         if (status != STATUS_SUCCESS) {
 631                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "fail to send the Idle mode Request\n");
 632                 Adapter->bPreparingForLowPowerMode = false;
 633                 StartInterruptUrb((struct bcm_interface_adapter *)(Adapter->pvInterfaceAdapter));
 634         }
 635         do_gettimeofday(&tv);
 636         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "IdleMode Msg submitter to Q :%ld ms", tv.tv_sec * 1000 + tv.tv_usec / 1000);
 637 }
 638
 639 /******************************************************************
 640 * Function    - DumpPackInfo()
 641 *
 642 * Description - This function dumps the all Queue(PackInfo[]) details.
 643 *
 644 * Parameters  - Adapter: Pointer to the Adapter structure.
 645 *
 646 * Returns     - None.
 647 *******************************************************************/
 648 void DumpPackInfo(struct bcm_mini_adapter *Adapter)
 649 {
 650         unsigned int uiLoopIndex = 0;
 651         unsigned int uiIndex = 0;
 652         unsigned int uiClsfrIndex = 0;
 653         struct bcm_classifier_rule *pstClassifierEntry = NULL;
 654
 655         for (uiLoopIndex = 0; uiLoopIndex < NO_OF_QUEUES; uiLoopIndex++) {
 656                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "*********** Showing Details Of Queue %d***** ******", uiLoopIndex);
 657                 if (false == Adapter->PackInfo[uiLoopIndex].bValid) {
 658                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bValid is false for %X index\n", uiLoopIndex);
 659                         continue;
 660                 }
 661
 662                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, " Dumping     SF Rule Entry For SFID %lX\n", Adapter->PackInfo[uiLoopIndex].ulSFID);
 663                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, " ucDirection %X\n", Adapter->PackInfo[uiLoopIndex].ucDirection);
 664
 665                 if (Adapter->PackInfo[uiLoopIndex].ucIpVersion == IPV6)
 666                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Ipv6 Service Flow\n");
 667                 else
 668                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Ipv4 Service Flow\n");
 669
 670                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "SF Traffic Priority %X\n", Adapter->PackInfo[uiLoopIndex].u8TrafficPriority);
 671
 672                 for (uiClsfrIndex = 0; uiClsfrIndex < MAX_CLASSIFIERS; uiClsfrIndex++) {
 673                         pstClassifierEntry = &Adapter->astClassifierTable[uiClsfrIndex];
 674                         if (!pstClassifierEntry->bUsed)
 675                                 continue;
 676
 677                         if (pstClassifierEntry->ulSFID != Adapter->PackInfo[uiLoopIndex].ulSFID)
 678                                 continue;
 679
 680                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tDumping Classifier Rule Entry For Index: %X Classifier Rule ID : %X\n", uiClsfrIndex, pstClassifierEntry->uiClassifierRuleIndex);
 681                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tDumping Classifier Rule Entry For Index: %X usVCID_Value : %X\n", uiClsfrIndex, pstClassifierEntry->usVCID_Value);
 682                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tDumping Classifier Rule Entry For Index: %X bProtocolValid : %X\n", uiClsfrIndex, pstClassifierEntry->bProtocolValid);
 683                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tDumping Classifier Rule Entry For Index: %X bTOSValid : %X\n", uiClsfrIndex, pstClassifierEntry->bTOSValid);
 684                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tDumping Classifier Rule Entry For Index: %X bDestIpValid : %X\n", uiClsfrIndex, pstClassifierEntry->bDestIpValid);
 685                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tDumping Classifier Rule Entry For Index: %X bSrcIpValid : %X\n", uiClsfrIndex, pstClassifierEntry->bSrcIpValid);
 686
 687                         for (uiIndex = 0; uiIndex < MAX_PORT_RANGE; uiIndex++) {
 688                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusSrcPortRangeLo:%X\n", pstClassifierEntry->usSrcPortRangeLo[uiIndex]);
 689                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusSrcPortRangeHi:%X\n", pstClassifierEntry->usSrcPortRangeHi[uiIndex]);
 690                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusDestPortRangeLo:%X\n", pstClassifierEntry->usDestPortRangeLo[uiIndex]);
 691                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusDestPortRangeHi:%X\n", pstClassifierEntry->usDestPortRangeHi[uiIndex]);
 692                         }
 693
 694                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tucIPSourceAddressLength : 0x%x\n", pstClassifierEntry->ucIPSourceAddressLength);
 695                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tucIPDestinationAddressLength : 0x%x\n", pstClassifierEntry->ucIPDestinationAddressLength);
 696                         for (uiIndex = 0; uiIndex < pstClassifierEntry->ucIPSourceAddressLength; uiIndex++) {
 697                                 if (Adapter->PackInfo[uiLoopIndex].ucIpVersion == IPV6) {
 698                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulSrcIpAddr :\n");
 699                                         DumpIpv6Address(pstClassifierEntry->stSrcIpAddress.ulIpv6Addr);
 700                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulSrcIpMask :\n");
 701                                         DumpIpv6Address(pstClassifierEntry->stSrcIpAddress.ulIpv6Mask);
 702                                 } else {
 703                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulSrcIpAddr:%lX\n", pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[uiIndex]);
 704                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulSrcIpMask:%lX\n", pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[uiIndex]);
 705                                 }
 706                         }
 707
 708                         for (uiIndex = 0; uiIndex < pstClassifierEntry->ucIPDestinationAddressLength; uiIndex++) {
 709                                 if (Adapter->PackInfo[uiLoopIndex].ucIpVersion == IPV6) {
 710                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulDestIpAddr :\n");
 711                                         DumpIpv6Address(pstClassifierEntry->stDestIpAddress.ulIpv6Addr);
 712                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulDestIpMask :\n");
 713                                         DumpIpv6Address(pstClassifierEntry->stDestIpAddress.ulIpv6Mask);
 714                                 } else {
 715                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulDestIpAddr:%lX\n", pstClassifierEntry->stDestIpAddress.ulIpv4Addr[uiIndex]);
 716                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulDestIpMask:%lX\n", pstClassifierEntry->stDestIpAddress.ulIpv4Mask[uiIndex]);
 717                                 }
 718                         }
 719                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tucProtocol:0x%X\n", pstClassifierEntry->ucProtocol[0]);
 720                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tu8ClassifierRulePriority:%X\n", pstClassifierEntry->u8ClassifierRulePriority);
 721                 }
 722                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ulSFID:%lX\n", Adapter->PackInfo[uiLoopIndex].ulSFID);
 723                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "usVCID_Value:%X\n", Adapter->PackInfo[uiLoopIndex].usVCID_Value);
 724                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "PhsEnabled: 0x%X\n", Adapter->PackInfo[uiLoopIndex].bHeaderSuppressionEnabled);
 725                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiThreshold:%X\n", Adapter->PackInfo[uiLoopIndex].uiThreshold);
 726
 727                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bValid:%X\n", Adapter->PackInfo[uiLoopIndex].bValid);
 728                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bActive:%X\n", Adapter->PackInfo[uiLoopIndex].bActive);
 729                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ActivateReqSent: %x", Adapter->PackInfo[uiLoopIndex].bActivateRequestSent);
 730                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "u8QueueType:%X\n", Adapter->PackInfo[uiLoopIndex].u8QueueType);
 731                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiMaxBucketSize:%X\n", Adapter->PackInfo[uiLoopIndex].uiMaxBucketSize);
 732                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiPerSFTxResourceCount:%X\n", atomic_read(&Adapter->PackInfo[uiLoopIndex].uiPerSFTxResourceCount));
 733                 /* DumpDebug(DUMP_INFO,("bCSSupport:%X\n",Adapter->PackInfo[uiLoopIndex].bCSSupport)); */
 734                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "CurrQueueDepthOnTarget: %x\n", Adapter->PackInfo[uiLoopIndex].uiCurrentQueueDepthOnTarget);
 735                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentBytesOnHost:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentBytesOnHost);
 736                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentPacketsOnHost:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentPacketsOnHost);
 737                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiDroppedCountBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiDroppedCountBytes);
 738                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiDroppedCountPackets:%X\n", Adapter->PackInfo[uiLoopIndex].uiDroppedCountPackets);
 739                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiSentBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiSentBytes);
 740                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiSentPackets:%X\n", Adapter->PackInfo[uiLoopIndex].uiSentPackets);
 741                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentDrainRate:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentDrainRate);
 742                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiThisPeriodSentBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiThisPeriodSentBytes);
 743                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "liDrainCalculated:%llX\n", Adapter->PackInfo[uiLoopIndex].liDrainCalculated);
 744                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentTokenCount:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentTokenCount);
 745                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "liLastUpdateTokenAt:%llX\n", Adapter->PackInfo[uiLoopIndex].liLastUpdateTokenAt);
 746                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiMaxAllowedRate:%X\n", Adapter->PackInfo[uiLoopIndex].uiMaxAllowedRate);
 747                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiPendedLast:%X\n", Adapter->PackInfo[uiLoopIndex].uiPendedLast);
 748                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "NumOfPacketsSent:%X\n", Adapter->PackInfo[uiLoopIndex].NumOfPacketsSent);
 749                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Direction: %x\n", Adapter->PackInfo[uiLoopIndex].ucDirection);
 750                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "CID: %x\n", Adapter->PackInfo[uiLoopIndex].usCID);
 751                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ProtocolValid: %x\n", Adapter->PackInfo[uiLoopIndex].bProtocolValid);
 752                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "TOSValid: %x\n", Adapter->PackInfo[uiLoopIndex].bTOSValid);
 753                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "DestIpValid: %x\n", Adapter->PackInfo[uiLoopIndex].bDestIpValid);
 754                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "SrcIpValid: %x\n", Adapter->PackInfo[uiLoopIndex].bSrcIpValid);
 755                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ActiveSet: %x\n", Adapter->PackInfo[uiLoopIndex].bActiveSet);
 756                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "AdmittedSet: %x\n", Adapter->PackInfo[uiLoopIndex].bAdmittedSet);
 757                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "AuthzSet: %x\n", Adapter->PackInfo[uiLoopIndex].bAuthorizedSet);
 758                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ClassifyPrority: %x\n", Adapter->PackInfo[uiLoopIndex].bClassifierPriority);
 759                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiMaxLatency: %x\n", Adapter->PackInfo[uiLoopIndex].uiMaxLatency);
 760                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO,
 761                                 DBG_LVL_ALL, "ServiceClassName: %*ph\n",
 762                                 4, Adapter->PackInfo[uiLoopIndex].
 763                                             ucServiceClassName);
 764 /* BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bHeaderSuppressionEnabled :%X\n", Adapter->PackInfo[uiLoopIndex].bHeaderSuppressionEnabled);
 765  * BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiTotalTxBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiTotalTxBytes);
 766  * BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiTotalRxBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiTotalRxBytes);
 767  *              DumpDebug(DUMP_INFO,("                          uiRanOutOfResCount:%X\n",Adapter->PackInfo[uiLoopIndex].uiRanOutOfResCount));
 768  */
 769         }
 770
 771         for (uiLoopIndex = 0; uiLoopIndex < MIBS_MAX_HIST_ENTRIES; uiLoopIndex++)
 772                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Adapter->aRxPktSizeHist[%x] = %x\n", uiLoopIndex, Adapter->aRxPktSizeHist[uiLoopIndex]);
 773
 774         for (uiLoopIndex = 0; uiLoopIndex < MIBS_MAX_HIST_ENTRIES; uiLoopIndex++)
 775                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Adapter->aTxPktSizeHist[%x] = %x\n", uiLoopIndex, Adapter->aTxPktSizeHist[uiLoopIndex]);
 776 }
 777
 778 int reset_card_proc(struct bcm_mini_adapter *ps_adapter)
 779 {
 780         int retval = STATUS_SUCCESS;
 781         struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
 782         struct bcm_interface_adapter *psIntfAdapter = NULL;
 783         unsigned int value = 0, uiResetValue = 0;
 784         int bytes;
 785
 786         psIntfAdapter = ((struct bcm_interface_adapter *)(ps_adapter->pvInterfaceAdapter));
 787         ps_adapter->bDDRInitDone = false;
 788
 789         if (ps_adapter->chip_id >= T3LPB) {
 790                 /* SYS_CFG register is write protected hence for modifying this reg value, it should be read twice before */
 791                 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
 792                 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
 793
 794                 /* making bit[6...5] same as was before f/w download. this setting force the h/w to */
 795                 /* re-populated the SP RAM area with the string descriptor. */
 796                 value = value | (ps_adapter->syscfgBefFwDld & 0x00000060);
 797                 wrmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
 798         }
 799
 800         /* killing all submitted URBs. */
 801         psIntfAdapter->psAdapter->StopAllXaction = TRUE;
 802         Bcm_kill_all_URBs(psIntfAdapter);
 803         /* Reset the UMA-B Device */
 804         if (ps_adapter->chip_id >= T3LPB) {
 805                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Resetting UMA-B\n");
 806                 retval = usb_reset_device(psIntfAdapter->udev);
 807                 psIntfAdapter->psAdapter->StopAllXaction = false;
 808
 809                 if (retval != STATUS_SUCCESS) {
 810                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reset failed with ret value :%d", retval);
 811                         goto err_exit;
 812                 }
 813
 814                 if (ps_adapter->chip_id == BCS220_2 ||
 815                         ps_adapter->chip_id == BCS220_2BC ||
 816                         ps_adapter->chip_id == BCS250_BC ||
 817                         ps_adapter->chip_id == BCS220_3) {
 818
 819                         bytes = rdmalt(ps_adapter, HPM_CONFIG_LDO145, &value, sizeof(value));
 820                         if (bytes < 0) {
 821                                 retval = bytes;
 822                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "read failed with status :%d", retval);
 823                                 goto err_exit;
 824                         }
 825                         /* setting 0th bit */
 826                         value |= (1<<0);
 827                         retval = wrmalt(ps_adapter, HPM_CONFIG_LDO145, &value, sizeof(value));
 828                         if (retval < 0) {
 829                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
 830                                 goto err_exit;
 831                         }
 832                 }
 833         } else {
 834                 bytes = rdmalt(ps_adapter, 0x0f007018, &value, sizeof(value));
 835                 if (bytes < 0) {
 836                         retval = bytes;
 837                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "read failed with status :%d", retval);
 838                         goto err_exit;
 839                 }
 840                 value &= (~(1<<16));
 841                 retval = wrmalt(ps_adapter, 0x0f007018, &value, sizeof(value));
 842                 if (retval < 0) {
 843                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
 844                         goto err_exit;
 845                 }
 846
 847                 /* Toggling the GPIO 8, 9 */
 848                 value = 0;
 849                 retval = wrmalt(ps_adapter, GPIO_OUTPUT_REGISTER, &value, sizeof(value));
 850                 if (retval < 0) {
 851                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
 852                         goto err_exit;
 853                 }
 854                 value = 0x300;
 855                 retval = wrmalt(ps_adapter, GPIO_MODE_REGISTER, &value, sizeof(value));
 856                 if (retval < 0) {
 857                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
 858                         goto err_exit;
 859                 }
 860                 mdelay(50);
 861         }
 862
 863         /* ps_adapter->downloadDDR = false; */
 864         if (ps_adapter->bFlashBoot) {
 865                 /* In flash boot mode MIPS state register has reverse polarity.
 866                  * So just or with setting bit 30.
 867                  * Make the MIPS in Reset state.
 868                  */
 869                 rdmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &uiResetValue, sizeof(uiResetValue));
 870                 uiResetValue |= (1<<30);
 871                 wrmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &uiResetValue, sizeof(uiResetValue));
 872         }
 873
 874         if (ps_adapter->chip_id >= T3LPB) {
 875                 uiResetValue = 0;
 876                 /*
 877                  * WA for SYSConfig Issue.
 878                  * Read SYSCFG Twice to make it writable.
 879                  */
 880                 rdmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue));
 881                 if (uiResetValue & (1<<4)) {
 882                         uiResetValue = 0;
 883                         rdmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue)); /* 2nd read to make it writable. */
 884                         uiResetValue &= (~(1<<4));
 885                         wrmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue));
 886                 }
 887         }
 888         uiResetValue = 0;
 889         wrmalt(ps_adapter, 0x0f01186c, &uiResetValue, sizeof(uiResetValue));
 890
 891 err_exit:
 892         psIntfAdapter->psAdapter->StopAllXaction = false;
 893         return retval;
 894 }
 895
 896 int run_card_proc(struct bcm_mini_adapter *ps_adapter)
 897 {
 898         int status = STATUS_SUCCESS;
 899         int bytes;
 900
 901         unsigned int value = 0;
 902         {
 903                 bytes = rdmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &value, sizeof(value));
 904                 if (bytes < 0) {
 905                         status = bytes;
 906                         BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "%s:%d\n", __func__, __LINE__);
 907                         return status;
 908                 }
 909
 910                 if (ps_adapter->bFlashBoot)
 911                         value &= (~(1<<30));
 912                 else
 913                         value |= (1<<30);
 914
 915                 if (wrmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &value, sizeof(value)) < 0) {
 916                         BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "%s:%d\n", __func__, __LINE__);
 917                         return STATUS_FAILURE;
 918                 }
 919         }
 920         return status;
 921 }
 922
 923 int InitCardAndDownloadFirmware(struct bcm_mini_adapter *ps_adapter)
 924 {
 925         int status;
 926         unsigned int value = 0;
 927         /*
 928          * Create the threads first and then download the
 929          * Firm/DDR Settings..
 930          */
 931         status = create_worker_threads(ps_adapter);
 932         if (status < 0)
 933                 return status;
 934
 935         status = bcm_parse_target_params(ps_adapter);
 936         if (status)
 937                 return status;
 938
 939         if (ps_adapter->chip_id >= T3LPB) {
 940                 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
 941                 ps_adapter->syscfgBefFwDld = value;
 942
 943                 if ((value & 0x60) == 0)
 944                         ps_adapter->bFlashBoot = TRUE;
 945         }
 946
 947         reset_card_proc(ps_adapter);
 948
 949         /* Initializing the NVM. */
 950         BcmInitNVM(ps_adapter);
 951         status = ddr_init(ps_adapter);
 952         if (status) {
 953                 pr_err(DRV_NAME "ddr_init Failed\n");
 954                 return status;
 955         }
 956
 957         /* Download cfg file */
 958         status = buffDnldVerify(ps_adapter,
 959                                 (PUCHAR)ps_adapter->pstargetparams,
 960                                 sizeof(struct bcm_target_params),
 961                                 CONFIG_BEGIN_ADDR);
 962         if (status) {
 963                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Error downloading CFG file");
 964                 goto OUT;
 965         }
 966
 967         if (register_networkdev(ps_adapter)) {
 968                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Register Netdevice failed. Cleanup needs to be performed.");
 969                 return -EIO;
 970         }
 971
 972         if (false == ps_adapter->AutoFirmDld) {
 973                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "AutoFirmDld Disabled in CFG File..\n");
 974                 /* If Auto f/w download is disable, register the control interface, */
 975                 /* register the control interface after the mailbox. */
 976                 if (register_control_device_interface(ps_adapter) < 0) {
 977                         BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Register Control Device failed. Cleanup needs to be performed.");
 978                         return -EIO;
 979                 }
 980                 return STATUS_SUCCESS;
 981         }
 982
 983         /*
 984          * Do the LED Settings here. It will be used by the Firmware Download
 985          * Thread.
 986          */
 987
 988         /*
 989          * 1. If the LED Settings fails, do not stop and do the Firmware download.
 990          * 2. This init would happened only if the cfg file is present, else
 991          *    call from the ioctl context.
 992          */
 993
 994         status = InitLedSettings(ps_adapter);
 995         if (status) {
 996                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_PRINTK, 0, 0, "INIT LED FAILED\n");
 997                 return status;
 998         }
 999
1000         if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1001                 ps_adapter->DriverState = DRIVER_INIT;
1002                 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1003         }
1004
1005         if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1006                 ps_adapter->DriverState = FW_DOWNLOAD;
1007                 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1008         }
1009
1010         value = 0;
1011         wrmalt(ps_adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4, &value, sizeof(value));
1012         wrmalt(ps_adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));
1013
1014         if (ps_adapter->eNVMType == NVM_FLASH) {
1015                 status = PropagateCalParamsFromFlashToMemory(ps_adapter);
1016                 if (status) {
1017                         BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Propagation of Cal param failed ..");
1018                         goto OUT;
1019                 }
1020         }
1021
1022         /* Download Firmare */
1023         status = BcmFileDownload(ps_adapter, BIN_FILE, FIRMWARE_BEGIN_ADDR);
1024         if (status != 0) {
1025                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "No Firmware File is present...\n");
1026                 goto OUT;
1027         }
1028
1029         status = run_card_proc(ps_adapter);
1030         if (status) {
1031                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "run_card_proc Failed\n");
1032                 goto OUT;
1033         }
1034
1035         ps_adapter->fw_download_done = TRUE;
1036         mdelay(10);
1037
1038 OUT:
1039         if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1040                 ps_adapter->DriverState = FW_DOWNLOAD_DONE;
1041                 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1042         }
1043
1044         return status;
1045 }
1046
1047 static int bcm_parse_target_params(struct bcm_mini_adapter *Adapter)
1048 {
1049         struct file *flp = NULL;
1050         char *buff;
1051         int len = 0;
1052
1053         buff = kmalloc(BUFFER_1K, GFP_KERNEL);
1054         if (!buff)
1055                 return -ENOMEM;
1056
1057         Adapter->pstargetparams = kmalloc(sizeof(struct bcm_target_params), GFP_KERNEL);
1058         if (Adapter->pstargetparams == NULL) {
1059                 kfree(buff);
1060                 return -ENOMEM;
1061         }
1062
1063         flp = open_firmware_file(Adapter, CFG_FILE);
1064         if (!flp) {
1065                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "NOT ABLE TO OPEN THE %s FILE\n", CFG_FILE);
1066                 kfree(buff);
1067                 kfree(Adapter->pstargetparams);
1068                 Adapter->pstargetparams = NULL;
1069                 return -ENOENT;
1070         }
1071         len = kernel_read(flp, 0, buff, BUFFER_1K);
1072         filp_close(flp, NULL);
1073
1074         if (len != sizeof(struct bcm_target_params)) {
1075                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Mismatch in Target Param Structure!\n");
1076                 kfree(buff);
1077                 kfree(Adapter->pstargetparams);
1078                 Adapter->pstargetparams = NULL;
1079                 return -ENOENT;
1080         }
1081
1082         /* Check for autolink in config params */
1083         /*
1084          * Values in Adapter->pstargetparams are in network byte order
1085          */
1086         memcpy(Adapter->pstargetparams, buff, sizeof(struct bcm_target_params));
1087         kfree(buff);
1088         beceem_parse_target_struct(Adapter);
1089         return STATUS_SUCCESS;
1090 }
1091
1092 void beceem_parse_target_struct(struct bcm_mini_adapter *Adapter)
1093 {
1094         unsigned int uiHostDrvrCfg6 = 0, uiEEPROMFlag = 0;
1095
1096         if (ntohl(Adapter->pstargetparams->m_u32PhyParameter2) & AUTO_SYNC_DISABLE) {
1097                 pr_info(DRV_NAME ": AutoSyncup is Disabled\n");
1098                 Adapter->AutoSyncup = false;
1099         } else {
1100                 pr_info(DRV_NAME ": AutoSyncup is Enabled\n");
1101                 Adapter->AutoSyncup = TRUE;
1102         }
1103
1104         if (ntohl(Adapter->pstargetparams->HostDrvrConfig6) & AUTO_LINKUP_ENABLE) {
1105                 pr_info(DRV_NAME ": Enabling autolink up");
1106                 Adapter->AutoLinkUp = TRUE;
1107         } else {
1108                 pr_info(DRV_NAME ": Disabling autolink up");
1109                 Adapter->AutoLinkUp = false;
1110         }
1111         /* Setting the DDR Setting.. */
1112         Adapter->DDRSetting = (ntohl(Adapter->pstargetparams->HostDrvrConfig6) >> 8)&0x0F;
1113         Adapter->ulPowerSaveMode = (ntohl(Adapter->pstargetparams->HostDrvrConfig6)>>12)&0x0F;
1114         pr_info(DRV_NAME ": DDR Setting: %x\n", Adapter->DDRSetting);
1115         pr_info(DRV_NAME ": Power Save Mode: %lx\n", Adapter->ulPowerSaveMode);
1116         if (ntohl(Adapter->pstargetparams->HostDrvrConfig6) & AUTO_FIRM_DOWNLOAD) {
1117                 pr_info(DRV_NAME ": Enabling Auto Firmware Download\n");
1118                 Adapter->AutoFirmDld = TRUE;
1119         } else {
1120                 pr_info(DRV_NAME ": Disabling Auto Firmware Download\n");
1121                 Adapter->AutoFirmDld = false;
1122         }
1123         uiHostDrvrCfg6 = ntohl(Adapter->pstargetparams->HostDrvrConfig6);
1124         Adapter->bMipsConfig = (uiHostDrvrCfg6>>20)&0x01;
1125         pr_info(DRV_NAME ": MIPSConfig   : 0x%X\n", Adapter->bMipsConfig);
1126         /* used for backward compatibility. */
1127         Adapter->bDPLLConfig = (uiHostDrvrCfg6>>19)&0x01;
1128         Adapter->PmuMode = (uiHostDrvrCfg6 >> 24) & 0x03;
1129         pr_info(DRV_NAME ": PMU MODE: %x", Adapter->PmuMode);
1130
1131         if ((uiHostDrvrCfg6 >> HOST_BUS_SUSPEND_BIT) & (0x01)) {
1132                 Adapter->bDoSuspend = TRUE;
1133                 pr_info(DRV_NAME ": Making DoSuspend TRUE as per configFile");
1134         }
1135
1136         uiEEPROMFlag = ntohl(Adapter->pstargetparams->m_u32EEPROMFlag);
1137         pr_info(DRV_NAME ": uiEEPROMFlag  : 0x%X\n", uiEEPROMFlag);
1138         Adapter->eNVMType = (enum bcm_nvm_type)((uiEEPROMFlag>>4)&0x3);
1139         Adapter->bStatusWrite = (uiEEPROMFlag>>6)&0x1;
1140         Adapter->uiSectorSizeInCFG = 1024*(0xFFFF & ntohl(Adapter->pstargetparams->HostDrvrConfig4));
1141         Adapter->bSectorSizeOverride = (bool) ((ntohl(Adapter->pstargetparams->HostDrvrConfig4))>>16)&0x1;
1142
1143         if (ntohl(Adapter->pstargetparams->m_u32PowerSavingModeOptions) & 0x01)
1144                 Adapter->ulPowerSaveMode = DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE;
1145
1146         if (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE)
1147                 doPowerAutoCorrection(Adapter);
1148 }
1149
1150 static void doPowerAutoCorrection(struct bcm_mini_adapter *psAdapter)
1151 {
1152         unsigned int reporting_mode;
1153
1154         reporting_mode = ntohl(psAdapter->pstargetparams->m_u32PowerSavingModeOptions) & 0x02;
1155         psAdapter->bIsAutoCorrectEnabled = !((char)(psAdapter->ulPowerSaveMode >> 3) & 0x1);
1156
1157         if (reporting_mode) {
1158                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "can't do suspen/resume as reporting mode is enable");
1159                 psAdapter->bDoSuspend = false;
1160         }
1161
1162         if (psAdapter->bIsAutoCorrectEnabled && (psAdapter->chip_id >= T3LPB)) {
1163                 /* If reporting mode is enable, switch PMU to PMC */
1164                 {
1165                         psAdapter->ulPowerSaveMode = DEVICE_POWERSAVE_MODE_AS_PMU_CLOCK_GATING;
1166                         psAdapter->bDoSuspend = false;
1167                 }
1168
1169                 /* clearing space bit[15..12] */
1170                 psAdapter->pstargetparams->HostDrvrConfig6 &= ~(htonl((0xF << 12)));
1171                 /* placing the power save mode option */
1172                 psAdapter->pstargetparams->HostDrvrConfig6 |= htonl((psAdapter->ulPowerSaveMode << 12));
1173         } else if (psAdapter->bIsAutoCorrectEnabled == false) {
1174                 /* remove the autocorrect disable bit set before dumping. */
1175                 psAdapter->ulPowerSaveMode &= ~(1 << 3);
1176                 psAdapter->pstargetparams->HostDrvrConfig6 &= ~(htonl(1 << 15));
1177                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Using Forced User Choice: %lx\n", psAdapter->ulPowerSaveMode);
1178         }
1179 }
1180
1181 static void convertEndian(unsigned char rwFlag, unsigned int *puiBuffer, unsigned int uiByteCount)
1182 {
1183         unsigned int uiIndex = 0;
1184
1185         if (RWM_WRITE == rwFlag) {
1186                 for (uiIndex = 0; uiIndex < (uiByteCount/sizeof(unsigned int)); uiIndex++)
1187                         puiBuffer[uiIndex] = htonl(puiBuffer[uiIndex]);
1188         } else {
1189                 for (uiIndex = 0; uiIndex < (uiByteCount/sizeof(unsigned int)); uiIndex++)
1190                         puiBuffer[uiIndex] = ntohl(puiBuffer[uiIndex]);
1191         }
1192 }
1193
1194 int rdm(struct bcm_mini_adapter *Adapter, unsigned int uiAddress, PCHAR pucBuff, size_t sSize)
1195 {
1196         return Adapter->interface_rdm(Adapter->pvInterfaceAdapter,
1197                                 uiAddress, pucBuff, sSize);
1198 }
1199
1200 int wrm(struct bcm_mini_adapter *Adapter, unsigned int uiAddress, PCHAR pucBuff, size_t sSize)
1201 {
1202         int iRetVal;
1203
1204         iRetVal = Adapter->interface_wrm(Adapter->pvInterfaceAdapter,
1205                                         uiAddress, pucBuff, sSize);
1206         return iRetVal;
1207 }
1208
1209 int wrmalt(struct bcm_mini_adapter *Adapter, unsigned int uiAddress, unsigned int *pucBuff, size_t size)
1210 {
1211         convertEndian(RWM_WRITE, pucBuff, size);
1212         return wrm(Adapter, uiAddress, (PUCHAR)pucBuff, size);
1213 }
1214
1215 int rdmalt(struct bcm_mini_adapter *Adapter, unsigned int uiAddress, unsigned int *pucBuff, size_t size)
1216 {
1217         int uiRetVal = 0;
1218
1219         uiRetVal = rdm(Adapter, uiAddress, (PUCHAR)pucBuff, size);
1220         convertEndian(RWM_READ, (unsigned int *)pucBuff, size);
1221
1222         return uiRetVal;
1223 }
1224
1225 int wrmWithLock(struct bcm_mini_adapter *Adapter, unsigned int uiAddress, PCHAR pucBuff, size_t sSize)
1226 {
1227         int status = STATUS_SUCCESS;
1228
1229         down(&Adapter->rdmwrmsync);
1230
1231         if ((Adapter->IdleMode == TRUE) ||
1232                 (Adapter->bShutStatus == TRUE) ||
1233                 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1234
1235                 status = -EACCES;
1236                 goto exit;
1237         }
1238
1239         status = wrm(Adapter, uiAddress, pucBuff, sSize);
1240 exit:
1241         up(&Adapter->rdmwrmsync);
1242         return status;
1243 }
1244
1245 int wrmaltWithLock(struct bcm_mini_adapter *Adapter, unsigned int uiAddress, unsigned int *pucBuff, size_t size)
1246 {
1247         int iRetVal = STATUS_SUCCESS;
1248
1249         down(&Adapter->rdmwrmsync);
1250
1251         if ((Adapter->IdleMode == TRUE) ||
1252                 (Adapter->bShutStatus == TRUE) ||
1253                 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1254
1255                 iRetVal = -EACCES;
1256                 goto exit;
1257         }
1258
1259         iRetVal = wrmalt(Adapter, uiAddress, pucBuff, size);
1260 exit:
1261         up(&Adapter->rdmwrmsync);
1262         return iRetVal;
1263 }
1264
1265 int rdmaltWithLock(struct bcm_mini_adapter *Adapter, unsigned int uiAddress, unsigned int *pucBuff, size_t size)
1266 {
1267         int uiRetVal = STATUS_SUCCESS;
1268
1269         down(&Adapter->rdmwrmsync);
1270         if ((Adapter->IdleMode == TRUE) ||
1271                 (Adapter->bShutStatus == TRUE) ||
1272                 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1273
1274                 uiRetVal = -EACCES;
1275                 goto exit;
1276         }
1277
1278         uiRetVal = rdmalt(Adapter, uiAddress, pucBuff, size);
1279 exit:
1280         up(&Adapter->rdmwrmsync);
1281         return uiRetVal;
1282 }
1283
1284 static void HandleShutDownModeWakeup(struct bcm_mini_adapter *Adapter)
1285 {
1286         int clear_abort_pattern = 0, Status = 0;
1287
1288         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "====>\n");
1289         /* target has woken up From Shut Down */
1290         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Clearing Shut Down Software abort pattern\n");
1291         Status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, (unsigned int *)&clear_abort_pattern, sizeof(clear_abort_pattern));
1292         if (Status) {
1293                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "WRM to SW_ABORT_IDLEMODE_LOC failed with err:%d", Status);
1294                 return;
1295         }
1296
1297         if (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE) {
1298                 msleep(100);
1299                 InterfaceHandleShutdownModeWakeup(Adapter);
1300                 msleep(100);
1301         }
1302
1303         if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1304                 Adapter->DriverState = NO_NETWORK_ENTRY;
1305                 wake_up(&Adapter->LEDInfo.notify_led_event);
1306         }
1307
1308         Adapter->bTriedToWakeUpFromlowPowerMode = false;
1309         Adapter->bShutStatus = false;
1310         wake_up(&Adapter->lowpower_mode_wait_queue);
1311         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "<====\n");
1312 }
1313
1314 static void SendShutModeResponse(struct bcm_mini_adapter *Adapter)
1315 {
1316         struct bcm_link_request stShutdownResponse;
1317         unsigned int NVMAccess = 0, lowPwrAbortMsg = 0;
1318         unsigned int Status = 0;
1319
1320         memset(&stShutdownResponse, 0, sizeof(struct bcm_link_request));
1321         stShutdownResponse.Leader.Status  = LINK_UP_CONTROL_REQ;
1322         stShutdownResponse.Leader.PLength = 8; /* 8 bytes; */
1323         stShutdownResponse.szData[0] = LINK_UP_ACK;
1324         stShutdownResponse.szData[1] = LINK_SHUTDOWN_REQ_FROM_FIRMWARE;
1325
1326         /*********************************
1327          * down_trylock -
1328          * if [ semaphore is available ]
1329          *               acquire semaphone and return value 0 ;
1330          *   else
1331          *               return non-zero value ;
1332          *
1333          ***********************************/
1334
1335         NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
1336         lowPwrAbortMsg = down_trylock(&Adapter->LowPowerModeSync);
1337
1338         if (NVMAccess || lowPwrAbortMsg || atomic_read(&Adapter->TotalPacketCount)) {
1339                 if (!NVMAccess)
1340                         up(&Adapter->NVMRdmWrmLock);
1341
1342                 if (!lowPwrAbortMsg)
1343                         up(&Adapter->LowPowerModeSync);
1344
1345                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Device Access is going on NACK the Shut Down MODE\n");
1346                 stShutdownResponse.szData[2] = SHUTDOWN_NACK_FROM_DRIVER; /* NACK- device access is going on. */
1347                 Adapter->bPreparingForLowPowerMode = false;
1348         } else {
1349                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Sending SHUTDOWN MODE ACK\n");
1350                 stShutdownResponse.szData[2] = SHUTDOWN_ACK_FROM_DRIVER; /* ShutDown ACK */
1351
1352                 /* Wait for the LED to TURN OFF before sending ACK response */
1353                 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1354                         int iRetVal = 0;
1355
1356                         /* Wake the LED Thread with LOWPOWER_MODE_ENTER State */
1357                         Adapter->DriverState = LOWPOWER_MODE_ENTER;
1358                         wake_up(&Adapter->LEDInfo.notify_led_event);
1359
1360                         /* Wait for 1 SEC for LED to OFF */
1361                         iRetVal = wait_event_timeout(Adapter->LEDInfo.idleModeSyncEvent, Adapter->LEDInfo.bIdle_led_off, msecs_to_jiffies(1000));
1362
1363                         /* If Timed Out to Sync IDLE MODE Enter, do IDLE mode Exit and Send NACK to device */
1364                         if (iRetVal <= 0) {
1365                                 stShutdownResponse.szData[1] = SHUTDOWN_NACK_FROM_DRIVER; /* NACK- device access is going on. */
1366                                 Adapter->DriverState = NO_NETWORK_ENTRY;
1367                                 wake_up(&Adapter->LEDInfo.notify_led_event);
1368                         }
1369                 }
1370
1371                 if (stShutdownResponse.szData[2] == SHUTDOWN_ACK_FROM_DRIVER) {
1372                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "ACKING SHUTDOWN MODE !!!!!!!!!");
1373                         down(&Adapter->rdmwrmsync);
1374                         Adapter->bPreparingForLowPowerMode = TRUE;
1375                         up(&Adapter->rdmwrmsync);
1376                         /* Killing all URBS. */
1377                         if (Adapter->bDoSuspend == TRUE)
1378                                 Bcm_kill_all_URBs((struct bcm_interface_adapter *)(Adapter->pvInterfaceAdapter));
1379                 } else {
1380                         Adapter->bPreparingForLowPowerMode = false;
1381                 }
1382
1383                 if (!NVMAccess)
1384                         up(&Adapter->NVMRdmWrmLock);
1385
1386                 if (!lowPwrAbortMsg)
1387                         up(&Adapter->LowPowerModeSync);
1388         }
1389
1390         Status = CopyBufferToControlPacket(Adapter, &stShutdownResponse);
1391         if (Status != STATUS_SUCCESS) {
1392                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "fail to send the Idle mode Request\n");
1393                 Adapter->bPreparingForLowPowerMode = false;
1394                 StartInterruptUrb((struct bcm_interface_adapter *)(Adapter->pvInterfaceAdapter));
1395         }
1396 }
1397
1398 static void HandleShutDownModeRequest(struct bcm_mini_adapter *Adapter, PUCHAR pucBuffer)
1399 {
1400         unsigned int uiResetValue = 0;
1401
1402         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "====>\n");
1403
1404         if (*(pucBuffer+1) ==  COMPLETE_WAKE_UP_NOTIFICATION_FRM_FW) {
1405                 HandleShutDownModeWakeup(Adapter);
1406         } else if (*(pucBuffer+1) ==  LINK_SHUTDOWN_REQ_FROM_FIRMWARE) {
1407                 /* Target wants to go to Shut Down Mode */
1408                 /* InterfacePrepareForShutdown(Adapter); */
1409                 if (Adapter->chip_id == BCS220_2 ||
1410                         Adapter->chip_id == BCS220_2BC ||
1411                         Adapter->chip_id == BCS250_BC ||
1412                         Adapter->chip_id == BCS220_3) {
1413
1414                         rdmalt(Adapter, HPM_CONFIG_MSW, &uiResetValue, 4);
1415                         uiResetValue |= (1<<17);
1416                         wrmalt(Adapter, HPM_CONFIG_MSW, &uiResetValue, 4);
1417                 }
1418
1419                 SendShutModeResponse(Adapter);
1420                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "ShutDownModeResponse:Notification received: Sending the response(Ack/Nack)\n");
1421         }
1422
1423         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "<====\n");
1424 }
1425
1426 void ResetCounters(struct bcm_mini_adapter *Adapter)
1427 {
1428         beceem_protocol_reset(Adapter);
1429         Adapter->CurrNumRecvDescs = 0;
1430         Adapter->PrevNumRecvDescs = 0;
1431         Adapter->LinkUpStatus = 0;
1432         Adapter->LinkStatus = 0;
1433         atomic_set(&Adapter->cntrlpktCnt, 0);
1434         atomic_set(&Adapter->TotalPacketCount, 0);
1435         Adapter->fw_download_done = false;
1436         Adapter->LinkStatus = 0;
1437         Adapter->AutoLinkUp = false;
1438         Adapter->IdleMode = false;
1439         Adapter->bShutStatus = false;
1440 }
1441
1442 struct bcm_classifier_rule *GetFragIPClsEntry(struct bcm_mini_adapter *Adapter, USHORT usIpIdentification, ULONG SrcIP)
1443 {
1444         unsigned int uiIndex = 0;
1445
1446         for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1447                 if ((Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) &&
1448                         (Adapter->astFragmentedPktClassifierTable[uiIndex].usIpIdentification == usIpIdentification) &&
1449                         (Adapter->astFragmentedPktClassifierTable[uiIndex].ulSrcIpAddress == SrcIP) &&
1450                         !Adapter->astFragmentedPktClassifierTable[uiIndex].bOutOfOrderFragment)
1451
1452                         return Adapter->astFragmentedPktClassifierTable[uiIndex].pstMatchedClassifierEntry;
1453         }
1454         return NULL;
1455 }
1456
1457 void AddFragIPClsEntry(struct bcm_mini_adapter *Adapter, struct bcm_fragmented_packet_info *psFragPktInfo)
1458 {
1459         unsigned int uiIndex = 0;
1460
1461         for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1462                 if (!Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) {
1463                         memcpy(&Adapter->astFragmentedPktClassifierTable[uiIndex], psFragPktInfo, sizeof(struct bcm_fragmented_packet_info));
1464                         break;
1465                 }
1466         }
1467 }
1468
1469 void DelFragIPClsEntry(struct bcm_mini_adapter *Adapter, USHORT usIpIdentification, ULONG SrcIp)
1470 {
1471         unsigned int uiIndex = 0;
1472
1473         for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1474                 if ((Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) &&
1475                         (Adapter->astFragmentedPktClassifierTable[uiIndex].usIpIdentification == usIpIdentification) &&
1476                         (Adapter->astFragmentedPktClassifierTable[uiIndex].ulSrcIpAddress == SrcIp))
1477
1478                         memset(&Adapter->astFragmentedPktClassifierTable[uiIndex], 0, sizeof(struct bcm_fragmented_packet_info));
1479         }
1480 }
1481
1482 void update_per_cid_rx(struct bcm_mini_adapter *Adapter)
1483 {
1484         unsigned int qindex = 0;
1485
1486         if ((jiffies - Adapter->liDrainCalculated) < XSECONDS)
1487                 return;
1488
1489         for (qindex = 0; qindex < HiPriority; qindex++) {
1490                 if (Adapter->PackInfo[qindex].ucDirection == 0) {
1491                         Adapter->PackInfo[qindex].uiCurrentRxRate =
1492                                 (Adapter->PackInfo[qindex].uiCurrentRxRate +
1493                                         Adapter->PackInfo[qindex].uiThisPeriodRxBytes) / 2;
1494
1495                         Adapter->PackInfo[qindex].uiThisPeriodRxBytes = 0;
1496                 } else {
1497                         Adapter->PackInfo[qindex].uiCurrentDrainRate =
1498                                 (Adapter->PackInfo[qindex].uiCurrentDrainRate +
1499                                         Adapter->PackInfo[qindex].uiThisPeriodSentBytes) / 2;
1500                         Adapter->PackInfo[qindex].uiThisPeriodSentBytes = 0;
1501                 }
1502         }
1503         Adapter->liDrainCalculated = jiffies;
1504 }
1505
1506 void update_per_sf_desc_cnts(struct bcm_mini_adapter *Adapter)
1507 {
1508         int iIndex = 0;
1509         u32 uibuff[MAX_TARGET_DSX_BUFFERS];
1510         int bytes;
1511
1512         if (!atomic_read(&Adapter->uiMBupdate))
1513                 return;
1514
1515         bytes = rdmaltWithLock(Adapter, TARGET_SFID_TXDESC_MAP_LOC, (unsigned int *)uibuff, sizeof(unsigned int) * MAX_TARGET_DSX_BUFFERS);
1516         if (bytes < 0) {
1517                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "rdm failed\n");
1518                 return;
1519         }
1520
1521         for (iIndex = 0; iIndex < HiPriority; iIndex++) {
1522                 if (Adapter->PackInfo[iIndex].bValid && Adapter->PackInfo[iIndex].ucDirection) {
1523                         if (Adapter->PackInfo[iIndex].usVCID_Value < MAX_TARGET_DSX_BUFFERS)
1524                                 atomic_set(&Adapter->PackInfo[iIndex].uiPerSFTxResourceCount, uibuff[Adapter->PackInfo[iIndex].usVCID_Value]);
1525                         else
1526                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Invalid VCID : %x\n", Adapter->PackInfo[iIndex].usVCID_Value);
1527                 }
1528         }
1529         atomic_set(&Adapter->uiMBupdate, false);
1530 }
1531
1532 void flush_queue(struct bcm_mini_adapter *Adapter, unsigned int iQIndex)
1533 {
1534         struct sk_buff *PacketToDrop = NULL;
1535         struct net_device_stats *netstats = &Adapter->dev->stats;
1536
1537         spin_lock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
1538
1539         while (Adapter->PackInfo[iQIndex].FirstTxQueue && atomic_read(&Adapter->TotalPacketCount)) {
1540                 PacketToDrop = Adapter->PackInfo[iQIndex].FirstTxQueue;
1541                 if (PacketToDrop && PacketToDrop->len) {
1542                         netstats->tx_dropped++;
1543                         DEQUEUEPACKET(Adapter->PackInfo[iQIndex].FirstTxQueue, Adapter->PackInfo[iQIndex].LastTxQueue);
1544                         Adapter->PackInfo[iQIndex].uiCurrentPacketsOnHost--;
1545                         Adapter->PackInfo[iQIndex].uiCurrentBytesOnHost -= PacketToDrop->len;
1546
1547                         /* Adding dropped statistics */
1548                         Adapter->PackInfo[iQIndex].uiDroppedCountBytes += PacketToDrop->len;
1549                         Adapter->PackInfo[iQIndex].uiDroppedCountPackets++;
1550                         dev_kfree_skb(PacketToDrop);
1551                         atomic_dec(&Adapter->TotalPacketCount);
1552                 }
1553         }
1554         spin_unlock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
1555 }
1556
1557 static void beceem_protocol_reset(struct bcm_mini_adapter *Adapter)
1558 {
1559         int i;
1560
1561         if (netif_msg_link(Adapter))
1562                 pr_notice(PFX "%s: protocol reset\n", Adapter->dev->name);
1563
1564         netif_carrier_off(Adapter->dev);
1565         netif_stop_queue(Adapter->dev);
1566
1567         Adapter->IdleMode = false;
1568         Adapter->LinkUpStatus = false;
1569         ClearTargetDSXBuffer(Adapter, 0, TRUE);
1570         /* Delete All Classifier Rules */
1571
1572         for (i = 0; i < HiPriority; i++)
1573                 DeleteAllClassifiersForSF(Adapter, i);
1574
1575         flush_all_queues(Adapter);
1576
1577         if (Adapter->TimerActive == TRUE)
1578                 Adapter->TimerActive = false;
1579
1580         memset(Adapter->astFragmentedPktClassifierTable, 0, sizeof(struct bcm_fragmented_packet_info) * MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES);
1581
1582         for (i = 0; i < HiPriority; i++) {
1583                 /* resetting only the first size (S_MIBS_SERVICEFLOW_TABLE) for the SF. */
1584                 /* It is same between MIBs and SF. */
1585                 memset(&Adapter->PackInfo[i].stMibsExtServiceFlowTable, 0, sizeof(struct bcm_mibs_parameters));
1586         }
1587 }