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