1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 * 21 * Copyright (c) 2002-2006 Neterion, Inc. 22 */ 23 24 #ifndef XGE_HAL_RING_H 25 #define XGE_HAL_RING_H 26 27 #include "xgehal-channel.h" 28 #include "xgehal-config.h" 29 #include "xgehal-mm.h" 30 31 __EXTERN_BEGIN_DECLS 32 33 /* HW ring configuration */ 34 #define XGE_HAL_RING_RXDBLOCK_SIZE 0x1000 35 36 #define XGE_HAL_RXD_T_CODE_OK 0x0 37 #define XGE_HAL_RXD_T_CODE_PARITY 0x1 38 #define XGE_HAL_RXD_T_CODE_ABORT 0x2 39 #define XGE_HAL_RXD_T_CODE_PARITY_ABORT 0x3 40 #define XGE_HAL_RXD_T_CODE_RDA_FAILURE 0x4 41 #define XGE_HAL_RXD_T_CODE_UNKNOWN_PROTO 0x5 42 #define XGE_HAL_RXD_T_CODE_BAD_FCS 0x6 43 #define XGE_HAL_RXD_T_CODE_BUFF_SIZE 0x7 44 #define XGE_HAL_RXD_T_CODE_BAD_ECC 0x8 45 #define XGE_HAL_RXD_T_CODE_UNUSED_C 0xC 46 #define XGE_HAL_RXD_T_CODE_UNKNOWN 0xF 47 48 #define XGE_HAL_RING_USE_MTU -1 49 50 /* control_1 and control_2 formatting - same for all buffer modes */ 51 #define XGE_HAL_RXD_GET_L3_CKSUM(control_1) ((u16)(control_1>>16) & 0xFFFF) 52 #define XGE_HAL_RXD_GET_L4_CKSUM(control_1) ((u16)(control_1 & 0xFFFF)) 53 54 #define XGE_HAL_RXD_MASK_VLAN_TAG vBIT(0xFFFF,48,16) 55 #define XGE_HAL_RXD_SET_VLAN_TAG(control_2, val) control_2 |= (u16)val 56 #define XGE_HAL_RXD_GET_VLAN_TAG(control_2) ((u16)(control_2 & 0xFFFF)) 57 58 #define XGE_HAL_RXD_POSTED_4_XFRAME BIT(7) /* control_1 */ 59 #define XGE_HAL_RXD_NOT_COMPLETED BIT(0) /* control_2 */ 60 #define XGE_HAL_RXD_T_CODE (BIT(12)|BIT(13)|BIT(14)|BIT(15)) 61 #define XGE_HAL_RXD_GET_T_CODE(control_1) \ 62 ((control_1 & XGE_HAL_RXD_T_CODE)>>48) 63 #define XGE_HAL_RXD_SET_T_CODE(control_1, val) \ 64 (control_1 |= (((u64)val & 0xF) << 48)) 65 66 #define XGE_HAL_RXD_MASK_FRAME_TYPE vBIT(0x3,25,2) 67 #define XGE_HAL_RXD_MASK_FRAME_PROTO vBIT(0xFFFF,24,8) 68 #define XGE_HAL_RXD_GET_FRAME_TYPE(control_1) \ 69 (u8)(0x3 & ((control_1 & XGE_HAL_RXD_MASK_FRAME_TYPE) >> 37)) 70 #define XGE_HAL_RXD_GET_FRAME_PROTO(control_1) \ 71 (u8)((control_1 & XGE_HAL_RXD_MASK_FRAME_PROTO) >> 32) 72 #define XGE_HAL_RXD_FRAME_PROTO_VLAN_TAGGED BIT(24) 73 #define XGE_HAL_RXD_FRAME_PROTO_IPV4 BIT(27) 74 #define XGE_HAL_RXD_FRAME_PROTO_IPV6 BIT(28) 75 #define XGE_HAL_RXD_FRAME_PROTO_IP_FRAGMENTED BIT(29) 76 #define XGE_HAL_RXD_FRAME_PROTO_TCP BIT(30) 77 #define XGE_HAL_RXD_FRAME_PROTO_UDP BIT(31) 78 #define XGE_HAL_RXD_FRAME_TCP_OR_UDP (XGE_HAL_RXD_FRAME_PROTO_TCP | \ 79 XGE_HAL_RXD_FRAME_PROTO_UDP) 80 81 /** 82 * enum xge_hal_frame_type_e - Ethernet frame format. 83 * @XGE_HAL_FRAME_TYPE_DIX: DIX (Ethernet II) format. 84 * @XGE_HAL_FRAME_TYPE_LLC: LLC format. 85 * @XGE_HAL_FRAME_TYPE_SNAP: SNAP format. 86 * @XGE_HAL_FRAME_TYPE_IPX: IPX format. 87 * 88 * Ethernet frame format. 89 */ 90 typedef enum xge_hal_frame_type_e { 91 XGE_HAL_FRAME_TYPE_DIX = 0x0, 92 XGE_HAL_FRAME_TYPE_LLC = 0x1, 93 XGE_HAL_FRAME_TYPE_SNAP = 0x2, 94 XGE_HAL_FRAME_TYPE_IPX = 0x3, 95 } xge_hal_frame_type_e; 96 97 /** 98 * enum xge_hal_frame_proto_e - Higher-layer ethernet protocols. 99 * @XGE_HAL_FRAME_PROTO_VLAN_TAGGED: VLAN. 100 * @XGE_HAL_FRAME_PROTO_IPV4: IPv4. 101 * @XGE_HAL_FRAME_PROTO_IPV6: IPv6. 102 * @XGE_HAL_FRAME_PROTO_IP_FRAGMENTED: IP fragmented. 103 * @XGE_HAL_FRAME_PROTO_TCP: TCP. 104 * @XGE_HAL_FRAME_PROTO_UDP: UDP. 105 * @XGE_HAL_FRAME_PROTO_TCP_OR_UDP: TCP or UDP. 106 * 107 * Higher layer ethernet protocols and options. 108 */ 109 typedef enum xge_hal_frame_proto_e { 110 XGE_HAL_FRAME_PROTO_VLAN_TAGGED = 0x80, 111 XGE_HAL_FRAME_PROTO_IPV4 = 0x10, 112 XGE_HAL_FRAME_PROTO_IPV6 = 0x08, 113 XGE_HAL_FRAME_PROTO_IP_FRAGMENTED = 0x04, 114 XGE_HAL_FRAME_PROTO_TCP = 0x02, 115 XGE_HAL_FRAME_PROTO_UDP = 0x01, 116 XGE_HAL_FRAME_PROTO_TCP_OR_UDP = (XGE_HAL_FRAME_PROTO_TCP | \ 117 XGE_HAL_FRAME_PROTO_UDP) 118 } xge_hal_frame_proto_e; 119 120 /* 121 * xge_hal_ring_rxd_1_t 122 */ 123 typedef struct { 124 u64 host_control; 125 u64 control_1; 126 u64 control_2; 127 #define XGE_HAL_RXD_1_MASK_BUFFER0_SIZE vBIT(0xFFFF,0,16) 128 #define XGE_HAL_RXD_1_SET_BUFFER0_SIZE(val) vBIT(val,0,16) 129 #define XGE_HAL_RXD_1_GET_BUFFER0_SIZE(Control_2) \ 130 (int)((Control_2 & vBIT(0xFFFF,0,16))>>48) 131 #define XGE_HAL_RXD_1_GET_RTH_VALUE(Control_2) \ 132 (u32)((Control_2 & vBIT(0xFFFFFFFF,16,32))>>16) 133 u64 buffer0_ptr; 134 } xge_hal_ring_rxd_1_t; 135 136 /* 137 * xge_hal_ring_rxd_3_t 138 */ 139 typedef struct { 140 u64 host_control; 141 u64 control_1; 142 143 u64 control_2; 144 #define XGE_HAL_RXD_3_MASK_BUFFER0_SIZE vBIT(0xFF,8,8) 145 #define XGE_HAL_RXD_3_SET_BUFFER0_SIZE(val) vBIT(val,8,8) 146 #define XGE_HAL_RXD_3_MASK_BUFFER1_SIZE vBIT(0xFFFF,16,16) 147 #define XGE_HAL_RXD_3_SET_BUFFER1_SIZE(val) vBIT(val,16,16) 148 #define XGE_HAL_RXD_3_MASK_BUFFER2_SIZE vBIT(0xFFFF,32,16) 149 #define XGE_HAL_RXD_3_SET_BUFFER2_SIZE(val) vBIT(val,32,16) 150 151 152 #define XGE_HAL_RXD_3_GET_BUFFER0_SIZE(Control_2) \ 153 (int)((Control_2 & vBIT(0xFF,8,8))>>48) 154 #define XGE_HAL_RXD_3_GET_BUFFER1_SIZE(Control_2) \ 155 (int)((Control_2 & vBIT(0xFFFF,16,16))>>32) 156 #define XGE_HAL_RXD_3_GET_BUFFER2_SIZE(Control_2) \ 157 (int)((Control_2 & vBIT(0xFFFF,32,16))>>16) 158 159 u64 buffer0_ptr; 160 u64 buffer1_ptr; 161 u64 buffer2_ptr; 162 } xge_hal_ring_rxd_3_t; 163 164 /* 165 * xge_hal_ring_rxd_5_t 166 */ 167 typedef struct { 168 #ifdef XGE_OS_HOST_BIG_ENDIAN 169 u32 host_control; 170 u32 control_3; 171 #else 172 u32 control_3; 173 u32 host_control; 174 #endif 175 176 177 #define XGE_HAL_RXD_5_MASK_BUFFER3_SIZE vBIT(0xFFFF,32,16) 178 #define XGE_HAL_RXD_5_SET_BUFFER3_SIZE(val) vBIT(val,32,16) 179 #define XGE_HAL_RXD_5_MASK_BUFFER4_SIZE vBIT(0xFFFF,48,16) 180 #define XGE_HAL_RXD_5_SET_BUFFER4_SIZE(val) vBIT(val,48,16) 181 182 #define XGE_HAL_RXD_5_GET_BUFFER3_SIZE(Control_3) \ 183 (int)((Control_3 & vBIT(0xFFFF,32,16))>>16) 184 #define XGE_HAL_RXD_5_GET_BUFFER4_SIZE(Control_3) \ 185 (int)((Control_3 & vBIT(0xFFFF,48,16))) 186 187 u64 control_1; 188 u64 control_2; 189 190 #define XGE_HAL_RXD_5_MASK_BUFFER0_SIZE vBIT(0xFFFF,0,16) 191 #define XGE_HAL_RXD_5_SET_BUFFER0_SIZE(val) vBIT(val,0,16) 192 #define XGE_HAL_RXD_5_MASK_BUFFER1_SIZE vBIT(0xFFFF,16,16) 193 #define XGE_HAL_RXD_5_SET_BUFFER1_SIZE(val) vBIT(val,16,16) 194 #define XGE_HAL_RXD_5_MASK_BUFFER2_SIZE vBIT(0xFFFF,32,16) 195 #define XGE_HAL_RXD_5_SET_BUFFER2_SIZE(val) vBIT(val,32,16) 196 197 198 #define XGE_HAL_RXD_5_GET_BUFFER0_SIZE(Control_2) \ 199 (int)((Control_2 & vBIT(0xFFFF,0,16))>>48) 200 #define XGE_HAL_RXD_5_GET_BUFFER1_SIZE(Control_2) \ 201 (int)((Control_2 & vBIT(0xFFFF,16,16))>>32) 202 #define XGE_HAL_RXD_5_GET_BUFFER2_SIZE(Control_2) \ 203 (int)((Control_2 & vBIT(0xFFFF,32,16))>>16) 204 u64 buffer0_ptr; 205 u64 buffer1_ptr; 206 u64 buffer2_ptr; 207 u64 buffer3_ptr; 208 u64 buffer4_ptr; 209 } xge_hal_ring_rxd_5_t; 210 211 #define XGE_HAL_RXD_GET_RTH_SPDM_HIT(Control_1) \ 212 (u8)((Control_1 & BIT(18))>>45) 213 #define XGE_HAL_RXD_GET_RTH_IT_HIT(Control_1) \ 214 (u8)((Control_1 & BIT(19))>>44) 215 #define XGE_HAL_RXD_GET_RTH_HASH_TYPE(Control_1) \ 216 (u8)((Control_1 & vBIT(0xF,20,4))>>40) 217 218 #define XGE_HAL_RXD_HASH_TYPE_NONE 0x0 219 #define XGE_HAL_RXD_HASH_TYPE_TCP_IPV4 0x1 220 #define XGE_HAL_RXD_HASH_TYPE_UDP_IPV4 0x2 221 #define XGE_HAL_RXD_HASH_TYPE_IPV4 0x3 222 #define XGE_HAL_RXD_HASH_TYPE_TCP_IPV6 0x4 223 #define XGE_HAL_RXD_HASH_TYPE_UDP_IPV6 0x5 224 #define XGE_HAL_RXD_HASH_TYPE_IPV6 0x6 225 #define XGE_HAL_RXD_HASH_TYPE_TCP_IPV6_EX 0x7 226 #define XGE_HAL_RXD_HASH_TYPE_UDP_IPV6_EX 0x8 227 #define XGE_HAL_RXD_HASH_TYPE_IPV6_EX 0x9 228 229 typedef u8 xge_hal_ring_block_t[XGE_HAL_RING_RXDBLOCK_SIZE]; 230 231 #define XGE_HAL_RING_NEXT_BLOCK_POINTER_OFFSET 0xFF8 232 #define XGE_HAL_RING_MEMBLOCK_IDX_OFFSET 0xFF0 233 234 #define XGE_HAL_RING_RXD_SIZEOF(n) \ 235 (n==1 ? sizeof(xge_hal_ring_rxd_1_t) : \ 236 (n==3 ? sizeof(xge_hal_ring_rxd_3_t) : \ 237 sizeof(xge_hal_ring_rxd_5_t))) 238 239 #define XGE_HAL_RING_RXDS_PER_BLOCK(n) \ 240 (n==1 ? 127 : (n==3 ? 85 : 63)) 241 242 /** 243 * struct xge_hal_ring_rxd_priv_t - Receive descriptor HAL-private data. 244 * @dma_addr: DMA (mapped) address of _this_ descriptor. 245 * @dma_handle: DMA handle used to map the descriptor onto device. 246 * @dma_offset: Descriptor's offset in the memory block. HAL allocates 247 * descriptors in memory blocks of 248 * %XGE_HAL_RING_RXDBLOCK_SIZE 249 * bytes. Each memblock is contiguous DMA-able memory. Each 250 * memblock contains 1 or more 4KB RxD blocks visible to the 251 * Xframe hardware. 252 * @dma_object: DMA address and handle of the memory block that contains 253 * the descriptor. This member is used only in the "checked" 254 * version of the HAL (to enforce certain assertions); 255 * otherwise it gets compiled out. 256 * @allocated: True if the descriptor is reserved, 0 otherwise. Internal usage. 257 * 258 * Per-receive decsriptor HAL-private data. HAL uses the space to keep DMA 259 * information associated with the descriptor. Note that ULD can ask HAL 260 * to allocate additional per-descriptor space for its own (ULD-specific) 261 * purposes. 262 */ 263 typedef struct xge_hal_ring_rxd_priv_t { 264 dma_addr_t dma_addr; 265 pci_dma_h dma_handle; 266 ptrdiff_t dma_offset; 267 #ifdef XGE_DEBUG_ASSERT 268 xge_hal_mempool_dma_t *dma_object; 269 #endif 270 #ifdef XGE_OS_MEMORY_CHECK 271 int allocated; 272 #endif 273 } xge_hal_ring_rxd_priv_t; 274 275 /** 276 * struct xge_hal_ring_t - Ring channel. 277 * @channel: Channel "base" of this ring, the common part of all HAL 278 * channels. 279 * @buffer_mode: 1, 3, or 5. The value specifies a receive buffer mode, 280 * as per Xframe User Guide. 281 * @indicate_max_pkts: Maximum number of packets processed within a single 282 * interrupt. Can be used to limit the time spent inside hw 283 * interrupt. 284 * @config: Ring configuration, part of device configuration 285 * (see xge_hal_device_config_t{}). 286 * @rxd_size: RxD sizes for 1-, 3- or 5- buffer modes. As per Xframe spec, 287 * 1-buffer mode descriptor is 32 byte long, etc. 288 * @rxd_priv_size: Per RxD size reserved (by HAL) for ULD to keep per-descriptor 289 * data (e.g., DMA handle for Solaris) 290 * @rxds_per_block: Number of descriptors per hardware-defined RxD 291 * block. Depends on the (1-,3-,5-) buffer mode. 292 * @mempool: Memory pool, the pool from which descriptors get allocated. 293 * (See xge_hal_mm.h). 294 * @rxdblock_priv_size: Reserved at the end of each RxD block. HAL internal 295 * usage. Not to confuse with @rxd_priv_size. 296 * @reserved_rxds_arr: Array of RxD pointers. At any point in time each 297 * entry in this array is available for allocation 298 * (via xge_hal_ring_dtr_reserve()) and posting. 299 * @cmpl_cnt: Completion counter. Is reset to zero upon entering the ISR. 300 * Used in conjunction with @indicate_max_pkts. 301 * Ring channel. 302 * 303 * Note: The structure is cache line aligned to better utilize 304 * CPU cache performance. 305 */ 306 typedef struct xge_hal_ring_t { 307 xge_hal_channel_t channel; 308 int buffer_mode; 309 int indicate_max_pkts; 310 xge_hal_ring_config_t *config; 311 int rxd_size; 312 int rxd_priv_size; 313 int rxds_per_block; 314 xge_hal_mempool_t *mempool; 315 int rxdblock_priv_size; 316 void **reserved_rxds_arr; 317 int cmpl_cnt; 318 } __xge_os_attr_cacheline_aligned xge_hal_ring_t; 319 320 /** 321 * struct xge_hal_dtr_info_t - Extended information associated with a 322 * completed ring descriptor. 323 * @l3_cksum: Result of IP checksum check (by Xframe hardware). 324 * This field containing XGE_HAL_L3_CKSUM_OK would mean that 325 * the checksum is correct, otherwise - the datagram is 326 * corrupted. 327 * @l4_cksum: Result of TCP/UDP checksum check (by Xframe hardware). 328 * This field containing XGE_HAL_L4_CKSUM_OK would mean that 329 * the checksum is correct. Otherwise - the packet is 330 * corrupted. 331 * @frame: See xge_hal_frame_type_e{}. 332 * @proto: Reporting bits for various higher-layer protocols, including (but 333 * note restricted to) TCP and UDP. See xge_hal_frame_proto_e{}. 334 * @vlan: VLAN tag extracted from the received frame. 335 * @rth_value: Receive Traffic Hashing(RTH) hash value. Produced by Xframe II 336 * hardware if RTH is enabled. 337 * @rth_it_hit: Set, If RTH hash value calculated by the Xframe II hardware 338 * has a matching entry in the Indirection table. 339 * @rth_spdm_hit: Set, If RTH hash value calculated by the Xframe II hardware 340 * has a matching entry in the Socket Pair Direct Match table. 341 * @rth_hash_type: RTH hash code of the function used to calculate the hash. 342 * @reserved_pad: Unused byte. 343 */ 344 typedef struct xge_hal_dtr_info_t { 345 int l3_cksum; 346 int l4_cksum; 347 int frame; /* zero or more of xge_hal_frame_type_e flags */ 348 int proto; /* zero or more of xge_hal_frame_proto_e flags */ 349 int vlan; 350 u32 rth_value; 351 u8 rth_it_hit; 352 u8 rth_spdm_hit; 353 u8 rth_hash_type; 354 u8 reserved_pad; 355 } xge_hal_dtr_info_t; 356 357 /* ========================== RING PRIVATE API ============================ */ 358 359 xge_hal_status_e __hal_ring_open(xge_hal_channel_h channelh, 360 xge_hal_channel_attr_t *attr); 361 362 void __hal_ring_close(xge_hal_channel_h channelh); 363 364 void __hal_ring_hw_initialize(xge_hal_device_h devh); 365 366 void __hal_ring_mtu_set(xge_hal_device_h devh, int new_mtu); 367 368 void __hal_ring_prc_enable(xge_hal_channel_h channelh); 369 370 void __hal_ring_prc_disable(xge_hal_channel_h channelh); 371 372 xge_hal_status_e __hal_ring_initial_replenish(xge_hal_channel_t *channel, 373 xge_hal_channel_reopen_e reopen); 374 375 #if defined(XGE_DEBUG_FP) && (XGE_DEBUG_FP & XGE_DEBUG_FP_RING) 376 #define __HAL_STATIC_RING 377 #define __HAL_INLINE_RING 378 379 __HAL_STATIC_RING __HAL_INLINE_RING int 380 __hal_ring_block_memblock_idx(xge_hal_ring_block_t *block); 381 382 __HAL_STATIC_RING __HAL_INLINE_RING void 383 __hal_ring_block_memblock_idx_set(xge_hal_ring_block_t*block, int memblock_idx); 384 385 __HAL_STATIC_RING __HAL_INLINE_RING dma_addr_t 386 __hal_ring_block_next_pointer(xge_hal_ring_block_t *block); 387 388 __HAL_STATIC_RING __HAL_INLINE_RING void 389 __hal_ring_block_next_pointer_set(xge_hal_ring_block_t*block, 390 dma_addr_t dma_next); 391 392 __HAL_STATIC_RING __HAL_INLINE_RING xge_hal_ring_rxd_priv_t* 393 __hal_ring_rxd_priv(xge_hal_ring_t *ring, xge_hal_dtr_h dtrh); 394 395 /* =========================== RING PUBLIC API ============================ */ 396 397 __HAL_STATIC_RING __HAL_INLINE_RING xge_hal_status_e 398 xge_hal_ring_dtr_reserve(xge_hal_channel_h channelh, xge_hal_dtr_h *dtrh); 399 400 __HAL_STATIC_RING __HAL_INLINE_RING void* 401 xge_hal_ring_dtr_private(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh); 402 403 __HAL_STATIC_RING __HAL_INLINE_RING void 404 xge_hal_ring_dtr_1b_set(xge_hal_dtr_h dtrh, dma_addr_t dma_pointer, int size); 405 406 __HAL_STATIC_RING __HAL_INLINE_RING void 407 xge_hal_ring_dtr_info_get(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh, 408 xge_hal_dtr_info_t *ext_info); 409 410 __HAL_STATIC_RING __HAL_INLINE_RING void 411 xge_hal_ring_dtr_1b_get(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh, 412 dma_addr_t *dma_pointer, int *pkt_length); 413 414 __HAL_STATIC_RING __HAL_INLINE_RING void 415 xge_hal_ring_dtr_3b_set(xge_hal_dtr_h dtrh, dma_addr_t dma_pointers[], 416 int sizes[]); 417 418 __HAL_STATIC_RING __HAL_INLINE_RING void 419 xge_hal_ring_dtr_3b_get(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh, 420 dma_addr_t dma_pointers[], int sizes[]); 421 422 __HAL_STATIC_RING __HAL_INLINE_RING void 423 xge_hal_ring_dtr_5b_set(xge_hal_dtr_h dtrh, dma_addr_t dma_pointers[], 424 int sizes[]); 425 426 __HAL_STATIC_RING __HAL_INLINE_RING void 427 xge_hal_ring_dtr_5b_get(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh, 428 dma_addr_t dma_pointer[], int sizes[]); 429 430 __HAL_STATIC_RING __HAL_INLINE_RING void 431 xge_hal_ring_dtr_post(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh); 432 433 __HAL_STATIC_RING __HAL_INLINE_RING void 434 xge_hal_ring_dtr_pre_post(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh); 435 436 __HAL_STATIC_RING __HAL_INLINE_RING void 437 xge_hal_ring_dtr_post_post(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh); 438 439 __HAL_STATIC_RING __HAL_INLINE_RING xge_hal_status_e 440 xge_hal_ring_dtr_next_completed(xge_hal_channel_h channelh, xge_hal_dtr_h *dtrh, 441 u8 *t_code); 442 443 __HAL_STATIC_RING __HAL_INLINE_RING void 444 xge_hal_ring_dtr_free(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh); 445 446 __HAL_STATIC_RING __HAL_INLINE_RING xge_hal_status_e 447 xge_hal_ring_is_next_dtr_completed(xge_hal_channel_h channelh); 448 449 #else /* XGE_FASTPATH_EXTERN */ 450 #define __HAL_STATIC_RING static 451 #define __HAL_INLINE_RING inline 452 #include "xgehal-ring-fp.c" 453 #endif /* XGE_FASTPATH_INLINE */ 454 455 __EXTERN_END_DECLS 456 457 #endif /* XGE_HAL_RING_H */ 458