Skip to content

L
linux
Commit 6c15e002 authored by Kevin McKinney's avatar Kevin McKinney Committed by Greg Kroah-Hartman
Browse files
Options

staging: bcm: fix coding style warnings and errors reported by checkpatch.pl tool 

Staging: bcm: Fix coding style errors reported by checkpatch.pl

Fix multiple warnings and errors reported by checkpatch.pl

Signed-off-by: Kevin McKinney<klmckinney1@gmail.com>
Reviewed-by: default avatarDan Carpenter <error27@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 96936173
Show whitespace changes
Inline Side-by-side
Showing with 1517 additions and 1649 deletions
drivers/staging/bcm/Bcmchar.c
View file @ 6c15e002
...@@ -34,7 +34,7 @@ static int bcm_char_open(struct inode *inode, struct file * filp) ...@@ -34,7 +34,7 @@ static int bcm_char_open(struct inode *inode, struct file * filp)
/* Store the Adapter structure */ /* Store the Adapter structure */
filp->private_data = pTarang; filp->private_data = pTarang;
/*Start Queuing the control response Packets*/ /* Start Queuing the control response Packets */
atomic_inc(&Adapter->ApplicationRunning); atomic_inc(&Adapter->ApplicationRunning);
nonseekable_open(inode, filp); nonseekable_open(inode, filp);
...@@ -84,7 +84,7 @@ static int bcm_char_release(struct inode *inode, struct file *filp) ...@@ -84,7 +84,7 @@ static int bcm_char_release(struct inode *inode, struct file *filp)
up(&Adapter->RxAppControlQueuelock); up(&Adapter->RxAppControlQueuelock);
/*Stop Queuing the control response Packets*/ /* Stop Queuing the control response Packets */
atomic_dec(&Adapter->ApplicationRunning); atomic_dec(&Adapter->ApplicationRunning);
kfree(pTarang); kfree(pTarang);
...@@ -162,29 +162,25 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -162,29 +162,25 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
int timeout = 0; int timeout = 0;
IOCTL_BUFFER IoBuffer; IOCTL_BUFFER IoBuffer;
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); 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);
if(_IOC_TYPE(cmd) != BCM_IOCTL) if (_IOC_TYPE(cmd) != BCM_IOCTL)
return -EFAULT; return -EFAULT;
if(_IOC_DIR(cmd) & _IOC_READ) if (_IOC_DIR(cmd) & _IOC_READ)
Status = !access_ok(VERIFY_WRITE, argp, _IOC_SIZE(cmd)); Status = !access_ok(VERIFY_WRITE, argp, _IOC_SIZE(cmd));
else if (_IOC_DIR(cmd) & _IOC_WRITE) else if (_IOC_DIR(cmd) & _IOC_WRITE)
Status = !access_ok(VERIFY_READ, argp, _IOC_SIZE(cmd)); Status = !access_ok(VERIFY_READ, argp, _IOC_SIZE(cmd));
else if (_IOC_NONE == (_IOC_DIR(cmd) & _IOC_NONE)) else if (_IOC_NONE == (_IOC_DIR(cmd) & _IOC_NONE))
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
if(Status) if (Status)
return -EFAULT; return -EFAULT;
if(Adapter->device_removed) if (Adapter->device_removed)
{
return -EFAULT; return -EFAULT;
}
if(FALSE == Adapter->fw_download_done) if (FALSE == Adapter->fw_download_done) {
{ switch (cmd) {
switch (cmd)
{
case IOCTL_MAC_ADDR_REQ: case IOCTL_MAC_ADDR_REQ:
case IOCTL_LINK_REQ: case IOCTL_LINK_REQ:
case IOCTL_CM_REQUEST: case IOCTL_CM_REQUEST:
...@@ -200,284 +196,268 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -200,284 +196,268 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
} }
Status = vendorextnIoctl(Adapter, cmd, arg); Status = vendorextnIoctl(Adapter, cmd, arg);
if(Status != CONTINUE_COMMON_PATH ) if (Status != CONTINUE_COMMON_PATH)
return Status; return Status;
switch(cmd){ switch (cmd) {
// Rdms for Swin Idle... /* Rdms for Swin Idle... */
case IOCTL_BCM_REGISTER_READ_PRIVATE: case IOCTL_BCM_REGISTER_READ_PRIVATE: {
{
RDM_BUFFER sRdmBuffer = {0}; RDM_BUFFER sRdmBuffer = {0};
PCHAR temp_buff; PCHAR temp_buff;
UINT Bufflen; UINT Bufflen;
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if (IoBuffer.InputLength > sizeof(sRdmBuffer)) if (IoBuffer.InputLength > sizeof(sRdmBuffer))
return -EINVAL; return -EINVAL;
if(copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength)) if (copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength))
return -EFAULT; return -EFAULT;
/* FIXME: need to restrict BuffLen */ /* FIXME: need to restrict BuffLen */
Bufflen = IoBuffer.OutputLength + (4 - IoBuffer.OutputLength%4)%4; Bufflen = IoBuffer.OutputLength + (4 - IoBuffer.OutputLength%4)%4;
temp_buff = kmalloc(Bufflen, GFP_KERNEL); temp_buff = kmalloc(Bufflen, GFP_KERNEL);
if(!temp_buff) if (!temp_buff)
return -ENOMEM; return -ENOMEM;
Status = rdmalt(Adapter, (UINT)sRdmBuffer.Register, Status = rdmalt(Adapter, (UINT)sRdmBuffer.Register,
(PUINT)temp_buff, Bufflen); (PUINT)temp_buff, Bufflen);
if(Status == STATUS_SUCCESS) if (Status == STATUS_SUCCESS) {
{ if (copy_to_user(IoBuffer.OutputBuffer, temp_buff, IoBuffer.OutputLength))
if(copy_to_user(IoBuffer.OutputBuffer, temp_buff, IoBuffer.OutputLength))
Status = -EFAULT; Status = -EFAULT;
} }
kfree(temp_buff); kfree(temp_buff);
break; break;
} }
case IOCTL_BCM_REGISTER_WRITE_PRIVATE:
{ case IOCTL_BCM_REGISTER_WRITE_PRIVATE: {
WRM_BUFFER sWrmBuffer = {0}; WRM_BUFFER sWrmBuffer = {0};
UINT uiTempVar=0; UINT uiTempVar = 0;
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if (IoBuffer.InputLength > sizeof(sWrmBuffer)) if (IoBuffer.InputLength > sizeof(sWrmBuffer))
return -EINVAL; return -EINVAL;
/* Get WrmBuffer structure */ /* Get WrmBuffer structure */
if(copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength)) if (copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength))
return -EFAULT; return -EFAULT;
uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK; uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK;
if(!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) && if (!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) &&
((uiTempVar == EEPROM_REJECT_REG_1)|| ((uiTempVar == EEPROM_REJECT_REG_1) ||
(uiTempVar == EEPROM_REJECT_REG_2) || (uiTempVar == EEPROM_REJECT_REG_2) ||
(uiTempVar == EEPROM_REJECT_REG_3) || (uiTempVar == EEPROM_REJECT_REG_3) ||
(uiTempVar == EEPROM_REJECT_REG_4))) (uiTempVar == EEPROM_REJECT_REG_4))) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
return -EFAULT; return -EFAULT;
} }
Status = wrmalt(Adapter, (UINT)sWrmBuffer.Register, Status = wrmalt(Adapter, (UINT)sWrmBuffer.Register,
(PUINT)sWrmBuffer.Data, sizeof(ULONG)); (PUINT)sWrmBuffer.Data, sizeof(ULONG));
if(Status == STATUS_SUCCESS)
{ if (Status == STATUS_SUCCESS) {
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"WRM Done\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Done\n");
} } else {
else BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
Status = -EFAULT; Status = -EFAULT;
} }
break; break;
} }
case IOCTL_BCM_REGISTER_READ: case IOCTL_BCM_REGISTER_READ:
case IOCTL_BCM_EEPROM_REGISTER_READ: case IOCTL_BCM_EEPROM_REGISTER_READ: {
{
RDM_BUFFER sRdmBuffer = {0}; RDM_BUFFER sRdmBuffer = {0};
PCHAR temp_buff = NULL; PCHAR temp_buff = NULL;
UINT uiTempVar = 0; UINT uiTempVar = 0;
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Rdms\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Rdms\n");
return -EACCES; return -EACCES;
} }
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if (IoBuffer.InputLength > sizeof(sRdmBuffer)) if (IoBuffer.InputLength > sizeof(sRdmBuffer))
return -EINVAL; return -EINVAL;
if(copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength)) if (copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength))
return -EFAULT; return -EFAULT;
/* FIXME: don't trust user supplied length */ /* FIXME: don't trust user supplied length */
temp_buff = kmalloc(IoBuffer.OutputLength, GFP_KERNEL); temp_buff = kmalloc(IoBuffer.OutputLength, GFP_KERNEL);
if(!temp_buff) if (!temp_buff)
return STATUS_FAILURE; return STATUS_FAILURE;
if((((ULONG)sRdmBuffer.Register & 0x0F000000) != 0x0F000000) || if ((((ULONG)sRdmBuffer.Register & 0x0F000000) != 0x0F000000) ||
((ULONG)sRdmBuffer.Register & 0x3)) ((ULONG)sRdmBuffer.Register & 0x3)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "RDM Done On invalid Address : %x Access Denied.\n", BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "RDM Done On invalid Address : %x Access Denied.\n",
(int)sRdmBuffer.Register); (int)sRdmBuffer.Register);
return -EINVAL; return -EINVAL;
} }
uiTempVar = sRdmBuffer.Register & EEPROM_REJECT_MASK; uiTempVar = sRdmBuffer.Register & EEPROM_REJECT_MASK;
Status = rdmaltWithLock(Adapter, (UINT)sRdmBuffer.Register, Status = rdmaltWithLock(Adapter, (UINT)sRdmBuffer.Register, (PUINT)temp_buff, IoBuffer.OutputLength);
(PUINT)temp_buff, IoBuffer.OutputLength);
if(Status == STATUS_SUCCESS) if (Status == STATUS_SUCCESS)
if(copy_to_user(IoBuffer.OutputBuffer, temp_buff, IoBuffer.OutputLength)) if (copy_to_user(IoBuffer.OutputBuffer, temp_buff, IoBuffer.OutputLength))
Status = -EFAULT; Status = -EFAULT;
kfree(temp_buff); kfree(temp_buff);
break; break;
} }
case IOCTL_BCM_REGISTER_WRITE: case IOCTL_BCM_REGISTER_WRITE:
case IOCTL_BCM_EEPROM_REGISTER_WRITE: case IOCTL_BCM_EEPROM_REGISTER_WRITE: {
{
WRM_BUFFER sWrmBuffer = {0}; WRM_BUFFER sWrmBuffer = {0};
UINT uiTempVar=0; UINT uiTempVar = 0;
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Wrms\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Wrms\n");
return -EACCES; return -EACCES;
} }
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if (IoBuffer.InputLength > sizeof(sWrmBuffer)) if (IoBuffer.InputLength > sizeof(sWrmBuffer))
return -EINVAL; return -EINVAL;
/* Get WrmBuffer structure */ /* Get WrmBuffer structure */
if(copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength)) if (copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength))
return -EFAULT; return -EFAULT;
if( (((ULONG)sWrmBuffer.Register & 0x0F000000) != 0x0F000000) || if ((((ULONG)sWrmBuffer.Register & 0x0F000000) != 0x0F000000) ||
((ULONG)sWrmBuffer.Register & 0x3) ) ((ULONG)sWrmBuffer.Register & 0x3)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Done On invalid Address : %x Access Denied.\n", BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "WRM Done On invalid Address : %x Access Denied.\n", (int)sWrmBuffer.Register);
(int)sWrmBuffer.Register);
return -EINVAL; return -EINVAL;
} }
uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK; uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK;
if(!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) && if (!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) &&
((uiTempVar == EEPROM_REJECT_REG_1)|| ((uiTempVar == EEPROM_REJECT_REG_1) ||
(uiTempVar == EEPROM_REJECT_REG_2) || (uiTempVar == EEPROM_REJECT_REG_2) ||
(uiTempVar == EEPROM_REJECT_REG_3) || (uiTempVar == EEPROM_REJECT_REG_3) ||
(uiTempVar == EEPROM_REJECT_REG_4)) && (uiTempVar == EEPROM_REJECT_REG_4)) &&
(cmd == IOCTL_BCM_REGISTER_WRITE)) (cmd == IOCTL_BCM_REGISTER_WRITE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
return -EFAULT; return -EFAULT;
} }
Status = wrmaltWithLock(Adapter, (UINT)sWrmBuffer.Register, Status = wrmaltWithLock(Adapter, (UINT)sWrmBuffer.Register,
(PUINT)sWrmBuffer.Data, sWrmBuffer.Length); (PUINT)sWrmBuffer.Data, sWrmBuffer.Length);
if(Status == STATUS_SUCCESS)
{ if (Status == STATUS_SUCCESS) {
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "WRM Done\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "WRM Done\n");
} } else {
else BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
Status = -EFAULT; Status = -EFAULT;
} }
break; break;
} }
case IOCTL_BCM_GPIO_SET_REQUEST: case IOCTL_BCM_GPIO_SET_REQUEST: {
{
UCHAR ucResetValue[4]; UCHAR ucResetValue[4];
UINT value =0; UINT value = 0;
UINT uiBit = 0; UINT uiBit = 0;
UINT uiOperation = 0; UINT uiOperation = 0;
GPIO_INFO gpio_info = {0}; GPIO_INFO gpio_info = {0};
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO Can't be set/clear in Low power Mode"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "GPIO Can't be set/clear in Low power Mode");
return -EACCES; return -EACCES;
} }
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if (IoBuffer.InputLength > sizeof(gpio_info)) if (IoBuffer.InputLength > sizeof(gpio_info))
return -EINVAL; return -EINVAL;
if(copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
if (copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
return -EFAULT; return -EFAULT;
uiBit = gpio_info.uiGpioNumber; uiBit = gpio_info.uiGpioNumber;
uiOperation = gpio_info.uiGpioValue; uiOperation = gpio_info.uiGpioValue;
value = (1<<uiBit);
value= (1<<uiBit); if (IsReqGpioIsLedInNVM(Adapter, value) == FALSE) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to LED !!!", value);
if(IsReqGpioIsLedInNVM(Adapter,value) ==FALSE)
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to LED !!!",value);
Status = -EINVAL; Status = -EINVAL;
break; break;
} }
/* Set - setting 1 */
if (uiOperation) {
/* Set the gpio output register */
Status = wrmaltWithLock(Adapter, BCM_GPIO_OUTPUT_SET_REG, (PUINT)(&value), sizeof(UINT));
if(uiOperation)//Set - setting 1 if (Status == STATUS_SUCCESS) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Set the GPIO bit\n");
//Set the gpio output register } else {
Status = wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_SET_REG , BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Failed to set the %dth GPIO\n", uiBit);
(PUINT)(&value), sizeof(UINT));
if(Status == STATUS_SUCCESS)
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Set the GPIO bit\n");
}
else
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Failed to set the %dth GPIO \n",uiBit);
break; break;
} }
} } else {
else//Unset - setting 0 /* Set the gpio output register */
{ Status = wrmaltWithLock(Adapter, BCM_GPIO_OUTPUT_CLR_REG, (PUINT)(&value), sizeof(UINT));
//Set the gpio output register
Status = wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_CLR_REG , if (Status == STATUS_SUCCESS) {
(PUINT)(&value), sizeof(UINT)); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Set the GPIO bit\n");
if(Status == STATUS_SUCCESS) } else {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Failed to clear the %dth GPIO\n", uiBit);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Set the GPIO bit\n");
}
else
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Failed to clear the %dth GPIO \n",uiBit);
break; break;
} }
} }
Status = rdmaltWithLock(Adapter, (UINT)GPIO_MODE_REGISTER, Status = rdmaltWithLock(Adapter, (UINT)GPIO_MODE_REGISTER, (PUINT)ucResetValue, sizeof(UINT));
(PUINT)ucResetValue, sizeof(UINT));
if (STATUS_SUCCESS != Status) if (STATUS_SUCCESS != Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO_MODE_REGISTER read failed"); "GPIO_MODE_REGISTER read failed");
break; break;
} }
//Set the gpio mode register to output
*(UINT*)ucResetValue |= (1<<uiBit); /* Set the gpio mode register to output */
Status = wrmaltWithLock(Adapter,GPIO_MODE_REGISTER , *(UINT *)ucResetValue |= (1<<uiBit);
Status = wrmaltWithLock(Adapter, GPIO_MODE_REGISTER,
(PUINT)ucResetValue, sizeof(UINT)); (PUINT)ucResetValue, sizeof(UINT));
if(Status == STATUS_SUCCESS)
{ if (Status == STATUS_SUCCESS) {
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Set the GPIO to output Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Set the GPIO to output Mode\n");
} } else {
else BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Failed to put GPIO in Output Mode\n");
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Failed to put GPIO in Output Mode\n");
break; break;
} }
} }
break; break;
case BCM_LED_THREAD_STATE_CHANGE_REQ:
{
USER_THREAD_REQ threadReq = { 0 };
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"User made LED thread InActive");
if((Adapter->IdleMode == TRUE) || case BCM_LED_THREAD_STATE_CHANGE_REQ: {
(Adapter->bShutStatus ==TRUE) || USER_THREAD_REQ threadReq = {0};
(Adapter->bPreparingForLowPowerMode ==TRUE)) BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "User made LED thread InActive");
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO Can't be set/clear in Low power Mode"); if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode == TRUE)) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "GPIO Can't be set/clear in Low power Mode");
Status = -EACCES; Status = -EACCES;
break; break;
} }
...@@ -491,202 +471,203 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -491,202 +471,203 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
if (copy_from_user(&threadReq, IoBuffer.InputBuffer, IoBuffer.InputLength)) if (copy_from_user(&threadReq, IoBuffer.InputBuffer, IoBuffer.InputLength))
return -EFAULT; return -EFAULT;
//if LED thread is running(Actively or Inactively) set it state to make inactive /* if LED thread is running(Actively or Inactively) set it state to make inactive */
if(Adapter->LEDInfo.led_thread_running) if (Adapter->LEDInfo.led_thread_running) {
{ if (threadReq.ThreadState == LED_THREAD_ACTIVATION_REQ) {
if(threadReq.ThreadState == LED_THREAD_ACTIVATION_REQ) BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Activating thread req");
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Activating thread req");
Adapter->DriverState = LED_THREAD_ACTIVE; Adapter->DriverState = LED_THREAD_ACTIVE;
} } else {
else BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "DeActivating Thread req.....");
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DeActivating Thread req.....");
Adapter->DriverState = LED_THREAD_INACTIVE; Adapter->DriverState = LED_THREAD_INACTIVE;
} }
//signal thread. /* signal thread. */
wake_up(&Adapter->LEDInfo.notify_led_event); wake_up(&Adapter->LEDInfo.notify_led_event);
} }
} }
break; break;
case IOCTL_BCM_GPIO_STATUS_REQUEST:
{ case IOCTL_BCM_GPIO_STATUS_REQUEST: {
ULONG uiBit = 0; ULONG uiBit = 0;
UCHAR ucRead[4]; UCHAR ucRead[4];
GPIO_INFO gpio_info = {0}; GPIO_INFO gpio_info = {0};
if((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode == TRUE))
return -EACCES; return -EACCES;
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if (IoBuffer.InputLength > sizeof(gpio_info)) if (IoBuffer.InputLength > sizeof(gpio_info))
return -EINVAL; return -EINVAL;
if(copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
if (copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
return -EFAULT; return -EFAULT;
uiBit = gpio_info.uiGpioNumber; uiBit = gpio_info.uiGpioNumber;
//Set the gpio output register
/* Set the gpio output register */
Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER, Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER,
(PUINT)ucRead, sizeof(UINT)); (PUINT)ucRead, sizeof(UINT));
if(Status != STATUS_SUCCESS)
{ if (Status != STATUS_SUCCESS) {
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "RDM Failed\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "RDM Failed\n");
return Status; return Status;
} }
} }
break; break;
case IOCTL_BCM_GPIO_MULTI_REQUEST:
{ case IOCTL_BCM_GPIO_MULTI_REQUEST: {
UCHAR ucResetValue[4]; UCHAR ucResetValue[4];
GPIO_MULTI_INFO gpio_multi_info[MAX_IDX]; GPIO_MULTI_INFO gpio_multi_info[MAX_IDX];
PGPIO_MULTI_INFO pgpio_multi_info = (PGPIO_MULTI_INFO)gpio_multi_info; PGPIO_MULTI_INFO pgpio_multi_info = (PGPIO_MULTI_INFO)gpio_multi_info;
memset( pgpio_multi_info, 0, MAX_IDX * sizeof( GPIO_MULTI_INFO)); memset(pgpio_multi_info, 0, MAX_IDX * sizeof(GPIO_MULTI_INFO));
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE))
return -EINVAL; return -EINVAL;
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if (IoBuffer.InputLength > sizeof(gpio_multi_info)) if (IoBuffer.InputLength > sizeof(gpio_multi_info))
return -EINVAL; return -EINVAL;
if (copy_from_user(&gpio_multi_info, IoBuffer.InputBuffer, IoBuffer.InputLength)) if (copy_from_user(&gpio_multi_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
return -EFAULT; return -EFAULT;
if(IsReqGpioIsLedInNVM(Adapter,pgpio_multi_info[WIMAX_IDX].uiGPIOMask)== FALSE) if (IsReqGpioIsLedInNVM(Adapter, pgpio_multi_info[WIMAX_IDX].uiGPIOMask) == FALSE) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,
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); "Sorry, Requested GPIO<0x%X> is not correspond to NVM LED bit map<0x%X>!!!",
pgpio_multi_info[WIMAX_IDX].uiGPIOMask, Adapter->gpioBitMap);
Status = -EINVAL; Status = -EINVAL;
break; break;
} }
/* Set the gpio output register */ /* Set the gpio output register */
if ((pgpio_multi_info[WIMAX_IDX].uiGPIOMask) &
if( ( pgpio_multi_info[WIMAX_IDX].uiGPIOMask) & (pgpio_multi_info[WIMAX_IDX].uiGPIOCommand)) {
( pgpio_multi_info[WIMAX_IDX].uiGPIOCommand))
{
/* Set 1's in GPIO OUTPUT REGISTER */ /* Set 1's in GPIO OUTPUT REGISTER */
*(UINT*) ucResetValue = pgpio_multi_info[WIMAX_IDX].uiGPIOMask & *(UINT *)ucResetValue = pgpio_multi_info[WIMAX_IDX].uiGPIOMask &
pgpio_multi_info[WIMAX_IDX].uiGPIOCommand & pgpio_multi_info[WIMAX_IDX].uiGPIOCommand &
pgpio_multi_info[WIMAX_IDX].uiGPIOValue; pgpio_multi_info[WIMAX_IDX].uiGPIOValue;
if( *(UINT*) ucResetValue) if (*(UINT *) ucResetValue)
Status = wrmaltWithLock( Adapter, BCM_GPIO_OUTPUT_SET_REG , (PUINT) ucResetValue, sizeof(ULONG)); Status = wrmaltWithLock(Adapter, BCM_GPIO_OUTPUT_SET_REG,
(PUINT)ucResetValue, sizeof(ULONG));
if( Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "WRM to BCM_GPIO_OUTPUT_SET_REG Failed.");
BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to BCM_GPIO_OUTPUT_SET_REG Failed.");
return Status; return Status;
} }
/* Clear to 0's in GPIO OUTPUT REGISTER */ /* Clear to 0's in GPIO OUTPUT REGISTER */
*(UINT*) ucResetValue = (pgpio_multi_info[WIMAX_IDX].uiGPIOMask & *(UINT *)ucResetValue = (pgpio_multi_info[WIMAX_IDX].uiGPIOMask &
pgpio_multi_info[WIMAX_IDX].uiGPIOCommand & pgpio_multi_info[WIMAX_IDX].uiGPIOCommand &
( ~( pgpio_multi_info[WIMAX_IDX].uiGPIOValue))); (~(pgpio_multi_info[WIMAX_IDX].uiGPIOValue)));
if( *(UINT*) ucResetValue) if (*(UINT *) ucResetValue)
Status = wrmaltWithLock( Adapter, BCM_GPIO_OUTPUT_CLR_REG , (PUINT) ucResetValue, sizeof(ULONG)); Status = wrmaltWithLock(Adapter, BCM_GPIO_OUTPUT_CLR_REG, (PUINT)ucResetValue, sizeof(ULONG));
if( Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "WRM to BCM_GPIO_OUTPUT_CLR_REG Failed.");
BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to BCM_GPIO_OUTPUT_CLR_REG Failed." );
return Status; return Status;
} }
} }
if( pgpio_multi_info[WIMAX_IDX].uiGPIOMask) if (pgpio_multi_info[WIMAX_IDX].uiGPIOMask) {
{
Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER, (PUINT)ucResetValue, sizeof(UINT)); Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER, (PUINT)ucResetValue, sizeof(UINT));
if(Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "RDM to GPIO_PIN_STATE_REGISTER Failed.");
BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"RDM to GPIO_PIN_STATE_REGISTER Failed.");
return Status; return Status;
} }
pgpio_multi_info[WIMAX_IDX].uiGPIOValue = ( *(UINT*)ucResetValue & pgpio_multi_info[WIMAX_IDX].uiGPIOValue = (*(UINT *)ucResetValue &
pgpio_multi_info[WIMAX_IDX].uiGPIOMask); pgpio_multi_info[WIMAX_IDX].uiGPIOMask);
} }
Status = copy_to_user(IoBuffer.OutputBuffer, &gpio_multi_info, IoBuffer.OutputLength); Status = copy_to_user(IoBuffer.OutputBuffer, &gpio_multi_info, IoBuffer.OutputLength);
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying Content to IOBufer for user space err:%d",Status); "Failed while copying Content to IOBufer for user space err:%d", Status);
break; break;
} }
} }
break; break;
case IOCTL_BCM_GPIO_MODE_REQUEST:
{ case IOCTL_BCM_GPIO_MODE_REQUEST: {
UCHAR ucResetValue[4]; UCHAR ucResetValue[4];
GPIO_MULTI_MODE gpio_multi_mode[MAX_IDX]; GPIO_MULTI_MODE gpio_multi_mode[MAX_IDX];
PGPIO_MULTI_MODE pgpio_multi_mode = ( PGPIO_MULTI_MODE) gpio_multi_mode; PGPIO_MULTI_MODE pgpio_multi_mode = (PGPIO_MULTI_MODE)gpio_multi_mode;
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE))
return -EINVAL; return -EINVAL;
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if (IoBuffer.InputLength > sizeof(gpio_multi_mode)) if (IoBuffer.InputLength > sizeof(gpio_multi_mode))
return -EINVAL; return -EINVAL;
if (copy_from_user(&gpio_multi_mode, IoBuffer.InputBuffer, IoBuffer.InputLength)) if (copy_from_user(&gpio_multi_mode, IoBuffer.InputBuffer, IoBuffer.InputLength))
return -EFAULT; return -EFAULT;
Status = rdmaltWithLock( Adapter, ( UINT) GPIO_MODE_REGISTER, ( PUINT) ucResetValue, sizeof( UINT)); Status = rdmaltWithLock(Adapter, (UINT)GPIO_MODE_REGISTER, (PUINT)ucResetValue, sizeof(UINT));
if( STATUS_SUCCESS != Status)
{ if (STATUS_SUCCESS != Status) {
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Read of GPIO_MODE_REGISTER failed"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Read of GPIO_MODE_REGISTER failed");
return Status; return Status;
} }
//Validating the request /* Validating the request */
if(IsReqGpioIsLedInNVM(Adapter,pgpio_multi_mode[WIMAX_IDX].uiGPIOMask)== FALSE) if (IsReqGpioIsLedInNVM(Adapter, pgpio_multi_mode[WIMAX_IDX].uiGPIOMask) == FALSE) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,
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); "Sorry, Requested GPIO<0x%X> is not correspond to NVM LED bit map<0x%X>!!!",
pgpio_multi_mode[WIMAX_IDX].uiGPIOMask, Adapter->gpioBitMap);
Status = -EINVAL; Status = -EINVAL;
break; break;
} }
if( pgpio_multi_mode[WIMAX_IDX].uiGPIOMask) if (pgpio_multi_mode[WIMAX_IDX].uiGPIOMask) {
{
/* write all OUT's (1's) */ /* write all OUT's (1's) */
*( UINT*) ucResetValue |= ( pgpio_multi_mode[WIMAX_IDX].uiGPIOMode & *(UINT *) ucResetValue |= (pgpio_multi_mode[WIMAX_IDX].uiGPIOMode &
pgpio_multi_mode[WIMAX_IDX].uiGPIOMask); pgpio_multi_mode[WIMAX_IDX].uiGPIOMask);
/* write all IN's (0's) */ /* write all IN's (0's) */
*( UINT*) ucResetValue &= ~( ( ~pgpio_multi_mode[WIMAX_IDX].uiGPIOMode) & *(UINT *) ucResetValue &= ~((~pgpio_multi_mode[WIMAX_IDX].uiGPIOMode) &
pgpio_multi_mode[WIMAX_IDX].uiGPIOMask); pgpio_multi_mode[WIMAX_IDX].uiGPIOMask);
/* Currently implemented return the modes of all GPIO's /* Currently implemented return the modes of all GPIO's
* else needs to bit AND with mask * else needs to bit AND with mask
* */ */
pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *(UINT*)ucResetValue; pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *(UINT *)ucResetValue;
Status = wrmaltWithLock( Adapter, GPIO_MODE_REGISTER , ( PUINT) ucResetValue, sizeof( ULONG)); Status = wrmaltWithLock(Adapter, GPIO_MODE_REGISTER, (PUINT)ucResetValue, sizeof(ULONG));
if( Status == STATUS_SUCCESS) if (Status == STATUS_SUCCESS) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,
BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM to GPIO_MODE_REGISTER Done"); "WRM to GPIO_MODE_REGISTER Done");
} } else {
else BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
{ "WRM to GPIO_MODE_REGISTER Failed");
BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to GPIO_MODE_REGISTER Failed");
Status = -EFAULT; Status = -EFAULT;
break; break;
} }
} else {
/* if uiGPIOMask is 0 then return mode register configuration */
pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *(UINT *)ucResetValue;
} }
else /* if uiGPIOMask is 0 then return mode register configuration */
{
pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *( UINT*) ucResetValue;
}
Status = copy_to_user(IoBuffer.OutputBuffer, &gpio_multi_mode, IoBuffer.OutputLength); Status = copy_to_user(IoBuffer.OutputBuffer, &gpio_multi_mode, IoBuffer.OutputLength);
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying Content to IOBufer for user space err:%d",Status); "Failed while copying Content to IOBufer for user space err:%d", Status);
break; break;
} }
} }
...@@ -697,21 +678,19 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -697,21 +678,19 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
case IOCTL_CM_REQUEST: case IOCTL_CM_REQUEST:
case IOCTL_SS_INFO_REQ: case IOCTL_SS_INFO_REQ:
case IOCTL_SEND_CONTROL_MESSAGE: case IOCTL_SEND_CONTROL_MESSAGE:
case IOCTL_IDLE_REQ: case IOCTL_IDLE_REQ: {
{ PVOID pvBuffer = NULL;
PVOID pvBuffer=NULL;
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
/* FIXME: don't accept any length from user */ /* FIXME: don't accept any length from user */
pvBuffer = kmalloc(IoBuffer.InputLength, GFP_KERNEL); pvBuffer = kmalloc(IoBuffer.InputLength, GFP_KERNEL);
if(!pvBuffer) if (!pvBuffer)
return -ENOMEM; return -ENOMEM;
if(copy_from_user(pvBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength)) if (copy_from_user(pvBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength)) {
{
Status = -EFAULT; Status = -EFAULT;
kfree(pvBuffer); kfree(pvBuffer);
break; break;
...@@ -721,190 +700,187 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -721,190 +700,187 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue, Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue,
!Adapter->bPreparingForLowPowerMode, !Adapter->bPreparingForLowPowerMode,
(1 * HZ)); (1 * HZ));
if(Status == -ERESTARTSYS) if (Status == -ERESTARTSYS)
goto cntrlEnd; goto cntrlEnd;
if(Adapter->bPreparingForLowPowerMode) if (Adapter->bPreparingForLowPowerMode) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Preparing Idle Mode is still True - Hence Rejecting control message\n"); "Preparing Idle Mode is still True - Hence Rejecting control message\n");
Status = STATUS_FAILURE ; Status = STATUS_FAILURE;
goto cntrlEnd ; goto cntrlEnd;
} }
Status = CopyBufferToControlPacket(Adapter, (PVOID)pvBuffer); Status = CopyBufferToControlPacket(Adapter, (PVOID)pvBuffer);
cntrlEnd:
cntrlEnd:
up(&Adapter->LowPowerModeSync); up(&Adapter->LowPowerModeSync);
kfree(pvBuffer); kfree(pvBuffer);
break; break;
} }
case IOCTL_BCM_BUFFER_DOWNLOAD_START:
{ case IOCTL_BCM_BUFFER_DOWNLOAD_START: {
INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock) ; INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
if(NVMAccess) if (NVMAccess) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,
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"); "IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
return -EACCES; return -EACCES;
} }
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
if(!down_trylock(&Adapter->fw_download_sema)) BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
{ "Starting the firmware download PID =0x%x!!!!\n", current->pid);
Adapter->bBinDownloaded=FALSE;
Adapter->fw_download_process_pid=current->pid; if (!down_trylock(&Adapter->fw_download_sema)) {
Adapter->bCfgDownloaded=FALSE; Adapter->bBinDownloaded = FALSE;
Adapter->fw_download_done=FALSE; Adapter->fw_download_process_pid = current->pid;
Adapter->bCfgDownloaded = FALSE;
Adapter->fw_download_done = FALSE;
netif_carrier_off(Adapter->dev); netif_carrier_off(Adapter->dev);
netif_stop_queue(Adapter->dev); netif_stop_queue(Adapter->dev);
Status = reset_card_proc(Adapter); Status = reset_card_proc(Adapter);
if(Status) if (Status) {
{
pr_err(PFX "%s: reset_card_proc Failed!\n", Adapter->dev->name); pr_err(PFX "%s: reset_card_proc Failed!\n", Adapter->dev->name);
up(&Adapter->fw_download_sema); up(&Adapter->fw_download_sema);
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
break; break;
} }
mdelay(10); mdelay(10);
} } else {
else
{
Status = -EBUSY; Status = -EBUSY;
} }
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
break; break;
} }
case IOCTL_BCM_BUFFER_DOWNLOAD:
{ case IOCTL_BCM_BUFFER_DOWNLOAD: {
FIRMWARE_INFO *psFwInfo = NULL; FIRMWARE_INFO *psFwInfo = NULL;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
do{ do {
if(!down_trylock(&Adapter->fw_download_sema)) if (!down_trylock(&Adapter->fw_download_sema)) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid way to download buffer. Use Start and then call this!!!\n"); "Invalid way to download buffer. Use Start and then call this!!!\n");
Status=-EINVAL; Status = -EINVAL;
break; break;
} }
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Length for FW DLD is : %lx\n", BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
IoBuffer.InputLength); "Length for FW DLD is : %lx\n", IoBuffer.InputLength);
if (IoBuffer.InputLength > sizeof(FIRMWARE_INFO)) if (IoBuffer.InputLength > sizeof(FIRMWARE_INFO))
return -EINVAL; return -EINVAL;
psFwInfo = kmalloc(sizeof(*psFwInfo), GFP_KERNEL); psFwInfo = kmalloc(sizeof(*psFwInfo), GFP_KERNEL);
if(!psFwInfo) if (!psFwInfo)
return -ENOMEM; return -ENOMEM;
if(copy_from_user(psFwInfo, IoBuffer.InputBuffer, IoBuffer.InputLength)) if (copy_from_user(psFwInfo, IoBuffer.InputBuffer, IoBuffer.InputLength))
return -EFAULT; return -EFAULT;
if(!psFwInfo->pvMappedFirmwareAddress || if (!psFwInfo->pvMappedFirmwareAddress ||
(psFwInfo->u32FirmwareLength == 0)) (psFwInfo->u32FirmwareLength == 0)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Something else is wrong %lu\n", BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Something else is wrong %lu\n",
psFwInfo->u32FirmwareLength); psFwInfo->u32FirmwareLength);
Status = -EINVAL; Status = -EINVAL;
break; break;
} }
Status = bcm_ioctl_fw_download(Adapter, psFwInfo); Status = bcm_ioctl_fw_download(Adapter, psFwInfo);
if(Status != STATUS_SUCCESS)
{ if (Status != STATUS_SUCCESS) {
if(psFwInfo->u32StartingAddress==CONFIG_BEGIN_ADDR) if (psFwInfo->u32StartingAddress == CONFIG_BEGIN_ADDR)
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "IOCTL: Configuration File Upload Failed\n");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "IOCTL: Configuration File Upload Failed\n");
}
else else
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "IOCTL: Firmware File Upload Failed\n");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "IOCTL: Firmware File Upload Failed\n");
}
//up(&Adapter->fw_download_sema);
if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) /* up(&Adapter->fw_download_sema); */
{
if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
Adapter->DriverState = DRIVER_INIT; Adapter->DriverState = DRIVER_INIT;
Adapter->LEDInfo.bLedInitDone = FALSE; Adapter->LEDInfo.bLedInitDone = FALSE;
wake_up(&Adapter->LEDInfo.notify_led_event); wake_up(&Adapter->LEDInfo.notify_led_event);
} }
} }
break ; break;
}while(0);
} while (0);
if(Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS)
up(&Adapter->fw_download_sema); up(&Adapter->fw_download_sema);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "IOCTL: Firmware File Uploaded\n");
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "IOCTL: Firmware File Uploaded\n");
kfree(psFwInfo); kfree(psFwInfo);
break; break;
} }
case IOCTL_BCM_BUFFER_DOWNLOAD_STOP:
{ case IOCTL_BCM_BUFFER_DOWNLOAD_STOP: {
INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock); INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
if(NVMAccess)
{ if (NVMAccess) {
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " FW download blocked as EEPROM Read/Write is in progress\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
"FW download blocked as EEPROM Read/Write is in progress\n");
up(&Adapter->fw_download_sema); up(&Adapter->fw_download_sema);
return -EACCES; return -EACCES;
} }
if(down_trylock(&Adapter->fw_download_sema))
{
Adapter->bBinDownloaded=TRUE;
Adapter->bCfgDownloaded=TRUE;
atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
Adapter->CurrNumRecvDescs=0; if (down_trylock(&Adapter->fw_download_sema)) {
Adapter->bBinDownloaded = TRUE;
Adapter->bCfgDownloaded = TRUE;
atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
Adapter->CurrNumRecvDescs = 0;
Adapter->downloadDDR = 0; Adapter->downloadDDR = 0;
//setting the Mips to Run /* setting the Mips to Run */
Status = run_card_proc(Adapter); Status = run_card_proc(Adapter);
if(Status)
{ if (Status) {
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Firm Download Failed\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Firm Download Failed\n");
up(&Adapter->fw_download_sema); up(&Adapter->fw_download_sema);
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
break; break;
} else {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG,
DBG_LVL_ALL, "Firm Download Over...\n");
} }
else
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Firm Download Over...\n");
mdelay(10); mdelay(10);
/* Wait for MailBox Interrupt */ /* Wait for MailBox Interrupt */
if(StartInterruptUrb((PS_INTERFACE_ADAPTER)Adapter->pvInterfaceAdapter)) if (StartInterruptUrb((PS_INTERFACE_ADAPTER)Adapter->pvInterfaceAdapter))
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Unable to send interrupt...\n");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Unable to send interrupt...\n");
}
timeout = 5*HZ; timeout = 5*HZ;
Adapter->waiting_to_fw_download_done = FALSE; Adapter->waiting_to_fw_download_done = FALSE;
wait_event_timeout(Adapter->ioctl_fw_dnld_wait_queue, wait_event_timeout(Adapter->ioctl_fw_dnld_wait_queue,
Adapter->waiting_to_fw_download_done, timeout); Adapter->waiting_to_fw_download_done, timeout);
Adapter->fw_download_process_pid=INVALID_PID; Adapter->fw_download_process_pid = INVALID_PID;
Adapter->fw_download_done=TRUE; Adapter->fw_download_done = TRUE;
atomic_set(&Adapter->CurrNumFreeTxDesc, 0); atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
Adapter->CurrNumRecvDescs = 0; Adapter->CurrNumRecvDescs = 0;
Adapter->PrevNumRecvDescs = 0; Adapter->PrevNumRecvDescs = 0;
atomic_set(&Adapter->cntrlpktCnt,0); atomic_set(&Adapter->cntrlpktCnt, 0);
Adapter->LinkUpStatus = 0; Adapter->LinkUpStatus = 0;
Adapter->LinkStatus = 0; Adapter->LinkStatus = 0;
if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) if (Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY) {
{
Adapter->DriverState = FW_DOWNLOAD_DONE; Adapter->DriverState = FW_DOWNLOAD_DONE;
wake_up(&Adapter->LEDInfo.notify_led_event); wake_up(&Adapter->LEDInfo.notify_led_event);
} }
if(!timeout) if (!timeout)
{
Status = -ENODEV; Status = -ENODEV;
} } else {
}
else
{
Status = -EINVAL; Status = -EINVAL;
} }
up(&Adapter->fw_download_sema); up(&Adapter->fw_download_sema);
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
break; break;
} }
case IOCTL_BE_BUCKET_SIZE: case IOCTL_BE_BUCKET_SIZE:
Status = 0; Status = 0;
if (get_user(Adapter->BEBucketSize, (unsigned long __user *)arg)) if (get_user(Adapter->BEBucketSize, (unsigned long __user *)arg))
...@@ -916,14 +892,14 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -916,14 +892,14 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
if (get_user(Adapter->rtPSBucketSize, (unsigned long __user *)arg)) if (get_user(Adapter->rtPSBucketSize, (unsigned long __user *)arg))
Status = -EFAULT; Status = -EFAULT;
break; break;
case IOCTL_CHIP_RESET:
{ case IOCTL_CHIP_RESET: {
INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock); INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
if(NVMAccess) if (NVMAccess) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, " IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
return -EACCES; return -EACCES;
} }
down(&Adapter->RxAppControlQueuelock); down(&Adapter->RxAppControlQueuelock);
Status = reset_card_proc(Adapter); Status = reset_card_proc(Adapter);
flushAllAppQ(); flushAllAppQ();
...@@ -932,8 +908,8 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -932,8 +908,8 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
ResetCounters(Adapter); ResetCounters(Adapter);
break; break;
} }
case IOCTL_QOS_THRESHOLD:
{ case IOCTL_QOS_THRESHOLD: {
USHORT uiLoopIndex; USHORT uiLoopIndex;
Status = 0; Status = 0;
...@@ -948,59 +924,56 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -948,59 +924,56 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
} }
case IOCTL_DUMP_PACKET_INFO: case IOCTL_DUMP_PACKET_INFO:
DumpPackInfo(Adapter); DumpPackInfo(Adapter);
DumpPhsRules(&Adapter->stBCMPhsContext); DumpPhsRules(&Adapter->stBCMPhsContext);
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
break; break;
case IOCTL_GET_PACK_INFO: case IOCTL_GET_PACK_INFO:
if(copy_to_user(argp, &Adapter->PackInfo, sizeof(PacketInfo)*NO_OF_QUEUES)) if (copy_to_user(argp, &Adapter->PackInfo, sizeof(PacketInfo)*NO_OF_QUEUES))
return -EFAULT; return -EFAULT;
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
break; break;
case IOCTL_BCM_SWITCH_TRANSFER_MODE:
{ case IOCTL_BCM_SWITCH_TRANSFER_MODE: {
UINT uiData = 0; UINT uiData = 0;
if(copy_from_user(&uiData, argp, sizeof(UINT))) if (copy_from_user(&uiData, argp, sizeof(UINT)))
return -EFAULT; return -EFAULT;
if(uiData) /* Allow All Packets */ if (uiData) {
{ /* Allow All Packets */
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: ETH_PACKET_TUNNELING_MODE\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: ETH_PACKET_TUNNELING_MODE\n");
Adapter->TransferMode = ETH_PACKET_TUNNELING_MODE; Adapter->TransferMode = ETH_PACKET_TUNNELING_MODE;
} } else {
else /* Allow IP only Packets */ /* Allow IP only Packets */
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: IP_PACKET_ONLY_MODE\n");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: IP_PACKET_ONLY_MODE\n");
Adapter->TransferMode = IP_PACKET_ONLY_MODE; Adapter->TransferMode = IP_PACKET_ONLY_MODE;
} }
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
break; break;
} }
case IOCTL_BCM_GET_DRIVER_VERSION: case IOCTL_BCM_GET_DRIVER_VERSION: {
{
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if(copy_to_user(IoBuffer.OutputBuffer, VER_FILEVERSION_STR, IoBuffer.OutputLength)) if (copy_to_user(IoBuffer.OutputBuffer, VER_FILEVERSION_STR, IoBuffer.OutputLength))
return -EFAULT; return -EFAULT;
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
break; break;
} }
case IOCTL_BCM_GET_CURRENT_STATUS:
{ case IOCTL_BCM_GET_CURRENT_STATUS: {
LINK_STATE link_state; LINK_STATE link_state;
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "copy_from_user failed..\n");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user failed..\n");
Status = -EFAULT; Status = -EFAULT;
break; break;
} }
if (IoBuffer.OutputLength != sizeof(link_state)) { if (IoBuffer.OutputLength != sizeof(link_state)) {
Status = -EINVAL; Status = -EINVAL;
break; break;
...@@ -1011,25 +984,23 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -1011,25 +984,23 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
link_state.bShutdownMode = Adapter->bShutStatus; link_state.bShutdownMode = Adapter->bShutStatus;
link_state.ucLinkStatus = Adapter->LinkStatus; link_state.ucLinkStatus = Adapter->LinkStatus;
if (copy_to_user(IoBuffer.OutputBuffer, &link_state, if (copy_to_user(IoBuffer.OutputBuffer, &link_state, min_t(size_t, sizeof(link_state), IoBuffer.OutputLength))) {
min_t(size_t, sizeof(link_state), IoBuffer.OutputLength))) BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy_to_user Failed..\n");
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_to_user Failed..\n");
Status = -EFAULT; Status = -EFAULT;
break; break;
} }
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
break; break;
} }
case IOCTL_BCM_SET_MAC_TRACING:
{ case IOCTL_BCM_SET_MAC_TRACING: {
UINT tracing_flag; UINT tracing_flag;
/* copy ioctl Buffer structure */ /* copy ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if(copy_from_user(&tracing_flag,IoBuffer.InputBuffer,sizeof(UINT))) if (copy_from_user(&tracing_flag, IoBuffer.InputBuffer, sizeof(UINT)))
return -EFAULT; return -EFAULT;
if (tracing_flag) if (tracing_flag)
...@@ -1038,38 +1009,36 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -1038,38 +1009,36 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
Adapter->pTarangs->MacTracingEnabled = FALSE; Adapter->pTarangs->MacTracingEnabled = FALSE;
break; break;
} }
case IOCTL_BCM_GET_DSX_INDICATION:
{ case IOCTL_BCM_GET_DSX_INDICATION: {
ULONG ulSFId=0; ULONG ulSFId = 0;
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if(IoBuffer.OutputLength < sizeof(stLocalSFAddIndicationAlt)) if (IoBuffer.OutputLength < sizeof(stLocalSFAddIndicationAlt)) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,
"Mismatch req: %lx needed is =0x%zx!!!", "Mismatch req: %lx needed is =0x%zx!!!",
IoBuffer.OutputLength, sizeof(stLocalSFAddIndicationAlt)); IoBuffer.OutputLength, sizeof(stLocalSFAddIndicationAlt));
return -EINVAL; return -EINVAL;
} }
if(copy_from_user(&ulSFId, IoBuffer.InputBuffer, sizeof(ulSFId))) if (copy_from_user(&ulSFId, IoBuffer.InputBuffer, sizeof(ulSFId)))
return -EFAULT; return -EFAULT;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Get DSX Data SF ID is =%lx\n", ulSFId ); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Get DSX Data SF ID is =%lx\n", ulSFId);
get_dsx_sf_data_to_application(Adapter, ulSFId, IoBuffer.OutputBuffer); get_dsx_sf_data_to_application(Adapter, ulSFId, IoBuffer.OutputBuffer);
Status=STATUS_SUCCESS; Status = STATUS_SUCCESS;
} }
break; break;
case IOCTL_BCM_GET_HOST_MIBS:
{ case IOCTL_BCM_GET_HOST_MIBS: {
PVOID temp_buff; PVOID temp_buff;
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if(IoBuffer.OutputLength != sizeof(S_MIBS_HOST_STATS_MIBS)) if (IoBuffer.OutputLength != sizeof(S_MIBS_HOST_STATS_MIBS)) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,
"Length Check failed %lu %zd\n", "Length Check failed %lu %zd\n",
IoBuffer.OutputLength, sizeof(S_MIBS_HOST_STATS_MIBS)); IoBuffer.OutputLength, sizeof(S_MIBS_HOST_STATS_MIBS));
return -EINVAL; return -EINVAL;
...@@ -1077,14 +1046,14 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -1077,14 +1046,14 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
/* FIXME: HOST_STATS are too big for kmalloc (122048)! */ /* FIXME: HOST_STATS are too big for kmalloc (122048)! */
temp_buff = kzalloc(sizeof(S_MIBS_HOST_STATS_MIBS), GFP_KERNEL); temp_buff = kzalloc(sizeof(S_MIBS_HOST_STATS_MIBS), GFP_KERNEL);
if(!temp_buff) if (!temp_buff)
return STATUS_FAILURE; return STATUS_FAILURE;
Status = ProcessGetHostMibs(Adapter, temp_buff); Status = ProcessGetHostMibs(Adapter, temp_buff);
GetDroppedAppCntrlPktMibs(temp_buff, pTarang); GetDroppedAppCntrlPktMibs(temp_buff, pTarang);
if (Status != STATUS_FAILURE) if (Status != STATUS_FAILURE)
if(copy_to_user(IoBuffer.OutputBuffer, temp_buff, sizeof(S_MIBS_HOST_STATS_MIBS))) if (copy_to_user(IoBuffer.OutputBuffer, temp_buff, sizeof(S_MIBS_HOST_STATS_MIBS)))
Status = -EFAULT; Status = -EFAULT;
kfree(temp_buff); kfree(temp_buff);
...@@ -1092,42 +1061,40 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -1092,42 +1061,40 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
} }
case IOCTL_BCM_WAKE_UP_DEVICE_FROM_IDLE: case IOCTL_BCM_WAKE_UP_DEVICE_FROM_IDLE:
if((FALSE == Adapter->bTriedToWakeUpFromlowPowerMode) && (TRUE==Adapter->IdleMode)) if ((FALSE == Adapter->bTriedToWakeUpFromlowPowerMode) && (TRUE == Adapter->IdleMode)) {
{
Adapter->usIdleModePattern = ABORT_IDLE_MODE; Adapter->usIdleModePattern = ABORT_IDLE_MODE;
Adapter->bWakeUpDevice = TRUE; Adapter->bWakeUpDevice = TRUE;
wake_up(&Adapter->process_rx_cntrlpkt); wake_up(&Adapter->process_rx_cntrlpkt);
} }
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
break; break;
case IOCTL_BCM_BULK_WRM: case IOCTL_BCM_BULK_WRM: {
{
PBULKWRM_BUFFER pBulkBuffer; PBULKWRM_BUFFER pBulkBuffer;
UINT uiTempVar=0; UINT uiTempVar = 0;
PCHAR pvBuffer = NULL; PCHAR pvBuffer = NULL;
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Device in Idle/Shutdown Mode, Blocking Wrms\n"); BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Device in Idle/Shutdown Mode, Blocking Wrms\n");
Status = -EACCES; Status = -EACCES;
break; break;
} }
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
/* FIXME: restrict length */ /* FIXME: restrict length */
pvBuffer = kmalloc(IoBuffer.InputLength, GFP_KERNEL); pvBuffer = kmalloc(IoBuffer.InputLength, GFP_KERNEL);
if(!pvBuffer) if (!pvBuffer)
return -ENOMEM; return -ENOMEM;
/* Get WrmBuffer structure */ /* Get WrmBuffer structure */
if(copy_from_user(pvBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength)) if (copy_from_user(pvBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength)) {
{
kfree(pvBuffer); kfree(pvBuffer);
Status = -EFAULT; Status = -EFAULT;
break; break;
...@@ -1135,125 +1102,105 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -1135,125 +1102,105 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
pBulkBuffer = (PBULKWRM_BUFFER)pvBuffer; pBulkBuffer = (PBULKWRM_BUFFER)pvBuffer;
if(((ULONG)pBulkBuffer->Register & 0x0F000000) != 0x0F000000 || if (((ULONG)pBulkBuffer->Register & 0x0F000000) != 0x0F000000 ||
((ULONG)pBulkBuffer->Register & 0x3)) ((ULONG)pBulkBuffer->Register & 0x3)) {
{
kfree(pvBuffer); kfree(pvBuffer);
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"WRM Done On invalid Address : %x Access Denied.\n",(int)pBulkBuffer->Register); BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "WRM Done On invalid Address : %x Access Denied.\n", (int)pBulkBuffer->Register);
Status = -EINVAL; Status = -EINVAL;
break; break;
} }
uiTempVar = pBulkBuffer->Register & EEPROM_REJECT_MASK; uiTempVar = pBulkBuffer->Register & EEPROM_REJECT_MASK;
if(!((Adapter->pstargetparams->m_u32Customize)&VSG_MODE) if (!((Adapter->pstargetparams->m_u32Customize)&VSG_MODE) &&
&& ((uiTempVar == EEPROM_REJECT_REG_1)|| ((uiTempVar == EEPROM_REJECT_REG_1) ||
(uiTempVar == EEPROM_REJECT_REG_2) || (uiTempVar == EEPROM_REJECT_REG_2) ||
(uiTempVar == EEPROM_REJECT_REG_3) || (uiTempVar == EEPROM_REJECT_REG_3) ||
(uiTempVar == EEPROM_REJECT_REG_4)) && (uiTempVar == EEPROM_REJECT_REG_4)) &&
(cmd == IOCTL_BCM_REGISTER_WRITE)) (cmd == IOCTL_BCM_REGISTER_WRITE)) {
{
kfree(pvBuffer); kfree(pvBuffer);
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"EEPROM Access Denied, not in VSG Mode\n"); BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
Status = -EFAULT; Status = -EFAULT;
break; break;
} }
if(pBulkBuffer->SwapEndian == FALSE) if (pBulkBuffer->SwapEndian == FALSE)
Status = wrmWithLock(Adapter, (UINT)pBulkBuffer->Register, (PCHAR)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG)); Status = wrmWithLock(Adapter, (UINT)pBulkBuffer->Register, (PCHAR)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
else else
Status = wrmaltWithLock(Adapter, (UINT)pBulkBuffer->Register, (PUINT)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG)); Status = wrmaltWithLock(Adapter, (UINT)pBulkBuffer->Register, (PUINT)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
if(Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS)
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "WRM Failed\n");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Failed\n");
}
kfree(pvBuffer); kfree(pvBuffer);
break; break;
} }
case IOCTL_BCM_GET_NVM_SIZE: case IOCTL_BCM_GET_NVM_SIZE:
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if(Adapter->eNVMType == NVM_EEPROM || Adapter->eNVMType == NVM_FLASH ) { if (Adapter->eNVMType == NVM_EEPROM || Adapter->eNVMType == NVM_FLASH) {
if(copy_to_user(IoBuffer.OutputBuffer, &Adapter->uiNVMDSDSize, sizeof(UINT))) if (copy_to_user(IoBuffer.OutputBuffer, &Adapter->uiNVMDSDSize, sizeof(UINT)))
return -EFAULT; return -EFAULT;
} }
Status = STATUS_SUCCESS ;
break;
case IOCTL_BCM_CAL_INIT : Status = STATUS_SUCCESS;
break;
{ case IOCTL_BCM_CAL_INIT: {
UINT uiSectorSize = 0 ; UINT uiSectorSize = 0 ;
if(Adapter->eNVMType == NVM_FLASH) if (Adapter->eNVMType == NVM_FLASH) {
{ if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if (copy_from_user(&uiSectorSize, IoBuffer.InputBuffer, sizeof(UINT))) if (copy_from_user(&uiSectorSize, IoBuffer.InputBuffer, sizeof(UINT)))
return -EFAULT; return -EFAULT;
if((uiSectorSize < MIN_SECTOR_SIZE) || (uiSectorSize > MAX_SECTOR_SIZE)) if ((uiSectorSize < MIN_SECTOR_SIZE) || (uiSectorSize > MAX_SECTOR_SIZE)) {
{
if (copy_to_user(IoBuffer.OutputBuffer, &Adapter->uiSectorSize, if (copy_to_user(IoBuffer.OutputBuffer, &Adapter->uiSectorSize,
sizeof(UINT))) sizeof(UINT)))
return -EFAULT; return -EFAULT;
} } else {
else if (IsFlash2x(Adapter)) {
{ if (copy_to_user(IoBuffer.OutputBuffer, &Adapter->uiSectorSize, sizeof(UINT)))
if(IsFlash2x(Adapter))
{
if (copy_to_user(IoBuffer.OutputBuffer,
&Adapter->uiSectorSize ,
sizeof(UINT)))
return -EFAULT; return -EFAULT;
} } else {
else if ((TRUE == Adapter->bShutStatus) || (TRUE == Adapter->IdleMode)) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device is in Idle/Shutdown Mode\n");
if((TRUE == Adapter->bShutStatus) ||
(TRUE == Adapter->IdleMode))
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is in Idle/Shutdown Mode\n");
return -EACCES; return -EACCES;
} }
Adapter->uiSectorSize = uiSectorSize ; Adapter->uiSectorSize = uiSectorSize;
BcmUpdateSectorSize(Adapter,Adapter->uiSectorSize); BcmUpdateSectorSize(Adapter, Adapter->uiSectorSize);
}
} }
Status = STATUS_SUCCESS ;
} }
else Status = STATUS_SUCCESS;
{ } else {
Status = STATUS_FAILURE; Status = STATUS_FAILURE;
} }
} }
break; break;
case IOCTL_BCM_SET_DEBUG :
case IOCTL_BCM_SET_DEBUG:
#ifdef DEBUG #ifdef DEBUG
{ {
USER_BCM_DBG_STATE sUserDebugState; USER_BCM_DBG_STATE sUserDebugState;
// BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Entered the ioctl %x \n", IOCTL_BCM_SET_DEBUG ); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In SET_DEBUG ioctl\n");
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In SET_DEBUG ioctl\n");
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if (copy_from_user(&sUserDebugState, IoBuffer.InputBuffer, sizeof(USER_BCM_DBG_STATE))) if (copy_from_user(&sUserDebugState, IoBuffer.InputBuffer, sizeof(USER_BCM_DBG_STATE)))
return -EFAULT; return -EFAULT;
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "IOCTL_BCM_SET_DEBUG: OnOff=%d Type = 0x%x ", BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "IOCTL_BCM_SET_DEBUG: OnOff=%d Type = 0x%x ",
sUserDebugState.OnOff, sUserDebugState.Type); sUserDebugState.OnOff, sUserDebugState.Type);
//sUserDebugState.Subtype <<= 1; /* sUserDebugState.Subtype <<= 1; */
sUserDebugState.Subtype = 1 << sUserDebugState.Subtype; sUserDebugState.Subtype = 1 << sUserDebugState.Subtype;
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "actual Subtype=0x%x\n", sUserDebugState.Subtype); BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "actual Subtype=0x%x\n", sUserDebugState.Subtype);
// Update new 'DebugState' in the Adapter /* Update new 'DebugState' in the Adapter */
Adapter->stDebugState.type |= sUserDebugState.Type; Adapter->stDebugState.type |= sUserDebugState.Type;
/* Subtype: A bitmap of 32 bits for Subtype per Type. /* Subtype: A bitmap of 32 bits for Subtype per Type.
* Valid indexes in 'subtype' array: 1,2,4,8 * Valid indexes in 'subtype' array: 1,2,4,8
...@@ -1266,181 +1213,160 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -1266,181 +1213,160 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
Adapter->stDebugState.subtype[sUserDebugState.Type] &= ~sUserDebugState.Subtype; Adapter->stDebugState.subtype[sUserDebugState.Type] &= ~sUserDebugState.Subtype;
BCM_SHOW_DEBUG_BITMAP(Adapter); BCM_SHOW_DEBUG_BITMAP(Adapter);
} }
#endif #endif
break; break;
case IOCTL_BCM_NVM_READ: case IOCTL_BCM_NVM_READ:
case IOCTL_BCM_NVM_WRITE: case IOCTL_BCM_NVM_WRITE: {
{
NVM_READWRITE stNVMReadWrite; NVM_READWRITE stNVMReadWrite;
PUCHAR pReadData = NULL; PUCHAR pReadData = NULL;
ULONG ulDSDMagicNumInUsrBuff = 0; ULONG ulDSDMagicNumInUsrBuff = 0;
struct timeval tv0, tv1; struct timeval tv0, tv1;
memset(&tv0,0,sizeof(struct timeval)); memset(&tv0, 0, sizeof(struct timeval));
memset(&tv1,0,sizeof(struct timeval)); memset(&tv1, 0, sizeof(struct timeval));
if((Adapter->eNVMType == NVM_FLASH) && (Adapter->uiFlashLayoutMajorVersion == 0)) if ((Adapter->eNVMType == NVM_FLASH) && (Adapter->uiFlashLayoutMajorVersion == 0)) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "The Flash Control Section is Corrupted. Hence Rejection on NVM Read/Write\n");
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,"The Flash Control Section is Corrupted. Hence Rejection on NVM Read/Write\n");
Status = -EFAULT; Status = -EFAULT;
break; break;
} }
if(IsFlash2x(Adapter)) if (IsFlash2x(Adapter)) {
{ if ((Adapter->eActiveDSD != DSD0) &&
if((Adapter->eActiveDSD != DSD0) &&
(Adapter->eActiveDSD != DSD1) && (Adapter->eActiveDSD != DSD1) &&
(Adapter->eActiveDSD != DSD2)) (Adapter->eActiveDSD != DSD2)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"No DSD is active..hence NVM Command is blocked"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "No DSD is active..hence NVM Command is blocked");
return STATUS_FAILURE ; return STATUS_FAILURE ;
} }
} }
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if(copy_from_user(&stNVMReadWrite, if (copy_from_user(&stNVMReadWrite,
(IOCTL_BCM_NVM_READ == cmd) ? IoBuffer.OutputBuffer : IoBuffer.InputBuffer, (IOCTL_BCM_NVM_READ == cmd) ? IoBuffer.OutputBuffer : IoBuffer.InputBuffer,
sizeof(NVM_READWRITE))) sizeof(NVM_READWRITE)))
return -EFAULT; return -EFAULT;
// /*
// Deny the access if the offset crosses the cal area limit. * Deny the access if the offset crosses the cal area limit.
// */
if((stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) > Adapter->uiNVMDSDSize)
{ if ((stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) > Adapter->uiNVMDSDSize) {
//BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Can't allow access beyond NVM Size: 0x%x 0x%x\n", stNVMReadWrite.uiOffset , /* BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Can't allow access beyond NVM Size: 0x%x 0x%x\n", stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes); */
// stNVMReadWrite.uiNumBytes);
Status = STATUS_FAILURE; Status = STATUS_FAILURE;
break; break;
} }
pReadData = kzalloc(stNVMReadWrite.uiNumBytes, GFP_KERNEL); pReadData = kzalloc(stNVMReadWrite.uiNumBytes, GFP_KERNEL);
if(!pReadData) if (!pReadData)
return -ENOMEM; return -ENOMEM;
if(copy_from_user(pReadData, stNVMReadWrite.pBuffer, if (copy_from_user(pReadData, stNVMReadWrite.pBuffer, stNVMReadWrite.uiNumBytes)) {
stNVMReadWrite.uiNumBytes))
{
Status = -EFAULT; Status = -EFAULT;
kfree(pReadData); kfree(pReadData);
break; break;
} }
do_gettimeofday(&tv0); do_gettimeofday(&tv0);
if(IOCTL_BCM_NVM_READ == cmd) if (IOCTL_BCM_NVM_READ == cmd) {
{
down(&Adapter->NVMRdmWrmLock); down(&Adapter->NVMRdmWrmLock);
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device is in Idle/Shutdown Mode\n");
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
kfree(pReadData); kfree(pReadData);
return -EACCES; return -EACCES;
} }
Status = BeceemNVMRead(Adapter, (PUINT)pReadData, Status = BeceemNVMRead(Adapter, (PUINT)pReadData, stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes);
stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes);
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
if(Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS) {
{
kfree(pReadData); kfree(pReadData);
return Status; return Status;
} }
if(copy_to_user(stNVMReadWrite.pBuffer,pReadData, stNVMReadWrite.uiNumBytes))
{ if (copy_to_user(stNVMReadWrite.pBuffer, pReadData, stNVMReadWrite.uiNumBytes)) {
kfree(pReadData); kfree(pReadData);
Status = -EFAULT; Status = -EFAULT;
} }
} } else {
else
{
down(&Adapter->NVMRdmWrmLock); down(&Adapter->NVMRdmWrmLock);
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device is in Idle/Shutdown Mode\n");
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
kfree(pReadData); kfree(pReadData);
return -EACCES; return -EACCES;
} }
Adapter->bHeaderChangeAllowed = TRUE ; Adapter->bHeaderChangeAllowed = TRUE;
if(IsFlash2x(Adapter)) if (IsFlash2x(Adapter)) {
{
/* /*
New Requirement:- * New Requirement:-
DSD section updation will be allowed in two case:- * DSD section updation will be allowed in two case:-
1. if DSD sig is present in DSD header means dongle is ok and updation is fruitfull * 1. if DSD sig is present in DSD header means dongle is ok and updation is fruitfull
2. if point 1 failes then user buff should have DSD sig. this point ensures that if dongle is * 2. if point 1 failes then user buff should have DSD sig. this point ensures that if dongle is
corrupted then user space program first modify the DSD header with valid DSD sig so * corrupted then user space program first modify the DSD header with valid DSD sig so
that this as well as further write may be worthwhile. * that this as well as further write may be worthwhile.
*
This restriction has been put assuming that if DSD sig is corrupted, DSD * This restriction has been put assuming that if DSD sig is corrupted, DSD
data won't be considered valid. * data won't be considered valid.
*/
Status = BcmFlash2xCorruptSig(Adapter, Adapter->eActiveDSD);
if (Status != STATUS_SUCCESS) {
if (((stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) != Adapter->uiNVMDSDSize) ||
(stNVMReadWrite.uiNumBytes < SIGNATURE_SIZE)) {
*/ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "DSD Sig is present neither in Flash nor User provided Input..");
Status = BcmFlash2xCorruptSig(Adapter,Adapter->eActiveDSD);
if(Status != STATUS_SUCCESS)
{
if(( (stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) != Adapter->uiNVMDSDSize ) ||
(stNVMReadWrite.uiNumBytes < SIGNATURE_SIZE))
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
kfree(pReadData); kfree(pReadData);
return Status; return Status;
} }
ulDSDMagicNumInUsrBuff = ntohl(*(PUINT)(pReadData + stNVMReadWrite.uiNumBytes - SIGNATURE_SIZE)); ulDSDMagicNumInUsrBuff = ntohl(*(PUINT)(pReadData + stNVMReadWrite.uiNumBytes - SIGNATURE_SIZE));
if(ulDSDMagicNumInUsrBuff != DSD_IMAGE_MAGIC_NUMBER) if (ulDSDMagicNumInUsrBuff != DSD_IMAGE_MAGIC_NUMBER) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "DSD Sig is present neither in Flash nor User provided Input..");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
kfree(pReadData); kfree(pReadData);
return Status; return Status;
} }
} }
} }
Status = BeceemNVMWrite(Adapter, (PUINT )pReadData,
stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes, stNVMReadWrite.bVerify);
if(IsFlash2x(Adapter))
BcmFlash2xWriteSig(Adapter,Adapter->eActiveDSD);
Adapter->bHeaderChangeAllowed = FALSE ; Status = BeceemNVMWrite(Adapter, (PUINT)pReadData, stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes, stNVMReadWrite.bVerify);
if (IsFlash2x(Adapter))
BcmFlash2xWriteSig(Adapter, Adapter->eActiveDSD);
up(&Adapter->NVMRdmWrmLock); Adapter->bHeaderChangeAllowed = FALSE;
up(&Adapter->NVMRdmWrmLock);
if(Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS) {
{
kfree(pReadData); kfree(pReadData);
return Status; return Status;
} }
} }
do_gettimeofday(&tv1);
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);
do_gettimeofday(&tv1);
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);
kfree(pReadData); kfree(pReadData);
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
} }
break; break;
case IOCTL_BCM_FLASH2X_SECTION_READ :
{
case IOCTL_BCM_FLASH2X_SECTION_READ: {
FLASH2X_READWRITE sFlash2xRead = {0}; FLASH2X_READWRITE sFlash2xRead = {0};
PUCHAR pReadBuff = NULL ; PUCHAR pReadBuff = NULL ;
UINT NOB = 0; UINT NOB = 0;
...@@ -1449,99 +1375,87 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -1449,99 +1375,87 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
UINT ReadOffset = 0; UINT ReadOffset = 0;
void __user *OutPutBuff; void __user *OutPutBuff;
if(IsFlash2x(Adapter) != TRUE) if (IsFlash2x(Adapter) != TRUE) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Does not have 2.x map");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
return -EINVAL; return -EINVAL;
} }
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_FLASH2X_SECTION_READ Called"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_FLASH2X_SECTION_READ Called");
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
//Reading FLASH 2.x READ structure /* Reading FLASH 2.x READ structure */
if (copy_from_user(&sFlash2xRead, IoBuffer.InputBuffer,sizeof(FLASH2X_READWRITE))) if (copy_from_user(&sFlash2xRead, IoBuffer.InputBuffer, sizeof(FLASH2X_READWRITE)))
return -EFAULT; return -EFAULT;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "\nsFlash2xRead.Section :%x", sFlash2xRead.Section);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "\nsFlash2xRead.offset :%x", sFlash2xRead.offset);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "\nsFlash2xRead.numOfBytes :%x", sFlash2xRead.numOfBytes);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "\nsFlash2xRead.bVerify :%x\n", sFlash2xRead.bVerify);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xRead.Section); /* This was internal to driver for raw read. now it has ben exposed to user space app. */
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%x" ,sFlash2xRead.offset); if (validateFlash2xReadWrite(Adapter, &sFlash2xRead) == FALSE)
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xRead.numOfBytes); return STATUS_FAILURE;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xRead.bVerify);
//This was internal to driver for raw read. now it has ben exposed to user space app.
if(validateFlash2xReadWrite(Adapter,&sFlash2xRead) == FALSE)
return STATUS_FAILURE ;
NOB = sFlash2xRead.numOfBytes; NOB = sFlash2xRead.numOfBytes;
if(NOB > Adapter->uiSectorSize ) if (NOB > Adapter->uiSectorSize)
BuffSize = Adapter->uiSectorSize; BuffSize = Adapter->uiSectorSize;
else else
BuffSize = NOB ; BuffSize = NOB;
ReadOffset = sFlash2xRead.offset ; ReadOffset = sFlash2xRead.offset ;
OutPutBuff = IoBuffer.OutputBuffer; OutPutBuff = IoBuffer.OutputBuffer;
pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL); pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
if(pReadBuff == NULL)
{ if (pReadBuff == NULL) {
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed for Flash 2.x Read Structure");
return -ENOMEM; return -ENOMEM;
} }
down(&Adapter->NVMRdmWrmLock); down(&Adapter->NVMRdmWrmLock);
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device is in Idle/Shutdown Mode\n");
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
kfree(pReadBuff); kfree(pReadBuff);
return -EACCES; return -EACCES;
} }
while(NOB) while (NOB) {
{ if (NOB > Adapter->uiSectorSize)
if(NOB > Adapter->uiSectorSize )
ReadBytes = Adapter->uiSectorSize; ReadBytes = Adapter->uiSectorSize;
else else
ReadBytes = NOB; ReadBytes = NOB;
/* Reading the data from Flash 2.x */
//Reading the data from Flash 2.x Status = BcmFlash2xBulkRead(Adapter, (PUINT)pReadBuff, sFlash2xRead.Section, ReadOffset, ReadBytes);
if (Status) {
Status = BcmFlash2xBulkRead(Adapter,(PUINT)pReadBuff,sFlash2xRead.Section,ReadOffset,ReadBytes); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Flash 2x read err with Status :%d", Status);
if(Status) break;
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Flash 2x read err with Status :%d", Status);
break ;
} }
BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes); BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, pReadBuff, ReadBytes);
Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes); Status = copy_to_user(OutPutBuff, pReadBuff, ReadBytes);
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy to use failed with status :%d", Status);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Copy to use failed with status :%d", Status);
break; break;
} }
NOB = NOB - ReadBytes; NOB = NOB - ReadBytes;
if(NOB) if (NOB) {
{ ReadOffset = ReadOffset + ReadBytes;
ReadOffset = ReadOffset + ReadBytes ;
OutPutBuff = OutPutBuff + ReadBytes ; OutPutBuff = OutPutBuff + ReadBytes ;
} }
} }
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
kfree(pReadBuff); kfree(pReadBuff);
} }
break ; break;
case IOCTL_BCM_FLASH2X_SECTION_WRITE :
{ case IOCTL_BCM_FLASH2X_SECTION_WRITE: {
FLASH2X_READWRITE sFlash2xWrite = {0}; FLASH2X_READWRITE sFlash2xWrite = {0};
PUCHAR pWriteBuff; PUCHAR pWriteBuff;
void __user *InputAddr; void __user *InputAddr;
...@@ -1550,134 +1464,128 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -1550,134 +1464,128 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
UINT WriteOffset = 0; UINT WriteOffset = 0;
UINT WriteBytes = 0; UINT WriteBytes = 0;
if(IsFlash2x(Adapter) != TRUE) if (IsFlash2x(Adapter) != TRUE) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Does not have 2.x map");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
return -EINVAL; return -EINVAL;
} }
//First make this False so that we can enable the Sector Permission Check in BeceemFlashBulkWrite /* First make this False so that we can enable the Sector Permission Check in BeceemFlashBulkWrite */
Adapter->bAllDSDWriteAllow = FALSE; Adapter->bAllDSDWriteAllow = FALSE;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_FLASH2X_SECTION_WRITE Called");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_FLASH2X_SECTION_WRITE Called");
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
//Reading FLASH 2.x READ structure /* Reading FLASH 2.x READ structure */
if (copy_from_user(&sFlash2xWrite, IoBuffer.InputBuffer, sizeof(FLASH2X_READWRITE))) if (copy_from_user(&sFlash2xWrite, IoBuffer.InputBuffer, sizeof(FLASH2X_READWRITE)))
return -EFAULT; return -EFAULT;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xWrite.Section); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "\nsFlash2xRead.Section :%x", sFlash2xWrite.Section);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%d" ,sFlash2xWrite.offset); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "\nsFlash2xRead.offset :%d", sFlash2xWrite.offset);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xWrite.numOfBytes); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "\nsFlash2xRead.numOfBytes :%x", sFlash2xWrite.numOfBytes);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xWrite.bVerify); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "\nsFlash2xRead.bVerify :%x\n", sFlash2xWrite.bVerify);
if((sFlash2xWrite.Section != VSA0) && (sFlash2xWrite.Section != VSA1) &&
(sFlash2xWrite.Section != VSA2) ) if ((sFlash2xWrite.Section != VSA0) && (sFlash2xWrite.Section != VSA1) && (sFlash2xWrite.Section != VSA2)) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Only VSA write is allowed");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Only VSA write is allowed");
return -EINVAL; return -EINVAL;
} }
if(validateFlash2xReadWrite(Adapter,&sFlash2xWrite) == FALSE) if (validateFlash2xReadWrite(Adapter, &sFlash2xWrite) == FALSE)
return STATUS_FAILURE ; return STATUS_FAILURE;
InputAddr = sFlash2xWrite.pDataBuff; InputAddr = sFlash2xWrite.pDataBuff;
WriteOffset = sFlash2xWrite.offset ; WriteOffset = sFlash2xWrite.offset;
NOB = sFlash2xWrite.numOfBytes; NOB = sFlash2xWrite.numOfBytes;
if(NOB > Adapter->uiSectorSize ) if (NOB > Adapter->uiSectorSize)
BuffSize = Adapter->uiSectorSize; BuffSize = Adapter->uiSectorSize;
else else
BuffSize = NOB ; BuffSize = NOB ;
pWriteBuff = kmalloc(BuffSize, GFP_KERNEL); pWriteBuff = kmalloc(BuffSize, GFP_KERNEL);
if(pWriteBuff == NULL)
if (pWriteBuff == NULL)
return -ENOMEM; return -ENOMEM;
/* extracting the remainder of the given offset. */
WriteBytes = Adapter->uiSectorSize;
if (WriteOffset % Adapter->uiSectorSize)
WriteBytes = Adapter->uiSectorSize - (WriteOffset % Adapter->uiSectorSize);
//extracting the remainder of the given offset. if (NOB < WriteBytes)
WriteBytes = Adapter->uiSectorSize ;
if(WriteOffset % Adapter->uiSectorSize)
WriteBytes =Adapter->uiSectorSize - (WriteOffset % Adapter->uiSectorSize);
if(NOB < WriteBytes)
WriteBytes = NOB; WriteBytes = NOB;
down(&Adapter->NVMRdmWrmLock); down(&Adapter->NVMRdmWrmLock);
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device is in Idle/Shutdown Mode\n");
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
kfree(pWriteBuff); kfree(pWriteBuff);
return -EACCES; return -EACCES;
} }
BcmFlash2xCorruptSig(Adapter,sFlash2xWrite.Section); BcmFlash2xCorruptSig(Adapter, sFlash2xWrite.Section);
do do {
{ Status = copy_from_user(pWriteBuff, InputAddr, WriteBytes);
Status = copy_from_user(pWriteBuff,InputAddr,WriteBytes); if (Status) {
if(Status) BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy to user failed with status :%d", Status);
{ break;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to user failed with status :%d", Status);
break ;
} }
BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pWriteBuff,WriteBytes); BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, pWriteBuff, WriteBytes);
//Writing the data from Flash 2.x
Status = BcmFlash2xBulkWrite(Adapter,(PUINT)pWriteBuff,sFlash2xWrite.Section,WriteOffset,WriteBytes,sFlash2xWrite.bVerify);
if(Status) /* Writing the data from Flash 2.x */
{ Status = BcmFlash2xBulkWrite(Adapter, (PUINT)pWriteBuff, sFlash2xWrite.Section, WriteOffset, WriteBytes, sFlash2xWrite.bVerify);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
break ; if (Status) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash 2x read err with Status :%d", Status);
break;
} }
NOB = NOB - WriteBytes; NOB = NOB - WriteBytes;
if(NOB) if (NOB) {
{ WriteOffset = WriteOffset + WriteBytes;
WriteOffset = WriteOffset + WriteBytes ; InputAddr = InputAddr + WriteBytes;
InputAddr = InputAddr + WriteBytes ; if (NOB > Adapter->uiSectorSize)
if(NOB > Adapter->uiSectorSize )
WriteBytes = Adapter->uiSectorSize; WriteBytes = Adapter->uiSectorSize;
else else
WriteBytes = NOB; WriteBytes = NOB;
} }
} while (NOB > 0);
BcmFlash2xWriteSig(Adapter, sFlash2xWrite.Section);
} while(NOB > 0);
BcmFlash2xWriteSig(Adapter,sFlash2xWrite.Section);
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
kfree(pWriteBuff); kfree(pWriteBuff);
} }
break ; break;
case IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP :
{
case IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP: {
PFLASH2X_BITMAP psFlash2xBitMap; PFLASH2X_BITMAP psFlash2xBitMap;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP Called"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP Called");
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if(IoBuffer.OutputLength != sizeof(FLASH2X_BITMAP)) if (IoBuffer.OutputLength != sizeof(FLASH2X_BITMAP))
return -EINVAL; return -EINVAL;
psFlash2xBitMap = kzalloc(sizeof(FLASH2X_BITMAP), GFP_KERNEL); psFlash2xBitMap = kzalloc(sizeof(FLASH2X_BITMAP), GFP_KERNEL);
if(psFlash2xBitMap == NULL) if (psFlash2xBitMap == NULL) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory is not available");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory is not available"); return -ENOMEM;
return -ENOMEM ;
} }
//Reading the Flash Sectio Bit map
/* Reading the Flash Sectio Bit map */
down(&Adapter->NVMRdmWrmLock); down(&Adapter->NVMRdmWrmLock);
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device is in Idle/Shutdown Mode\n");
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
kfree(psFlash2xBitMap); kfree(psFlash2xBitMap);
return -EACCES; return -EACCES;
...@@ -1690,236 +1598,207 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -1690,236 +1598,207 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
kfree(psFlash2xBitMap); kfree(psFlash2xBitMap);
} }
break ; break;
case IOCTL_BCM_SET_ACTIVE_SECTION :
{ case IOCTL_BCM_SET_ACTIVE_SECTION: {
FLASH2X_SECTION_VAL eFlash2xSectionVal = 0; FLASH2X_SECTION_VAL eFlash2xSectionVal = 0;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SET_ACTIVE_SECTION Called"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SET_ACTIVE_SECTION Called");
if(IsFlash2x(Adapter) != TRUE) if (IsFlash2x(Adapter) != TRUE) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Does not have 2.x map");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
return -EINVAL; return -EINVAL;
} }
Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)); Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
return Status; return Status;
} }
Status = copy_from_user(&eFlash2xSectionVal,IoBuffer.InputBuffer, sizeof(INT)); Status = copy_from_user(&eFlash2xSectionVal, IoBuffer.InputBuffer, sizeof(INT));
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
return Status; return Status;
} }
down(&Adapter->NVMRdmWrmLock); down(&Adapter->NVMRdmWrmLock);
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device is in Idle/Shutdown Mode\n");
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
return -EACCES; return -EACCES;
} }
Status = BcmSetActiveSection(Adapter,eFlash2xSectionVal); Status = BcmSetActiveSection(Adapter, eFlash2xSectionVal);
if(Status) if (Status)
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Failed to make it's priority Highest. Status %d", Status);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed to make it's priority Highest. Status %d", Status);
}
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
} }
break ; break;
case IOCTL_BCM_IDENTIFY_ACTIVE_SECTION :
{
//Right Now we are taking care of only DSD
Adapter->bAllDSDWriteAllow = FALSE ;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_IDENTIFY_ACTIVE_SECTION called");
Status = STATUS_SUCCESS ; case IOCTL_BCM_IDENTIFY_ACTIVE_SECTION: {
/* Right Now we are taking care of only DSD */
Adapter->bAllDSDWriteAllow = FALSE;
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_IDENTIFY_ACTIVE_SECTION called");
Status = STATUS_SUCCESS;
} }
break ; break;
case IOCTL_BCM_COPY_SECTION :
{ case IOCTL_BCM_COPY_SECTION: {
FLASH2X_COPY_SECTION sCopySectStrut = {0}; FLASH2X_COPY_SECTION sCopySectStrut = {0};
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_COPY_SECTION Called"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_COPY_SECTION Called");
Adapter->bAllDSDWriteAllow = FALSE ; Adapter->bAllDSDWriteAllow = FALSE;
if(IsFlash2x(Adapter) != TRUE) if (IsFlash2x(Adapter) != TRUE) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Does not have 2.x map");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
return -EINVAL; return -EINVAL;
} }
Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)); Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed Status :%d", Status);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed Status :%d", Status);
return Status; return Status;
} }
Status = copy_from_user(&sCopySectStrut, IoBuffer.InputBuffer, sizeof(FLASH2X_COPY_SECTION)); Status = copy_from_user(&sCopySectStrut, IoBuffer.InputBuffer, sizeof(FLASH2X_COPY_SECTION));
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of Copy_Section_Struct failed with Status :%d", Status);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Copy_Section_Struct failed with Status :%d", Status);
return Status; return Status;
} }
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Source SEction :%x", sCopySectStrut.SrcSection);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Destination SEction :%x", sCopySectStrut.DstSection);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "offset :%x", sCopySectStrut.offset);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "NOB :%x", sCopySectStrut.numOfBytes);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Source SEction :%x", sCopySectStrut.SrcSection);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Destination SEction :%x", sCopySectStrut.DstSection);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "offset :%x", sCopySectStrut.offset);
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "NOB :%x", sCopySectStrut.numOfBytes);
if(IsSectionExistInFlash(Adapter,sCopySectStrut.SrcSection) == FALSE) if (IsSectionExistInFlash(Adapter, sCopySectStrut.SrcSection) == FALSE) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Source Section<%x> does not exixt in Flash ", sCopySectStrut.SrcSection);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Source Section<%x> does not exixt in Flash ", sCopySectStrut.SrcSection);
return -EINVAL; return -EINVAL;
} }
if(IsSectionExistInFlash(Adapter,sCopySectStrut.DstSection) == FALSE) if (IsSectionExistInFlash(Adapter, sCopySectStrut.DstSection) == FALSE) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Destinatio Section<%x> does not exixt in Flash ", sCopySectStrut.DstSection);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Destinatio Section<%x> does not exixt in Flash ", sCopySectStrut.DstSection);
return -EINVAL; return -EINVAL;
} }
if(sCopySectStrut.SrcSection == sCopySectStrut.DstSection) if (sCopySectStrut.SrcSection == sCopySectStrut.DstSection) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Source and Destination section should be different");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Source and Destination section should be different");
return -EINVAL; return -EINVAL;
} }
down(&Adapter->NVMRdmWrmLock); down(&Adapter->NVMRdmWrmLock);
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device is in Idle/Shutdown Mode\n");
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
return -EACCES; return -EACCES;
} }
if(sCopySectStrut.SrcSection == ISO_IMAGE1 || sCopySectStrut.SrcSection == ISO_IMAGE2) if (sCopySectStrut.SrcSection == ISO_IMAGE1 || sCopySectStrut.SrcSection == ISO_IMAGE2) {
{ if (IsNonCDLessDevice(Adapter)) {
if(IsNonCDLessDevice(Adapter)) BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Device is Non-CDLess hence won't have ISO !!");
{ Status = -EINVAL;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is Non-CDLess hence won't have ISO !!"); } else if (sCopySectStrut.numOfBytes == 0) {
Status = -EINVAL ; Status = BcmCopyISO(Adapter, sCopySectStrut);
} } else {
else if(sCopySectStrut.numOfBytes == 0) BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Partial Copy of ISO section is not Allowed..");
{ Status = STATUS_FAILURE;
Status = BcmCopyISO(Adapter,sCopySectStrut);
}
else
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Partial Copy of ISO section is not Allowed..");
Status = STATUS_FAILURE ;
} }
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
return Status; return Status;
} }
Status = BcmCopySection(Adapter, sCopySectStrut.SrcSection, Status = BcmCopySection(Adapter, sCopySectStrut.SrcSection,
sCopySectStrut.DstSection,sCopySectStrut.offset,sCopySectStrut.numOfBytes); sCopySectStrut.DstSection, sCopySectStrut.offset, sCopySectStrut.numOfBytes);
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
} }
break ; break;
case IOCTL_BCM_GET_FLASH_CS_INFO :
{ case IOCTL_BCM_GET_FLASH_CS_INFO: {
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_GET_FLASH_CS_INFO Called"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_GET_FLASH_CS_INFO Called");
Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)); Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
break; break;
} }
if(Adapter->eNVMType != NVM_FLASH)
{ if (Adapter->eNVMType != NVM_FLASH) {
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Connected device does not have flash"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Connected device does not have flash");
Status = -EINVAL; Status = -EINVAL;
break; break;
} }
if(IsFlash2x(Adapter) == TRUE)
{
if(IoBuffer.OutputLength < sizeof(FLASH2X_CS_INFO)) if (IsFlash2x(Adapter) == TRUE) {
if (IoBuffer.OutputLength < sizeof(FLASH2X_CS_INFO))
return -EINVAL; return -EINVAL;
if (copy_to_user(IoBuffer.OutputBuffer, Adapter->psFlash2xCSInfo, sizeof(FLASH2X_CS_INFO))) if (copy_to_user(IoBuffer.OutputBuffer, Adapter->psFlash2xCSInfo, sizeof(FLASH2X_CS_INFO)))
return -EFAULT; return -EFAULT;
} } else {
else if (IoBuffer.OutputLength < sizeof(FLASH_CS_INFO))
{
if(IoBuffer.OutputLength < sizeof(FLASH_CS_INFO))
return -EINVAL; return -EINVAL;
if (copy_to_user(IoBuffer.OutputBuffer, Adapter->psFlashCSInfo, sizeof(FLASH_CS_INFO))) if (copy_to_user(IoBuffer.OutputBuffer, Adapter->psFlashCSInfo, sizeof(FLASH_CS_INFO)))
return -EFAULT; return -EFAULT;
} }
} }
break ; break;
case IOCTL_BCM_SELECT_DSD :
{ case IOCTL_BCM_SELECT_DSD: {
UINT SectOfset = 0; UINT SectOfset = 0;
FLASH2X_SECTION_VAL eFlash2xSectionVal; FLASH2X_SECTION_VAL eFlash2xSectionVal;
eFlash2xSectionVal = NO_SECTION_VAL ; eFlash2xSectionVal = NO_SECTION_VAL;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_SELECT_DSD Called"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SELECT_DSD Called");
if(IsFlash2x(Adapter) != TRUE) if (IsFlash2x(Adapter) != TRUE) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash Does not have 2.x map");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
return -EINVAL; return -EINVAL;
} }
Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)); Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
return Status; return Status;
} }
Status = copy_from_user(&eFlash2xSectionVal, IoBuffer.InputBuffer, sizeof(INT)); Status = copy_from_user(&eFlash2xSectionVal, IoBuffer.InputBuffer, sizeof(INT));
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
return Status; return Status;
} }
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", eFlash2xSectionVal); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Read Section :%d", eFlash2xSectionVal);
if((eFlash2xSectionVal != DSD0) && if ((eFlash2xSectionVal != DSD0) &&
(eFlash2xSectionVal != DSD1) && (eFlash2xSectionVal != DSD1) &&
(eFlash2xSectionVal != DSD2) ) (eFlash2xSectionVal != DSD2)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Passed section<%x> is not DSD section", eFlash2xSectionVal); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Passed section<%x> is not DSD section", eFlash2xSectionVal);
return STATUS_FAILURE ; return STATUS_FAILURE;
} }
SectOfset= BcmGetSectionValStartOffset(Adapter,eFlash2xSectionVal); SectOfset = BcmGetSectionValStartOffset(Adapter, eFlash2xSectionVal);
if(SectOfset == INVALID_OFFSET) if (SectOfset == INVALID_OFFSET) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Provided Section val <%d> does not exixt in Flash 2.x", eFlash2xSectionVal);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Provided Section val <%d> does not exixt in Flash 2.x", eFlash2xSectionVal);
return -EINVAL; return -EINVAL;
} }
Adapter->bAllDSDWriteAllow = TRUE ; Adapter->bAllDSDWriteAllow = TRUE;
Adapter->ulFlashCalStart = SectOfset;
Adapter->ulFlashCalStart = SectOfset ;
Adapter->eActiveDSD = eFlash2xSectionVal; Adapter->eActiveDSD = eFlash2xSectionVal;
} }
Status = STATUS_SUCCESS ; Status = STATUS_SUCCESS;
break; break;
case IOCTL_BCM_NVM_RAW_READ : case IOCTL_BCM_NVM_RAW_READ: {
{
NVM_READWRITE stNVMRead; NVM_READWRITE stNVMRead;
INT NOB ; INT NOB ;
INT BuffSize ; INT BuffSize ;
...@@ -1928,100 +1807,91 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -1928,100 +1807,91 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
PUCHAR pReadBuff; PUCHAR pReadBuff;
void __user *OutPutBuff; void __user *OutPutBuff;
if(Adapter->eNVMType != NVM_FLASH) if (Adapter->eNVMType != NVM_FLASH) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "NVM TYPE is not Flash");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"NVM TYPE is not Flash "); return -EINVAL;
return -EINVAL ;
} }
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
if(copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
Status = -EFAULT; Status = -EFAULT;
break; break;
} }
if(copy_from_user(&stNVMRead, IoBuffer.OutputBuffer,sizeof(NVM_READWRITE))) if (copy_from_user(&stNVMRead, IoBuffer.OutputBuffer, sizeof(NVM_READWRITE)))
return -EFAULT; return -EFAULT;
NOB = stNVMRead.uiNumBytes; NOB = stNVMRead.uiNumBytes;
//In Raw-Read max Buff size : 64MB /* In Raw-Read max Buff size : 64MB */
if(NOB > DEFAULT_BUFF_SIZE) if (NOB > DEFAULT_BUFF_SIZE)
BuffSize = DEFAULT_BUFF_SIZE; BuffSize = DEFAULT_BUFF_SIZE;
else else
BuffSize = NOB ; BuffSize = NOB;
ReadOffset = stNVMRead.uiOffset; ReadOffset = stNVMRead.uiOffset;
OutPutBuff = stNVMRead.pBuffer; OutPutBuff = stNVMRead.pBuffer;
pReadBuff = kzalloc(BuffSize , GFP_KERNEL); pReadBuff = kzalloc(BuffSize , GFP_KERNEL);
if(pReadBuff == NULL) if (pReadBuff == NULL) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Memory allocation failed for Flash 2.x Read Structure");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
Status = -ENOMEM; Status = -ENOMEM;
break; break;
} }
down(&Adapter->NVMRdmWrmLock); down(&Adapter->NVMRdmWrmLock);
if((Adapter->IdleMode == TRUE) || if ((Adapter->IdleMode == TRUE) ||
(Adapter->bShutStatus ==TRUE) || (Adapter->bShutStatus == TRUE) ||
(Adapter->bPreparingForLowPowerMode ==TRUE)) (Adapter->bPreparingForLowPowerMode == TRUE)) {
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device is in Idle/Shutdown Mode\n");
kfree(pReadBuff); kfree(pReadBuff);
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
return -EACCES; return -EACCES;
} }
Adapter->bFlashRawRead = TRUE ; Adapter->bFlashRawRead = TRUE;
while(NOB)
{ while (NOB) {
if(NOB > DEFAULT_BUFF_SIZE ) if (NOB > DEFAULT_BUFF_SIZE)
ReadBytes = DEFAULT_BUFF_SIZE; ReadBytes = DEFAULT_BUFF_SIZE;
else else
ReadBytes = NOB; ReadBytes = NOB;
//Reading the data from Flash 2.x /* Reading the data from Flash 2.x */
Status = BeceemNVMRead(Adapter,(PUINT)pReadBuff,ReadOffset,ReadBytes); Status = BeceemNVMRead(Adapter, (PUINT)pReadBuff, ReadOffset, ReadBytes);
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Flash 2x read err with Status :%d", Status);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
break; break;
} }
BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff,ReadBytes); BCM_DEBUG_PRINT_BUFFER(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, pReadBuff, ReadBytes);
Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes); Status = copy_to_user(OutPutBuff, pReadBuff, ReadBytes);
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy to use failed with status :%d", Status);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to use failed with status :%d", Status);
break; break;
} }
NOB = NOB - ReadBytes; NOB = NOB - ReadBytes;
if(NOB) if (NOB) {
{ ReadOffset = ReadOffset + ReadBytes;
ReadOffset = ReadOffset + ReadBytes ; OutPutBuff = OutPutBuff + ReadBytes;
OutPutBuff = OutPutBuff + ReadBytes ;
} }
} }
Adapter->bFlashRawRead = FALSE ; Adapter->bFlashRawRead = FALSE;
up(&Adapter->NVMRdmWrmLock); up(&Adapter->NVMRdmWrmLock);
kfree(pReadBuff); kfree(pReadBuff);
break ; break;
} }
case IOCTL_BCM_CNTRLMSG_MASK: case IOCTL_BCM_CNTRLMSG_MASK: {
{ ULONG RxCntrlMsgBitMask = 0;
ULONG RxCntrlMsgBitMask = 0 ;
/* Copy Ioctl Buffer structure */ /* Copy Ioctl Buffer structure */
Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)); Status = copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER));
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "copy of Ioctl buffer is failed from user space");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of Ioctl buffer is failed from user space");
Status = -EFAULT; Status = -EFAULT;
break; break;
} }
...@@ -2032,21 +1902,20 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -2032,21 +1902,20 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
} }
Status = copy_from_user(&RxCntrlMsgBitMask, IoBuffer.InputBuffer, IoBuffer.InputLength); Status = copy_from_user(&RxCntrlMsgBitMask, IoBuffer.InputBuffer, IoBuffer.InputLength);
if(Status) if (Status) {
{ BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "copy of control bit mask failed from user space");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of control bit mask failed from user space");
Status = -EFAULT; Status = -EFAULT;
break; break;
} }
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\n Got user defined cntrl msg bit mask :%lx", RxCntrlMsgBitMask); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "\n Got user defined cntrl msg bit mask :%lx", RxCntrlMsgBitMask);
pTarang->RxCntrlMsgBitMask = RxCntrlMsgBitMask ; pTarang->RxCntrlMsgBitMask = RxCntrlMsgBitMask;
} }
break; break;
case IOCTL_BCM_GET_DEVICE_DRIVER_INFO:
{ case IOCTL_BCM_GET_DEVICE_DRIVER_INFO: {
DEVICE_DRIVER_INFO DevInfo; DEVICE_DRIVER_INFO DevInfo;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Called IOCTL_BCM_GET_DEVICE_DRIVER_INFO\n"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Called IOCTL_BCM_GET_DEVICE_DRIVER_INFO\n");
DevInfo.MaxRDMBufferSize = BUFFER_4K; DevInfo.MaxRDMBufferSize = BUFFER_4K;
DevInfo.u32DSDStartOffset = EEPROM_CALPARAM_START; DevInfo.u32DSDStartOffset = EEPROM_CALPARAM_START;
...@@ -2057,36 +1926,34 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg) ...@@ -2057,36 +1926,34 @@ static long bcm_char_ioctl(struct file *filp, UINT cmd, ULONG arg)
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if(IoBuffer.OutputLength < sizeof(DevInfo)) if (IoBuffer.OutputLength < sizeof(DevInfo))
return -EINVAL; return -EINVAL;
if (copy_to_user(IoBuffer.OutputBuffer, &DevInfo, sizeof(DevInfo))) if (copy_to_user(IoBuffer.OutputBuffer, &DevInfo, sizeof(DevInfo)))
return -EFAULT; return -EFAULT;
} }
break ; break;
case IOCTL_BCM_TIME_SINCE_NET_ENTRY: case IOCTL_BCM_TIME_SINCE_NET_ENTRY: {
{
ST_TIME_ELAPSED stTimeElapsedSinceNetEntry = {0}; ST_TIME_ELAPSED stTimeElapsedSinceNetEntry = {0};
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_TIME_SINCE_NET_ENTRY called"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_TIME_SINCE_NET_ENTRY called");
if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER))) if (copy_from_user(&IoBuffer, argp, sizeof(IOCTL_BUFFER)))
return -EFAULT; return -EFAULT;
if(IoBuffer.OutputLength < sizeof(ST_TIME_ELAPSED)) if (IoBuffer.OutputLength < sizeof(ST_TIME_ELAPSED))
return -EINVAL; return -EINVAL;
stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = get_seconds() - Adapter->liTimeSinceLastNetEntry; stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = get_seconds() - Adapter->liTimeSinceLastNetEntry;
if (copy_to_user(IoBuffer.OutputBuffer, &stTimeElapsedSinceNetEntry, sizeof(ST_TIME_ELAPSED))) if (copy_to_user(IoBuffer.OutputBuffer, &stTimeElapsedSinceNetEntry, sizeof(ST_TIME_ELAPSED)))
return -EFAULT; return -EFAULT;
} }
break; break;
case IOCTL_CLOSE_NOTIFICATION: case IOCTL_CLOSE_NOTIFICATION:
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_CLOSE_NOTIFICATION"); BCM_DEBUG_PRINT(Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_CLOSE_NOTIFICATION");
break; break;
default: default:
...@@ -2141,3 +2008,4 @@ void unregister_control_device_interface(PMINI_ADAPTER Adapter) ...@@ -2141,3 +2008,4 @@ void unregister_control_device_interface(PMINI_ADAPTER Adapter)
unregister_chrdev(Adapter->major, DEV_NAME); unregister_chrdev(Adapter->major, DEV_NAME);
} }
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7