drivers/staging/bcm/Bcmchar.c

   1 #include "headers.h"
   2 /***************************************************************
   3 * Function        - bcm_char_open()
   4 *
   5 * Description - This is the "open" entry point for the character
   6 *                               driver.
   7 *
   8 * Parameters  - inode: Pointer to the Inode structure of char device
   9 *                               filp : File pointer of the char device
  10 *
  11 * Returns         - Zero(Success)
  12 ****************************************************************/
  13 static struct class *bcm_class = NULL;
  14 static int bcm_char_open(struct inode *inode, struct file * filp)
  15 {
  16         PMINI_ADAPTER           Adapter = NULL;
  17     PPER_TARANG_DATA    pTarang = NULL;
  18
  19         Adapter = GET_BCM_ADAPTER(gblpnetdev);
  20     pTarang = (PPER_TARANG_DATA)kmalloc(sizeof(PER_TARANG_DATA), GFP_KERNEL);
  21     if (!pTarang)
  22         return -ENOMEM;
  23
  24         memset (pTarang, 0, sizeof(PER_TARANG_DATA));
  25     pTarang->Adapter = Adapter;
  26         pTarang->RxCntrlMsgBitMask = 0xFFFFFFFF & ~(1 << 0xB) ;
  27
  28         down(&Adapter->RxAppControlQueuelock);
  29     pTarang->next = Adapter->pTarangs;
  30     Adapter->pTarangs = pTarang;
  31         up(&Adapter->RxAppControlQueuelock);
  32
  33         /* Store the Adapter structure */
  34         filp->private_data = pTarang;
  35
  36         /*Start Queuing the control response Packets*/
  37         atomic_inc(&Adapter->ApplicationRunning);
  38         return 0;
  39 }
  40 static int bcm_char_release(struct inode *inode, struct file *filp)
  41 {
  42     PPER_TARANG_DATA pTarang, tmp, ptmp;
  43         PMINI_ADAPTER Adapter=NULL;
  44     struct sk_buff * pkt, * npkt;
  45
  46     pTarang = (PPER_TARANG_DATA)filp->private_data;
  47
  48     if(pTarang == NULL)
  49         {
  50         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "ptarang is null\n");
  51         return 0;
  52         }
  53
  54         Adapter = pTarang->Adapter;
  55
  56     down( &Adapter->RxAppControlQueuelock);
  57
  58     tmp = Adapter->pTarangs;
  59     for ( ptmp = NULL; tmp; ptmp = tmp, tmp = tmp->next )
  60         {
  61         if ( tmp == pTarang )
  62                         break;
  63         }
  64
  65     if ( tmp )
  66         {
  67         if ( !ptmp )
  68             Adapter->pTarangs = tmp->next;
  69         else
  70             ptmp->next = tmp->next;
  71         }
  72
  73     else
  74         {
  75         up( &Adapter->RxAppControlQueuelock);
  76         return 0;
  77         }
  78
  79     pkt = pTarang->RxAppControlHead;
  80     while ( pkt )
  81         {
  82         npkt = pkt->next;
  83         kfree_skb(pkt);
  84         pkt = npkt;
  85         }
  86
  87     up( &Adapter->RxAppControlQueuelock);
  88
  89     /*Stop Queuing the control response Packets*/
  90     atomic_dec(&Adapter->ApplicationRunning);
  91
  92     bcm_kfree(pTarang);
  93
  94         /* remove this filp from the asynchronously notified filp's */
  95     filp->private_data = NULL;
  96     return 0;
  97 }
  98
  99 static int bcm_char_read(struct file *filp, PCHAR buf, size_t size, loff_t *f_pos)
 100 {
 101     PPER_TARANG_DATA pTarang = (PPER_TARANG_DATA)filp->private_data;
 102         PMINI_ADAPTER   Adapter = pTarang->Adapter;
 103     struct sk_buff* Packet = NULL;
 104     UINT            PktLen = 0;
 105         int                     wait_ret_val=0;
 106
 107         wait_ret_val = wait_event_interruptible(Adapter->process_read_wait_queue,
 108                 (pTarang->RxAppControlHead || Adapter->device_removed));
 109         if((wait_ret_val == -ERESTARTSYS))
 110         {
 111                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Exiting as i've been asked to exit!!!\n");
 112                 return wait_ret_val;
 113         }
 114
 115         if(Adapter->device_removed)
 116         {
 117                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device Removed... Killing the Apps...\n");
 118                 return -ENODEV;
 119         }
 120
 121         if(FALSE == Adapter->fw_download_done)
 122                 return -EACCES;
 123
 124     down( &Adapter->RxAppControlQueuelock);
 125
 126         if(pTarang->RxAppControlHead)
 127         {
 128                 Packet = pTarang->RxAppControlHead;
 129                 DEQUEUEPACKET(pTarang->RxAppControlHead,pTarang->RxAppControlTail);
 130                 pTarang->AppCtrlQueueLen--;
 131         }
 132
 133     up(&Adapter->RxAppControlQueuelock);
 134
 135         if(Packet)
 136         {
 137                 PktLen = Packet->len;
 138                 if(copy_to_user(buf, Packet->data, PktLen))
 139                 {
 140                         bcm_kfree_skb(Packet);
 141                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "\nReturning from copy to user failure \n");
 142                         return -EFAULT;
 143                 }
 144                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Read %d Bytes From Adapter packet = 0x%p by process %d!\n", PktLen, Packet, current->pid);
 145                 bcm_kfree_skb(Packet);
 146         }
 147
 148     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "<====\n");
 149     return PktLen;
 150 }
 151
 152 static INT bcm_char_ioctl(struct inode *inode, struct file *filp,
 153                                         UINT cmd, ULONG arg)
 154 {
 155     PPER_TARANG_DATA  pTarang = (PPER_TARANG_DATA)filp->private_data;
 156         PMINI_ADAPTER   Adapter = pTarang->Adapter;
 157         INT                     Status = STATUS_FAILURE;
 158         IOCTL_BUFFER    IoBuffer={0};
 159 #ifndef BCM_SHM_INTERFACE
 160     int timeout = 0;
 161 #endif
 162
 163
 164         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Parameters Passed to control IOCTL cmd=0x%X arg=0x%lX", cmd, arg);
 165
 166         if(_IOC_TYPE(cmd) != BCM_IOCTL)
 167                 return -EFAULT;
 168         if(_IOC_DIR(cmd) & _IOC_READ)
 169                 Status = !access_ok(VERIFY_WRITE, (PVOID)arg, _IOC_SIZE(cmd));
 170         else if (_IOC_DIR(cmd) & _IOC_WRITE)
 171             Status = !access_ok(VERIFY_READ, (PVOID)arg, _IOC_SIZE(cmd));
 172         else if (_IOC_NONE == (_IOC_DIR(cmd) & _IOC_NONE))
 173             Status = STATUS_SUCCESS;
 174
 175         if(Status)
 176                 return -EFAULT;
 177
 178         if(Adapter->device_removed)
 179         {
 180                 return -EFAULT;
 181         }
 182
 183         if(FALSE == Adapter->fw_download_done)
 184         {
 185                 switch (cmd)
 186                 {
 187                         case IOCTL_MAC_ADDR_REQ:
 188                         case IOCTL_LINK_REQ:
 189                         case IOCTL_CM_REQUEST:
 190                         case IOCTL_SS_INFO_REQ:
 191                         case IOCTL_SEND_CONTROL_MESSAGE:
 192                         case IOCTL_IDLE_REQ:
 193                         case IOCTL_BCM_GPIO_SET_REQUEST:
 194                         case IOCTL_BCM_GPIO_STATUS_REQUEST:
 195                                 return -EACCES;
 196                         default:
 197                                 break;
 198                 }
 199         }
 200
 201         Status = vendorextnIoctl(Adapter, cmd, arg);
 202         if(Status != CONTINUE_COMMON_PATH )
 203         {
 204                  return Status;
 205         }
 206
 207         switch(cmd){
 208                 // Rdms for Swin Idle...
 209                 case IOCTL_BCM_REGISTER_READ_PRIVATE:
 210                 {
 211                         RDM_BUFFER  sRdmBuffer = {0};
 212                         PCHAR temp_buff = NULL;
 213                         UINT Bufflen = 0;
 214                         /* Copy Ioctl Buffer structure */
 215                         if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
 216                                 sizeof(IOCTL_BUFFER)))
 217                         {
 218                                 Status = -EFAULT;
 219                                 break;
 220                         }
 221
 222                         Bufflen = IoBuffer.OutputLength + (4 - IoBuffer.OutputLength%4)%4;
 223                         temp_buff = (PCHAR)kmalloc(Bufflen, GFP_KERNEL);
 224                         if(!temp_buff)
 225                         {
 226                                 return STATUS_FAILURE;
 227                         }
 228                         if(copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer,
 229                                 IoBuffer.InputLength))
 230                         {
 231                                 Status = -EFAULT;
 232                                 break;
 233                         }
 234                         Status = rdmalt(Adapter, (UINT)sRdmBuffer.Register,
 235                                         (PUINT)temp_buff, Bufflen);
 236                         if(Status != STATUS_SUCCESS)
 237                         {
 238                                 bcm_kfree(temp_buff);
 239                                 return Status;
 240                         }
 241                         if(copy_to_user((PCHAR)IoBuffer.OutputBuffer,
 242                                 (PCHAR)temp_buff, (UINT)IoBuffer.OutputLength))
 243                         {
 244                                 Status = -EFAULT;
 245                         }
 246                         bcm_kfree(temp_buff);
 247                         break;
 248                 }
 249                 case IOCTL_BCM_REGISTER_WRITE_PRIVATE:
 250                 {
 251                         WRM_BUFFER  sWrmBuffer = {0};
 252                         UINT uiTempVar=0;
 253                         /* Copy Ioctl Buffer structure */
 254
 255                         if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
 256                                 sizeof(IOCTL_BUFFER)))
 257                         {
 258                                 Status = -EFAULT;
 259                                 break;
 260                         }
 261                         /* Get WrmBuffer structure */
 262                         if(copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer,
 263                                 IoBuffer.InputLength))
 264                         {
 265                                 Status = -EFAULT;
 266                                 break;
 267                         }
 268                         uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK;
 269                         if(!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) &&
 270                                 ((uiTempVar == EEPROM_REJECT_REG_1)||
 271                                 (uiTempVar == EEPROM_REJECT_REG_2) ||
 272                                 (uiTempVar == EEPROM_REJECT_REG_3) ||
 273                                 (uiTempVar == EEPROM_REJECT_REG_4)))
 274                         {
 275                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
 276                                 Status = -EFAULT;
 277                                 break;
 278                         }
 279                         Status = wrmalt(Adapter, (UINT)sWrmBuffer.Register,
 280                                                 (PUINT)sWrmBuffer.Data, sizeof(ULONG));
 281                         if(Status == STATUS_SUCCESS)
 282                         {
 283                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"WRM Done\n");
 284                         }
 285                         else
 286                         {
 287                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
 288                                 Status = -EFAULT;
 289                         }
 290                         break;
 291                 }
 292
 293                 case IOCTL_BCM_REGISTER_READ:
 294                 case IOCTL_BCM_EEPROM_REGISTER_READ:
 295                 {
 296                         RDM_BUFFER  sRdmBuffer = {0};
 297                         PCHAR temp_buff = NULL;
 298                         UINT uiTempVar = 0;
 299                         if((Adapter->IdleMode == TRUE) ||
 300                                 (Adapter->bShutStatus ==TRUE) ||
 301                                 (Adapter->bPreparingForLowPowerMode ==TRUE))
 302                         {
 303                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Rdms\n");
 304                                 Status = -EACCES;
 305                                 break;
 306                         }
 307                         /* Copy Ioctl Buffer structure */
 308                         if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
 309                                 sizeof(IOCTL_BUFFER)))
 310                         {
 311                                 Status = -EFAULT;
 312                                 break;
 313                         }
 314
 315                         temp_buff = (PCHAR)kmalloc(IoBuffer.OutputLength, GFP_KERNEL);
 316                         if(!temp_buff)
 317                         {
 318                                 return STATUS_FAILURE;
 319                         }
 320                         if(copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer,
 321                                 IoBuffer.InputLength))
 322                         {
 323                                 Status = -EFAULT;
 324                                 break;
 325                         }
 326
 327                         if(
 328 #if !defined(BCM_SHM_INTERFACE)
 329                                 (((ULONG)sRdmBuffer.Register & 0x0F000000) != 0x0F000000) ||
 330 #endif
 331                                         ((ULONG)sRdmBuffer.Register & 0x3)
 332                           )
 333                         {
 334                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "RDM Done On invalid Address : %x Access Denied.\n",
 335                                         (int)sRdmBuffer.Register);
 336                                 Status = -EINVAL;
 337                                 break;
 338                         }
 339
 340                         uiTempVar = sRdmBuffer.Register & EEPROM_REJECT_MASK;
 341                         Status = rdmaltWithLock(Adapter, (UINT)sRdmBuffer.Register,
 342                                                 (PUINT)temp_buff, IoBuffer.OutputLength);
 343                         if(Status != STATUS_SUCCESS)
 344                         {
 345                                 bcm_kfree(temp_buff);
 346                                 return Status;
 347                         }
 348                         if(copy_to_user((PCHAR)IoBuffer.OutputBuffer,
 349                                 (PCHAR)temp_buff, (UINT)IoBuffer.OutputLength))
 350                         {
 351                                 Status = -EFAULT;
 352                         }
 353                         bcm_kfree(temp_buff);
 354                         break;
 355                 }
 356                 case IOCTL_BCM_REGISTER_WRITE:
 357                 case IOCTL_BCM_EEPROM_REGISTER_WRITE:
 358                 {
 359                         WRM_BUFFER  sWrmBuffer = {0};
 360                         UINT uiTempVar=0;
 361                         if((Adapter->IdleMode == TRUE) ||
 362                                 (Adapter->bShutStatus ==TRUE) ||
 363                                 (Adapter->bPreparingForLowPowerMode ==TRUE))
 364                         {
 365                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Wrms\n");
 366                                 Status = -EACCES;
 367                                 break;
 368                         }
 369                         /* Copy Ioctl Buffer structure */
 370                         if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
 371                                         sizeof(IOCTL_BUFFER)))
 372                         {
 373                                 Status = -EFAULT;
 374                                 break;
 375                         }
 376                         /* Get WrmBuffer structure */
 377                         if(copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer,
 378                                 IoBuffer.InputLength))
 379                         {
 380                                 Status = -EFAULT;
 381                                 break;
 382                         }
 383                         if(
 384 #if !defined(BCM_SHM_INTERFACE)
 385
 386                                 (((ULONG)sWrmBuffer.Register & 0x0F000000) != 0x0F000000) ||
 387 #endif
 388                                         ((ULONG)sWrmBuffer.Register & 0x3)
 389                          )
 390                         {
 391                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Done On invalid Address : %x Access Denied.\n",
 392                                                 (int)sWrmBuffer.Register);
 393                                 Status = -EINVAL;
 394                                 break;
 395                         }
 396                         uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK;
 397                         if(!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) &&
 398                                 ((uiTempVar == EEPROM_REJECT_REG_1)||
 399                                 (uiTempVar == EEPROM_REJECT_REG_2) ||
 400                                 (uiTempVar == EEPROM_REJECT_REG_3) ||
 401                                 (uiTempVar == EEPROM_REJECT_REG_4)) &&
 402                                 (cmd == IOCTL_BCM_REGISTER_WRITE))
 403                         {
 404                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
 405                                 Status = -EFAULT;
 406                                 break;
 407                         }
 408
 409                         Status = wrmaltWithLock(Adapter, (UINT)sWrmBuffer.Register,
 410                                                         (PUINT)sWrmBuffer.Data, sWrmBuffer.Length);
 411                         if(Status == STATUS_SUCCESS)
 412                         {
 413                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "WRM Done\n");
 414                         }
 415                         else
 416                         {
 417                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
 418                                 Status = -EFAULT;
 419                         }
 420                         break;
 421                 }
 422                 case IOCTL_BCM_GPIO_SET_REQUEST:
 423                 {
 424                         UCHAR ucResetValue[4];
 425                         UINT value =0;
 426                         UINT uiBit = 0;
 427                 UINT uiOperation = 0;
 428
 429                         GPIO_INFO   gpio_info = {0};
 430                         if((Adapter->IdleMode == TRUE) ||
 431                                 (Adapter->bShutStatus ==TRUE) ||
 432                                 (Adapter->bPreparingForLowPowerMode ==TRUE))
 433                         {
 434                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO Can't be set/clear in Low power Mode");
 435                                 Status = -EACCES;
 436                                 break;
 437                         }
 438                         if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
 439                         {
 440                                 Status = -EFAULT;
 441                                 break;
 442                     }
 443                         if(copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
 444                         {
 445                                 Status = -EFAULT;
 446                                 break;
 447                         }
 448                         uiBit  = gpio_info.uiGpioNumber;
 449                         uiOperation = gpio_info.uiGpioValue;
 450
 451                         value= (1<<uiBit);
 452
 453                         if(IsReqGpioIsLedInNVM(Adapter,value) ==FALSE)
 454                         {
 455                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to LED !!!",value);
 456                                 Status = -EINVAL;
 457                                 break;
 458                         }
 459
 460
 461                         if(uiOperation)//Set - setting 1
 462                         {
 463                                 //Set the gpio output register
 464                                 Status = wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_SET_REG ,
 465                                                 (PUINT)(&value), sizeof(UINT));
 466                                 if(Status == STATUS_SUCCESS)
 467                                 {
 468                     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Set the GPIO bit\n");
 469                                 }
 470                     else
 471                         {
 472                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Failed to set the %dth GPIO \n",uiBit);
 473                         break;
 474                 }
 475                         }
 476                         else//Unset - setting 0
 477                         {
 478                                 //Set the gpio output register
 479                                 Status = wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_CLR_REG ,
 480                                                 (PUINT)(&value), sizeof(UINT));
 481                                 if(Status == STATUS_SUCCESS)
 482                                 {
 483                     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Set the GPIO bit\n");
 484                                 }
 485                     else
 486                         {
 487                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Failed to clear the %dth GPIO \n",uiBit);
 488                         break;
 489                 }
 490                         }
 491
 492                         Status = rdmaltWithLock(Adapter, (UINT)GPIO_MODE_REGISTER,
 493                                         (PUINT)ucResetValue, sizeof(UINT));
 494                         if (STATUS_SUCCESS != Status)
 495             {
 496                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO_MODE_REGISTER read failed");
 497                                 break;
 498                         }
 499                         //Set the gpio mode register to output
 500                         *(UINT*)ucResetValue |= (1<<uiBit);
 501                         Status = wrmaltWithLock(Adapter,GPIO_MODE_REGISTER ,
 502                                         (PUINT)ucResetValue, sizeof(UINT));
 503                         if(Status == STATUS_SUCCESS)
 504                         {
 505                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Set the GPIO to output Mode\n");
 506                         }
 507             else
 508             {
 509                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Failed to put GPIO in Output Mode\n");
 510                 break;
 511             }
 512                 }
 513                 break;
 514                 case BCM_LED_THREAD_STATE_CHANGE_REQ:
 515                 {
 516
 517                         USER_THREAD_REQ threadReq = {0};
 518                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"User made LED thread InActive");
 519
 520                         if((Adapter->IdleMode == TRUE) ||
 521                                 (Adapter->bShutStatus ==TRUE) ||
 522                                 (Adapter->bPreparingForLowPowerMode ==TRUE))
 523                         {
 524                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO Can't be set/clear in Low power Mode");
 525                                 Status = -EACCES;
 526                                 break;
 527                         }
 528                         Status =copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
 529                         if(Status)
 530                         {
 531                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
 532                                 break;
 533                         }
 534
 535                         Status= copy_from_user(&threadReq, IoBuffer.InputBuffer, IoBuffer.InputLength);
 536                         if(Status)
 537                         {
 538                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the InputBuffer from user space err:%d",Status);
 539                                 break;
 540                         }
 541                         //if LED thread is running(Actively or Inactively) set it state to make inactive
 542                         if(Adapter->LEDInfo.led_thread_running)
 543                         {
 544                                 if(threadReq.ThreadState == LED_THREAD_ACTIVATION_REQ)
 545                                 {
 546                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Activating thread req");
 547                                         Adapter->DriverState = LED_THREAD_ACTIVE;
 548                                 }
 549                                 else
 550                                 {
 551                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DeActivating Thread req.....");
 552                                         Adapter->DriverState = LED_THREAD_INACTIVE;
 553                                 }
 554
 555                                 //signal thread.
 556                                 wake_up(&Adapter->LEDInfo.notify_led_event);
 557
 558                         }
 559                 }
 560                 break;
 561                 case IOCTL_BCM_GPIO_STATUS_REQUEST:
 562                 {
 563                         ULONG uiBit = 0;
 564                         UCHAR ucRead[4];
 565                         GPIO_INFO   gpio_info = {0};
 566                         if((Adapter->IdleMode == TRUE) ||
 567                                 (Adapter->bShutStatus ==TRUE) ||
 568                                 (Adapter->bPreparingForLowPowerMode ==TRUE))
 569                         {
 570                                 Status = -EACCES;
 571                                 break;
 572                         }
 573                         if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
 574             {
 575                 Status = -EFAULT;
 576                     break;
 577                 }
 578                 if(copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
 579                 {
 580                     Status = -EFAULT;
 581                     break;
 582                 }
 583                 uiBit  = gpio_info.uiGpioNumber;
 584                                   //Set the gpio output register
 585                                 Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER,
 586                         (PUINT)ucRead, sizeof(UINT));
 587                 if(Status != STATUS_SUCCESS)
 588                 {
 589                     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "RDM Failed\n");
 590                                         return Status;
 591                 }
 592
 593                         }
 594                         break;
 595                         case IOCTL_BCM_GPIO_MULTI_REQUEST:
 596                         {
 597                                 UCHAR ucResetValue[4];
 598                                 GPIO_MULTI_INFO gpio_multi_info[MAX_IDX];
 599                                 PGPIO_MULTI_INFO pgpio_multi_info = (PGPIO_MULTI_INFO)gpio_multi_info;
 600
 601                                 memset( pgpio_multi_info, 0, MAX_IDX * sizeof( GPIO_MULTI_INFO));
 602
 603                                 if((Adapter->IdleMode == TRUE) ||
 604                                 (Adapter->bShutStatus ==TRUE) ||
 605                                 (Adapter->bPreparingForLowPowerMode ==TRUE))
 606                                 {
 607                                         Status = -EINVAL;
 608                                         break;
 609                                 }
 610                                 Status = copy_from_user( (PCHAR)&IoBuffer, ( PCHAR)arg, sizeof( IOCTL_BUFFER));
 611                                 if(Status)
 612                                 {
 613                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
 614                                         break;
 615                                 }
 616
 617                                 Status = copy_from_user( &gpio_multi_info, IoBuffer.InputBuffer, IoBuffer.InputLength);
 618                                 if(Status)
 619                                 {
 620                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer Contents from user space err:%d",Status);
 621                                         break;
 622                                 }
 623                                 if(IsReqGpioIsLedInNVM(Adapter,pgpio_multi_info[WIMAX_IDX].uiGPIOMask)== FALSE)
 624                                 {
 625                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to NVM LED bit map<0x%X>!!!",pgpio_multi_info[WIMAX_IDX].uiGPIOMask,Adapter->gpioBitMap);
 626                                         Status = -EINVAL;
 627                                         break;
 628                                 }
 629
 630                                 /* Set the gpio output register */
 631
 632                                 if( ( pgpio_multi_info[WIMAX_IDX].uiGPIOMask) &
 633                                         ( pgpio_multi_info[WIMAX_IDX].uiGPIOCommand))
 634                                 {
 635                                         /* Set 1's in GPIO OUTPUT REGISTER */
 636                                         *(UINT*) ucResetValue =  pgpio_multi_info[WIMAX_IDX].uiGPIOMask &
 637                                                                                  pgpio_multi_info[WIMAX_IDX].uiGPIOCommand &
 638                                                                                          pgpio_multi_info[WIMAX_IDX].uiGPIOValue;
 639
 640                                         if( *(UINT*) ucResetValue)
 641                                                 Status = wrmaltWithLock( Adapter, BCM_GPIO_OUTPUT_SET_REG , (PUINT) ucResetValue, sizeof(ULONG));
 642
 643                                         if( Status != STATUS_SUCCESS)
 644                                         {
 645                                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to BCM_GPIO_OUTPUT_SET_REG Failed.");
 646                                                 return Status;
 647                                         }
 648
 649                                         /* Clear to 0's in GPIO OUTPUT REGISTER */
 650                                         *(UINT*) ucResetValue = (pgpio_multi_info[WIMAX_IDX].uiGPIOMask &
 651                                                         pgpio_multi_info[WIMAX_IDX].uiGPIOCommand &
 652                                                         ( ~( pgpio_multi_info[WIMAX_IDX].uiGPIOValue)));
 653
 654                                         if( *(UINT*) ucResetValue)
 655                                                 Status = wrmaltWithLock( Adapter, BCM_GPIO_OUTPUT_CLR_REG , (PUINT) ucResetValue, sizeof(ULONG));
 656
 657                                         if( Status != STATUS_SUCCESS)
 658                                         {
 659                                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to BCM_GPIO_OUTPUT_CLR_REG Failed." );
 660                                                 return Status;
 661                                         }
 662                                 }
 663
 664                                 if( pgpio_multi_info[WIMAX_IDX].uiGPIOMask)
 665                                 {
 666                                         Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER, (PUINT)ucResetValue, sizeof(UINT));
 667
 668                                         if(Status != STATUS_SUCCESS)
 669                                         {
 670                                                 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"RDM to GPIO_PIN_STATE_REGISTER Failed.");
 671                                                 return Status;
 672                                         }
 673
 674                                         pgpio_multi_info[WIMAX_IDX].uiGPIOValue = ( *(UINT*)ucResetValue &
 675                                                                                         pgpio_multi_info[WIMAX_IDX].uiGPIOMask);
 676                                 }
 677
 678                                 Status = copy_to_user( (PCHAR)IoBuffer.OutputBuffer, &gpio_multi_info, IoBuffer.OutputLength);
 679                                 if(Status)
 680                                 {
 681                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying Content to IOBufer for user space err:%d",Status);
 682                                         break;
 683                                 }
 684                         }
 685                         break;
 686                 case IOCTL_BCM_GPIO_MODE_REQUEST:
 687                 {
 688                         UCHAR ucResetValue[4];
 689                         GPIO_MULTI_MODE gpio_multi_mode[MAX_IDX];
 690                         PGPIO_MULTI_MODE pgpio_multi_mode = ( PGPIO_MULTI_MODE) gpio_multi_mode;
 691
 692                         if((Adapter->IdleMode == TRUE) ||
 693                                 (Adapter->bShutStatus ==TRUE) ||
 694                                 (Adapter->bPreparingForLowPowerMode ==TRUE))
 695                         {
 696                                         Status = -EINVAL;
 697                                         break;
 698                         }
 699                         Status = copy_from_user( (PCHAR)&IoBuffer, ( PCHAR)arg, sizeof( IOCTL_BUFFER));
 700                         if(Status)
 701                         {
 702                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
 703                                 break;
 704                         }
 705
 706                         Status = copy_from_user( &gpio_multi_mode, IoBuffer.InputBuffer, IoBuffer.InputLength);
 707                         if(Status)
 708                         {
 709                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer Contents from user space err:%d",Status);
 710                                 break;
 711                         }
 712
 713                         Status = rdmaltWithLock( Adapter, ( UINT) GPIO_MODE_REGISTER, ( PUINT) ucResetValue, sizeof( UINT));
 714                         if( STATUS_SUCCESS != Status)
 715                         {
 716                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Read of GPIO_MODE_REGISTER failed");
 717                                 return Status;
 718                         }
 719
 720                         //Validating the request
 721                         if(IsReqGpioIsLedInNVM(Adapter,pgpio_multi_mode[WIMAX_IDX].uiGPIOMask)== FALSE)
 722                         {
 723                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to NVM LED bit map<0x%X>!!!",pgpio_multi_mode[WIMAX_IDX].uiGPIOMask,Adapter->gpioBitMap);
 724                                 Status = -EINVAL;
 725                                 break;
 726                         }
 727
 728                         if( pgpio_multi_mode[WIMAX_IDX].uiGPIOMask)
 729                         {
 730                                 /* write all OUT's (1's) */
 731                                 *( UINT*) ucResetValue |= ( pgpio_multi_mode[WIMAX_IDX].uiGPIOMode &
 732                                                                 pgpio_multi_mode[WIMAX_IDX].uiGPIOMask);
 733                                 /* write all IN's (0's) */
 734                                 *( UINT*) ucResetValue &= ~( ( ~pgpio_multi_mode[WIMAX_IDX].uiGPIOMode) &
 735                                                                 pgpio_multi_mode[WIMAX_IDX].uiGPIOMask);
 736
 737                                 /* Currently implemented return the modes of all GPIO's
 738                                  * else needs to bit AND with  mask
 739                                  * */
 740                                 pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *(UINT*)ucResetValue;
 741
 742                                 Status = wrmaltWithLock( Adapter, GPIO_MODE_REGISTER , ( PUINT) ucResetValue, sizeof( ULONG));
 743                                 if( Status == STATUS_SUCCESS)
 744                                 {
 745                                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM to GPIO_MODE_REGISTER Done");
 746                                 }
 747                                 else
 748                                 {
 749                                         BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to GPIO_MODE_REGISTER Failed");
 750                                         Status = -EFAULT;
 751                                         break;
 752                                 }
 753                         }
 754                         else /* if uiGPIOMask is 0 then return mode register configuration */
 755                         {
 756                                 pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *( UINT*) ucResetValue;
 757                         }
 758                         Status = copy_to_user( (PCHAR)IoBuffer.OutputBuffer, &gpio_multi_mode, IoBuffer.OutputLength);
 759                         if(Status)
 760                         {
 761                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying Content to IOBufer for user space err:%d",Status);
 762                                 break;
 763                         }
 764                 }
 765                 break;
 766
 767                 case IOCTL_MAC_ADDR_REQ:
 768                 case IOCTL_LINK_REQ:
 769                 case IOCTL_CM_REQUEST:
 770                 case IOCTL_SS_INFO_REQ:
 771                 case IOCTL_SEND_CONTROL_MESSAGE:
 772                 case IOCTL_IDLE_REQ:
 773                 {
 774                         PVOID pvBuffer=NULL;
 775                         /* Copy Ioctl Buffer structure */
 776                         if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
 777                                                         sizeof(IOCTL_BUFFER)))
 778                         {
 779                                 Status = -EFAULT;
 780                                 break;
 781                         }
 782                         pvBuffer=kmalloc(IoBuffer.InputLength, GFP_KERNEL);
 783                         if(!pvBuffer)
 784                         {
 785                                 return -ENOMEM;
 786                         }
 787
 788                         if(copy_from_user(pvBuffer, IoBuffer.InputBuffer,
 789                                         IoBuffer.InputLength))
 790                         {
 791                                 Status = -EFAULT;
 792                                 bcm_kfree(pvBuffer);
 793                                 break;
 794                         }
 795
 796                         down(&Adapter->LowPowerModeSync);
 797                         Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue,
 798                                                                                                         !Adapter->bPreparingForLowPowerMode,
 799                                                                                                         (1 * HZ));
 800                         if(Status == -ERESTARTSYS)
 801                                         goto cntrlEnd;
 802
 803                         if(Adapter->bPreparingForLowPowerMode)
 804                         {
 805                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Preparing Idle Mode is still True - Hence Rejecting control message\n");
 806                                 Status = STATUS_FAILURE ;
 807                                 goto cntrlEnd ;
 808                         }
 809                         Status = CopyBufferToControlPacket(Adapter, (PVOID)pvBuffer);
 810                 cntrlEnd:
 811                         up(&Adapter->LowPowerModeSync);
 812                         bcm_kfree(pvBuffer);
 813                         break;
 814                 }
 815 #ifndef BCM_SHM_INTERFACE
 816                 case IOCTL_BCM_BUFFER_DOWNLOAD_START:
 817                 {
 818                         INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock) ;
 819                         if(NVMAccess)
 820                         {
 821                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
 822                                 return -EACCES;
 823                         }
 824                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
 825                     if(!down_trylock(&Adapter->fw_download_sema))
 826                         {
 827                                 Adapter->bBinDownloaded=FALSE;
 828                                 Adapter->fw_download_process_pid=current->pid;
 829                                 Adapter->bCfgDownloaded=FALSE;
 830                                 Adapter->fw_download_done=FALSE;
 831                                 netif_carrier_off(Adapter->dev);
 832                                 netif_stop_queue(Adapter->dev);
 833                                 Status = reset_card_proc(Adapter);
 834                                 if(Status)
 835                                 {
 836                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "reset_card_proc Failed!\n");
 837                                         up(&Adapter->fw_download_sema);
 838                                         up(&Adapter->NVMRdmWrmLock);
 839                                         break;
 840                                 }
 841                                 mdelay(10);
 842                         }
 843                         else
 844                         {
 845
 846                                 Status = -EBUSY;
 847
 848                         }
 849                         up(&Adapter->NVMRdmWrmLock);
 850                         break;
 851                 }
 852                 case IOCTL_BCM_BUFFER_DOWNLOAD:
 853                         {
 854                                 FIRMWARE_INFO   *psFwInfo=NULL;
 855                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
 856                         do{
 857                                 if(!down_trylock(&Adapter->fw_download_sema))
 858                                 {
 859                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid way to download buffer. Use Start and then call this!!!\n");
 860                                         Status=-EINVAL;
 861                                         break;
 862                                 }
 863                                 /* Copy Ioctl Buffer structure */
 864                                 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
 865                                                 sizeof(IOCTL_BUFFER)))
 866                                 {
 867                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
 868                                         Status = -EFAULT;
 869                                         break;
 870                                 }
 871                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Length for FW DLD is : %lx\n",
 872                                                                                 IoBuffer.InputLength);
 873                                 psFwInfo=kmalloc(sizeof(*psFwInfo), GFP_KERNEL);
 874                                 if(!psFwInfo)
 875                                 {
 876                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Failed to allocate buffer!!!!\n");
 877                                         Status = -ENOMEM;
 878                                         break;
 879                                 }
 880                                 if(copy_from_user(psFwInfo, IoBuffer.InputBuffer,
 881                                                         IoBuffer.InputLength))
 882                                 {
 883                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_from_user 2 failed\n");
 884                                         Status = -EFAULT;
 885                                         break;
 886                                 }
 887
 888                                 if(!psFwInfo->pvMappedFirmwareAddress ||
 889                                                 (psFwInfo->u32FirmwareLength == 0))
 890                                 {
 891                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Something else is wrong %lu\n",
 892                                         psFwInfo->u32FirmwareLength);
 893                                         Status = -EINVAL;
 894                                         break;
 895                                 }
 896                                 Status = bcm_ioctl_fw_download(Adapter, psFwInfo);
 897                                 if(Status != STATUS_SUCCESS)
 898                                 {
 899                                         if(psFwInfo->u32StartingAddress==CONFIG_BEGIN_ADDR)
 900                                         {
 901                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "IOCTL: Configuration File Upload Failed\n");
 902                                         }
 903                                         else
 904                                         {
 905                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "IOCTL: Firmware File Upload Failed\n");
 906                                         }
 907                                         //up(&Adapter->fw_download_sema);
 908
 909                                         if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)
 910                                         {
 911                                                 Adapter->DriverState = DRIVER_INIT;
 912                                                 Adapter->LEDInfo.bLedInitDone = FALSE;
 913                                                 wake_up(&Adapter->LEDInfo.notify_led_event);
 914                                         }
 915                                 }
 916                                 break ;
 917                           }while(0);
 918
 919                           if(Status != STATUS_SUCCESS)
 920                                         up(&Adapter->fw_download_sema);
 921                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "IOCTL: Firmware File Uploaded\n");
 922                                 bcm_kfree(psFwInfo);
 923                                 break;
 924                         }
 925                 case IOCTL_BCM_BUFFER_DOWNLOAD_STOP:
 926                 {
 927                         INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
 928                         if(NVMAccess)
 929                         {
 930                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " FW download blocked as EEPROM Read/Write is in progress\n");
 931                                 up(&Adapter->fw_download_sema);
 932                                 return -EACCES;
 933                         }
 934                         if(down_trylock(&Adapter->fw_download_sema))
 935                         {
 936                                 Adapter->bBinDownloaded=TRUE;
 937                                 Adapter->bCfgDownloaded=TRUE;
 938                                 atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
 939                                 atomic_set(&Adapter->RxRollOverCount, 0);
 940                                 Adapter->CurrNumRecvDescs=0;
 941                                 Adapter->downloadDDR = 0;
 942
 943                                 //setting the Mips to Run
 944                                 Status = run_card_proc(Adapter);
 945                                 if(Status)
 946                                 {
 947                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Firm Download Failed\n");
 948                                         up(&Adapter->fw_download_sema);
 949                                         up(&Adapter->NVMRdmWrmLock);
 950                                         break;
 951                                 }
 952                                 else
 953                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Firm Download Over...\n");
 954                                 mdelay(10);
 955                                 /* Wait for MailBox Interrupt */
 956                                 if(StartInterruptUrb((PS_INTERFACE_ADAPTER)Adapter->pvInterfaceAdapter))
 957                                 {
 958                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Unable to send interrupt...\n");
 959                                 }
 960                                 timeout = 5*HZ;
 961                                 Adapter->waiting_to_fw_download_done = FALSE;
 962                                 wait_event_timeout(Adapter->ioctl_fw_dnld_wait_queue,
 963                                         Adapter->waiting_to_fw_download_done, timeout);
 964                                 Adapter->fw_download_process_pid=INVALID_PID;
 965                                 Adapter->fw_download_done=TRUE;
 966                                 atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
 967                                 Adapter->CurrNumRecvDescs = 0;
 968                                 Adapter->PrevNumRecvDescs = 0;
 969                                 atomic_set(&Adapter->cntrlpktCnt,0);
 970                 Adapter->LinkUpStatus = 0;
 971                 Adapter->LinkStatus = 0;
 972
 973                                 if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)
 974                                 {
 975                                         Adapter->DriverState = FW_DOWNLOAD_DONE;
 976                                         wake_up(&Adapter->LEDInfo.notify_led_event);
 977                                 }
 978
 979                                 if(!timeout)
 980                                 {
 981                                         Status = -ENODEV;
 982                                 }
 983                         }
 984                         else
 985                         {
 986                                 Status = -EINVAL;
 987                         }
 988                         up(&Adapter->fw_download_sema);
 989                         up(&Adapter->NVMRdmWrmLock);
 990                         break;
 991                 }
 992 #endif
 993                 case IOCTL_BE_BUCKET_SIZE:
 994                         Adapter->BEBucketSize = *(PULONG)arg;
 995                         Status = STATUS_SUCCESS;
 996                         break;
 997
 998                 case IOCTL_RTPS_BUCKET_SIZE:
 999                         Adapter->rtPSBucketSize = *(PULONG)arg;
