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
 818         psIntfAdapter = ((PS_INTERFACE_ADAPTER)(ps_adapter->pvInterfaceAdapter));
 819         ps_adapter->bDDRInitDone = FALSE;
 820
 821         if (ps_adapter->chip_id >= T3LPB) {
 822                 /* SYS_CFG register is write protected hence for modifying this reg value, it should be read twice before */
 823                 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
 824                 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
 825
 826                 /* making bit[6...5] same as was before f/w download. this setting force the h/w to */
 827                 /* re-populated the SP RAM area with the string descriptor. */
 828                 value = value | (ps_adapter->syscfgBefFwDld & 0x00000060);
 829                 wrmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
 830         }
 831
 832         /* killing all submitted URBs. */
 833         psIntfAdapter->psAdapter->StopAllXaction = TRUE;
 834         Bcm_kill_all_URBs(psIntfAdapter);
 835         /* Reset the UMA-B Device */
 836         if (ps_adapter->chip_id >= T3LPB) {
 837                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reseting UMA-B\n");
 838                 retval = usb_reset_device(psIntfAdapter->udev);
 839                 psIntfAdapter->psAdapter->StopAllXaction = FALSE;
 840
 841                 if (retval != STATUS_SUCCESS) {
 842                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reset failed with ret value :%d", retval);
 843                         goto err_exit;
 844                 }
 845
 846                 if (ps_adapter->chip_id == BCS220_2 ||
 847                         ps_adapter->chip_id == BCS220_2BC ||
 848                         ps_adapter->chip_id == BCS250_BC ||
 849                         ps_adapter->chip_id == BCS220_3) {
 850
 851                         retval = rdmalt(ps_adapter, HPM_CONFIG_LDO145, &value, sizeof(value));
 852                         if (retval < 0) {
 853                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "read failed with status :%d", retval);
 854                                 goto err_exit;
 855                         }
 856                         /* setting 0th bit */
 857                         value |= (1<<0);
 858                         retval = wrmalt(ps_adapter, HPM_CONFIG_LDO145, &value, sizeof(value));
 859                         if (retval < 0) {
 860                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
 861                                 goto err_exit;
 862                         }
 863                 }
 864         } else {
 865                 retval = rdmalt(ps_adapter, 0x0f007018, &value, sizeof(value));
 866                 if (retval < 0) {
 867                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "read failed with status :%d", retval);
 868                         goto err_exit;
 869                 }
 870                 value &= (~(1<<16));
 871                 retval = wrmalt(ps_adapter, 0x0f007018, &value, sizeof(value));
 872                 if (retval < 0) {
 873                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
 874                         goto err_exit;
 875                 }
 876
 877                 /* Toggling the GPIO 8, 9 */
 878                 value = 0;
 879                 retval = wrmalt(ps_adapter, GPIO_OUTPUT_REGISTER, &value, sizeof(value));
 880                 if (retval < 0) {
 881                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
 882                         goto err_exit;
 883                 }
 884                 value = 0x300;
 885                 retval = wrmalt(ps_adapter, GPIO_MODE_REGISTER, &value, sizeof(value));
 886                 if (retval < 0) {
 887                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
 888                         goto err_exit;
 889                 }
 890                 mdelay(50);
 891         }
 892
 893         /* ps_adapter->downloadDDR = false; */
 894         if (ps_adapter->bFlashBoot) {
 895                 /* In flash boot mode MIPS state register has reverse polarity.
 896                  * So just or with setting bit 30.
 897                  * Make the MIPS in Reset state.
 898                  */
 899                 rdmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &uiResetValue, sizeof(uiResetValue));
 900                 uiResetValue |= (1<<30);
 901                 wrmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &uiResetValue, sizeof(uiResetValue));
 902         }
 903
 904         if (ps_adapter->chip_id >= T3LPB) {
 905                 uiResetValue = 0;
 906                 /*
 907                  * WA for SYSConfig Issue.
 908                  * Read SYSCFG Twice to make it writable.
 909                  */
 910                 rdmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue));
 911                 if (uiResetValue & (1<<4)) {
 912                         uiResetValue = 0;
 913                         rdmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue)); /* 2nd read to make it writable. */
 914                         uiResetValue &= (~(1<<4));
 915                         wrmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue));
 916                 }
 917         }
 918         uiResetValue = 0;
 919         wrmalt(ps_adapter, 0x0f01186c, &uiResetValue, sizeof(uiResetValue));
 920
 921 err_exit:
 922         psIntfAdapter->psAdapter->StopAllXaction = FALSE;
 923         return retval;
 924 }
 925
 926 int run_card_proc(PMINI_ADAPTER ps_adapter)
 927 {
 928         unsigned int value = 0;
 929         {
 930                 if (rdmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &value, sizeof(value)) < 0) {
 931                         BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "%s:%d\n", __func__, __LINE__);
 932                         return STATUS_FAILURE;
 933                 }
 934
 935                 if (ps_adapter->bFlashBoot)
 936                         value &= (~(1<<30));
 937                 else
 938                         value |= (1<<30);
 939
 940                 if (wrmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &value, sizeof(value)) < 0) {
 941                         BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "%s:%d\n", __func__, __LINE__);
 942                         return STATUS_FAILURE;
 943                 }
 944         }
 945         return STATUS_SUCCESS;
 946 }
 947
 948 int InitCardAndDownloadFirmware(PMINI_ADAPTER ps_adapter)
 949 {
 950         int status;
 951         UINT value = 0;
 952         /*
 953          * Create the threads first and then download the
 954          * Firm/DDR Settings..
 955          */
 956         status = create_worker_threads(ps_adapter);
 957         if (status < 0)
 958                 return status;
 959
 960         status = bcm_parse_target_params(ps_adapter);
 961         if (status)
 962                 return status;
 963
 964         if (ps_adapter->chip_id >= T3LPB) {
 965                 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
 966                 ps_adapter->syscfgBefFwDld = value;
 967
 968                 if ((value & 0x60) == 0)
 969                         ps_adapter->bFlashBoot = TRUE;
 970         }
 971
 972         reset_card_proc(ps_adapter);
 973
 974         /* Initializing the NVM. */
 975         BcmInitNVM(ps_adapter);
 976         status = ddr_init(ps_adapter);
 977         if (status) {
 978                 pr_err(DRV_NAME "ddr_init Failed\n");
 979                 return status;
 980         }
 981
 982         /* Download cfg file */
 983         status = buffDnldVerify(ps_adapter,
 984                                 (PUCHAR)ps_adapter->pstargetparams,
 985                                 sizeof(STARGETPARAMS),
 986                                 CONFIG_BEGIN_ADDR);
 987         if (status) {
 988                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Error downloading CFG file");
 989                 goto OUT;
 990         }
 991
 992         if (register_networkdev(ps_adapter)) {
 993                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Register Netdevice failed. Cleanup needs to be performed.");
 994                 return -EIO;
 995         }
 996
 997         if (FALSE == ps_adapter->AutoFirmDld) {
 998                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "AutoFirmDld Disabled in CFG File..\n");
 999                 /* If Auto f/w download is disable, register the control interface, */
1000                 /* register the control interface after the mailbox. */
1001                 if (register_control_device_interface(ps_adapter) < 0) {
1002                         BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Register Control Device failed. Cleanup needs to be performed.");
1003                         return -EIO;
1004                 }
1005                 return STATUS_SUCCESS;
1006         }
1007
1008         /*
1009          * Do the LED Settings here. It will be used by the Firmware Download
1010          * Thread.
1011          */
1012
1013         /*
1014          * 1. If the LED Settings fails, do not stop and do the Firmware download.
1015          * 2. This init would happened only if the cfg file is present, else
1016          *    call from the ioctl context.
1017          */
1018
1019         status = InitLedSettings(ps_adapter);
1020         if (status) {
1021                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_PRINTK, 0, 0, "INIT LED FAILED\n");
1022                 return status;
1023         }
1024
1025         if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1026                 ps_adapter->DriverState = DRIVER_INIT;
1027                 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1028         }
1029
1030         if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1031                 ps_adapter->DriverState = FW_DOWNLOAD;
1032                 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1033         }
1034
1035         value = 0;
1036         wrmalt(ps_adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4, &value, sizeof(value));
1037         wrmalt(ps_adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));
1038
1039         if (ps_adapter->eNVMType == NVM_FLASH) {
1040                 status = PropagateCalParamsFromFlashToMemory(ps_adapter);
1041                 if (status) {
1042                         BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Propagation of Cal param failed ..");
1043                         goto OUT;
1044                 }
1045         }
1046
1047         /* Download Firmare */
1048         status = BcmFileDownload(ps_adapter, BIN_FILE, FIRMWARE_BEGIN_ADDR);
1049         if (status != 0) {
1050                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "No Firmware File is present...\n");
1051                 goto OUT;
1052         }
1053
1054         status = run_card_proc(ps_adapter);
1055         if (status) {
1056                 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "run_card_proc Failed\n");
1057                 goto OUT;
1058         }
1059
1060         ps_adapter->fw_download_done = TRUE;
1061         mdelay(10);
1062
1063 OUT:
1064         if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1065                 ps_adapter->DriverState = FW_DOWNLOAD_DONE;
1066                 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1067         }
1068
1069         return status;
1070 }
1071
1072 static int bcm_parse_target_params(PMINI_ADAPTER Adapter)
1073 {
1074         struct file *flp = NULL;
1075         mm_segment_t oldfs = {0};
1076         char *buff;
1077         int len = 0;
1078         loff_t pos = 0;
1079
1080         buff = kmalloc(BUFFER_1K, GFP_KERNEL);
1081         if (!buff)
1082                 return -ENOMEM;
1083
1084         Adapter->pstargetparams = kmalloc(sizeof(STARGETPARAMS), GFP_KERNEL);
1085         if (Adapter->pstargetparams == NULL) {
1086                 kfree(buff);
1087                 return -ENOMEM;
1088         }
1089
1090         flp = open_firmware_file(Adapter, CFG_FILE);
1091         if (!flp) {
1092                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "NOT ABLE TO OPEN THE %s FILE\n", CFG_FILE);
1093                 kfree(buff);
1094                 kfree(Adapter->pstargetparams);
1095                 Adapter->pstargetparams = NULL;
1096                 return -ENOENT;
1097         }
1098         oldfs = get_fs();
1099         set_fs(get_ds());
1100         len = vfs_read(flp, (void __user __force *)buff, BUFFER_1K, &pos);
1101         set_fs(oldfs);
1102
1103         if (len != sizeof(STARGETPARAMS)) {
1104                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Mismatch in Target Param Structure!\n");
1105                 kfree(buff);
1106                 kfree(Adapter->pstargetparams);
1107                 Adapter->pstargetparams = NULL;
1108                 filp_close(flp, current->files);
1109                 return -ENOENT;
1110         }
1111         filp_close(flp, current->files);
1112
1113         /* Check for autolink in config params */
1114         /*
1115          * Values in Adapter->pstargetparams are in network byte order
1116          */
1117         memcpy(Adapter->pstargetparams, buff, sizeof(STARGETPARAMS));
1118         kfree(buff);
1119         beceem_parse_target_struct(Adapter);
1120         return STATUS_SUCCESS;
1121 }
1122
1123 void beceem_parse_target_struct(PMINI_ADAPTER Adapter)
1124 {
1125         UINT uiHostDrvrCfg6 = 0, uiEEPROMFlag = 0;
1126
1127         if (ntohl(Adapter->pstargetparams->m_u32PhyParameter2) & AUTO_SYNC_DISABLE) {
1128                 pr_info(DRV_NAME ": AutoSyncup is Disabled\n");
1129                 Adapter->AutoSyncup = FALSE;
1130         } else {
1131                 pr_info(DRV_NAME ": AutoSyncup is Enabled\n");
1132                 Adapter->AutoSyncup = TRUE;
1133         }
1134
1135         if (ntohl(Adapter->pstargetparams->HostDrvrConfig6) & AUTO_LINKUP_ENABLE) {
1136                 pr_info(DRV_NAME ": Enabling autolink up");
1137                 Adapter->AutoLinkUp = TRUE;
1138         } else {
1139                 pr_info(DRV_NAME ": Disabling autolink up");
1140                 Adapter->AutoLinkUp = FALSE;
1141         }
1142         /* Setting the DDR Setting.. */
1143         Adapter->DDRSetting = (ntohl(Adapter->pstargetparams->HostDrvrConfig6) >> 8)&0x0F;
1144         Adapter->ulPowerSaveMode = (ntohl(Adapter->pstargetparams->HostDrvrConfig6)>>12)&0x0F;
1145         pr_info(DRV_NAME ": DDR Setting: %x\n", Adapter->DDRSetting);
1146         pr_info(DRV_NAME ": Power Save Mode: %lx\n", Adapter->ulPowerSaveMode);
1147         if (ntohl(Adapter->pstargetparams->HostDrvrConfig6) & AUTO_FIRM_DOWNLOAD) {
1148                 pr_info(DRV_NAME ": Enabling Auto Firmware Download\n");
1149                 Adapter->AutoFirmDld = TRUE;
1150         } else {
1151                 pr_info(DRV_NAME ": Disabling Auto Firmware Download\n");
1152                 Adapter->AutoFirmDld = FALSE;
1153         }
1154         uiHostDrvrCfg6 = ntohl(Adapter->pstargetparams->HostDrvrConfig6);
1155         Adapter->bMipsConfig = (uiHostDrvrCfg6>>20)&0x01;
1156         pr_info(DRV_NAME ": MIPSConfig   : 0x%X\n", Adapter->bMipsConfig);
1157         /* used for backward compatibility. */
1158         Adapter->bDPLLConfig = (uiHostDrvrCfg6>>19)&0x01;
1159         Adapter->PmuMode = (uiHostDrvrCfg6 >> 24) & 0x03;
1160         pr_info(DRV_NAME ": PMU MODE: %x", Adapter->PmuMode);
1161
1162         if ((uiHostDrvrCfg6 >> HOST_BUS_SUSPEND_BIT) & (0x01)) {
1163                 Adapter->bDoSuspend = TRUE;
1164                 pr_info(DRV_NAME ": Making DoSuspend TRUE as per configFile");
1165         }
1166
1167         uiEEPROMFlag = ntohl(Adapter->pstargetparams->m_u32EEPROMFlag);
1168         pr_info(DRV_NAME ": uiEEPROMFlag  : 0x%X\n", uiEEPROMFlag);
1169         Adapter->eNVMType = (NVM_TYPE)((uiEEPROMFlag>>4)&0x3);
1170         Adapter->bStatusWrite = (uiEEPROMFlag>>6)&0x1;
1171         Adapter->uiSectorSizeInCFG = 1024*(0xFFFF & ntohl(Adapter->pstargetparams->HostDrvrConfig4));
1172         Adapter->bSectorSizeOverride = (bool) ((ntohl(Adapter->pstargetparams->HostDrvrConfig4))>>16)&0x1;
1173
1174         if (ntohl(Adapter->pstargetparams->m_u32PowerSavingModeOptions) & 0x01)
1175                 Adapter->ulPowerSaveMode = DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE;
1176
1177         if (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE)
1178                 doPowerAutoCorrection(Adapter);
1179 }
1180
1181 static VOID doPowerAutoCorrection(PMINI_ADAPTER psAdapter)
1182 {
1183         UINT reporting_mode;
1184
1185         reporting_mode = ntohl(psAdapter->pstargetparams->m_u32PowerSavingModeOptions) & 0x02;
1186         psAdapter->bIsAutoCorrectEnabled = !((char)(psAdapter->ulPowerSaveMode >> 3) & 0x1);
1187
1188         if (reporting_mode == TRUE) {
1189                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "can't do suspen/resume as reporting mode is enable");
1190                 psAdapter->bDoSuspend = FALSE;
1191         }
1192
1193         if (psAdapter->bIsAutoCorrectEnabled && (psAdapter->chip_id >= T3LPB)) {
1194                 /* If reporting mode is enable, switch PMU to PMC */
1195                 {
1196                         psAdapter->ulPowerSaveMode = DEVICE_POWERSAVE_MODE_AS_PMU_CLOCK_GATING;
1197                         psAdapter->bDoSuspend = FALSE;
1198                 }
1199
1200                 /* clearing space bit[15..12] */
1201                 psAdapter->pstargetparams->HostDrvrConfig6 &= ~(htonl((0xF << 12)));
1202                 /* placing the power save mode option */
1203                 psAdapter->pstargetparams->HostDrvrConfig6 |= htonl((psAdapter->ulPowerSaveMode << 12));
1204         } else if (psAdapter->bIsAutoCorrectEnabled == FALSE) {
1205                 /* remove the autocorrect disable bit set before dumping. */
1206                 psAdapter->ulPowerSaveMode &= ~(1 << 3);
1207                 psAdapter->pstargetparams->HostDrvrConfig6 &= ~(htonl(1 << 15));
1208                 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Using Forced User Choice: %lx\n", psAdapter->ulPowerSaveMode);
1209         }
1210 }
1211
1212 #if 0
1213 static unsigned char *ReadMacAddrEEPROM(PMINI_ADAPTER Adapter, ulong dwAddress)
1214 {
1215         int status = 0, i = 0;
1216         unsigned int temp = 0;
1217         unsigned char *pucmacaddr = kmalloc(MAC_ADDRESS_SIZE, GFP_KERNEL);
1218
1219         if (!pucmacaddr) {
1220                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "No Buffers to Read the EEPROM Address\n");
1221                 return NULL;
1222         }
1223
1224         dwAddress |= 0x5b000000;
1225         status = wrmalt(Adapter, EEPROM_COMMAND_Q_REG, (PUINT)&dwAddress, sizeof(UINT));
1226         if (status != STATUS_SUCCESS) {
1227                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "wrm Failed..\n");
1228                 kfree(pucmacaddr);
1229                 pucmacaddr = NULL;
1230                 goto OUT;
1231         }
1232
1233         for (i = 0; i < MAC_ADDRESS_SIZE; i++) {
1234                 status = rdmalt(Adapter, EEPROM_READ_DATA_Q_REG, &temp, sizeof(temp));
1235                 if (status != STATUS_SUCCESS) {
1236                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "rdm Failed..\n");
1237                         kfree(pucmacaddr);
1238                         pucmacaddr = NULL;
1239                         goto OUT;
1240                 }
1241                 pucmacaddr[i] = temp & 0xff;
1242                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "%x\n", pucmacaddr[i]);
1243         }
1244 OUT:
1245         return pucmacaddr;
1246 }
1247 #endif
1248
1249 static void convertEndian(B_UINT8 rwFlag, PUINT puiBuffer, UINT uiByteCount)
1250 {
1251         UINT uiIndex = 0;
1252
1253         if (RWM_WRITE == rwFlag) {
1254                 for (uiIndex = 0; uiIndex < (uiByteCount/sizeof(UINT)); uiIndex++)
1255                         puiBuffer[uiIndex] = htonl(puiBuffer[uiIndex]);
1256         } else {
1257                 for (uiIndex = 0; uiIndex < (uiByteCount/sizeof(UINT)); uiIndex++)
1258                         puiBuffer[uiIndex] = ntohl(puiBuffer[uiIndex]);
1259         }
1260 }
1261
1262 #define CACHE_ADDRESS_MASK 0x80000000
1263 #define UNCACHE_ADDRESS_MASK 0xa0000000
1264
1265 int rdm(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
1266 {
1267         return Adapter->interface_rdm(Adapter->pvInterfaceAdapter,
1268                                 uiAddress, pucBuff, sSize);
1269 }
1270
1271 int wrm(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
1272 {
1273         int iRetVal;
1274
1275         iRetVal = Adapter->interface_wrm(Adapter->pvInterfaceAdapter,
1276                                         uiAddress, pucBuff, sSize);
1277         return iRetVal;
1278 }
1279
1280 int wrmalt(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1281 {
1282         convertEndian(RWM_WRITE, pucBuff, size);
1283         return wrm(Adapter, uiAddress, (PUCHAR)pucBuff, size);
1284 }
1285
1286 int rdmalt(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1287 {
1288         INT uiRetVal = 0;
1289
1290         uiRetVal = rdm(Adapter, uiAddress, (PUCHAR)pucBuff, size);
1291         convertEndian(RWM_READ, (PUINT)pucBuff, size);
1292
1293         return uiRetVal;
1294 }
1295
1296 int wrmWithLock(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
1297 {
1298         INT status = STATUS_SUCCESS;
1299         down(&Adapter->rdmwrmsync);
1300
1301         if ((Adapter->IdleMode == TRUE) ||
1302                 (Adapter->bShutStatus == TRUE) ||
1303                 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1304
1305                 status = -EACCES;
1306                 goto exit;
1307         }
1308
1309         status = wrm(Adapter, uiAddress, pucBuff, sSize);
1310 exit:
1311         up(&Adapter->rdmwrmsync);
1312         return status;
1313 }
1314
1315 int wrmaltWithLock(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1316 {
1317         int iRetVal = STATUS_SUCCESS;
1318
1319         down(&Adapter->rdmwrmsync);
1320
1321         if ((Adapter->IdleMode == TRUE) ||
1322                 (Adapter->bShutStatus == TRUE) ||
1323                 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1324
1325                 iRetVal = -EACCES;
1326                 goto exit;
1327         }
1328
1329         iRetVal = wrmalt(Adapter, uiAddress, pucBuff, size);
1330 exit:
1331         up(&Adapter->rdmwrmsync);
1332         return iRetVal;
1333 }
1334
1335 int rdmaltWithLock(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1336 {
1337         INT uiRetVal = STATUS_SUCCESS;
1338
1339         down(&Adapter->rdmwrmsync);
1340         if ((Adapter->IdleMode == TRUE) ||
1341                 (Adapter->bShutStatus == TRUE) ||
1342                 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1343
1344                 uiRetVal = -EACCES;
1345                 goto exit;
1346         }
1347
1348         uiRetVal = rdmalt(Adapter, uiAddress, pucBuff, size);
1349 exit:
1350         up(&Adapter->rdmwrmsync);
1351         return uiRetVal;
1352 }
1353
1354 static VOID HandleShutDownModeWakeup(PMINI_ADAPTER Adapter)
1355 {
1356         int clear_abort_pattern = 0, Status = 0;
1357         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "====>\n");
1358         /* target has woken up From Shut Down */
1359         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Clearing Shut Down Software abort pattern\n");
1360         Status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, (PUINT)&clear_abort_pattern, sizeof(clear_abort_pattern));
1361         if (Status) {
1362                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "WRM to SW_ABORT_IDLEMODE_LOC failed with err:%d", Status);
1363                 return;
1364         }
1365
1366         if (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE) {
1367                 msleep(100);
1368                 InterfaceHandleShutdownModeWakeup(Adapter);
1369                 msleep(100);
1370         }
1371
1372         if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1373                 Adapter->DriverState = NO_NETWORK_ENTRY;
1374                 wake_up(&Adapter->LEDInfo.notify_led_event);
1375         }
1376
1377         Adapter->bTriedToWakeUpFromlowPowerMode = FALSE;
1378         Adapter->bShutStatus = FALSE;
1379         wake_up(&Adapter->lowpower_mode_wait_queue);
1380         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "<====\n");
1381 }
1382
1383 static VOID SendShutModeResponse(PMINI_ADAPTER Adapter)
1384 {
1385         CONTROL_MESSAGE stShutdownResponse;
1386         UINT NVMAccess = 0, lowPwrAbortMsg = 0;
1387         UINT Status = 0;
1388
1389         memset(&stShutdownResponse, 0, sizeof(CONTROL_MESSAGE));
1390         stShutdownResponse.Leader.Status  = LINK_UP_CONTROL_REQ;
1391         stShutdownResponse.Leader.PLength = 8; /* 8 bytes; */
1392         stShutdownResponse.szData[0] = LINK_UP_ACK;
1393         stShutdownResponse.szData[1] = LINK_SHUTDOWN_REQ_FROM_FIRMWARE;
1394
1395         /*********************************
1396          * down_trylock -
1397          * if [ semaphore is available ]
1398          *               acquire semaphone and return value 0 ;
1399          *   else
1400          *               return non-zero value ;
1401          *
1402          ***********************************/
1403
1404         NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
1405         lowPwrAbortMsg = down_trylock(&Adapter->LowPowerModeSync);
1406
1407         if (NVMAccess || lowPwrAbortMsg || atomic_read(&Adapter->TotalPacketCount)) {
1408                 if (!NVMAccess)
1409                         up(&Adapter->NVMRdmWrmLock);
1410
1411                 if (!lowPwrAbortMsg)
1412                         up(&Adapter->LowPowerModeSync);
1413
1414                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Device Access is going on NACK the Shut Down MODE\n");
1415                 stShutdownResponse.szData[2] = SHUTDOWN_NACK_FROM_DRIVER; /* NACK- device access is going on. */
1416                 Adapter->bPreparingForLowPowerMode = FALSE;
1417         } else {
1418                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Sending SHUTDOWN MODE ACK\n");
1419                 stShutdownResponse.szData[2] = SHUTDOWN_ACK_FROM_DRIVER; /* ShutDown ACK */
1420
1421                 /* Wait for the LED to TURN OFF before sending ACK response */
1422                 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1423                         INT iRetVal = 0;
1424
1425                         /* Wake the LED Thread with LOWPOWER_MODE_ENTER State */
1426                         Adapter->DriverState = LOWPOWER_MODE_ENTER;
1427                         wake_up(&Adapter->LEDInfo.notify_led_event);
1428
1429                         /* Wait for 1 SEC for LED to OFF */
1430                         iRetVal = wait_event_timeout(Adapter->LEDInfo.idleModeSyncEvent, Adapter->LEDInfo.bIdle_led_off, msecs_to_jiffies(1000));
1431
1432                         /* If Timed Out to Sync IDLE MODE Enter, do IDLE mode Exit and Send NACK to device */
1433                         if (iRetVal <= 0) {
1434                                 stShutdownResponse.szData[1] = SHUTDOWN_NACK_FROM_DRIVER; /* NACK- device access is going on. */
1435                                 Adapter->DriverState = NO_NETWORK_ENTRY;
1436                                 wake_up(&Adapter->LEDInfo.notify_led_event);
1437                         }
1438                 }
1439
1440                 if (stShutdownResponse.szData[2] == SHUTDOWN_ACK_FROM_DRIVER) {
1441                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "ACKING SHUTDOWN MODE !!!!!!!!!");
1442                         down(&Adapter->rdmwrmsync);
1443                         Adapter->bPreparingForLowPowerMode = TRUE;
1444                         up(&Adapter->rdmwrmsync);
1445                         /* Killing all URBS. */
1446                         if (Adapter->bDoSuspend == TRUE)
1447                                 Bcm_kill_all_URBs((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
1448                 } else {
1449                         Adapter->bPreparingForLowPowerMode = FALSE;
1450                 }
1451
1452                 if (!NVMAccess)
1453                         up(&Adapter->NVMRdmWrmLock);
1454
1455                 if (!lowPwrAbortMsg)
1456                         up(&Adapter->LowPowerModeSync);
1457         }
1458
1459         Status = CopyBufferToControlPacket(Adapter, &stShutdownResponse);
1460         if ((Status != STATUS_SUCCESS)) {
1461                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "fail to send the Idle mode Request\n");
1462                 Adapter->bPreparingForLowPowerMode = FALSE;
1463                 StartInterruptUrb((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
1464         }
1465 }
1466
1467 static void HandleShutDownModeRequest(PMINI_ADAPTER Adapter, PUCHAR pucBuffer)
1468 {
1469         B_UINT32 uiResetValue = 0;
1470
1471         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "====>\n");
1472
1473         if (*(pucBuffer+1) ==  COMPLETE_WAKE_UP_NOTIFICATION_FRM_FW) {
1474                 HandleShutDownModeWakeup(Adapter);
1475         } else if (*(pucBuffer+1) ==  LINK_SHUTDOWN_REQ_FROM_FIRMWARE) {
1476                 /* Target wants to go to Shut Down Mode */
1477                 /* InterfacePrepareForShutdown(Adapter); */
1478                 if (Adapter->chip_id == BCS220_2 ||
1479                         Adapter->chip_id == BCS220_2BC ||
1480                         Adapter->chip_id == BCS250_BC ||
1481                         Adapter->chip_id == BCS220_3) {
1482
1483                         rdmalt(Adapter, HPM_CONFIG_MSW, &uiResetValue, 4);
1484                         uiResetValue |= (1<<17);
1485                         wrmalt(Adapter, HPM_CONFIG_MSW, &uiResetValue, 4);
1486                 }
1487
1488                 SendShutModeResponse(Adapter);
1489                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "ShutDownModeResponse:Notification received: Sending the response(Ack/Nack)\n");
1490         }
1491
1492         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "<====\n");
1493         return;
1494 }
1495
1496 VOID ResetCounters(PMINI_ADAPTER Adapter)
1497 {
1498         beceem_protocol_reset(Adapter);
1499         Adapter->CurrNumRecvDescs = 0;
1500         Adapter->PrevNumRecvDescs = 0;
1501         Adapter->LinkUpStatus = 0;
1502         Adapter->LinkStatus = 0;
1503         atomic_set(&Adapter->cntrlpktCnt, 0);
1504         atomic_set(&Adapter->TotalPacketCount, 0);
1505         Adapter->fw_download_done = FALSE;
1506         Adapter->LinkStatus = 0;
1507         Adapter->AutoLinkUp = FALSE;
1508         Adapter->IdleMode = FALSE;
1509         Adapter->bShutStatus = FALSE;
1510 }
1511
1512 S_CLASSIFIER_RULE *GetFragIPClsEntry(PMINI_ADAPTER Adapter, USHORT usIpIdentification, ULONG SrcIP)
1513 {
1514         UINT uiIndex = 0;
1515         for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1516                 if ((Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) &&
1517                         (Adapter->astFragmentedPktClassifierTable[uiIndex].usIpIdentification == usIpIdentification) &&
1518                         (Adapter->astFragmentedPktClassifierTable[uiIndex].ulSrcIpAddress == SrcIP) &&
1519                         !Adapter->astFragmentedPktClassifierTable[uiIndex].bOutOfOrderFragment)
1520
1521                         return Adapter->astFragmentedPktClassifierTable[uiIndex].pstMatchedClassifierEntry;
1522         }
1523         return NULL;
1524 }
1525
1526 void AddFragIPClsEntry(PMINI_ADAPTER Adapter, PS_FRAGMENTED_PACKET_INFO psFragPktInfo)
1527 {
1528         UINT uiIndex = 0;
1529         for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1530                 if (!Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) {
1531                         memcpy(&Adapter->astFragmentedPktClassifierTable[uiIndex], psFragPktInfo, sizeof(S_FRAGMENTED_PACKET_INFO));
1532                         break;
1533                 }
1534         }
1535 }
1536
1537 void DelFragIPClsEntry(PMINI_ADAPTER Adapter, USHORT usIpIdentification, ULONG SrcIp)
1538 {
1539         UINT uiIndex = 0;
1540         for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1541                 if ((Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) &&
1542                         (Adapter->astFragmentedPktClassifierTable[uiIndex].usIpIdentification == usIpIdentification) &&
1543                         (Adapter->astFragmentedPktClassifierTable[uiIndex].ulSrcIpAddress == SrcIp))
1544
1545                         memset(&Adapter->astFragmentedPktClassifierTable[uiIndex], 0, sizeof(S_FRAGMENTED_PACKET_INFO));
1546         }
1547 }
1548
1549 void update_per_cid_rx(PMINI_ADAPTER Adapter)
1550 {
1551         UINT qindex = 0;
1552
1553         if ((jiffies - Adapter->liDrainCalculated) < XSECONDS)
1554                 return;
1555
1556         for (qindex = 0; qindex < HiPriority; qindex++) {
1557                 if (Adapter->PackInfo[qindex].ucDirection == 0) {
1558                         Adapter->PackInfo[qindex].uiCurrentRxRate =
1559                                 (Adapter->PackInfo[qindex].uiCurrentRxRate +
1560                                         Adapter->PackInfo[qindex].uiThisPeriodRxBytes) / 2;
1561
1562                         Adapter->PackInfo[qindex].uiThisPeriodRxBytes = 0;
1563                 } else {
1564                         Adapter->PackInfo[qindex].uiCurrentDrainRate =
1565                                 (Adapter->PackInfo[qindex].uiCurrentDrainRate +
1566                                         Adapter->PackInfo[qindex].uiThisPeriodSentBytes) / 2;
1567                         Adapter->PackInfo[qindex].uiThisPeriodSentBytes = 0;
1568                 }
1569         }
1570         Adapter->liDrainCalculated = jiffies;
1571 }
1572
1573 void update_per_sf_desc_cnts(PMINI_ADAPTER Adapter)
1574 {
1575         INT iIndex = 0;
1576         u32 uibuff[MAX_TARGET_DSX_BUFFERS];
1577
1578         if (!atomic_read(&Adapter->uiMBupdate))
1579                 return;
1580
1581         if (rdmaltWithLock(Adapter, TARGET_SFID_TXDESC_MAP_LOC, (PUINT)uibuff, sizeof(UINT) * MAX_TARGET_DSX_BUFFERS) < 0) {
1582                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "rdm failed\n");
1583                 return;
1584         }
1585
1586         for (iIndex = 0; iIndex < HiPriority; iIndex++) {
1587                 if (Adapter->PackInfo[iIndex].bValid && Adapter->PackInfo[iIndex].ucDirection) {
1588                         if (Adapter->PackInfo[iIndex].usVCID_Value < MAX_TARGET_DSX_BUFFERS)
1589                                 atomic_set(&Adapter->PackInfo[iIndex].uiPerSFTxResourceCount, uibuff[Adapter->PackInfo[iIndex].usVCID_Value]);
1590                         else
1591                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Invalid VCID : %x\n", Adapter->PackInfo[iIndex].usVCID_Value);
1592                 }
1593         }
1594         atomic_set(&Adapter->uiMBupdate, FALSE);
1595 }
1596
1597 void flush_queue(PMINI_ADAPTER Adapter, UINT iQIndex)
1598 {
1599         struct sk_buff *PacketToDrop = NULL;
1600         struct net_device_stats *netstats = &Adapter->dev->stats;
1601         spin_lock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
1602
1603         while (Adapter->PackInfo[iQIndex].FirstTxQueue && atomic_read(&Adapter->TotalPacketCount)) {
1604                 PacketToDrop = Adapter->PackInfo[iQIndex].FirstTxQueue;
1605                 if (PacketToDrop && PacketToDrop->len) {
1606                         netstats->tx_dropped++;
1607                         DEQUEUEPACKET(Adapter->PackInfo[iQIndex].FirstTxQueue, Adapter->PackInfo[iQIndex].LastTxQueue);
1608                         Adapter->PackInfo[iQIndex].uiCurrentPacketsOnHost--;
1609                         Adapter->PackInfo[iQIndex].uiCurrentBytesOnHost -= PacketToDrop->len;
1610
1611                         /* Adding dropped statistics */
1612                         Adapter->PackInfo[iQIndex].uiDroppedCountBytes += PacketToDrop->len;
1613                         Adapter->PackInfo[iQIndex].uiDroppedCountPackets++;
1614                         dev_kfree_skb(PacketToDrop);
1615                         atomic_dec(&Adapter->TotalPacketCount);
1616                 }
1617         }
1618         spin_unlock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
1619 }
1620
1621 static void beceem_protocol_reset(PMINI_ADAPTER Adapter)
1622 {
1623         int i;
1624         if (netif_msg_link(Adapter))
1625                 pr_notice(PFX "%s: protocol reset\n", Adapter->dev->name);
1626
1627         netif_carrier_off(Adapter->dev);
1628         netif_stop_queue(Adapter->dev);
1629
1630         Adapter->IdleMode = FALSE;
1631         Adapter->LinkUpStatus = FALSE;
1632         ClearTargetDSXBuffer(Adapter, 0, TRUE);
1633         /* Delete All Classifier Rules */
1634
1635         for (i = 0; i < HiPriority; i++)
1636                 DeleteAllClassifiersForSF(Adapter, i);
1637
1638         flush_all_queues(Adapter);
1639
1640         if (Adapter->TimerActive == TRUE)
1641                 Adapter->TimerActive = FALSE;
1642
1643         memset(Adapter->astFragmentedPktClassifierTable, 0, sizeof(S_FRAGMENTED_PACKET_INFO) * MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES);
1644
1645         for (i = 0; i < HiPriority; i++) {
1646                 /* resetting only the first size (S_MIBS_SERVICEFLOW_TABLE) for the SF. */
1647                 /* It is same between MIBs and SF. */
1648                 memset(&Adapter->PackInfo[i].stMibsExtServiceFlowTable, 0, sizeof(S_MIBS_EXTSERVICEFLOW_PARAMETERS));
1649         }
1650 }