2 /***************************************************************
3 * Function - bcm_char_open()
5 * Description - This is the "open" entry point for the character
8 * Parameters - inode: Pointer to the Inode structure of char device
9 * filp : File pointer of the char device
11 * Returns - Zero(Success)
12 ****************************************************************/
13 static struct class *bcm_class = NULL;
14 static int bcm_char_open(struct inode *inode, struct file * filp)
16 PMINI_ADAPTER Adapter = NULL;
17 PPER_TARANG_DATA pTarang = NULL;
19 Adapter = GET_BCM_ADAPTER(gblpnetdev);
20 pTarang = (PPER_TARANG_DATA)kmalloc(sizeof(PER_TARANG_DATA), GFP_KERNEL);
24 memset (pTarang, 0, sizeof(PER_TARANG_DATA));
25 pTarang->Adapter = Adapter;
26 pTarang->RxCntrlMsgBitMask = 0xFFFFFFFF & ~(1 << 0xB) ;
28 down(&Adapter->RxAppControlQueuelock);
29 pTarang->next = Adapter->pTarangs;
30 Adapter->pTarangs = pTarang;
31 up(&Adapter->RxAppControlQueuelock);
33 /* Store the Adapter structure */
34 filp->private_data = pTarang;
36 /*Start Queuing the control response Packets*/
37 atomic_inc(&Adapter->ApplicationRunning);
40 static int bcm_char_release(struct inode *inode, struct file *filp)
42 PPER_TARANG_DATA pTarang, tmp, ptmp;
43 PMINI_ADAPTER Adapter=NULL;
44 struct sk_buff * pkt, * npkt;
46 pTarang = (PPER_TARANG_DATA)filp->private_data;
50 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "ptarang is null\n");
54 Adapter = pTarang->Adapter;
56 down( &Adapter->RxAppControlQueuelock);
58 tmp = Adapter->pTarangs;
59 for ( ptmp = NULL; tmp; ptmp = tmp, tmp = tmp->next )
68 Adapter->pTarangs = tmp->next;
70 ptmp->next = tmp->next;
75 up( &Adapter->RxAppControlQueuelock);
79 pkt = pTarang->RxAppControlHead;
87 up( &Adapter->RxAppControlQueuelock);
89 /*Stop Queuing the control response Packets*/
90 atomic_dec(&Adapter->ApplicationRunning);
94 /* remove this filp from the asynchronously notified filp's */
95 filp->private_data = NULL;
99 static int bcm_char_read(struct file *filp, PCHAR buf, size_t size, loff_t *f_pos)
101 PPER_TARANG_DATA pTarang = (PPER_TARANG_DATA)filp->private_data;
102 PMINI_ADAPTER Adapter = pTarang->Adapter;
103 struct sk_buff* Packet = NULL;
107 wait_ret_val = wait_event_interruptible(Adapter->process_read_wait_queue,
108 (pTarang->RxAppControlHead || Adapter->device_removed));
109 if((wait_ret_val == -ERESTARTSYS))
111 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Exiting as i've been asked to exit!!!\n");
115 if(Adapter->device_removed)
117 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device Removed... Killing the Apps...\n");
121 if(FALSE == Adapter->fw_download_done)
124 down( &Adapter->RxAppControlQueuelock);
126 if(pTarang->RxAppControlHead)
128 Packet = pTarang->RxAppControlHead;
129 DEQUEUEPACKET(pTarang->RxAppControlHead,pTarang->RxAppControlTail);
130 pTarang->AppCtrlQueueLen--;
133 up(&Adapter->RxAppControlQueuelock);
137 PktLen = Packet->len;
138 if(copy_to_user(buf, Packet->data, PktLen))
140 bcm_kfree_skb(Packet);
141 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "\nReturning from copy to user failure \n");
144 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Read %d Bytes From Adapter packet = 0x%p by process %d!\n", PktLen, Packet, current->pid);
145 bcm_kfree_skb(Packet);
148 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "<====\n");
152 static INT bcm_char_ioctl(struct inode *inode, struct file *filp,
155 PPER_TARANG_DATA pTarang = (PPER_TARANG_DATA)filp->private_data;
156 PMINI_ADAPTER Adapter = pTarang->Adapter;
157 INT Status = STATUS_FAILURE;
158 IOCTL_BUFFER IoBuffer={0};
159 #ifndef BCM_SHM_INTERFACE
164 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Parameters Passed to control IOCTL cmd=0x%X arg=0x%lX", cmd, arg);
166 if(_IOC_TYPE(cmd) != BCM_IOCTL)
168 if(_IOC_DIR(cmd) & _IOC_READ)
169 Status = !access_ok(VERIFY_WRITE, (PVOID)arg, _IOC_SIZE(cmd));
170 else if (_IOC_DIR(cmd) & _IOC_WRITE)
171 Status = !access_ok(VERIFY_READ, (PVOID)arg, _IOC_SIZE(cmd));
172 else if (_IOC_NONE == (_IOC_DIR(cmd) & _IOC_NONE))
173 Status = STATUS_SUCCESS;
178 if(Adapter->device_removed)
183 if(FALSE == Adapter->fw_download_done)
187 case IOCTL_MAC_ADDR_REQ:
189 case IOCTL_CM_REQUEST:
190 case IOCTL_SS_INFO_REQ:
191 case IOCTL_SEND_CONTROL_MESSAGE:
193 case IOCTL_BCM_GPIO_SET_REQUEST:
194 case IOCTL_BCM_GPIO_STATUS_REQUEST:
201 Status = vendorextnIoctl(Adapter, cmd, arg);
202 if(Status != CONTINUE_COMMON_PATH )
208 // Rdms for Swin Idle...
209 case IOCTL_BCM_REGISTER_READ_PRIVATE:
211 RDM_BUFFER sRdmBuffer = {0};
212 PCHAR temp_buff = NULL;
214 /* Copy Ioctl Buffer structure */
215 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
216 sizeof(IOCTL_BUFFER)))
222 Bufflen = IoBuffer.OutputLength + (4 - IoBuffer.OutputLength%4)%4;
223 temp_buff = (PCHAR)kmalloc(Bufflen, GFP_KERNEL);
226 return STATUS_FAILURE;
228 if(copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer,
229 IoBuffer.InputLength))
234 Status = rdmalt(Adapter, (UINT)sRdmBuffer.Register,
235 (PUINT)temp_buff, Bufflen);
236 if(Status != STATUS_SUCCESS)
238 bcm_kfree(temp_buff);
241 if(copy_to_user((PCHAR)IoBuffer.OutputBuffer,
242 (PCHAR)temp_buff, (UINT)IoBuffer.OutputLength))
246 bcm_kfree(temp_buff);
249 case IOCTL_BCM_REGISTER_WRITE_PRIVATE:
251 WRM_BUFFER sWrmBuffer = {0};
253 /* Copy Ioctl Buffer structure */
255 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
256 sizeof(IOCTL_BUFFER)))
261 /* Get WrmBuffer structure */
262 if(copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer,
263 IoBuffer.InputLength))
268 uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK;
269 if(!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) &&
270 ((uiTempVar == EEPROM_REJECT_REG_1)||
271 (uiTempVar == EEPROM_REJECT_REG_2) ||
272 (uiTempVar == EEPROM_REJECT_REG_3) ||
273 (uiTempVar == EEPROM_REJECT_REG_4)))
275 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
279 Status = wrmalt(Adapter, (UINT)sWrmBuffer.Register,
280 (PUINT)sWrmBuffer.Data, sizeof(ULONG));
281 if(Status == STATUS_SUCCESS)
283 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"WRM Done\n");
287 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
293 case IOCTL_BCM_REGISTER_READ:
294 case IOCTL_BCM_EEPROM_REGISTER_READ:
296 RDM_BUFFER sRdmBuffer = {0};
297 PCHAR temp_buff = NULL;
299 if((Adapter->IdleMode == TRUE) ||
300 (Adapter->bShutStatus ==TRUE) ||
301 (Adapter->bPreparingForLowPowerMode ==TRUE))
303 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Rdms\n");
307 /* Copy Ioctl Buffer structure */
308 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
309 sizeof(IOCTL_BUFFER)))
315 temp_buff = (PCHAR)kmalloc(IoBuffer.OutputLength, GFP_KERNEL);
318 return STATUS_FAILURE;
320 if(copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer,
321 IoBuffer.InputLength))
328 #if !defined(BCM_SHM_INTERFACE)
329 (((ULONG)sRdmBuffer.Register & 0x0F000000) != 0x0F000000) ||
331 ((ULONG)sRdmBuffer.Register & 0x3)
334 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "RDM Done On invalid Address : %x Access Denied.\n",
335 (int)sRdmBuffer.Register);
340 uiTempVar = sRdmBuffer.Register & EEPROM_REJECT_MASK;
341 Status = rdmaltWithLock(Adapter, (UINT)sRdmBuffer.Register,
342 (PUINT)temp_buff, IoBuffer.OutputLength);
343 if(Status != STATUS_SUCCESS)
345 bcm_kfree(temp_buff);
348 if(copy_to_user((PCHAR)IoBuffer.OutputBuffer,
349 (PCHAR)temp_buff, (UINT)IoBuffer.OutputLength))
353 bcm_kfree(temp_buff);
356 case IOCTL_BCM_REGISTER_WRITE:
357 case IOCTL_BCM_EEPROM_REGISTER_WRITE:
359 WRM_BUFFER sWrmBuffer = {0};
361 if((Adapter->IdleMode == TRUE) ||
362 (Adapter->bShutStatus ==TRUE) ||
363 (Adapter->bPreparingForLowPowerMode ==TRUE))
365 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Wrms\n");
369 /* Copy Ioctl Buffer structure */
370 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
371 sizeof(IOCTL_BUFFER)))
376 /* Get WrmBuffer structure */
377 if(copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer,
378 IoBuffer.InputLength))
384 #if !defined(BCM_SHM_INTERFACE)
386 (((ULONG)sWrmBuffer.Register & 0x0F000000) != 0x0F000000) ||
388 ((ULONG)sWrmBuffer.Register & 0x3)
391 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Done On invalid Address : %x Access Denied.\n",
392 (int)sWrmBuffer.Register);
396 uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK;
397 if(!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) &&
398 ((uiTempVar == EEPROM_REJECT_REG_1)||
399 (uiTempVar == EEPROM_REJECT_REG_2) ||
400 (uiTempVar == EEPROM_REJECT_REG_3) ||
401 (uiTempVar == EEPROM_REJECT_REG_4)) &&
402 (cmd == IOCTL_BCM_REGISTER_WRITE))
404 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
409 Status = wrmaltWithLock(Adapter, (UINT)sWrmBuffer.Register,
410 (PUINT)sWrmBuffer.Data, sWrmBuffer.Length);
411 if(Status == STATUS_SUCCESS)
413 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "WRM Done\n");
417 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
422 case IOCTL_BCM_GPIO_SET_REQUEST:
424 UCHAR ucResetValue[4];
427 UINT uiOperation = 0;
429 GPIO_INFO gpio_info = {0};
430 if((Adapter->IdleMode == TRUE) ||
431 (Adapter->bShutStatus ==TRUE) ||
432 (Adapter->bPreparingForLowPowerMode ==TRUE))
434 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO Can't be set/clear in Low power Mode");
438 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
443 if(copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
448 uiBit = gpio_info.uiGpioNumber;
449 uiOperation = gpio_info.uiGpioValue;
453 if(IsReqGpioIsLedInNVM(Adapter,value) ==FALSE)
455 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to LED !!!",value);
461 if(uiOperation)//Set - setting 1
463 //Set the gpio output register
464 Status = wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_SET_REG ,
465 (PUINT)(&value), sizeof(UINT));
466 if(Status == STATUS_SUCCESS)
468 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Set the GPIO bit\n");
472 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Failed to set the %dth GPIO \n",uiBit);
476 else//Unset - setting 0
478 //Set the gpio output register
479 Status = wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_CLR_REG ,
480 (PUINT)(&value), sizeof(UINT));
481 if(Status == STATUS_SUCCESS)
483 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Set the GPIO bit\n");
487 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Failed to clear the %dth GPIO \n",uiBit);
492 Status = rdmaltWithLock(Adapter, (UINT)GPIO_MODE_REGISTER,
493 (PUINT)ucResetValue, sizeof(UINT));
494 if (STATUS_SUCCESS != Status)
496 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO_MODE_REGISTER read failed");
499 //Set the gpio mode register to output
500 *(UINT*)ucResetValue |= (1<<uiBit);
501 Status = wrmaltWithLock(Adapter,GPIO_MODE_REGISTER ,
502 (PUINT)ucResetValue, sizeof(UINT));
503 if(Status == STATUS_SUCCESS)
505 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Set the GPIO to output Mode\n");
509 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Failed to put GPIO in Output Mode\n");
514 case BCM_LED_THREAD_STATE_CHANGE_REQ:
517 USER_THREAD_REQ threadReq = {0};
518 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"User made LED thread InActive");
520 if((Adapter->IdleMode == TRUE) ||
521 (Adapter->bShutStatus ==TRUE) ||
522 (Adapter->bPreparingForLowPowerMode ==TRUE))
524 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO Can't be set/clear in Low power Mode");
528 Status =copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
531 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
535 Status= copy_from_user(&threadReq, IoBuffer.InputBuffer, IoBuffer.InputLength);
538 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the InputBuffer from user space err:%d",Status);
541 //if LED thread is running(Actively or Inactively) set it state to make inactive
542 if(Adapter->LEDInfo.led_thread_running)
544 if(threadReq.ThreadState == LED_THREAD_ACTIVATION_REQ)
546 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Activating thread req");
547 Adapter->DriverState = LED_THREAD_ACTIVE;
551 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DeActivating Thread req.....");
552 Adapter->DriverState = LED_THREAD_INACTIVE;
556 wake_up(&Adapter->LEDInfo.notify_led_event);
561 case IOCTL_BCM_GPIO_STATUS_REQUEST:
565 GPIO_INFO gpio_info = {0};
566 if((Adapter->IdleMode == TRUE) ||
567 (Adapter->bShutStatus ==TRUE) ||
568 (Adapter->bPreparingForLowPowerMode ==TRUE))
573 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
578 if(copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
583 uiBit = gpio_info.uiGpioNumber;
584 //Set the gpio output register
585 Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER,
586 (PUINT)ucRead, sizeof(UINT));
587 if(Status != STATUS_SUCCESS)
589 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "RDM Failed\n");
595 case IOCTL_BCM_GPIO_MULTI_REQUEST:
597 UCHAR ucResetValue[4];
598 GPIO_MULTI_INFO gpio_multi_info[MAX_IDX];
599 PGPIO_MULTI_INFO pgpio_multi_info = (PGPIO_MULTI_INFO)gpio_multi_info;
601 memset( pgpio_multi_info, 0, MAX_IDX * sizeof( GPIO_MULTI_INFO));
603 if((Adapter->IdleMode == TRUE) ||
604 (Adapter->bShutStatus ==TRUE) ||
605 (Adapter->bPreparingForLowPowerMode ==TRUE))
610 Status = copy_from_user( (PCHAR)&IoBuffer, ( PCHAR)arg, sizeof( IOCTL_BUFFER));
613 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
617 Status = copy_from_user( &gpio_multi_info, IoBuffer.InputBuffer, IoBuffer.InputLength);
620 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer Contents from user space err:%d",Status);
623 if(IsReqGpioIsLedInNVM(Adapter,pgpio_multi_info[WIMAX_IDX].uiGPIOMask)== FALSE)
625 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to NVM LED bit map<0x%X>!!!",pgpio_multi_info[WIMAX_IDX].uiGPIOMask,Adapter->gpioBitMap);
630 /* Set the gpio output register */
632 if( ( pgpio_multi_info[WIMAX_IDX].uiGPIOMask) &
633 ( pgpio_multi_info[WIMAX_IDX].uiGPIOCommand))
635 /* Set 1's in GPIO OUTPUT REGISTER */
636 *(UINT*) ucResetValue = pgpio_multi_info[WIMAX_IDX].uiGPIOMask &
637 pgpio_multi_info[WIMAX_IDX].uiGPIOCommand &
638 pgpio_multi_info[WIMAX_IDX].uiGPIOValue;
640 if( *(UINT*) ucResetValue)
641 Status = wrmaltWithLock( Adapter, BCM_GPIO_OUTPUT_SET_REG , (PUINT) ucResetValue, sizeof(ULONG));
643 if( Status != STATUS_SUCCESS)
645 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to BCM_GPIO_OUTPUT_SET_REG Failed.");
649 /* Clear to 0's in GPIO OUTPUT REGISTER */
650 *(UINT*) ucResetValue = (pgpio_multi_info[WIMAX_IDX].uiGPIOMask &
651 pgpio_multi_info[WIMAX_IDX].uiGPIOCommand &
652 ( ~( pgpio_multi_info[WIMAX_IDX].uiGPIOValue)));
654 if( *(UINT*) ucResetValue)
655 Status = wrmaltWithLock( Adapter, BCM_GPIO_OUTPUT_CLR_REG , (PUINT) ucResetValue, sizeof(ULONG));
657 if( Status != STATUS_SUCCESS)
659 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to BCM_GPIO_OUTPUT_CLR_REG Failed." );
664 if( pgpio_multi_info[WIMAX_IDX].uiGPIOMask)
666 Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER, (PUINT)ucResetValue, sizeof(UINT));
668 if(Status != STATUS_SUCCESS)
670 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"RDM to GPIO_PIN_STATE_REGISTER Failed.");
674 pgpio_multi_info[WIMAX_IDX].uiGPIOValue = ( *(UINT*)ucResetValue &
675 pgpio_multi_info[WIMAX_IDX].uiGPIOMask);
678 Status = copy_to_user( (PCHAR)IoBuffer.OutputBuffer, &gpio_multi_info, IoBuffer.OutputLength);
681 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying Content to IOBufer for user space err:%d",Status);
686 case IOCTL_BCM_GPIO_MODE_REQUEST:
688 UCHAR ucResetValue[4];
689 GPIO_MULTI_MODE gpio_multi_mode[MAX_IDX];
690 PGPIO_MULTI_MODE pgpio_multi_mode = ( PGPIO_MULTI_MODE) gpio_multi_mode;
692 if((Adapter->IdleMode == TRUE) ||
693 (Adapter->bShutStatus ==TRUE) ||
694 (Adapter->bPreparingForLowPowerMode ==TRUE))
699 Status = copy_from_user( (PCHAR)&IoBuffer, ( PCHAR)arg, sizeof( IOCTL_BUFFER));
702 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
706 Status = copy_from_user( &gpio_multi_mode, IoBuffer.InputBuffer, IoBuffer.InputLength);
709 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer Contents from user space err:%d",Status);
713 Status = rdmaltWithLock( Adapter, ( UINT) GPIO_MODE_REGISTER, ( PUINT) ucResetValue, sizeof( UINT));
714 if( STATUS_SUCCESS != Status)
716 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Read of GPIO_MODE_REGISTER failed");
720 //Validating the request
721 if(IsReqGpioIsLedInNVM(Adapter,pgpio_multi_mode[WIMAX_IDX].uiGPIOMask)== FALSE)
723 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to NVM LED bit map<0x%X>!!!",pgpio_multi_mode[WIMAX_IDX].uiGPIOMask,Adapter->gpioBitMap);
728 if( pgpio_multi_mode[WIMAX_IDX].uiGPIOMask)
730 /* write all OUT's (1's) */
731 *( UINT*) ucResetValue |= ( pgpio_multi_mode[WIMAX_IDX].uiGPIOMode &
732 pgpio_multi_mode[WIMAX_IDX].uiGPIOMask);
733 /* write all IN's (0's) */
734 *( UINT*) ucResetValue &= ~( ( ~pgpio_multi_mode[WIMAX_IDX].uiGPIOMode) &
735 pgpio_multi_mode[WIMAX_IDX].uiGPIOMask);
737 /* Currently implemented return the modes of all GPIO's
738 * else needs to bit AND with mask
740 pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *(UINT*)ucResetValue;
742 Status = wrmaltWithLock( Adapter, GPIO_MODE_REGISTER , ( PUINT) ucResetValue, sizeof( ULONG));
743 if( Status == STATUS_SUCCESS)
745 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM to GPIO_MODE_REGISTER Done");
749 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to GPIO_MODE_REGISTER Failed");
754 else /* if uiGPIOMask is 0 then return mode register configuration */
756 pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *( UINT*) ucResetValue;
758 Status = copy_to_user( (PCHAR)IoBuffer.OutputBuffer, &gpio_multi_mode, IoBuffer.OutputLength);
761 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying Content to IOBufer for user space err:%d",Status);
767 case IOCTL_MAC_ADDR_REQ:
769 case IOCTL_CM_REQUEST:
770 case IOCTL_SS_INFO_REQ:
771 case IOCTL_SEND_CONTROL_MESSAGE:
775 /* Copy Ioctl Buffer structure */
776 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
777 sizeof(IOCTL_BUFFER)))
782 pvBuffer=kmalloc(IoBuffer.InputLength, GFP_KERNEL);
788 if(copy_from_user(pvBuffer, IoBuffer.InputBuffer,
789 IoBuffer.InputLength))
796 down(&Adapter->LowPowerModeSync);
797 Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue,
798 !Adapter->bPreparingForLowPowerMode,
800 if(Status == -ERESTARTSYS)
803 if(Adapter->bPreparingForLowPowerMode)
805 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Preparing Idle Mode is still True - Hence Rejecting control message\n");
806 Status = STATUS_FAILURE ;
809 Status = CopyBufferToControlPacket(Adapter, (PVOID)pvBuffer);
811 up(&Adapter->LowPowerModeSync);
815 #ifndef BCM_SHM_INTERFACE
816 case IOCTL_BCM_BUFFER_DOWNLOAD_START:
818 INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock) ;
821 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
824 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
825 if(!down_trylock(&Adapter->fw_download_sema))
827 Adapter->bBinDownloaded=FALSE;
828 Adapter->fw_download_process_pid=current->pid;
829 Adapter->bCfgDownloaded=FALSE;
830 Adapter->fw_download_done=FALSE;
831 netif_carrier_off(Adapter->dev);
832 netif_stop_queue(Adapter->dev);
833 Status = reset_card_proc(Adapter);
836 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "reset_card_proc Failed!\n");
837 up(&Adapter->fw_download_sema);
838 up(&Adapter->NVMRdmWrmLock);
849 up(&Adapter->NVMRdmWrmLock);
852 case IOCTL_BCM_BUFFER_DOWNLOAD:
854 FIRMWARE_INFO *psFwInfo=NULL;
855 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
857 if(!down_trylock(&Adapter->fw_download_sema))
859 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid way to download buffer. Use Start and then call this!!!\n");
863 /* Copy Ioctl Buffer structure */
864 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
865 sizeof(IOCTL_BUFFER)))
867 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
871 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Length for FW DLD is : %lx\n",
872 IoBuffer.InputLength);
873 psFwInfo=kmalloc(sizeof(*psFwInfo), GFP_KERNEL);
876 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Failed to allocate buffer!!!!\n");
880 if(copy_from_user(psFwInfo, IoBuffer.InputBuffer,
881 IoBuffer.InputLength))
883 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_from_user 2 failed\n");
888 if(!psFwInfo->pvMappedFirmwareAddress ||
889 (psFwInfo->u32FirmwareLength == 0))
891 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Something else is wrong %lu\n",
892 psFwInfo->u32FirmwareLength);
896 Status = bcm_ioctl_fw_download(Adapter, psFwInfo);
897 if(Status != STATUS_SUCCESS)
899 if(psFwInfo->u32StartingAddress==CONFIG_BEGIN_ADDR)
901 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "IOCTL: Configuration File Upload Failed\n");
905 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "IOCTL: Firmware File Upload Failed\n");
907 //up(&Adapter->fw_download_sema);
909 if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)
911 Adapter->DriverState = DRIVER_INIT;
912 Adapter->LEDInfo.bLedInitDone = FALSE;
913 wake_up(&Adapter->LEDInfo.notify_led_event);
919 if(Status != STATUS_SUCCESS)
920 up(&Adapter->fw_download_sema);
921 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "IOCTL: Firmware File Uploaded\n");
925 case IOCTL_BCM_BUFFER_DOWNLOAD_STOP:
927 INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
930 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " FW download blocked as EEPROM Read/Write is in progress\n");
931 up(&Adapter->fw_download_sema);
934 if(down_trylock(&Adapter->fw_download_sema))
936 Adapter->bBinDownloaded=TRUE;
937 Adapter->bCfgDownloaded=TRUE;
938 atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
939 atomic_set(&Adapter->RxRollOverCount, 0);
940 Adapter->CurrNumRecvDescs=0;
941 Adapter->downloadDDR = 0;
943 //setting the Mips to Run
944 Status = run_card_proc(Adapter);
947 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Firm Download Failed\n");
948 up(&Adapter->fw_download_sema);
949 up(&Adapter->NVMRdmWrmLock);
953 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Firm Download Over...\n");
955 /* Wait for MailBox Interrupt */
956 if(StartInterruptUrb((PS_INTERFACE_ADAPTER)Adapter->pvInterfaceAdapter))
958 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Unable to send interrupt...\n");
961 Adapter->waiting_to_fw_download_done = FALSE;
962 wait_event_timeout(Adapter->ioctl_fw_dnld_wait_queue,
963 Adapter->waiting_to_fw_download_done, timeout);
964 Adapter->fw_download_process_pid=INVALID_PID;
965 Adapter->fw_download_done=TRUE;
966 atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
967 Adapter->CurrNumRecvDescs = 0;
968 Adapter->PrevNumRecvDescs = 0;
969 atomic_set(&Adapter->cntrlpktCnt,0);
970 Adapter->LinkUpStatus = 0;
971 Adapter->LinkStatus = 0;
973 if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)
975 Adapter->DriverState = FW_DOWNLOAD_DONE;
976 wake_up(&Adapter->LEDInfo.notify_led_event);
988 up(&Adapter->fw_download_sema);
989 up(&Adapter->NVMRdmWrmLock);
993 case IOCTL_BE_BUCKET_SIZE:
994 Adapter->BEBucketSize = *(PULONG)arg;
995 Status = STATUS_SUCCESS;
998 case IOCTL_RTPS_BUCKET_SIZE:
999 Adapter->rtPSBucketSize = *(PULONG)arg;
1000 Status = STATUS_SUCCESS;
1002 case IOCTL_CHIP_RESET:
1004 INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
1007 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
1010 down(&Adapter->RxAppControlQueuelock);
1011 Status = reset_card_proc(Adapter);
1013 up(&Adapter->RxAppControlQueuelock);
1014 up(&Adapter->NVMRdmWrmLock);
1015 ResetCounters(Adapter);
1018 case IOCTL_QOS_THRESHOLD:
1021 for(uiLoopIndex = 0 ; uiLoopIndex < NO_OF_QUEUES ; uiLoopIndex++)
1023 Adapter->PackInfo[uiLoopIndex].uiThreshold = *(PULONG)arg;
1025 Status = STATUS_SUCCESS;
1029 case IOCTL_DUMP_PACKET_INFO:
1031 DumpPackInfo(Adapter);
1032 DumpPhsRules(&Adapter->stBCMPhsContext);
1033 Status = STATUS_SUCCESS;
1036 case IOCTL_GET_PACK_INFO:
1037 if(copy_to_user((PCHAR)arg, &Adapter->PackInfo,
1038 sizeof(PacketInfo)*NO_OF_QUEUES))
1043 Status = STATUS_SUCCESS;
1045 case IOCTL_BCM_SWITCH_TRANSFER_MODE:
1048 if(copy_from_user(&uiData, (PUINT)arg, sizeof(UINT)))
1053 if(uiData) /* Allow All Packets */
1055 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: ETH_PACKET_TUNNELING_MODE\n");
1056 Adapter->TransferMode = ETH_PACKET_TUNNELING_MODE;
1058 else /* Allow IP only Packets */
1060 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: IP_PACKET_ONLY_MODE\n");
1061 Adapter->TransferMode = IP_PACKET_ONLY_MODE;
1063 Status = STATUS_SUCCESS;
1067 case IOCTL_BCM_GET_DRIVER_VERSION:
1069 /* Copy Ioctl Buffer structure */
1070 if(copy_from_user((PCHAR)&IoBuffer,
1071 (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1076 if(copy_to_user((PUCHAR)IoBuffer.OutputBuffer,
1077 VER_FILEVERSION_STR, (UINT)IoBuffer.OutputLength))
1082 Status = STATUS_SUCCESS;
1085 case IOCTL_BCM_GET_CURRENT_STATUS:
1087 LINK_STATE *plink_state = NULL;
1088 /* Copy Ioctl Buffer structure */
1089 if(copy_from_user((PCHAR)&IoBuffer,
1090 (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1092 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user failed..\n");
1096 plink_state = (LINK_STATE*)arg;
1097 plink_state->bIdleMode = (UCHAR)Adapter->IdleMode;
1098 plink_state->bShutdownMode = Adapter->bShutStatus;
1099 plink_state->ucLinkStatus = (UCHAR)Adapter->LinkStatus;
1100 if(copy_to_user((PUCHAR)IoBuffer.OutputBuffer,
1101 (PUCHAR)plink_state, (UINT)IoBuffer.OutputLength))
1103 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_to_user Failed..\n");
1107 Status = STATUS_SUCCESS;
1110 case IOCTL_BCM_SET_MAC_TRACING:
1113 /* copy ioctl Buffer structure */
1114 if(copy_from_user((PCHAR)&IoBuffer,
1115 (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1120 if(copy_from_user((PCHAR)&tracing_flag,
1121 (PCHAR)IoBuffer.InputBuffer,sizeof(UINT)))
1127 Adapter->pTarangs->MacTracingEnabled = TRUE;
1129 Adapter->pTarangs->MacTracingEnabled = FALSE;
1132 case IOCTL_BCM_GET_DSX_INDICATION:
1135 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
1136 sizeof(IOCTL_BUFFER)))
1138 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid IO buffer!!!" );
1142 if(IoBuffer.OutputLength < sizeof(stLocalSFAddIndicationAlt))
1144 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Mismatch req: %lx needed is =0x%x!!!",
1145 IoBuffer.OutputLength, sizeof(stLocalSFAddIndicationAlt));
1148 if(copy_from_user((PCHAR)&ulSFId, (PCHAR)IoBuffer.InputBuffer,
1151 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Invalid SFID!!! %lu", ulSFId );
1155 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Get DSX Data SF ID is =%lx\n", ulSFId );
1156 get_dsx_sf_data_to_application(Adapter, ulSFId,
1157 IoBuffer.OutputBuffer);
1158 Status=STATUS_SUCCESS;
1161 case IOCTL_BCM_GET_HOST_MIBS:
1165 if(copy_from_user((PCHAR)&IoBuffer,
1166 (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1168 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_from user for IoBuff failed\n");
1173 if(IoBuffer.OutputLength != sizeof(S_MIBS_HOST_STATS_MIBS))
1175 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Length Check failed %lu %d\n", IoBuffer.OutputLength,
1176 sizeof(S_MIBS_HOST_STATS_MIBS));
1180 temp_buff = (PCHAR)kmalloc(IoBuffer.OutputLength, GFP_KERNEL);
1184 return STATUS_FAILURE;
1187 Status = ProcessGetHostMibs(Adapter,
1188 (PUCHAR)temp_buff, IoBuffer.OutputLength);
1190 Status = GetDroppedAppCntrlPktMibs((PVOID)temp_buff,
1191 (PPER_TARANG_DATA)filp->private_data);
1193 if(copy_to_user((PCHAR)IoBuffer.OutputBuffer,(PCHAR)temp_buff,
1194 sizeof(S_MIBS_HOST_STATS_MIBS)))
1196 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy to user failed\n");
1197 bcm_kfree(temp_buff);
1201 bcm_kfree(temp_buff);
1205 case IOCTL_BCM_WAKE_UP_DEVICE_FROM_IDLE:
1206 if((FALSE == Adapter->bTriedToWakeUpFromlowPowerMode) && (TRUE==Adapter->IdleMode))
1208 Adapter->usIdleModePattern = ABORT_IDLE_MODE;
1209 Adapter->bWakeUpDevice = TRUE;
1210 wake_up(&Adapter->process_rx_cntrlpkt);
1212 Adapter->bTriedToWakeUpFromlowPowerMode = TRUE;
1213 InterfaceAbortIdlemode (Adapter, Adapter->usIdleModePattern);
1216 Status = STATUS_SUCCESS;
1219 case IOCTL_BCM_BULK_WRM:
1221 PBULKWRM_BUFFER pBulkBuffer;
1223 PCHAR pvBuffer = NULL;
1225 if((Adapter->IdleMode == TRUE) ||
1226 (Adapter->bShutStatus ==TRUE) ||
1227 (Adapter->bPreparingForLowPowerMode ==TRUE))
1229 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Device in Idle/Shutdown Mode, Blocking Wrms\n");
1233 /* Copy Ioctl Buffer structure */
1234 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1240 pvBuffer=kmalloc(IoBuffer.InputLength, GFP_KERNEL);
1247 /* Get WrmBuffer structure */
1248 if(copy_from_user(pvBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength))
1250 bcm_kfree(pvBuffer);
1255 pBulkBuffer = (PBULKWRM_BUFFER)pvBuffer;
1257 if(((ULONG)pBulkBuffer->Register & 0x0F000000) != 0x0F000000 ||
1258 ((ULONG)pBulkBuffer->Register & 0x3))
1260 bcm_kfree(pvBuffer);
1261 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"WRM Done On invalid Address : %x Access Denied.\n",(int)pBulkBuffer->Register);
1267 uiTempVar = pBulkBuffer->Register & EEPROM_REJECT_MASK;
1268 if(!((Adapter->pstargetparams->m_u32Customize)&VSG_MODE)
1269 && ((uiTempVar == EEPROM_REJECT_REG_1)||
1270 (uiTempVar == EEPROM_REJECT_REG_2) ||
1271 (uiTempVar == EEPROM_REJECT_REG_3) ||
1272 (uiTempVar == EEPROM_REJECT_REG_4)) &&
1273 (cmd == IOCTL_BCM_REGISTER_WRITE))
1275 bcm_kfree(pvBuffer);
1276 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"EEPROM Access Denied, not in VSG Mode\n");
1281 if(pBulkBuffer->SwapEndian == FALSE)
1282 Status = wrmWithLock(Adapter, (UINT)pBulkBuffer->Register, (PCHAR)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
1284 Status = wrmaltWithLock(Adapter, (UINT)pBulkBuffer->Register, (PUINT)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
1286 if(Status != STATUS_SUCCESS)
1288 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Failed\n");
1291 bcm_kfree(pvBuffer);
1295 case IOCTL_BCM_GET_NVM_SIZE:
1298 if(copy_from_user((unsigned char *)&IoBuffer,
1299 (unsigned char *)arg, sizeof(IOCTL_BUFFER)))
1301 //IOLog("failed NVM first");
1305 if(Adapter->eNVMType == NVM_EEPROM || Adapter->eNVMType == NVM_FLASH ) {
1306 if(copy_to_user(IoBuffer.OutputBuffer,
1307 (unsigned char *)&Adapter->uiNVMDSDSize, (UINT)sizeof(UINT)))
1314 Status = STATUS_SUCCESS ;
1318 case IOCTL_BCM_CAL_INIT :
1321 UINT uiSectorSize = 0 ;
1322 if(Adapter->eNVMType == NVM_FLASH)
1324 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1327 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy From User space failed. status :%d", Status);
1330 uiSectorSize = *((PUINT)(IoBuffer.InputBuffer));
1331 if((uiSectorSize < MIN_SECTOR_SIZE) || (uiSectorSize > MAX_SECTOR_SIZE))
1334 Status = copy_to_user(IoBuffer.OutputBuffer,
1335 (unsigned char *)&Adapter->uiSectorSize ,
1336 (UINT)sizeof(UINT));
1339 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Coping the sector size to use space failed. status:%d",Status);
1345 if(IsFlash2x(Adapter))
1347 Status = copy_to_user(IoBuffer.OutputBuffer,
1348 (unsigned char *)&Adapter->uiSectorSize ,
1349 (UINT)sizeof(UINT));
1352 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Coping the sector size to use space failed. status:%d",Status);
1359 if((TRUE == Adapter->bShutStatus) ||
1360 (TRUE == Adapter->IdleMode))
1362 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is in Idle/Shutdown Mode\n");
1366 Adapter->uiSectorSize = uiSectorSize ;
1367 BcmUpdateSectorSize(Adapter,Adapter->uiSectorSize);
1370 Status = STATUS_SUCCESS ;
1374 Status = STATUS_FAILURE;
1378 case IOCTL_BCM_SET_DEBUG :
1380 USER_BCM_DBG_STATE sUserDebugState;
1382 // BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Entered the ioctl %x \n", IOCTL_BCM_SET_DEBUG );
1384 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In SET_DEBUG ioctl\n");
1385 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1388 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy from user failed\n");
1391 Status = copy_from_user(&sUserDebugState,(USER_BCM_DBG_STATE *)IoBuffer.InputBuffer, sizeof(USER_BCM_DBG_STATE));
1394 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of IoBuffer.InputBuffer failed");
1398 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "IOCTL_BCM_SET_DEBUG: OnOff=%d Type = 0x%x ",
1399 sUserDebugState.OnOff, sUserDebugState.Type);
1400 //sUserDebugState.Subtype <<= 1;
1401 sUserDebugState.Subtype = 1 << sUserDebugState.Subtype;
1402 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "actual Subtype=0x%x\n", sUserDebugState.Subtype);
1404 // Update new 'DebugState' in the Adapter
1405 Adapter->stDebugState.type |= sUserDebugState.Type;
1406 /* Subtype: A bitmap of 32 bits for Subtype per Type.
1407 * Valid indexes in 'subtype' array: 1,2,4,8
1408 * corresponding to valid Type values. Hence we can use the 'Type' field
1409 * as the index value, ignoring the array entries 0,3,5,6,7 !
1411 if (sUserDebugState.OnOff)
1412 Adapter->stDebugState.subtype[sUserDebugState.Type] |= sUserDebugState.Subtype;
1414 Adapter->stDebugState.subtype[sUserDebugState.Type] &= ~sUserDebugState.Subtype;
1416 BCM_SHOW_DEBUG_BITMAP(Adapter);
1420 case IOCTL_BCM_NVM_READ:
1421 case IOCTL_BCM_NVM_WRITE:
1424 NVM_READWRITE stNVMReadWrite = {0};
1425 PUCHAR pReadData = NULL;
1426 PUCHAR pBuffertobeCopied = NULL;
1427 ULONG ulDSDMagicNumInUsrBuff = 0 ;
1428 struct timeval tv0, tv1;
1429 memset(&tv0,0,sizeof(struct timeval));
1430 memset(&tv1,0,sizeof(struct timeval));
1431 if((Adapter->eNVMType == NVM_FLASH) && (Adapter->uiFlashLayoutMajorVersion == 0))
1433 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,"The Flash Control Section is Corrupted. Hence Rejection on NVM Read/Write\n");
1438 if(IsFlash2x(Adapter))
1440 if((Adapter->eActiveDSD != DSD0) &&
1441 (Adapter->eActiveDSD != DSD1) &&
1442 (Adapter->eActiveDSD != DSD2))
1444 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"No DSD is active..hence NVM Command is blocked");
1445 return STATUS_FAILURE ;
1449 /* Copy Ioctl Buffer structure */
1451 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1453 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copy_from_user failed\n");
1457 if(IOCTL_BCM_NVM_READ == cmd)
1458 pBuffertobeCopied = IoBuffer.OutputBuffer;
1460 pBuffertobeCopied = IoBuffer.InputBuffer;
1462 if(copy_from_user(&stNVMReadWrite, pBuffertobeCopied,sizeof(NVM_READWRITE)))
1469 // Deny the access if the offset crosses the cal area limit.
1471 if((stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) > Adapter->uiNVMDSDSize)
1473 //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Can't allow access beyond NVM Size: 0x%x 0x%x\n", stNVMReadWrite.uiOffset ,
1474 // stNVMReadWrite.uiNumBytes);
1475 Status = STATUS_FAILURE;
1479 pReadData =(PCHAR)kmalloc(stNVMReadWrite.uiNumBytes, GFP_KERNEL);
1484 memset(pReadData,0,stNVMReadWrite.uiNumBytes);
1486 if(copy_from_user(pReadData, stNVMReadWrite.pBuffer,
1487 stNVMReadWrite.uiNumBytes))
1490 bcm_kfree(pReadData);
1494 do_gettimeofday(&tv0);
1495 if(IOCTL_BCM_NVM_READ == cmd)
1497 down(&Adapter->NVMRdmWrmLock);
1499 if((Adapter->IdleMode == TRUE) ||
1500 (Adapter->bShutStatus ==TRUE) ||
1501 (Adapter->bPreparingForLowPowerMode ==TRUE))
1503 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1504 up(&Adapter->NVMRdmWrmLock);
1505 bcm_kfree(pReadData);
1509 Status = BeceemNVMRead(Adapter, (PUINT)pReadData,
1510 stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes);
1512 up(&Adapter->NVMRdmWrmLock);
1514 if(Status != STATUS_SUCCESS)
1516 bcm_kfree(pReadData);
1519 if(copy_to_user((PCHAR)stNVMReadWrite.pBuffer,
1520 (PCHAR)pReadData, (UINT)stNVMReadWrite.uiNumBytes))
1522 bcm_kfree(pReadData);
1529 down(&Adapter->NVMRdmWrmLock);
1531 if((Adapter->IdleMode == TRUE) ||
1532 (Adapter->bShutStatus ==TRUE) ||
1533 (Adapter->bPreparingForLowPowerMode ==TRUE))
1535 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1536 up(&Adapter->NVMRdmWrmLock);
1537 bcm_kfree(pReadData);
1541 Adapter->bHeaderChangeAllowed = TRUE ;
1542 if(IsFlash2x(Adapter))
1546 DSD section updation will be allowed in two case:-
1547 1. if DSD sig is present in DSD header means dongle is ok and updation is fruitfull
1548 2. if point 1 failes then user buff should have DSD sig. this point ensures that if dongle is
1549 corrupted then user space program first modify the DSD header with valid DSD sig so
1550 that this as well as further write may be worthwhile.
1552 This restriction has been put assuming that if DSD sig is corrupted, DSD
1553 data won't be considered valid.
1557 Status = BcmFlash2xCorruptSig(Adapter,Adapter->eActiveDSD);
1558 if(Status != STATUS_SUCCESS)
1560 if(( (stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) != Adapter->uiNVMDSDSize ) ||
1561 (stNVMReadWrite.uiNumBytes < SIGNATURE_SIZE))
1563 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
1564 up(&Adapter->NVMRdmWrmLock);
1565 bcm_kfree(pReadData);
1569 ulDSDMagicNumInUsrBuff = ntohl(*(PUINT)(pReadData + stNVMReadWrite.uiNumBytes - SIGNATURE_SIZE));
1570 if(ulDSDMagicNumInUsrBuff != DSD_IMAGE_MAGIC_NUMBER)
1572 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
1573 up(&Adapter->NVMRdmWrmLock);
1574 bcm_kfree(pReadData);
1579 Status = BeceemNVMWrite(Adapter, (PUINT )pReadData,
1580 stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes, stNVMReadWrite.bVerify);
1581 if(IsFlash2x(Adapter))
1582 BcmFlash2xWriteSig(Adapter,Adapter->eActiveDSD);
1584 Adapter->bHeaderChangeAllowed = FALSE ;
1586 up(&Adapter->NVMRdmWrmLock);
1589 if(Status != STATUS_SUCCESS)
1591 bcm_kfree(pReadData);
1595 do_gettimeofday(&tv1);
1596 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " timetaken by Write/read :%ld msec\n",(tv1.tv_sec - tv0.tv_sec)*1000 +(tv1.tv_usec - tv0.tv_usec)/1000);
1599 bcm_kfree(pReadData);
1600 Status = STATUS_SUCCESS;
1603 case IOCTL_BCM_FLASH2X_SECTION_READ :
1606 FLASH2X_READWRITE sFlash2xRead = {0};
1607 PUCHAR pReadBuff = NULL ;
1611 UINT ReadOffset = 0;
1612 PUCHAR OutPutBuff = NULL;
1614 if(IsFlash2x(Adapter) != TRUE)
1616 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1620 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_FLASH2X_SECTION_READ Called");
1621 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1624 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1628 //Reading FLASH 2.x READ structure
1629 Status = copy_from_user((PUCHAR)&sFlash2xRead, (PUCHAR)IoBuffer.InputBuffer,sizeof(FLASH2X_READWRITE));
1632 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Input Buffer failed");
1637 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xRead.Section);
1638 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%x" ,sFlash2xRead.offset);
1639 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xRead.numOfBytes);
1640 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xRead.bVerify);
1642 //This was internal to driver for raw read. now it has ben exposed to user space app.
1643 if(validateFlash2xReadWrite(Adapter,&sFlash2xRead) == FALSE)
1644 return STATUS_FAILURE ;
1646 NOB = sFlash2xRead.numOfBytes;
1647 if(NOB > Adapter->uiSectorSize )
1648 BuffSize = Adapter->uiSectorSize;
1652 ReadOffset = sFlash2xRead.offset ;
1653 OutPutBuff = (PUCHAR)(IoBuffer.OutputBuffer) ;
1656 pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
1657 if(pReadBuff == NULL)
1659 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
1662 down(&Adapter->NVMRdmWrmLock);
1664 if((Adapter->IdleMode == TRUE) ||
1665 (Adapter->bShutStatus ==TRUE) ||
1666 (Adapter->bPreparingForLowPowerMode ==TRUE))
1668 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1669 up(&Adapter->NVMRdmWrmLock);
1670 bcm_kfree(pReadBuff);
1677 if(NOB > Adapter->uiSectorSize )
1678 ReadBytes = Adapter->uiSectorSize;
1683 //Reading the data from Flash 2.x
1685 Status = BcmFlash2xBulkRead(Adapter,(PUINT)pReadBuff,sFlash2xRead.Section,ReadOffset,ReadBytes);
1688 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Flash 2x read err with Status :%d", Status);
1692 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes);
1694 Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes);
1697 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Copy to use failed with status :%d", Status);
1700 NOB = NOB - ReadBytes;
1703 ReadOffset = ReadOffset + ReadBytes ;
1704 OutPutBuff = OutPutBuff + ReadBytes ;
1708 up(&Adapter->NVMRdmWrmLock);
1709 bcm_kfree(pReadBuff);
1713 case IOCTL_BCM_FLASH2X_SECTION_WRITE :
1715 FLASH2X_READWRITE sFlash2xWrite = {0};
1716 PUCHAR pWriteBuff = NULL;
1717 PUCHAR InputAddr = NULL;
1720 UINT WriteOffset = 0;
1721 UINT WriteBytes = 0;
1723 if(IsFlash2x(Adapter) != TRUE)
1725 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1729 //First make this False so that we can enable the Sector Permission Check in BeceemFlashBulkWrite
1730 Adapter->bAllDSDWriteAllow = FALSE;
1733 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_FLASH2X_SECTION_WRITE Called");
1734 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1737 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1741 //Reading FLASH 2.x READ structure
1742 Status = copy_from_user((PCHAR)&sFlash2xWrite, (PCHAR)IoBuffer.InputBuffer, sizeof(FLASH2X_READWRITE));
1745 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Reading of output Buffer from IOCTL buffer fails");
1749 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xWrite.Section);
1750 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%d" ,sFlash2xWrite.offset);
1751 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xWrite.numOfBytes);
1752 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xWrite.bVerify);
1754 if((sFlash2xWrite.Section == ISO_IMAGE1) ||(sFlash2xWrite.Section == ISO_IMAGE2) ||
1755 (sFlash2xWrite.Section == DSD0) || (sFlash2xWrite.Section == DSD1) || (sFlash2xWrite.Section == DSD2))
1757 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"ISO/DSD Image write is not allowed.... ");
1758 return STATUS_FAILURE ;
1761 if((sFlash2xWrite.Section != VSA0) && (sFlash2xWrite.Section != VSA1) &&
1762 (sFlash2xWrite.Section != VSA2) )
1764 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Only VSA write is allowed");
1768 if(validateFlash2xReadWrite(Adapter,&sFlash2xWrite) == FALSE)
1769 return STATUS_FAILURE ;
1771 InputAddr = (PCHAR)(sFlash2xWrite.pDataBuff) ;
1772 WriteOffset = sFlash2xWrite.offset ;
1773 NOB = sFlash2xWrite.numOfBytes;
1775 if(NOB > Adapter->uiSectorSize )
1776 BuffSize = Adapter->uiSectorSize;
1780 pWriteBuff = (PCHAR)kmalloc(BuffSize, GFP_KERNEL);
1781 if(pWriteBuff == NULL)
1783 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
1787 //extracting the remainder of the given offset.
1788 WriteBytes = Adapter->uiSectorSize ;
1789 if(WriteOffset % Adapter->uiSectorSize)
1790 WriteBytes =Adapter->uiSectorSize - (WriteOffset % Adapter->uiSectorSize);
1791 if(NOB < WriteBytes)
1794 down(&Adapter->NVMRdmWrmLock);
1796 if((Adapter->IdleMode == TRUE) ||
1797 (Adapter->bShutStatus ==TRUE) ||
1798 (Adapter->bPreparingForLowPowerMode ==TRUE))
1800 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1801 up(&Adapter->NVMRdmWrmLock);
1802 bcm_kfree(pWriteBuff);
1806 BcmFlash2xCorruptSig(Adapter,sFlash2xWrite.Section);
1809 Status = copy_from_user(pWriteBuff,InputAddr,WriteBytes);
1812 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to user failed with status :%d", Status);
1815 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pWriteBuff,WriteBytes);
1816 //Writing the data from Flash 2.x
1817 Status = BcmFlash2xBulkWrite(Adapter,(PUINT)pWriteBuff,sFlash2xWrite.Section,WriteOffset,WriteBytes,sFlash2xWrite.bVerify);
1821 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
1825 NOB = NOB - WriteBytes;
1828 WriteOffset = WriteOffset + WriteBytes ;
1829 InputAddr = InputAddr + WriteBytes ;
1830 if(NOB > Adapter->uiSectorSize )
1831 WriteBytes = Adapter->uiSectorSize;
1838 BcmFlash2xWriteSig(Adapter,sFlash2xWrite.Section);
1839 up(&Adapter->NVMRdmWrmLock);
1840 bcm_kfree(pWriteBuff);
1843 case IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP :
1846 PFLASH2X_BITMAP psFlash2xBitMap = NULL ;
1847 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP Called");
1849 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1852 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1855 if(IoBuffer.OutputLength != sizeof(FLASH2X_BITMAP))
1857 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Structure size mismatch Lib :0x%lx Driver :0x%x ",IoBuffer.OutputLength, sizeof(FLASH2X_BITMAP));
1861 psFlash2xBitMap = (PFLASH2X_BITMAP)kzalloc(sizeof(FLASH2X_BITMAP), GFP_KERNEL);
1862 if(psFlash2xBitMap == NULL)
1864 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory is not available");
1867 //Reading the Flash Sectio Bit map
1868 down(&Adapter->NVMRdmWrmLock);
1870 if((Adapter->IdleMode == TRUE) ||
1871 (Adapter->bShutStatus ==TRUE) ||
1872 (Adapter->bPreparingForLowPowerMode ==TRUE))
1874 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1875 up(&Adapter->NVMRdmWrmLock);
1876 bcm_kfree(psFlash2xBitMap);
1880 BcmGetFlash2xSectionalBitMap(Adapter, psFlash2xBitMap);
1881 up(&Adapter->NVMRdmWrmLock);
1882 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)psFlash2xBitMap, sizeof(FLASH2X_BITMAP));
1885 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash2x bitMap failed");
1886 bcm_kfree(psFlash2xBitMap);
1889 bcm_kfree(psFlash2xBitMap);
1892 case IOCTL_BCM_SET_ACTIVE_SECTION :
1894 FLASH2X_SECTION_VAL eFlash2xSectionVal = 0;
1895 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SET_ACTIVE_SECTION Called");
1897 if(IsFlash2x(Adapter) != TRUE)
1899 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1903 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1906 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1910 Status = copy_from_user((PCHAR)&eFlash2xSectionVal,(PCHAR)IoBuffer.InputBuffer, sizeof(INT));
1913 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
1917 down(&Adapter->NVMRdmWrmLock);
1919 if((Adapter->IdleMode == TRUE) ||
1920 (Adapter->bShutStatus ==TRUE) ||
1921 (Adapter->bPreparingForLowPowerMode ==TRUE))
1923 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1924 up(&Adapter->NVMRdmWrmLock);
1928 Status = BcmSetActiveSection(Adapter,eFlash2xSectionVal);
1931 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed to make it's priority Highest. Status %d", Status);
1933 up(&Adapter->NVMRdmWrmLock);
1936 case IOCTL_BCM_IDENTIFY_ACTIVE_SECTION :
1938 //Right Now we are taking care of only DSD
1939 Adapter->bAllDSDWriteAllow = FALSE ;
1940 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_IDENTIFY_ACTIVE_SECTION called");
1943 SECTION_TYPE section = 0 ;
1946 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_IDENTIFY_ACTIVE_SECTION Called");
1947 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1950 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy of IOCTL BUFFER failed");
1953 Status = copy_from_user((PCHAR)section,(PCHAR)&IoBuffer, sizeof(INT));
1956 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy of section type failed failed");
1959 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", section);
1961 Adapter->ulFlashCalStart = Adapter->uiActiveDSDOffsetAtFwDld ;
1963 Status = STATUS_FAILURE ;
1965 Status = STATUS_SUCCESS ;
1968 case IOCTL_BCM_COPY_SECTION :
1970 FLASH2X_COPY_SECTION sCopySectStrut = {0};
1971 Status = STATUS_SUCCESS;
1972 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_COPY_SECTION Called");
1974 Adapter->bAllDSDWriteAllow = FALSE ;
1975 if(IsFlash2x(Adapter) != TRUE)
1977 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1981 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1984 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed Status :%d", Status);
1988 Status = copy_from_user((PCHAR)&sCopySectStrut,(PCHAR)IoBuffer.InputBuffer, sizeof(FLASH2X_COPY_SECTION));
1991 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Copy_Section_Struct failed with Status :%d", Status);
1994 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Source SEction :%x", sCopySectStrut.SrcSection);
1995 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Destination SEction :%x", sCopySectStrut.DstSection);
1996 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "offset :%x", sCopySectStrut.offset);
1997 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "NOB :%x", sCopySectStrut.numOfBytes);
2000 if(IsSectionExistInFlash(Adapter,sCopySectStrut.SrcSection) == FALSE)
2002 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Source Section<%x> does not exixt in Flash ", sCopySectStrut.SrcSection);
2006 if(IsSectionExistInFlash(Adapter,sCopySectStrut.DstSection) == FALSE)
2008 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Destinatio Section<%x> does not exixt in Flash ", sCopySectStrut.DstSection);
2012 if(sCopySectStrut.SrcSection == sCopySectStrut.DstSection)
2014 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Source and Destination section should be different");
2018 down(&Adapter->NVMRdmWrmLock);
2020 if((Adapter->IdleMode == TRUE) ||
2021 (Adapter->bShutStatus ==TRUE) ||
2022 (Adapter->bPreparingForLowPowerMode ==TRUE))
2024 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2025 up(&Adapter->NVMRdmWrmLock);
2029 if(sCopySectStrut.SrcSection == ISO_IMAGE1 || sCopySectStrut.SrcSection == ISO_IMAGE2)
2031 if(IsNonCDLessDevice(Adapter))
2033 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is Non-CDLess hence won't have ISO !!");
2036 else if(sCopySectStrut.numOfBytes == 0)
2038 Status = BcmCopyISO(Adapter,sCopySectStrut);
2042 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Partial Copy of ISO section is not Allowed..");
2043 Status = STATUS_FAILURE ;
2045 up(&Adapter->NVMRdmWrmLock);
2049 Status = BcmCopySection(Adapter, sCopySectStrut.SrcSection,
2050 sCopySectStrut.DstSection,sCopySectStrut.offset,sCopySectStrut.numOfBytes);
2051 up(&Adapter->NVMRdmWrmLock);
2054 case IOCTL_BCM_GET_FLASH_CS_INFO :
2056 Status = STATUS_SUCCESS;
2057 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_GET_FLASH_CS_INFO Called");
2059 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2062 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2065 if(Adapter->eNVMType != NVM_FLASH)
2067 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Connected device does not have flash");
2071 if(IsFlash2x(Adapter) == TRUE)
2074 if(IoBuffer.OutputLength < sizeof(FLASH2X_CS_INFO))
2076 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0," Passed buffer size:0x%lX is insufficient for the CS structure.. \nRequired size :0x%x ",IoBuffer.OutputLength, sizeof(FLASH2X_CS_INFO));
2081 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)Adapter->psFlash2xCSInfo, sizeof(FLASH2X_CS_INFO));
2084 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash2x cs info failed");
2090 if(IoBuffer.OutputLength < sizeof(FLASH_CS_INFO))
2092 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0," Passed buffer size:0x%lX is insufficient for the CS structure.. Required size :0x%u ",IoBuffer.OutputLength, sizeof(FLASH_CS_INFO));
2096 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)Adapter->psFlashCSInfo, sizeof(FLASH_CS_INFO));
2099 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash CS info failed");
2106 case IOCTL_BCM_SELECT_DSD :
2109 FLASH2X_SECTION_VAL eFlash2xSectionVal;
2110 eFlash2xSectionVal = NO_SECTION_VAL ;
2111 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_SELECT_DSD Called");
2113 if(IsFlash2x(Adapter) != TRUE)
2115 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
2119 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2122 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2125 Status = copy_from_user((PCHAR)&eFlash2xSectionVal,(PCHAR)IoBuffer.InputBuffer, sizeof(INT));
2128 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
2132 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", eFlash2xSectionVal);
2133 if((eFlash2xSectionVal != DSD0) &&
2134 (eFlash2xSectionVal != DSD1) &&
2135 (eFlash2xSectionVal != DSD2) )
2137 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Passed section<%x> is not DSD section", eFlash2xSectionVal);
2138 return STATUS_FAILURE ;
2141 SectOfset= BcmGetSectionValStartOffset(Adapter,eFlash2xSectionVal);
2142 if(SectOfset == INVALID_OFFSET)
2144 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Provided Section val <%d> does not exixt in Flash 2.x", eFlash2xSectionVal);
2148 Adapter->bAllDSDWriteAllow = TRUE ;
2150 Adapter->ulFlashCalStart = SectOfset ;
2151 Adapter->eActiveDSD = eFlash2xSectionVal;
2153 Status = STATUS_SUCCESS ;
2156 case IOCTL_BCM_NVM_RAW_READ :
2159 NVM_READWRITE stNVMRead = {0};
2163 UINT ReadBytes = 0 ;
2164 PUCHAR pReadBuff = NULL ;
2165 PUCHAR OutPutBuff = NULL ;
2167 if(Adapter->eNVMType != NVM_FLASH)
2169 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"NVM TYPE is not Flash ");
2173 /* Copy Ioctl Buffer structure */
2174 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
2176 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
2181 if(copy_from_user(&stNVMRead, (PUCHAR)IoBuffer.OutputBuffer,sizeof(NVM_READWRITE)))
2187 NOB = stNVMRead.uiNumBytes;
2188 //In Raw-Read max Buff size : 64MB
2190 if(NOB > DEFAULT_BUFF_SIZE)
2191 BuffSize = DEFAULT_BUFF_SIZE;
2195 ReadOffset = stNVMRead.uiOffset ;
2196 OutPutBuff = (PUCHAR)(stNVMRead.pBuffer) ;
2199 pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
2200 if(pReadBuff == NULL)
2202 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
2206 down(&Adapter->NVMRdmWrmLock);
2208 if((Adapter->IdleMode == TRUE) ||
2209 (Adapter->bShutStatus ==TRUE) ||
2210 (Adapter->bPreparingForLowPowerMode ==TRUE))
2212 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2213 bcm_kfree(pReadBuff);
2214 up(&Adapter->NVMRdmWrmLock);
2218 Adapter->bFlashRawRead = TRUE ;
2221 if(NOB > DEFAULT_BUFF_SIZE )
2222 ReadBytes = DEFAULT_BUFF_SIZE;
2226 //Reading the data from Flash 2.x
2227 Status = BeceemNVMRead(Adapter,(PUINT)pReadBuff,ReadOffset,ReadBytes);
2230 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
2234 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes);
2236 Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes);
2239 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to use failed with status :%d", Status);
2242 NOB = NOB - ReadBytes;
2245 ReadOffset = ReadOffset + ReadBytes ;
2246 OutPutBuff = OutPutBuff + ReadBytes ;
2250 Adapter->bFlashRawRead = FALSE ;
2251 up(&Adapter->NVMRdmWrmLock);
2252 bcm_kfree(pReadBuff);
2256 case IOCTL_BCM_CNTRLMSG_MASK:
2258 ULONG RxCntrlMsgBitMask = 0 ;
2260 /* Copy Ioctl Buffer structure */
2261 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2264 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of Ioctl buffer is failed from user space");
2268 Status = copy_from_user(&RxCntrlMsgBitMask, IoBuffer.InputBuffer, IoBuffer.InputLength);
2271 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of control bit mask failed from user space");
2274 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\n Got user defined cntrl msg bit mask :%lx", RxCntrlMsgBitMask);
2275 pTarang->RxCntrlMsgBitMask = RxCntrlMsgBitMask ;
2278 case IOCTL_BCM_GET_DEVICE_DRIVER_INFO:
2280 DEVICE_DRIVER_INFO DevInfo;
2282 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Called IOCTL_BCM_GET_DEVICE_DRIVER_INFO\n");
2284 DevInfo.MaxRDMBufferSize = BUFFER_4K;
2285 DevInfo.u32DSDStartOffset = EEPROM_CALPARAM_START;
2286 DevInfo.u32RxAlignmentCorrection = 0;
2287 DevInfo.u32NVMType = Adapter->eNVMType;
2288 DevInfo.u32InterfaceType = BCM_USB;
2290 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2293 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2296 if(IoBuffer.OutputLength < sizeof(DevInfo))
2298 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"User Passed buffer length is less than actural buffer size");
2299 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"user passed buffer size :0x%lX, expected size :0x%x",IoBuffer.OutputLength, sizeof(DevInfo));
2303 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)&DevInfo, sizeof(DevInfo));
2306 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copying Dev info structure to user space buffer failed");
2312 case IOCTL_BCM_TIME_SINCE_NET_ENTRY:
2314 ST_TIME_ELAPSED stTimeElapsedSinceNetEntry = {0};
2315 struct timeval tv = {0} ;
2317 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_TIME_SINCE_NET_ENTRY called");
2319 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2322 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2325 if(IoBuffer.OutputLength < sizeof(ST_TIME_ELAPSED))
2327 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"User Passed buffer length:0x%lx is less than expected buff size :0x%X",IoBuffer.OutputLength,sizeof(ST_TIME_ELAPSED));
2332 //stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = Adapter->liTimeSinceLastNetEntry;
2333 do_gettimeofday(&tv);
2334 stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = tv.tv_sec - Adapter->liTimeSinceLastNetEntry;
2336 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)&stTimeElapsedSinceNetEntry, sizeof(ST_TIME_ELAPSED));
2339 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copying ST_TIME_ELAPSED structure to user space buffer failed");
2347 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "wrong input %x",cmd);
2348 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In default ioctl %d\n", cmd);
2349 Status = STATUS_FAILURE;
2357 static struct file_operations bcm_fops = {
2358 .owner = THIS_MODULE,
2359 .open = bcm_char_open,
2360 .release = bcm_char_release,
2361 .read = bcm_char_read,
2362 .unlocked_ioctl = bcm_char_ioctl,
2366 int register_control_device_interface(PMINI_ADAPTER Adapter)
2368 if(Adapter->major>0)
2369 return Adapter->major;
2370 Adapter->major = register_chrdev(0, "tarang", &bcm_fops);
2371 if(Adapter->major < 0)
2373 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "register_chrdev:Failed to registering WiMax control char device!");
2374 return Adapter->major;
2378 bcm_class = class_create (THIS_MODULE, "tarang");
2379 if(IS_ERR (bcm_class))
2381 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unable to create class\n");
2382 unregister_chrdev(Adapter->major, "tarang");
2386 Adapter->pstCreatedClassDevice = device_create (bcm_class, NULL,
2387 MKDEV(Adapter->major, 0),
2388 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
2393 if(IS_ERR(Adapter->pstCreatedClassDevice))
2395 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "class device did not get created : %ld", PTR_ERR(Adapter->pstCreatedClassDevice) );
2397 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Got Major No: %d", Adapter->major);
2401 void unregister_control_device_interface(PMINI_ADAPTER Adapter)
2403 if(Adapter->major > 0)
2405 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "destroying class device");
2406 device_destroy (bcm_class, MKDEV(Adapter->major, 0));
2408 if(!IS_ERR(bcm_class))
2410 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "destroying created class ");
2411 class_destroy (bcm_class);
2414 if(Adapter->major > 0)
2416 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"unregistering character interface");
2417 unregister_chrdev(Adapter->major, "tarang");