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
_lepp_num_free_slots(unsigned int head,unsigned int tail)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
lepp_num_free_comp_slots(const lepp_queue_t * q)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
lepp_qsub(int v1,int v2)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__ */
616