LXR linux/drivers/staging/bcm/Transmit.c

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