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:
1004 Adapter->BEBucketSize = *(PULONG)arg;
1005 Status = STATUS_SUCCESS;
1008 case IOCTL_RTPS_BUCKET_SIZE:
1009 Adapter->rtPSBucketSize = *(PULONG)arg;
1010 Status = STATUS_SUCCESS;
1012 case IOCTL_CHIP_RESET:
1014 INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
1017 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
1020 down(&Adapter->RxAppControlQueuelock);
1021 Status = reset_card_proc(Adapter);
1023 up(&Adapter->RxAppControlQueuelock);
1024 up(&Adapter->NVMRdmWrmLock);
1025 ResetCounters(Adapter);
1028 case IOCTL_QOS_THRESHOLD:
1031 for(uiLoopIndex = 0 ; uiLoopIndex < NO_OF_QUEUES ; uiLoopIndex++)
1033 Adapter->PackInfo[uiLoopIndex].uiThreshold = *(PULONG)arg;
1035 Status = STATUS_SUCCESS;
1039 case IOCTL_DUMP_PACKET_INFO:
1041 DumpPackInfo(Adapter);
1042 DumpPhsRules(&Adapter->stBCMPhsContext);
1043 Status = STATUS_SUCCESS;
1046 case IOCTL_GET_PACK_INFO:
1047 if(copy_to_user(argp, &Adapter->PackInfo,
1048 sizeof(PacketInfo)*NO_OF_QUEUES))
1053 Status = STATUS_SUCCESS;
1055 case IOCTL_BCM_SWITCH_TRANSFER_MODE:
1058 if(copy_from_user(&uiData, argp, sizeof(UINT)))
1063 if(uiData) /* Allow All Packets */
1065 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: ETH_PACKET_TUNNELING_MODE\n");
1066 Adapter->TransferMode = ETH_PACKET_TUNNELING_MODE;
1068 else /* Allow IP only Packets */
1070 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: IP_PACKET_ONLY_MODE\n");
1071 Adapter->TransferMode = IP_PACKET_ONLY_MODE;
1073 Status = STATUS_SUCCESS;
1077 case IOCTL_BCM_GET_DRIVER_VERSION:
1079 /* Copy Ioctl Buffer structure */
1080 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1085 if(copy_to_user(IoBuffer.OutputBuffer,
1086 VER_FILEVERSION_STR, (UINT)IoBuffer.OutputLength))
1091 Status = STATUS_SUCCESS;
1094 case IOCTL_BCM_GET_CURRENT_STATUS:
1096 LINK_STATE *plink_state = NULL;
1097 /* Copy Ioctl Buffer structure */
1098 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1100 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user failed..\n");
1104 plink_state = (LINK_STATE*)arg;
1105 plink_state->bIdleMode = (UCHAR)Adapter->IdleMode;
1106 plink_state->bShutdownMode = Adapter->bShutStatus;
1107 plink_state->ucLinkStatus = (UCHAR)Adapter->LinkStatus;
1108 if(copy_to_user(IoBuffer.OutputBuffer,
1109 (PUCHAR)plink_state, (UINT)IoBuffer.OutputLength))
1111 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_to_user Failed..\n");
1115 Status = STATUS_SUCCESS;
1118 case IOCTL_BCM_SET_MAC_TRACING:
1121 /* copy ioctl Buffer structure */
1122 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1127 if(copy_from_user(&tracing_flag, IoBuffer.InputBuffer,sizeof(UINT)))
1133 Adapter->pTarangs->MacTracingEnabled = TRUE;
1135 Adapter->pTarangs->MacTracingEnabled = FALSE;
1138 case IOCTL_BCM_GET_DSX_INDICATION:
1141 if(copy_from_user((PCHAR)&IoBuffer, argp,
1142 sizeof(IOCTL_BUFFER)))
1144 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid IO buffer!!!" );
1148 if(IoBuffer.OutputLength < sizeof(stLocalSFAddIndicationAlt))
1150 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Mismatch req: %lx needed is =0x%zx!!!",
1151 IoBuffer.OutputLength, sizeof(stLocalSFAddIndicationAlt));
1154 if(copy_from_user(&ulSFId, IoBuffer.InputBuffer,
1157 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Invalid SFID!!! %lu", ulSFId );
1161 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Get DSX Data SF ID is =%lx\n", ulSFId );
1162 get_dsx_sf_data_to_application(Adapter, ulSFId,
1163 IoBuffer.OutputBuffer);
1164 Status=STATUS_SUCCESS;
1167 case IOCTL_BCM_GET_HOST_MIBS:
1171 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1173 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_from user for IoBuff failed\n");
1178 if(IoBuffer.OutputLength != sizeof(S_MIBS_HOST_STATS_MIBS))
1180 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Length Check failed %lu %zd\n", IoBuffer.OutputLength,
1181 sizeof(S_MIBS_HOST_STATS_MIBS));
1185 temp_buff = (PCHAR)kmalloc(IoBuffer.OutputLength, GFP_KERNEL);
1189 return STATUS_FAILURE;
1192 Status = ProcessGetHostMibs(Adapter,
1193 (PUCHAR)temp_buff, IoBuffer.OutputLength);
1195 Status = GetDroppedAppCntrlPktMibs((PVOID)temp_buff,
1196 (PPER_TARANG_DATA)filp->private_data);
1198 if(copy_to_user(IoBuffer.OutputBuffer,(PCHAR)temp_buff,
1199 sizeof(S_MIBS_HOST_STATS_MIBS)))
1201 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy to user failed\n");
1202 bcm_kfree(temp_buff);
1206 bcm_kfree(temp_buff);
1210 case IOCTL_BCM_WAKE_UP_DEVICE_FROM_IDLE:
1211 if((FALSE == Adapter->bTriedToWakeUpFromlowPowerMode) && (TRUE==Adapter->IdleMode))
1213 Adapter->usIdleModePattern = ABORT_IDLE_MODE;
1214 Adapter->bWakeUpDevice = TRUE;
1215 wake_up(&Adapter->process_rx_cntrlpkt);
1217 Adapter->bTriedToWakeUpFromlowPowerMode = TRUE;
1218 InterfaceAbortIdlemode (Adapter, Adapter->usIdleModePattern);
1221 Status = STATUS_SUCCESS;
1224 case IOCTL_BCM_BULK_WRM:
1226 PBULKWRM_BUFFER pBulkBuffer;
1228 PCHAR pvBuffer = NULL;
1230 if((Adapter->IdleMode == TRUE) ||
1231 (Adapter->bShutStatus ==TRUE) ||
1232 (Adapter->bPreparingForLowPowerMode ==TRUE))
1234 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Device in Idle/Shutdown Mode, Blocking Wrms\n");
1238 /* Copy Ioctl Buffer structure */
1239 if(copy_from_user((PCHAR)&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1245 pvBuffer=kmalloc(IoBuffer.InputLength, GFP_KERNEL);
1252 /* Get WrmBuffer structure */
1253 if(copy_from_user(pvBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength))
1255 bcm_kfree(pvBuffer);
1260 pBulkBuffer = (PBULKWRM_BUFFER)pvBuffer;
1262 if(((ULONG)pBulkBuffer->Register & 0x0F000000) != 0x0F000000 ||
1263 ((ULONG)pBulkBuffer->Register & 0x3))
1265 bcm_kfree(pvBuffer);
1266 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"WRM Done On invalid Address : %x Access Denied.\n",(int)pBulkBuffer->Register);
1272 uiTempVar = pBulkBuffer->Register & EEPROM_REJECT_MASK;
1273 if(!((Adapter->pstargetparams->m_u32Customize)&VSG_MODE)
1274 && ((uiTempVar == EEPROM_REJECT_REG_1)||
1275 (uiTempVar == EEPROM_REJECT_REG_2) ||
1276 (uiTempVar == EEPROM_REJECT_REG_3) ||
1277 (uiTempVar == EEPROM_REJECT_REG_4)) &&
1278 (cmd == IOCTL_BCM_REGISTER_WRITE))
1280 bcm_kfree(pvBuffer);
1281 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"EEPROM Access Denied, not in VSG Mode\n");
1286 if(pBulkBuffer->SwapEndian == FALSE)
1287 Status = wrmWithLock(Adapter, (UINT)pBulkBuffer->Register, (PCHAR)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
1289 Status = wrmaltWithLock(Adapter, (UINT)pBulkBuffer->Register, (PUINT)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
1291 if(Status != STATUS_SUCCESS)
1293 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Failed\n");
1296 bcm_kfree(pvBuffer);
1300 case IOCTL_BCM_GET_NVM_SIZE:
1303 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1305 //IOLog("failed NVM first");
1309 if(Adapter->eNVMType == NVM_EEPROM || Adapter->eNVMType == NVM_FLASH ) {
1310 if(copy_to_user(IoBuffer.OutputBuffer,
1311 (unsigned char *)&Adapter->uiNVMDSDSize, (UINT)sizeof(UINT)))
1318 Status = STATUS_SUCCESS ;
1322 case IOCTL_BCM_CAL_INIT :
1325 UINT uiSectorSize = 0 ;
1326 if(Adapter->eNVMType == NVM_FLASH)
1328 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1331 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy From User space failed. status :%d", Status);
1334 uiSectorSize = *((PUINT)(IoBuffer.InputBuffer)); /* FIXME: unchecked __user access */
1335 if((uiSectorSize < MIN_SECTOR_SIZE) || (uiSectorSize > MAX_SECTOR_SIZE))
1338 Status = copy_to_user(IoBuffer.OutputBuffer,
1339 (unsigned char *)&Adapter->uiSectorSize ,
1340 (UINT)sizeof(UINT));
1343 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Coping the sector size to use space failed. status:%d",Status);
1349 if(IsFlash2x(Adapter))
1351 Status = copy_to_user(IoBuffer.OutputBuffer,
1352 (unsigned char *)&Adapter->uiSectorSize ,
1353 (UINT)sizeof(UINT));
1356 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Coping the sector size to use space failed. status:%d",Status);
1363 if((TRUE == Adapter->bShutStatus) ||
1364 (TRUE == Adapter->IdleMode))
1366 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is in Idle/Shutdown Mode\n");
1370 Adapter->uiSectorSize = uiSectorSize ;
1371 BcmUpdateSectorSize(Adapter,Adapter->uiSectorSize);
1374 Status = STATUS_SUCCESS ;
1378 Status = STATUS_FAILURE;
1382 case IOCTL_BCM_SET_DEBUG :
1384 USER_BCM_DBG_STATE sUserDebugState;
1386 // BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Entered the ioctl %x \n", IOCTL_BCM_SET_DEBUG );
1388 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In SET_DEBUG ioctl\n");
1389 Status = copy_from_user((PCHAR)&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1392 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy from user failed\n");
1396 Status = copy_from_user(&sUserDebugState,IoBuffer.InputBuffer, sizeof(USER_BCM_DBG_STATE));
1399 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of IoBuffer.InputBuffer failed");
1403 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "IOCTL_BCM_SET_DEBUG: OnOff=%d Type = 0x%x ",
1404 sUserDebugState.OnOff, sUserDebugState.Type);
1405 //sUserDebugState.Subtype <<= 1;
1406 sUserDebugState.Subtype = 1 << sUserDebugState.Subtype;
1407 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "actual Subtype=0x%x\n", sUserDebugState.Subtype);
1409 // Update new 'DebugState' in the Adapter
1410 Adapter->stDebugState.type |= sUserDebugState.Type;
1411 /* Subtype: A bitmap of 32 bits for Subtype per Type.
1412 * Valid indexes in 'subtype' array: 1,2,4,8
1413 * corresponding to valid Type values. Hence we can use the 'Type' field
1414 * as the index value, ignoring the array entries 0,3,5,6,7 !
1416 if (sUserDebugState.OnOff)
1417 Adapter->stDebugState.subtype[sUserDebugState.Type] |= sUserDebugState.Subtype;
1419 Adapter->stDebugState.subtype[sUserDebugState.Type] &= ~sUserDebugState.Subtype;
1421 BCM_SHOW_DEBUG_BITMAP(Adapter);
1425 case IOCTL_BCM_NVM_READ:
1426 case IOCTL_BCM_NVM_WRITE:
1429 NVM_READWRITE stNVMReadWrite = {};
1430 PUCHAR pReadData = NULL;
1431 void __user * pBuffertobeCopied = NULL;
1432 ULONG ulDSDMagicNumInUsrBuff = 0 ;
1433 struct timeval tv0, tv1;
1434 memset(&tv0,0,sizeof(struct timeval));
1435 memset(&tv1,0,sizeof(struct timeval));
1436 if((Adapter->eNVMType == NVM_FLASH) && (Adapter->uiFlashLayoutMajorVersion == 0))
1438 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,"The Flash Control Section is Corrupted. Hence Rejection on NVM Read/Write\n");
1443 if(IsFlash2x(Adapter))
1445 if((Adapter->eActiveDSD != DSD0) &&
1446 (Adapter->eActiveDSD != DSD1) &&
1447 (Adapter->eActiveDSD != DSD2))
1449 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"No DSD is active..hence NVM Command is blocked");
1450 return STATUS_FAILURE ;
1454 /* Copy Ioctl Buffer structure */
1456 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
1458 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copy_from_user failed\n");
1462 if(IOCTL_BCM_NVM_READ == cmd)
1463 pBuffertobeCopied = IoBuffer.OutputBuffer;
1465 pBuffertobeCopied = IoBuffer.InputBuffer;
1467 if(copy_from_user(&stNVMReadWrite, pBuffertobeCopied,sizeof(NVM_READWRITE)))
1474 // Deny the access if the offset crosses the cal area limit.
1476 if((stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) > Adapter->uiNVMDSDSize)
1478 //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Can't allow access beyond NVM Size: 0x%x 0x%x\n", stNVMReadWrite.uiOffset ,
1479 // stNVMReadWrite.uiNumBytes);
1480 Status = STATUS_FAILURE;
1484 pReadData =(PCHAR)kmalloc(stNVMReadWrite.uiNumBytes, GFP_KERNEL);
1489 memset(pReadData,0,stNVMReadWrite.uiNumBytes);
1491 if(copy_from_user(pReadData, stNVMReadWrite.pBuffer,
1492 stNVMReadWrite.uiNumBytes))
1495 bcm_kfree(pReadData);
1499 do_gettimeofday(&tv0);
1500 if(IOCTL_BCM_NVM_READ == cmd)
1502 down(&Adapter->NVMRdmWrmLock);
1504 if((Adapter->IdleMode == TRUE) ||
1505 (Adapter->bShutStatus ==TRUE) ||
1506 (Adapter->bPreparingForLowPowerMode ==TRUE))
1508 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1509 up(&Adapter->NVMRdmWrmLock);
1510 bcm_kfree(pReadData);
1514 Status = BeceemNVMRead(Adapter, (PUINT)pReadData,
1515 stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes);
1517 up(&Adapter->NVMRdmWrmLock);
1519 if(Status != STATUS_SUCCESS)
1521 bcm_kfree(pReadData);
1524 if(copy_to_user(stNVMReadWrite.pBuffer,
1525 pReadData, (UINT)stNVMReadWrite.uiNumBytes))
1527 bcm_kfree(pReadData);
1534 down(&Adapter->NVMRdmWrmLock);
1536 if((Adapter->IdleMode == TRUE) ||
1537 (Adapter->bShutStatus ==TRUE) ||
1538 (Adapter->bPreparingForLowPowerMode ==TRUE))
1540 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1541 up(&Adapter->NVMRdmWrmLock);
1542 bcm_kfree(pReadData);
1546 Adapter->bHeaderChangeAllowed = TRUE ;
1547 if(IsFlash2x(Adapter))
1551 DSD section updation will be allowed in two case:-
1552 1. if DSD sig is present in DSD header means dongle is ok and updation is fruitfull
1553 2. if point 1 failes then user buff should have DSD sig. this point ensures that if dongle is
1554 corrupted then user space program first modify the DSD header with valid DSD sig so
1555 that this as well as further write may be worthwhile.
1557 This restriction has been put assuming that if DSD sig is corrupted, DSD
1558 data won't be considered valid.
1562 Status = BcmFlash2xCorruptSig(Adapter,Adapter->eActiveDSD);
1563 if(Status != STATUS_SUCCESS)
1565 if(( (stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) != Adapter->uiNVMDSDSize ) ||
1566 (stNVMReadWrite.uiNumBytes < SIGNATURE_SIZE))
1568 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
1569 up(&Adapter->NVMRdmWrmLock);
1570 bcm_kfree(pReadData);
1574 ulDSDMagicNumInUsrBuff = ntohl(*(PUINT)(pReadData + stNVMReadWrite.uiNumBytes - SIGNATURE_SIZE));
1575 if(ulDSDMagicNumInUsrBuff != DSD_IMAGE_MAGIC_NUMBER)
1577 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
1578 up(&Adapter->NVMRdmWrmLock);
1579 bcm_kfree(pReadData);
1584 Status = BeceemNVMWrite(Adapter, (PUINT )pReadData,
1585 stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes, stNVMReadWrite.bVerify);
1586 if(IsFlash2x(Adapter))
1587 BcmFlash2xWriteSig(Adapter,Adapter->eActiveDSD);
1589 Adapter->bHeaderChangeAllowed = FALSE ;
1591 up(&Adapter->NVMRdmWrmLock);
1594 if(Status != STATUS_SUCCESS)
1596 bcm_kfree(pReadData);
1600 do_gettimeofday(&tv1);
1601 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);
1604 bcm_kfree(pReadData);
1605 Status = STATUS_SUCCESS;
1608 case IOCTL_BCM_FLASH2X_SECTION_READ :
1611 FLASH2X_READWRITE sFlash2xRead = {0};
1612 PUCHAR pReadBuff = NULL ;
1616 UINT ReadOffset = 0;
1617 char __user *OutPutBuff = NULL;
1619 if(IsFlash2x(Adapter) != TRUE)
1621 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1625 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_FLASH2X_SECTION_READ Called");
1626 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1629 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1633 //Reading FLASH 2.x READ structure
1634 Status = copy_from_user(&sFlash2xRead, IoBuffer.InputBuffer,sizeof(FLASH2X_READWRITE));
1637 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Input Buffer failed");
1642 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xRead.Section);
1643 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%x" ,sFlash2xRead.offset);
1644 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xRead.numOfBytes);
1645 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xRead.bVerify);
1647 //This was internal to driver for raw read. now it has ben exposed to user space app.
1648 if(validateFlash2xReadWrite(Adapter,&sFlash2xRead) == FALSE)
1649 return STATUS_FAILURE ;
1651 NOB = sFlash2xRead.numOfBytes;
1652 if(NOB > Adapter->uiSectorSize )
1653 BuffSize = Adapter->uiSectorSize;
1657 ReadOffset = sFlash2xRead.offset ;
1658 OutPutBuff = IoBuffer.OutputBuffer;
1661 pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
1662 if(pReadBuff == NULL)
1664 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
1667 down(&Adapter->NVMRdmWrmLock);
1669 if((Adapter->IdleMode == TRUE) ||
1670 (Adapter->bShutStatus ==TRUE) ||
1671 (Adapter->bPreparingForLowPowerMode ==TRUE))
1673 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1674 up(&Adapter->NVMRdmWrmLock);
1675 bcm_kfree(pReadBuff);
1682 if(NOB > Adapter->uiSectorSize )
1683 ReadBytes = Adapter->uiSectorSize;
1688 //Reading the data from Flash 2.x
1690 Status = BcmFlash2xBulkRead(Adapter,(PUINT)pReadBuff,sFlash2xRead.Section,ReadOffset,ReadBytes);
1693 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Flash 2x read err with Status :%d", Status);
1697 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes);
1699 Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes);
1702 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Copy to use failed with status :%d", Status);
1706 NOB = NOB - ReadBytes;
1709 ReadOffset = ReadOffset + ReadBytes ;
1710 OutPutBuff = OutPutBuff + ReadBytes ;
1714 up(&Adapter->NVMRdmWrmLock);
1715 bcm_kfree(pReadBuff);
1719 case IOCTL_BCM_FLASH2X_SECTION_WRITE :
1721 FLASH2X_READWRITE sFlash2xWrite = {0};
1722 PUCHAR pWriteBuff = NULL;
1723 void __user *InputAddr = NULL;
1726 UINT WriteOffset = 0;
1727 UINT WriteBytes = 0;
1729 if(IsFlash2x(Adapter) != TRUE)
1731 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1735 //First make this False so that we can enable the Sector Permission Check in BeceemFlashBulkWrite
1736 Adapter->bAllDSDWriteAllow = FALSE;
1739 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_FLASH2X_SECTION_WRITE Called");
1740 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1743 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1747 //Reading FLASH 2.x READ structure
1748 Status = copy_from_user(&sFlash2xWrite, IoBuffer.InputBuffer, sizeof(FLASH2X_READWRITE));
1751 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Reading of output Buffer from IOCTL buffer fails");
1755 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xWrite.Section);
1756 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%d" ,sFlash2xWrite.offset);
1757 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xWrite.numOfBytes);
1758 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xWrite.bVerify);
1760 if((sFlash2xWrite.Section == ISO_IMAGE1) ||(sFlash2xWrite.Section == ISO_IMAGE2) ||
1761 (sFlash2xWrite.Section == DSD0) || (sFlash2xWrite.Section == DSD1) || (sFlash2xWrite.Section == DSD2))
1763 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"ISO/DSD Image write is not allowed.... ");
1764 return STATUS_FAILURE ;
1767 if((sFlash2xWrite.Section != VSA0) && (sFlash2xWrite.Section != VSA1) &&
1768 (sFlash2xWrite.Section != VSA2) )
1770 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Only VSA write is allowed");
1774 if(validateFlash2xReadWrite(Adapter,&sFlash2xWrite) == FALSE)
1775 return STATUS_FAILURE ;
1777 InputAddr = sFlash2xWrite.pDataBuff;
1778 WriteOffset = sFlash2xWrite.offset ;
1779 NOB = sFlash2xWrite.numOfBytes;
1781 if(NOB > Adapter->uiSectorSize )
1782 BuffSize = Adapter->uiSectorSize;
1786 pWriteBuff = (PCHAR)kmalloc(BuffSize, GFP_KERNEL);
1787 if(pWriteBuff == NULL)
1789 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
1793 //extracting the remainder of the given offset.
1794 WriteBytes = Adapter->uiSectorSize ;
1795 if(WriteOffset % Adapter->uiSectorSize)
1796 WriteBytes =Adapter->uiSectorSize - (WriteOffset % Adapter->uiSectorSize);
1797 if(NOB < WriteBytes)
1800 down(&Adapter->NVMRdmWrmLock);
1802 if((Adapter->IdleMode == TRUE) ||
1803 (Adapter->bShutStatus ==TRUE) ||
1804 (Adapter->bPreparingForLowPowerMode ==TRUE))
1806 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1807 up(&Adapter->NVMRdmWrmLock);
1808 bcm_kfree(pWriteBuff);
1812 BcmFlash2xCorruptSig(Adapter,sFlash2xWrite.Section);
1815 Status = copy_from_user(pWriteBuff,InputAddr,WriteBytes);
1818 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to user failed with status :%d", Status);
1822 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pWriteBuff,WriteBytes);
1823 //Writing the data from Flash 2.x
1824 Status = BcmFlash2xBulkWrite(Adapter,(PUINT)pWriteBuff,sFlash2xWrite.Section,WriteOffset,WriteBytes,sFlash2xWrite.bVerify);
1828 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
1832 NOB = NOB - WriteBytes;
1835 WriteOffset = WriteOffset + WriteBytes ;
1836 InputAddr = InputAddr + WriteBytes ;
1837 if(NOB > Adapter->uiSectorSize )
1838 WriteBytes = Adapter->uiSectorSize;
1845 BcmFlash2xWriteSig(Adapter,sFlash2xWrite.Section);
1846 up(&Adapter->NVMRdmWrmLock);
1847 bcm_kfree(pWriteBuff);
1850 case IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP :
1853 PFLASH2X_BITMAP psFlash2xBitMap = NULL ;
1854 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP Called");
1856 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1859 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1862 if(IoBuffer.OutputLength != sizeof(FLASH2X_BITMAP))
1864 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Structure size mismatch Lib :0x%lx Driver :0x%zx ",IoBuffer.OutputLength, sizeof(FLASH2X_BITMAP));
1868 psFlash2xBitMap = (PFLASH2X_BITMAP)kzalloc(sizeof(FLASH2X_BITMAP), GFP_KERNEL);
1869 if(psFlash2xBitMap == NULL)
1871 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory is not available");
1874 //Reading the Flash Sectio Bit map
1875 down(&Adapter->NVMRdmWrmLock);
1877 if((Adapter->IdleMode == TRUE) ||
1878 (Adapter->bShutStatus ==TRUE) ||
1879 (Adapter->bPreparingForLowPowerMode ==TRUE))
1881 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1882 up(&Adapter->NVMRdmWrmLock);
1883 bcm_kfree(psFlash2xBitMap);
1887 BcmGetFlash2xSectionalBitMap(Adapter, psFlash2xBitMap);
1888 up(&Adapter->NVMRdmWrmLock);
1889 Status = copy_to_user(IoBuffer.OutputBuffer, psFlash2xBitMap, sizeof(FLASH2X_BITMAP));
1892 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash2x bitMap failed");
1893 bcm_kfree(psFlash2xBitMap);
1896 bcm_kfree(psFlash2xBitMap);
1899 case IOCTL_BCM_SET_ACTIVE_SECTION :
1901 FLASH2X_SECTION_VAL eFlash2xSectionVal = 0;
1902 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SET_ACTIVE_SECTION Called");
1904 if(IsFlash2x(Adapter) != TRUE)
1906 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1910 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1913 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1917 Status = copy_from_user(&eFlash2xSectionVal,IoBuffer.InputBuffer, sizeof(INT));
1920 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
1924 down(&Adapter->NVMRdmWrmLock);
1926 if((Adapter->IdleMode == TRUE) ||
1927 (Adapter->bShutStatus ==TRUE) ||
1928 (Adapter->bPreparingForLowPowerMode ==TRUE))
1930 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1931 up(&Adapter->NVMRdmWrmLock);
1935 Status = BcmSetActiveSection(Adapter,eFlash2xSectionVal);
1938 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed to make it's priority Highest. Status %d", Status);
1940 up(&Adapter->NVMRdmWrmLock);
1943 case IOCTL_BCM_IDENTIFY_ACTIVE_SECTION :
1945 //Right Now we are taking care of only DSD
1946 Adapter->bAllDSDWriteAllow = FALSE ;
1947 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_IDENTIFY_ACTIVE_SECTION called");
1950 SECTION_TYPE section = 0 ;
1953 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_IDENTIFY_ACTIVE_SECTION Called");
1954 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1957 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy of IOCTL BUFFER failed");
1960 Status = copy_from_user((PCHAR)section,(PCHAR)&IoBuffer, sizeof(INT));
1963 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy of section type failed failed");
1966 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", section);
1968 Adapter->ulFlashCalStart = Adapter->uiActiveDSDOffsetAtFwDld ;
1970 Status = STATUS_FAILURE ;
1972 Status = STATUS_SUCCESS ;
1975 case IOCTL_BCM_COPY_SECTION :
1977 FLASH2X_COPY_SECTION sCopySectStrut = {0};
1978 Status = STATUS_SUCCESS;
1979 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_COPY_SECTION Called");
1981 Adapter->bAllDSDWriteAllow = FALSE ;
1982 if(IsFlash2x(Adapter) != TRUE)
1984 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1988 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
1991 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed Status :%d", Status);
1995 Status = copy_from_user(&sCopySectStrut,IoBuffer.InputBuffer, sizeof(FLASH2X_COPY_SECTION));
1998 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Copy_Section_Struct failed with Status :%d", Status);
2001 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Source SEction :%x", sCopySectStrut.SrcSection);
2002 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Destination SEction :%x", sCopySectStrut.DstSection);
2003 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "offset :%x", sCopySectStrut.offset);
2004 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "NOB :%x", sCopySectStrut.numOfBytes);
2007 if(IsSectionExistInFlash(Adapter,sCopySectStrut.SrcSection) == FALSE)
2009 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Source Section<%x> does not exixt in Flash ", sCopySectStrut.SrcSection);
2013 if(IsSectionExistInFlash(Adapter,sCopySectStrut.DstSection) == FALSE)
2015 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Destinatio Section<%x> does not exixt in Flash ", sCopySectStrut.DstSection);
2019 if(sCopySectStrut.SrcSection == sCopySectStrut.DstSection)
2021 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Source and Destination section should be different");
2025 down(&Adapter->NVMRdmWrmLock);
2027 if((Adapter->IdleMode == TRUE) ||
2028 (Adapter->bShutStatus ==TRUE) ||
2029 (Adapter->bPreparingForLowPowerMode ==TRUE))
2031 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2032 up(&Adapter->NVMRdmWrmLock);
2036 if(sCopySectStrut.SrcSection == ISO_IMAGE1 || sCopySectStrut.SrcSection == ISO_IMAGE2)
2038 if(IsNonCDLessDevice(Adapter))
2040 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is Non-CDLess hence won't have ISO !!");
2043 else if(sCopySectStrut.numOfBytes == 0)
2045 Status = BcmCopyISO(Adapter,sCopySectStrut);
2049 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Partial Copy of ISO section is not Allowed..");
2050 Status = STATUS_FAILURE ;
2052 up(&Adapter->NVMRdmWrmLock);
2056 Status = BcmCopySection(Adapter, sCopySectStrut.SrcSection,
2057 sCopySectStrut.DstSection,sCopySectStrut.offset,sCopySectStrut.numOfBytes);
2058 up(&Adapter->NVMRdmWrmLock);
2061 case IOCTL_BCM_GET_FLASH_CS_INFO :
2063 Status = STATUS_SUCCESS;
2064 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_GET_FLASH_CS_INFO Called");
2066 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2069 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2073 if(Adapter->eNVMType != NVM_FLASH)
2075 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Connected device does not have flash");
2079 if(IsFlash2x(Adapter) == TRUE)
2082 if(IoBuffer.OutputLength < sizeof(FLASH2X_CS_INFO))
2084 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));
2089 Status = copy_to_user(IoBuffer.OutputBuffer, Adapter->psFlash2xCSInfo, sizeof(FLASH2X_CS_INFO));
2092 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash2x cs info failed");
2099 if(IoBuffer.OutputLength < sizeof(FLASH_CS_INFO))
2101 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));
2105 Status = copy_to_user(IoBuffer.OutputBuffer, Adapter->psFlashCSInfo, sizeof(FLASH_CS_INFO));
2108 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash CS info failed");
2116 case IOCTL_BCM_SELECT_DSD :
2119 FLASH2X_SECTION_VAL eFlash2xSectionVal;
2120 eFlash2xSectionVal = NO_SECTION_VAL ;
2121 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_SELECT_DSD Called");
2123 if(IsFlash2x(Adapter) != TRUE)
2125 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
2129 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2132 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2135 Status = copy_from_user(&eFlash2xSectionVal,IoBuffer.InputBuffer, sizeof(INT));
2138 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
2142 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", eFlash2xSectionVal);
2143 if((eFlash2xSectionVal != DSD0) &&
2144 (eFlash2xSectionVal != DSD1) &&
2145 (eFlash2xSectionVal != DSD2) )
2147 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Passed section<%x> is not DSD section", eFlash2xSectionVal);
2148 return STATUS_FAILURE ;
2151 SectOfset= BcmGetSectionValStartOffset(Adapter,eFlash2xSectionVal);
2152 if(SectOfset == INVALID_OFFSET)
2154 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Provided Section val <%d> does not exixt in Flash 2.x", eFlash2xSectionVal);
2158 Adapter->bAllDSDWriteAllow = TRUE ;
2160 Adapter->ulFlashCalStart = SectOfset ;
2161 Adapter->eActiveDSD = eFlash2xSectionVal;
2163 Status = STATUS_SUCCESS ;
2166 case IOCTL_BCM_NVM_RAW_READ :
2169 NVM_READWRITE stNVMRead = {};
2173 UINT ReadBytes = 0 ;
2174 PUCHAR pReadBuff = NULL ;
2175 char __user *OutPutBuff = NULL ;
2177 if(Adapter->eNVMType != NVM_FLASH)
2179 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"NVM TYPE is not Flash ");
2183 /* Copy Ioctl Buffer structure */
2184 if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
2186 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
2191 if(copy_from_user(&stNVMRead, IoBuffer.OutputBuffer,sizeof(NVM_READWRITE)))
2197 NOB = stNVMRead.uiNumBytes;
2198 //In Raw-Read max Buff size : 64MB
2200 if(NOB > DEFAULT_BUFF_SIZE)
2201 BuffSize = DEFAULT_BUFF_SIZE;
2205 ReadOffset = stNVMRead.uiOffset ;
2206 OutPutBuff = stNVMRead.pBuffer;
2209 pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
2210 if(pReadBuff == NULL)
2212 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
2216 down(&Adapter->NVMRdmWrmLock);
2218 if((Adapter->IdleMode == TRUE) ||
2219 (Adapter->bShutStatus ==TRUE) ||
2220 (Adapter->bPreparingForLowPowerMode ==TRUE))
2222 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2223 bcm_kfree(pReadBuff);
2224 up(&Adapter->NVMRdmWrmLock);
2228 Adapter->bFlashRawRead = TRUE ;
2231 if(NOB > DEFAULT_BUFF_SIZE )
2232 ReadBytes = DEFAULT_BUFF_SIZE;
2236 //Reading the data from Flash 2.x
2237 Status = BeceemNVMRead(Adapter,(PUINT)pReadBuff,ReadOffset,ReadBytes);
2240 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
2244 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes);
2246 Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes);
2249 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to use failed with status :%d", Status);
2253 NOB = NOB - ReadBytes;
2256 ReadOffset = ReadOffset + ReadBytes ;
2257 OutPutBuff = OutPutBuff + ReadBytes ;
2261 Adapter->bFlashRawRead = FALSE ;
2262 up(&Adapter->NVMRdmWrmLock);
2263 bcm_kfree(pReadBuff);
2267 case IOCTL_BCM_CNTRLMSG_MASK:
2269 ULONG RxCntrlMsgBitMask = 0 ;
2271 /* Copy Ioctl Buffer structure */
2272 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2275 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of Ioctl buffer is failed from user space");
2280 Status = copy_from_user(&RxCntrlMsgBitMask, IoBuffer.InputBuffer, IoBuffer.InputLength);
2283 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of control bit mask failed from user space");
2287 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\n Got user defined cntrl msg bit mask :%lx", RxCntrlMsgBitMask);
2288 pTarang->RxCntrlMsgBitMask = RxCntrlMsgBitMask ;
2291 case IOCTL_BCM_GET_DEVICE_DRIVER_INFO:
2293 DEVICE_DRIVER_INFO DevInfo;
2295 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Called IOCTL_BCM_GET_DEVICE_DRIVER_INFO\n");
2297 DevInfo.MaxRDMBufferSize = BUFFER_4K;
2298 DevInfo.u32DSDStartOffset = EEPROM_CALPARAM_START;
2299 DevInfo.u32RxAlignmentCorrection = 0;
2300 DevInfo.u32NVMType = Adapter->eNVMType;
2301 DevInfo.u32InterfaceType = BCM_USB;
2303 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2306 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2310 if(IoBuffer.OutputLength < sizeof(DevInfo))
2312 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"User Passed buffer length is less than actural buffer size");
2313 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"user passed buffer size :0x%lX, expected size :0x%zx",IoBuffer.OutputLength, sizeof(DevInfo));
2317 Status = copy_to_user(IoBuffer.OutputBuffer, &DevInfo, sizeof(DevInfo));
2320 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copying Dev info structure to user space buffer failed");
2327 case IOCTL_BCM_TIME_SINCE_NET_ENTRY:
2329 ST_TIME_ELAPSED stTimeElapsedSinceNetEntry = {0};
2330 struct timeval tv = {0} ;
2332 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_TIME_SINCE_NET_ENTRY called");
2334 Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
2337 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2341 if(IoBuffer.OutputLength < sizeof(ST_TIME_ELAPSED))
2343 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));
2348 //stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = Adapter->liTimeSinceLastNetEntry;
2349 do_gettimeofday(&tv);
2350 stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = tv.tv_sec - Adapter->liTimeSinceLastNetEntry;
2352 Status = copy_to_user(IoBuffer.OutputBuffer, &stTimeElapsedSinceNetEntry, sizeof(ST_TIME_ELAPSED));
2355 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copying ST_TIME_ELAPSED structure to user space buffer failed");
2364 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "wrong input %x",cmd);
2365 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In default ioctl %d\n", cmd);
2366 Status = STATUS_FAILURE;
2374 static struct file_operations bcm_fops = {
2375 .owner = THIS_MODULE,
2376 .open = bcm_char_open,
2377 .release = bcm_char_release,
2378 .read = bcm_char_read,
2379 .unlocked_ioctl = bcm_char_ioctl,
2380 .llseek = no_llseek,
2384 int register_control_device_interface(PMINI_ADAPTER Adapter)
2386 if(Adapter->major>0)
2387 return Adapter->major;
2388 Adapter->major = register_chrdev(0, "tarang", &bcm_fops);
2389 if(Adapter->major < 0)
2391 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "register_chrdev:Failed to registering WiMax control char device!");
2392 return Adapter->major;
2396 bcm_class = class_create (THIS_MODULE, "tarang");
2397 if(IS_ERR (bcm_class))
2399 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unable to create class\n");
2400 unregister_chrdev(Adapter->major, "tarang");
2404 Adapter->pstCreatedClassDevice = device_create (bcm_class, NULL,
2405 MKDEV(Adapter->major, 0),
2406 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
2411 if(IS_ERR(Adapter->pstCreatedClassDevice))
2413 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "class device did not get created : %ld", PTR_ERR(Adapter->pstCreatedClassDevice) );
2415 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Got Major No: %d", Adapter->major);
2419 void unregister_control_device_interface(PMINI_ADAPTER Adapter)
2421 if(Adapter->major > 0)
2423 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "destroying class device");
2424 device_destroy (bcm_class, MKDEV(Adapter->major, 0));
2426 if(!IS_ERR(bcm_class))
2428 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "destroying created class ");
2429 class_destroy (bcm_class);
2432 if(Adapter->major > 0)
2434 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"unregistering character interface");
2435 unregister_chrdev(Adapter->major, "tarang");