3 static int BcmFileDownload(struct bcm_mini_adapter *Adapter, const char *path, unsigned int loc);
4 static VOID doPowerAutoCorrection(struct bcm_mini_adapter *psAdapter);
5 static void HandleShutDownModeRequest(struct bcm_mini_adapter *Adapter, PUCHAR pucBuffer);
6 static int bcm_parse_target_params(struct bcm_mini_adapter *Adapter);
7 static void beceem_protocol_reset(struct bcm_mini_adapter *Adapter);
9 static VOID default_wimax_protocol_initialize(struct bcm_mini_adapter *Adapter)
13 for (uiLoopIndex = 0; uiLoopIndex < NO_OF_QUEUES-1; uiLoopIndex++) {
14 Adapter->PackInfo[uiLoopIndex].uiThreshold = TX_PACKET_THRESHOLD;
15 Adapter->PackInfo[uiLoopIndex].uiMaxAllowedRate = MAX_ALLOWED_RATE;
16 Adapter->PackInfo[uiLoopIndex].uiMaxBucketSize = 20*1024*1024;
19 Adapter->BEBucketSize = BE_BUCKET_SIZE;
20 Adapter->rtPSBucketSize = rtPS_BUCKET_SIZE;
21 Adapter->LinkStatus = SYNC_UP_REQUEST;
22 Adapter->TransferMode = IP_PACKET_ONLY_MODE;
23 Adapter->usBestEffortQueueIndex = -1;
27 INT InitAdapter(struct bcm_mini_adapter *psAdapter)
30 INT Status = STATUS_SUCCESS;
31 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Initialising Adapter = %p", psAdapter);
33 if (psAdapter == NULL) {
34 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Adapter is NULL");
38 sema_init(&psAdapter->NVMRdmWrmLock, 1);
39 sema_init(&psAdapter->rdmwrmsync, 1);
40 spin_lock_init(&psAdapter->control_queue_lock);
41 spin_lock_init(&psAdapter->txtransmitlock);
42 sema_init(&psAdapter->RxAppControlQueuelock, 1);
43 sema_init(&psAdapter->fw_download_sema, 1);
44 sema_init(&psAdapter->LowPowerModeSync, 1);
46 for (i = 0; i < NO_OF_QUEUES; i++)
47 spin_lock_init(&psAdapter->PackInfo[i].SFQueueLock);
50 init_waitqueue_head(&psAdapter->process_rx_cntrlpkt);
51 init_waitqueue_head(&psAdapter->tx_packet_wait_queue);
52 init_waitqueue_head(&psAdapter->process_read_wait_queue);
53 init_waitqueue_head(&psAdapter->ioctl_fw_dnld_wait_queue);
54 init_waitqueue_head(&psAdapter->lowpower_mode_wait_queue);
55 psAdapter->waiting_to_fw_download_done = TRUE;
56 psAdapter->fw_download_done = FALSE;
58 default_wimax_protocol_initialize(psAdapter);
59 for (i = 0; i < MAX_CNTRL_PKTS; i++) {
60 psAdapter->txctlpacket[i] = kmalloc(MAX_CNTL_PKT_SIZE, GFP_KERNEL);
61 if (!psAdapter->txctlpacket[i]) {
62 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "No More Cntl pkts got, max got is %d", i);
67 if (AllocAdapterDsxBuffer(psAdapter)) {
68 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Failed to allocate DSX buffers");
72 /* Initialize PHS interface */
73 if (phs_init(&psAdapter->stBCMPhsContext, psAdapter) != 0) {
74 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "%s:%s:%d:Error PHS Init Failed=====>\n", __FILE__, __func__, __LINE__);
78 Status = BcmAllocFlashCSStructure(psAdapter);
80 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Memory Allocation for Flash structure failed");
84 Status = vendorextnInit(psAdapter);
86 if (STATUS_SUCCESS != Status) {
87 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Vendor Init Failed");
91 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Adapter initialised");
93 return STATUS_SUCCESS;
96 VOID AdapterFree(struct bcm_mini_adapter *Adapter)
99 beceem_protocol_reset(Adapter);
100 vendorextnExit(Adapter);
102 if (Adapter->control_packet_handler && !IS_ERR(Adapter->control_packet_handler))
103 kthread_stop(Adapter->control_packet_handler);
105 if (Adapter->transmit_packet_thread && !IS_ERR(Adapter->transmit_packet_thread))
106 kthread_stop(Adapter->transmit_packet_thread);
108 wake_up(&Adapter->process_read_wait_queue);
110 if (Adapter->LEDInfo.led_thread_running & (BCM_LED_THREAD_RUNNING_ACTIVELY | BCM_LED_THREAD_RUNNING_INACTIVELY))
111 kthread_stop(Adapter->LEDInfo.led_cntrl_threadid);
113 unregister_networkdev(Adapter);
115 /* FIXME: use proper wait_event and refcounting */
116 while (atomic_read(&Adapter->ApplicationRunning)) {
117 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Waiting for Application to close.. %d\n", atomic_read(&Adapter->ApplicationRunning));
120 unregister_control_device_interface(Adapter);
121 kfree(Adapter->pstargetparams);
123 for (count = 0; count < MAX_CNTRL_PKTS; count++)
124 kfree(Adapter->txctlpacket[count]);
126 FreeAdapterDsxBuffer(Adapter);
127 kfree(Adapter->pvInterfaceAdapter);
129 /* Free the PHS Interface */
130 PhsCleanup(&Adapter->stBCMPhsContext);
132 BcmDeAllocFlashCSStructure(Adapter);
134 free_netdev(Adapter->dev);
137 static int create_worker_threads(struct bcm_mini_adapter *psAdapter)
139 /* Rx Control Packets Processing */
140 psAdapter->control_packet_handler = kthread_run((int (*)(void *))
141 control_packet_handler, psAdapter, "%s-rx", DRV_NAME);
142 if (IS_ERR(psAdapter->control_packet_handler)) {
143 pr_notice(DRV_NAME ": could not create control thread\n");
144 return PTR_ERR(psAdapter->control_packet_handler);
148 psAdapter->transmit_packet_thread = kthread_run((int (*)(void *))
149 tx_pkt_handler, psAdapter, "%s-tx", DRV_NAME);
150 if (IS_ERR(psAdapter->transmit_packet_thread)) {
151 pr_notice(DRV_NAME ": could not creat transmit thread\n");
152 kthread_stop(psAdapter->control_packet_handler);
153 return PTR_ERR(psAdapter->transmit_packet_thread);
158 static struct file *open_firmware_file(struct bcm_mini_adapter *Adapter, const char *path)
160 struct file *flp = NULL;
164 flp = filp_open(path, O_RDONLY, S_IRWXU);
167 pr_err(DRV_NAME "Unable To Open File %s, err %ld", path, PTR_ERR(flp));
171 if (Adapter->device_removed)
180 * Download Address on the chip
182 static int BcmFileDownload(struct bcm_mini_adapter *Adapter, const char *path, unsigned int loc)
185 struct file *flp = NULL;
187 struct timeval tv = {0};
189 flp = open_firmware_file(Adapter, path);
192 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Unable to Open %s\n", path);
195 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Opened file is = %s and length =0x%lx to be downloaded at =0x%x", path, (unsigned long)flp->f_dentry->d_inode->i_size, loc);
196 do_gettimeofday(&tv);
198 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "download start %lx", ((tv.tv_sec * 1000) + (tv.tv_usec / 1000)));
199 if (Adapter->bcm_file_download(Adapter->pvInterfaceAdapter, flp, loc)) {
200 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Failed to download the firmware with error %x!!!", -EIO);
206 vfs_llseek(flp, 0, 0);
208 if (Adapter->bcm_file_readback_from_chip(Adapter->pvInterfaceAdapter, flp, loc)) {
209 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Failed to read back firmware!");
217 if (flp && !(IS_ERR(flp)))
218 filp_close(flp, current->files);
225 * @ingroup ctrl_pkt_functions
226 * This function copies the contents of given buffer
227 * to the control packet and queues it for transmission.
228 * @note Do not acquire the spinock, as it it already acquired.
229 * @return SUCCESS/FAILURE.
232 * Control Packet Buffer
234 INT CopyBufferToControlPacket(struct bcm_mini_adapter *Adapter, PVOID ioBuffer)
236 struct bcm_leader *pLeader = NULL;
238 unsigned char *ctrl_buff = NULL;
240 struct bcm_link_request *pLinkReq = NULL;
241 PUCHAR pucAddIndication = NULL;
243 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "======>");
245 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Got Null Buffer\n");
249 pLinkReq = (struct bcm_link_request *)ioBuffer;
250 pLeader = (struct bcm_leader *)ioBuffer; /* ioBuffer Contains sw_Status and Payload */
252 if (Adapter->bShutStatus == TRUE &&
253 pLinkReq->szData[0] == LINK_DOWN_REQ_PAYLOAD &&
254 pLinkReq->szData[1] == LINK_SYNC_UP_SUBTYPE) {
256 /* Got sync down in SHUTDOWN..we could not process this. */
257 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "SYNC DOWN Request in Shut Down Mode..\n");
258 return STATUS_FAILURE;
261 if ((pLeader->Status == LINK_UP_CONTROL_REQ) &&
262 ((pLinkReq->szData[0] == LINK_UP_REQ_PAYLOAD &&
263 (pLinkReq->szData[1] == LINK_SYNC_UP_SUBTYPE)) || /* Sync Up Command */
264 pLinkReq->szData[0] == NETWORK_ENTRY_REQ_PAYLOAD)) /* Net Entry Command */ {
266 if (Adapter->LinkStatus > PHY_SYNC_ACHIVED) {
267 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "LinkStatus is Greater than PHY_SYN_ACHIEVED");
268 return STATUS_FAILURE;
271 if (TRUE == Adapter->bShutStatus) {
272 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "SYNC UP IN SHUTDOWN..Device WakeUp\n");
273 if (Adapter->bTriedToWakeUpFromlowPowerMode == FALSE) {
274 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Waking up for the First Time..\n");
275 Adapter->usIdleModePattern = ABORT_SHUTDOWN_MODE; /* change it to 1 for current support. */
276 Adapter->bWakeUpDevice = TRUE;
277 wake_up(&Adapter->process_rx_cntrlpkt);
278 Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue, !Adapter->bShutStatus, (5 * HZ));
280 if (Status == -ERESTARTSYS)
283 if (Adapter->bShutStatus) {
284 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Shutdown Mode Wake up Failed - No Wake Up Received\n");
285 return STATUS_FAILURE;
288 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Wakeup has been tried already...\n");
293 if (TRUE == Adapter->IdleMode) {
294 /* BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is in Idle mode ... hence\n"); */
295 if (pLeader->Status == LINK_UP_CONTROL_REQ || pLeader->Status == 0x80 ||
296 pLeader->Status == CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ) {
298 if ((pLeader->Status == LINK_UP_CONTROL_REQ) && (pLinkReq->szData[0] == LINK_DOWN_REQ_PAYLOAD)) {
299 if ((pLinkReq->szData[1] == LINK_SYNC_DOWN_SUBTYPE)) {
300 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Link Down Sent in Idle Mode\n");
301 Adapter->usIdleModePattern = ABORT_IDLE_SYNCDOWN; /* LINK DOWN sent in Idle Mode */
303 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "ABORT_IDLE_MODE pattern is being written\n");
304 Adapter->usIdleModePattern = ABORT_IDLE_REG;
307 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "ABORT_IDLE_MODE pattern is being written\n");
308 Adapter->usIdleModePattern = ABORT_IDLE_MODE;
311 /*Setting bIdleMode_tx_from_host to TRUE to indicate LED control thread to represent
312 * the wake up from idlemode is from host
314 /* Adapter->LEDInfo.bIdleMode_tx_from_host = TRUE; */
315 Adapter->bWakeUpDevice = TRUE;
316 wake_up(&Adapter->process_rx_cntrlpkt);
318 /* We should not send DREG message down while in idlemode. */
319 if (LINK_DOWN_REQ_PAYLOAD == pLinkReq->szData[0])
320 return STATUS_SUCCESS;
322 Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue, !Adapter->IdleMode, (5 * HZ));
324 if (Status == -ERESTARTSYS)
327 if (Adapter->IdleMode) {
328 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Idle Mode Wake up Failed - No Wake Up Received\n");
329 return STATUS_FAILURE;
332 return STATUS_SUCCESS;
336 /* The Driver has to send control messages with a particular VCID */
337 pLeader->Vcid = VCID_CONTROL_PACKET; /* VCID for control packet. */
339 /* Allocate skb for Control Packet */
340 pktlen = pLeader->PLength;
341 ctrl_buff = (char *)Adapter->txctlpacket[atomic_read(&Adapter->index_wr_txcntrlpkt)%MAX_CNTRL_PKTS];
343 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Control packet to be taken =%d and address is =%pincoming address is =%p and packet len=%x",
344 atomic_read(&Adapter->index_wr_txcntrlpkt), ctrl_buff, ioBuffer, pktlen);
347 if ((pLeader->Status == 0x80) ||
348 (pLeader->Status == CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ)) {
350 * Restructure the DSX message to handle Multiple classifier Support
351 * Write the Service Flow param Structures directly to the target
352 * and embed the pointers in the DSX messages sent to target.
354 /* Lets store the current length of the control packet we are transmitting */
355 pucAddIndication = (PUCHAR)ioBuffer + LEADER_SIZE;
356 pktlen = pLeader->PLength;
357 Status = StoreCmControlResponseMessage(Adapter, pucAddIndication, &pktlen);
359 ClearTargetDSXBuffer(Adapter, ((stLocalSFAddIndicationAlt *)pucAddIndication)->u16TID, FALSE);
360 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, " Error Restoring The DSX Control Packet. Dsx Buffers on Target may not be Setup Properly ");
361 return STATUS_FAILURE;
364 * update the leader to use the new length
365 * The length of the control packet is length of message being sent + Leader length
367 pLeader->PLength = pktlen;
371 if (pktlen + LEADER_SIZE > MAX_CNTL_PKT_SIZE)
374 memset(ctrl_buff, 0, pktlen+LEADER_SIZE);
375 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Copying the Control Packet Buffer with length=%d\n", pLeader->PLength);
376 *(struct bcm_leader *)ctrl_buff = *pLeader;
377 memcpy(ctrl_buff + LEADER_SIZE, ((PUCHAR)ioBuffer + LEADER_SIZE), pLeader->PLength);
378 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Enqueuing the Control Packet");
380 /* Update the statistics counters */
381 spin_lock_bh(&Adapter->PackInfo[HiPriority].SFQueueLock);
382 Adapter->PackInfo[HiPriority].uiCurrentBytesOnHost += pLeader->PLength;
383 Adapter->PackInfo[HiPriority].uiCurrentPacketsOnHost++;
384 atomic_inc(&Adapter->TotalPacketCount);
385 spin_unlock_bh(&Adapter->PackInfo[HiPriority].SFQueueLock);
386 Adapter->PackInfo[HiPriority].bValid = TRUE;
388 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "CurrBytesOnHost: %x bValid: %x",
389 Adapter->PackInfo[HiPriority].uiCurrentBytesOnHost,
390 Adapter->PackInfo[HiPriority].bValid);
391 Status = STATUS_SUCCESS;
392 /*Queue the packet for transmission */
393 atomic_inc(&Adapter->index_wr_txcntrlpkt);
394 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Calling transmit_packets");
395 atomic_set(&Adapter->TxPktAvail, 1);
396 wake_up(&Adapter->tx_packet_wait_queue);
399 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "mem allocation Failed");
401 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "<====");
405 /******************************************************************
406 * Function - LinkMessage()
408 * Description - This function builds the Sync-up and Link-up request
409 * packet messages depending on the device Link status.
411 * Parameters - Adapter: Pointer to the Adapter structure.
414 *******************************************************************/
415 VOID LinkMessage(struct bcm_mini_adapter *Adapter)
417 struct bcm_link_request *pstLinkRequest = NULL;
418 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "=====>");
419 if (Adapter->LinkStatus == SYNC_UP_REQUEST && Adapter->AutoSyncup) {
420 pstLinkRequest = kzalloc(sizeof(struct bcm_link_request), GFP_ATOMIC);
421 if (!pstLinkRequest) {
422 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Can not allocate memory for Link request!");
425 /* sync up request... */
426 Adapter->LinkStatus = WAIT_FOR_SYNC; /* current link status */
427 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Requesting For SyncUp...");
428 pstLinkRequest->szData[0] = LINK_UP_REQ_PAYLOAD;
429 pstLinkRequest->szData[1] = LINK_SYNC_UP_SUBTYPE;
430 pstLinkRequest->Leader.Status = LINK_UP_CONTROL_REQ;
431 pstLinkRequest->Leader.PLength = sizeof(ULONG);
432 Adapter->bSyncUpRequestSent = TRUE;
434 } else if (Adapter->LinkStatus == PHY_SYNC_ACHIVED && Adapter->AutoLinkUp) {
435 pstLinkRequest = kzalloc(sizeof(struct bcm_link_request), GFP_ATOMIC);
436 if (!pstLinkRequest) {
437 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Can not allocate memory for Link request!");
440 /* LINK_UP_REQUEST */
441 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Requesting For LinkUp...");
442 pstLinkRequest->szData[0] = LINK_UP_REQ_PAYLOAD;
443 pstLinkRequest->szData[1] = LINK_NET_ENTRY;
444 pstLinkRequest->Leader.Status = LINK_UP_CONTROL_REQ;
445 pstLinkRequest->Leader.PLength = sizeof(ULONG);
447 if (pstLinkRequest) {
448 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Calling CopyBufferToControlPacket");
449 CopyBufferToControlPacket(Adapter, pstLinkRequest);
450 kfree(pstLinkRequest);
452 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "LinkMessage <=====");
456 /**********************************************************************
457 * Function - StatisticsResponse()
459 * Description - This function handles the Statistics response packet.
461 * Parameters - Adapter : Pointer to the Adapter structure.
462 * - pvBuffer: Starting address of Statistic response data.
465 ************************************************************************/
466 VOID StatisticsResponse(struct bcm_mini_adapter *Adapter, PVOID pvBuffer)
468 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "%s====>", __func__);
469 Adapter->StatisticsPointer = ntohl(*(__be32 *)pvBuffer);
470 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Stats at %x", (UINT)Adapter->StatisticsPointer);
471 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "%s <====", __func__);
475 /**********************************************************************
476 * Function - LinkControlResponseMessage()
478 * Description - This function handles the Link response packets.
480 * Parameters - Adapter : Pointer to the Adapter structure.
481 * - pucBuffer: Starting address of Link response data.
484 ***********************************************************************/
485 VOID LinkControlResponseMessage(struct bcm_mini_adapter *Adapter, PUCHAR pucBuffer)
487 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "=====>");
489 if (*pucBuffer == LINK_UP_ACK) {
490 switch (*(pucBuffer+1)) {
491 case PHY_SYNC_ACHIVED: /* SYNCed UP */
492 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "PHY_SYNC_ACHIVED");
494 if (Adapter->LinkStatus == LINKUP_DONE)
495 beceem_protocol_reset(Adapter);
497 Adapter->usBestEffortQueueIndex = INVALID_QUEUE_INDEX;
498 Adapter->LinkStatus = PHY_SYNC_ACHIVED;
500 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
501 Adapter->DriverState = NO_NETWORK_ENTRY;
502 wake_up(&Adapter->LEDInfo.notify_led_event);
505 LinkMessage(Adapter);
509 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "LINKUP_DONE");
510 Adapter->LinkStatus = LINKUP_DONE;
511 Adapter->bPHSEnabled = *(pucBuffer+3);
512 Adapter->bETHCSEnabled = *(pucBuffer+4) & ETH_CS_MASK;
513 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "PHS Support Status Received In LinkUp Ack : %x\n", Adapter->bPHSEnabled);
515 if ((FALSE == Adapter->bShutStatus) && (FALSE == Adapter->IdleMode)) {
516 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
517 Adapter->DriverState = NORMAL_OPERATION;
518 wake_up(&Adapter->LEDInfo.notify_led_event);
521 LinkMessage(Adapter);
526 * Driver to ignore the DREG_RECEIVED
527 * WiMAX Application should handle this Message
529 /* Adapter->liTimeSinceLastNetEntry = 0; */
530 Adapter->LinkUpStatus = 0;
531 Adapter->LinkStatus = 0;
532 Adapter->usBestEffortQueueIndex = INVALID_QUEUE_INDEX;
533 Adapter->bTriedToWakeUpFromlowPowerMode = FALSE;
534 Adapter->IdleMode = FALSE;
535 beceem_protocol_reset(Adapter);
538 case LINK_SHUTDOWN_REQ_FROM_FIRMWARE:
539 case COMPLETE_WAKE_UP_NOTIFICATION_FRM_FW:
541 HandleShutDownModeRequest(Adapter, pucBuffer);
545 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "default case:LinkResponse %x", *(pucBuffer + 1));
548 } else if (SET_MAC_ADDRESS_RESPONSE == *pucBuffer) {
549 PUCHAR puMacAddr = (pucBuffer + 1);
550 Adapter->LinkStatus = SYNC_UP_REQUEST;
551 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "MAC address response, sending SYNC_UP");
552 LinkMessage(Adapter);
553 memcpy(Adapter->dev->dev_addr, puMacAddr, MAC_ADDRESS_SIZE);
555 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "%s <=====", __func__);
559 void SendIdleModeResponse(struct bcm_mini_adapter *Adapter)
561 INT status = 0, NVMAccess = 0, lowPwrAbortMsg = 0;
563 struct bcm_link_request stIdleResponse = {{0} };
564 memset(&tv, 0, sizeof(tv));
565 stIdleResponse.Leader.Status = IDLE_MESSAGE;
566 stIdleResponse.Leader.PLength = IDLE_MODE_PAYLOAD_LENGTH;
567 stIdleResponse.szData[0] = GO_TO_IDLE_MODE_PAYLOAD;
568 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, " ============>");
570 /*********************************
572 * if [ semaphore is available ]
573 * acquire semaphone and return value 0 ;
575 * return non-zero value ;
577 ***********************************/
579 NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
580 lowPwrAbortMsg = down_trylock(&Adapter->LowPowerModeSync);
583 if ((NVMAccess || lowPwrAbortMsg || atomic_read(&Adapter->TotalPacketCount)) &&
584 (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE)) {
587 up(&Adapter->NVMRdmWrmLock);
590 up(&Adapter->LowPowerModeSync);
592 stIdleResponse.szData[1] = TARGET_CAN_NOT_GO_TO_IDLE_MODE; /* NACK- device access is going on. */
593 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "HOST IS NACKING Idle mode To F/W!!!!!!!!");
594 Adapter->bPreparingForLowPowerMode = FALSE;
596 stIdleResponse.szData[1] = TARGET_CAN_GO_TO_IDLE_MODE; /* 2; Idle ACK */
597 Adapter->StatisticsPointer = 0;
599 /* Wait for the LED to TURN OFF before sending ACK response */
600 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
603 /* Wake the LED Thread with IDLEMODE_ENTER State */
604 Adapter->DriverState = LOWPOWER_MODE_ENTER;
605 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);
606 wake_up(&Adapter->LEDInfo.notify_led_event);
608 /* Wait for 1 SEC for LED to OFF */
609 iRetVal = wait_event_timeout(Adapter->LEDInfo.idleModeSyncEvent, Adapter->LEDInfo.bIdle_led_off, msecs_to_jiffies(1000));
611 /* If Timed Out to Sync IDLE MODE Enter, do IDLE mode Exit and Send NACK to device */
613 stIdleResponse.szData[1] = TARGET_CAN_NOT_GO_TO_IDLE_MODE; /* NACK- device access is going on. */
614 Adapter->DriverState = NORMAL_OPERATION;
615 wake_up(&Adapter->LEDInfo.notify_led_event);
616 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "NACKING Idle mode as time out happen from LED side!!!!!!!!");
620 if (stIdleResponse.szData[1] == TARGET_CAN_GO_TO_IDLE_MODE) {
621 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "ACKING IDLE MODE !!!!!!!!!");
622 down(&Adapter->rdmwrmsync);
623 Adapter->bPreparingForLowPowerMode = TRUE;
624 up(&Adapter->rdmwrmsync);
625 /* Killing all URBS. */
626 if (Adapter->bDoSuspend == TRUE)
627 Bcm_kill_all_URBs((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
629 Adapter->bPreparingForLowPowerMode = FALSE;
633 up(&Adapter->NVMRdmWrmLock);
636 up(&Adapter->LowPowerModeSync);
639 status = CopyBufferToControlPacket(Adapter, &stIdleResponse);
640 if ((status != STATUS_SUCCESS)) {
641 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "fail to send the Idle mode Request\n");
642 Adapter->bPreparingForLowPowerMode = FALSE;
643 StartInterruptUrb((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
645 do_gettimeofday(&tv);
646 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);
649 /******************************************************************
650 * Function - DumpPackInfo()
652 * Description - This function dumps the all Queue(PackInfo[]) details.
654 * Parameters - Adapter: Pointer to the Adapter structure.
657 *******************************************************************/
658 VOID DumpPackInfo(struct bcm_mini_adapter *Adapter)
660 UINT uiLoopIndex = 0;
662 UINT uiClsfrIndex = 0;
663 struct bcm_classifier_rule *pstClassifierEntry = NULL;
665 for (uiLoopIndex = 0; uiLoopIndex < NO_OF_QUEUES; uiLoopIndex++) {
666 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "*********** Showing Details Of Queue %d***** ******", uiLoopIndex);
667 if (FALSE == Adapter->PackInfo[uiLoopIndex].bValid) {
668 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bValid is FALSE for %X index\n", uiLoopIndex);
672 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, " Dumping SF Rule Entry For SFID %lX\n", Adapter->PackInfo[uiLoopIndex].ulSFID);
673 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, " ucDirection %X\n", Adapter->PackInfo[uiLoopIndex].ucDirection);
675 if (Adapter->PackInfo[uiLoopIndex].ucIpVersion == IPV6)
676 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Ipv6 Service Flow\n");
678 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Ipv4 Service Flow\n");
680 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "SF Traffic Priority %X\n", Adapter->PackInfo[uiLoopIndex].u8TrafficPriority);
682 for (uiClsfrIndex = 0; uiClsfrIndex < MAX_CLASSIFIERS; uiClsfrIndex++) {
683 pstClassifierEntry = &Adapter->astClassifierTable[uiClsfrIndex];
684 if (!pstClassifierEntry->bUsed)
687 if (pstClassifierEntry->ulSFID != Adapter->PackInfo[uiLoopIndex].ulSFID)
690 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);
691 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);
692 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);
693 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);
694 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);
695 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);
697 for (uiIndex = 0; uiIndex < MAX_PORT_RANGE; uiIndex++) {
698 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusSrcPortRangeLo:%X\n", pstClassifierEntry->usSrcPortRangeLo[uiIndex]);
699 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusSrcPortRangeHi:%X\n", pstClassifierEntry->usSrcPortRangeHi[uiIndex]);
700 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusDestPortRangeLo:%X\n", pstClassifierEntry->usDestPortRangeLo[uiIndex]);
701 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusDestPortRangeHi:%X\n", pstClassifierEntry->usDestPortRangeHi[uiIndex]);
704 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tucIPSourceAddressLength : 0x%x\n", pstClassifierEntry->ucIPSourceAddressLength);
705 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tucIPDestinationAddressLength : 0x%x\n", pstClassifierEntry->ucIPDestinationAddressLength);
706 for (uiIndex = 0; uiIndex < pstClassifierEntry->ucIPSourceAddressLength; uiIndex++) {
707 if (Adapter->PackInfo[uiLoopIndex].ucIpVersion == IPV6) {
708 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulSrcIpAddr :\n");
709 DumpIpv6Address(pstClassifierEntry->stSrcIpAddress.ulIpv6Addr);
710 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulSrcIpMask :\n");
711 DumpIpv6Address(pstClassifierEntry->stSrcIpAddress.ulIpv6Mask);
713 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulSrcIpAddr:%lX\n", pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[uiIndex]);
714 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulSrcIpMask:%lX\n", pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[uiIndex]);
718 for (uiIndex = 0; uiIndex < pstClassifierEntry->ucIPDestinationAddressLength; uiIndex++) {
719 if (Adapter->PackInfo[uiLoopIndex].ucIpVersion == IPV6) {
720 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulDestIpAddr :\n");
721 DumpIpv6Address(pstClassifierEntry->stDestIpAddress.ulIpv6Addr);
722 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulDestIpMask :\n");
723 DumpIpv6Address(pstClassifierEntry->stDestIpAddress.ulIpv6Mask);
725 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulDestIpAddr:%lX\n", pstClassifierEntry->stDestIpAddress.ulIpv4Addr[uiIndex]);
726 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulDestIpMask:%lX\n", pstClassifierEntry->stDestIpAddress.ulIpv4Mask[uiIndex]);
729 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tucProtocol:0x%X\n", pstClassifierEntry->ucProtocol[0]);
730 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tu8ClassifierRulePriority:%X\n", pstClassifierEntry->u8ClassifierRulePriority);
732 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ulSFID:%lX\n", Adapter->PackInfo[uiLoopIndex].ulSFID);
733 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "usVCID_Value:%X\n", Adapter->PackInfo[uiLoopIndex].usVCID_Value);
734 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "PhsEnabled: 0x%X\n", Adapter->PackInfo[uiLoopIndex].bHeaderSuppressionEnabled);
735 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiThreshold:%X\n", Adapter->PackInfo[uiLoopIndex].uiThreshold);
737 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bValid:%X\n", Adapter->PackInfo[uiLoopIndex].bValid);
738 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bActive:%X\n", Adapter->PackInfo[uiLoopIndex].bActive);
739 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ActivateReqSent: %x", Adapter->PackInfo[uiLoopIndex].bActivateRequestSent);
740 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "u8QueueType:%X\n", Adapter->PackInfo[uiLoopIndex].u8QueueType);
741 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiMaxBucketSize:%X\n", Adapter->PackInfo[uiLoopIndex].uiMaxBucketSize);
742 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiPerSFTxResourceCount:%X\n", atomic_read(&Adapter->PackInfo[uiLoopIndex].uiPerSFTxResourceCount));
743 /* DumpDebug(DUMP_INFO,("bCSSupport:%X\n",Adapter->PackInfo[uiLoopIndex].bCSSupport)); */
744 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "CurrQueueDepthOnTarget: %x\n", Adapter->PackInfo[uiLoopIndex].uiCurrentQueueDepthOnTarget);
745 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentBytesOnHost:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentBytesOnHost);
746 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentPacketsOnHost:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentPacketsOnHost);
747 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiDroppedCountBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiDroppedCountBytes);
748 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiDroppedCountPackets:%X\n", Adapter->PackInfo[uiLoopIndex].uiDroppedCountPackets);
749 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiSentBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiSentBytes);
750 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiSentPackets:%X\n", Adapter->PackInfo[uiLoopIndex].uiSentPackets);
751 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentDrainRate:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentDrainRate);
752 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiThisPeriodSentBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiThisPeriodSentBytes);
753 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "liDrainCalculated:%llX\n", Adapter->PackInfo[uiLoopIndex].liDrainCalculated);
754 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentTokenCount:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentTokenCount);
755 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "liLastUpdateTokenAt:%llX\n", Adapter->PackInfo[uiLoopIndex].liLastUpdateTokenAt);
756 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiMaxAllowedRate:%X\n", Adapter->PackInfo[uiLoopIndex].uiMaxAllowedRate);
757 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiPendedLast:%X\n", Adapter->PackInfo[uiLoopIndex].uiPendedLast);
758 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "NumOfPacketsSent:%X\n", Adapter->PackInfo[uiLoopIndex].NumOfPacketsSent);
759 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Direction: %x\n", Adapter->PackInfo[uiLoopIndex].ucDirection);
760 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "CID: %x\n", Adapter->PackInfo[uiLoopIndex].usCID);
761 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ProtocolValid: %x\n", Adapter->PackInfo[uiLoopIndex].bProtocolValid);
762 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "TOSValid: %x\n", Adapter->PackInfo[uiLoopIndex].bTOSValid);
763 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "DestIpValid: %x\n", Adapter->PackInfo[uiLoopIndex].bDestIpValid);
764 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "SrcIpValid: %x\n", Adapter->PackInfo[uiLoopIndex].bSrcIpValid);
765 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ActiveSet: %x\n", Adapter->PackInfo[uiLoopIndex].bActiveSet);
766 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "AdmittedSet: %x\n", Adapter->PackInfo[uiLoopIndex].bAdmittedSet);
767 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "AuthzSet: %x\n", Adapter->PackInfo[uiLoopIndex].bAuthorizedSet);
768 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ClassifyPrority: %x\n", Adapter->PackInfo[uiLoopIndex].bClassifierPriority);
769 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiMaxLatency: %x\n", Adapter->PackInfo[uiLoopIndex].uiMaxLatency);
770 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]);
771 /* BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bHeaderSuppressionEnabled :%X\n", Adapter->PackInfo[uiLoopIndex].bHeaderSuppressionEnabled);
772 * BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiTotalTxBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiTotalTxBytes);
773 * BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiTotalRxBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiTotalRxBytes);
774 * DumpDebug(DUMP_INFO,(" uiRanOutOfResCount:%X\n",Adapter->PackInfo[uiLoopIndex].uiRanOutOfResCount));
778 for (uiLoopIndex = 0; uiLoopIndex < MIBS_MAX_HIST_ENTRIES; uiLoopIndex++)
779 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Adapter->aRxPktSizeHist[%x] = %x\n", uiLoopIndex, Adapter->aRxPktSizeHist[uiLoopIndex]);
781 for (uiLoopIndex = 0; uiLoopIndex < MIBS_MAX_HIST_ENTRIES; uiLoopIndex++)
782 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Adapter->aTxPktSizeHist[%x] = %x\n", uiLoopIndex, Adapter->aTxPktSizeHist[uiLoopIndex]);
787 int reset_card_proc(struct bcm_mini_adapter *ps_adapter)
789 int retval = STATUS_SUCCESS;
790 struct bcm_mini_adapter *Adapter = GET_BCM_ADAPTER(gblpnetdev);
791 PS_INTERFACE_ADAPTER psIntfAdapter = NULL;
792 unsigned int value = 0, uiResetValue = 0;
795 psIntfAdapter = ((PS_INTERFACE_ADAPTER)(ps_adapter->pvInterfaceAdapter));
796 ps_adapter->bDDRInitDone = FALSE;
798 if (ps_adapter->chip_id >= T3LPB) {
799 /* SYS_CFG register is write protected hence for modifying this reg value, it should be read twice before */
800 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
801 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
803 /* making bit[6...5] same as was before f/w download. this setting force the h/w to */
804 /* re-populated the SP RAM area with the string descriptor. */
805 value = value | (ps_adapter->syscfgBefFwDld & 0x00000060);
806 wrmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
809 /* killing all submitted URBs. */
810 psIntfAdapter->psAdapter->StopAllXaction = TRUE;
811 Bcm_kill_all_URBs(psIntfAdapter);
812 /* Reset the UMA-B Device */
813 if (ps_adapter->chip_id >= T3LPB) {
814 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Resetting UMA-B\n");
815 retval = usb_reset_device(psIntfAdapter->udev);
816 psIntfAdapter->psAdapter->StopAllXaction = FALSE;
818 if (retval != STATUS_SUCCESS) {
819 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reset failed with ret value :%d", retval);
823 if (ps_adapter->chip_id == BCS220_2 ||
824 ps_adapter->chip_id == BCS220_2BC ||
825 ps_adapter->chip_id == BCS250_BC ||
826 ps_adapter->chip_id == BCS220_3) {
828 bytes = rdmalt(ps_adapter, HPM_CONFIG_LDO145, &value, sizeof(value));
831 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "read failed with status :%d", retval);
834 /* setting 0th bit */
836 retval = wrmalt(ps_adapter, HPM_CONFIG_LDO145, &value, sizeof(value));
838 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
843 bytes = rdmalt(ps_adapter, 0x0f007018, &value, sizeof(value));
846 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "read failed with status :%d", retval);
850 retval = wrmalt(ps_adapter, 0x0f007018, &value, sizeof(value));
852 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
856 /* Toggling the GPIO 8, 9 */
858 retval = wrmalt(ps_adapter, GPIO_OUTPUT_REGISTER, &value, sizeof(value));
860 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
864 retval = wrmalt(ps_adapter, GPIO_MODE_REGISTER, &value, sizeof(value));
866 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
872 /* ps_adapter->downloadDDR = false; */
873 if (ps_adapter->bFlashBoot) {
874 /* In flash boot mode MIPS state register has reverse polarity.
875 * So just or with setting bit 30.
876 * Make the MIPS in Reset state.
878 rdmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &uiResetValue, sizeof(uiResetValue));
879 uiResetValue |= (1<<30);
880 wrmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &uiResetValue, sizeof(uiResetValue));
883 if (ps_adapter->chip_id >= T3LPB) {
886 * WA for SYSConfig Issue.
887 * Read SYSCFG Twice to make it writable.
889 rdmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue));
890 if (uiResetValue & (1<<4)) {
892 rdmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue)); /* 2nd read to make it writable. */
893 uiResetValue &= (~(1<<4));
894 wrmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue));
898 wrmalt(ps_adapter, 0x0f01186c, &uiResetValue, sizeof(uiResetValue));
901 psIntfAdapter->psAdapter->StopAllXaction = FALSE;
905 int run_card_proc(struct bcm_mini_adapter *ps_adapter)
907 int status = STATUS_SUCCESS;
910 unsigned int value = 0;
912 bytes = rdmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &value, sizeof(value));
915 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "%s:%d\n", __func__, __LINE__);
919 if (ps_adapter->bFlashBoot)
924 if (wrmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &value, sizeof(value)) < 0) {
925 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "%s:%d\n", __func__, __LINE__);
926 return STATUS_FAILURE;
932 int InitCardAndDownloadFirmware(struct bcm_mini_adapter *ps_adapter)
937 * Create the threads first and then download the
938 * Firm/DDR Settings..
940 status = create_worker_threads(ps_adapter);
944 status = bcm_parse_target_params(ps_adapter);
948 if (ps_adapter->chip_id >= T3LPB) {
949 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
950 ps_adapter->syscfgBefFwDld = value;
952 if ((value & 0x60) == 0)
953 ps_adapter->bFlashBoot = TRUE;
956 reset_card_proc(ps_adapter);
958 /* Initializing the NVM. */
959 BcmInitNVM(ps_adapter);
960 status = ddr_init(ps_adapter);
962 pr_err(DRV_NAME "ddr_init Failed\n");
966 /* Download cfg file */
967 status = buffDnldVerify(ps_adapter,
968 (PUCHAR)ps_adapter->pstargetparams,
969 sizeof(STARGETPARAMS),
972 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Error downloading CFG file");
976 if (register_networkdev(ps_adapter)) {
977 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Register Netdevice failed. Cleanup needs to be performed.");
981 if (FALSE == ps_adapter->AutoFirmDld) {
982 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "AutoFirmDld Disabled in CFG File..\n");
983 /* If Auto f/w download is disable, register the control interface, */
984 /* register the control interface after the mailbox. */
985 if (register_control_device_interface(ps_adapter) < 0) {
986 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Register Control Device failed. Cleanup needs to be performed.");
989 return STATUS_SUCCESS;
993 * Do the LED Settings here. It will be used by the Firmware Download
998 * 1. If the LED Settings fails, do not stop and do the Firmware download.
999 * 2. This init would happened only if the cfg file is present, else
1000 * call from the ioctl context.
1003 status = InitLedSettings(ps_adapter);
1005 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_PRINTK, 0, 0, "INIT LED FAILED\n");
1009 if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1010 ps_adapter->DriverState = DRIVER_INIT;
1011 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1014 if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1015 ps_adapter->DriverState = FW_DOWNLOAD;
1016 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1020 wrmalt(ps_adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4, &value, sizeof(value));
1021 wrmalt(ps_adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));
1023 if (ps_adapter->eNVMType == NVM_FLASH) {
1024 status = PropagateCalParamsFromFlashToMemory(ps_adapter);
1026 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Propagation of Cal param failed ..");
1031 /* Download Firmare */
1032 status = BcmFileDownload(ps_adapter, BIN_FILE, FIRMWARE_BEGIN_ADDR);
1034 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "No Firmware File is present...\n");
1038 status = run_card_proc(ps_adapter);
1040 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "run_card_proc Failed\n");
1044 ps_adapter->fw_download_done = TRUE;
1048 if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1049 ps_adapter->DriverState = FW_DOWNLOAD_DONE;
1050 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1056 static int bcm_parse_target_params(struct bcm_mini_adapter *Adapter)
1058 struct file *flp = NULL;
1059 mm_segment_t oldfs = {0};
1064 buff = kmalloc(BUFFER_1K, GFP_KERNEL);
1068 Adapter->pstargetparams = kmalloc(sizeof(STARGETPARAMS), GFP_KERNEL);
1069 if (Adapter->pstargetparams == NULL) {
1074 flp = open_firmware_file(Adapter, CFG_FILE);
1076 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "NOT ABLE TO OPEN THE %s FILE\n", CFG_FILE);
1078 kfree(Adapter->pstargetparams);
1079 Adapter->pstargetparams = NULL;
1084 len = vfs_read(flp, (void __user __force *)buff, BUFFER_1K, &pos);
1087 if (len != sizeof(STARGETPARAMS)) {
1088 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Mismatch in Target Param Structure!\n");
1090 kfree(Adapter->pstargetparams);
1091 Adapter->pstargetparams = NULL;
1092 filp_close(flp, current->files);
1095 filp_close(flp, current->files);
1097 /* Check for autolink in config params */
1099 * Values in Adapter->pstargetparams are in network byte order
1101 memcpy(Adapter->pstargetparams, buff, sizeof(STARGETPARAMS));
1103 beceem_parse_target_struct(Adapter);
1104 return STATUS_SUCCESS;
1107 void beceem_parse_target_struct(struct bcm_mini_adapter *Adapter)
1109 UINT uiHostDrvrCfg6 = 0, uiEEPROMFlag = 0;
1111 if (ntohl(Adapter->pstargetparams->m_u32PhyParameter2) & AUTO_SYNC_DISABLE) {
1112 pr_info(DRV_NAME ": AutoSyncup is Disabled\n");
1113 Adapter->AutoSyncup = FALSE;
1115 pr_info(DRV_NAME ": AutoSyncup is Enabled\n");
1116 Adapter->AutoSyncup = TRUE;
1119 if (ntohl(Adapter->pstargetparams->HostDrvrConfig6) & AUTO_LINKUP_ENABLE) {
1120 pr_info(DRV_NAME ": Enabling autolink up");
1121 Adapter->AutoLinkUp = TRUE;
1123 pr_info(DRV_NAME ": Disabling autolink up");
1124 Adapter->AutoLinkUp = FALSE;
1126 /* Setting the DDR Setting.. */
1127 Adapter->DDRSetting = (ntohl(Adapter->pstargetparams->HostDrvrConfig6) >> 8)&0x0F;
1128 Adapter->ulPowerSaveMode = (ntohl(Adapter->pstargetparams->HostDrvrConfig6)>>12)&0x0F;
1129 pr_info(DRV_NAME ": DDR Setting: %x\n", Adapter->DDRSetting);
1130 pr_info(DRV_NAME ": Power Save Mode: %lx\n", Adapter->ulPowerSaveMode);
1131 if (ntohl(Adapter->pstargetparams->HostDrvrConfig6) & AUTO_FIRM_DOWNLOAD) {
1132 pr_info(DRV_NAME ": Enabling Auto Firmware Download\n");
1133 Adapter->AutoFirmDld = TRUE;
1135 pr_info(DRV_NAME ": Disabling Auto Firmware Download\n");
1136 Adapter->AutoFirmDld = FALSE;
1138 uiHostDrvrCfg6 = ntohl(Adapter->pstargetparams->HostDrvrConfig6);
1139 Adapter->bMipsConfig = (uiHostDrvrCfg6>>20)&0x01;
1140 pr_info(DRV_NAME ": MIPSConfig : 0x%X\n", Adapter->bMipsConfig);
1141 /* used for backward compatibility. */
1142 Adapter->bDPLLConfig = (uiHostDrvrCfg6>>19)&0x01;
1143 Adapter->PmuMode = (uiHostDrvrCfg6 >> 24) & 0x03;
1144 pr_info(DRV_NAME ": PMU MODE: %x", Adapter->PmuMode);
1146 if ((uiHostDrvrCfg6 >> HOST_BUS_SUSPEND_BIT) & (0x01)) {
1147 Adapter->bDoSuspend = TRUE;
1148 pr_info(DRV_NAME ": Making DoSuspend TRUE as per configFile");
1151 uiEEPROMFlag = ntohl(Adapter->pstargetparams->m_u32EEPROMFlag);
1152 pr_info(DRV_NAME ": uiEEPROMFlag : 0x%X\n", uiEEPROMFlag);
1153 Adapter->eNVMType = (NVM_TYPE)((uiEEPROMFlag>>4)&0x3);
1154 Adapter->bStatusWrite = (uiEEPROMFlag>>6)&0x1;
1155 Adapter->uiSectorSizeInCFG = 1024*(0xFFFF & ntohl(Adapter->pstargetparams->HostDrvrConfig4));
1156 Adapter->bSectorSizeOverride = (bool) ((ntohl(Adapter->pstargetparams->HostDrvrConfig4))>>16)&0x1;
1158 if (ntohl(Adapter->pstargetparams->m_u32PowerSavingModeOptions) & 0x01)
1159 Adapter->ulPowerSaveMode = DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE;
1161 if (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE)
1162 doPowerAutoCorrection(Adapter);
1165 static VOID doPowerAutoCorrection(struct bcm_mini_adapter *psAdapter)
1167 UINT reporting_mode;
1169 reporting_mode = ntohl(psAdapter->pstargetparams->m_u32PowerSavingModeOptions) & 0x02;
1170 psAdapter->bIsAutoCorrectEnabled = !((char)(psAdapter->ulPowerSaveMode >> 3) & 0x1);
1172 if (reporting_mode == TRUE) {
1173 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "can't do suspen/resume as reporting mode is enable");
1174 psAdapter->bDoSuspend = FALSE;
1177 if (psAdapter->bIsAutoCorrectEnabled && (psAdapter->chip_id >= T3LPB)) {
1178 /* If reporting mode is enable, switch PMU to PMC */
1180 psAdapter->ulPowerSaveMode = DEVICE_POWERSAVE_MODE_AS_PMU_CLOCK_GATING;
1181 psAdapter->bDoSuspend = FALSE;
1184 /* clearing space bit[15..12] */
1185 psAdapter->pstargetparams->HostDrvrConfig6 &= ~(htonl((0xF << 12)));
1186 /* placing the power save mode option */
1187 psAdapter->pstargetparams->HostDrvrConfig6 |= htonl((psAdapter->ulPowerSaveMode << 12));
1188 } else if (psAdapter->bIsAutoCorrectEnabled == FALSE) {
1189 /* remove the autocorrect disable bit set before dumping. */
1190 psAdapter->ulPowerSaveMode &= ~(1 << 3);
1191 psAdapter->pstargetparams->HostDrvrConfig6 &= ~(htonl(1 << 15));
1192 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Using Forced User Choice: %lx\n", psAdapter->ulPowerSaveMode);
1196 static void convertEndian(B_UINT8 rwFlag, PUINT puiBuffer, UINT uiByteCount)
1200 if (RWM_WRITE == rwFlag) {
1201 for (uiIndex = 0; uiIndex < (uiByteCount/sizeof(UINT)); uiIndex++)
1202 puiBuffer[uiIndex] = htonl(puiBuffer[uiIndex]);
1204 for (uiIndex = 0; uiIndex < (uiByteCount/sizeof(UINT)); uiIndex++)
1205 puiBuffer[uiIndex] = ntohl(puiBuffer[uiIndex]);
1209 #define CACHE_ADDRESS_MASK 0x80000000
1210 #define UNCACHE_ADDRESS_MASK 0xa0000000
1212 int rdm(struct bcm_mini_adapter *Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
1214 return Adapter->interface_rdm(Adapter->pvInterfaceAdapter,
1215 uiAddress, pucBuff, sSize);
1218 int wrm(struct bcm_mini_adapter *Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
1222 iRetVal = Adapter->interface_wrm(Adapter->pvInterfaceAdapter,
1223 uiAddress, pucBuff, sSize);
1227 int wrmalt(struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1229 convertEndian(RWM_WRITE, pucBuff, size);
1230 return wrm(Adapter, uiAddress, (PUCHAR)pucBuff, size);
1233 int rdmalt(struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1237 uiRetVal = rdm(Adapter, uiAddress, (PUCHAR)pucBuff, size);
1238 convertEndian(RWM_READ, (PUINT)pucBuff, size);
1243 int wrmWithLock(struct bcm_mini_adapter *Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
1245 INT status = STATUS_SUCCESS;
1246 down(&Adapter->rdmwrmsync);
1248 if ((Adapter->IdleMode == TRUE) ||
1249 (Adapter->bShutStatus == TRUE) ||
1250 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1256 status = wrm(Adapter, uiAddress, pucBuff, sSize);
1258 up(&Adapter->rdmwrmsync);
1262 int wrmaltWithLock(struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1264 int iRetVal = STATUS_SUCCESS;
1266 down(&Adapter->rdmwrmsync);
1268 if ((Adapter->IdleMode == TRUE) ||
1269 (Adapter->bShutStatus == TRUE) ||
1270 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1276 iRetVal = wrmalt(Adapter, uiAddress, pucBuff, size);
1278 up(&Adapter->rdmwrmsync);
1282 int rdmaltWithLock(struct bcm_mini_adapter *Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1284 INT uiRetVal = STATUS_SUCCESS;
1286 down(&Adapter->rdmwrmsync);
1287 if ((Adapter->IdleMode == TRUE) ||
1288 (Adapter->bShutStatus == TRUE) ||
1289 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1295 uiRetVal = rdmalt(Adapter, uiAddress, pucBuff, size);
1297 up(&Adapter->rdmwrmsync);
1301 static VOID HandleShutDownModeWakeup(struct bcm_mini_adapter *Adapter)
1303 int clear_abort_pattern = 0, Status = 0;
1304 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "====>\n");
1305 /* target has woken up From Shut Down */
1306 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Clearing Shut Down Software abort pattern\n");
1307 Status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, (PUINT)&clear_abort_pattern, sizeof(clear_abort_pattern));
1309 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "WRM to SW_ABORT_IDLEMODE_LOC failed with err:%d", Status);
1313 if (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE) {
1315 InterfaceHandleShutdownModeWakeup(Adapter);
1319 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1320 Adapter->DriverState = NO_NETWORK_ENTRY;
1321 wake_up(&Adapter->LEDInfo.notify_led_event);
1324 Adapter->bTriedToWakeUpFromlowPowerMode = FALSE;
1325 Adapter->bShutStatus = FALSE;
1326 wake_up(&Adapter->lowpower_mode_wait_queue);
1327 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "<====\n");
1330 static VOID SendShutModeResponse(struct bcm_mini_adapter *Adapter)
1332 struct bcm_link_request stShutdownResponse;
1333 UINT NVMAccess = 0, lowPwrAbortMsg = 0;
1336 memset(&stShutdownResponse, 0, sizeof(struct bcm_link_request));
1337 stShutdownResponse.Leader.Status = LINK_UP_CONTROL_REQ;
1338 stShutdownResponse.Leader.PLength = 8; /* 8 bytes; */
1339 stShutdownResponse.szData[0] = LINK_UP_ACK;
1340 stShutdownResponse.szData[1] = LINK_SHUTDOWN_REQ_FROM_FIRMWARE;
1342 /*********************************
1344 * if [ semaphore is available ]
1345 * acquire semaphone and return value 0 ;
1347 * return non-zero value ;
1349 ***********************************/
1351 NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
1352 lowPwrAbortMsg = down_trylock(&Adapter->LowPowerModeSync);
1354 if (NVMAccess || lowPwrAbortMsg || atomic_read(&Adapter->TotalPacketCount)) {
1356 up(&Adapter->NVMRdmWrmLock);
1358 if (!lowPwrAbortMsg)
1359 up(&Adapter->LowPowerModeSync);
1361 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Device Access is going on NACK the Shut Down MODE\n");
1362 stShutdownResponse.szData[2] = SHUTDOWN_NACK_FROM_DRIVER; /* NACK- device access is going on. */
1363 Adapter->bPreparingForLowPowerMode = FALSE;
1365 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Sending SHUTDOWN MODE ACK\n");
1366 stShutdownResponse.szData[2] = SHUTDOWN_ACK_FROM_DRIVER; /* ShutDown ACK */
1368 /* Wait for the LED to TURN OFF before sending ACK response */
1369 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1372 /* Wake the LED Thread with LOWPOWER_MODE_ENTER State */
1373 Adapter->DriverState = LOWPOWER_MODE_ENTER;
1374 wake_up(&Adapter->LEDInfo.notify_led_event);
1376 /* Wait for 1 SEC for LED to OFF */
1377 iRetVal = wait_event_timeout(Adapter->LEDInfo.idleModeSyncEvent, Adapter->LEDInfo.bIdle_led_off, msecs_to_jiffies(1000));
1379 /* If Timed Out to Sync IDLE MODE Enter, do IDLE mode Exit and Send NACK to device */
1381 stShutdownResponse.szData[1] = SHUTDOWN_NACK_FROM_DRIVER; /* NACK- device access is going on. */
1382 Adapter->DriverState = NO_NETWORK_ENTRY;
1383 wake_up(&Adapter->LEDInfo.notify_led_event);
1387 if (stShutdownResponse.szData[2] == SHUTDOWN_ACK_FROM_DRIVER) {
1388 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "ACKING SHUTDOWN MODE !!!!!!!!!");
1389 down(&Adapter->rdmwrmsync);
1390 Adapter->bPreparingForLowPowerMode = TRUE;
1391 up(&Adapter->rdmwrmsync);
1392 /* Killing all URBS. */
1393 if (Adapter->bDoSuspend == TRUE)
1394 Bcm_kill_all_URBs((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
1396 Adapter->bPreparingForLowPowerMode = FALSE;
1400 up(&Adapter->NVMRdmWrmLock);
1402 if (!lowPwrAbortMsg)
1403 up(&Adapter->LowPowerModeSync);
1406 Status = CopyBufferToControlPacket(Adapter, &stShutdownResponse);
1407 if ((Status != STATUS_SUCCESS)) {
1408 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "fail to send the Idle mode Request\n");
1409 Adapter->bPreparingForLowPowerMode = FALSE;
1410 StartInterruptUrb((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
1414 static void HandleShutDownModeRequest(struct bcm_mini_adapter *Adapter, PUCHAR pucBuffer)
1416 B_UINT32 uiResetValue = 0;
1418 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "====>\n");
1420 if (*(pucBuffer+1) == COMPLETE_WAKE_UP_NOTIFICATION_FRM_FW) {
1421 HandleShutDownModeWakeup(Adapter);
1422 } else if (*(pucBuffer+1) == LINK_SHUTDOWN_REQ_FROM_FIRMWARE) {
1423 /* Target wants to go to Shut Down Mode */
1424 /* InterfacePrepareForShutdown(Adapter); */
1425 if (Adapter->chip_id == BCS220_2 ||
1426 Adapter->chip_id == BCS220_2BC ||
1427 Adapter->chip_id == BCS250_BC ||
1428 Adapter->chip_id == BCS220_3) {
1430 rdmalt(Adapter, HPM_CONFIG_MSW, &uiResetValue, 4);
1431 uiResetValue |= (1<<17);
1432 wrmalt(Adapter, HPM_CONFIG_MSW, &uiResetValue, 4);
1435 SendShutModeResponse(Adapter);
1436 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "ShutDownModeResponse:Notification received: Sending the response(Ack/Nack)\n");
1439 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "<====\n");
1443 VOID ResetCounters(struct bcm_mini_adapter *Adapter)
1445 beceem_protocol_reset(Adapter);
1446 Adapter->CurrNumRecvDescs = 0;
1447 Adapter->PrevNumRecvDescs = 0;
1448 Adapter->LinkUpStatus = 0;
1449 Adapter->LinkStatus = 0;
1450 atomic_set(&Adapter->cntrlpktCnt, 0);
1451 atomic_set(&Adapter->TotalPacketCount, 0);
1452 Adapter->fw_download_done = FALSE;
1453 Adapter->LinkStatus = 0;
1454 Adapter->AutoLinkUp = FALSE;
1455 Adapter->IdleMode = FALSE;
1456 Adapter->bShutStatus = FALSE;
1459 struct bcm_classifier_rule *GetFragIPClsEntry(struct bcm_mini_adapter *Adapter, USHORT usIpIdentification, ULONG SrcIP)
1462 for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1463 if ((Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) &&
1464 (Adapter->astFragmentedPktClassifierTable[uiIndex].usIpIdentification == usIpIdentification) &&
1465 (Adapter->astFragmentedPktClassifierTable[uiIndex].ulSrcIpAddress == SrcIP) &&
1466 !Adapter->astFragmentedPktClassifierTable[uiIndex].bOutOfOrderFragment)
1468 return Adapter->astFragmentedPktClassifierTable[uiIndex].pstMatchedClassifierEntry;
1473 void AddFragIPClsEntry(struct bcm_mini_adapter *Adapter, struct bcm_fragmented_packet_info *psFragPktInfo)
1476 for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1477 if (!Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) {
1478 memcpy(&Adapter->astFragmentedPktClassifierTable[uiIndex], psFragPktInfo, sizeof(struct bcm_fragmented_packet_info));
1484 void DelFragIPClsEntry(struct bcm_mini_adapter *Adapter, USHORT usIpIdentification, ULONG SrcIp)
1487 for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1488 if ((Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) &&
1489 (Adapter->astFragmentedPktClassifierTable[uiIndex].usIpIdentification == usIpIdentification) &&
1490 (Adapter->astFragmentedPktClassifierTable[uiIndex].ulSrcIpAddress == SrcIp))
1492 memset(&Adapter->astFragmentedPktClassifierTable[uiIndex], 0, sizeof(struct bcm_fragmented_packet_info));
1496 void update_per_cid_rx(struct bcm_mini_adapter *Adapter)
1500 if ((jiffies - Adapter->liDrainCalculated) < XSECONDS)
1503 for (qindex = 0; qindex < HiPriority; qindex++) {
1504 if (Adapter->PackInfo[qindex].ucDirection == 0) {
1505 Adapter->PackInfo[qindex].uiCurrentRxRate =
1506 (Adapter->PackInfo[qindex].uiCurrentRxRate +
1507 Adapter->PackInfo[qindex].uiThisPeriodRxBytes) / 2;
1509 Adapter->PackInfo[qindex].uiThisPeriodRxBytes = 0;
1511 Adapter->PackInfo[qindex].uiCurrentDrainRate =
1512 (Adapter->PackInfo[qindex].uiCurrentDrainRate +
1513 Adapter->PackInfo[qindex].uiThisPeriodSentBytes) / 2;
1514 Adapter->PackInfo[qindex].uiThisPeriodSentBytes = 0;
1517 Adapter->liDrainCalculated = jiffies;
1520 void update_per_sf_desc_cnts(struct bcm_mini_adapter *Adapter)
1523 u32 uibuff[MAX_TARGET_DSX_BUFFERS];
1526 if (!atomic_read(&Adapter->uiMBupdate))
1529 bytes = rdmaltWithLock(Adapter, TARGET_SFID_TXDESC_MAP_LOC, (PUINT)uibuff, sizeof(UINT) * MAX_TARGET_DSX_BUFFERS);
1531 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "rdm failed\n");
1535 for (iIndex = 0; iIndex < HiPriority; iIndex++) {
1536 if (Adapter->PackInfo[iIndex].bValid && Adapter->PackInfo[iIndex].ucDirection) {
1537 if (Adapter->PackInfo[iIndex].usVCID_Value < MAX_TARGET_DSX_BUFFERS)
1538 atomic_set(&Adapter->PackInfo[iIndex].uiPerSFTxResourceCount, uibuff[Adapter->PackInfo[iIndex].usVCID_Value]);
1540 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Invalid VCID : %x\n", Adapter->PackInfo[iIndex].usVCID_Value);
1543 atomic_set(&Adapter->uiMBupdate, FALSE);
1546 void flush_queue(struct bcm_mini_adapter *Adapter, UINT iQIndex)
1548 struct sk_buff *PacketToDrop = NULL;
1549 struct net_device_stats *netstats = &Adapter->dev->stats;
1550 spin_lock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
1552 while (Adapter->PackInfo[iQIndex].FirstTxQueue && atomic_read(&Adapter->TotalPacketCount)) {
1553 PacketToDrop = Adapter->PackInfo[iQIndex].FirstTxQueue;
1554 if (PacketToDrop && PacketToDrop->len) {
1555 netstats->tx_dropped++;
1556 DEQUEUEPACKET(Adapter->PackInfo[iQIndex].FirstTxQueue, Adapter->PackInfo[iQIndex].LastTxQueue);
1557 Adapter->PackInfo[iQIndex].uiCurrentPacketsOnHost--;
1558 Adapter->PackInfo[iQIndex].uiCurrentBytesOnHost -= PacketToDrop->len;
1560 /* Adding dropped statistics */
1561 Adapter->PackInfo[iQIndex].uiDroppedCountBytes += PacketToDrop->len;
1562 Adapter->PackInfo[iQIndex].uiDroppedCountPackets++;
1563 dev_kfree_skb(PacketToDrop);
1564 atomic_dec(&Adapter->TotalPacketCount);
1567 spin_unlock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
1570 static void beceem_protocol_reset(struct bcm_mini_adapter *Adapter)
1573 if (netif_msg_link(Adapter))
1574 pr_notice(PFX "%s: protocol reset\n", Adapter->dev->name);
1576 netif_carrier_off(Adapter->dev);
1577 netif_stop_queue(Adapter->dev);
1579 Adapter->IdleMode = FALSE;
1580 Adapter->LinkUpStatus = FALSE;
1581 ClearTargetDSXBuffer(Adapter, 0, TRUE);
1582 /* Delete All Classifier Rules */
1584 for (i = 0; i < HiPriority; i++)
1585 DeleteAllClassifiersForSF(Adapter, i);
1587 flush_all_queues(Adapter);
1589 if (Adapter->TimerActive == TRUE)
1590 Adapter->TimerActive = FALSE;
1592 memset(Adapter->astFragmentedPktClassifierTable, 0, sizeof(struct bcm_fragmented_packet_info) * MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES);
1594 for (i = 0; i < HiPriority; i++) {
1595 /* resetting only the first size (S_MIBS_SERVICEFLOW_TABLE) for the SF. */
1596 /* It is same between MIBs and SF. */
1597 memset(&Adapter->PackInfo[i].stMibsExtServiceFlowTable, 0, sizeof(S_MIBS_EXTSERVICEFLOW_PARAMETERS));