drivers/staging/bcm/Misc.c

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