Commit | Line | Data |
---|---|---|
e5a06939 CM |
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 | |
25985edc | 322 | * error occurred, or if some of the entries in the vector contain |
e5a06939 CM |
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__ */ |