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