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