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