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