4 /***************************************************************
5 * Function - bcm_char_open()
7 * Description - This is the "open" entry point for the character
10 * Parameters - inode: Pointer to the Inode structure of char device
11 * filp : File pointer of the char device
13 * Returns - Zero(Success)
14 ****************************************************************/
15 static struct class *bcm_class = NULL;
16 static int bcm_char_open(struct inode *inode, struct file * filp)
18 PMINI_ADAPTER Adapter = NULL;
19 PPER_TARANG_DATA pTarang = NULL;
21 Adapter = GET_BCM_ADAPTER(gblpnetdev);
22 pTarang = (PPER_TARANG_DATA)kmalloc(sizeof(PER_TARANG_DATA), GFP_KERNEL);
26 memset (pTarang, 0, sizeof(PER_TARANG_DATA));
27 pTarang->Adapter = Adapter;
28 pTarang->RxCntrlMsgBitMask = 0xFFFFFFFF & ~(1 << 0xB) ;
30 down(&Adapter->RxAppControlQueuelock);
31 pTarang->next = Adapter->pTarangs;
32 Adapter->pTarangs = pTarang;
33 up(&Adapter->RxAppControlQueuelock);
35 /* Store the Adapter structure */
36 filp->private_data = pTarang;
38 /*Start Queuing the control response Packets*/
39 atomic_inc(&Adapter->ApplicationRunning);
41 nonseekable_open(inode, filp);
44 static int bcm_char_release(struct inode *inode, struct file *filp)
46 PPER_TARANG_DATA pTarang, tmp, ptmp;
47 PMINI_ADAPTER Adapter=NULL;
48 struct sk_buff * pkt, * npkt;
50 pTarang = (PPER_TARANG_DATA)filp->private_data;
54 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "ptarang is null\n");
58 Adapter = pTarang->Adapter;
60 down( &Adapter->RxAppControlQueuelock);
62 tmp = Adapter->pTarangs;
63 for ( ptmp = NULL; tmp; ptmp = tmp, tmp = tmp->next )
72 Adapter->pTarangs = tmp->next;
74 ptmp->next = tmp->next;
79 up( &Adapter->RxAppControlQueuelock);
83 pkt = pTarang->RxAppControlHead;
91 up( &Adapter->RxAppControlQueuelock);
93 /*Stop Queuing the control response Packets*/
94 atomic_dec(&Adapter->ApplicationRunning);
98 /* remove this filp from the asynchronously notified filp's */
99 filp->private_data = NULL;
103 static ssize_t bcm_char_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos)
105 PPER_TARANG_DATA pTarang = (PPER_TARANG_DATA)filp->private_data;
106 PMINI_ADAPTER Adapter = pTarang->Adapter;
107 struct sk_buff* Packet = NULL;
111 wait_ret_val = wait_event_interruptible(Adapter->process_read_wait_queue,
112 (pTarang->RxAppControlHead || Adapter->device_removed));
113 if((wait_ret_val == -ERESTARTSYS))
115 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Exiting as i've been asked to exit!!!\n");
119 if(Adapter->device_removed)
121 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device Removed... Killing the Apps...\n");
125 if(FALSE == Adapter->fw_download_done)
128 down( &Adapter->RxAppControlQueuelock);
130 if(pTarang->RxAppControlHead)
132 Packet = pTarang->RxAppControlHead;
133 DEQUEUEPACKET(pTarang->RxAppControlHead,pTarang->RxAppControlTail);
134 pTarang->AppCtrlQueueLen--;
137 up(&Adapter->RxAppControlQueuelock);
141 PktLen = Packet->len;
142 if(copy_to_user(buf, Packet->data, PktLen))
144 bcm_kfree_skb(Packet);
145 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "\nReturning from copy to user failure \n");
148 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);
149 bcm_kfree_skb(Packet);
152 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "<====\n");
156 static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
158 PPER_TARANG_DATA pTarang = (PPER_TARANG_DATA)filp->private_data;
159 void __user *argp = (void __user *)argp;
160 PMINI_ADAPTER Adapter = pTarang->Adapter;
161 INT Status = STATUS_FAILURE;
162 IOCTL_BUFFER IoBuffer={};
163 #ifndef BCM_SHM_INTERFACE
168 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);
170 if(_IOC_TYPE(cmd) != BCM_IOCTL)
172 if(_IOC_DIR(cmd) & _IOC_READ)
173 Status = !access_ok(VERIFY_WRITE, argp, _IOC_SIZE(cmd));
174 else if (_IOC_DIR(cmd) & _IOC_WRITE)
175 Status = !access_ok(VERIFY_READ, argp, _IOC_SIZE(cmd));
176 else if (_IOC_NONE == (_IOC_DIR(cmd) & _IOC_NONE))
177 Status = STATUS_SUCCESS;
182 if(Adapter->device_removed)
187 if(FALSE == Adapter->fw_download_done)
191 case IOCTL_MAC_ADDR_REQ:
193 case IOCTL_CM_REQUEST:
194 case IOCTL_SS_INFO_REQ:
195 case IOCTL_SEND_CONTROL_MESSAGE:
197 case IOCTL_BCM_GPIO_SET_REQUEST:
198 case IOCTL_BCM_GPIO_STATUS_REQUEST:
205 Status = vendorextnIoctl(Adapter, cmd, arg);
206 if(Status != CONTINUE_COMMON_PATH )
212 // Rdms for Swin Idle...
213 case IOCTL_BCM_REGISTER_READ_PRIVATE:
215 RDM_BUFFER sRdmBuffer = {0};
216 PCHAR temp_buff = NULL;
218 /* Copy Ioctl Buffer structure */
219 if(copy_from_user((PCHAR)&IoBuffer, argp,
220 sizeof(IOCTL_BUFFER)))
226 Bufflen = IoBuffer.OutputLength + (4 - IoBuffer.OutputLength%4)%4;
227 temp_buff = (PCHAR)kmalloc(Bufflen, GFP_KERNEL);
230 return STATUS_FAILURE;
232 if(copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer,
233 IoBuffer.InputLength))
238 Status = rdmalt(Adapter, (UINT)sRdmBuffer.Register,
239 (PUINT)temp_buff, Bufflen);
240 if(Status != STATUS_SUCCESS)
242 bcm_kfree(temp_buff);
245 if(copy_to_user(IoBuffer.OutputBuffer,
246 (PCHAR)temp_buff, (UINT)IoBuffer.OutputLength))
250 bcm_kfree(temp_buff);
253 case IOCTL_BCM_REGISTER_WRITE_PRIVATE:
255 WRM_BUFFER sWrmBuffer = {0};
257 /* Copy Ioctl Buffer structure */
259 if(copy_from_user(&IoBuffer, argp,
260 sizeof(IOCTL_BUFFER)))
265 /* Get WrmBuffer structure */
266 if(copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer,
267 IoBuffer.InputLength))
272 uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK;
273 if(!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) &&
274 ((uiTempVar == EEPROM_REJECT_REG_1)||
275 (uiTempVar == EEPROM_REJECT_REG_2) ||
276 (uiTempVar == EEPROM_REJECT_REG_3) ||
277 (uiTempVar == EEPROM_REJECT_REG_4)))
279 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
283 Status = wrmalt(Adapter, (UINT)sWrmBuffer.Register,
284 (PUINT)sWrmBuffer.Data, sizeof(ULONG));
285 if(Status == STATUS_SUCCESS)
287 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"WRM Done\n");
291 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
297 case IOCTL_BCM_REGISTER_READ:
298 case IOCTL_BCM_EEPROM_REGISTER_READ:
300 RDM_BUFFER sRdmBuffer = {0};
301 PCHAR temp_buff = NULL;
303 if((Adapter->IdleMode == TRUE) ||
304 (Adapter->bShutStatus ==TRUE) ||
305 (Adapter->bPreparingForLowPowerMode ==TRUE))
307 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Rdms\n");
311 /* Copy Ioctl Buffer structure */
312 if(copy_from_user(&IoBuffer, argp,
313 sizeof(IOCTL_BUFFER)))
319 temp_buff = (PCHAR)kmalloc(IoBuffer.OutputLength, GFP_KERNEL);
322 return STATUS_FAILURE;
324 if(copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer,
325 IoBuffer.InputLength))
332 #if !defined(BCM_SHM_INTERFACE)
333 (((ULONG)sRdmBuffer.Register & 0x0F000000) != 0x0F000000) ||
335 ((ULONG)sRdmBuffer.Register & 0x3)
338 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "RDM Done On invalid Address : %x Access Denied.\n",
339 (int)sRdmBuffer.Register);
344 uiTempVar = sRdmBuffer.Register & EEPROM_REJECT_MASK;
345 Status = rdmaltWithLock(Adapter, (UINT)sRdmBuffer.Register,
346 (PUINT)temp_buff, IoBuffer.OutputLength);
347 if(Status != STATUS_SUCCESS)
349 bcm_kfree(temp_buff);
352 if(copy_to_user(IoBuffer.OutputBuffer,
353 (PCHAR)temp_buff, (UINT)IoBuffer.OutputLength))
357 bcm_kfree(temp_buff);
360 case IOCTL_BCM_REGISTER_WRITE:
361 case IOCTL_BCM_EEPROM_REGISTER_WRITE:
363 WRM_BUFFER sWrmBuffer = {0};
365 if((Adapter->IdleMode == TRUE) ||
366 (Adapter->bShutStatus ==TRUE) ||
367 (Adapter->bPreparingForLowPowerMode ==TRUE))
369 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Wrms\n");
373 /* Copy Ioctl Buffer structure */
374 if(copy_from_user((PCHAR)&IoBuffer, argp,
375 sizeof(IOCTL_BUFFER)))
380 /* Get WrmBuffer structure */
381 if(copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer,
382 IoBuffer.InputLength))
388 #if !defined(BCM_SHM_INTERFACE)
390 (((ULONG)sWrmBuffer.Register & 0x0F000000) != 0x0F000000) ||
392 ((ULONG)sWrmBuffer.Register & 0x3)
395 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Done On invalid Address : %x Access Denied.\n",
396 (int)sWrmBuffer.Register);
400 uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK;
401 if(!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) &&
402 ((uiTempVar == EEPROM_REJECT_REG_1)||
403 (uiTempVar == EEPROM_REJECT_REG_2) ||
404 (uiTempVar == EEPROM_REJECT_REG_3) ||
405 (uiTempVar == EEPROM_REJECT_REG_4)) &&
406 (cmd == IOCTL_BCM_REGISTER_WRITE))
408 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
413 Status = wrmaltWithLock(Adapter, (UINT)sWrmBuffer.Register,
414 (PUINT)sWrmBuffer.Data, sWrmBuffer.Length);
415 if(Status == STATUS_SUCCESS)
417 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "WRM Done\n");
421 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
426 case IOCTL_BCM_GPIO_SET_REQUEST:
428 UCHAR ucResetValue[4];
431 UINT uiOperation = 0;
433 GPIO_INFO gpio_info = {0};
434 if((Adapter->IdleMode == TRUE) ||
435 (Adapter->bShutStatus ==TRUE) ||
436 (Adapter->bPreparingForLowPowerMode ==TRUE))
438 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO Can't be set/clear in Low power Mode");
442 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
447 if(copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
452 uiBit = gpio_info.uiGpioNumber;
453 uiOperation = gpio_info.uiGpioValue;
457 if(IsReqGpioIsLedInNVM(Adapter,value) ==FALSE)
459 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to LED !!!",value);
465 if(uiOperation)//Set - setting 1
467 //Set the gpio output register
468 Status = wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_SET_REG ,
469 (PUINT)(&value), sizeof(UINT));
470 if(Status == STATUS_SUCCESS)
472 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Set the GPIO bit\n");
476 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Failed to set the %dth GPIO \n",uiBit);
480 else//Unset - setting 0
482 //Set the gpio output register
483 Status = wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_CLR_REG ,
484 (PUINT)(&value), sizeof(UINT));
485 if(Status == STATUS_SUCCESS)
487 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Set the GPIO bit\n");
491 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Failed to clear the %dth GPIO \n",uiBit);
496 Status = rdmaltWithLock(Adapter, (UINT)GPIO_MODE_REGISTER,
497 (PUINT)ucResetValue, sizeof(UINT));
498 if (STATUS_SUCCESS != Status)
500 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO_MODE_REGISTER read failed");
503 //Set the gpio mode register to output
504 *(UINT*)ucResetValue |= (1<<uiBit);
505 Status = wrmaltWithLock(Adapter,GPIO_MODE_REGISTER ,
506 (PUINT)ucResetValue, sizeof(UINT));
507 if(Status == STATUS_SUCCESS)
509 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Set the GPIO to output Mode\n");
513 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Failed to put GPIO in Output Mode\n");
518 case BCM_LED_THREAD_STATE_CHANGE_REQ:
521 USER_THREAD_REQ threadReq = {0};
522 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"User made LED thread InActive");
524 if((Adapter->IdleMode == TRUE) ||
525 (Adapter->bShutStatus ==TRUE) ||
526 (Adapter->bPreparingForLowPowerMode ==TRUE))
528 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO Can't be set/clear in Low power Mode");
532 Status =copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
535 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
540 Status= copy_from_user(&threadReq, IoBuffer.InputBuffer, IoBuffer.InputLength);
543 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the InputBuffer from user space err:%d",Status);
547 //if LED thread is running(Actively or Inactively) set it state to make inactive
548 if(Adapter->LEDInfo.led_thread_running)
550 if(threadReq.ThreadState == LED_THREAD_ACTIVATION_REQ)
552 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Activating thread req");
553 Adapter->DriverState = LED_THREAD_ACTIVE;
557 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DeActivating Thread req.....");
558 Adapter->DriverState = LED_THREAD_INACTIVE;
562 wake_up(&Adapter->LEDInfo.notify_led_event);
567 case IOCTL_BCM_GPIO_STATUS_REQUEST:
571 GPIO_INFO gpio_info = {0};
572 if((Adapter->IdleMode == TRUE) ||
573 (Adapter->bShutStatus ==TRUE) ||
574 (Adapter->bPreparingForLowPowerMode ==TRUE))
579 if(copy_from_user((PCHAR)&IoBuffer, argp, sizeof(IOCTL_BUFFER))) {
583 if(copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
588 uiBit = gpio_info.uiGpioNumber;
589 //Set the gpio output register
590 Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER,
591 (PUINT)ucRead, sizeof(UINT));
592 if(Status != STATUS_SUCCESS)
594 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "RDM Failed\n");
600 case IOCTL_BCM_GPIO_MULTI_REQUEST:
602 UCHAR ucResetValue[4];
603 GPIO_MULTI_INFO gpio_multi_info[MAX_IDX];
604 PGPIO_MULTI_INFO pgpio_multi_info = (PGPIO_MULTI_INFO)gpio_multi_info;
606 memset( pgpio_multi_info, 0, MAX_IDX * sizeof( GPIO_MULTI_INFO));
608 if((Adapter->IdleMode == TRUE) ||
609 (Adapter->bShutStatus ==TRUE) ||
610 (Adapter->bPreparingForLowPowerMode ==TRUE))
615 Status = copy_from_user( (PCHAR)&IoBuffer, argp, sizeof( IOCTL_BUFFER));
618 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
623 Status = copy_from_user( &gpio_multi_info, IoBuffer.InputBuffer, IoBuffer.InputLength);
626 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer Contents from user space err:%d",Status);
630 if(IsReqGpioIsLedInNVM(Adapter,pgpio_multi_info[WIMAX_IDX].uiGPIOMask)== FALSE)
632 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);
637 /* Set the gpio output register */
639 if( ( pgpio_multi_info[WIMAX_IDX].uiGPIOMask) &
640 ( pgpio_multi_info[WIMAX_IDX].uiGPIOCommand))
642 /* Set 1's in GPIO OUTPUT REGISTER */
643 *(UINT*) ucResetValue = pgpio_multi_info[WIMAX_IDX].uiGPIOMask &
644 pgpio_multi_info[WIMAX_IDX].uiGPIOCommand &
645 pgpio_multi_info[WIMAX_IDX].uiGPIOValue;
647 if( *(UINT*) ucResetValue)
648 Status = wrmaltWithLock( Adapter, BCM_GPIO_OUTPUT_SET_REG , (PUINT) ucResetValue, sizeof(ULONG));
650 if( Status != STATUS_SUCCESS)
652 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to BCM_GPIO_OUTPUT_SET_REG Failed.");
656 /* Clear to 0's in GPIO OUTPUT REGISTER */
657 *(UINT*) ucResetValue = (pgpio_multi_info[WIMAX_IDX].uiGPIOMask &
658 pgpio_multi_info[WIMAX_IDX].uiGPIOCommand &
659 ( ~( pgpio_multi_info[WIMAX_IDX].uiGPIOValue)));
661 if( *(UINT*) ucResetValue)
662 Status = wrmaltWithLock( Adapter, BCM_GPIO_OUTPUT_CLR_REG , (PUINT) ucResetValue, sizeof(ULONG));
664 if( Status != STATUS_SUCCESS)
666 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to BCM_GPIO_OUTPUT_CLR_REG Failed." );
671 if( pgpio_multi_info[WIMAX_IDX].uiGPIOMask)
673 Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER, (PUINT)ucResetValue, sizeof(UINT));
675 if(Status != STATUS_SUCCESS)
677 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"RDM to GPIO_PIN_STATE_REGISTER Failed.");
681 pgpio_multi_info[WIMAX_IDX].uiGPIOValue = ( *(UINT*)ucResetValue &
682 pgpio_multi_info[WIMAX_IDX].uiGPIOMask);
685 Status = copy_to_user(IoBuffer.OutputBuffer, &gpio_multi_info, IoBuffer.OutputLength);
688 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying Content to IOBufer for user space err:%d",Status);
694 case IOCTL_BCM_GPIO_MODE_REQUEST:
696 UCHAR ucResetValue[4];
697 GPIO_MULTI_MODE gpio_multi_mode[MAX_IDX];
698 PGPIO_MULTI_MODE pgpio_multi_mode = ( PGPIO_MULTI_MODE) gpio_multi_mode;
700 if((Adapter->IdleMode == TRUE) ||
701 (Adapter->bShutStatus ==TRUE) ||
702 (Adapter->bPreparingForLowPowerMode ==TRUE))
707 Status = copy_from_user(&IoBuffer, argp, sizeof( IOCTL_BUFFER));
710 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
715 Status = copy_from_user( &gpio_multi_mode, IoBuffer.InputBuffer, IoBuffer.InputLength);
718 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer Contents from user space err:%d",Status);
723 Status = rdmaltWithLock( Adapter, ( UINT) GPIO_MODE_REGISTER, ( PUINT) ucResetValue, sizeof( UINT));
724 if( STATUS_SUCCESS != Status)
726 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Read of GPIO_MODE_REGISTER failed");
730 //Validating the request
731 if(IsReqGpioIsLedInNVM(Adapter,pgpio_multi_mode[WIMAX_IDX].uiGPIOMask)== FALSE)
733 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);
738 if( pgpio_multi_mode[WIMAX_IDX].uiGPIOMask)
740 /* write all OUT's (1's) */
741 *( UINT*) ucResetValue |= ( pgpio_multi_mode[WIMAX_IDX].uiGPIOMode &
742 pgpio_multi_mode[WIMAX_IDX].uiGPIOMask);
743 /* write all IN's (0's) */
744 *( UINT*) ucResetValue &= ~( ( ~pgpio_multi_mode[WIMAX_IDX].uiGPIOMode) &
745 pgpio_multi_mode[WIMAX_IDX].uiGPIOMask);
747 /* Currently implemented return the modes of all GPIO's
748 * else needs to bit AND with mask
750 pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *(UINT*)ucResetValue;
752 Status = wrmaltWithLock( Adapter, GPIO_MODE_REGISTER , ( PUINT) ucResetValue, sizeof( ULONG));
753 if( Status == STATUS_SUCCESS)
755 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM to GPIO_MODE_REGISTER Done");
759 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to GPIO_MODE_REGISTER Failed");
764 else /* if uiGPIOMask is 0 then return mode register configuration */
766 pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *( UINT*) ucResetValue;
768 Status = copy_to_user(IoBuffer.OutputBuffer, &gpio_multi_mode, IoBuffer.OutputLength);
771 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying Content to IOBufer for user space err:%d",Status);
778 case IOCTL_MAC_ADDR_REQ:
780 case IOCTL_CM_REQUEST:
781 case IOCTL_SS_INFO_REQ:
782 case IOCTL_SEND_CONTROL_MESSAGE:
786 /* Copy Ioctl Buffer structure */
787 if(copy_from_user(&IoBuffer, argp,
788 sizeof(IOCTL_BUFFER)))
793 pvBuffer=kmalloc(IoBuffer.InputLength, GFP_KERNEL);
799 if(copy_from_user(pvBuffer, IoBuffer.InputBuffer,
800 IoBuffer.InputLength))
807 down(&Adapter->LowPowerModeSync);
808 Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue,
809 !Adapter->bPreparingForLowPowerMode,
811 if(Status == -ERESTARTSYS)
814 if(Adapter->bPreparingForLowPowerMode)
816 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Preparing Idle Mode is still True - Hence Rejecting control message\n");
817 Status = STATUS_FAILURE ;
820 Status = CopyBufferToControlPacket(Adapter, (PVOID)pvBuffer);
822 up(&Adapter->LowPowerModeSync);
826 #ifndef BCM_SHM_INTERFACE
827 case IOCTL_BCM_BUFFER_DOWNLOAD_START:
829 INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock) ;
832 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");
835 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
836 if(!down_trylock(&Adapter->fw_download_sema))
838 Adapter->bBinDownloaded=FALSE;
839 Adapter->fw_download_process_pid=current->pid;
840 Adapter->bCfgDownloaded=FALSE;
841 Adapter->fw_download_done=FALSE;
842 netif_carrier_off(Adapter->dev);
843 netif_stop_queue(Adapter->dev);
844 Status = reset_card_proc(Adapter);
847 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "reset_card_proc Failed!\n");
848 up(&Adapter->fw_download_sema);
849 up(&Adapter->NVMRdmWrmLock);
860 up(&Adapter->NVMRdmWrmLock);
863 case IOCTL_BCM_BUFFER_DOWNLOAD:
865 FIRMWARE_INFO *psFwInfo=NULL;
866 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
868 if(!down_trylock(&Adapter->fw_download_sema))
870 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid way to download buffer. Use Start and then call this!!!\n");
874 /* Copy Ioctl Buffer structure */
875 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
877 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
881 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Length for FW DLD is : %lx\n",
882 IoBuffer.InputLength);
883 psFwInfo=kmalloc(sizeof(*psFwInfo), GFP_KERNEL);
886 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Failed to allocate buffer!!!!\n");
890 if(copy_from_user(psFwInfo, IoBuffer.InputBuffer,
891 IoBuffer.InputLength))
893 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_from_user 2 failed\n");
898 if(!psFwInfo->pvMappedFirmwareAddress ||
899 (psFwInfo->u32FirmwareLength == 0))
901 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Something else is wrong %lu\n",
902 psFwInfo->u32FirmwareLength);
906 Status = bcm_ioctl_fw_download(Adapter, psFwInfo);
907 if(Status != STATUS_SUCCESS)
909 if(psFwInfo->u32StartingAddress==CONFIG_BEGIN_ADDR)
911 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "IOCTL: Configuration File Upload Failed\n");
915 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "IOCTL: Firmware File Upload Failed\n");
917 //up(&Adapter->fw_download_sema);
919 if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)
921 Adapter->DriverState = DRIVER_INIT;
922 Adapter->LEDInfo.bLedInitDone = FALSE;
923 wake_up(&Adapter->LEDInfo.notify_led_event);
929 if(Status != STATUS_SUCCESS)
930 up(&Adapter->fw_download_sema);
931 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "IOCTL: Firmware File Uploaded\n");
935 case IOCTL_BCM_BUFFER_DOWNLOAD_STOP:
937 INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
940 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " FW download blocked as EEPROM Read/Write is in progress\n");
941 up(&Adapter->fw_download_sema);
944 if(down_trylock(&Adapter->fw_download_sema))
946 Adapter->bBinDownloaded=TRUE;
947 Adapter->bCfgDownloaded=TRUE;
948 atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
949 atomic_set(&Adapter->RxRollOverCount, 0);
950 Adapter->CurrNumRecvDescs=0;
951 Adapter->downloadDDR = 0;
953 //setting the Mips to Run
954 Status = run_card_proc(Adapter);
957 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Firm Download Failed\n");
958 up(&Adapter->fw_download_sema);
959 up(&Adapter->NVMRdmWrmLock);
963 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Firm Download Over...\n");
965 /* Wait for MailBox Interrupt */
966 if(StartInterruptUrb((PS_INTERFACE_ADAPTER)Adapter->pvInterfaceAdapter))
968 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Unable to send interrupt...\n");
971 Adapter->waiting_to_fw_download_done = FALSE;
972 wait_event_timeout(Adapter->ioctl_fw_dnld_wait_queue,
973 Adapter->waiting_to_fw_download_done, timeout);
974 Adapter->fw_download_process_pid=INVALID_PID;
975 Adapter->fw_download_done=TRUE;
976 atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
977 Adapter->CurrNumRecvDescs = 0;
978 Adapter->PrevNumRecvDescs = 0;
979 atomic_set(&Adapter->cntrlpktCnt,0);
980 Adapter->LinkUpStatus = 0;
981 Adapter->LinkStatus = 0;
983 if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)
985 Adapter->DriverState = FW_DOWNLOAD_DONE;
986 wake_up(&Adapter->LEDInfo.notify_led_event);
998 up(&Adapter->fw_download_sema);
999 up(&Adapter->NVMRdmWrmLock);
1003 case IOCTL_BE_BUCKET_SIZE:
1005 if (get_user(Adapter->BEBucketSize, (unsigned long __user *)arg))
1009 case IOCTL_RTPS_BUCKET_SIZE:
1011 if (get_user(Adapter->rtPSBucketSize, (unsigned long __user *)arg))
1014 case IOCTL_CHIP_RESET:
1016 INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
1019 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
1022 down(&Adapter->RxAppControlQueuelock);
1023 Status = reset_card_proc(Adapter);
1025 up(&Adapter->RxAppControlQueuelock);
1026 up(&Adapter->NVMRdmWrmLock);
1027 ResetCounters(Adapter);
1030 case IOCTL_QOS_THRESHOLD:
1035 for (uiLoopIndex = 0; uiLoopIndex < NO_OF_QUEUES; uiLoopIndex++) {
1036 if (get_user(Adapter->PackInfo[uiLoopIndex].uiThreshold,
1037 (unsigned long __user *)arg)) {
1045 case IOCTL_DUMP_PACKET_INFO:
1047 DumpPackInfo(Adapter);
1048 DumpPhsRules(&Adapter->stBCMPhsContext);
1049 Status = STATUS_SUCCESS;
1052 case IOCTL_GET_PACK_INFO:
1053 if(copy_to_user(argp, &Adapter->PackInfo,
1054 sizeof(PacketInfo)*NO_OF_QUEUES))
1059 Status = STATUS_SUCCESS;
1061 case IOCTL_BCM_SWITCH_TRANSFER_MODE:
1064 if(copy_from_user(&uiData, argp, sizeof(UINT)))
1069 if(uiData) /* Allow All Packets */
1071 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: ETH_PACKET_TUNNELING_MODE\n");
1072 Adapter->TransferMode = ETH_PACKET_TUNNELING_MODE;
1074 else /* Allow IP only Packets */
1076 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: IP_PACKET_ONLY_MODE\n");
1077 Adapter->TransferMode = IP_PACKET_ONLY_MODE;
1079 Status = STATUS_SUCCESS;
1083 case IOCTL_BCM_GET_DRIVER_VERSION:
1085 /* Copy Ioctl Buffer structure */
1086 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1091 if(copy_to_user(IoBuffer.OutputBuffer,
1092 VER_FILEVERSION_STR, (UINT)IoBuffer.OutputLength))
1097 Status = STATUS_SUCCESS;
1100 case IOCTL_BCM_GET_CURRENT_STATUS:
1102 LINK_STATE plink_state;
1104 /* Copy Ioctl Buffer structure */
1105 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1107 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user failed..\n");
1111 if (IoBuffer.OutputLength != sizeof(plink_state)) {
1116 if (copy_from_user(&plink_state, (void __user *)arg, sizeof(plink_state))) {
1120 plink_state.bIdleMode = (UCHAR)Adapter->IdleMode;
1121 plink_state.bShutdownMode = Adapter->bShutStatus;
1122 plink_state.ucLinkStatus = (UCHAR)Adapter->LinkStatus;
1123 if (copy_to_user(IoBuffer.OutputBuffer, &plink_state, IoBuffer.OutputLength)) {
1124 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_to_user Failed..\n");
1128 Status = STATUS_SUCCESS;
1131 case IOCTL_BCM_SET_MAC_TRACING:
1134 /* copy ioctl Buffer structure */
1135 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1140 if(copy_from_user(&tracing_flag, IoBuffer.InputBuffer,sizeof(UINT)))
1146 Adapter->pTarangs->MacTracingEnabled = TRUE;
1148 Adapter->pTarangs->MacTracingEnabled = FALSE;
1151 case IOCTL_BCM_GET_DSX_INDICATION:
1154 if(copy_from_user((PCHAR)&IoBuffer, argp,
1155 sizeof(IOCTL_BUFFER)))
1157 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid IO buffer!!!" );
1161 if(IoBuffer.OutputLength < sizeof(stLocalSFAddIndicationAlt))
1163 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Mismatch req: %lx needed is =0x%zx!!!",
1164 IoBuffer.OutputLength, sizeof(stLocalSFAddIndicationAlt));
1167 if(copy_from_user(&ulSFId, IoBuffer.InputBuffer,
1170 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Invalid SFID!!! %lu", ulSFId );
1174 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Get DSX Data SF ID is =%lx\n", ulSFId );
1175 get_dsx_sf_data_to_application(Adapter, ulSFId,
1176 IoBuffer.OutputBuffer);
1177 Status=STATUS_SUCCESS;
1180 case IOCTL_BCM_GET_HOST_MIBS:
1184 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1186 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_from user for IoBuff failed\n");
1191 if(IoBuffer.OutputLength != sizeof(S_MIBS_HOST_STATS_MIBS))
1193 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Length Check failed %lu %zd\n", IoBuffer.OutputLength,
1194 sizeof(S_MIBS_HOST_STATS_MIBS));
1198 temp_buff = (PCHAR)kmalloc(IoBuffer.OutputLength, GFP_KERNEL);
1202 return STATUS_FAILURE;
1205 Status = ProcessGetHostMibs(Adapter,
1206 (PUCHAR)temp_buff, IoBuffer.OutputLength);
1208 Status = GetDroppedAppCntrlPktMibs((PVOID)temp_buff,
1209 (PPER_TARANG_DATA)filp->private_data);
1211 if(copy_to_user(IoBuffer.OutputBuffer,(PCHAR)temp_buff,
1212 sizeof(S_MIBS_HOST_STATS_MIBS)))
1214 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy to user failed\n");
1215 bcm_kfree(temp_buff);
1219 bcm_kfree(temp_buff);
1223 case IOCTL_BCM_WAKE_UP_DEVICE_FROM_IDLE:
1224 if((FALSE == Adapter->bTriedToWakeUpFromlowPowerMode) && (TRUE==Adapter->IdleMode))
1226 Adapter->usIdleModePattern = ABORT_IDLE_MODE;
1227 Adapter->bWakeUpDevice = TRUE;
1228 wake_up(&Adapter->process_rx_cntrlpkt);
1230 Adapter->bTriedToWakeUpFromlowPowerMode = TRUE;
1231 InterfaceAbortIdlemode (Adapter, Adapter->usIdleModePattern);
1234 Status = STATUS_SUCCESS;
1237 case IOCTL_BCM_BULK_WRM:
1239 PBULKWRM_BUFFER pBulkBuffer;
1241 PCHAR pvBuffer = NULL;
1243 if((Adapter->IdleMode == TRUE) ||
1244 (Adapter->bShutStatus ==TRUE) ||
1245 (Adapter->bPreparingForLowPowerMode ==TRUE))
1247 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Device in Idle/Shutdown Mode, Blocking Wrms\n");
1251 /* Copy Ioctl Buffer structure */
1252 if(copy_from_user((PCHAR)&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1258 pvBuffer=kmalloc(IoBuffer.InputLength, GFP_KERNEL);
1265 /* Get WrmBuffer structure */
1266 if(copy_from_user(pvBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength))
1268 bcm_kfree(pvBuffer);
1273 pBulkBuffer = (PBULKWRM_BUFFER)pvBuffer;
1275 if(((ULONG)pBulkBuffer->Register & 0x0F000000) != 0x0F000000 ||
1276 ((ULONG)pBulkBuffer->Register & 0x3))
1278 bcm_kfree(pvBuffer);
1279 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"WRM Done On invalid Address : %x Access Denied.\n",(int)pBulkBuffer->Register);
1285 uiTempVar = pBulkBuffer->Register & EEPROM_REJECT_MASK;
1286 if(!((Adapter->pstargetparams->m_u32Customize)&VSG_MODE)
1287 && ((uiTempVar == EEPROM_REJECT_REG_1)||
1288 (uiTempVar == EEPROM_REJECT_REG_2) ||
1289 (uiTempVar == EEPROM_REJECT_REG_3) ||
1290 (uiTempVar == EEPROM_REJECT_REG_4)) &&
1291 (cmd == IOCTL_BCM_REGISTER_WRITE))
1293 bcm_kfree(pvBuffer);
1294 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"EEPROM Access Denied, not in VSG Mode\n");
1299 if(pBulkBuffer->SwapEndian == FALSE)
1300 Status = wrmWithLock(Adapter, (UINT)pBulkBuffer->Register, (PCHAR)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
1302 Status = wrmaltWithLock(Adapter, (UINT)pBulkBuffer->Register, (PUINT)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
1304 if(Status != STATUS_SUCCESS)
1306 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Failed\n");
1309 bcm_kfree(pvBuffer);
1313 case IOCTL_BCM_GET_NVM_SIZE:
1316 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1318 //IOLog("failed NVM first");
1322 if(Adapter->eNVMType == NVM_EEPROM || Adapter->eNVMType == NVM_FLASH ) {
1323 if(copy_to_user(IoBuffer.OutputBuffer,
1324 (unsigned char *)&Adapter->uiNVMDSDSize, (UINT)sizeof(UINT)))
1331 Status = STATUS_SUCCESS ;
1335 case IOCTL_BCM_CAL_INIT :
1338 UINT uiSectorSize = 0 ;
1339 if(Adapter->eNVMType == NVM_FLASH)
1341 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1344 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy From User space failed. status :%d", Status);
1347 if (get_user(uiSectorSize, (unsigned int __user *)IoBuffer.InputBuffer))
1350 if((uiSectorSize < MIN_SECTOR_SIZE) || (uiSectorSize > MAX_SECTOR_SIZE))
1353 Status = copy_to_user(IoBuffer.OutputBuffer,
1354 (unsigned char *)&Adapter->uiSectorSize ,
1355 (UINT)sizeof(UINT));
1358 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Coping the sector size to use space failed. status:%d",Status);
1364 if(IsFlash2x(Adapter))
1366 Status = copy_to_user(IoBuffer.OutputBuffer,
1367 (unsigned char *)&Adapter->uiSectorSize ,
1368 (UINT)sizeof(UINT));
1371 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Coping the sector size to use space failed. status:%d",Status);
1378 if((TRUE == Adapter->bShutStatus) ||
1379 (TRUE == Adapter->IdleMode))
1381 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is in Idle/Shutdown Mode\n");
1385 Adapter->uiSectorSize = uiSectorSize ;
1386 BcmUpdateSectorSize(Adapter,Adapter->uiSectorSize);
1389 Status = STATUS_SUCCESS ;
1393 Status = STATUS_FAILURE;
1397 case IOCTL_BCM_SET_DEBUG :
1399 USER_BCM_DBG_STATE sUserDebugState;
1401 // BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Entered the ioctl %x \n", IOCTL_BCM_SET_DEBUG );
1403 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In SET_DEBUG ioctl\n");
1404 Status = copy_from_user((PCHAR)&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1407 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy from user failed\n");
1411 Status = copy_from_user(&sUserDebugState,IoBuffer.InputBuffer, sizeof(USER_BCM_DBG_STATE));
1414 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of IoBuffer.InputBuffer failed");
1418 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "IOCTL_BCM_SET_DEBUG: OnOff=%d Type = 0x%x ",
1419 sUserDebugState.OnOff, sUserDebugState.Type);
1420 //sUserDebugState.Subtype <<= 1;
1421 sUserDebugState.Subtype = 1 << sUserDebugState.Subtype;
1422 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "actual Subtype=0x%x\n", sUserDebugState.Subtype);
1424 // Update new 'DebugState' in the Adapter
1425 Adapter->stDebugState.type |= sUserDebugState.Type;
1426 /* Subtype: A bitmap of 32 bits for Subtype per Type.
1427 * Valid indexes in 'subtype' array: 1,2,4,8
1428 * corresponding to valid Type values. Hence we can use the 'Type' field
1429 * as the index value, ignoring the array entries 0,3,5,6,7 !
1431 if (sUserDebugState.OnOff)
1432 Adapter->stDebugState.subtype[sUserDebugState.Type] |= sUserDebugState.Subtype;
1434 Adapter->stDebugState.subtype[sUserDebugState.Type] &= ~sUserDebugState.Subtype;
1436 BCM_SHOW_DEBUG_BITMAP(Adapter);
1440 case IOCTL_BCM_NVM_READ:
1441 case IOCTL_BCM_NVM_WRITE:
1444 NVM_READWRITE stNVMReadWrite = {};
1445 PUCHAR pReadData = NULL;
1446 void __user * pBuffertobeCopied = NULL;
1447 ULONG ulDSDMagicNumInUsrBuff = 0 ;
1448 struct timeval tv0, tv1;
1449 memset(&tv0,0,sizeof(struct timeval));
1450 memset(&tv1,0,sizeof(struct timeval));
1451 if((Adapter->eNVMType == NVM_FLASH) && (Adapter->uiFlashLayoutMajorVersion == 0))
1453 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,"The Flash Control Section is Corrupted. Hence Rejection on NVM Read/Write\n");
1458 if(IsFlash2x(Adapter))
1460 if((Adapter->eActiveDSD != DSD0) &&
1461 (Adapter->eActiveDSD != DSD1) &&
1462 (Adapter->eActiveDSD != DSD2))
1464 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"No DSD is active..hence NVM Command is blocked");
1465 return STATUS_FAILURE ;
1469 /* Copy Ioctl Buffer structure */
1471 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1473 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copy_from_user failed\n");
1477 if(IOCTL_BCM_NVM_READ == cmd)
1478 pBuffertobeCopied = IoBuffer.OutputBuffer;
1480 pBuffertobeCopied = IoBuffer.InputBuffer;
1482 if(copy_from_user(&stNVMReadWrite, pBuffertobeCopied,sizeof(NVM_READWRITE)))
1489 // Deny the access if the offset crosses the cal area limit.
1491 if((stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) > Adapter->uiNVMDSDSize)
1493 //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Can't allow access beyond NVM Size: 0x%x 0x%x\n", stNVMReadWrite.uiOffset ,
1494 // stNVMReadWrite.uiNumBytes);
1495 Status = STATUS_FAILURE;
1499 pReadData =(PCHAR)kmalloc(stNVMReadWrite.uiNumBytes, GFP_KERNEL);
1504 memset(pReadData,0,stNVMReadWrite.uiNumBytes);
1506 if(copy_from_user(pReadData, stNVMReadWrite.pBuffer,
1507 stNVMReadWrite.uiNumBytes))
1510 bcm_kfree(pReadData);
1514 do_gettimeofday(&tv0);
1515 if(IOCTL_BCM_NVM_READ == cmd)
1517 down(&Adapter->NVMRdmWrmLock);
1519 if((Adapter->IdleMode == TRUE) ||
1520 (Adapter->bShutStatus ==TRUE) ||
1521 (Adapter->bPreparingForLowPowerMode ==TRUE))
1523 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1524 up(&Adapter->NVMRdmWrmLock);
1525 bcm_kfree(pReadData);
1529 Status = BeceemNVMRead(Adapter, (PUINT)pReadData,
1530 stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes);
1532 up(&Adapter->NVMRdmWrmLock);
1534 if(Status != STATUS_SUCCESS)
1536 bcm_kfree(pReadData);
1539 if(copy_to_user(stNVMReadWrite.pBuffer,
1540 pReadData, (UINT)stNVMReadWrite.uiNumBytes))
1542 bcm_kfree(pReadData);
1549 down(&Adapter->NVMRdmWrmLock);
1551 if((Adapter->IdleMode == TRUE) ||
1552 (Adapter->bShutStatus ==TRUE) ||
1553 (Adapter->bPreparingForLowPowerMode ==TRUE))
1555 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1556 up(&Adapter->NVMRdmWrmLock);
1557 bcm_kfree(pReadData);
1561 Adapter->bHeaderChangeAllowed = TRUE ;
1562 if(IsFlash2x(Adapter))
1566 DSD section updation will be allowed in two case:-
1567 1. if DSD sig is present in DSD header means dongle is ok and updation is fruitfull
1568 2. if point 1 failes then user buff should have DSD sig. this point ensures that if dongle is
1569 corrupted then user space program first modify the DSD header with valid DSD sig so
1570 that this as well as further write may be worthwhile.
1572 This restriction has been put assuming that if DSD sig is corrupted, DSD
1573 data won't be considered valid.
1577 Status = BcmFlash2xCorruptSig(Adapter,Adapter->eActiveDSD);
1578 if(Status != STATUS_SUCCESS)
1580 if(( (stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) != Adapter->uiNVMDSDSize ) ||
1581 (stNVMReadWrite.uiNumBytes < SIGNATURE_SIZE))
1583 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
1584 up(&Adapter->NVMRdmWrmLock);
1585 bcm_kfree(pReadData);
1589 ulDSDMagicNumInUsrBuff = ntohl(*(PUINT)(pReadData + stNVMReadWrite.uiNumBytes - SIGNATURE_SIZE));
1590 if(ulDSDMagicNumInUsrBuff != DSD_IMAGE_MAGIC_NUMBER)
1592 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
1593 up(&Adapter->NVMRdmWrmLock);
1594 bcm_kfree(pReadData);
1599 Status = BeceemNVMWrite(Adapter, (PUINT )pReadData,
1600 stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes, stNVMReadWrite.bVerify);
1601 if(IsFlash2x(Adapter))
1602 BcmFlash2xWriteSig(Adapter,Adapter->eActiveDSD);
1604 Adapter->bHeaderChangeAllowed = FALSE ;
1606 up(&Adapter->NVMRdmWrmLock);
1609 if(Status != STATUS_SUCCESS)
1611 bcm_kfree(pReadData);
1615 do_gettimeofday(&tv1);
1616 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);
1619 bcm_kfree(pReadData);
1620 Status = STATUS_SUCCESS;
1623 case IOCTL_BCM_FLASH2X_SECTION_READ :
1626 FLASH2X_READWRITE sFlash2xRead = {0};
1627 PUCHAR pReadBuff = NULL ;
1631 UINT ReadOffset = 0;
1632 char __user *OutPutBuff = NULL;
1634 if(IsFlash2x(Adapter) != TRUE)
1636 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1640 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_FLASH2X_SECTION_READ Called");
1641 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1644 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1648 //Reading FLASH 2.x READ structure
1649 Status = copy_from_user(&sFlash2xRead, IoBuffer.InputBuffer,sizeof(FLASH2X_READWRITE));
1652 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Input Buffer failed");
1657 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xRead.Section);
1658 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%x" ,sFlash2xRead.offset);
1659 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xRead.numOfBytes);
1660 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xRead.bVerify);
1662 //This was internal to driver for raw read. now it has ben exposed to user space app.
1663 if(validateFlash2xReadWrite(Adapter,&sFlash2xRead) == FALSE)
1664 return STATUS_FAILURE ;
1666 NOB = sFlash2xRead.numOfBytes;
1667 if(NOB > Adapter->uiSectorSize )
1668 BuffSize = Adapter->uiSectorSize;
1672 ReadOffset = sFlash2xRead.offset ;
1673 OutPutBuff = IoBuffer.OutputBuffer;
1676 pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
1677 if(pReadBuff == NULL)
1679 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
1682 down(&Adapter->NVMRdmWrmLock);
1684 if((Adapter->IdleMode == TRUE) ||
1685 (Adapter->bShutStatus ==TRUE) ||
1686 (Adapter->bPreparingForLowPowerMode ==TRUE))
1688 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1689 up(&Adapter->NVMRdmWrmLock);
1690 bcm_kfree(pReadBuff);
1697 if(NOB > Adapter->uiSectorSize )
1698 ReadBytes = Adapter->uiSectorSize;
1703 //Reading the data from Flash 2.x
1705 Status = BcmFlash2xBulkRead(Adapter,(PUINT)pReadBuff,sFlash2xRead.Section,ReadOffset,ReadBytes);
1708 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Flash 2x read err with Status :%d", Status);
1712 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes);
1714 Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes);
1717 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Copy to use failed with status :%d", Status);
1721 NOB = NOB - ReadBytes;
1724 ReadOffset = ReadOffset + ReadBytes ;
1725 OutPutBuff = OutPutBuff + ReadBytes ;
1729 up(&Adapter->NVMRdmWrmLock);
1730 bcm_kfree(pReadBuff);
1734 case IOCTL_BCM_FLASH2X_SECTION_WRITE :
1736 FLASH2X_READWRITE sFlash2xWrite = {0};
1737 PUCHAR pWriteBuff = NULL;
1738 void __user *InputAddr = NULL;
1741 UINT WriteOffset = 0;
1742 UINT WriteBytes = 0;
1744 if(IsFlash2x(Adapter) != TRUE)
1746 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1750 //First make this False so that we can enable the Sector Permission Check in BeceemFlashBulkWrite
1751 Adapter->bAllDSDWriteAllow = FALSE;
1754 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_FLASH2X_SECTION_WRITE Called");
1755 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1758 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1762 //Reading FLASH 2.x READ structure
1763 Status = copy_from_user(&sFlash2xWrite, IoBuffer.InputBuffer, sizeof(FLASH2X_READWRITE));
1766 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Reading of output Buffer from IOCTL buffer fails");
1770 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xWrite.Section);
1771 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%d" ,sFlash2xWrite.offset);
1772 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xWrite.numOfBytes);
1773 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xWrite.bVerify);
1775 if((sFlash2xWrite.Section == ISO_IMAGE1) ||(sFlash2xWrite.Section == ISO_IMAGE2) ||
1776 (sFlash2xWrite.Section == DSD0) || (sFlash2xWrite.Section == DSD1) || (sFlash2xWrite.Section == DSD2))
1778 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"ISO/DSD Image write is not allowed.... ");
1779 return STATUS_FAILURE ;
1782 if((sFlash2xWrite.Section != VSA0) && (sFlash2xWrite.Section != VSA1) &&
1783 (sFlash2xWrite.Section != VSA2) )
1785 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Only VSA write is allowed");
1789 if(validateFlash2xReadWrite(Adapter,&sFlash2xWrite) == FALSE)
1790 return STATUS_FAILURE ;
1792 InputAddr = sFlash2xWrite.pDataBuff;
1793 WriteOffset = sFlash2xWrite.offset ;
1794 NOB = sFlash2xWrite.numOfBytes;
1796 if(NOB > Adapter->uiSectorSize )
1797 BuffSize = Adapter->uiSectorSize;
1801 pWriteBuff = (PCHAR)kmalloc(BuffSize, GFP_KERNEL);
1802 if(pWriteBuff == NULL)
1804 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
1808 //extracting the remainder of the given offset.
1809 WriteBytes = Adapter->uiSectorSize ;
1810 if(WriteOffset % Adapter->uiSectorSize)
1811 WriteBytes =Adapter->uiSectorSize - (WriteOffset % Adapter->uiSectorSize);
1812 if(NOB < WriteBytes)
1815 down(&Adapter->NVMRdmWrmLock);
1817 if((Adapter->IdleMode == TRUE) ||
1818 (Adapter->bShutStatus ==TRUE) ||
1819 (Adapter->bPreparingForLowPowerMode ==TRUE))
1821 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1822 up(&Adapter->NVMRdmWrmLock);
1823 bcm_kfree(pWriteBuff);
1827 BcmFlash2xCorruptSig(Adapter,sFlash2xWrite.Section);
1830 Status = copy_from_user(pWriteBuff,InputAddr,WriteBytes);
1833 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to user failed with status :%d", Status);
1837 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pWriteBuff,WriteBytes);
1838 //Writing the data from Flash 2.x
1839 Status = BcmFlash2xBulkWrite(Adapter,(PUINT)pWriteBuff,sFlash2xWrite.Section,WriteOffset,WriteBytes,sFlash2xWrite.bVerify);
1843 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
1847 NOB = NOB - WriteBytes;
1850 WriteOffset = WriteOffset + WriteBytes ;
1851 InputAddr = InputAddr + WriteBytes ;
1852 if(NOB > Adapter->uiSectorSize )
1853 WriteBytes = Adapter->uiSectorSize;
1860 BcmFlash2xWriteSig(Adapter,sFlash2xWrite.Section);
1861 up(&Adapter->NVMRdmWrmLock);
1862 bcm_kfree(pWriteBuff);
1865 case IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP :
1868 PFLASH2X_BITMAP psFlash2xBitMap = NULL ;
1869 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP Called");
1871 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1874 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1877 if(IoBuffer.OutputLength != sizeof(FLASH2X_BITMAP))
1879 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Structure size mismatch Lib :0x%lx Driver :0x%zx ",IoBuffer.OutputLength, sizeof(FLASH2X_BITMAP));
1883 psFlash2xBitMap = (PFLASH2X_BITMAP)kzalloc(sizeof(FLASH2X_BITMAP), GFP_KERNEL);
1884 if(psFlash2xBitMap == NULL)
1886 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory is not available");
1889 //Reading the Flash Sectio Bit map
1890 down(&Adapter->NVMRdmWrmLock);
1892 if((Adapter->IdleMode == TRUE) ||
1893 (Adapter->bShutStatus ==TRUE) ||
1894 (Adapter->bPreparingForLowPowerMode ==TRUE))
1896 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1897 up(&Adapter->NVMRdmWrmLock);
1898 bcm_kfree(psFlash2xBitMap);
1902 BcmGetFlash2xSectionalBitMap(Adapter, psFlash2xBitMap);
1903 up(&Adapter->NVMRdmWrmLock);
1904 Status = copy_to_user(IoBuffer.OutputBuffer, psFlash2xBitMap, sizeof(FLASH2X_BITMAP));
1907 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash2x bitMap failed");
1908 bcm_kfree(psFlash2xBitMap);
1911 bcm_kfree(psFlash2xBitMap);
1914 case IOCTL_BCM_SET_ACTIVE_SECTION :
1916 FLASH2X_SECTION_VAL eFlash2xSectionVal = 0;
1917 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SET_ACTIVE_SECTION Called");
1919 if(IsFlash2x(Adapter) != TRUE)
1921 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1925 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1928 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1932 Status = copy_from_user(&eFlash2xSectionVal,IoBuffer.InputBuffer, sizeof(INT));
1935 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
1939 down(&Adapter->NVMRdmWrmLock);
1941 if((Adapter->IdleMode == TRUE) ||
1942 (Adapter->bShutStatus ==TRUE) ||
1943 (Adapter->bPreparingForLowPowerMode ==TRUE))
1945 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1946 up(&Adapter->NVMRdmWrmLock);
1950 Status = BcmSetActiveSection(Adapter,eFlash2xSectionVal);
1953 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed to make it's priority Highest. Status %d", Status);
1955 up(&Adapter->NVMRdmWrmLock);
1958 case IOCTL_BCM_IDENTIFY_ACTIVE_SECTION :
1960 //Right Now we are taking care of only DSD
1961 Adapter->bAllDSDWriteAllow = FALSE ;
1962 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_IDENTIFY_ACTIVE_SECTION called");
1965 SECTION_TYPE section = 0 ;
1968 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_IDENTIFY_ACTIVE_SECTION Called");
1969 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1972 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy of IOCTL BUFFER failed");
1975 Status = copy_from_user((PCHAR)section,(PCHAR)&IoBuffer, sizeof(INT));
1978 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy of section type failed failed");
1981 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", section);
1983 Adapter->ulFlashCalStart = Adapter->uiActiveDSDOffsetAtFwDld ;
1985 Status = STATUS_FAILURE ;
1987 Status = STATUS_SUCCESS ;
1990 case IOCTL_BCM_COPY_SECTION :
1992 FLASH2X_COPY_SECTION sCopySectStrut = {0};
1993 Status = STATUS_SUCCESS;
1994 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_COPY_SECTION Called");
1996 Adapter->bAllDSDWriteAllow = FALSE ;
1997 if(IsFlash2x(Adapter) != TRUE)
1999 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
2003 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2006 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed Status :%d", Status);
2010 Status = copy_from_user(&sCopySectStrut,IoBuffer.InputBuffer, sizeof(FLASH2X_COPY_SECTION));
2013 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Copy_Section_Struct failed with Status :%d", Status);
2016 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Source SEction :%x", sCopySectStrut.SrcSection);
2017 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Destination SEction :%x", sCopySectStrut.DstSection);
2018 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "offset :%x", sCopySectStrut.offset);
2019 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "NOB :%x", sCopySectStrut.numOfBytes);
2022 if(IsSectionExistInFlash(Adapter,sCopySectStrut.SrcSection) == FALSE)
2024 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Source Section<%x> does not exixt in Flash ", sCopySectStrut.SrcSection);
2028 if(IsSectionExistInFlash(Adapter,sCopySectStrut.DstSection) == FALSE)
2030 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Destinatio Section<%x> does not exixt in Flash ", sCopySectStrut.DstSection);
2034 if(sCopySectStrut.SrcSection == sCopySectStrut.DstSection)
2036 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Source and Destination section should be different");
2040 down(&Adapter->NVMRdmWrmLock);
2042 if((Adapter->IdleMode == TRUE) ||
2043 (Adapter->bShutStatus ==TRUE) ||
2044 (Adapter->bPreparingForLowPowerMode ==TRUE))
2046 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2047 up(&Adapter->NVMRdmWrmLock);
2051 if(sCopySectStrut.SrcSection == ISO_IMAGE1 || sCopySectStrut.SrcSection == ISO_IMAGE2)
2053 if(IsNonCDLessDevice(Adapter))
2055 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is Non-CDLess hence won't have ISO !!");
2058 else if(sCopySectStrut.numOfBytes == 0)
2060 Status = BcmCopyISO(Adapter,sCopySectStrut);
2064 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Partial Copy of ISO section is not Allowed..");
2065 Status = STATUS_FAILURE ;
2067 up(&Adapter->NVMRdmWrmLock);
2071 Status = BcmCopySection(Adapter, sCopySectStrut.SrcSection,
2072 sCopySectStrut.DstSection,sCopySectStrut.offset,sCopySectStrut.numOfBytes);
2073 up(&Adapter->NVMRdmWrmLock);
2076 case IOCTL_BCM_GET_FLASH_CS_INFO :
2078 Status = STATUS_SUCCESS;
2079 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_GET_FLASH_CS_INFO Called");
2081 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2084 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2088 if(Adapter->eNVMType != NVM_FLASH)
2090 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Connected device does not have flash");
2094 if(IsFlash2x(Adapter) == TRUE)
2097 if(IoBuffer.OutputLength < sizeof(FLASH2X_CS_INFO))
2099 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0," Passed buffer size:0x%lX is insufficient for the CS structure.. \nRequired size :0x%zx ",IoBuffer.OutputLength, sizeof(FLASH2X_CS_INFO));
2104 Status = copy_to_user(IoBuffer.OutputBuffer, Adapter->psFlash2xCSInfo, sizeof(FLASH2X_CS_INFO));
2107 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash2x cs info failed");
2114 if(IoBuffer.OutputLength < sizeof(FLASH_CS_INFO))
2116 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0," Passed buffer size:0x%lX is insufficient for the CS structure.. Required size :0x%zx ",IoBuffer.OutputLength, sizeof(FLASH_CS_INFO));
2120 Status = copy_to_user(IoBuffer.OutputBuffer, Adapter->psFlashCSInfo, sizeof(FLASH_CS_INFO));
2123 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash CS info failed");
2131 case IOCTL_BCM_SELECT_DSD :
2134 FLASH2X_SECTION_VAL eFlash2xSectionVal;
2135 eFlash2xSectionVal = NO_SECTION_VAL ;
2136 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_SELECT_DSD Called");
2138 if(IsFlash2x(Adapter) != TRUE)
2140 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
2144 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2147 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2150 Status = copy_from_user(&eFlash2xSectionVal,IoBuffer.InputBuffer, sizeof(INT));
2153 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
2157 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", eFlash2xSectionVal);
2158 if((eFlash2xSectionVal != DSD0) &&
2159 (eFlash2xSectionVal != DSD1) &&
2160 (eFlash2xSectionVal != DSD2) )
2162 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Passed section<%x> is not DSD section", eFlash2xSectionVal);
2163 return STATUS_FAILURE ;
2166 SectOfset= BcmGetSectionValStartOffset(Adapter,eFlash2xSectionVal);
2167 if(SectOfset == INVALID_OFFSET)
2169 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Provided Section val <%d> does not exixt in Flash 2.x", eFlash2xSectionVal);
2173 Adapter->bAllDSDWriteAllow = TRUE ;
2175 Adapter->ulFlashCalStart = SectOfset ;
2176 Adapter->eActiveDSD = eFlash2xSectionVal;
2178 Status = STATUS_SUCCESS ;
2181 case IOCTL_BCM_NVM_RAW_READ :
2184 NVM_READWRITE stNVMRead = {};
2188 UINT ReadBytes = 0 ;
2189 PUCHAR pReadBuff = NULL ;
2190 char __user *OutPutBuff = NULL ;
2192 if(Adapter->eNVMType != NVM_FLASH)
2194 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"NVM TYPE is not Flash ");
2198 /* Copy Ioctl Buffer structure */
2199 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
2201 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
2206 if(copy_from_user(&stNVMRead, IoBuffer.OutputBuffer,sizeof(NVM_READWRITE)))
2212 NOB = stNVMRead.uiNumBytes;
2213 //In Raw-Read max Buff size : 64MB
2215 if(NOB > DEFAULT_BUFF_SIZE)
2216 BuffSize = DEFAULT_BUFF_SIZE;
2220 ReadOffset = stNVMRead.uiOffset ;
2221 OutPutBuff = stNVMRead.pBuffer;
2224 pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
2225 if(pReadBuff == NULL)
2227 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
2231 down(&Adapter->NVMRdmWrmLock);
2233 if((Adapter->IdleMode == TRUE) ||
2234 (Adapter->bShutStatus ==TRUE) ||
2235 (Adapter->bPreparingForLowPowerMode ==TRUE))
2237 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2238 bcm_kfree(pReadBuff);
2239 up(&Adapter->NVMRdmWrmLock);
2243 Adapter->bFlashRawRead = TRUE ;
2246 if(NOB > DEFAULT_BUFF_SIZE )
2247 ReadBytes = DEFAULT_BUFF_SIZE;
2251 //Reading the data from Flash 2.x
2252 Status = BeceemNVMRead(Adapter,(PUINT)pReadBuff,ReadOffset,ReadBytes);
2255 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
2259 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes);
2261 Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes);
2264 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to use failed with status :%d", Status);
2268 NOB = NOB - ReadBytes;
2271 ReadOffset = ReadOffset + ReadBytes ;
2272 OutPutBuff = OutPutBuff + ReadBytes ;
2276 Adapter->bFlashRawRead = FALSE ;
2277 up(&Adapter->NVMRdmWrmLock);
2278 bcm_kfree(pReadBuff);
2282 case IOCTL_BCM_CNTRLMSG_MASK:
2284 ULONG RxCntrlMsgBitMask = 0 ;
2286 /* Copy Ioctl Buffer structure */
2287 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2290 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of Ioctl buffer is failed from user space");
2295 Status = copy_from_user(&RxCntrlMsgBitMask, IoBuffer.InputBuffer, IoBuffer.InputLength);
2298 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of control bit mask failed from user space");
2302 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\n Got user defined cntrl msg bit mask :%lx", RxCntrlMsgBitMask);
2303 pTarang->RxCntrlMsgBitMask = RxCntrlMsgBitMask ;
2306 case IOCTL_BCM_GET_DEVICE_DRIVER_INFO:
2308 DEVICE_DRIVER_INFO DevInfo;
2310 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Called IOCTL_BCM_GET_DEVICE_DRIVER_INFO\n");
2312 DevInfo.MaxRDMBufferSize = BUFFER_4K;
2313 DevInfo.u32DSDStartOffset = EEPROM_CALPARAM_START;
2314 DevInfo.u32RxAlignmentCorrection = 0;
2315 DevInfo.u32NVMType = Adapter->eNVMType;
2316 DevInfo.u32InterfaceType = BCM_USB;
2318 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2321 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2325 if(IoBuffer.OutputLength < sizeof(DevInfo))
2327 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"User Passed buffer length is less than actural buffer size");
2328 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"user passed buffer size :0x%lX, expected size :0x%zx",IoBuffer.OutputLength, sizeof(DevInfo));
2332 Status = copy_to_user(IoBuffer.OutputBuffer, &DevInfo, sizeof(DevInfo));
2335 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copying Dev info structure to user space buffer failed");
2342 case IOCTL_BCM_TIME_SINCE_NET_ENTRY:
2344 ST_TIME_ELAPSED stTimeElapsedSinceNetEntry = {0};
2345 struct timeval tv = {0} ;
2347 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_TIME_SINCE_NET_ENTRY called");
2349 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2352 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2356 if(IoBuffer.OutputLength < sizeof(ST_TIME_ELAPSED))
2358 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"User Passed buffer length:0x%lx is less than expected buff size :0x%zX",IoBuffer.OutputLength,sizeof(ST_TIME_ELAPSED));
2363 //stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = Adapter->liTimeSinceLastNetEntry;
2364 do_gettimeofday(&tv);
2365 stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = tv.tv_sec - Adapter->liTimeSinceLastNetEntry;
2367 Status = copy_to_user(IoBuffer.OutputBuffer, &stTimeElapsedSinceNetEntry, sizeof(ST_TIME_ELAPSED));
2370 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copying ST_TIME_ELAPSED structure to user space buffer failed");
2379 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "wrong input %x",cmd);
2380 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In default ioctl %d\n", cmd);
2381 Status = STATUS_FAILURE;
2389 static struct file_operations bcm_fops = {
2390 .owner = THIS_MODULE,
2391 .open = bcm_char_open,
2392 .release = bcm_char_release,
2393 .read = bcm_char_read,
2394 .unlocked_ioctl = bcm_char_ioctl,
2395 .llseek = no_llseek,
2399 int register_control_device_interface(PMINI_ADAPTER Adapter)
2401 if(Adapter->major>0)
2402 return Adapter->major;
2403 Adapter->major = register_chrdev(0, "tarang", &bcm_fops);
2404 if(Adapter->major < 0)
2406 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "register_chrdev:Failed to registering WiMax control char device!");
2407 return Adapter->major;
2411 bcm_class = class_create (THIS_MODULE, "tarang");
2412 if(IS_ERR (bcm_class))
2414 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unable to create class\n");
2415 unregister_chrdev(Adapter->major, "tarang");
2419 Adapter->pstCreatedClassDevice = device_create (bcm_class, NULL,
2420 MKDEV(Adapter->major, 0),
2421 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
2426 if(IS_ERR(Adapter->pstCreatedClassDevice))
2428 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "class device did not get created : %ld", PTR_ERR(Adapter->pstCreatedClassDevice) );
2430 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Got Major No: %d", Adapter->major);
2434 void unregister_control_device_interface(PMINI_ADAPTER Adapter)
2436 if(Adapter->major > 0)
2438 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "destroying class device");
2439 device_destroy (bcm_class, MKDEV(Adapter->major, 0));
2441 if(!IS_ERR(bcm_class))
2443 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "destroying created class ");
2444 class_destroy (bcm_class);
2447 if(Adapter->major > 0)
2449 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"unregistering character interface");
2450 unregister_chrdev(Adapter->major, "tarang");