drivers/staging/bcm/Misc.c

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