drivers/staging/bcm/InterfaceTx.c

   1 #include "headers.h"
   2
   3 /*this is transmit call-back(BULK OUT)*/
   4 static void write_bulk_callback(struct urb *urb/*, struct pt_regs *regs*/)
   5 {
   6         PUSB_TCB pTcb= (PUSB_TCB)urb->context;
   7         PS_INTERFACE_ADAPTER psIntfAdapter = pTcb->psIntfAdapter;
   8         CONTROL_MESSAGE *pControlMsg = (CONTROL_MESSAGE *)urb->transfer_buffer;
   9         PMINI_ADAPTER psAdapter = psIntfAdapter->psAdapter ;
  10         BOOLEAN bpowerDownMsg = FALSE ;
  11     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
  12 #if 0
  13         struct timeval tv;
  14         UINT time_ms = 0;
  15 #endif
  16         if(urb->status != STATUS_SUCCESS)
  17         {
  18                 if(urb->status == -EPIPE)
  19                 {
  20                         psIntfAdapter->psAdapter->bEndPointHalted = TRUE ;
  21                         wake_up(&psIntfAdapter->psAdapter->tx_packet_wait_queue);
  22                 }
  23                 else
  24                 {
  25                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL,"Tx URB has got cancelled. status :%d", urb->status);
  26                 }
  27         }
  28
  29         pTcb->bUsed = FALSE;
  30         atomic_dec(&psIntfAdapter->uNumTcbUsed);
  31
  32
  33
  34         if(TRUE == psAdapter->bPreparingForLowPowerMode)
  35         {
  36                 #if 0
  37                 do_gettimeofday(&tv);
  38                 time_ms = tv.tv_sec *1000 + tv.tv_usec/1000;
  39                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " %s Idle Mode ACK_Sent got from device at time :0x%x", __FUNCTION__, time_ms);
  40                 #endif
  41
  42                 if(((pControlMsg->szData[0] == GO_TO_IDLE_MODE_PAYLOAD) &&
  43                         (pControlMsg->szData[1] == TARGET_CAN_GO_TO_IDLE_MODE)))
  44
  45                 {
  46                         bpowerDownMsg = TRUE ;
  47                         //This covers the bus err while Idle Request msg sent down.
  48                         if(urb->status != STATUS_SUCCESS)
  49                         {
  50                                 psAdapter->bPreparingForLowPowerMode = FALSE ;
  51                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL,"Idle Mode Request msg failed to reach to Modem");
  52                                 //Signalling the cntrl pkt path in Ioctl
  53                                 wake_up(&psAdapter->lowpower_mode_wait_queue);
  54                                 StartInterruptUrb(psIntfAdapter);
  55                                 goto err_exit;
  56                         }
  57
  58                         if(psAdapter->bDoSuspend == FALSE)
  59                         {
  60                                 psAdapter->IdleMode = TRUE;
  61                                 //since going in Idle mode completed hence making this var false;
  62                                 psAdapter->bPreparingForLowPowerMode = FALSE ;
  63
  64                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "Host Entered in Idle Mode State...");
  65                                 //Signalling the cntrl pkt path in Ioctl
  66                                 wake_up(&psAdapter->lowpower_mode_wait_queue);
  67                         }
  68
  69                 }
  70                 else if((pControlMsg->Leader.Status == LINK_UP_CONTROL_REQ) &&
  71                         (pControlMsg->szData[0] == LINK_UP_ACK) &&
  72                         (pControlMsg->szData[1] == LINK_SHUTDOWN_REQ_FROM_FIRMWARE)  &&
  73                         (pControlMsg->szData[2] == SHUTDOWN_ACK_FROM_DRIVER))
  74                 {
  75                         //This covers the bus err while shutdown Request msg sent down.
  76                         if(urb->status != STATUS_SUCCESS)
  77                         {
  78                                 psAdapter->bPreparingForLowPowerMode = FALSE ;
  79                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL,"Shutdown Request Msg failed to reach to Modem");
  80                                 //Signalling the cntrl pkt path in Ioctl
  81                                 wake_up(&psAdapter->lowpower_mode_wait_queue);
  82                                 StartInterruptUrb(psIntfAdapter);
  83                                 goto err_exit;
  84                         }
  85
  86                         bpowerDownMsg = TRUE ;
  87                         if(psAdapter->bDoSuspend == FALSE)
  88                         {
  89                                 psAdapter->bShutStatus = TRUE;
  90                                 //since going in shutdown mode completed hence making this var false;
  91                                 psAdapter->bPreparingForLowPowerMode = FALSE ;
  92                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL,"Host Entered in shutdown Mode State...");
  93                                 //Signalling the cntrl pkt path in Ioctl
  94                                 wake_up(&psAdapter->lowpower_mode_wait_queue);
  95                         }
  96                 }
  97
  98                 if(psAdapter->bDoSuspend && bpowerDownMsg)
  99                 {
 100                         //issuing bus suspend request
 101                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL,"Issuing the Bus suspend request to USB stack");
 102                         psIntfAdapter->bPreparingForBusSuspend = TRUE;
 103                         schedule_work(&psIntfAdapter->usbSuspendWork);
 104
 105                 }
 106
 107         }
 108
 109 err_exit :
 110 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
 111         usb_buffer_free(urb->dev, urb->transfer_buffer_length,
 112                         urb->transfer_buffer, urb->transfer_dma);
 113 #else
 114         usb_free_coherent(urb->dev, urb->transfer_buffer_length,
 115                         urb->transfer_buffer, urb->transfer_dma);
 116 #endif
 117 }
 118
 119
 120 static PUSB_TCB GetBulkOutTcb(PS_INTERFACE_ADAPTER psIntfAdapter)
 121 {
 122         PUSB_TCB pTcb = NULL;
 123         UINT index = 0;
 124
 125         if((atomic_read(&psIntfAdapter->uNumTcbUsed) < MAXIMUM_USB_TCB) &&
 126                 (psIntfAdapter->psAdapter->StopAllXaction ==FALSE))
 127         {
 128                 index = atomic_read(&psIntfAdapter->uCurrTcb);
 129                 pTcb = &psIntfAdapter->asUsbTcb[index];
 130                 pTcb->bUsed = TRUE;
 131                 pTcb->psIntfAdapter= psIntfAdapter;
 132                 BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "Got Tx desc %d used %d",
 133                         index, atomic_read(&psIntfAdapter->uNumTcbUsed));
 134                 index = (index + 1) % MAXIMUM_USB_TCB;
 135                 atomic_set(&psIntfAdapter->uCurrTcb, index);
 136                 atomic_inc(&psIntfAdapter->uNumTcbUsed);
 137         }
 138         return pTcb;
 139 }
 140
 141 static int TransmitTcb(PS_INTERFACE_ADAPTER psIntfAdapter, PUSB_TCB pTcb, PVOID data, int len)
 142 {
 143
 144         struct urb *urb = pTcb->urb;
 145         int retval = 0;
 146
 147 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
 148         urb->transfer_buffer = usb_buffer_alloc(psIntfAdapter->udev, len,
 149                                                 GFP_ATOMIC, &urb->transfer_dma);
 150 #else
 151         urb->transfer_buffer = usb_alloc_coherent(psIntfAdapter->udev, len,
 152                                                 GFP_ATOMIC, &urb->transfer_dma);
 153 #endif
 154
 155         if (!urb->transfer_buffer)
 156         {
 157                 BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_PRINTK, 0, 0, "Error allocating memory\n");
 158                 return  -ENOMEM;
 159         }
 160         memcpy(urb->transfer_buffer, data, len);
 161         urb->transfer_buffer_length = len;
 162
 163         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "Sending Bulk out packet\n");
 164         //For T3B,INT OUT end point will be used as bulk out end point
 165         if((psIntfAdapter->psAdapter->chip_id == T3B) && (psIntfAdapter->bHighSpeedDevice == TRUE))
 166         {
 167                 usb_fill_int_urb(urb, psIntfAdapter->udev,
 168                 psIntfAdapter->sBulkOut.bulk_out_pipe,
 169                         urb->transfer_buffer, len, write_bulk_callback, pTcb,
 170                         psIntfAdapter->sBulkOut.int_out_interval);
 171         }
 172         else
 173         {
 174         usb_fill_bulk_urb(urb, psIntfAdapter->udev,
 175                   psIntfAdapter->sBulkOut.bulk_out_pipe,
 176                   urb->transfer_buffer, len, write_bulk_callback, pTcb);
 177         }
 178         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; /* For DMA transfer */
 179
 180         if(FALSE == psIntfAdapter->psAdapter->device_removed &&
 181            FALSE == psIntfAdapter->psAdapter->bEndPointHalted &&
 182            FALSE == psIntfAdapter->bSuspended &&
 183            FALSE == psIntfAdapter->bPreparingForBusSuspend)
 184         {
 185                 retval = usb_submit_urb(urb, GFP_ATOMIC);
 186                 if (retval)
 187                 {
 188                         BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "failed submitting write urb, error %d", retval);
 189                         if(retval == -EPIPE)
 190                         {
 191                                 psIntfAdapter->psAdapter->bEndPointHalted = TRUE ;
 192                                 wake_up(&psIntfAdapter->psAdapter->tx_packet_wait_queue);
 193                         }
 194                 }
 195         }
 196         return retval;
 197 }
 198
 199 int InterfaceTransmitPacket(PVOID arg, PVOID data, UINT len)
 200 {
 201         PUSB_TCB pTcb= NULL;
 202
 203         PS_INTERFACE_ADAPTER psIntfAdapter = (PS_INTERFACE_ADAPTER)arg;
 204         pTcb= GetBulkOutTcb(psIntfAdapter);
 205         if(pTcb == NULL)
 206         {
 207                 BCM_DEBUG_PRINT(psIntfAdapter->psAdapter,DBG_TYPE_PRINTK, 0, 0, "No URB to transmit packet, dropping packet");
 208                 return -EFAULT;
 209         }
 210         return TransmitTcb(psIntfAdapter, pTcb, data, len);
 211 }
 212
 213