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 bcm_transmit->reply_to_arp_request[label="ARP"]
  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 * Function    - bcm_transmit()
  40 *
  41 * Description - This is the main transmit function for our virtual
  42 *                               interface(veth0). It handles the ARP packets. It
  43 *                               clones this packet and then Queue it to a suitable
  44 *                               Queue. Then calls the transmit_packet().
  45 *
  46 * Parameter   -  skb - Pointer to the socket buffer structure
  47 *                                dev - Pointer to the virtual net device structure
  48 *
  49 * Returns     -  zero (success) or -ve value (failure)
  50 *
  51 *********************************************************************/
  52
  53 INT bcm_transmit(struct sk_buff *skb,           /**< skb */
  54                                         struct net_device *dev  /**< net device pointer */
  55                                         )
  56 {
  57         PMINI_ADAPTER           Adapter = NULL;
  58         USHORT                          qindex=0;
  59         struct timeval tv;
  60         UINT            pkt_type = 0;
  61         UINT            calltransmit = 0;
  62
  63         BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "\n%s====>\n",__FUNCTION__);
  64
  65         memset(&tv, 0, sizeof(tv));
  66         /* Check for valid parameters */
  67         if(skb == NULL || dev==NULL)
  68         {
  69             BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX,TX_OSAL_DBG, DBG_LVL_ALL, "Got NULL skb or dev\n");
  70                 return -EINVAL;
  71         }
  72
  73         Adapter = GET_BCM_ADAPTER(dev);
  74         if(!Adapter)
  75         {
  76                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "Got Invalid Adapter\n");
  77                 return -EINVAL;
  78         }
  79         if(Adapter->device_removed == TRUE || !Adapter->LinkUpStatus)
  80         {
  81                 if(!netif_queue_stopped(dev)) {
  82                                 netif_carrier_off(dev);
  83                                 netif_stop_queue(dev);
  84                 }
  85                 return STATUS_FAILURE;
  86         }
  87         BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "Packet size : %d\n", skb->len);
  88
  89         /*Add Ethernet CS check here*/
  90         if(Adapter->TransferMode == IP_PACKET_ONLY_MODE )
  91         {
  92         pkt_type = ntohs(*(PUSHORT)(skb->data + 12));
  93                 /* Get the queue index where the packet is to be queued */
  94                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "Getting the Queue Index.....");
  95
  96                 qindex = GetPacketQueueIndex(Adapter,skb);
  97
  98                 if((SHORT)INVALID_QUEUE_INDEX==(SHORT)qindex)
  99                 {
 100                         if(pkt_type == ETH_ARP_FRAME)
 101                         {
 102                                 /*
 103                                 Reply directly to ARP request packet
 104                                 ARP Spoofing only if NO ETH CS rule matches for it
 105                                 */
 106                                 BCM_DEBUG_PRINT (Adapter,DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL,"ARP OPCODE = %02x",
 107
 108                 (*(PUCHAR)(skb->data + 21)));
 109
 110                 reply_to_arp_request(skb);
 111
 112                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX,TX_OSAL_DBG, DBG_LVL_ALL,"After reply_to_arp_request \n");
 113
 114                         }
 115                         else
 116                         {
 117                 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL,
 118                         "Invalid queue index, dropping pkt\n");
 119
 120                                 bcm_kfree_skb(skb);
 121                         }
 122                         return STATUS_SUCCESS;
 123         }
 124
 125                 if(Adapter->PackInfo[qindex].uiCurrentPacketsOnHost >= SF_MAX_ALLOWED_PACKETS_TO_BACKUP)
 126                 {
 127                         atomic_inc(&Adapter->TxDroppedPacketCount);
 128                         bcm_kfree_skb(skb);
 129                         return STATUS_SUCCESS;
 130                 }
 131
 132                 /* Now Enqueue the packet */
 133                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "bcm_transmit Enqueueing the Packet To Queue %d",qindex);
 134                 spin_lock(&Adapter->PackInfo[qindex].SFQueueLock);
 135                 Adapter->PackInfo[qindex].uiCurrentBytesOnHost += skb->len;
 136                 Adapter->PackInfo[qindex].uiCurrentPacketsOnHost++;
 137
 138                 *((B_UINT32 *)skb->cb + SKB_CB_LATENCY_OFFSET ) = jiffies;
 139                 ENQUEUEPACKET(Adapter->PackInfo[qindex].FirstTxQueue,
 140                           Adapter->PackInfo[qindex].LastTxQueue, skb);
 141                 atomic_inc(&Adapter->TotalPacketCount);
 142                 spin_unlock(&Adapter->PackInfo[qindex].SFQueueLock);
 143                 do_gettimeofday(&tv);
 144
 145                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL,"ENQ: \n");
 146                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "Pkt Len = %d, sec: %ld, usec: %ld\n",
 147                 (skb->len-ETH_HLEN), tv.tv_sec, tv.tv_usec);
 148
 149                 if(calltransmit == 1)
 150                         transmit_packets(Adapter);
 151                 else
 152                 {
 153                         if(!atomic_read(&Adapter->TxPktAvail))
 154                         {
 155                                 atomic_set(&Adapter->TxPktAvail, 1);
 156                                 wake_up(&Adapter->tx_packet_wait_queue);
 157                         }
 158                 }
 159                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "<====");
 160         }
 161         else
 162                 bcm_kfree_skb(skb);
 163
 164   return STATUS_SUCCESS;
 165 }
 166
 167
 168 /**
 169 @ingroup ctrl_pkt_functions
 170 This function dispatches control packet to the h/w interface
 171 @return zero(success) or -ve value(failure)
 172 */
 173 INT SendControlPacket(PMINI_ADAPTER Adapter, /**<Logical Adapter*/
 174                                                         char *pControlPacket/**<Control Packet*/
 175                                                         )
 176 {
 177         PLEADER PLeader = NULL;
 178         struct timeval tv;
 179         memset(&tv, 0, sizeof(tv));
 180
 181
 182
 183         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "========>");
 184
 185         PLeader=(PLEADER)pControlPacket;
 186         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Tx");
 187         if(!pControlPacket || !Adapter)
 188         {
 189                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Got NULL Control Packet or Adapter");
 190                 return STATUS_FAILURE;
 191         }
 192         if((atomic_read( &Adapter->CurrNumFreeTxDesc ) <
 193                 ((PLeader->PLength-1)/MAX_DEVICE_DESC_SIZE)+1))
 194     {
 195         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "NO FREE DESCRIPTORS TO SEND CONTROL PACKET");
 196         if(Adapter->bcm_jiffies == 0)
 197         {
 198                 Adapter->bcm_jiffies = jiffies;
 199             BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "UPDATED TIME(hex): %lu",
 200                                 Adapter->bcm_jiffies);
 201         }
 202         return STATUS_FAILURE;
 203     }
 204
 205         /* Update the netdevice statistics */
 206         /* Dump Packet  */
 207         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Leader Status: %x", PLeader->Status);
 208         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Leader VCID: %x",PLeader->Vcid);
 209         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "Leader Length: %x",PLeader->PLength);
 210         if(Adapter->device_removed)
 211                 return 0;
 212         Adapter->interface_transmit(Adapter->pvInterfaceAdapter,
 213                                         pControlPacket, (PLeader->PLength + LEADER_SIZE));
 214
 215         ((PLINUX_DEP_DATA)Adapter->pvOsDepData)->netstats.tx_packets++;
 216         ((PLINUX_DEP_DATA)Adapter->pvOsDepData)->netstats.tx_bytes+=
 217                         PLeader->PLength;
 218         atomic_dec(&Adapter->CurrNumFreeTxDesc);
 219         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_CONTROL, DBG_LVL_ALL, "<=========");
 220         return STATUS_SUCCESS;
 221 }
 222 static  LEADER Leader={0};
 223 /**
 224 @ingroup tx_functions
 225 This function despatches the IP packets with the given vcid
 226 to the target via the host h/w interface.
 227 @return  zero(success) or -ve value(failure)
 228 */
 229 INT SetupNextSend(PMINI_ADAPTER Adapter, /**<Logical Adapter*/
 230                                         struct sk_buff *Packet, /**<data buffer*/
 231                                         USHORT Vcid)                    /**<VCID for this packet*/
 232 {
 233         int             status=0;
 234         BOOLEAN bHeaderSupressionEnabled = FALSE;
 235         B_UINT16            uiClassifierRuleID;
 236         int QueueIndex = NO_OF_QUEUES + 1;
 237
 238         if(!Adapter || !Packet)
 239         {
 240                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "Got NULL Adapter or Packet");
 241                 return -EINVAL;
 242         }
 243         if(Packet->len > MAX_DEVICE_DESC_SIZE)
 244         {
 245                 status = STATUS_FAILURE;
 246                 goto errExit;
 247         }
 248
 249         /* Get the Classifier Rule ID */
 250         uiClassifierRuleID = *((UINT32*) (Packet->cb)+SKB_CB_CLASSIFICATION_OFFSET);
 251         QueueIndex = SearchVcid( Adapter,Vcid);
 252         if(QueueIndex < NO_OF_QUEUES)
 253         {
 254                 bHeaderSupressionEnabled =
 255                         Adapter->PackInfo[QueueIndex].bHeaderSuppressionEnabled;
 256                 bHeaderSupressionEnabled =
 257                         bHeaderSupressionEnabled & Adapter->bPHSEnabled;
 258         }
 259         if(Adapter->device_removed)
 260                 {
 261                 status = STATUS_FAILURE;
 262                 goto errExit;
 263                 }
 264
 265         status = PHSTransmit(Adapter, &Packet, Vcid, uiClassifierRuleID, bHeaderSupressionEnabled,
 266                                                         (UINT *)&Packet->len, Adapter->PackInfo[QueueIndex].bEthCSSupport);
 267
 268         if(status != STATUS_SUCCESS)
 269         {
 270                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "PHS Transmit failed..\n");
 271                 goto errExit;
 272         }
 273
 274         Leader.Vcid     = Vcid;
 275
 276     if(TCP_ACK == *((UINT32*) (Packet->cb) + SKB_CB_TCPACK_OFFSET ))
 277         {
 278         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "Sending TCP ACK\n");
 279                 Leader.Status = LEADER_STATUS_TCP_ACK;
 280         }
 281         else
 282         {
 283                 Leader.Status = LEADER_STATUS;
 284         }
 285
 286         if(Adapter->PackInfo[QueueIndex].bEthCSSupport)
 287         {
 288                 Leader.PLength = Packet->len;
 289                 if(skb_headroom(Packet) < LEADER_SIZE)
 290         {
 291                         if((status = skb_cow(Packet,LEADER_SIZE)))
 292                         {
 293                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL,"bcm_transmit : Failed To Increase headRoom\n");
 294                                 goto errExit;
 295                         }
 296                 }
 297                 skb_push(Packet, LEADER_SIZE);
 298                 memcpy(Packet->data, &Leader, LEADER_SIZE);
 299         }
 300
 301         else
 302         {
 303                 Leader.PLength = Packet->len - ETH_HLEN;
 304                 memcpy((LEADER*)skb_pull(Packet, (ETH_HLEN - LEADER_SIZE)), &Leader, LEADER_SIZE);
 305         }
 306
 307         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "Packet->len = %d", Packet->len);
 308         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "Vcid = %d", Vcid);
 309
 310         status = Adapter->interface_transmit(Adapter->pvInterfaceAdapter,
 311                         Packet->data, (Leader.PLength + LEADER_SIZE));
 312         if(status)
 313         {
 314                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "Tx Failed..\n");
 315         }
 316         else
 317         {
 318                 Adapter->PackInfo[QueueIndex].uiTotalTxBytes += Leader.PLength;
 319                 atomic_add(Leader.PLength, &Adapter->GoodTxByteCount);
 320                 atomic_inc(&Adapter->TxTotalPacketCount);
 321         }
 322
 323         atomic_dec(&Adapter->CurrNumFreeTxDesc);
 324
 325 errExit:
 326
 327         if(STATUS_SUCCESS == status)
 328         {
 329                 Adapter->PackInfo[QueueIndex].uiCurrentTokenCount -= Leader.PLength << 3;
 330                 Adapter->PackInfo[QueueIndex].uiSentBytes += (Packet->len);
 331                 Adapter->PackInfo[QueueIndex].uiSentPackets++;
 332                 Adapter->PackInfo[QueueIndex].NumOfPacketsSent++;
 333
 334                 atomic_dec(&Adapter->PackInfo[QueueIndex].uiPerSFTxResourceCount);
 335                 Adapter->PackInfo[QueueIndex].uiThisPeriodSentBytes += Leader.PLength;
 336         }
 337
 338
 339         bcm_kfree_skb(Packet);
 340         return status;
 341 }
 342
 343 /**
 344 @ingroup tx_functions
 345 Transmit thread
 346 */
 347 int tx_pkt_handler(PMINI_ADAPTER Adapter  /**< pointer to adapter object*/
 348                                 )
 349 {
 350         int status = 0;
 351
 352         UINT calltransmit = 1;
 353         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Entring to wait for signal from the interrupt service thread!Adapter = %p",Adapter);
 354
 355
 356         while(1)
 357         {
 358                 if(Adapter->LinkUpStatus){
 359                         wait_event_timeout(Adapter->tx_packet_wait_queue,
 360                                 ((atomic_read(&Adapter->TxPktAvail) &&
 361                                 (MINIMUM_PENDING_DESCRIPTORS <
 362                                 atomic_read(&Adapter->CurrNumFreeTxDesc)) &&
 363                                 (Adapter->device_removed == FALSE))) ||
 364                                 (1 == Adapter->downloadDDR) || kthread_should_stop()
 365                                 || (TRUE == Adapter->bEndPointHalted)
 366                                 , msecs_to_jiffies(10));
 367                 }
 368                 else{
 369                         wait_event(Adapter->tx_packet_wait_queue,
 370                                 ((atomic_read(&Adapter->TxPktAvail) &&
 371                                 (MINIMUM_PENDING_DESCRIPTORS <
 372                                 atomic_read(&Adapter->CurrNumFreeTxDesc)) &&
 373                                 (Adapter->device_removed == FALSE))) ||
 374                                 (1 == Adapter->downloadDDR) || kthread_should_stop()
 375                                 || (TRUE == Adapter->bEndPointHalted)
 376                                 );
 377                 }
 378
 379                 if(kthread_should_stop() || Adapter->device_removed)
 380                 {
 381                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Exiting the tx thread..\n");
 382                         Adapter->transmit_packet_thread = NULL;
 383                         return 0;
 384                 }
 385
 386
 387                 if(Adapter->downloadDDR == 1)
 388                 {
 389                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Downloading DDR Settings\n");
 390                         Adapter->downloadDDR +=1;
 391                         status = download_ddr_settings(Adapter);
 392                         if(status)
 393                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "DDR DOWNLOAD FAILED!\n");
 394                         continue;
 395                 }
 396
 397                 //Check end point for halt/stall.
 398                 if(Adapter->bEndPointHalted == TRUE)
 399                 {
 400                         Bcm_clear_halt_of_endpoints(Adapter);
 401                         Adapter->bEndPointHalted = FALSE;
 402                         StartInterruptUrb((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
 403                 }
 404
 405                 if(Adapter->LinkUpStatus && !Adapter->IdleMode)
 406                 {
 407                         if(atomic_read(&Adapter->TotalPacketCount))
 408                         {
 409                                 update_per_sf_desc_cnts(Adapter);
 410                         }
 411                 }
 412
 413                 if( atomic_read(&Adapter->CurrNumFreeTxDesc) &&
 414                         Adapter->LinkStatus == SYNC_UP_REQUEST &&
 415                         !Adapter->bSyncUpRequestSent)
 416                 {
 417                         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Calling LinkMessage");
 418                         LinkMessage(Adapter);
 419                 }
 420
 421                 if((Adapter->IdleMode || Adapter->bShutStatus) && atomic_read(&Adapter->TotalPacketCount))
 422                 {
 423                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Device in Low Power mode...waking up");
 424                         Adapter->usIdleModePattern = ABORT_IDLE_MODE;
 425                                 Adapter->bWakeUpDevice = TRUE;
 426                                 wake_up(&Adapter->process_rx_cntrlpkt);
 427                 }
 428
 429
 430                 if(calltransmit)
 431                         transmit_packets(Adapter);
 432
 433                 atomic_set(&Adapter->TxPktAvail, 0);
 434         }
 435         return 0;
 436 }
 437
 438
 439