drivers/staging/bcm/Misc.c

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