drivers/staging/bcm/Transmit.c

   1 /**
   2  * @file Transmit.c
   3  * @defgroup tx_functions Transmission
   4  * @section Queueing
   5  * @dot
   6  * digraph transmit1 {
   7  * node[shape=box]
   8  * edge[weight=5;color=red]
   9  *
  10  * bcm_transmit->GetPacketQueueIndex[label="IP Packet"]
  11  * GetPacketQueueIndex->IpVersion4[label="IPV4"]
  12  * GetPacketQueueIndex->IpVersion6[label="IPV6"]
  13  * }
  14  *
  15  * @enddot
  16  *
  17  * @section De-Queueing
  18  * @dot
  19  * digraph transmit2 {
  20  * node[shape=box]
  21  * edge[weight=5;color=red]
  22  * interrupt_service_thread->transmit_packets
  23  * tx_pkt_hdler->transmit_packets
  24  * transmit_packets->CheckAndSendPacketFromIndex
  25  * transmit_packets->UpdateTokenCount
  26  * CheckAndSendPacketFromIndex->PruneQueue
  27  * CheckAndSendPacketFromIndex->IsPacketAllowedForFlow
  28  * CheckAndSendPacketFromIndex->SendControlPacket[label="control pkt"]
  29  * SendControlPacket->bcm_cmd53
  30  * CheckAndSendPacketFromIndex->SendPacketFromQueue[label="data pkt"]
  31  * SendPacketFromQueue->SetupNextSend->bcm_cmd53
  32  * }
  33  * @enddot
  34  */
  35
  36 #include "headers.h"
  37
  38 /**
  39  * @ingroup ctrl_pkt_functions
  40  * This function dispatches control packet to the h/w interface
  41  * @return zero(success) or -ve value(failure)
  42  */
  43 int SendControlPacket(struct bcm_mini_adapter *Adapter, char *pControlPacket)
  44 {
  45         struct bcm_leader *PLeader = (struct bcm_leader *)pControlPacket;
  46
  47         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Tx");
  48         if (!pControlPacket || !Adapter) {
  49                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL,
  50                                 "Got NULL Control Packet or Adapter");
  51                 return STATUS_FAILURE;
  52         }
  53         if ((atomic_read(&Adapter->CurrNumFreeTxDesc) <
  54                         ((PLeader->PLength-1)/MAX_DEVICE_DESC_SIZE)+1)) {
  55                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL,
  56                                 "NO FREE DESCRIPTORS TO SEND CONTROL PACKET");
  57                 return STATUS_FAILURE;
  58         }
  59
  60         /* Update the netdevice statistics */
  61         /* Dump Packet  */
  62         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL,
  63                         "Leader Status: %x", PLeader->Status);
  64         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL,
  65                         "Leader VCID: %x", PLeader->Vcid);
  66         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL,
  67                         "Leader Length: %x", PLeader->PLength);
  68         if (Adapter->device_removed)
  69                 return 0;
  70
  71         if (netif_msg_pktdata(Adapter))
  72                 print_hex_dump(KERN_DEBUG, PFX "tx control: ", DUMP_PREFIX_NONE,
  73                                16, 1, pControlPacket,
  74                                PLeader->PLength + LEADER_SIZE, 0);
  75
  76         Adapter->interface_transmit(Adapter->pvInterfaceAdapter,
  77                                     pControlPacket,
  78                                     (PLeader->PLength + LEADER_SIZE));
  79
  80         atomic_dec(&Adapter->CurrNumFreeTxDesc);
  81         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL,
  82                         "<=========");
  83         return STATUS_SUCCESS;
  84 }
  85
  86 /**
  87  * @ingroup tx_functions
  88  * This function despatches the IP packets with the given vcid
  89  * to the target via the host h/w interface.
  90  * @return  zero(success) or -ve value(failure)
  91  */
  92 int SetupNextSend(struct bcm_mini_adapter *Adapter,  struct sk_buff *Packet, USHORT Vcid)
  93 {
  94         int     status = 0;
  95         bool    bHeaderSupressionEnabled = false;
  96         B_UINT16 uiClassifierRuleID;
  97         u16     QueueIndex = skb_get_queue_mapping(Packet);
  98         struct bcm_packet_info *curr_packet_info =
  99                 &Adapter->PackInfo[QueueIndex];
 100         struct bcm_leader Leader = {0};
 101
 102         if (Packet->len > MAX_DEVICE_DESC_SIZE) {
 103                 status = STATUS_FAILURE;
 104                 goto errExit;
 105         }
 106
 107         /* Get the Classifier Rule ID */
 108         uiClassifierRuleID = *((UINT32 *) (Packet->cb) +
 109                                SKB_CB_CLASSIFICATION_OFFSET);
 110
 111         bHeaderSupressionEnabled = curr_packet_info->bHeaderSuppressionEnabled &
 112                 Adapter->bPHSEnabled;
 113
 114         if (Adapter->device_removed) {
 115                 status = STATUS_FAILURE;
 116                 goto errExit;
 117         }
 118
 119         status = PHSTransmit(Adapter, &Packet, Vcid, uiClassifierRuleID,
 120                              bHeaderSupressionEnabled,
 121                              (UINT *)&Packet->len,
 122                              curr_packet_info->bEthCSSupport);
 123
 124         if (status != STATUS_SUCCESS) {
 125                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL,
 126                                 "PHS Transmit failed..\n");
 127                 goto errExit;
 128         }
 129
 130         Leader.Vcid = Vcid;
 131
 132         if (TCP_ACK == *((UINT32 *) (Packet->cb) + SKB_CB_TCPACK_OFFSET))
 133                 Leader.Status = LEADER_STATUS_TCP_ACK;
 134         else
 135                 Leader.Status = LEADER_STATUS;
 136
 137         if (curr_packet_info->bEthCSSupport) {
 138                 Leader.PLength = Packet->len;
 139                 if (skb_headroom(Packet) < LEADER_SIZE) {
 140                         status = skb_cow(Packet, LEADER_SIZE);
 141                         if (status) {
 142                                 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, NEXT_SEND,
 143                                                 DBG_LVL_ALL,
 144                                                 "bcm_transmit : Failed To Increase headRoom\n");
 145                                 goto errExit;
 146                         }
 147                 }
 148                 skb_push(Packet, LEADER_SIZE);
 149                 memcpy(Packet->data, &Leader, LEADER_SIZE);
 150         } else {
 151                 Leader.PLength = Packet->len - ETH_HLEN;
 152                 memcpy((struct bcm_leader *)skb_pull(Packet,
 153                                                      (ETH_HLEN - LEADER_SIZE)),
 154                         &Leader,
 155                         LEADER_SIZE);
 156         }
 157
 158         status = Adapter->interface_transmit(Adapter->pvInterfaceAdapter,
 159                                              Packet->data,
 160                                              (Leader.PLength + LEADER_SIZE));
 161         if (status) {
 162                 ++Adapter->dev->stats.tx_errors;
 163                 if (netif_msg_tx_err(Adapter))
 164                         pr_info(PFX "%s: transmit error %d\n",
 165                                 Adapter->dev->name,
 166                                 status);
 167         } else {
 168                 struct net_device_stats *netstats = &Adapter->dev->stats;
 169
 170                 curr_packet_info->uiTotalTxBytes += Leader.PLength;
 171
 172                 netstats->tx_bytes += Leader.PLength;
 173                 ++netstats->tx_packets;
 174
 175                 curr_packet_info->uiCurrentTokenCount -= Leader.PLength << 3;
 176                 curr_packet_info->uiSentBytes += (Packet->len);
 177                 curr_packet_info->uiSentPackets++;
 178                 curr_packet_info->NumOfPacketsSent++;
 179
 180                 atomic_dec(&curr_packet_info->uiPerSFTxResourceCount);
 181                 curr_packet_info->uiThisPeriodSentBytes += Leader.PLength;
 182         }
 183
 184         atomic_dec(&Adapter->CurrNumFreeTxDesc);
 185
 186 errExit:
 187         dev_kfree_skb(Packet);
 188         return status;
 189 }
 190
 191 static int tx_pending(struct bcm_mini_adapter *Adapter)
 192 {
 193         return (atomic_read(&Adapter->TxPktAvail)
 194                 && MINIMUM_PENDING_DESCRIPTORS <
 195                         atomic_read(&Adapter->CurrNumFreeTxDesc))
 196                 || Adapter->device_removed || (1 == Adapter->downloadDDR);
 197 }
 198
 199 /**
 200  * @ingroup tx_functions
 201  * Transmit thread
 202  */
 203 int tx_pkt_handler(struct bcm_mini_adapter *Adapter /**< pointer to adapter object*/)
 204 {
 205         int status = 0;
 206
 207         while (!kthread_should_stop()) {
 208                 /* FIXME - the timeout looks like workaround for racey usage of TxPktAvail */
 209                 if (Adapter->LinkUpStatus)
 210                         wait_event_timeout(Adapter->tx_packet_wait_queue,
 211                                            tx_pending(Adapter),
 212                                            msecs_to_jiffies(10));
 213                 else
 214                         wait_event_interruptible(Adapter->tx_packet_wait_queue,
 215                                                  tx_pending(Adapter));
 216
 217                 if (Adapter->device_removed)
 218                         break;
 219
 220                 if (Adapter->downloadDDR == 1) {
 221                         Adapter->downloadDDR += 1;
 222                         status = download_ddr_settings(Adapter);
 223                         if (status)
 224                                 pr_err(PFX "DDR DOWNLOAD FAILED! %d\n", status);
 225                         continue;
 226                 }
 227
 228                 /* Check end point for halt/stall. */
 229                 if (Adapter->bEndPointHalted == TRUE) {
 230                         Bcm_clear_halt_of_endpoints(Adapter);
 231                         Adapter->bEndPointHalted = false;
 232                         StartInterruptUrb((struct bcm_interface_adapter *)(Adapter->pvInterfaceAdapter));
 233                 }
 234
 235                 if (Adapter->LinkUpStatus && !Adapter->IdleMode) {
 236                         if (atomic_read(&Adapter->TotalPacketCount))
 237                                 update_per_sf_desc_cnts(Adapter);
 238                 }
 239
 240                 if (atomic_read(&Adapter->CurrNumFreeTxDesc) &&
 241                         Adapter->LinkStatus == SYNC_UP_REQUEST &&
 242                         !Adapter->bSyncUpRequestSent) {
 243
 244                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_PACKETS,
 245                                         DBG_LVL_ALL, "Calling LinkMessage");
 246                         LinkMessage(Adapter);
 247                 }
 248
 249                 if ((Adapter->IdleMode || Adapter->bShutStatus) &&
 250                                 atomic_read(&Adapter->TotalPacketCount)) {
 251                         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX,
 252                                         TX_PACKETS, DBG_LVL_ALL,
 253                                         "Device in Low Power mode...waking up");
 254                         Adapter->usIdleModePattern = ABORT_IDLE_MODE;
 255                         Adapter->bWakeUpDevice = TRUE;
 256                         wake_up(&Adapter->process_rx_cntrlpkt);
 257                 }
 258
 259                 transmit_packets(Adapter);
 260                 atomic_set(&Adapter->TxPktAvail, 0);
 261         }
 262
 263         BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL,
 264                         "Exiting the tx thread..\n");
 265         Adapter->transmit_packet_thread = NULL;
 266         return 0;
 267 }