linux/arch/tile/include/hv/drv_xgbe_intf.h
<<
>>
Prefs
   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 */
  30typedef 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}
  43netio_ipp_address_t;
  44
  45/** The various pread/pwrite offsets into the hypervisor-level driver.
  46 * @ingroup types
  47 */
  48typedef 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 */
 141typedef 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 */
 157typedef 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. */
 170typedef 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 */
 178int __netio_fastio0(uint32_t fastio_index);
 179/** 1-argument fast I/O call */
 180int __netio_fastio1(uint32_t fastio_index, uint32_t arg0);
 181/** 3-argument fast I/O call, 2-word return value */
 182netio_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 */
 185int __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 */
 188int __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 */
 191int __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 */
 246typedef 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. */
 335typedef 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. */
 389typedef 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. */
 405typedef 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. */
 456typedef 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_DEFAULT_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. */
 493typedef 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 */
 562static 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. */
 575static inline unsigned int
 576lepp_num_free_comp_slots(const lepp_queue_t* q)
 577{
 578  return _lepp_num_free_slots(q->comp_head, q->comp_tail);
 579}
 580
 581static inline int
 582lepp_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__ */
 616