1 #include "headers.h"
2
3 static int BcmFileDownload(PMINI_ADAPTER Adapter, const char *path, unsigned int loc);
4 static VOID doPowerAutoCorrection(PMINI_ADAPTER psAdapter);
5 static void HandleShutDownModeRequest(PMINI_ADAPTER Adapter, PUCHAR pucBuffer);
6 static int bcm_parse_target_params(PMINI_ADAPTER Adapter);
7 static void beceem_protocol_reset(PMINI_ADAPTER Adapter);
8
default_wimax_protocol_initialize(PMINI_ADAPTER Adapter)9 static VOID default_wimax_protocol_initialize(PMINI_ADAPTER Adapter)
10 {
11 UINT uiLoopIndex;
12
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;
17 }
18
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;
24 return;
25 }
26
InitAdapter(PMINI_ADAPTER psAdapter)27 INT InitAdapter(PMINI_ADAPTER psAdapter)
28 {
29 int i = 0;
30 INT Status = STATUS_SUCCESS;
31 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Initialising Adapter = %p", psAdapter);
32
33 if (psAdapter == NULL) {
34 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Adapter is NULL");
35 return -EINVAL;
36 }
37
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);
45
46 for (i = 0; i < NO_OF_QUEUES; i++)
47 spin_lock_init(&psAdapter->PackInfo[i].SFQueueLock);
48 i = 0;
49
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;
57
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);
63 return -ENOMEM;
64 }
65 }
66
67 if (AllocAdapterDsxBuffer(psAdapter)) {
68 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Failed to allocate DSX buffers");
69 return -EINVAL;
70 }
71
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__);
75 return -ENOMEM;
76 }
77
78 Status = BcmAllocFlashCSStructure(psAdapter);
79 if (Status) {
80 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Memory Allocation for Flash structure failed");
81 return Status;
82 }
83
84 Status = vendorextnInit(psAdapter);
85
86 if (STATUS_SUCCESS != Status) {
87 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Vendor Init Failed");
88 return Status;
89 }
90
91 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Adapter initialised");
92
93 return STATUS_SUCCESS;
94 }
95
AdapterFree(PMINI_ADAPTER Adapter)96 VOID AdapterFree(PMINI_ADAPTER Adapter)
97 {
98 int count;
99 beceem_protocol_reset(Adapter);
100 vendorextnExit(Adapter);
101
102 if (Adapter->control_packet_handler && !IS_ERR(Adapter->control_packet_handler))
103 kthread_stop(Adapter->control_packet_handler);
104
105 if (Adapter->transmit_packet_thread && !IS_ERR(Adapter->transmit_packet_thread))
106 kthread_stop(Adapter->transmit_packet_thread);
107
108 wake_up(&Adapter->process_read_wait_queue);
109
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);
112
113 unregister_networkdev(Adapter);
114
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));
118 msleep(100);
119 }
120 unregister_control_device_interface(Adapter);
121 kfree(Adapter->pstargetparams);
122
123 for (count = 0; count < MAX_CNTRL_PKTS; count++)
124 kfree(Adapter->txctlpacket[count]);
125
126 FreeAdapterDsxBuffer(Adapter);
127 kfree(Adapter->pvInterfaceAdapter);
128
129 /* Free the PHS Interface */
130 PhsCleanup(&Adapter->stBCMPhsContext);
131
132 BcmDeAllocFlashCSStructure(Adapter);
133
134 free_netdev(Adapter->dev);
135 }
136
create_worker_threads(PMINI_ADAPTER psAdapter)137 static int create_worker_threads(PMINI_ADAPTER psAdapter)
138 {
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);
145 }
146
147 /* Tx Thread */
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);
154 }
155 return 0;
156 }
157
open_firmware_file(PMINI_ADAPTER Adapter,const char * path)158 static struct file *open_firmware_file(PMINI_ADAPTER Adapter, const char *path)
159 {
160 struct file *flp = NULL;
161 mm_segment_t oldfs;
162 oldfs = get_fs();
163 set_fs(get_ds());
164 flp = filp_open(path, O_RDONLY, S_IRWXU);
165 set_fs(oldfs);
166 if (IS_ERR(flp)) {
167 pr_err(DRV_NAME "Unable To Open File %s, err %ld", path, PTR_ERR(flp));
168 flp = NULL;
169 }
170
171 if (Adapter->device_removed)
172 flp = NULL;
173
174 return flp;
175 }
176
177 /* Arguments:
178 * Logical Adapter
179 * Path to image file
180 * Download Address on the chip
181 */
BcmFileDownload(PMINI_ADAPTER Adapter,const char * path,unsigned int loc)182 static int BcmFileDownload(PMINI_ADAPTER Adapter, const char *path, unsigned int loc)
183 {
184 int errorno = 0;
185 struct file *flp = NULL;
186 mm_segment_t oldfs;
187 struct timeval tv = {0};
188
189 flp = open_firmware_file(Adapter, path);
190 if (!flp) {
191 errorno = -ENOENT;
192 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Unable to Open %s\n", path);
193 goto exit_download;
194 }
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);
197
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);
201 errorno = -EIO;
202 goto exit_download;
203 }
204 oldfs = get_fs();
205 set_fs(get_ds());
206 vfs_llseek(flp, 0, 0);
207 set_fs(oldfs);
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!");
210 errorno = -EIO;
211 goto exit_download;
212 }
213
214 exit_download:
215 oldfs = get_fs();
216 set_fs(get_ds());
217 if (flp && !(IS_ERR(flp)))
218 filp_close(flp, current->files);
219 set_fs(oldfs);
220
221 return errorno;
222 }
223
224 /**
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.
230 * Arguments:
231 * Logical Adapter
232 * Control Packet Buffer
233 */
CopyBufferToControlPacket(PMINI_ADAPTER Adapter,PVOID ioBuffer)234 INT CopyBufferToControlPacket(PMINI_ADAPTER Adapter, PVOID ioBuffer)
235 {
236 PLEADER pLeader = NULL;
237 INT Status = 0;
238 unsigned char *ctrl_buff = NULL;
239 UINT pktlen = 0;
240 PLINK_REQUEST pLinkReq = NULL;
241 PUCHAR pucAddIndication = NULL;
242
243 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "======>");
244 if (!ioBuffer) {
245 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Got Null Buffer\n");
246 return -EINVAL;
247 }
248
249 pLinkReq = (PLINK_REQUEST)ioBuffer;
250 pLeader = (PLEADER)ioBuffer; /* ioBuffer Contains sw_Status and Payload */
251
252 if (Adapter->bShutStatus == TRUE &&
253 pLinkReq->szData[0] == LINK_DOWN_REQ_PAYLOAD &&
254 pLinkReq->szData[1] == LINK_SYNC_UP_SUBTYPE) {
255
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;
259 }
260
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 */ {
265
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;
269 }
270
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));
279
280 if (Status == -ERESTARTSYS)
281 return Status;
282
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;
286 }
287 } else {
288 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Wakeup has been tried already...\n");
289 }
290 }
291 }
292
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) {
297
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 */
302 } else {
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;
305 }
306 } else {
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;
309 }
310
311 /*Setting bIdleMode_tx_from_host to TRUE to indicate LED control thread to represent
312 * the wake up from idlemode is from host
313 */
314 /* Adapter->LEDInfo.bIdleMode_tx_from_host = TRUE; */
315 Adapter->bWakeUpDevice = TRUE;
316 wake_up(&Adapter->process_rx_cntrlpkt);
317
318 /* We should not send DREG message down while in idlemode. */
319 if (LINK_DOWN_REQ_PAYLOAD == pLinkReq->szData[0])
320 return STATUS_SUCCESS;
321
322 Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue, !Adapter->IdleMode, (5 * HZ));
323
324 if (Status == -ERESTARTSYS)
325 return Status;
326
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;
330 }
331 } else {
332 return STATUS_SUCCESS;
333 }
334 }
335
336 /* The Driver has to send control messages with a particular VCID */
337 pLeader->Vcid = VCID_CONTROL_PACKET; /* VCID for control packet. */
338
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];
342
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);
345 if (ctrl_buff) {
346 if (pLeader) {
347 if ((pLeader->Status == 0x80) ||
348 (pLeader->Status == CM_CONTROL_NEWDSX_MULTICLASSIFIER_REQ)) {
349 /*
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.
353 */
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);
358 if (Status != 1) {
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;
362 }
363 /*
364 * update the leader to use the new length
365 * The length of the control packet is length of message being sent + Leader length
366 */
367 pLeader->PLength = pktlen;
368 }
369 }
370
371 if (pktlen + LEADER_SIZE > MAX_CNTL_PKT_SIZE)
372 return -EINVAL;
373
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 *(PLEADER)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");
379
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;
387
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);
397 } else {
398 Status = -ENOMEM;
399 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "mem allocation Failed");
400 }
401 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "<====");
402 return Status;
403 }
404
405 #if 0
406 /*****************************************************************
407 * Function - SendStatisticsPointerRequest()
408 *
409 * Description - This function builds and forwards the Statistics
410 * Pointer Request control Packet.
411 *
412 * Parameters - Adapter : Pointer to Adapter structure.
413 * - pstStatisticsPtrRequest : Pointer to link request.
414 *
415 * Returns - None.
416 *****************************************************************/
417 static VOID SendStatisticsPointerRequest(PMINI_ADAPTER Adapter, PLINK_REQUEST pstStatisticsPtrRequest)
418 {
419 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "======>");
420 pstStatisticsPtrRequest->Leader.Status = STATS_POINTER_REQ_STATUS;
421 pstStatisticsPtrRequest->Leader.PLength = sizeof(ULONG); /* minimum 4 bytes */
422 pstStatisticsPtrRequest->szData[0] = STATISTICS_POINTER_REQ;
423 CopyBufferToControlPacket(Adapter, pstStatisticsPtrRequest);
424 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "<=====");
425 return;
426 }
427 #endif
428
429 /******************************************************************
430 * Function - LinkMessage()
431 *
432 * Description - This function builds the Sync-up and Link-up request
433 * packet messages depending on the device Link status.
434 *
435 * Parameters - Adapter: Pointer to the Adapter structure.
436 *
437 * Returns - None.
438 *******************************************************************/
LinkMessage(PMINI_ADAPTER Adapter)439 VOID LinkMessage(PMINI_ADAPTER Adapter)
440 {
441 PLINK_REQUEST pstLinkRequest = NULL;
442 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "=====>");
443 if (Adapter->LinkStatus == SYNC_UP_REQUEST && Adapter->AutoSyncup) {
444 pstLinkRequest = kzalloc(sizeof(LINK_REQUEST), GFP_ATOMIC);
445 if (!pstLinkRequest) {
446 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Can not allocate memory for Link request!");
447 return;
448 }
449 /* sync up request... */
450 Adapter->LinkStatus = WAIT_FOR_SYNC; /* current link status */
451 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Requesting For SyncUp...");
452 pstLinkRequest->szData[0] = LINK_UP_REQ_PAYLOAD;
453 pstLinkRequest->szData[1] = LINK_SYNC_UP_SUBTYPE;
454 pstLinkRequest->Leader.Status = LINK_UP_CONTROL_REQ;
455 pstLinkRequest->Leader.PLength = sizeof(ULONG);
456 Adapter->bSyncUpRequestSent = TRUE;
457
458 } else if (Adapter->LinkStatus == PHY_SYNC_ACHIVED && Adapter->AutoLinkUp) {
459 pstLinkRequest = kzalloc(sizeof(LINK_REQUEST), GFP_ATOMIC);
460 if (!pstLinkRequest) {
461 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Can not allocate memory for Link request!");
462 return;
463 }
464 /* LINK_UP_REQUEST */
465 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Requesting For LinkUp...");
466 pstLinkRequest->szData[0] = LINK_UP_REQ_PAYLOAD;
467 pstLinkRequest->szData[1] = LINK_NET_ENTRY;
468 pstLinkRequest->Leader.Status = LINK_UP_CONTROL_REQ;
469 pstLinkRequest->Leader.PLength = sizeof(ULONG);
470 }
471 if (pstLinkRequest) {
472 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "Calling CopyBufferToControlPacket");
473 CopyBufferToControlPacket(Adapter, pstLinkRequest);
474 kfree(pstLinkRequest);
475 }
476 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, LINK_UP_MSG, DBG_LVL_ALL, "LinkMessage <=====");
477 return;
478 }
479
480 /**********************************************************************
481 * Function - StatisticsResponse()
482 *
483 * Description - This function handles the Statistics response packet.
484 *
485 * Parameters - Adapter : Pointer to the Adapter structure.
486 * - pvBuffer: Starting address of Statistic response data.
487 *
488 * Returns - None.
489 ************************************************************************/
StatisticsResponse(PMINI_ADAPTER Adapter,PVOID pvBuffer)490 VOID StatisticsResponse(PMINI_ADAPTER Adapter, PVOID pvBuffer)
491 {
492 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "%s====>", __func__);
493 Adapter->StatisticsPointer = ntohl(*(__be32 *)pvBuffer);
494 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Stats at %x", (UINT)Adapter->StatisticsPointer);
495 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "%s <====", __func__);
496 return;
497 }
498
499 /**********************************************************************
500 * Function - LinkControlResponseMessage()
501 *
502 * Description - This function handles the Link response packets.
503 *
504 * Parameters - Adapter : Pointer to the Adapter structure.
505 * - pucBuffer: Starting address of Link response data.
506 *
507 * Returns - None.
508 ***********************************************************************/
LinkControlResponseMessage(PMINI_ADAPTER Adapter,PUCHAR pucBuffer)509 VOID LinkControlResponseMessage(PMINI_ADAPTER Adapter, PUCHAR pucBuffer)
510 {
511 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "=====>");
512
513 if (*pucBuffer == LINK_UP_ACK) {
514 switch (*(pucBuffer+1)) {
515 case PHY_SYNC_ACHIVED: /* SYNCed UP */
516 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "PHY_SYNC_ACHIVED");
517
518 if (Adapter->LinkStatus == LINKUP_DONE)
519 beceem_protocol_reset(Adapter);
520
521 Adapter->usBestEffortQueueIndex = INVALID_QUEUE_INDEX;
522 Adapter->LinkStatus = PHY_SYNC_ACHIVED;
523
524 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
525 Adapter->DriverState = NO_NETWORK_ENTRY;
526 wake_up(&Adapter->LEDInfo.notify_led_event);
527 }
528
529 LinkMessage(Adapter);
530 break;
531
532 case LINKUP_DONE:
533 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "LINKUP_DONE");
534 Adapter->LinkStatus = LINKUP_DONE;
535 Adapter->bPHSEnabled = *(pucBuffer+3);
536 Adapter->bETHCSEnabled = *(pucBuffer+4) & ETH_CS_MASK;
537 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "PHS Support Status Received In LinkUp Ack : %x\n", Adapter->bPHSEnabled);
538
539 if ((FALSE == Adapter->bShutStatus) && (FALSE == Adapter->IdleMode)) {
540 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
541 Adapter->DriverState = NORMAL_OPERATION;
542 wake_up(&Adapter->LEDInfo.notify_led_event);
543 }
544 }
545 LinkMessage(Adapter);
546 break;
547
548 case WAIT_FOR_SYNC:
549 /*
550 * Driver to ignore the DREG_RECEIVED
551 * WiMAX Application should handle this Message
552 */
553 /* Adapter->liTimeSinceLastNetEntry = 0; */
554 Adapter->LinkUpStatus = 0;
555 Adapter->LinkStatus = 0;
556 Adapter->usBestEffortQueueIndex = INVALID_QUEUE_INDEX;
557 Adapter->bTriedToWakeUpFromlowPowerMode = FALSE;
558 Adapter->IdleMode = FALSE;
559 beceem_protocol_reset(Adapter);
560
561 break;
562 case LINK_SHUTDOWN_REQ_FROM_FIRMWARE:
563 case COMPLETE_WAKE_UP_NOTIFICATION_FRM_FW:
564 {
565 HandleShutDownModeRequest(Adapter, pucBuffer);
566 }
567 break;
568 default:
569 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "default case:LinkResponse %x", *(pucBuffer + 1));
570 break;
571 }
572 } else if (SET_MAC_ADDRESS_RESPONSE == *pucBuffer) {
573 PUCHAR puMacAddr = (pucBuffer + 1);
574 Adapter->LinkStatus = SYNC_UP_REQUEST;
575 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "MAC address response, sending SYNC_UP");
576 LinkMessage(Adapter);
577 memcpy(Adapter->dev->dev_addr, puMacAddr, MAC_ADDRESS_SIZE);
578 }
579 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "%s <=====", __func__);
580 return;
581 }
582
SendIdleModeResponse(PMINI_ADAPTER Adapter)583 void SendIdleModeResponse(PMINI_ADAPTER Adapter)
584 {
585 INT status = 0, NVMAccess = 0, lowPwrAbortMsg = 0;
586 struct timeval tv;
587 CONTROL_MESSAGE stIdleResponse = {{0} };
588 memset(&tv, 0, sizeof(tv));
589 stIdleResponse.Leader.Status = IDLE_MESSAGE;
590 stIdleResponse.Leader.PLength = IDLE_MODE_PAYLOAD_LENGTH;
591 stIdleResponse.szData[0] = GO_TO_IDLE_MODE_PAYLOAD;
592 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, " ============>");
593
594 /*********************************
595 *down_trylock -
596 * if [ semaphore is available ]
597 * acquire semaphone and return value 0 ;
598 * else
599 * return non-zero value ;
600 *
601 ***********************************/
602
603 NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
604 lowPwrAbortMsg = down_trylock(&Adapter->LowPowerModeSync);
605
606
607 if ((NVMAccess || lowPwrAbortMsg || atomic_read(&Adapter->TotalPacketCount)) &&
608 (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE)) {
609
610 if (!NVMAccess)
611 up(&Adapter->NVMRdmWrmLock);
612
613 if (!lowPwrAbortMsg)
614 up(&Adapter->LowPowerModeSync);
615
616 stIdleResponse.szData[1] = TARGET_CAN_NOT_GO_TO_IDLE_MODE; /* NACK- device access is going on. */
617 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "HOST IS NACKING Idle mode To F/W!!!!!!!!");
618 Adapter->bPreparingForLowPowerMode = FALSE;
619 } else {
620 stIdleResponse.szData[1] = TARGET_CAN_GO_TO_IDLE_MODE; /* 2; Idle ACK */
621 Adapter->StatisticsPointer = 0;
622
623 /* Wait for the LED to TURN OFF before sending ACK response */
624 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
625 INT iRetVal = 0;
626
627 /* Wake the LED Thread with IDLEMODE_ENTER State */
628 Adapter->DriverState = LOWPOWER_MODE_ENTER;
629 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);
630 wake_up(&Adapter->LEDInfo.notify_led_event);
631
632 /* Wait for 1 SEC for LED to OFF */
633 iRetVal = wait_event_timeout(Adapter->LEDInfo.idleModeSyncEvent, Adapter->LEDInfo.bIdle_led_off, msecs_to_jiffies(1000));
634
635 /* If Timed Out to Sync IDLE MODE Enter, do IDLE mode Exit and Send NACK to device */
636 if (iRetVal <= 0) {
637 stIdleResponse.szData[1] = TARGET_CAN_NOT_GO_TO_IDLE_MODE; /* NACK- device access is going on. */
638 Adapter->DriverState = NORMAL_OPERATION;
639 wake_up(&Adapter->LEDInfo.notify_led_event);
640 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "NACKING Idle mode as time out happen from LED side!!!!!!!!");
641 }
642 }
643
644 if (stIdleResponse.szData[1] == TARGET_CAN_GO_TO_IDLE_MODE) {
645 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_RX, RX_DPC, DBG_LVL_ALL, "ACKING IDLE MODE !!!!!!!!!");
646 down(&Adapter->rdmwrmsync);
647 Adapter->bPreparingForLowPowerMode = TRUE;
648 up(&Adapter->rdmwrmsync);
649 /* Killing all URBS. */
650 if (Adapter->bDoSuspend == TRUE)
651 Bcm_kill_all_URBs((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
652 } else {
653 Adapter->bPreparingForLowPowerMode = FALSE;
654 }
655
656 if (!NVMAccess)
657 up(&Adapter->NVMRdmWrmLock);
658
659 if (!lowPwrAbortMsg)
660 up(&Adapter->LowPowerModeSync);
661 }
662
663 status = CopyBufferToControlPacket(Adapter, &stIdleResponse);
664 if ((status != STATUS_SUCCESS)) {
665 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "fail to send the Idle mode Request\n");
666 Adapter->bPreparingForLowPowerMode = FALSE;
667 StartInterruptUrb((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
668 }
669 do_gettimeofday(&tv);
670 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);
671 }
672
673 /******************************************************************
674 * Function - DumpPackInfo()
675 *
676 * Description - This function dumps the all Queue(PackInfo[]) details.
677 *
678 * Parameters - Adapter: Pointer to the Adapter structure.
679 *
680 * Returns - None.
681 *******************************************************************/
DumpPackInfo(PMINI_ADAPTER Adapter)682 VOID DumpPackInfo(PMINI_ADAPTER Adapter)
683 {
684 UINT uiLoopIndex = 0;
685 UINT uiIndex = 0;
686 UINT uiClsfrIndex = 0;
687 S_CLASSIFIER_RULE *pstClassifierEntry = NULL;
688
689 for (uiLoopIndex = 0; uiLoopIndex < NO_OF_QUEUES; uiLoopIndex++) {
690 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "*********** Showing Details Of Queue %d***** ******", uiLoopIndex);
691 if (FALSE == Adapter->PackInfo[uiLoopIndex].bValid) {
692 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bValid is FALSE for %X index\n", uiLoopIndex);
693 continue;
694 }
695
696 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, " Dumping SF Rule Entry For SFID %lX\n", Adapter->PackInfo[uiLoopIndex].ulSFID);
697 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, " ucDirection %X\n", Adapter->PackInfo[uiLoopIndex].ucDirection);
698
699 if (Adapter->PackInfo[uiLoopIndex].ucIpVersion == IPV6)
700 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Ipv6 Service Flow\n");
701 else
702 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Ipv4 Service Flow\n");
703
704 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "SF Traffic Priority %X\n", Adapter->PackInfo[uiLoopIndex].u8TrafficPriority);
705
706 for (uiClsfrIndex = 0; uiClsfrIndex < MAX_CLASSIFIERS; uiClsfrIndex++) {
707 pstClassifierEntry = &Adapter->astClassifierTable[uiClsfrIndex];
708 if (!pstClassifierEntry->bUsed)
709 continue;
710
711 if (pstClassifierEntry->ulSFID != Adapter->PackInfo[uiLoopIndex].ulSFID)
712 continue;
713
714 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);
715 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);
716 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);
717 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);
718 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);
719 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);
720
721 for (uiIndex = 0; uiIndex < MAX_PORT_RANGE; uiIndex++) {
722 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusSrcPortRangeLo:%X\n", pstClassifierEntry->usSrcPortRangeLo[uiIndex]);
723 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusSrcPortRangeHi:%X\n", pstClassifierEntry->usSrcPortRangeHi[uiIndex]);
724 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusDestPortRangeLo:%X\n", pstClassifierEntry->usDestPortRangeLo[uiIndex]);
725 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tusDestPortRangeHi:%X\n", pstClassifierEntry->usDestPortRangeHi[uiIndex]);
726 }
727
728 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tucIPSourceAddressLength : 0x%x\n", pstClassifierEntry->ucIPSourceAddressLength);
729 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tucIPDestinationAddressLength : 0x%x\n", pstClassifierEntry->ucIPDestinationAddressLength);
730 for (uiIndex = 0; uiIndex < pstClassifierEntry->ucIPSourceAddressLength; uiIndex++) {
731 if (Adapter->PackInfo[uiLoopIndex].ucIpVersion == IPV6) {
732 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulSrcIpAddr :\n");
733 DumpIpv6Address(pstClassifierEntry->stSrcIpAddress.ulIpv6Addr);
734 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulSrcIpMask :\n");
735 DumpIpv6Address(pstClassifierEntry->stSrcIpAddress.ulIpv6Mask);
736 } else {
737 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulSrcIpAddr:%lX\n", pstClassifierEntry->stSrcIpAddress.ulIpv4Addr[uiIndex]);
738 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulSrcIpMask:%lX\n", pstClassifierEntry->stSrcIpAddress.ulIpv4Mask[uiIndex]);
739 }
740 }
741
742 for (uiIndex = 0; uiIndex < pstClassifierEntry->ucIPDestinationAddressLength; uiIndex++) {
743 if (Adapter->PackInfo[uiLoopIndex].ucIpVersion == IPV6) {
744 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulDestIpAddr :\n");
745 DumpIpv6Address(pstClassifierEntry->stDestIpAddress.ulIpv6Addr);
746 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tIpv6 ulDestIpMask :\n");
747 DumpIpv6Address(pstClassifierEntry->stDestIpAddress.ulIpv6Mask);
748 } else {
749 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulDestIpAddr:%lX\n", pstClassifierEntry->stDestIpAddress.ulIpv4Addr[uiIndex]);
750 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tulDestIpMask:%lX\n", pstClassifierEntry->stDestIpAddress.ulIpv4Mask[uiIndex]);
751 }
752 }
753 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tucProtocol:0x%X\n", pstClassifierEntry->ucProtocol[0]);
754 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "\tu8ClassifierRulePriority:%X\n", pstClassifierEntry->u8ClassifierRulePriority);
755 }
756 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ulSFID:%lX\n", Adapter->PackInfo[uiLoopIndex].ulSFID);
757 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "usVCID_Value:%X\n", Adapter->PackInfo[uiLoopIndex].usVCID_Value);
758 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "PhsEnabled: 0x%X\n", Adapter->PackInfo[uiLoopIndex].bHeaderSuppressionEnabled);
759 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiThreshold:%X\n", Adapter->PackInfo[uiLoopIndex].uiThreshold);
760
761 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bValid:%X\n", Adapter->PackInfo[uiLoopIndex].bValid);
762 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bActive:%X\n", Adapter->PackInfo[uiLoopIndex].bActive);
763 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ActivateReqSent: %x", Adapter->PackInfo[uiLoopIndex].bActivateRequestSent);
764 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "u8QueueType:%X\n", Adapter->PackInfo[uiLoopIndex].u8QueueType);
765 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiMaxBucketSize:%X\n", Adapter->PackInfo[uiLoopIndex].uiMaxBucketSize);
766 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiPerSFTxResourceCount:%X\n", atomic_read(&Adapter->PackInfo[uiLoopIndex].uiPerSFTxResourceCount));
767 /* DumpDebug(DUMP_INFO,("bCSSupport:%X\n",Adapter->PackInfo[uiLoopIndex].bCSSupport)); */
768 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "CurrQueueDepthOnTarget: %x\n", Adapter->PackInfo[uiLoopIndex].uiCurrentQueueDepthOnTarget);
769 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentBytesOnHost:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentBytesOnHost);
770 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentPacketsOnHost:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentPacketsOnHost);
771 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiDroppedCountBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiDroppedCountBytes);
772 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiDroppedCountPackets:%X\n", Adapter->PackInfo[uiLoopIndex].uiDroppedCountPackets);
773 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiSentBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiSentBytes);
774 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiSentPackets:%X\n", Adapter->PackInfo[uiLoopIndex].uiSentPackets);
775 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentDrainRate:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentDrainRate);
776 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiThisPeriodSentBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiThisPeriodSentBytes);
777 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "liDrainCalculated:%llX\n", Adapter->PackInfo[uiLoopIndex].liDrainCalculated);
778 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiCurrentTokenCount:%X\n", Adapter->PackInfo[uiLoopIndex].uiCurrentTokenCount);
779 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "liLastUpdateTokenAt:%llX\n", Adapter->PackInfo[uiLoopIndex].liLastUpdateTokenAt);
780 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiMaxAllowedRate:%X\n", Adapter->PackInfo[uiLoopIndex].uiMaxAllowedRate);
781 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiPendedLast:%X\n", Adapter->PackInfo[uiLoopIndex].uiPendedLast);
782 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "NumOfPacketsSent:%X\n", Adapter->PackInfo[uiLoopIndex].NumOfPacketsSent);
783 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Direction: %x\n", Adapter->PackInfo[uiLoopIndex].ucDirection);
784 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "CID: %x\n", Adapter->PackInfo[uiLoopIndex].usCID);
785 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ProtocolValid: %x\n", Adapter->PackInfo[uiLoopIndex].bProtocolValid);
786 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "TOSValid: %x\n", Adapter->PackInfo[uiLoopIndex].bTOSValid);
787 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "DestIpValid: %x\n", Adapter->PackInfo[uiLoopIndex].bDestIpValid);
788 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "SrcIpValid: %x\n", Adapter->PackInfo[uiLoopIndex].bSrcIpValid);
789 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ActiveSet: %x\n", Adapter->PackInfo[uiLoopIndex].bActiveSet);
790 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "AdmittedSet: %x\n", Adapter->PackInfo[uiLoopIndex].bAdmittedSet);
791 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "AuthzSet: %x\n", Adapter->PackInfo[uiLoopIndex].bAuthorizedSet);
792 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "ClassifyPrority: %x\n", Adapter->PackInfo[uiLoopIndex].bClassifierPriority);
793 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiMaxLatency: %x\n", Adapter->PackInfo[uiLoopIndex].uiMaxLatency);
794 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]);
795 /* BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "bHeaderSuppressionEnabled :%X\n", Adapter->PackInfo[uiLoopIndex].bHeaderSuppressionEnabled);
796 * BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiTotalTxBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiTotalTxBytes);
797 * BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "uiTotalRxBytes:%X\n", Adapter->PackInfo[uiLoopIndex].uiTotalRxBytes);
798 * DumpDebug(DUMP_INFO,(" uiRanOutOfResCount:%X\n",Adapter->PackInfo[uiLoopIndex].uiRanOutOfResCount));
799 */
800 }
801
802 for (uiLoopIndex = 0; uiLoopIndex < MIBS_MAX_HIST_ENTRIES; uiLoopIndex++)
803 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Adapter->aRxPktSizeHist[%x] = %x\n", uiLoopIndex, Adapter->aRxPktSizeHist[uiLoopIndex]);
804
805 for (uiLoopIndex = 0; uiLoopIndex < MIBS_MAX_HIST_ENTRIES; uiLoopIndex++)
806 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, DUMP_INFO, DBG_LVL_ALL, "Adapter->aTxPktSizeHist[%x] = %x\n", uiLoopIndex, Adapter->aTxPktSizeHist[uiLoopIndex]);
807
808 return;
809 }
810
reset_card_proc(PMINI_ADAPTER ps_adapter)811 int reset_card_proc(PMINI_ADAPTER ps_adapter)
812 {
813 int retval = STATUS_SUCCESS;
814 PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
815 PS_INTERFACE_ADAPTER psIntfAdapter = NULL;
816 unsigned int value = 0, uiResetValue = 0;
817 int bytes;
818
819 psIntfAdapter = ((PS_INTERFACE_ADAPTER)(ps_adapter->pvInterfaceAdapter));
820 ps_adapter->bDDRInitDone = FALSE;
821
822 if (ps_adapter->chip_id >= T3LPB) {
823 /* SYS_CFG register is write protected hence for modifying this reg value, it should be read twice before */
824 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
825 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
826
827 /* making bit[6...5] same as was before f/w download. this setting force the h/w to */
828 /* re-populated the SP RAM area with the string descriptor. */
829 value = value | (ps_adapter->syscfgBefFwDld & 0x00000060);
830 wrmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
831 }
832
833 /* killing all submitted URBs. */
834 psIntfAdapter->psAdapter->StopAllXaction = TRUE;
835 Bcm_kill_all_URBs(psIntfAdapter);
836 /* Reset the UMA-B Device */
837 if (ps_adapter->chip_id >= T3LPB) {
838 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reseting UMA-B\n");
839 retval = usb_reset_device(psIntfAdapter->udev);
840 psIntfAdapter->psAdapter->StopAllXaction = FALSE;
841
842 if (retval != STATUS_SUCCESS) {
843 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Reset failed with ret value :%d", retval);
844 goto err_exit;
845 }
846
847 if (ps_adapter->chip_id == BCS220_2 ||
848 ps_adapter->chip_id == BCS220_2BC ||
849 ps_adapter->chip_id == BCS250_BC ||
850 ps_adapter->chip_id == BCS220_3) {
851
852 bytes = rdmalt(ps_adapter, HPM_CONFIG_LDO145, &value, sizeof(value));
853 if (bytes < 0) {
854 retval = bytes;
855 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "read failed with status :%d", retval);
856 goto err_exit;
857 }
858 /* setting 0th bit */
859 value |= (1<<0);
860 retval = wrmalt(ps_adapter, HPM_CONFIG_LDO145, &value, sizeof(value));
861 if (retval < 0) {
862 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
863 goto err_exit;
864 }
865 }
866 } else {
867 bytes = rdmalt(ps_adapter, 0x0f007018, &value, sizeof(value));
868 if (bytes < 0) {
869 retval = bytes;
870 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "read failed with status :%d", retval);
871 goto err_exit;
872 }
873 value &= (~(1<<16));
874 retval = wrmalt(ps_adapter, 0x0f007018, &value, sizeof(value));
875 if (retval < 0) {
876 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
877 goto err_exit;
878 }
879
880 /* Toggling the GPIO 8, 9 */
881 value = 0;
882 retval = wrmalt(ps_adapter, GPIO_OUTPUT_REGISTER, &value, sizeof(value));
883 if (retval < 0) {
884 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
885 goto err_exit;
886 }
887 value = 0x300;
888 retval = wrmalt(ps_adapter, GPIO_MODE_REGISTER, &value, sizeof(value));
889 if (retval < 0) {
890 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "write failed with status :%d", retval);
891 goto err_exit;
892 }
893 mdelay(50);
894 }
895
896 /* ps_adapter->downloadDDR = false; */
897 if (ps_adapter->bFlashBoot) {
898 /* In flash boot mode MIPS state register has reverse polarity.
899 * So just or with setting bit 30.
900 * Make the MIPS in Reset state.
901 */
902 rdmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &uiResetValue, sizeof(uiResetValue));
903 uiResetValue |= (1<<30);
904 wrmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &uiResetValue, sizeof(uiResetValue));
905 }
906
907 if (ps_adapter->chip_id >= T3LPB) {
908 uiResetValue = 0;
909 /*
910 * WA for SYSConfig Issue.
911 * Read SYSCFG Twice to make it writable.
912 */
913 rdmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue));
914 if (uiResetValue & (1<<4)) {
915 uiResetValue = 0;
916 rdmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue)); /* 2nd read to make it writable. */
917 uiResetValue &= (~(1<<4));
918 wrmalt(ps_adapter, SYS_CFG, &uiResetValue, sizeof(uiResetValue));
919 }
920 }
921 uiResetValue = 0;
922 wrmalt(ps_adapter, 0x0f01186c, &uiResetValue, sizeof(uiResetValue));
923
924 err_exit:
925 psIntfAdapter->psAdapter->StopAllXaction = FALSE;
926 return retval;
927 }
928
run_card_proc(PMINI_ADAPTER ps_adapter)929 int run_card_proc(PMINI_ADAPTER ps_adapter)
930 {
931 int status = STATUS_SUCCESS;
932 int bytes;
933
934 unsigned int value = 0;
935 {
936 bytes = rdmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &value, sizeof(value));
937 if (bytes < 0) {
938 status = bytes;
939 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "%s:%d\n", __func__, __LINE__);
940 return status;
941 }
942
943 if (ps_adapter->bFlashBoot)
944 value &= (~(1<<30));
945 else
946 value |= (1<<30);
947
948 if (wrmalt(ps_adapter, CLOCK_RESET_CNTRL_REG_1, &value, sizeof(value)) < 0) {
949 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "%s:%d\n", __func__, __LINE__);
950 return STATUS_FAILURE;
951 }
952 }
953 return status;
954 }
955
InitCardAndDownloadFirmware(PMINI_ADAPTER ps_adapter)956 int InitCardAndDownloadFirmware(PMINI_ADAPTER ps_adapter)
957 {
958 int status;
959 UINT value = 0;
960 /*
961 * Create the threads first and then download the
962 * Firm/DDR Settings..
963 */
964 status = create_worker_threads(ps_adapter);
965 if (status < 0)
966 return status;
967
968 status = bcm_parse_target_params(ps_adapter);
969 if (status)
970 return status;
971
972 if (ps_adapter->chip_id >= T3LPB) {
973 rdmalt(ps_adapter, SYS_CFG, &value, sizeof(value));
974 ps_adapter->syscfgBefFwDld = value;
975
976 if ((value & 0x60) == 0)
977 ps_adapter->bFlashBoot = TRUE;
978 }
979
980 reset_card_proc(ps_adapter);
981
982 /* Initializing the NVM. */
983 BcmInitNVM(ps_adapter);
984 status = ddr_init(ps_adapter);
985 if (status) {
986 pr_err(DRV_NAME "ddr_init Failed\n");
987 return status;
988 }
989
990 /* Download cfg file */
991 status = buffDnldVerify(ps_adapter,
992 (PUCHAR)ps_adapter->pstargetparams,
993 sizeof(STARGETPARAMS),
994 CONFIG_BEGIN_ADDR);
995 if (status) {
996 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Error downloading CFG file");
997 goto OUT;
998 }
999
1000 if (register_networkdev(ps_adapter)) {
1001 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Register Netdevice failed. Cleanup needs to be performed.");
1002 return -EIO;
1003 }
1004
1005 if (FALSE == ps_adapter->AutoFirmDld) {
1006 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "AutoFirmDld Disabled in CFG File..\n");
1007 /* If Auto f/w download is disable, register the control interface, */
1008 /* register the control interface after the mailbox. */
1009 if (register_control_device_interface(ps_adapter) < 0) {
1010 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Register Control Device failed. Cleanup needs to be performed.");
1011 return -EIO;
1012 }
1013 return STATUS_SUCCESS;
1014 }
1015
1016 /*
1017 * Do the LED Settings here. It will be used by the Firmware Download
1018 * Thread.
1019 */
1020
1021 /*
1022 * 1. If the LED Settings fails, do not stop and do the Firmware download.
1023 * 2. This init would happened only if the cfg file is present, else
1024 * call from the ioctl context.
1025 */
1026
1027 status = InitLedSettings(ps_adapter);
1028 if (status) {
1029 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_PRINTK, 0, 0, "INIT LED FAILED\n");
1030 return status;
1031 }
1032
1033 if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1034 ps_adapter->DriverState = DRIVER_INIT;
1035 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1036 }
1037
1038 if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1039 ps_adapter->DriverState = FW_DOWNLOAD;
1040 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1041 }
1042
1043 value = 0;
1044 wrmalt(ps_adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 4, &value, sizeof(value));
1045 wrmalt(ps_adapter, EEPROM_CAL_DATA_INTERNAL_LOC - 8, &value, sizeof(value));
1046
1047 if (ps_adapter->eNVMType == NVM_FLASH) {
1048 status = PropagateCalParamsFromFlashToMemory(ps_adapter);
1049 if (status) {
1050 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Propagation of Cal param failed ..");
1051 goto OUT;
1052 }
1053 }
1054
1055 /* Download Firmare */
1056 status = BcmFileDownload(ps_adapter, BIN_FILE, FIRMWARE_BEGIN_ADDR);
1057 if (status != 0) {
1058 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "No Firmware File is present...\n");
1059 goto OUT;
1060 }
1061
1062 status = run_card_proc(ps_adapter);
1063 if (status) {
1064 BCM_DEBUG_PRINT(ps_adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "run_card_proc Failed\n");
1065 goto OUT;
1066 }
1067
1068 ps_adapter->fw_download_done = TRUE;
1069 mdelay(10);
1070
1071 OUT:
1072 if (ps_adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1073 ps_adapter->DriverState = FW_DOWNLOAD_DONE;
1074 wake_up(&ps_adapter->LEDInfo.notify_led_event);
1075 }
1076
1077 return status;
1078 }
1079
bcm_parse_target_params(PMINI_ADAPTER Adapter)1080 static int bcm_parse_target_params(PMINI_ADAPTER Adapter)
1081 {
1082 struct file *flp = NULL;
1083 mm_segment_t oldfs = {0};
1084 char *buff;
1085 int len = 0;
1086 loff_t pos = 0;
1087
1088 buff = kmalloc(BUFFER_1K, GFP_KERNEL);
1089 if (!buff)
1090 return -ENOMEM;
1091
1092 Adapter->pstargetparams = kmalloc(sizeof(STARGETPARAMS), GFP_KERNEL);
1093 if (Adapter->pstargetparams == NULL) {
1094 kfree(buff);
1095 return -ENOMEM;
1096 }
1097
1098 flp = open_firmware_file(Adapter, CFG_FILE);
1099 if (!flp) {
1100 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "NOT ABLE TO OPEN THE %s FILE\n", CFG_FILE);
1101 kfree(buff);
1102 kfree(Adapter->pstargetparams);
1103 Adapter->pstargetparams = NULL;
1104 return -ENOENT;
1105 }
1106 oldfs = get_fs();
1107 set_fs(get_ds());
1108 len = vfs_read(flp, (void __user __force *)buff, BUFFER_1K, &pos);
1109 set_fs(oldfs);
1110
1111 if (len != sizeof(STARGETPARAMS)) {
1112 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Mismatch in Target Param Structure!\n");
1113 kfree(buff);
1114 kfree(Adapter->pstargetparams);
1115 Adapter->pstargetparams = NULL;
1116 filp_close(flp, current->files);
1117 return -ENOENT;
1118 }
1119 filp_close(flp, current->files);
1120
1121 /* Check for autolink in config params */
1122 /*
1123 * Values in Adapter->pstargetparams are in network byte order
1124 */
1125 memcpy(Adapter->pstargetparams, buff, sizeof(STARGETPARAMS));
1126 kfree(buff);
1127 beceem_parse_target_struct(Adapter);
1128 return STATUS_SUCCESS;
1129 }
1130
beceem_parse_target_struct(PMINI_ADAPTER Adapter)1131 void beceem_parse_target_struct(PMINI_ADAPTER Adapter)
1132 {
1133 UINT uiHostDrvrCfg6 = 0, uiEEPROMFlag = 0;
1134
1135 if (ntohl(Adapter->pstargetparams->m_u32PhyParameter2) & AUTO_SYNC_DISABLE) {
1136 pr_info(DRV_NAME ": AutoSyncup is Disabled\n");
1137 Adapter->AutoSyncup = FALSE;
1138 } else {
1139 pr_info(DRV_NAME ": AutoSyncup is Enabled\n");
1140 Adapter->AutoSyncup = TRUE;
1141 }
1142
1143 if (ntohl(Adapter->pstargetparams->HostDrvrConfig6) & AUTO_LINKUP_ENABLE) {
1144 pr_info(DRV_NAME ": Enabling autolink up");
1145 Adapter->AutoLinkUp = TRUE;
1146 } else {
1147 pr_info(DRV_NAME ": Disabling autolink up");
1148 Adapter->AutoLinkUp = FALSE;
1149 }
1150 /* Setting the DDR Setting.. */
1151 Adapter->DDRSetting = (ntohl(Adapter->pstargetparams->HostDrvrConfig6) >> 8)&0x0F;
1152 Adapter->ulPowerSaveMode = (ntohl(Adapter->pstargetparams->HostDrvrConfig6)>>12)&0x0F;
1153 pr_info(DRV_NAME ": DDR Setting: %x\n", Adapter->DDRSetting);
1154 pr_info(DRV_NAME ": Power Save Mode: %lx\n", Adapter->ulPowerSaveMode);
1155 if (ntohl(Adapter->pstargetparams->HostDrvrConfig6) & AUTO_FIRM_DOWNLOAD) {
1156 pr_info(DRV_NAME ": Enabling Auto Firmware Download\n");
1157 Adapter->AutoFirmDld = TRUE;
1158 } else {
1159 pr_info(DRV_NAME ": Disabling Auto Firmware Download\n");
1160 Adapter->AutoFirmDld = FALSE;
1161 }
1162 uiHostDrvrCfg6 = ntohl(Adapter->pstargetparams->HostDrvrConfig6);
1163 Adapter->bMipsConfig = (uiHostDrvrCfg6>>20)&0x01;
1164 pr_info(DRV_NAME ": MIPSConfig : 0x%X\n", Adapter->bMipsConfig);
1165 /* used for backward compatibility. */
1166 Adapter->bDPLLConfig = (uiHostDrvrCfg6>>19)&0x01;
1167 Adapter->PmuMode = (uiHostDrvrCfg6 >> 24) & 0x03;
1168 pr_info(DRV_NAME ": PMU MODE: %x", Adapter->PmuMode);
1169
1170 if ((uiHostDrvrCfg6 >> HOST_BUS_SUSPEND_BIT) & (0x01)) {
1171 Adapter->bDoSuspend = TRUE;
1172 pr_info(DRV_NAME ": Making DoSuspend TRUE as per configFile");
1173 }
1174
1175 uiEEPROMFlag = ntohl(Adapter->pstargetparams->m_u32EEPROMFlag);
1176 pr_info(DRV_NAME ": uiEEPROMFlag : 0x%X\n", uiEEPROMFlag);
1177 Adapter->eNVMType = (NVM_TYPE)((uiEEPROMFlag>>4)&0x3);
1178 Adapter->bStatusWrite = (uiEEPROMFlag>>6)&0x1;
1179 Adapter->uiSectorSizeInCFG = 1024*(0xFFFF & ntohl(Adapter->pstargetparams->HostDrvrConfig4));
1180 Adapter->bSectorSizeOverride = (bool) ((ntohl(Adapter->pstargetparams->HostDrvrConfig4))>>16)&0x1;
1181
1182 if (ntohl(Adapter->pstargetparams->m_u32PowerSavingModeOptions) & 0x01)
1183 Adapter->ulPowerSaveMode = DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE;
1184
1185 if (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE)
1186 doPowerAutoCorrection(Adapter);
1187 }
1188
doPowerAutoCorrection(PMINI_ADAPTER psAdapter)1189 static VOID doPowerAutoCorrection(PMINI_ADAPTER psAdapter)
1190 {
1191 UINT reporting_mode;
1192
1193 reporting_mode = ntohl(psAdapter->pstargetparams->m_u32PowerSavingModeOptions) & 0x02;
1194 psAdapter->bIsAutoCorrectEnabled = !((char)(psAdapter->ulPowerSaveMode >> 3) & 0x1);
1195
1196 if (reporting_mode == TRUE) {
1197 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "can't do suspen/resume as reporting mode is enable");
1198 psAdapter->bDoSuspend = FALSE;
1199 }
1200
1201 if (psAdapter->bIsAutoCorrectEnabled && (psAdapter->chip_id >= T3LPB)) {
1202 /* If reporting mode is enable, switch PMU to PMC */
1203 {
1204 psAdapter->ulPowerSaveMode = DEVICE_POWERSAVE_MODE_AS_PMU_CLOCK_GATING;
1205 psAdapter->bDoSuspend = FALSE;
1206 }
1207
1208 /* clearing space bit[15..12] */
1209 psAdapter->pstargetparams->HostDrvrConfig6 &= ~(htonl((0xF << 12)));
1210 /* placing the power save mode option */
1211 psAdapter->pstargetparams->HostDrvrConfig6 |= htonl((psAdapter->ulPowerSaveMode << 12));
1212 } else if (psAdapter->bIsAutoCorrectEnabled == FALSE) {
1213 /* remove the autocorrect disable bit set before dumping. */
1214 psAdapter->ulPowerSaveMode &= ~(1 << 3);
1215 psAdapter->pstargetparams->HostDrvrConfig6 &= ~(htonl(1 << 15));
1216 BCM_DEBUG_PRINT(psAdapter, DBG_TYPE_INITEXIT, MP_INIT, DBG_LVL_ALL, "Using Forced User Choice: %lx\n", psAdapter->ulPowerSaveMode);
1217 }
1218 }
1219
1220 #if 0
1221 static unsigned char *ReadMacAddrEEPROM(PMINI_ADAPTER Adapter, ulong dwAddress)
1222 {
1223 int status = 0, i = 0;
1224 unsigned int temp = 0;
1225 unsigned char *pucmacaddr = kmalloc(MAC_ADDRESS_SIZE, GFP_KERNEL);
1226 int bytes;
1227
1228 if (!pucmacaddr) {
1229 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "No Buffers to Read the EEPROM Address\n");
1230 return NULL;
1231 }
1232
1233 dwAddress |= 0x5b000000;
1234 status = wrmalt(Adapter, EEPROM_COMMAND_Q_REG, (PUINT)&dwAddress, sizeof(UINT));
1235 if (status != STATUS_SUCCESS) {
1236 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "wrm Failed..\n");
1237 kfree(pucmacaddr);
1238 pucmacaddr = NULL;
1239 goto OUT;
1240 }
1241
1242 for (i = 0; i < MAC_ADDRESS_SIZE; i++) {
1243 bytes = rdmalt(Adapter, EEPROM_READ_DATA_Q_REG, &temp, sizeof(temp));
1244 if (bytes < 0) {
1245 status = bytes;
1246 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "rdm Failed..\n");
1247 kfree(pucmacaddr);
1248 pucmacaddr = NULL;
1249 goto OUT;
1250 }
1251 pucmacaddr[i] = temp & 0xff;
1252 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "%x\n", pucmacaddr[i]);
1253 }
1254 OUT:
1255 return pucmacaddr;
1256 }
1257 #endif
1258
convertEndian(B_UINT8 rwFlag,PUINT puiBuffer,UINT uiByteCount)1259 static void convertEndian(B_UINT8 rwFlag, PUINT puiBuffer, UINT uiByteCount)
1260 {
1261 UINT uiIndex = 0;
1262
1263 if (RWM_WRITE == rwFlag) {
1264 for (uiIndex = 0; uiIndex < (uiByteCount/sizeof(UINT)); uiIndex++)
1265 puiBuffer[uiIndex] = htonl(puiBuffer[uiIndex]);
1266 } else {
1267 for (uiIndex = 0; uiIndex < (uiByteCount/sizeof(UINT)); uiIndex++)
1268 puiBuffer[uiIndex] = ntohl(puiBuffer[uiIndex]);
1269 }
1270 }
1271
1272 #define CACHE_ADDRESS_MASK 0x80000000
1273 #define UNCACHE_ADDRESS_MASK 0xa0000000
1274
rdm(PMINI_ADAPTER Adapter,UINT uiAddress,PCHAR pucBuff,size_t sSize)1275 int rdm(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
1276 {
1277 return Adapter->interface_rdm(Adapter->pvInterfaceAdapter,
1278 uiAddress, pucBuff, sSize);
1279 }
1280
wrm(PMINI_ADAPTER Adapter,UINT uiAddress,PCHAR pucBuff,size_t sSize)1281 int wrm(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
1282 {
1283 int iRetVal;
1284
1285 iRetVal = Adapter->interface_wrm(Adapter->pvInterfaceAdapter,
1286 uiAddress, pucBuff, sSize);
1287 return iRetVal;
1288 }
1289
wrmalt(PMINI_ADAPTER Adapter,UINT uiAddress,PUINT pucBuff,size_t size)1290 int wrmalt(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1291 {
1292 convertEndian(RWM_WRITE, pucBuff, size);
1293 return wrm(Adapter, uiAddress, (PUCHAR)pucBuff, size);
1294 }
1295
rdmalt(PMINI_ADAPTER Adapter,UINT uiAddress,PUINT pucBuff,size_t size)1296 int rdmalt(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1297 {
1298 INT uiRetVal = 0;
1299
1300 uiRetVal = rdm(Adapter, uiAddress, (PUCHAR)pucBuff, size);
1301 convertEndian(RWM_READ, (PUINT)pucBuff, size);
1302
1303 return uiRetVal;
1304 }
1305
wrmWithLock(PMINI_ADAPTER Adapter,UINT uiAddress,PCHAR pucBuff,size_t sSize)1306 int wrmWithLock(PMINI_ADAPTER Adapter, UINT uiAddress, PCHAR pucBuff, size_t sSize)
1307 {
1308 INT status = STATUS_SUCCESS;
1309 down(&Adapter->rdmwrmsync);
1310
1311 if ((Adapter->IdleMode == TRUE) ||
1312 (Adapter->bShutStatus == TRUE) ||
1313 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1314
1315 status = -EACCES;
1316 goto exit;
1317 }
1318
1319 status = wrm(Adapter, uiAddress, pucBuff, sSize);
1320 exit:
1321 up(&Adapter->rdmwrmsync);
1322 return status;
1323 }
1324
wrmaltWithLock(PMINI_ADAPTER Adapter,UINT uiAddress,PUINT pucBuff,size_t size)1325 int wrmaltWithLock(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1326 {
1327 int iRetVal = STATUS_SUCCESS;
1328
1329 down(&Adapter->rdmwrmsync);
1330
1331 if ((Adapter->IdleMode == TRUE) ||
1332 (Adapter->bShutStatus == TRUE) ||
1333 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1334
1335 iRetVal = -EACCES;
1336 goto exit;
1337 }
1338
1339 iRetVal = wrmalt(Adapter, uiAddress, pucBuff, size);
1340 exit:
1341 up(&Adapter->rdmwrmsync);
1342 return iRetVal;
1343 }
1344
rdmaltWithLock(PMINI_ADAPTER Adapter,UINT uiAddress,PUINT pucBuff,size_t size)1345 int rdmaltWithLock(PMINI_ADAPTER Adapter, UINT uiAddress, PUINT pucBuff, size_t size)
1346 {
1347 INT uiRetVal = STATUS_SUCCESS;
1348
1349 down(&Adapter->rdmwrmsync);
1350 if ((Adapter->IdleMode == TRUE) ||
1351 (Adapter->bShutStatus == TRUE) ||
1352 (Adapter->bPreparingForLowPowerMode == TRUE)) {
1353
1354 uiRetVal = -EACCES;
1355 goto exit;
1356 }
1357
1358 uiRetVal = rdmalt(Adapter, uiAddress, pucBuff, size);
1359 exit:
1360 up(&Adapter->rdmwrmsync);
1361 return uiRetVal;
1362 }
1363
HandleShutDownModeWakeup(PMINI_ADAPTER Adapter)1364 static VOID HandleShutDownModeWakeup(PMINI_ADAPTER Adapter)
1365 {
1366 int clear_abort_pattern = 0, Status = 0;
1367 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "====>\n");
1368 /* target has woken up From Shut Down */
1369 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Clearing Shut Down Software abort pattern\n");
1370 Status = wrmalt(Adapter, SW_ABORT_IDLEMODE_LOC, (PUINT)&clear_abort_pattern, sizeof(clear_abort_pattern));
1371 if (Status) {
1372 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "WRM to SW_ABORT_IDLEMODE_LOC failed with err:%d", Status);
1373 return;
1374 }
1375
1376 if (Adapter->ulPowerSaveMode != DEVICE_POWERSAVE_MODE_AS_PROTOCOL_IDLE_MODE) {
1377 msleep(100);
1378 InterfaceHandleShutdownModeWakeup(Adapter);
1379 msleep(100);
1380 }
1381
1382 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1383 Adapter->DriverState = NO_NETWORK_ENTRY;
1384 wake_up(&Adapter->LEDInfo.notify_led_event);
1385 }
1386
1387 Adapter->bTriedToWakeUpFromlowPowerMode = FALSE;
1388 Adapter->bShutStatus = FALSE;
1389 wake_up(&Adapter->lowpower_mode_wait_queue);
1390 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "<====\n");
1391 }
1392
SendShutModeResponse(PMINI_ADAPTER Adapter)1393 static VOID SendShutModeResponse(PMINI_ADAPTER Adapter)
1394 {
1395 CONTROL_MESSAGE stShutdownResponse;
1396 UINT NVMAccess = 0, lowPwrAbortMsg = 0;
1397 UINT Status = 0;
1398
1399 memset(&stShutdownResponse, 0, sizeof(CONTROL_MESSAGE));
1400 stShutdownResponse.Leader.Status = LINK_UP_CONTROL_REQ;
1401 stShutdownResponse.Leader.PLength = 8; /* 8 bytes; */
1402 stShutdownResponse.szData[0] = LINK_UP_ACK;
1403 stShutdownResponse.szData[1] = LINK_SHUTDOWN_REQ_FROM_FIRMWARE;
1404
1405 /*********************************
1406 * down_trylock -
1407 * if [ semaphore is available ]
1408 * acquire semaphone and return value 0 ;
1409 * else
1410 * return non-zero value ;
1411 *
1412 ***********************************/
1413
1414 NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
1415 lowPwrAbortMsg = down_trylock(&Adapter->LowPowerModeSync);
1416
1417 if (NVMAccess || lowPwrAbortMsg || atomic_read(&Adapter->TotalPacketCount)) {
1418 if (!NVMAccess)
1419 up(&Adapter->NVMRdmWrmLock);
1420
1421 if (!lowPwrAbortMsg)
1422 up(&Adapter->LowPowerModeSync);
1423
1424 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Device Access is going on NACK the Shut Down MODE\n");
1425 stShutdownResponse.szData[2] = SHUTDOWN_NACK_FROM_DRIVER; /* NACK- device access is going on. */
1426 Adapter->bPreparingForLowPowerMode = FALSE;
1427 } else {
1428 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "Sending SHUTDOWN MODE ACK\n");
1429 stShutdownResponse.szData[2] = SHUTDOWN_ACK_FROM_DRIVER; /* ShutDown ACK */
1430
1431 /* Wait for the LED to TURN OFF before sending ACK response */
1432 if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
1433 INT iRetVal = 0;
1434
1435 /* Wake the LED Thread with LOWPOWER_MODE_ENTER State */
1436 Adapter->DriverState = LOWPOWER_MODE_ENTER;
1437 wake_up(&Adapter->LEDInfo.notify_led_event);
1438
1439 /* Wait for 1 SEC for LED to OFF */
1440 iRetVal = wait_event_timeout(Adapter->LEDInfo.idleModeSyncEvent, Adapter->LEDInfo.bIdle_led_off, msecs_to_jiffies(1000));
1441
1442 /* If Timed Out to Sync IDLE MODE Enter, do IDLE mode Exit and Send NACK to device */
1443 if (iRetVal <= 0) {
1444 stShutdownResponse.szData[1] = SHUTDOWN_NACK_FROM_DRIVER; /* NACK- device access is going on. */
1445 Adapter->DriverState = NO_NETWORK_ENTRY;
1446 wake_up(&Adapter->LEDInfo.notify_led_event);
1447 }
1448 }
1449
1450 if (stShutdownResponse.szData[2] == SHUTDOWN_ACK_FROM_DRIVER) {
1451 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "ACKING SHUTDOWN MODE !!!!!!!!!");
1452 down(&Adapter->rdmwrmsync);
1453 Adapter->bPreparingForLowPowerMode = TRUE;
1454 up(&Adapter->rdmwrmsync);
1455 /* Killing all URBS. */
1456 if (Adapter->bDoSuspend == TRUE)
1457 Bcm_kill_all_URBs((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
1458 } else {
1459 Adapter->bPreparingForLowPowerMode = FALSE;
1460 }
1461
1462 if (!NVMAccess)
1463 up(&Adapter->NVMRdmWrmLock);
1464
1465 if (!lowPwrAbortMsg)
1466 up(&Adapter->LowPowerModeSync);
1467 }
1468
1469 Status = CopyBufferToControlPacket(Adapter, &stShutdownResponse);
1470 if ((Status != STATUS_SUCCESS)) {
1471 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "fail to send the Idle mode Request\n");
1472 Adapter->bPreparingForLowPowerMode = FALSE;
1473 StartInterruptUrb((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
1474 }
1475 }
1476
HandleShutDownModeRequest(PMINI_ADAPTER Adapter,PUCHAR pucBuffer)1477 static void HandleShutDownModeRequest(PMINI_ADAPTER Adapter, PUCHAR pucBuffer)
1478 {
1479 B_UINT32 uiResetValue = 0;
1480
1481 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "====>\n");
1482
1483 if (*(pucBuffer+1) == COMPLETE_WAKE_UP_NOTIFICATION_FRM_FW) {
1484 HandleShutDownModeWakeup(Adapter);
1485 } else if (*(pucBuffer+1) == LINK_SHUTDOWN_REQ_FROM_FIRMWARE) {
1486 /* Target wants to go to Shut Down Mode */
1487 /* InterfacePrepareForShutdown(Adapter); */
1488 if (Adapter->chip_id == BCS220_2 ||
1489 Adapter->chip_id == BCS220_2BC ||
1490 Adapter->chip_id == BCS250_BC ||
1491 Adapter->chip_id == BCS220_3) {
1492
1493 rdmalt(Adapter, HPM_CONFIG_MSW, &uiResetValue, 4);
1494 uiResetValue |= (1<<17);
1495 wrmalt(Adapter, HPM_CONFIG_MSW, &uiResetValue, 4);
1496 }
1497
1498 SendShutModeResponse(Adapter);
1499 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "ShutDownModeResponse:Notification received: Sending the response(Ack/Nack)\n");
1500 }
1501
1502 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, MP_SHUTDOWN, DBG_LVL_ALL, "<====\n");
1503 return;
1504 }
1505
ResetCounters(PMINI_ADAPTER Adapter)1506 VOID ResetCounters(PMINI_ADAPTER Adapter)
1507 {
1508 beceem_protocol_reset(Adapter);
1509 Adapter->CurrNumRecvDescs = 0;
1510 Adapter->PrevNumRecvDescs = 0;
1511 Adapter->LinkUpStatus = 0;
1512 Adapter->LinkStatus = 0;
1513 atomic_set(&Adapter->cntrlpktCnt, 0);
1514 atomic_set(&Adapter->TotalPacketCount, 0);
1515 Adapter->fw_download_done = FALSE;
1516 Adapter->LinkStatus = 0;
1517 Adapter->AutoLinkUp = FALSE;
1518 Adapter->IdleMode = FALSE;
1519 Adapter->bShutStatus = FALSE;
1520 }
1521
GetFragIPClsEntry(PMINI_ADAPTER Adapter,USHORT usIpIdentification,ULONG SrcIP)1522 S_CLASSIFIER_RULE *GetFragIPClsEntry(PMINI_ADAPTER Adapter, USHORT usIpIdentification, ULONG SrcIP)
1523 {
1524 UINT uiIndex = 0;
1525 for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1526 if ((Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) &&
1527 (Adapter->astFragmentedPktClassifierTable[uiIndex].usIpIdentification == usIpIdentification) &&
1528 (Adapter->astFragmentedPktClassifierTable[uiIndex].ulSrcIpAddress == SrcIP) &&
1529 !Adapter->astFragmentedPktClassifierTable[uiIndex].bOutOfOrderFragment)
1530
1531 return Adapter->astFragmentedPktClassifierTable[uiIndex].pstMatchedClassifierEntry;
1532 }
1533 return NULL;
1534 }
1535
AddFragIPClsEntry(PMINI_ADAPTER Adapter,PS_FRAGMENTED_PACKET_INFO psFragPktInfo)1536 void AddFragIPClsEntry(PMINI_ADAPTER Adapter, PS_FRAGMENTED_PACKET_INFO psFragPktInfo)
1537 {
1538 UINT uiIndex = 0;
1539 for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1540 if (!Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) {
1541 memcpy(&Adapter->astFragmentedPktClassifierTable[uiIndex], psFragPktInfo, sizeof(S_FRAGMENTED_PACKET_INFO));
1542 break;
1543 }
1544 }
1545 }
1546
DelFragIPClsEntry(PMINI_ADAPTER Adapter,USHORT usIpIdentification,ULONG SrcIp)1547 void DelFragIPClsEntry(PMINI_ADAPTER Adapter, USHORT usIpIdentification, ULONG SrcIp)
1548 {
1549 UINT uiIndex = 0;
1550 for (uiIndex = 0; uiIndex < MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES; uiIndex++) {
1551 if ((Adapter->astFragmentedPktClassifierTable[uiIndex].bUsed) &&
1552 (Adapter->astFragmentedPktClassifierTable[uiIndex].usIpIdentification == usIpIdentification) &&
1553 (Adapter->astFragmentedPktClassifierTable[uiIndex].ulSrcIpAddress == SrcIp))
1554
1555 memset(&Adapter->astFragmentedPktClassifierTable[uiIndex], 0, sizeof(S_FRAGMENTED_PACKET_INFO));
1556 }
1557 }
1558
update_per_cid_rx(PMINI_ADAPTER Adapter)1559 void update_per_cid_rx(PMINI_ADAPTER Adapter)
1560 {
1561 UINT qindex = 0;
1562
1563 if ((jiffies - Adapter->liDrainCalculated) < XSECONDS)
1564 return;
1565
1566 for (qindex = 0; qindex < HiPriority; qindex++) {
1567 if (Adapter->PackInfo[qindex].ucDirection == 0) {
1568 Adapter->PackInfo[qindex].uiCurrentRxRate =
1569 (Adapter->PackInfo[qindex].uiCurrentRxRate +
1570 Adapter->PackInfo[qindex].uiThisPeriodRxBytes) / 2;
1571
1572 Adapter->PackInfo[qindex].uiThisPeriodRxBytes = 0;
1573 } else {
1574 Adapter->PackInfo[qindex].uiCurrentDrainRate =
1575 (Adapter->PackInfo[qindex].uiCurrentDrainRate +
1576 Adapter->PackInfo[qindex].uiThisPeriodSentBytes) / 2;
1577 Adapter->PackInfo[qindex].uiThisPeriodSentBytes = 0;
1578 }
1579 }
1580 Adapter->liDrainCalculated = jiffies;
1581 }
1582
update_per_sf_desc_cnts(PMINI_ADAPTER Adapter)1583 void update_per_sf_desc_cnts(PMINI_ADAPTER Adapter)
1584 {
1585 INT iIndex = 0;
1586 u32 uibuff[MAX_TARGET_DSX_BUFFERS];
1587 int bytes;
1588
1589 if (!atomic_read(&Adapter->uiMBupdate))
1590 return;
1591
1592 bytes = rdmaltWithLock(Adapter, TARGET_SFID_TXDESC_MAP_LOC, (PUINT)uibuff, sizeof(UINT) * MAX_TARGET_DSX_BUFFERS);
1593 if (bytes < 0) {
1594 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "rdm failed\n");
1595 return;
1596 }
1597
1598 for (iIndex = 0; iIndex < HiPriority; iIndex++) {
1599 if (Adapter->PackInfo[iIndex].bValid && Adapter->PackInfo[iIndex].ucDirection) {
1600 if (Adapter->PackInfo[iIndex].usVCID_Value < MAX_TARGET_DSX_BUFFERS)
1601 atomic_set(&Adapter->PackInfo[iIndex].uiPerSFTxResourceCount, uibuff[Adapter->PackInfo[iIndex].usVCID_Value]);
1602 else
1603 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Invalid VCID : %x\n", Adapter->PackInfo[iIndex].usVCID_Value);
1604 }
1605 }
1606 atomic_set(&Adapter->uiMBupdate, FALSE);
1607 }
1608
flush_queue(PMINI_ADAPTER Adapter,UINT iQIndex)1609 void flush_queue(PMINI_ADAPTER Adapter, UINT iQIndex)
1610 {
1611 struct sk_buff *PacketToDrop = NULL;
1612 struct net_device_stats *netstats = &Adapter->dev->stats;
1613 spin_lock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
1614
1615 while (Adapter->PackInfo[iQIndex].FirstTxQueue && atomic_read(&Adapter->TotalPacketCount)) {
1616 PacketToDrop = Adapter->PackInfo[iQIndex].FirstTxQueue;
1617 if (PacketToDrop && PacketToDrop->len) {
1618 netstats->tx_dropped++;
1619 DEQUEUEPACKET(Adapter->PackInfo[iQIndex].FirstTxQueue, Adapter->PackInfo[iQIndex].LastTxQueue);
1620 Adapter->PackInfo[iQIndex].uiCurrentPacketsOnHost--;
1621 Adapter->PackInfo[iQIndex].uiCurrentBytesOnHost -= PacketToDrop->len;
1622
1623 /* Adding dropped statistics */
1624 Adapter->PackInfo[iQIndex].uiDroppedCountBytes += PacketToDrop->len;
1625 Adapter->PackInfo[iQIndex].uiDroppedCountPackets++;
1626 dev_kfree_skb(PacketToDrop);
1627 atomic_dec(&Adapter->TotalPacketCount);
1628 }
1629 }
1630 spin_unlock_bh(&Adapter->PackInfo[iQIndex].SFQueueLock);
1631 }
1632
beceem_protocol_reset(PMINI_ADAPTER Adapter)1633 static void beceem_protocol_reset(PMINI_ADAPTER Adapter)
1634 {
1635 int i;
1636 if (netif_msg_link(Adapter))
1637 pr_notice(PFX "%s: protocol reset\n", Adapter->dev->name);
1638
1639 netif_carrier_off(Adapter->dev);
1640 netif_stop_queue(Adapter->dev);
1641
1642 Adapter->IdleMode = FALSE;
1643 Adapter->LinkUpStatus = FALSE;
1644 ClearTargetDSXBuffer(Adapter, 0, TRUE);
1645 /* Delete All Classifier Rules */
1646
1647 for (i = 0; i < HiPriority; i++)
1648 DeleteAllClassifiersForSF(Adapter, i);
1649
1650 flush_all_queues(Adapter);
1651
1652 if (Adapter->TimerActive == TRUE)
1653 Adapter->TimerActive = FALSE;
1654
1655 memset(Adapter->astFragmentedPktClassifierTable, 0, sizeof(S_FRAGMENTED_PACKET_INFO) * MAX_FRAGMENTEDIP_CLASSIFICATION_ENTRIES);
1656
1657 for (i = 0; i < HiPriority; i++) {
1658 /* resetting only the first size (S_MIBS_SERVICEFLOW_TABLE) for the SF. */
1659 /* It is same between MIBs and SF. */
1660 memset(&Adapter->PackInfo[i].stMibsExtServiceFlowTable, 0, sizeof(S_MIBS_EXTSERVICEFLOW_PARAMETERS));
1661 }
1662 }
1663