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