1000                         Status = STATUS_SUCCESS;
1001                         break;
1002                 case IOCTL_CHIP_RESET:
1003             {
1004                         INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
1005                         if(NVMAccess)
1006                         {
1007                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
1008                                 return -EACCES;
1009                         }
1010                         down(&Adapter->RxAppControlQueuelock);
1011                         Status = reset_card_proc(Adapter);
1012                         flushAllAppQ();
1013                         up(&Adapter->RxAppControlQueuelock);
1014                         up(&Adapter->NVMRdmWrmLock);
1015                         ResetCounters(Adapter);
1016                         break;
1017                 }
1018                 case IOCTL_QOS_THRESHOLD:
1019                 {
1020                         USHORT uiLoopIndex;
1021                         for(uiLoopIndex = 0 ; uiLoopIndex < NO_OF_QUEUES ; uiLoopIndex++)
1022                         {
1023                                 Adapter->PackInfo[uiLoopIndex].uiThreshold = *(PULONG)arg;
1024                         }
1025                         Status = STATUS_SUCCESS;
1026                         break;
1027                 }
1028
1029                 case IOCTL_DUMP_PACKET_INFO:
1030
1031                         DumpPackInfo(Adapter);
1032                 DumpPhsRules(&Adapter->stBCMPhsContext);
1033                         Status = STATUS_SUCCESS;
1034                         break;
1035
1036                 case IOCTL_GET_PACK_INFO:
1037                         if(copy_to_user((PCHAR)arg, &Adapter->PackInfo,
1038                                 sizeof(PacketInfo)*NO_OF_QUEUES))
1039                         {
1040                                 Status = -EFAULT;
1041                                 break;
1042                         }
1043                         Status = STATUS_SUCCESS;
1044                         break;
1045                 case IOCTL_BCM_SWITCH_TRANSFER_MODE:
1046                 {
1047                         UINT uiData = 0;
1048                         if(copy_from_user(&uiData, (PUINT)arg, sizeof(UINT)))
1049                         {
1050                                 Status = -EFAULT;
1051                                 break;
1052                         }
1053                         if(uiData)      /* Allow All Packets */
1054                         {
1055                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: ETH_PACKET_TUNNELING_MODE\n");
1056                                 Adapter->TransferMode = ETH_PACKET_TUNNELING_MODE;
1057                         }
1058                         else    /* Allow IP only Packets */
1059                         {
1060                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: IP_PACKET_ONLY_MODE\n");
1061                                 Adapter->TransferMode = IP_PACKET_ONLY_MODE;
1062                         }
1063                         Status = STATUS_SUCCESS;
1064                         break;
1065                 }
1066
1067                 case IOCTL_BCM_GET_DRIVER_VERSION:
1068                 {
1069                         /* Copy Ioctl Buffer structure */
1070                         if(copy_from_user((PCHAR)&IoBuffer,
1071                                         (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1072                         {
1073                                 Status = -EFAULT;
1074                                 break;
1075                         }
1076                         if(copy_to_user((PUCHAR)IoBuffer.OutputBuffer,
1077                                 VER_FILEVERSION_STR, (UINT)IoBuffer.OutputLength))
1078                         {
1079                                 Status = -EFAULT;
1080                                 break;
1081                         }
1082                         Status = STATUS_SUCCESS;
1083                         break;
1084                 }
1085                 case IOCTL_BCM_GET_CURRENT_STATUS:
1086                 {
1087                         LINK_STATE *plink_state = NULL;
1088                         /* Copy Ioctl Buffer structure */
1089                         if(copy_from_user((PCHAR)&IoBuffer,
1090                                         (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1091                         {
1092                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user failed..\n");
1093                                 Status = -EFAULT;
1094                                 break;
1095                         }
1096                         plink_state = (LINK_STATE*)arg;
1097                         plink_state->bIdleMode = (UCHAR)Adapter->IdleMode;
1098                         plink_state->bShutdownMode = Adapter->bShutStatus;
1099                         plink_state->ucLinkStatus = (UCHAR)Adapter->LinkStatus;
1100                         if(copy_to_user((PUCHAR)IoBuffer.OutputBuffer,
1101                                 (PUCHAR)plink_state, (UINT)IoBuffer.OutputLength))
1102                         {
1103                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_to_user Failed..\n");
1104                                 Status = -EFAULT;
1105                                 break;
1106                         }
1107                         Status = STATUS_SUCCESS;
1108                         break;
1109                 }
1110         case IOCTL_BCM_SET_MAC_TRACING:
1111         {
1112             UINT  tracing_flag;
1113             /* copy ioctl Buffer structure */
1114                         if(copy_from_user((PCHAR)&IoBuffer,
1115                                 (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1116                         {
1117                                 Status = -EFAULT;
1118                                 break;
1119                         }
1120                         if(copy_from_user((PCHAR)&tracing_flag,
1121                      (PCHAR)IoBuffer.InputBuffer,sizeof(UINT)))
1122             {
1123                                 Status = -EFAULT;
1124                                 break;
1125                         }
1126             if (tracing_flag)
1127                 Adapter->pTarangs->MacTracingEnabled = TRUE;
1128             else
1129                 Adapter->pTarangs->MacTracingEnabled = FALSE;
1130             break;
1131         }
1132                 case IOCTL_BCM_GET_DSX_INDICATION:
1133                 {
1134                         ULONG ulSFId=0;
1135                         if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
1136                                         sizeof(IOCTL_BUFFER)))
1137                         {
1138                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid IO buffer!!!" );
1139                                 Status = -EFAULT;
1140                                 break;
1141                         }
1142                         if(IoBuffer.OutputLength < sizeof(stLocalSFAddIndicationAlt))
1143                         {
1144                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Mismatch req: %lx needed is =0x%zx!!!",
1145                                         IoBuffer.OutputLength, sizeof(stLocalSFAddIndicationAlt));
1146                                 return -EINVAL;
1147                         }
1148                         if(copy_from_user((PCHAR)&ulSFId, (PCHAR)IoBuffer.InputBuffer,
1149                                         sizeof(ulSFId)))
1150                         {
1151                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Invalid SFID!!! %lu", ulSFId );
1152                                 Status = -EFAULT;
1153                                 break;
1154                         }
1155                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Get DSX Data SF ID is =%lx\n", ulSFId );
1156                         get_dsx_sf_data_to_application(Adapter, ulSFId,
1157                                 IoBuffer.OutputBuffer);
1158                         Status=STATUS_SUCCESS;
1159                 }
1160                 break;
1161                 case IOCTL_BCM_GET_HOST_MIBS:
1162                 {
1163                         PCHAR temp_buff;
1164
1165                         if(copy_from_user((PCHAR)&IoBuffer,
1166                                         (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1167                         {
1168                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_from user for IoBuff failed\n");
1169                                 Status = -EFAULT;
1170                                 break;
1171                         }
1172
1173                         if(IoBuffer.OutputLength != sizeof(S_MIBS_HOST_STATS_MIBS))
1174                         {
1175                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Length Check failed %lu %zd\n", IoBuffer.OutputLength,
1176                                                                                         sizeof(S_MIBS_HOST_STATS_MIBS));
1177                         return -EINVAL;
1178                         }
1179
1180                         temp_buff = (PCHAR)kmalloc(IoBuffer.OutputLength, GFP_KERNEL);
1181
1182                         if(!temp_buff)
1183                         {
1184                                 return STATUS_FAILURE;
1185                         }
1186
1187                         Status = ProcessGetHostMibs(Adapter,
1188                                         (PUCHAR)temp_buff, IoBuffer.OutputLength);
1189
1190                 Status = GetDroppedAppCntrlPktMibs((PVOID)temp_buff,
1191                                                                         (PPER_TARANG_DATA)filp->private_data);
1192
1193                         if(copy_to_user((PCHAR)IoBuffer.OutputBuffer,(PCHAR)temp_buff,
1194                                 sizeof(S_MIBS_HOST_STATS_MIBS)))
1195                         {
1196                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy to user failed\n");
1197                                 bcm_kfree(temp_buff);
1198                                 return -EFAULT;
1199                         }
1200
1201                         bcm_kfree(temp_buff);
1202                         break;
1203                 }
1204
1205                 case IOCTL_BCM_WAKE_UP_DEVICE_FROM_IDLE:
1206                         if((FALSE == Adapter->bTriedToWakeUpFromlowPowerMode) && (TRUE==Adapter->IdleMode))
1207                         {
1208                                 Adapter->usIdleModePattern = ABORT_IDLE_MODE;
1209                                 Adapter->bWakeUpDevice = TRUE;
1210                                 wake_up(&Adapter->process_rx_cntrlpkt);
1211                                 #if 0
1212                                 Adapter->bTriedToWakeUpFromlowPowerMode = TRUE;
1213                                 InterfaceAbortIdlemode (Adapter, Adapter->usIdleModePattern);
1214                                 #endif
1215                         }
1216                         Status = STATUS_SUCCESS;
1217                         break;
1218
1219                 case IOCTL_BCM_BULK_WRM:
1220                         {
1221                                 PBULKWRM_BUFFER pBulkBuffer;
1222                                 UINT uiTempVar=0;
1223                                 PCHAR pvBuffer = NULL;
1224
1225                                 if((Adapter->IdleMode == TRUE) ||
1226                                         (Adapter->bShutStatus ==TRUE) ||
1227                                         (Adapter->bPreparingForLowPowerMode ==TRUE))
1228                                 {
1229                     BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Device in Idle/Shutdown Mode, Blocking Wrms\n");
1230                                         Status = -EACCES;
1231                                         break;
1232                                 }
1233                                 /* Copy Ioctl Buffer structure */
1234                                 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1235                                 {
1236                                         Status = -EFAULT;
1237                                         break;
1238                                 }
1239
1240                                 pvBuffer=kmalloc(IoBuffer.InputLength, GFP_KERNEL);
1241                                 if(!pvBuffer)
1242                                 {
1243                                         return -ENOMEM;
1244                                         break;
1245                                 }
1246
1247                                 /* Get WrmBuffer structure */
1248                 if(copy_from_user(pvBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength))
1249                                 {
1250                                         bcm_kfree(pvBuffer);
1251                                         Status = -EFAULT;
1252                                         break;
1253                                 }
1254
1255                                 pBulkBuffer = (PBULKWRM_BUFFER)pvBuffer;
1256
1257                                 if(((ULONG)pBulkBuffer->Register & 0x0F000000) != 0x0F000000 ||
1258                                         ((ULONG)pBulkBuffer->Register & 0x3))
1259                                 {
1260                                         bcm_kfree(pvBuffer);
1261                     BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"WRM Done On invalid Address : %x Access Denied.\n",(int)pBulkBuffer->Register);
1262                                         Status = -EINVAL;
1263                                         break;
1264                                 }
1265
1266
1267                                 uiTempVar = pBulkBuffer->Register & EEPROM_REJECT_MASK;
1268                                 if(!((Adapter->pstargetparams->m_u32Customize)&VSG_MODE)
1269                                 &&      ((uiTempVar == EEPROM_REJECT_REG_1)||
1270                                                 (uiTempVar == EEPROM_REJECT_REG_2) ||
1271                                         (uiTempVar == EEPROM_REJECT_REG_3) ||
1272                                         (uiTempVar == EEPROM_REJECT_REG_4)) &&
1273                                         (cmd == IOCTL_BCM_REGISTER_WRITE))
1274                                 {
1275                                         bcm_kfree(pvBuffer);
1276                     BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"EEPROM Access Denied, not in VSG Mode\n");
1277                                         Status = -EFAULT;
1278                                         break;
1279                                 }
1280
1281                                 if(pBulkBuffer->SwapEndian == FALSE)
1282                                         Status = wrmWithLock(Adapter, (UINT)pBulkBuffer->Register, (PCHAR)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
1283                                 else
1284                                         Status = wrmaltWithLock(Adapter, (UINT)pBulkBuffer->Register, (PUINT)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
1285
1286                                 if(Status != STATUS_SUCCESS)
1287                                 {
1288                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Failed\n");
1289                                 }
1290
1291                                 bcm_kfree(pvBuffer);
1292                                 break;
1293                         }
1294
1295                 case IOCTL_BCM_GET_NVM_SIZE:
1296                         {
1297
1298                         if(copy_from_user((unsigned char *)&IoBuffer,
1299                                         (unsigned char *)arg, sizeof(IOCTL_BUFFER)))
1300                         {
1301                                 //IOLog("failed NVM first");
1302                                 Status = -EFAULT;
1303                                 break;
1304                         }
1305                         if(Adapter->eNVMType == NVM_EEPROM || Adapter->eNVMType == NVM_FLASH ) {
1306                                 if(copy_to_user(IoBuffer.OutputBuffer,
1307                                         (unsigned char *)&Adapter->uiNVMDSDSize, (UINT)sizeof(UINT)))
1308                                 {
1309                                                 Status = -EFAULT;
1310                                                 return Status;
1311                                 }
1312                         }
1313
1314                         Status = STATUS_SUCCESS ;
1315                         }
1316                         break;
1317
1318                 case IOCTL_BCM_CAL_INIT :
1319
1320                         {
1321                                 UINT uiSectorSize = 0 ;
1322                                 if(Adapter->eNVMType == NVM_FLASH)
1323                                 {
1324                                         Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1325                                         if(Status)
1326                                         {
1327                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy From User space failed. status :%d", Status);
1328                                                 return Status;
1329                                         }
1330                                         uiSectorSize = *((PUINT)(IoBuffer.InputBuffer));
1331                                         if((uiSectorSize < MIN_SECTOR_SIZE) || (uiSectorSize > MAX_SECTOR_SIZE))
1332                                         {
1333
1334                                                 Status = copy_to_user(IoBuffer.OutputBuffer,
1335                                                                         (unsigned char *)&Adapter->uiSectorSize ,
1336                                                                         (UINT)sizeof(UINT));
1337                                                 if(Status)
1338                                                 {
1339                                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Coping the sector size to use space failed. status:%d",Status);
1340                                                                 return Status;
1341                                                 }
1342                                         }
1343                                         else
1344                                         {
1345                                                 if(IsFlash2x(Adapter))
1346                                                 {
1347                                                         Status = copy_to_user(IoBuffer.OutputBuffer,
1348                                                                         (unsigned char *)&Adapter->uiSectorSize ,
1349                                                                         (UINT)sizeof(UINT));
1350                                                         if(Status)
1351                                                         {
1352                                                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Coping the sector size to use space failed. status:%d",Status);
1353                                                                         return Status;
1354                                                         }
1355
1356                                                 }
1357                                                 else
1358                                                 {
1359                                                         if((TRUE == Adapter->bShutStatus) ||
1360                                                            (TRUE == Adapter->IdleMode))
1361                                                         {
1362                                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is in Idle/Shutdown Mode\n");
1363                                                                 return -EACCES;
1364                                                         }
1365
1366                                                         Adapter->uiSectorSize = uiSectorSize ;
1367                                                         BcmUpdateSectorSize(Adapter,Adapter->uiSectorSize);
1368                                                 }
1369                                         }
1370                                         Status = STATUS_SUCCESS ;
1371                                 }
1372                                 else
1373                                 {
1374                                         Status = STATUS_FAILURE;
1375                                 }
1376                         }
1377                         break;
1378         case IOCTL_BCM_SET_DEBUG :
1379             {
1380                 USER_BCM_DBG_STATE sUserDebugState;
1381
1382 //                              BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Entered the ioctl %x \n", IOCTL_BCM_SET_DEBUG );
1383
1384                                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In SET_DEBUG ioctl\n");
1385                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1386                                 if(Status)
1387                                 {
1388                                         BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy from user failed\n");
1389                                         break;
1390                                 }
1391                                 Status = copy_from_user(&sUserDebugState,(USER_BCM_DBG_STATE *)IoBuffer.InputBuffer, sizeof(USER_BCM_DBG_STATE));
1392                                 if(Status)
1393                                 {
1394                                         BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,  "Copy of IoBuffer.InputBuffer failed");
1395                                         return Status;
1396                                 }
1397
1398                                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "IOCTL_BCM_SET_DEBUG: OnOff=%d Type = 0x%x ",
1399                                 sUserDebugState.OnOff, sUserDebugState.Type);
1400                                 //sUserDebugState.Subtype <<= 1;
1401                                 sUserDebugState.Subtype = 1 << sUserDebugState.Subtype;
1402                                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "actual Subtype=0x%x\n", sUserDebugState.Subtype);
1403
1404                                 // Update new 'DebugState' in the Adapter
1405                                 Adapter->stDebugState.type |= sUserDebugState.Type;
1406                                 /* Subtype: A bitmap of 32 bits for Subtype per Type.
1407                                  * Valid indexes in 'subtype' array: 1,2,4,8
1408                                  * corresponding to valid Type values. Hence we can use the 'Type' field
1409                                  * as the index value, ignoring the array entries 0,3,5,6,7 !
1410                                  */
1411                                 if (sUserDebugState.OnOff)
1412                                         Adapter->stDebugState.subtype[sUserDebugState.Type] |= sUserDebugState.Subtype;
1413                                 else
1414                                         Adapter->stDebugState.subtype[sUserDebugState.Type] &= ~sUserDebugState.Subtype;
1415
1416                 BCM_SHOW_DEBUG_BITMAP(Adapter);
1417
1418                         }
1419                         break;
1420                 case IOCTL_BCM_NVM_READ:
1421                 case IOCTL_BCM_NVM_WRITE:
1422                         {
1423
1424                                 NVM_READWRITE  stNVMReadWrite = {0};
1425                                 PUCHAR pReadData = NULL;
1426                                 PUCHAR pBuffertobeCopied = NULL;
1427                                 ULONG ulDSDMagicNumInUsrBuff = 0 ;
1428                                 struct timeval tv0, tv1;
1429                                 memset(&tv0,0,sizeof(struct timeval));
1430                                 memset(&tv1,0,sizeof(struct timeval));
1431                                 if((Adapter->eNVMType == NVM_FLASH) && (Adapter->uiFlashLayoutMajorVersion == 0))
1432                                 {
1433                                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,"The Flash Control Section is Corrupted. Hence Rejection on NVM Read/Write\n");
1434                                         Status = -EFAULT;
1435                                         break;
1436                                 }
1437
1438                                 if(IsFlash2x(Adapter))
1439                                 {
1440                                         if((Adapter->eActiveDSD != DSD0) &&
1441                                                 (Adapter->eActiveDSD != DSD1) &&
1442                                                 (Adapter->eActiveDSD != DSD2))
1443                                         {
1444                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"No DSD is active..hence NVM Command is blocked");
1445                                                 return STATUS_FAILURE ;
1446                                         }
1447                                 }
1448
1449                         /* Copy Ioctl Buffer structure */
1450
1451                                 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1452                                 {
1453                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copy_from_user failed\n");
1454                     Status = -EFAULT;
1455                                         break;
1456                                 }
1457                                 if(IOCTL_BCM_NVM_READ == cmd)
1458                                         pBuffertobeCopied = IoBuffer.OutputBuffer;
1459                                 else
1460                                         pBuffertobeCopied = IoBuffer.InputBuffer;
1461
1462                                 if(copy_from_user(&stNVMReadWrite, pBuffertobeCopied,sizeof(NVM_READWRITE)))
1463                                 {
1464                                         Status = -EFAULT;
1465                                         break;
1466                                 }
1467
1468                                 //
1469                                 // Deny the access if the offset crosses the cal area limit.
1470                                 //
1471                                 if((stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) > Adapter->uiNVMDSDSize)
1472                                 {
1473                                 //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Can't allow access beyond NVM Size: 0x%x 0x%x\n", stNVMReadWrite.uiOffset ,
1474 //                                                      stNVMReadWrite.uiNumBytes);
1475                                         Status = STATUS_FAILURE;
1476                                         break;
1477                                 }
1478
1479                                 pReadData =(PCHAR)kmalloc(stNVMReadWrite.uiNumBytes, GFP_KERNEL);
1480
1481                                 if(!pReadData)
1482                                         return -ENOMEM;
1483
1484                                 memset(pReadData,0,stNVMReadWrite.uiNumBytes);
1485
1486                                 if(copy_from_user(pReadData, stNVMReadWrite.pBuffer,
1487                                                         stNVMReadWrite.uiNumBytes))
1488                                 {
1489                                         Status = -EFAULT;
1490                                         bcm_kfree(pReadData);
1491                                         break;
1492                                 }
1493
1494                                 do_gettimeofday(&tv0);
1495                                 if(IOCTL_BCM_NVM_READ == cmd)
1496                                 {
1497                                         down(&Adapter->NVMRdmWrmLock);
1498
1499                                         if((Adapter->IdleMode == TRUE) ||
1500                                                 (Adapter->bShutStatus ==TRUE) ||
1501                                                 (Adapter->bPreparingForLowPowerMode ==TRUE))
1502                                         {
1503                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1504                                                 up(&Adapter->NVMRdmWrmLock);
1505                                                 bcm_kfree(pReadData);
1506                                                 return -EACCES;
1507                                         }
1508
1509                                         Status = BeceemNVMRead(Adapter, (PUINT)pReadData,
1510                                                 stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes);
1511
1512                                         up(&Adapter->NVMRdmWrmLock);
1513
1514                                         if(Status != STATUS_SUCCESS)
1515                                                 {
1516                                                         bcm_kfree(pReadData);
1517                                                         return Status;
1518                                                 }
1519                                         if(copy_to_user((PCHAR)stNVMReadWrite.pBuffer,
1520                                                         (PCHAR)pReadData, (UINT)stNVMReadWrite.uiNumBytes))
1521                                                 {
1522                                                         bcm_kfree(pReadData);
1523                                                         Status = -EFAULT;
1524                                                 }
1525                                 }
1526                                 else
1527                                 {
1528
1529                                         down(&Adapter->NVMRdmWrmLock);
1530
1531                                         if((Adapter->IdleMode == TRUE) ||
1532                                                 (Adapter->bShutStatus ==TRUE) ||
1533                                                 (Adapter->bPreparingForLowPowerMode ==TRUE))
1534                                         {
1535                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1536                                                 up(&Adapter->NVMRdmWrmLock);
1537                                                 bcm_kfree(pReadData);
1538                                                 return -EACCES;
1539                                         }
1540
1541                                         Adapter->bHeaderChangeAllowed = TRUE ;
1542                                         if(IsFlash2x(Adapter))
1543                                         {
1544                                                 /*
1545                                                         New Requirement:-
1546                                                         DSD section updation will be allowed in two case:-
1547                                                         1.  if DSD sig is present in DSD header means dongle is ok and updation is fruitfull
1548                                                         2.  if point 1 failes then user buff should have DSD sig. this point ensures that if dongle is
1549                                                               corrupted then user space program first modify the DSD header with valid DSD sig so
1550                                                               that this as well as further write may be worthwhile.
1551
1552                                                          This restriction has been put assuming that if DSD sig is corrupted, DSD
1553                                                          data won't be considered valid.
1554
1555
1556                                                 */
1557                                                 Status = BcmFlash2xCorruptSig(Adapter,Adapter->eActiveDSD);
1558                                                 if(Status != STATUS_SUCCESS)
1559                                                 {
1560                                                         if(( (stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) != Adapter->uiNVMDSDSize ) ||
1561                                                                 (stNVMReadWrite.uiNumBytes < SIGNATURE_SIZE))
1562                                                         {
1563                                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
1564                                                                 up(&Adapter->NVMRdmWrmLock);
1565                                                                 bcm_kfree(pReadData);
1566                                                                 return Status;
1567                                                         }
1568
1569                                                         ulDSDMagicNumInUsrBuff = ntohl(*(PUINT)(pReadData + stNVMReadWrite.uiNumBytes - SIGNATURE_SIZE));
1570                                                         if(ulDSDMagicNumInUsrBuff != DSD_IMAGE_MAGIC_NUMBER)
1571                                                         {
1572                                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
1573                                                                 up(&Adapter->NVMRdmWrmLock);
1574                                                                 bcm_kfree(pReadData);
1575                                                                 return Status;
1576                                                         }
1577                                                 }
1578                                         }
1579                                         Status = BeceemNVMWrite(Adapter, (PUINT )pReadData,
1580                                                                         stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes, stNVMReadWrite.bVerify);
1581                                         if(IsFlash2x(Adapter))
1582                                                 BcmFlash2xWriteSig(Adapter,Adapter->eActiveDSD);
1583
1584                                         Adapter->bHeaderChangeAllowed = FALSE ;
1585
1586                                         up(&Adapter->NVMRdmWrmLock);
1587
1588
1589                                         if(Status != STATUS_SUCCESS)
1590                                         {
1591                                                 bcm_kfree(pReadData);
1592                                                 return Status;
1593                                         }
1594                                 }
1595                                 do_gettimeofday(&tv1);
1596                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " timetaken by Write/read :%ld msec\n",(tv1.tv_sec - tv0.tv_sec)*1000 +(tv1.tv_usec - tv0.tv_usec)/1000);
1597
1598
1599                                 bcm_kfree(pReadData);
1600                                 Status = STATUS_SUCCESS;
1601                         }
1602                         break;
1603                 case IOCTL_BCM_FLASH2X_SECTION_READ :
1604                          {
1605
1606                                 FLASH2X_READWRITE sFlash2xRead = {0};
1607                                 PUCHAR pReadBuff = NULL ;
1608                                 UINT NOB = 0;
1609                                 UINT BuffSize = 0;
1610                                 UINT ReadBytes = 0;
1611                                 UINT ReadOffset = 0;
1612                                 PUCHAR OutPutBuff = NULL;
1613
1614                                 if(IsFlash2x(Adapter) != TRUE)
1615                                 {
1616                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1617                                         return -EINVAL;
1618                                 }
1619
1620                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_FLASH2X_SECTION_READ Called");
1621                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1622                                 if(Status)
1623                                 {
1624                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1625                                         return Status ;
1626                                 }
1627
1628                                 //Reading FLASH 2.x READ structure
1629                                 Status = copy_from_user((PUCHAR)&sFlash2xRead, (PUCHAR)IoBuffer.InputBuffer,sizeof(FLASH2X_READWRITE));
1630                                 if(Status)
1631                                 {
1632                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Input Buffer failed");
1633                                         return Status ;
1634                                 }
1635
1636
1637                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xRead.Section);
1638                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%x" ,sFlash2xRead.offset);
1639                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xRead.numOfBytes);
1640                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xRead.bVerify);
1641
1642                                 //This was internal to driver for raw read. now it has ben exposed to user space app.
1643                                 if(validateFlash2xReadWrite(Adapter,&sFlash2xRead) == FALSE)
1644                                         return STATUS_FAILURE ;
1645
1646                                 NOB = sFlash2xRead.numOfBytes;
1647                                 if(NOB > Adapter->uiSectorSize )
1648                                         BuffSize = Adapter->uiSectorSize;
1649                                 else
1650                                         BuffSize = NOB ;
1651
1652                                 ReadOffset = sFlash2xRead.offset ;
1653                                 OutPutBuff = (PUCHAR)(IoBuffer.OutputBuffer) ;
1654
1655
1656                                 pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
1657                                 if(pReadBuff == NULL)
1658                                 {
1659                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
1660                                         return -ENOMEM;
1661                                 }
1662                                 down(&Adapter->NVMRdmWrmLock);
1663
1664                                 if((Adapter->IdleMode == TRUE) ||
1665                                         (Adapter->bShutStatus ==TRUE) ||
1666                                         (Adapter->bPreparingForLowPowerMode ==TRUE))
1667                                 {
1668                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1669                                         up(&Adapter->NVMRdmWrmLock);
1670                                         bcm_kfree(pReadBuff);
1671                                         return -EACCES;
1672                                 }
1673
1674                                 while(NOB)
1675                                 {
1676
1677                                         if(NOB > Adapter->uiSectorSize )
1678                                                 ReadBytes = Adapter->uiSectorSize;
1679                                         else
1680                                                 ReadBytes = NOB;
1681
1682
1683                                         //Reading the data from Flash 2.x
1684
1685                                         Status = BcmFlash2xBulkRead(Adapter,(PUINT)pReadBuff,sFlash2xRead.Section,ReadOffset,ReadBytes);
1686                                         if(Status)
1687                                         {
1688                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Flash 2x read err with Status :%d", Status);
1689                                                 break ;
1690                                         }
1691
1692                                         BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes);
1693
1694                                         Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes);
1695                                         if(Status)
1696                                         {
1697                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Copy to use failed with status :%d", Status);
1698                                                 break;
1699                                         }
1700                                         NOB = NOB - ReadBytes;
1701                                         if(NOB)
1702                                         {
1703                                                 ReadOffset = ReadOffset + ReadBytes ;
1704                                                 OutPutBuff = OutPutBuff + ReadBytes ;
1705                                         }
1706
1707                                 }
1708                                 up(&Adapter->NVMRdmWrmLock);
1709                                 bcm_kfree(pReadBuff);
1710
1711                          }
1712                          break ;
1713                 case IOCTL_BCM_FLASH2X_SECTION_WRITE :
1714                          {
1715                                 FLASH2X_READWRITE sFlash2xWrite = {0};
1716                                 PUCHAR pWriteBuff = NULL;
1717                                 PUCHAR InputAddr = NULL;
1718                                 UINT NOB = 0;
1719                                 UINT BuffSize = 0;
1720                                 UINT WriteOffset = 0;
1721                                 UINT WriteBytes = 0;
1722
1723                                 if(IsFlash2x(Adapter) != TRUE)
1724                                 {
1725                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1726                                         return -EINVAL;
1727                                 }
1728
1729                                 //First make this False so that we can enable the Sector Permission Check in BeceemFlashBulkWrite
1730                                 Adapter->bAllDSDWriteAllow = FALSE;
1731
1732
1733                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_FLASH2X_SECTION_WRITE Called");
1734                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1735                                 if(Status)
1736                                 {
1737                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1738                                         return Status;
1739                                 }
1740
1741                                 //Reading FLASH 2.x READ structure
1742                                 Status = copy_from_user((PCHAR)&sFlash2xWrite, (PCHAR)IoBuffer.InputBuffer, sizeof(FLASH2X_READWRITE));
1743                                 if(Status)
1744                                 {
1745                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Reading of output Buffer from IOCTL buffer fails");
1746                                         return Status;
1747                                 }
1748
1749                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xWrite.Section);
1750                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%d" ,sFlash2xWrite.offset);
1751                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xWrite.numOfBytes);
1752                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xWrite.bVerify);
1753                                 #if 0
1754                                 if((sFlash2xWrite.Section == ISO_IMAGE1) ||(sFlash2xWrite.Section == ISO_IMAGE2) ||
1755                                         (sFlash2xWrite.Section == DSD0) || (sFlash2xWrite.Section == DSD1) || (sFlash2xWrite.Section == DSD2))
1756                                 {
1757                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"ISO/DSD Image write is not allowed....  ");
1758                                         return STATUS_FAILURE ;
1759                                 }
1760                                 #endif
1761                                 if((sFlash2xWrite.Section != VSA0) && (sFlash2xWrite.Section != VSA1) &&
1762                                         (sFlash2xWrite.Section != VSA2) )
1763                                 {
1764                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Only VSA write is allowed");
1765                                         return -EINVAL;
1766                                 }
1767
1768                                 if(validateFlash2xReadWrite(Adapter,&sFlash2xWrite) == FALSE)
1769                                         return STATUS_FAILURE ;
1770
1771                                 InputAddr = (PCHAR)(sFlash2xWrite.pDataBuff) ;
1772                                 WriteOffset = sFlash2xWrite.offset ;
1773                                 NOB = sFlash2xWrite.numOfBytes;
1774
1775                                 if(NOB > Adapter->uiSectorSize )
1776                                         BuffSize = Adapter->uiSectorSize;
1777                                 else
1778                                         BuffSize = NOB ;
1779
1780                                 pWriteBuff = (PCHAR)kmalloc(BuffSize, GFP_KERNEL);
1781                                 if(pWriteBuff == NULL)
1782                                 {
1783                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
1784                                         return -ENOMEM;
1785                                 }
1786
1787                                 //extracting the remainder of the given offset.
1788                                 WriteBytes = Adapter->uiSectorSize ;
1789                                 if(WriteOffset % Adapter->uiSectorSize)
1790                                         WriteBytes =Adapter->uiSectorSize - (WriteOffset % Adapter->uiSectorSize);
1791                                 if(NOB < WriteBytes)
1792                                         WriteBytes = NOB;
1793
1794                                 down(&Adapter->NVMRdmWrmLock);
1795
1796                                 if((Adapter->IdleMode == TRUE) ||
1797                                         (Adapter->bShutStatus ==TRUE) ||
1798                                         (Adapter->bPreparingForLowPowerMode ==TRUE))
1799                                 {
1800                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1801                                         up(&Adapter->NVMRdmWrmLock);
1802                                         bcm_kfree(pWriteBuff);
1803                                         return -EACCES;
1804                                 }
1805
1806                                 BcmFlash2xCorruptSig(Adapter,sFlash2xWrite.Section);
1807                                 do
1808                                 {
1809                                         Status = copy_from_user(pWriteBuff,InputAddr,WriteBytes);
1810                                         if(Status)
1811                                         {
1812                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to user failed with status :%d", Status);
1813                                                 break ;
1814                                         }
1815                                         BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pWriteBuff,WriteBytes);
1816                                         //Writing the data from Flash 2.x
1817                                         Status = BcmFlash2xBulkWrite(Adapter,(PUINT)pWriteBuff,sFlash2xWrite.Section,WriteOffset,WriteBytes,sFlash2xWrite.bVerify);
1818
1819                                         if(Status)
1820                                         {
1821                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
1822                                                 break ;
1823                                         }
1824
1825                                         NOB = NOB - WriteBytes;
1826                                         if(NOB)
1827                                         {
1828                                                 WriteOffset = WriteOffset + WriteBytes ;
1829                                                 InputAddr = InputAddr + WriteBytes ;
1830                                                 if(NOB > Adapter->uiSectorSize )
1831                                                         WriteBytes = Adapter->uiSectorSize;
1832                                                 else
1833                                                         WriteBytes = NOB;
1834                                         }
1835
1836
1837                                 }       while(NOB > 0);
1838                                 BcmFlash2xWriteSig(Adapter,sFlash2xWrite.Section);
1839                                 up(&Adapter->NVMRdmWrmLock);
1840                                 bcm_kfree(pWriteBuff);
1841                          }
1842                          break ;
1843                 case IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP :
1844                          {
1845
1846                                 PFLASH2X_BITMAP psFlash2xBitMap = NULL ;
1847                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP Called");
1848
1849                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1850                                 if(Status)
1851                                 {
1852                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1853                                         return Status;
1854                                 }
1855                                 if(IoBuffer.OutputLength != sizeof(FLASH2X_BITMAP))
1856                                 {
1857                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Structure size mismatch Lib :0x%lx Driver :0x%zx ",IoBuffer.OutputLength, sizeof(FLASH2X_BITMAP));
1858                                         break;
1859                                 }
1860
1861                                 psFlash2xBitMap = (PFLASH2X_BITMAP)kzalloc(sizeof(FLASH2X_BITMAP), GFP_KERNEL);
1862                                 if(psFlash2xBitMap == NULL)
1863                                 {
1864                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory is not available");
1865                                         return -ENOMEM ;
1866                                 }
1867                                 //Reading the Flash Sectio Bit map
1868                                 down(&Adapter->NVMRdmWrmLock);
1869
1870                                 if((Adapter->IdleMode == TRUE) ||
1871                                         (Adapter->bShutStatus ==TRUE) ||
1872                                         (Adapter->bPreparingForLowPowerMode ==TRUE))
1873                                 {
1874                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1875                                         up(&Adapter->NVMRdmWrmLock);
1876                                         bcm_kfree(psFlash2xBitMap);
1877                                         return -EACCES;
1878                                 }
1879
1880                                 BcmGetFlash2xSectionalBitMap(Adapter, psFlash2xBitMap);
1881                                 up(&Adapter->NVMRdmWrmLock);
1882                                 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)psFlash2xBitMap, sizeof(FLASH2X_BITMAP));
1883                                 if(Status)
1884                                 {
1885                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash2x bitMap failed");
1886                                         bcm_kfree(psFlash2xBitMap);
1887                                         return Status;
1888                                 }
1889                                 bcm_kfree(psFlash2xBitMap);
1890                          }
1891                          break ;
1892                 case IOCTL_BCM_SET_ACTIVE_SECTION :
1893                          {
1894                                 FLASH2X_SECTION_VAL eFlash2xSectionVal = 0;
1895                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SET_ACTIVE_SECTION Called");
1896
1897                                 if(IsFlash2x(Adapter) != TRUE)
1898                                 {
1899                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1900                                         return -EINVAL;
1901                                 }
1902
1903                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1904                                 if(Status)
1905                                 {
1906                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1907                                         return Status;
1908                                 }
1909
1910                                 Status = copy_from_user((PCHAR)&eFlash2xSectionVal,(PCHAR)IoBuffer.InputBuffer, sizeof(INT));
1911                                 if(Status)
1912                                 {
1913                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
1914                                         return Status;
1915                                 }
1916
1917                                 down(&Adapter->NVMRdmWrmLock);
1918
1919                                 if((Adapter->IdleMode == TRUE) ||
1920                                         (Adapter->bShutStatus ==TRUE) ||
1921                                         (Adapter->bPreparingForLowPowerMode ==TRUE))
1922                                 {
1923                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1924                                         up(&Adapter->NVMRdmWrmLock);
1925                                         return -EACCES;
1926                                 }
1927
1928                                 Status = BcmSetActiveSection(Adapter,eFlash2xSectionVal);
1929                                 if(Status)
1930                                 {
1931                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed to make it's priority Highest. Status %d", Status);
1932                                 }
1933                                 up(&Adapter->NVMRdmWrmLock);
1934                         }
1935                         break ;
1936                 case IOCTL_BCM_IDENTIFY_ACTIVE_SECTION :
1937                          {
1938                                 //Right Now we are taking care of only DSD
1939                                 Adapter->bAllDSDWriteAllow = FALSE ;
1940                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_IDENTIFY_ACTIVE_SECTION called");
1941
1942                                 #if 0
1943                                 SECTION_TYPE section = 0 ;
1944
1945
1946                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_IDENTIFY_ACTIVE_SECTION Called");
1947                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1948                                 if(Status)
1949                                 {
1950                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy of IOCTL BUFFER failed");
1951                                         return Status;
1952                                 }
1953                                 Status = copy_from_user((PCHAR)section,(PCHAR)&IoBuffer, sizeof(INT));
1954                                 if(Status)
1955                                 {
1956                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy of section type failed failed");
1957                                         return Status;
1958                                 }
1959                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", section);
1960                                 if(section == DSD)
1961                                         Adapter->ulFlashCalStart = Adapter->uiActiveDSDOffsetAtFwDld ;
1962                                 else
1963                                         Status = STATUS_FAILURE ;
1964                                 #endif
1965                                 Status = STATUS_SUCCESS ;
1966                          }
1967                          break ;
1968                 case IOCTL_BCM_COPY_SECTION :
1969                          {
1970                                 FLASH2X_COPY_SECTION sCopySectStrut = {0};
1971                                 Status = STATUS_SUCCESS;
1972                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_COPY_SECTION  Called");
1973
1974                                 Adapter->bAllDSDWriteAllow = FALSE ;
1975                                 if(IsFlash2x(Adapter) != TRUE)
1976                                 {
1977                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1978                                         return -EINVAL;
1979                                 }
1980
1981                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1982                                 if(Status)
1983                                 {
1984                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed Status :%d", Status);
1985                                         return Status;
1986                                 }
1987
1988                                 Status = copy_from_user((PCHAR)&sCopySectStrut,(PCHAR)IoBuffer.InputBuffer, sizeof(FLASH2X_COPY_SECTION));
1989                                 if(Status)
1990                                 {
1991                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Copy_Section_Struct failed with Status :%d", Status);
1992                                         return Status;
1993                                 }
1994                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Source SEction :%x", sCopySectStrut.SrcSection);
1995                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Destination SEction :%x", sCopySectStrut.DstSection);
1996                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "offset :%x", sCopySectStrut.offset);
1997                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "NOB :%x", sCopySectStrut.numOfBytes);
1998
1999
2000                                 if(IsSectionExistInFlash(Adapter,sCopySectStrut.SrcSection) == FALSE)
2001                                 {
2002                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Source Section<%x> does not exixt in Flash ", sCopySectStrut.SrcSection);
2003                                         return -EINVAL;
2004                                 }
2005
2006                                 if(IsSectionExistInFlash(Adapter,sCopySectStrut.DstSection) == FALSE)
2007                                 {
2008                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Destinatio Section<%x> does not exixt in Flash ", sCopySectStrut.DstSection);
2009                                         return -EINVAL;
2010                                 }
2011
2012                                 if(sCopySectStrut.SrcSection == sCopySectStrut.DstSection)
2013                                 {
2014                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Source and Destination section should be different");
2015                                         return -EINVAL;
2016                                 }
2017
2018                                 down(&Adapter->NVMRdmWrmLock);
2019
2020                                 if((Adapter->IdleMode == TRUE) ||
2021                                         (Adapter->bShutStatus ==TRUE) ||
2022                                         (Adapter->bPreparingForLowPowerMode ==TRUE))
2023                                 {
2024                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2025                                         up(&Adapter->NVMRdmWrmLock);
2026                                         return -EACCES;
2027                                 }
2028
2029                                 if(sCopySectStrut.SrcSection == ISO_IMAGE1 || sCopySectStrut.SrcSection == ISO_IMAGE2)
2030                                 {
2031                                         if(IsNonCDLessDevice(Adapter))
2032                                         {
2033                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is Non-CDLess hence won't have ISO !!");
2034                                                 Status = -EINVAL ;
2035                                         }
2036                                         else if(sCopySectStrut.numOfBytes == 0)
2037                                         {
2038                                                 Status = BcmCopyISO(Adapter,sCopySectStrut);
2039                                         }
2040                                         else
2041                                         {
2042                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Partial Copy of ISO section is not Allowed..");
2043                                                 Status = STATUS_FAILURE ;
2044                                         }
2045                                         up(&Adapter->NVMRdmWrmLock);
2046                                         return Status;
2047                                 }
2048
2049                                 Status = BcmCopySection(Adapter, sCopySectStrut.SrcSection,
2050                                                         sCopySectStrut.DstSection,sCopySectStrut.offset,sCopySectStrut.numOfBytes);
2051                                 up(&Adapter->NVMRdmWrmLock);
2052                          }
2053                          break ;
2054                 case IOCTL_BCM_GET_FLASH_CS_INFO :
2055                          {
2056                                 Status = STATUS_SUCCESS;
2057                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_GET_FLASH_CS_INFO Called");
2058
2059                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2060                                 if(Status)
2061                                 {
2062                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2063                                         break;
2064                                 }
2065                                 if(Adapter->eNVMType != NVM_FLASH)
2066                                 {
2067                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Connected device does not have flash");
2068                                         Status = -EINVAL;
2069                                         break;
2070                                 }
2071                                 if(IsFlash2x(Adapter) == TRUE)
2072                                 {
2073
2074                                         if(IoBuffer.OutputLength < sizeof(FLASH2X_CS_INFO))
2075                                         {
2076                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0," Passed buffer size:0x%lX is insufficient for the CS structure.. \nRequired size :0x%zx ",IoBuffer.OutputLength, sizeof(FLASH2X_CS_INFO));
2077                                                 Status = -EINVAL;
2078                                                 break;
2079                                         }
2080
2081                                         Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)Adapter->psFlash2xCSInfo, sizeof(FLASH2X_CS_INFO));
2082                                         if(Status)
2083                                         {
2084                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash2x cs info failed");
2085                                                 break;
2086                                         }
2087                                 }
2088                                 else
2089                                 {
2090                                         if(IoBuffer.OutputLength < sizeof(FLASH_CS_INFO))
2091                                         {
2092                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0," Passed buffer size:0x%lX is insufficient for the CS structure.. Required size :0x%zx ",IoBuffer.OutputLength, sizeof(FLASH_CS_INFO));
2093                                                 Status = -EINVAL;
2094                                                 break;
2095                                         }
2096                                         Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)Adapter->psFlashCSInfo, sizeof(FLASH_CS_INFO));
2097                                         if(Status)
2098                                         {
2099                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash CS info failed");
2100                                                 break;
2101                                         }
2102
2103                                  }
2104                           }
2105                           break ;
2106                 case IOCTL_BCM_SELECT_DSD :
2107                          {
2108                                 UINT SectOfset = 0;
2109                                 FLASH2X_SECTION_VAL eFlash2xSectionVal;
2110                                 eFlash2xSectionVal = NO_SECTION_VAL ;
2111                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_SELECT_DSD Called");
2112
2113                                 if(IsFlash2x(Adapter) != TRUE)
2114                                 {
2115                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
2116                                         return -EINVAL;
2117                                 }
2118
2119                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2120                                 if(Status)
2121                                 {
2122                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2123                                         return Status;
2124                                 }
2125                                 Status = copy_from_user((PCHAR)&eFlash2xSectionVal,(PCHAR)IoBuffer.InputBuffer, sizeof(INT));
2126                                 if(Status)
2127                                 {
2128                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
2129                                         return Status;
2130                                 }
2131
2132                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", eFlash2xSectionVal);
2133                                 if((eFlash2xSectionVal != DSD0) &&
2134                                         (eFlash2xSectionVal != DSD1) &&
2135                                         (eFlash2xSectionVal != DSD2) )
2136                                 {
2137                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Passed section<%x> is not DSD section", eFlash2xSectionVal);
2138                                         return STATUS_FAILURE ;
2139                                 }
2140
2141                                 SectOfset= BcmGetSectionValStartOffset(Adapter,eFlash2xSectionVal);
2142                                 if(SectOfset == INVALID_OFFSET)
2143                                 {
2144                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Provided Section val <%d> does not exixt in Flash 2.x", eFlash2xSectionVal);
2145                                         return -EINVAL;
2146                                 }
2147
2148                                 Adapter->bAllDSDWriteAllow = TRUE ;
2149
2150                                 Adapter->ulFlashCalStart = SectOfset ;
2151                                 Adapter->eActiveDSD = eFlash2xSectionVal;
2152                          }
2153                          Status = STATUS_SUCCESS ;
2154                          break;
2155
2156                 case IOCTL_BCM_NVM_RAW_READ :
2157                          {
2158
2159                                 NVM_READWRITE  stNVMRead = {0};
2160                                 INT NOB ;
2161                                 INT BuffSize ;
2162                                 INT ReadOffset = 0;
2163                                 UINT ReadBytes = 0 ;
2164                                 PUCHAR pReadBuff = NULL ;
2165                                 PUCHAR OutPutBuff = NULL ;
2166
2167                                 if(Adapter->eNVMType != NVM_FLASH)
2168                                 {
2169                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"NVM TYPE is not Flash ");
2170                                         return -EINVAL ;
2171                                 }
2172
2173                                 /* Copy Ioctl Buffer structure */
2174                                 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
2175                                 {
2176                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
2177                                         Status = -EFAULT;
2178                                         break;
2179                                 }
2180
2181                                 if(copy_from_user(&stNVMRead, (PUCHAR)IoBuffer.OutputBuffer,sizeof(NVM_READWRITE)))
2182                                 {
2183                                         Status = -EFAULT;
2184                                         break;
2185                                 }
2186
2187                                 NOB = stNVMRead.uiNumBytes;
2188                                 //In Raw-Read max Buff size : 64MB
2189
2190                                 if(NOB > DEFAULT_BUFF_SIZE)
2191                                         BuffSize = DEFAULT_BUFF_SIZE;
2192                                 else
2193                                         BuffSize = NOB ;
2194
2195                                 ReadOffset = stNVMRead.uiOffset ;
2196                                 OutPutBuff = (PUCHAR)(stNVMRead.pBuffer) ;
2197
2198
2199                                 pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
2200                                 if(pReadBuff == NULL)
2201                                 {
2202                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
2203                                         Status = -ENOMEM;
2204                                         break;
2205                                 }
2206                                 down(&Adapter->NVMRdmWrmLock);
2207
2208                                 if((Adapter->IdleMode == TRUE) ||
2209                                         (Adapter->bShutStatus ==TRUE) ||
2210                                         (Adapter->bPreparingForLowPowerMode ==TRUE))
2211                                 {
2212                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2213                                         bcm_kfree(pReadBuff);
2214                                         up(&Adapter->NVMRdmWrmLock);
2215                                         return -EACCES;
2216                                 }
2217
2218                                 Adapter->bFlashRawRead = TRUE ;
2219                                 while(NOB)
2220                                 {
2221                                         if(NOB > DEFAULT_BUFF_SIZE )
2222                                                 ReadBytes = DEFAULT_BUFF_SIZE;
2223                                         else
2224                                                 ReadBytes = NOB;
2225
2226                                         //Reading the data from Flash 2.x
2227                                         Status = BeceemNVMRead(Adapter,(PUINT)pReadBuff,ReadOffset,ReadBytes);
2228                                         if(Status)
2229                                         {
2230                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
2231                                                 break;
2232                                         }
2233
2234                                         BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes);
2235
2236                                         Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes);
2237                                         if(Status)
2238                                         {
2239                                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to use failed with status :%d", Status);
2240                                                 break;
2241                                         }
2242                                         NOB = NOB - ReadBytes;
2243                                         if(NOB)
2244                                         {
2245                                                 ReadOffset = ReadOffset + ReadBytes ;
2246                                                 OutPutBuff = OutPutBuff + ReadBytes ;
2247                                         }
2248
2249                                 }
2250                                 Adapter->bFlashRawRead = FALSE ;
2251                                 up(&Adapter->NVMRdmWrmLock);
2252                                 bcm_kfree(pReadBuff);
2253                                 break ;
2254                          }
2255
2256                 case IOCTL_BCM_CNTRLMSG_MASK:
2257                          {
2258                                 ULONG RxCntrlMsgBitMask = 0 ;
2259
2260                                 /* Copy Ioctl Buffer structure */
2261                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2262                                 if(Status)
2263                                 {
2264                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of Ioctl buffer is failed from user space");
2265                                         break;
2266                                 }
2267
2268                                 Status = copy_from_user(&RxCntrlMsgBitMask, IoBuffer.InputBuffer, IoBuffer.InputLength);
2269                                 if(Status)
2270                                 {
2271                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of control bit mask failed from user space");
2272                                         break;
2273                                 }
2274                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\n Got user defined cntrl msg bit mask :%lx", RxCntrlMsgBitMask);
2275                                 pTarang->RxCntrlMsgBitMask = RxCntrlMsgBitMask ;
2276                          }
2277                          break;
2278                         case IOCTL_BCM_GET_DEVICE_DRIVER_INFO:
2279                         {
2280                                 DEVICE_DRIVER_INFO DevInfo;
2281
2282                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Called IOCTL_BCM_GET_DEVICE_DRIVER_INFO\n");
2283
2284                                 DevInfo.MaxRDMBufferSize = BUFFER_4K;
2285                                 DevInfo.u32DSDStartOffset = EEPROM_CALPARAM_START;
2286                                 DevInfo.u32RxAlignmentCorrection = 0;
2287                                 DevInfo.u32NVMType = Adapter->eNVMType;
2288                                 DevInfo.u32InterfaceType = BCM_USB;
2289
2290                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2291                                 if(Status)
2292                                 {
2293                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2294                                         break;
2295                                 }
2296                                 if(IoBuffer.OutputLength < sizeof(DevInfo))
2297                                 {
2298                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"User Passed buffer length is less than actural buffer size");
2299                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"user passed buffer size :0x%lX, expected size :0x%zx",IoBuffer.OutputLength, sizeof(DevInfo));
2300                                         Status = -EINVAL;
2301                                         break;
2302                                 }
2303                                 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)&DevInfo, sizeof(DevInfo));
2304                                 if(Status)
2305                                 {
2306                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copying Dev info structure to user space buffer failed");
2307                                         break;
2308                                 }
2309                         }
2310                         break ;
2311
2312                         case IOCTL_BCM_TIME_SINCE_NET_ENTRY:
2313                         {
2314                                 ST_TIME_ELAPSED stTimeElapsedSinceNetEntry = {0};
2315                                 struct timeval tv = {0} ;
2316
2317                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_TIME_SINCE_NET_ENTRY called");
2318
2319                                 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2320                                 if(Status)
2321                                 {
2322                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2323                                         break;
2324                                 }
2325                                 if(IoBuffer.OutputLength < sizeof(ST_TIME_ELAPSED))
2326                                 {
2327                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"User Passed buffer length:0x%lx is less than expected buff size :0x%zX",IoBuffer.OutputLength,sizeof(ST_TIME_ELAPSED));
2328                                         Status = -EINVAL;
2329                                         break;
2330                                 }
2331
2332                                 //stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = Adapter->liTimeSinceLastNetEntry;
2333                                 do_gettimeofday(&tv);
2334                                 stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = tv.tv_sec - Adapter->liTimeSinceLastNetEntry;
2335
2336                                 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)&stTimeElapsedSinceNetEntry, sizeof(ST_TIME_ELAPSED));
2337                                 if(Status)
2338                                 {
2339                                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copying ST_TIME_ELAPSED structure to user space buffer failed");
2340                                         break;
2341                                 }
2342
2343                         }
2344                         break;
2345
2346                 default:
2347             BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "wrong input %x",cmd);
2348                         BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In default ioctl %d\n", cmd);
2349                          Status = STATUS_FAILURE;
2350
2351                         break;
2352         }
2353         return Status;
2354 }
2355
2356
2357 static struct file_operations bcm_fops = {
2358     .owner    = THIS_MODULE,
2359     .open     = bcm_char_open,
2360     .release  = bcm_char_release,
2361     .read     = bcm_char_read,
2362     .unlocked_ioctl    = bcm_char_ioctl,
2363 };
2364
2365
2366 int register_control_device_interface(PMINI_ADAPTER Adapter)
2367 {
2368         if(Adapter->major>0)
2369         return Adapter->major;
2370     Adapter->major = register_chrdev(0, "tarang", &bcm_fops);
2371     if(Adapter->major < 0)
2372     {
2373         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "register_chrdev:Failed to registering WiMax control char device!");
2374         return Adapter->major;
2375     }
2376
2377         bcm_class = NULL;
2378         bcm_class = class_create (THIS_MODULE, "tarang");
2379         if(IS_ERR (bcm_class))
2380         {
2381         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unable to create class\n");
2382         unregister_chrdev(Adapter->major, "tarang");
2383                 Adapter->major = 0;
2384                 return -ENODEV;
2385         }
2386         Adapter->pstCreatedClassDevice = device_create (bcm_class, NULL,
2387                                                                 MKDEV(Adapter->major, 0),
2388 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
2389                                                                 NULL    ,
2390 #endif
2391                                                                 "tarang");
2392
2393         if(IS_ERR(Adapter->pstCreatedClassDevice))
2394         {
2395                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "class device did not get created : %ld", PTR_ERR(Adapter->pstCreatedClassDevice) );
2396         }
2397         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Got Major No: %d", Adapter->major);
2398     return 0;
2399 }
2400
2401 void unregister_control_device_interface(PMINI_ADAPTER Adapter)
2402 {
2403         if(Adapter->major > 0)
2404         {
2405         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "destroying class device");
2406                 device_destroy (bcm_class, MKDEV(Adapter->major, 0));
2407         }
2408     if(!IS_ERR(bcm_class))
2409         {
2410         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "destroying created class ");
2411         class_destroy (bcm_class);
2412                 bcm_class = NULL;
2413         }
2414         if(Adapter->major > 0)
2415         {
2416                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"unregistering character interface");
2417         unregister_chrdev(Adapter->major, "tarang");
2418         }
2419
2420 }