drivers/staging/bcm/Misc.c

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