drivers/staging/bcm/Bcmchar.c

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