arch/tile/include/hv/drv_xgbe_intf.h

   1 /*
   2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
   3  *
   4  *   This program is free software; you can redistribute it and/or
   5  *   modify it under the terms of the GNU General Public License
   6  *   as published by the Free Software Foundation, version 2.
   7  *
   8  *   This program is distributed in the hope that it will be useful, but
   9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  *   NON INFRINGEMENT.  See the GNU General Public License for
  12  *   more details.
  13  */
  14
  15 /**
  16  * @file drv_xgbe_intf.h
  17  * Interface to the hypervisor XGBE driver.
  18  */
  19
  20 #ifndef __DRV_XGBE_INTF_H__
  21 #define __DRV_XGBE_INTF_H__
  22
  23 /**
  24  * An object for forwarding VAs and PAs to the hypervisor.
  25  * @ingroup types
  26  *
  27  * This allows the supervisor to specify a number of areas of memory to
  28  * store packet buffers.
  29  */
  30 typedef struct
  31 {
  32   /** The physical address of the memory. */
  33   HV_PhysAddr pa;
  34   /** Page table entry for the memory.  This is only used to derive the
  35    *  memory's caching mode; the PA bits are ignored. */
  36   HV_PTE pte;
  37   /** The virtual address of the memory. */
  38   HV_VirtAddr va;
  39   /** Size (in bytes) of the memory area. */
  40   int size;
  41
  42 }
  43 netio_ipp_address_t;
  44
  45 /** The various pread/pwrite offsets into the hypervisor-level driver.
  46  * @ingroup types
  47  */
  48 typedef enum
  49 {
  50   /** Inform the Linux driver of the address of the NetIO arena memory.
  51    *  This offset is actually only used to convey information from netio
  52    *  to the Linux driver; it never makes it from there to the hypervisor.
  53    *  Write-only; takes a uint32_t specifying the VA address. */
  54   NETIO_FIXED_ADDR               = 0x5000000000000000ULL,
  55
  56   /** Inform the Linux driver of the size of the NetIO arena memory.
  57    *  This offset is actually only used to convey information from netio
  58    *  to the Linux driver; it never makes it from there to the hypervisor.
  59    *  Write-only; takes a uint32_t specifying the VA size. */
  60   NETIO_FIXED_SIZE               = 0x5100000000000000ULL,
  61
  62   /** Register current tile with IPP.  Write then read: write, takes a
  63    *  netio_input_config_t, read returns a pointer to a netio_queue_impl_t. */
  64   NETIO_IPP_INPUT_REGISTER_OFF   = 0x6000000000000000ULL,
  65
  66   /** Unregister current tile from IPP.  Write-only, takes a dummy argument. */
  67   NETIO_IPP_INPUT_UNREGISTER_OFF = 0x6100000000000000ULL,
  68
  69   /** Start packets flowing.  Write-only, takes a dummy argument. */
  70   NETIO_IPP_INPUT_INIT_OFF       = 0x6200000000000000ULL,
  71
  72   /** Stop packets flowing.  Write-only, takes a dummy argument. */
  73   NETIO_IPP_INPUT_UNINIT_OFF     = 0x6300000000000000ULL,
  74
  75   /** Configure group (typically we group on VLAN).  Write-only: takes an
  76    *  array of netio_group_t's, low 24 bits of the offset is the base group
  77    *  number times the size of a netio_group_t. */
  78   NETIO_IPP_INPUT_GROUP_CFG_OFF  = 0x6400000000000000ULL,
  79
  80   /** Configure bucket.  Write-only: takes an array of netio_bucket_t's, low
  81    *  24 bits of the offset is the base bucket number times the size of a
  82    *  netio_bucket_t. */
  83   NETIO_IPP_INPUT_BUCKET_CFG_OFF = 0x6500000000000000ULL,
  84
  85   /** Get/set a parameter.  Read or write: read or write data is the parameter
  86    *  value, low 32 bits of the offset is a __netio_getset_offset_t. */
  87   NETIO_IPP_PARAM_OFF            = 0x6600000000000000ULL,
  88
  89   /** Get fast I/O index.  Read-only; returns a 4-byte base index value. */
  90   NETIO_IPP_GET_FASTIO_OFF       = 0x6700000000000000ULL,
  91
  92   /** Configure hijack IP address.  Packets with this IPv4 dest address
  93    *  go to bucket NETIO_NUM_BUCKETS - 1.  Write-only: takes an IP address
  94    *  in some standard form.  FIXME: Define the form! */
  95   NETIO_IPP_INPUT_HIJACK_CFG_OFF  = 0x6800000000000000ULL,
  96
  97   /**
  98    * Offsets beyond this point are reserved for the supervisor (although that
  99    * enforcement must be done by the supervisor driver itself).
 100    */
 101   NETIO_IPP_USER_MAX_OFF         = 0x6FFFFFFFFFFFFFFFULL,
 102
 103   /** Register I/O memory.  Write-only, takes a netio_ipp_address_t. */
 104   NETIO_IPP_IOMEM_REGISTER_OFF   = 0x7000000000000000ULL,
 105
 106   /** Unregister I/O memory.  Write-only, takes a netio_ipp_address_t. */
 107   NETIO_IPP_IOMEM_UNREGISTER_OFF = 0x7100000000000000ULL,
 108
 109   /* Offsets greater than 0x7FFFFFFF can't be used directly from Linux
 110    * userspace code due to limitations in the pread/pwrite syscalls. */
 111
 112   /** Drain LIPP buffers. */
 113   NETIO_IPP_DRAIN_OFF              = 0xFA00000000000000ULL,
 114
 115   /** Supply a netio_ipp_address_t to be used as shared memory for the
 116    *  LEPP command queue. */
 117   NETIO_EPP_SHM_OFF              = 0xFB00000000000000ULL,
 118
 119   /* 0xFC... is currently unused. */
 120
 121   /** Stop IPP/EPP tiles.  Write-only, takes a dummy argument.  */
 122   NETIO_IPP_STOP_SHIM_OFF        = 0xFD00000000000000ULL,
 123
 124   /** Start IPP/EPP tiles.  Write-only, takes a dummy argument.  */
 125   NETIO_IPP_START_SHIM_OFF       = 0xFE00000000000000ULL,
 126
 127   /** Supply packet arena.  Write-only, takes an array of
 128     * netio_ipp_address_t values. */
 129   NETIO_IPP_ADDRESS_OFF          = 0xFF00000000000000ULL,
 130 } netio_hv_offset_t;
 131
 132 /** Extract the base offset from an offset */
 133 #define NETIO_BASE_OFFSET(off)    ((off) & 0xFF00000000000000ULL)
 134 /** Extract the local offset from an offset */
 135 #define NETIO_LOCAL_OFFSET(off)   ((off) & 0x00FFFFFFFFFFFFFFULL)
 136
 137
 138 /**
 139  * Get/set offset.
 140  */
 141 typedef union
 142 {
 143   struct
 144   {
 145     uint64_t addr:48;        /**< Class-specific address */
 146     unsigned int class:8;    /**< Class (e.g., NETIO_PARAM) */
 147     unsigned int opcode:8;   /**< High 8 bits of NETIO_IPP_PARAM_OFF */
 148   }
 149   bits;                      /**< Bitfields */
 150   uint64_t word;             /**< Aggregated value to use as the offset */
 151 }
 152 __netio_getset_offset_t;
 153
 154 /**
 155  * Fast I/O index offsets (must be contiguous).
 156  */
 157 typedef enum
 158 {
 159   NETIO_FASTIO_ALLOCATE         = 0, /**< Get empty packet buffer */
 160   NETIO_FASTIO_FREE_BUFFER      = 1, /**< Give buffer back to IPP */
 161   NETIO_FASTIO_RETURN_CREDITS   = 2, /**< Give credits to IPP */
 162   NETIO_FASTIO_SEND_PKT_NOCK    = 3, /**< Send a packet, no checksum */
 163   NETIO_FASTIO_SEND_PKT_CK      = 4, /**< Send a packet, with checksum */
 164   NETIO_FASTIO_SEND_PKT_VEC     = 5, /**< Send a vector of packets */
 165   NETIO_FASTIO_SENDV_PKT        = 6, /**< Sendv one packet */
 166   NETIO_FASTIO_NUM_INDEX        = 7, /**< Total number of fast I/O indices */
 167 } netio_fastio_index_t;
 168
 169 /** 3-word return type for Fast I/O call. */
 170 typedef struct
 171 {
 172   int err;            /**< Error code. */
 173   uint32_t val0;      /**< Value.  Meaning depends upon the specific call. */
 174   uint32_t val1;      /**< Value.  Meaning depends upon the specific call. */
 175 } netio_fastio_rv3_t;
 176
 177 /** 0-argument fast I/O call */
 178 int __netio_fastio0(uint32_t fastio_index);
 179 /** 1-argument fast I/O call */
 180 int __netio_fastio1(uint32_t fastio_index, uint32_t arg0);
 181 /** 3-argument fast I/O call, 2-word return value */
 182 netio_fastio_rv3_t __netio_fastio3_rv3(uint32_t fastio_index, uint32_t arg0,
 183                                        uint32_t arg1, uint32_t arg2);
 184 /** 4-argument fast I/O call */
 185 int __netio_fastio4(uint32_t fastio_index, uint32_t arg0, uint32_t arg1,
 186                     uint32_t arg2, uint32_t arg3);
 187 /** 6-argument fast I/O call */
 188 int __netio_fastio6(uint32_t fastio_index, uint32_t arg0, uint32_t arg1,
 189                     uint32_t arg2, uint32_t arg3, uint32_t arg4, uint32_t arg5);
 190 /** 9-argument fast I/O call */
 191 int __netio_fastio9(uint32_t fastio_index, uint32_t arg0, uint32_t arg1,
 192                     uint32_t arg2, uint32_t arg3, uint32_t arg4, uint32_t arg5,
 193                     uint32_t arg6, uint32_t arg7, uint32_t arg8);
 194
 195 /** Allocate an empty packet.
 196  * @param fastio_index Fast I/O index.
 197  * @param size Size of the packet to allocate.
 198  */
 199 #define __netio_fastio_allocate(fastio_index, size) \
 200   __netio_fastio1((fastio_index) + NETIO_FASTIO_ALLOCATE, size)
 201
 202 /** Free a buffer.
 203  * @param fastio_index Fast I/O index.
 204  * @param handle Handle for the packet to free.
 205  */
 206 #define __netio_fastio_free_buffer(fastio_index, handle) \
 207   __netio_fastio1((fastio_index) + NETIO_FASTIO_FREE_BUFFER, handle)
 208
 209 /** Increment our receive credits.
 210  * @param fastio_index Fast I/O index.
 211  * @param credits Number of credits to add.
 212  */
 213 #define __netio_fastio_return_credits(fastio_index, credits) \
 214   __netio_fastio1((fastio_index) + NETIO_FASTIO_RETURN_CREDITS, credits)
 215
 216 /** Send packet, no checksum.
 217  * @param fastio_index Fast I/O index.
 218  * @param ackflag Nonzero if we want an ack.
 219  * @param size Size of the packet.
 220  * @param va Virtual address of start of packet.
 221  * @param handle Packet handle.
 222  */
 223 #define __netio_fastio_send_pkt_nock(fastio_index, ackflag, size, va, handle) \
 224   __netio_fastio4((fastio_index) + NETIO_FASTIO_SEND_PKT_NOCK, ackflag, \
 225                   size, va, handle)
 226
 227 /** Send packet, calculate checksum.
 228  * @param fastio_index Fast I/O index.
 229  * @param ackflag Nonzero if we want an ack.
 230  * @param size Size of the packet.
 231  * @param va Virtual address of start of packet.
 232  * @param handle Packet handle.
 233  * @param csum0 Shim checksum header.
 234  * @param csum1 Checksum seed.
 235  */
 236 #define __netio_fastio_send_pkt_ck(fastio_index, ackflag, size, va, handle, \
 237                                    csum0, csum1) \
 238   __netio_fastio6((fastio_index) + NETIO_FASTIO_SEND_PKT_CK, ackflag, \
 239                   size, va, handle, csum0, csum1)
 240
 241
 242 /** Format for the "csum0" argument to the __netio_fastio_send routines
 243  * and LEPP.  Note that this is currently exactly identical to the
 244  * ShimProtocolOffloadHeader.
 245  */
 246 typedef union
 247 {
 248   struct
 249   {
 250     unsigned int start_byte:7;       /**< The first byte to be checksummed */
 251     unsigned int count:14;           /**< Number of bytes to be checksummed. */
 252     unsigned int destination_byte:7; /**< The byte to write the checksum to. */
 253     unsigned int reserved:4;         /**< Reserved. */
 254   } bits;                            /**< Decomposed method of access. */
 255   unsigned int word;                 /**< To send out the IDN. */
 256 } __netio_checksum_header_t;
 257
 258
 259 /** Sendv packet with 1 or 2 segments.
 260  * @param fastio_index Fast I/O index.
 261  * @param flags Ack/csum/notify flags in low 3 bits; number of segments minus
 262  *        1 in next 2 bits; expected checksum in high 16 bits.
 263  * @param confno Confirmation number to request, if notify flag set.
 264  * @param csum0 Checksum descriptor; if zero, no checksum.
 265  * @param va_F Virtual address of first segment.
 266  * @param va_L Virtual address of last segment, if 2 segments.
 267  * @param len_F_L Length of first segment in low 16 bits; length of last
 268  *        segment, if 2 segments, in high 16 bits.
 269  */
 270 #define __netio_fastio_sendv_pkt_1_2(fastio_index, flags, confno, csum0, \
 271                                      va_F, va_L, len_F_L) \
 272   __netio_fastio6((fastio_index) + NETIO_FASTIO_SENDV_PKT, flags, confno, \
 273                   csum0, va_F, va_L, len_F_L)
 274
 275 /** Send packet on PCIe interface.
 276  * @param fastio_index Fast I/O index.
 277  * @param flags Ack/csum/notify flags in low 3 bits.
 278  * @param confno Confirmation number to request, if notify flag set.
 279  * @param csum0 Checksum descriptor; Hard wired 0, not needed for PCIe.
 280  * @param va_F Virtual address of the packet buffer.
 281  * @param va_L Virtual address of last segment, if 2 segments. Hard wired 0.
 282  * @param len_F_L Length of the packet buffer in low 16 bits.
 283  */
 284 #define __netio_fastio_send_pcie_pkt(fastio_index, flags, confno, csum0, \
 285                                      va_F, va_L, len_F_L) \
 286   __netio_fastio6((fastio_index) + PCIE_FASTIO_SENDV_PKT, flags, confno, \
 287                   csum0, va_F, va_L, len_F_L)
 288
 289 /** Sendv packet with 3 or 4 segments.
 290  * @param fastio_index Fast I/O index.
 291  * @param flags Ack/csum/notify flags in low 3 bits; number of segments minus
 292  *        1 in next 2 bits; expected checksum in high 16 bits.
 293  * @param confno Confirmation number to request, if notify flag set.
 294  * @param csum0 Checksum descriptor; if zero, no checksum.
 295  * @param va_F Virtual address of first segment.
 296  * @param va_L Virtual address of last segment (third segment if 3 segments,
 297  *        fourth segment if 4 segments).
 298  * @param len_F_L Length of first segment in low 16 bits; length of last
 299  *        segment in high 16 bits.
 300  * @param va_M0 Virtual address of "middle 0" segment; this segment is sent
 301  *        second when there are three segments, and third if there are four.
 302  * @param va_M1 Virtual address of "middle 1" segment; this segment is sent
 303  *        second when there are four segments.
 304  * @param len_M0_M1 Length of middle 0 segment in low 16 bits; length of middle
 305  *        1 segment, if 4 segments, in high 16 bits.
 306  */
 307 #define __netio_fastio_sendv_pkt_3_4(fastio_index, flags, confno, csum0, va_F, \
 308                                      va_L, len_F_L, va_M0, va_M1, len_M0_M1) \
 309   __netio_fastio9((fastio_index) + NETIO_FASTIO_SENDV_PKT, flags, confno, \
 310                   csum0, va_F, va_L, len_F_L, va_M0, va_M1, len_M0_M1)
 311
 312 /** Send vector of packets.
 313  * @param fastio_index Fast I/O index.
 314  * @param seqno Number of packets transmitted so far on this interface;
 315  *        used to decide which packets should be acknowledged.
 316  * @param nentries Number of entries in vector.
 317  * @param va Virtual address of start of vector entry array.
 318  * @return 3-word netio_fastio_rv3_t structure.  The structure's err member
 319  *         is an error code, or zero if no error.  The val0 member is the
 320  *         updated value of seqno; it has been incremented by 1 for each
 321  *         packet sent.  That increment may be less than nentries if an
 322  *         error occurred, or if some of the entries in the vector contain
 323  *         handles equal to NETIO_PKT_HANDLE_NONE.  The val1 member is the
 324  *         updated value of nentries; it has been decremented by 1 for each
 325  *         vector entry processed.  Again, that decrement may be less than
 326  *         nentries (leaving the returned value positive) if an error
 327  *         occurred.
 328  */
 329 #define __netio_fastio_send_pkt_vec(fastio_index, seqno, nentries, va) \
 330   __netio_fastio3_rv3((fastio_index) + NETIO_FASTIO_SEND_PKT_VEC, seqno, \
 331                       nentries, va)
 332
 333
 334 /** An egress DMA command for LEPP. */
 335 typedef struct
 336 {
 337   /** Is this a TSO transfer?
 338    *
 339    * NOTE: This field is always 0, to distinguish it from
 340    * lepp_tso_cmd_t.  It must come first!
 341    */
 342   uint8_t tso               : 1;
 343
 344   /** Unused padding bits. */
 345   uint8_t _unused           : 3;
 346
 347   /** Should this packet be sent directly from caches instead of DRAM,
 348    * using hash-for-home to locate the packet data?
 349    */
 350   uint8_t hash_for_home     : 1;
 351
 352   /** Should we compute a checksum? */
 353   uint8_t compute_checksum  : 1;
 354
 355   /** Is this the final buffer for this packet?
 356    *
 357    * A single packet can be split over several input buffers (a "gather"
 358    * operation).  This flag indicates that this is the last buffer
 359    * in a packet.
 360    */
 361   uint8_t end_of_packet     : 1;
 362
 363   /** Should LEPP advance 'comp_busy' when this DMA is fully finished? */
 364   uint8_t send_completion   : 1;
 365
 366   /** High bits of Client Physical Address of the start of the buffer
 367    *  to be egressed.
 368    *
 369    *  NOTE: Only 6 bits are actually needed here, as CPAs are
 370    *  currently 38 bits.  So two bits could be scavenged from this.
 371    */
 372   uint8_t cpa_hi;
 373
 374   /** The number of bytes to be egressed. */
 375   uint16_t length;
 376
 377   /** Low 32 bits of Client Physical Address of the start of the buffer
 378    *  to be egressed.
 379    */
 380   uint32_t cpa_lo;
 381
 382   /** Checksum information (only used if 'compute_checksum'). */
 383   __netio_checksum_header_t checksum_data;
 384
 385 } lepp_cmd_t;
 386
 387
 388 /** A chunk of physical memory for a TSO egress. */
 389 typedef struct
 390 {
 391   /** The low bits of the CPA. */
 392   uint32_t cpa_lo;
 393   /** The high bits of the CPA. */
 394   uint16_t cpa_hi               : 15;
 395   /** Should this packet be sent directly from caches instead of DRAM,
 396    *  using hash-for-home to locate the packet data?
 397    */
 398   uint16_t hash_for_home        : 1;
 399   /** The length in bytes. */
 400   uint16_t length;
 401 } lepp_frag_t;
 402
 403
 404 /** An LEPP command that handles TSO. */
 405 typedef struct
 406 {
 407   /** Is this a TSO transfer?
 408    *
 409    *  NOTE: This field is always 1, to distinguish it from
 410    *  lepp_cmd_t.  It must come first!
 411    */
 412   uint8_t tso             : 1;
 413
 414   /** Unused padding bits. */
 415   uint8_t _unused         : 7;
 416
 417   /** Size of the header[] array in bytes.  It must be in the range
 418    *  [40, 127], which are the smallest header for a TCP packet over
 419    *  Ethernet and the maximum possible prepend size supported by
 420    *  hardware, respectively.  Note that the array storage must be
 421    *  padded out to a multiple of four bytes so that the following
 422    *  LEPP command is aligned properly.
 423    */
 424   uint8_t header_size;
 425
 426   /** Byte offset of the IP header in header[]. */
 427   uint8_t ip_offset;
 428
 429   /** Byte offset of the TCP header in header[]. */
 430   uint8_t tcp_offset;
 431
 432   /** The number of bytes to use for the payload of each packet,
 433    *  except of course the last one, which may not have enough bytes.
 434    *  This means that each Ethernet packet except the last will have a
 435    *  size of header_size + payload_size.
 436    */
 437   uint16_t payload_size;
 438
 439   /** The length of the 'frags' array that follows this struct. */
 440   uint16_t num_frags;
 441
 442   /** The actual frags. */
 443   lepp_frag_t frags[0 /* Variable-sized; num_frags entries. */];
 444
 445   /*
 446    * The packet header template logically follows frags[],
 447    * but you can't declare that in C.
 448    *
 449    * uint32_t header[header_size_in_words_rounded_up];
 450    */
 451
 452 } lepp_tso_cmd_t;
 453
 454
 455 /** An LEPP completion ring entry. */
 456 typedef void* lepp_comp_t;
 457
 458
 459 /** Maximum number of frags for one TSO command.  This is adapted from
 460  *  linux's "MAX_SKB_FRAGS", and presumably over-estimates by one, for
 461  *  our page size of exactly 65536.  We add one for a "body" fragment.
 462  */
 463 #define LEPP_MAX_FRAGS (65536 / HV_PAGE_SIZE_SMALL + 2 + 1)
 464
 465 /** Total number of bytes needed for an lepp_tso_cmd_t. */
 466 #define LEPP_TSO_CMD_SIZE(num_frags, header_size) \
 467   (sizeof(lepp_tso_cmd_t) + \
 468    (num_frags) * sizeof(lepp_frag_t) + \
 469    (((header_size) + 3) & -4))
 470
 471 /** The size of the lepp "cmd" queue. */
 472 #define LEPP_CMD_QUEUE_BYTES \
 473  (((CHIP_L2_CACHE_SIZE() - 2 * CHIP_L2_LINE_SIZE()) / \
 474   (sizeof(lepp_cmd_t) + sizeof(lepp_comp_t))) * sizeof(lepp_cmd_t))
 475
 476 /** The largest possible command that can go in lepp_queue_t::cmds[]. */
 477 #define LEPP_MAX_CMD_SIZE LEPP_TSO_CMD_SIZE(LEPP_MAX_FRAGS, 128)
 478
 479 /** The largest possible value of lepp_queue_t::cmd_{head, tail} (inclusive).
 480  */
 481 #define LEPP_CMD_LIMIT \
 482   (LEPP_CMD_QUEUE_BYTES - LEPP_MAX_CMD_SIZE)
 483
 484 /** The maximum number of completions in an LEPP queue. */
 485 #define LEPP_COMP_QUEUE_SIZE \
 486   ((LEPP_CMD_LIMIT + sizeof(lepp_cmd_t) - 1) / sizeof(lepp_cmd_t))
 487
 488 /** Increment an index modulo the queue size. */
 489 #define LEPP_QINC(var) \
 490   (var = __insn_mnz(var - (LEPP_COMP_QUEUE_SIZE - 1), var + 1))
 491
 492 /** A queue used to convey egress commands from the client to LEPP. */
 493 typedef struct
 494 {
 495   /** Index of first completion not yet processed by user code.
 496    *  If this is equal to comp_busy, there are no such completions.
 497    *
 498    *  NOTE: This is only read/written by the user.
 499    */
 500   unsigned int comp_head;
 501
 502   /** Index of first completion record not yet completed.
 503    *  If this is equal to comp_tail, there are no such completions.
 504    *  This index gets advanced (modulo LEPP_QUEUE_SIZE) whenever
 505    *  a command with the 'completion' bit set is finished.
 506    *
 507    *  NOTE: This is only written by LEPP, only read by the user.
 508    */
 509   volatile unsigned int comp_busy;
 510
 511   /** Index of the first empty slot in the completion ring.
 512    *  Entries from this up to but not including comp_head (in ring order)
 513    *  can be filled in with completion data.
 514    *
 515    *  NOTE: This is only read/written by the user.
 516    */
 517   unsigned int comp_tail;
 518
 519   /** Byte index of first command enqueued for LEPP but not yet processed.
 520    *
 521    *  This is always divisible by sizeof(void*) and always <= LEPP_CMD_LIMIT.
 522    *
 523    *  NOTE: LEPP advances this counter as soon as it no longer needs
 524    *  the cmds[] storage for this entry, but the transfer is not actually
 525    *  complete (i.e. the buffer pointed to by the command is no longer
 526    *  needed) until comp_busy advances.
 527    *
 528    *  If this is equal to cmd_tail, the ring is empty.
 529    *
 530    *  NOTE: This is only written by LEPP, only read by the user.
 531    */
 532   volatile unsigned int cmd_head;
 533
 534   /** Byte index of first empty slot in the command ring.  This field can
 535    *  be incremented up to but not equal to cmd_head (because that would
 536    *  mean the ring is empty).
 537    *
 538    *  This is always divisible by sizeof(void*) and always <= LEPP_CMD_LIMIT.
 539    *
 540    *  NOTE: This is read/written by the user, only read by LEPP.
 541    */
 542   volatile unsigned int cmd_tail;
 543
 544   /** A ring of variable-sized egress DMA commands.
 545    *
 546    *  NOTE: Only written by the user, only read by LEPP.
 547    */
 548   char cmds[LEPP_CMD_QUEUE_BYTES]
 549     __attribute__((aligned(CHIP_L2_LINE_SIZE())));
 550
 551   /** A ring of user completion data.
 552    *  NOTE: Only read/written by the user.
 553    */
 554   lepp_comp_t comps[LEPP_COMP_QUEUE_SIZE]
 555     __attribute__((aligned(CHIP_L2_LINE_SIZE())));
 556 } lepp_queue_t;
 557
 558
 559 /** An internal helper function for determining the number of entries
 560  *  available in a ring buffer, given that there is one sentinel.
 561  */
 562 static inline unsigned int
 563 _lepp_num_free_slots(unsigned int head, unsigned int tail)
 564 {
 565   /*
 566    * One entry is reserved for use as a sentinel, to distinguish
 567    * "empty" from "full".  So we compute
 568    * (head - tail - 1) % LEPP_QUEUE_SIZE, but without using a slow % operation.
 569    */
 570   return (head - tail - 1) + ((head <= tail) ? LEPP_COMP_QUEUE_SIZE : 0);
 571 }
 572
 573
 574 /** Returns how many new comp entries can be enqueued. */
 575 static inline unsigned int
 576 lepp_num_free_comp_slots(const lepp_queue_t* q)
 577 {
 578   return _lepp_num_free_slots(q->comp_head, q->comp_tail);
 579 }
 580
 581 static inline int
 582 lepp_qsub(int v1, int v2)
 583 {
 584   int delta = v1 - v2;
 585   return delta + ((delta >> 31) & LEPP_COMP_QUEUE_SIZE);
 586 }
 587
 588
 589 /** FIXME: Check this from linux, via a new "pwrite()" call. */
 590 #define LIPP_VERSION 1
 591
 592
 593 /** We use exactly two bytes of alignment padding. */
 594 #define LIPP_PACKET_PADDING 2
 595
 596 /** The minimum size of a "small" buffer (including the padding). */
 597 #define LIPP_SMALL_PACKET_SIZE 128
 598
 599 /*
 600  * NOTE: The following two values should total to less than around
 601  * 13582, to keep the total size used for "lipp_state_t" below 64K.
 602  */
 603
 604 /** The maximum number of "small" buffers.
 605  *  This is enough for 53 network cpus with 128 credits.  Note that
 606  *  if these are exhausted, we will fall back to using large buffers.
 607  */
 608 #define LIPP_SMALL_BUFFERS 6785
 609
 610 /** The maximum number of "large" buffers.
 611  *  This is enough for 53 network cpus with 128 credits.
 612  */
 613 #define LIPP_LARGE_BUFFERS 6785
 614
 615 #endif /* __DRV_XGBE_INTF_H__ */