drivers/staging/bcm/InterfaceInit.c

   1 #include "headers.h"
   2
   3 static struct usb_device_id InterfaceUsbtable[] = {
   4     { USB_DEVICE(BCM_USB_VENDOR_ID_T3, BCM_USB_PRODUCT_ID_T3) },
   5     { USB_DEVICE(BCM_USB_VENDOR_ID_T3, BCM_USB_PRODUCT_ID_T3B) },
   6     { USB_DEVICE(BCM_USB_VENDOR_ID_T3, BCM_USB_PRODUCT_ID_T3L) },
   7     { USB_DEVICE(BCM_USB_VENDOR_ID_T3, BCM_USB_PRODUCT_ID_SM250) },
   8     { USB_DEVICE(BCM_USB_VENDOR_ID_ZTE, BCM_USB_PRODUCT_ID_226) },
   9     { USB_DEVICE(BCM_USB_VENDOR_ID_FOXCONN, BCM_USB_PRODUCT_ID_1901) },
  10     { USB_DEVICE(BCM_USB_VENDOR_ID_ZTE, BCM_USB_PRODUCT_ID_ZTE_TU25) },
  11     { }
  12 };
  13 MODULE_DEVICE_TABLE(usb, InterfaceUsbtable);
  14
  15 static int debug = -1;
  16 module_param(debug, uint, 0600);
  17 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
  18
  19 static const u32 default_msg =
  20     NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
  21     | NETIF_MSG_TIMER | NETIF_MSG_TX_ERR | NETIF_MSG_RX_ERR
  22     | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
  23
  24 static INT InterfaceAdapterInit(PS_INTERFACE_ADAPTER Adapter);
  25
  26 static VOID InterfaceAdapterFree(PS_INTERFACE_ADAPTER psIntfAdapter)
  27 {
  28         INT i = 0;
  29         // Wake up the wait_queue...
  30         if(psIntfAdapter->psAdapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)
  31         {
  32                 psIntfAdapter->psAdapter->DriverState = DRIVER_HALT;
  33                 wake_up(&psIntfAdapter->psAdapter->LEDInfo.notify_led_event);
  34         }
  35         reset_card_proc(psIntfAdapter->psAdapter);
  36
  37         //worst case time taken by the RDM/WRM will be 5 sec. will check after every 100 ms
  38         //to accertain the device is not being accessed. After this No RDM/WRM should be made.
  39         while(psIntfAdapter->psAdapter->DeviceAccess)
  40         {
  41                 BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"Device is being Accessed \n");
  42                 msleep(100);
  43         }
  44         /* Free interrupt URB */
  45         //psIntfAdapter->psAdapter->device_removed = TRUE;
  46         if(psIntfAdapter->psInterruptUrb)
  47         {
  48                 usb_free_urb(psIntfAdapter->psInterruptUrb);
  49         }
  50
  51         /* Free transmit URBs */
  52         for(i = 0; i < MAXIMUM_USB_TCB; i++)
  53         {
  54                 if(psIntfAdapter->asUsbTcb[i].urb  != NULL)
  55                 {
  56                         usb_free_urb(psIntfAdapter->asUsbTcb[i].urb);
  57                         psIntfAdapter->asUsbTcb[i].urb = NULL;
  58                 }
  59         }
  60         /* Free receive URB and buffers */
  61         for(i = 0; i < MAXIMUM_USB_RCB; i++)
  62         {
  63                 if (psIntfAdapter->asUsbRcb[i].urb != NULL)
  64                 {
  65                         kfree(psIntfAdapter->asUsbRcb[i].urb->transfer_buffer);
  66                         usb_free_urb(psIntfAdapter->asUsbRcb[i].urb);
  67                         psIntfAdapter->asUsbRcb[i].urb = NULL;
  68                 }
  69         }
  70         AdapterFree(psIntfAdapter->psAdapter);
  71 }
  72
  73 static VOID ConfigureEndPointTypesThroughEEPROM(PMINI_ADAPTER Adapter)
  74 {
  75         ULONG ulReg = 0;
  76
  77 // Program EP2 MAX_PKT_SIZE
  78         ulReg = ntohl(EP2_MPS_REG);
  79         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x128,4,TRUE);
  80         ulReg = ntohl(EP2_MPS);
  81         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x12C,4,TRUE);
  82
  83         ulReg = ntohl(EP2_CFG_REG);
  84         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x132,4,TRUE);
  85         if(((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter))->bHighSpeedDevice == TRUE)
  86         {
  87                 ulReg = ntohl(EP2_CFG_INT);
  88                 BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x136,4,TRUE);
  89         }
  90         else
  91         {
  92 // USE BULK EP as TX in FS mode.
  93                 ulReg = ntohl(EP2_CFG_BULK);
  94                 BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x136,4,TRUE);
  95         }
  96
  97
  98 // Program EP4 MAX_PKT_SIZE.
  99         ulReg = ntohl(EP4_MPS_REG);
 100         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x13C,4,TRUE);
 101         ulReg = ntohl(EP4_MPS);
 102         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x140,4,TRUE);
 103
 104 //      Program TX EP as interrupt (Alternate Setting)
 105         if( rdmalt(Adapter,0x0F0110F8, (PUINT)&ulReg,4))
 106         {
 107                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "reading of Tx EP is failing");
 108                 return ;
 109         }
 110         ulReg |= 0x6;
 111
 112         ulReg = ntohl(ulReg);
 113         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x1CC,4,TRUE);
 114
 115         ulReg = ntohl(EP4_CFG_REG);
 116         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x1C8,4,TRUE);
 117 // Program ISOCHRONOUS EP size to zero.
 118         ulReg = ntohl(ISO_MPS_REG);
 119         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x1D2,4,TRUE);
 120         ulReg = ntohl(ISO_MPS);
 121         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x1D6,4,TRUE);
 122
 123 // Update EEPROM Version.
 124 // Read 4 bytes from 508 and modify 511 and 510.
 125 //
 126         ReadBeceemEEPROM(Adapter,0x1FC,(PUINT)&ulReg);
 127         ulReg &= 0x0101FFFF;
 128         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x1FC,4,TRUE);
 129 //
 130 //Update length field if required. Also make the string NULL terminated.
 131 //
 132         ReadBeceemEEPROM(Adapter,0xA8,(PUINT)&ulReg);
 133         if((ulReg&0x00FF0000)>>16 > 0x30)
 134         {
 135                 ulReg = (ulReg&0xFF00FFFF)|(0x30<<16);
 136                 BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0xA8,4,TRUE);
 137         }
 138         ReadBeceemEEPROM(Adapter,0x148,(PUINT)&ulReg);
 139         if((ulReg&0x00FF0000)>>16 > 0x30)
 140         {
 141                 ulReg = (ulReg&0xFF00FFFF)|(0x30<<16);
 142                 BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x148,4,TRUE);
 143         }
 144         ulReg = 0;
 145         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x122,4,TRUE);
 146         ulReg = 0;
 147         BeceemEEPROMBulkWrite(Adapter,(PUCHAR)&ulReg,0x1C2,4,TRUE);
 148
 149 }
 150
 151 static int
 152 usbbcm_device_probe(struct usb_interface *intf, const struct usb_device_id *id)
 153 {
 154         struct usb_device *udev = interface_to_usbdev (intf);
 155         int retval;
 156         PMINI_ADAPTER psAdapter;
 157         PS_INTERFACE_ADAPTER psIntfAdapter;
 158         struct net_device *ndev;
 159
 160         /* Reserve one extra queue for the bit-bucket */
 161         ndev = alloc_etherdev_mq(sizeof(MINI_ADAPTER), NO_OF_QUEUES+1);
 162         if(ndev == NULL) {
 163                 dev_err(&udev->dev, DRV_NAME ": no memory for device\n");
 164                 return -ENOMEM;
 165         }
 166
 167         SET_NETDEV_DEV(ndev, &intf->dev);
 168
 169         psAdapter = netdev_priv(ndev);
 170         psAdapter->dev = ndev;
 171         psAdapter->msg_enable = netif_msg_init(debug, default_msg);
 172
 173     /* Init default driver debug state */
 174
 175         psAdapter->stDebugState.debug_level = DBG_LVL_CURR;
 176         psAdapter->stDebugState.type = DBG_TYPE_INITEXIT;
 177
 178     /* Technically, one can start using BCM_DEBUG_PRINT after this point.
 179          * However, realize that by default the Type/Subtype bitmaps are all zero now;
 180          * so no prints will actually appear until the TestApp turns on debug paths via
 181          * the ioctl(); so practically speaking, in early init, no logging happens.
 182          *
 183          * A solution (used below): we explicitly set the bitmaps to 1 for Type=DBG_TYPE_INITEXIT
 184          * and ALL subtype's of the same. Now all bcm debug statements get logged, enabling debug
 185          * during early init.
 186          * Further, we turn this OFF once init_module() completes.
 187          */
 188
 189     psAdapter->stDebugState.subtype[DBG_TYPE_INITEXIT] = 0xff;
 190         BCM_SHOW_DEBUG_BITMAP(psAdapter);
 191
 192         retval = InitAdapter(psAdapter);
 193         if(retval)
 194         {
 195                 dev_err(&udev->dev, DRV_NAME ": InitAdapter Failed\n");
 196                 AdapterFree(psAdapter);
 197                 return retval;
 198         }
 199
 200         /* Allocate interface adapter structure */
 201         psIntfAdapter = kzalloc(sizeof(S_INTERFACE_ADAPTER), GFP_KERNEL);
 202         if (psIntfAdapter == NULL)
 203         {
 204                 dev_err(&udev->dev, DRV_NAME ": no memory for Interface adapter\n");
 205                 AdapterFree (psAdapter);
 206                 return -ENOMEM;
 207         }
 208
 209         psAdapter->pvInterfaceAdapter = psIntfAdapter;
 210         psIntfAdapter->psAdapter = psAdapter;
 211
 212         /* Store usb interface in Interface Adapter */
 213         psIntfAdapter->interface = intf;
 214         usb_set_intfdata(intf, psIntfAdapter);
 215
 216         BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "psIntfAdapter 0x%p",psIntfAdapter);
 217         retval = InterfaceAdapterInit(psIntfAdapter);
 218         if(retval)
 219         {
 220                 /* If the Firmware/Cfg File is not present
 221                  * then return success, let the application
 222                  * download the files.
 223                  */
 224                 if(-ENOENT == retval){
 225                         BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "File Not Found, Use App to Download\n");
 226                         return STATUS_SUCCESS;
 227                 }
 228                 BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "InterfaceAdapterInit Failed \n");
 229                 usb_set_intfdata(intf, NULL);
 230                 udev = interface_to_usbdev (intf);
 231                 usb_put_dev(udev);
 232                 InterfaceAdapterFree(psIntfAdapter);
 233                 return retval ;
 234         }
 235         if(psAdapter->chip_id > T3)
 236         {
 237                 uint32_t uiNackZeroLengthInt=4;
 238                 if(wrmalt(psAdapter, DISABLE_USB_ZERO_LEN_INT, &uiNackZeroLengthInt, sizeof(uiNackZeroLengthInt)))
 239                 {
 240                         return -EIO;
 241                 }
 242         }
 243
 244         /* Check whether the USB-Device Supports remote Wake-Up */
 245         if(USB_CONFIG_ATT_WAKEUP & udev->actconfig->desc.bmAttributes)
 246         {
 247                 /* If Suspend then only support dynamic suspend */
 248                 if(psAdapter->bDoSuspend)
 249                 {
 250 #ifdef CONFIG_PM
 251                         udev->autosuspend_delay = 0;
 252                         intf->needs_remote_wakeup = 1;
 253 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
 254                         udev->autosuspend_disabled = 0;
 255 #else
 256                         usb_enable_autosuspend(udev);
 257 #endif
 258                         device_init_wakeup(&intf->dev,1);
 259 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 32)
 260                         usb_autopm_disable(intf);
 261 #endif
 262                         INIT_WORK(&psIntfAdapter->usbSuspendWork, putUsbSuspend);
 263                         BCM_DEBUG_PRINT(psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Enabling USB Auto-Suspend\n");
 264 #endif
 265                 }
 266                 else
 267                 {
 268                         intf->needs_remote_wakeup = 0;
 269 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
 270                         udev->autosuspend_disabled = 1;
 271 #else
 272                         usb_disable_autosuspend(udev);
 273 #endif
 274                 }
 275         }
 276
 277     psAdapter->stDebugState.subtype[DBG_TYPE_INITEXIT] = 0x0;
 278     return retval;
 279 }
 280
 281 static void usbbcm_disconnect (struct usb_interface *intf)
 282 {
 283         PS_INTERFACE_ADAPTER psIntfAdapter = usb_get_intfdata(intf);
 284         PMINI_ADAPTER psAdapter;
 285         struct usb_device  *udev = interface_to_usbdev (intf);
 286
 287         if(psIntfAdapter == NULL)
 288                 return;
 289
 290         psAdapter = psIntfAdapter->psAdapter;
 291         netif_device_detach(psAdapter->dev);
 292
 293         if(psAdapter->bDoSuspend)
 294                 intf->needs_remote_wakeup = 0;
 295
 296         psAdapter->device_removed = TRUE ;
 297         usb_set_intfdata(intf, NULL);
 298         InterfaceAdapterFree(psIntfAdapter);
 299         usb_put_dev(udev);
 300 }
 301
 302 static int AllocUsbCb(PS_INTERFACE_ADAPTER psIntfAdapter)
 303 {
 304         int i = 0;
 305         for(i = 0; i < MAXIMUM_USB_TCB; i++)
 306         {
 307                 if((psIntfAdapter->asUsbTcb[i].urb =
 308                                 usb_alloc_urb(0, GFP_KERNEL)) == NULL)
 309                 {
 310                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_PRINTK, 0, 0, "Cant allocate Tx urb for index %d", i);
 311                         return -ENOMEM;
 312                 }
 313         }
 314
 315         for(i = 0; i < MAXIMUM_USB_RCB; i++)
 316         {
 317                 if ((psIntfAdapter->asUsbRcb[i].urb =
 318                                 usb_alloc_urb(0, GFP_KERNEL)) == NULL)
 319                 {
 320                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_PRINTK, 0, 0, "Cant allocate Rx urb for index %d", i);
 321                         return -ENOMEM;
 322                 }
 323                 if((psIntfAdapter->asUsbRcb[i].urb->transfer_buffer =
 324                         kmalloc(MAX_DATA_BUFFER_SIZE, GFP_KERNEL)) == NULL)
 325                 {
 326                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_PRINTK, 0, 0, "Cant allocate Rx buffer for index %d", i);
 327                         return -ENOMEM;
 328                 }
 329                 psIntfAdapter->asUsbRcb[i].urb->transfer_buffer_length = MAX_DATA_BUFFER_SIZE;
 330         }
 331         return 0;
 332 }
 333
 334
 335
 336 static int device_run(PS_INTERFACE_ADAPTER psIntfAdapter)
 337 {
 338         INT value = 0;
 339         UINT status = STATUS_SUCCESS;
 340
 341         status = InitCardAndDownloadFirmware(psIntfAdapter->psAdapter);
 342         if(status != STATUS_SUCCESS)
 343         {
 344                 pr_err(DRV_NAME "InitCardAndDownloadFirmware failed.\n");
 345                 return status;
 346         }
 347         if(TRUE == psIntfAdapter->psAdapter->fw_download_done)
 348         {
 349                 if(StartInterruptUrb(psIntfAdapter))
 350                 {
 351                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Cannot send interrupt in URB");
 352                 }
 353                 //now register the cntrl interface.
 354                 //after downloading the f/w waiting for 5 sec to get the mailbox interrupt.
 355
 356                 psIntfAdapter->psAdapter->waiting_to_fw_download_done = FALSE;
 357                 value = wait_event_timeout(psIntfAdapter->psAdapter->ioctl_fw_dnld_wait_queue,
 358                                         psIntfAdapter->psAdapter->waiting_to_fw_download_done, 5*HZ);
 359
 360                 if(value == 0)
 361                         pr_err(DRV_NAME ": Mailbox Interrupt has not reached to Driver..\n");
 362
 363                 if(register_control_device_interface(psIntfAdapter->psAdapter) < 0)
 364                 {
 365                         pr_err(DRV_NAME ": Register Control Device failed...\n");
 366                         return -EIO;
 367                 }
 368         }
 369         return 0;
 370 }
 371
 372
 373 static inline int bcm_usb_endpoint_num(const struct usb_endpoint_descriptor *epd)
 374 {
 375         return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 376 }
 377
 378 static inline int bcm_usb_endpoint_type(const struct usb_endpoint_descriptor *epd)
 379 {
 380         return epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
 381 }
 382
 383 static inline int bcm_usb_endpoint_dir_in(const struct usb_endpoint_descriptor *epd)
 384 {
 385         return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN);
 386 }
 387
 388 static inline int bcm_usb_endpoint_dir_out(const struct usb_endpoint_descriptor *epd)
 389 {
 390         return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);
 391 }
 392
 393 static inline int bcm_usb_endpoint_xfer_bulk(const struct usb_endpoint_descriptor *epd)
 394 {
 395         return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 396                 USB_ENDPOINT_XFER_BULK);
 397 }
 398
 399 static inline int bcm_usb_endpoint_xfer_control(const struct usb_endpoint_descriptor *epd)
 400 {
 401         return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 402                 USB_ENDPOINT_XFER_CONTROL);
 403 }
 404
 405 static inline int bcm_usb_endpoint_xfer_int(const struct usb_endpoint_descriptor *epd)
 406 {
 407         return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 408                 USB_ENDPOINT_XFER_INT);
 409 }
 410
 411 static inline int bcm_usb_endpoint_xfer_isoc(const struct usb_endpoint_descriptor *epd)
 412 {
 413         return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 414                 USB_ENDPOINT_XFER_ISOC);
 415 }
 416
 417 static inline int bcm_usb_endpoint_is_bulk_in(const struct usb_endpoint_descriptor *epd)
 418 {
 419         return (bcm_usb_endpoint_xfer_bulk(epd) && bcm_usb_endpoint_dir_in(epd));
 420 }
 421
 422 static inline int bcm_usb_endpoint_is_bulk_out(const struct usb_endpoint_descriptor *epd)
 423 {
 424         return (bcm_usb_endpoint_xfer_bulk(epd) && bcm_usb_endpoint_dir_out(epd));
 425 }
 426
 427 static inline int bcm_usb_endpoint_is_int_in(const struct usb_endpoint_descriptor *epd)
 428 {
 429         return (bcm_usb_endpoint_xfer_int(epd) && bcm_usb_endpoint_dir_in(epd));
 430 }
 431
 432 static inline int bcm_usb_endpoint_is_int_out(const struct usb_endpoint_descriptor *epd)
 433 {
 434         return (bcm_usb_endpoint_xfer_int(epd) && bcm_usb_endpoint_dir_out(epd));
 435 }
 436
 437 static inline int bcm_usb_endpoint_is_isoc_in(const struct usb_endpoint_descriptor *epd)
 438 {
 439         return (bcm_usb_endpoint_xfer_isoc(epd) && bcm_usb_endpoint_dir_in(epd));
 440 }
 441
 442 static inline int bcm_usb_endpoint_is_isoc_out(const struct usb_endpoint_descriptor *epd)
 443 {
 444         return (bcm_usb_endpoint_xfer_isoc(epd) && bcm_usb_endpoint_dir_out(epd));
 445 }
 446
 447 static INT InterfaceAdapterInit(PS_INTERFACE_ADAPTER psIntfAdapter)
 448 {
 449         struct usb_host_interface *iface_desc;
 450         struct usb_endpoint_descriptor *endpoint;
 451         size_t buffer_size;
 452         ULONG value;
 453         INT retval = 0;
 454         INT usedIntOutForBulkTransfer = 0 ;
 455         BOOLEAN bBcm16 = FALSE;
 456         UINT uiData = 0;
 457
 458         /* Store the usb dev into interface adapter */
 459         psIntfAdapter->udev = usb_get_dev(interface_to_usbdev(psIntfAdapter->interface));
 460
 461         psIntfAdapter->bHighSpeedDevice = (psIntfAdapter->udev->speed == USB_SPEED_HIGH);
 462         psIntfAdapter->psAdapter->interface_rdm = BcmRDM;
 463         psIntfAdapter->psAdapter->interface_wrm = BcmWRM;
 464
 465         if(rdmalt(psIntfAdapter->psAdapter, CHIP_ID_REG, (PUINT)&(psIntfAdapter->psAdapter->chip_id), sizeof(UINT)) < 0)
 466         {
 467                 BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_PRINTK, 0, 0, "CHIP ID Read Failed\n");
 468                 return STATUS_FAILURE;
 469         }
 470
 471         if(0xbece3200==(psIntfAdapter->psAdapter->chip_id&~(0xF0)))
 472                 psIntfAdapter->psAdapter->chip_id &= ~0xF0;
 473
 474         dev_info(&psIntfAdapter->udev->dev, "RDM Chip ID 0x%lx\n",
 475                  psIntfAdapter->psAdapter->chip_id);
 476
 477         iface_desc = psIntfAdapter->interface->cur_altsetting;
 478
 479         if(psIntfAdapter->psAdapter->chip_id == T3B)
 480         {
 481                 //
 482                 //T3B device will have EEPROM,check if EEPROM is proper and BCM16 can be done or not.
 483                 //
 484                 BeceemEEPROMBulkRead(psIntfAdapter->psAdapter,&uiData,0x0,4);
 485                 if(uiData == BECM)
 486                         bBcm16 = TRUE;
 487
 488                 dev_info(&psIntfAdapter->udev->dev, "number of alternate setting %d\n",
 489                          psIntfAdapter->interface->num_altsetting);
 490
 491                 if(bBcm16 == TRUE)
 492                 {
 493                         //selecting alternate setting one as a default setting for High Speed  modem.
 494                         if(psIntfAdapter->bHighSpeedDevice)
 495                                 retval= usb_set_interface(psIntfAdapter->udev,DEFAULT_SETTING_0,ALTERNATE_SETTING_1);
 496                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "BCM16 is Applicable on this dongle");
 497                         if(retval || (psIntfAdapter->bHighSpeedDevice == FALSE))
 498                         {
 499                                 usedIntOutForBulkTransfer = EP2 ;
 500                                 endpoint = &iface_desc->endpoint[EP2].desc;
 501                                 BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Interface altsetting  got failed or Moemd is configured to FS.hence will work on default setting 0 \n");
 502                                 /*
 503                                 If Modem is high speed device EP2 should be INT OUT End point
 504                                 If Mode is FS then EP2 should be bulk end point
 505                                 */
 506                                 if(((psIntfAdapter->bHighSpeedDevice ==TRUE ) && (bcm_usb_endpoint_is_int_out(endpoint)== FALSE))
 507                                         ||((psIntfAdapter->bHighSpeedDevice == FALSE)&& (bcm_usb_endpoint_is_bulk_out(endpoint)== FALSE)))
 508                                 {
 509                                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"Configuring the EEPROM ");
 510                                         //change the EP2, EP4 to INT OUT end point
 511                                         ConfigureEndPointTypesThroughEEPROM(psIntfAdapter->psAdapter);
 512
 513                                         /*
 514                                         It resets the device and if any thing gets changed in USB descriptor it will show fail and
 515                                         re-enumerate the device
 516                                         */
 517                                         retval = usb_reset_device(psIntfAdapter->udev);
 518                                         if(retval)
 519                                         {
 520                                                 BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "reset got failed. hence Re-enumerating the device \n");
 521                                                 return retval ;
 522                                         }
 523
 524                                 }
 525                                 if((psIntfAdapter->bHighSpeedDevice == FALSE) && bcm_usb_endpoint_is_bulk_out(endpoint))
 526                                 {
 527                                         // Once BULK is selected in FS mode. Revert it back to INT. Else USB_IF will fail.
 528                                         UINT _uiData = ntohl(EP2_CFG_INT);
 529                                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"Reverting Bulk to INT as it is FS MODE");
 530                                         BeceemEEPROMBulkWrite(psIntfAdapter->psAdapter,(PUCHAR)&_uiData,0x136,4,TRUE);
 531                                 }
 532                         }
 533                         else
 534                         {
 535                                 usedIntOutForBulkTransfer = EP4 ;
 536                                 endpoint = &iface_desc->endpoint[EP4].desc;
 537                                 BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Choosing AltSetting as a default setting");
 538                                 if( bcm_usb_endpoint_is_int_out(endpoint) == FALSE)
 539                                 {
 540                                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, " Dongle does not have BCM16 Fix");
 541                                         //change the EP2, EP4 to INT OUT end point and use EP4 in altsetting
 542                                         ConfigureEndPointTypesThroughEEPROM(psIntfAdapter->psAdapter);
 543
 544                                         /*
 545                                         It resets the device and if any thing gets changed in USB descriptor it will show fail and
 546                                         re-enumerate the device
 547                                         */
 548                                         retval = usb_reset_device(psIntfAdapter->udev);
 549                                         if(retval)
 550                                         {
 551                                                 BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "reset got failed. hence Re-enumerating the device \n");
 552                                                 return retval ;
 553                                         }
 554
 555                                 }
 556                         }
 557                 }
 558         }
 559
 560         iface_desc = psIntfAdapter->interface->cur_altsetting;
 561
 562         for (value = 0; value < iface_desc->desc.bNumEndpoints; ++value)
 563         {
 564                 endpoint = &iface_desc->endpoint[value].desc;
 565
 566         if (!psIntfAdapter->sBulkIn.bulk_in_endpointAddr && bcm_usb_endpoint_is_bulk_in(endpoint))
 567         {
 568             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 569             psIntfAdapter->sBulkIn.bulk_in_size = buffer_size;
 570             psIntfAdapter->sBulkIn.bulk_in_endpointAddr =
 571                                                                 endpoint->bEndpointAddress;
 572                 psIntfAdapter->sBulkIn.bulk_in_pipe =
 573                                         usb_rcvbulkpipe(psIntfAdapter->udev,
 574                                                                 psIntfAdapter->sBulkIn.bulk_in_endpointAddr);
 575         }
 576
 577         if (!psIntfAdapter->sBulkOut.bulk_out_endpointAddr && bcm_usb_endpoint_is_bulk_out(endpoint))
 578         {
 579
 580                         psIntfAdapter->sBulkOut.bulk_out_endpointAddr =
 581                                                                                 endpoint->bEndpointAddress;
 582                 psIntfAdapter->sBulkOut.bulk_out_pipe =
 583                         usb_sndbulkpipe(psIntfAdapter->udev,
 584                                         psIntfAdapter->sBulkOut.bulk_out_endpointAddr);
 585         }
 586
 587         if (!psIntfAdapter->sIntrIn.int_in_endpointAddr && bcm_usb_endpoint_is_int_in(endpoint))
 588         {
 589             buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 590             psIntfAdapter->sIntrIn.int_in_size = buffer_size;
 591             psIntfAdapter->sIntrIn.int_in_endpointAddr =
 592                                                                 endpoint->bEndpointAddress;
 593             psIntfAdapter->sIntrIn.int_in_interval = endpoint->bInterval;
 594             psIntfAdapter->sIntrIn.int_in_buffer =
 595                                                 kmalloc(buffer_size, GFP_KERNEL);
 596             if (!psIntfAdapter->sIntrIn.int_in_buffer) {
 597                     dev_err(&psIntfAdapter->udev->dev,
 598                             "could not allocate interrupt_in_buffer\n");
 599                 return -EINVAL;
 600             }
 601         }
 602
 603         if (!psIntfAdapter->sIntrOut.int_out_endpointAddr && bcm_usb_endpoint_is_int_out(endpoint))
 604         {
 605
 606                         if( !psIntfAdapter->sBulkOut.bulk_out_endpointAddr &&
 607                                 (psIntfAdapter->psAdapter->chip_id == T3B) && (value == usedIntOutForBulkTransfer))
 608                         {
 609                                 //use first intout end point as a bulk out end point
 610                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 611                 psIntfAdapter->sBulkOut.bulk_out_size = buffer_size;
 612                                 //printk("\nINT OUT Endpoing buffer size :%x endpoint :%x\n", buffer_size, value +1);
 613                                 psIntfAdapter->sBulkOut.bulk_out_endpointAddr =
 614                                                                                 endpoint->bEndpointAddress;
 615                         psIntfAdapter->sBulkOut.bulk_out_pipe =
 616                                 usb_sndintpipe(psIntfAdapter->udev,
 617                                         psIntfAdapter->sBulkOut.bulk_out_endpointAddr);
 618                         psIntfAdapter->sBulkOut.int_out_interval = endpoint->bInterval;
 619
 620                         }
 621                         else if(value == EP6)
 622                         {
 623                     buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 624                     psIntfAdapter->sIntrOut.int_out_size = buffer_size;
 625                     psIntfAdapter->sIntrOut.int_out_endpointAddr =
 626                                                                                 endpoint->bEndpointAddress;
 627                     psIntfAdapter->sIntrOut.int_out_interval = endpoint->bInterval;
 628                     psIntfAdapter->sIntrOut.int_out_buffer= kmalloc(buffer_size,
 629                                                                                                                 GFP_KERNEL);
 630                         if (!psIntfAdapter->sIntrOut.int_out_buffer)
 631                         {
 632                                 dev_err(&psIntfAdapter->udev->dev,
 633                                         "could not allocate interrupt_out_buffer\n");
 634                                         return -EINVAL;
 635                         }
 636         }
 637     }
 638         }
 639     usb_set_intfdata(psIntfAdapter->interface, psIntfAdapter);
 640
 641         psIntfAdapter->psAdapter->bcm_file_download = InterfaceFileDownload;
 642         psIntfAdapter->psAdapter->bcm_file_readback_from_chip =
 643                                 InterfaceFileReadbackFromChip;
 644         psIntfAdapter->psAdapter->interface_transmit = InterfaceTransmitPacket;
 645
 646         retval = CreateInterruptUrb(psIntfAdapter);
 647
 648         if(retval)
 649         {
 650                 BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_PRINTK, 0, 0, "Cannot create interrupt urb");
 651                 return retval;
 652         }
 653
 654         retval = AllocUsbCb(psIntfAdapter);
 655         if(retval)
 656         {
 657                 return retval;
 658         }
 659
 660
 661         return device_run(psIntfAdapter);
 662 }
 663
 664 static int InterfaceSuspend (struct usb_interface *intf, pm_message_t message)
 665 {
 666         PS_INTERFACE_ADAPTER  psIntfAdapter = usb_get_intfdata(intf);
 667
 668         psIntfAdapter->bSuspended = TRUE;
 669
 670         if(TRUE == psIntfAdapter->bPreparingForBusSuspend)
 671         {
 672                 psIntfAdapter->bPreparingForBusSuspend = FALSE;
 673
 674                 if(psIntfAdapter->psAdapter->LinkStatus == LINKUP_DONE)
 675                 {
 676                         psIntfAdapter->psAdapter->IdleMode = TRUE ;
 677                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Host Entered in PMU Idle Mode..");
 678                 }
 679                 else
 680                 {
 681                         psIntfAdapter->psAdapter->bShutStatus = TRUE;
 682                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Host Entered in PMU Shutdown Mode..");
 683                 }
 684         }
 685         psIntfAdapter->psAdapter->bPreparingForLowPowerMode = FALSE;
 686
 687         //Signaling the control pkt path
 688         wake_up(&psIntfAdapter->psAdapter->lowpower_mode_wait_queue);
 689
 690         return 0;
 691 }
 692
 693 static int InterfaceResume (struct usb_interface *intf)
 694 {
 695     PS_INTERFACE_ADAPTER  psIntfAdapter = usb_get_intfdata(intf);
 696         printk("=================================\n");
 697         mdelay(100);
 698 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 32)
 699         intf->pm_usage_cnt =1 ;
 700 #endif
 701         psIntfAdapter->bSuspended = FALSE;
 702
 703         StartInterruptUrb(psIntfAdapter);
 704         InterfaceRx(psIntfAdapter);
 705         return 0;
 706 }
 707
 708 static struct usb_driver usbbcm_driver = {
 709     .name = "usbbcm",
 710     .probe = usbbcm_device_probe,
 711     .disconnect = usbbcm_disconnect,
 712     .suspend = InterfaceSuspend,
 713     .resume = InterfaceResume,
 714     .id_table = InterfaceUsbtable,
 715     .supports_autosuspend = 1,
 716 };
 717
 718 struct class *bcm_class;
 719
 720
 721 static __init int bcm_init(void)
 722 {
 723         printk(KERN_INFO "%s: %s, %s\n", DRV_NAME, DRV_DESCRIPTION, DRV_VERSION);
 724         printk(KERN_INFO "%s\n", DRV_COPYRIGHT);
 725
 726         bcm_class = class_create(THIS_MODULE, DRV_NAME);
 727         if (IS_ERR(bcm_class)) {
 728                 printk(KERN_ERR DRV_NAME ": could not create class\n");
 729                 return PTR_ERR(bcm_class);
 730         }
 731
 732         return usb_register(&usbbcm_driver);
 733 }
 734
 735 static __exit void bcm_exit(void)
 736 {
 737         class_destroy (bcm_class);
 738
 739         usb_deregister(&usbbcm_driver);
 740 }
 741
 742 module_init(bcm_init);
 743 module_exit(bcm_exit);
 744
 745 MODULE_DESCRIPTION(DRV_DESCRIPTION);
 746 MODULE_VERSION(DRV_VERSION);
 747 MODULE_LICENSE ("GPL");