D7net
Home
Console
Upload
information
Create File
Create Folder
About
Tools
:
/
lib
/
modules
/
4.4.0-1128-aws
/
build
/
arch
/
tile
/
include
/
hv
/
Filename :
drv_xgbe_impl.h
back
Copy
/* * Copyright 2010 Tilera Corporation. All Rights Reserved. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation, version 2. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or * NON INFRINGEMENT. See the GNU General Public License for * more details. */ /** * @file drivers/xgbe/impl.h * Implementation details for the NetIO library. */ #ifndef __DRV_XGBE_IMPL_H__ #define __DRV_XGBE_IMPL_H__ #include <hv/netio_errors.h> #include <hv/netio_intf.h> #include <hv/drv_xgbe_intf.h> /** How many groups we have (log2). */ #define LOG2_NUM_GROUPS (12) /** How many groups we have. */ #define NUM_GROUPS (1 << LOG2_NUM_GROUPS) /** Number of output requests we'll buffer per tile. */ #define EPP_REQS_PER_TILE (32) /** Words used in an eDMA command without checksum acceleration. */ #define EDMA_WDS_NO_CSUM 8 /** Words used in an eDMA command with checksum acceleration. */ #define EDMA_WDS_CSUM 10 /** Total available words in the eDMA command FIFO. */ #define EDMA_WDS_TOTAL 128 /* * FIXME: These definitions are internal and should have underscores! * NOTE: The actual numeric values here are intentional and allow us to * optimize the concept "if small ... else if large ... else ...", by * checking for the low bit being set, and then for non-zero. * These are used as array indices, so they must have the values (0, 1, 2) * in some order. */ #define SIZE_SMALL (1) /**< Small packet queue. */ #define SIZE_LARGE (2) /**< Large packet queue. */ #define SIZE_JUMBO (0) /**< Jumbo packet queue. */ /** The number of "SIZE_xxx" values. */ #define NETIO_NUM_SIZES 3 /* * Default numbers of packets for IPP drivers. These values are chosen * such that CIPP1 will not overflow its L2 cache. */ /** The default number of small packets. */ #define NETIO_DEFAULT_SMALL_PACKETS 2750 /** The default number of large packets. */ #define NETIO_DEFAULT_LARGE_PACKETS 2500 /** The default number of jumbo packets. */ #define NETIO_DEFAULT_JUMBO_PACKETS 250 /** Log2 of the size of a memory arena. */ #define NETIO_ARENA_SHIFT 24 /* 16 MB */ /** Size of a memory arena. */ #define NETIO_ARENA_SIZE (1 << NETIO_ARENA_SHIFT) /** A queue of packets. * * This structure partially defines a queue of packets waiting to be * processed. The queue as a whole is written to by an interrupt handler and * read by non-interrupt code; this data structure is what's touched by the * interrupt handler. The other part of the queue state, the read offset, is * kept in user space, not in hypervisor space, so it is in a separate data * structure. * * The read offset (__packet_receive_read in the user part of the queue * structure) points to the next packet to be read. When the read offset is * equal to the write offset, the queue is empty; therefore the queue must * contain one more slot than the required maximum queue size. * * Here's an example of all 3 state variables and what they mean. All * pointers move left to right. * * @code * I I V V V V I I I I * 0 1 2 3 4 5 6 7 8 9 10 * ^ ^ ^ ^ * | | | * | | __last_packet_plus_one * | __buffer_write * __packet_receive_read * @endcode * * This queue has 10 slots, and thus can hold 9 packets (_last_packet_plus_one * = 10). The read pointer is at 2, and the write pointer is at 6; thus, * there are valid, unread packets in slots 2, 3, 4, and 5. The remaining * slots are invalid (do not contain a packet). */ typedef struct { /** Byte offset of the next notify packet to be written: zero for the first * packet on the queue, sizeof (netio_pkt_t) for the second packet on the * queue, etc. */ volatile uint32_t __packet_write; /** Offset of the packet after the last valid packet (i.e., when any * pointer is incremented to this value, it wraps back to zero). */ uint32_t __last_packet_plus_one; } __netio_packet_queue_t; /** A queue of buffers. * * This structure partially defines a queue of empty buffers which have been * obtained via requests to the IPP. (The elements of the queue are packet * handles, which are transformed into a full netio_pkt_t when the buffer is * retrieved.) The queue as a whole is written to by an interrupt handler and * read by non-interrupt code; this data structure is what's touched by the * interrupt handler. The other parts of the queue state, the read offset and * requested write offset, are kept in user space, not in hypervisor space, so * they are in a separate data structure. * * The read offset (__buffer_read in the user part of the queue structure) * points to the next buffer to be read. When the read offset is equal to the * write offset, the queue is empty; therefore the queue must contain one more * slot than the required maximum queue size. * * The requested write offset (__buffer_requested_write in the user part of * the queue structure) points to the slot which will hold the next buffer we * request from the IPP, once we get around to sending such a request. When * the requested write offset is equal to the write offset, no requests for * new buffers are outstanding; when the requested write offset is one greater * than the read offset, no more requests may be sent. * * Note that, unlike the packet_queue, the buffer_queue places incoming * buffers at decreasing addresses. This makes the check for "is it time to * wrap the buffer pointer" cheaper in the assembly code which receives new * buffers, and means that the value which defines the queue size, * __last_buffer, is different than in the packet queue. Also, the offset * used in the packet_queue is already scaled by the size of a packet; here we * use unscaled slot indices for the offsets. (These differences are * historical, and in the future it's possible that the packet_queue will look * more like this queue.) * * @code * Here's an example of all 4 state variables and what they mean. Remember: * all pointers move right to left. * * V V V I I R R V V V * 0 1 2 3 4 5 6 7 8 9 * ^ ^ ^ ^ * | | | | * | | | __last_buffer * | | __buffer_write * | __buffer_requested_write * __buffer_read * @endcode * * This queue has 10 slots, and thus can hold 9 buffers (_last_buffer = 9). * The read pointer is at 2, and the write pointer is at 6; thus, there are * valid, unread buffers in slots 2, 1, 0, 9, 8, and 7. The requested write * pointer is at 4; thus, requests have been made to the IPP for buffers which * will be placed in slots 6 and 5 when they arrive. Finally, the remaining * slots are invalid (do not contain a buffer). */ typedef struct { /** Ordinal number of the next buffer to be written: 0 for the first slot in * the queue, 1 for the second slot in the queue, etc. */ volatile uint32_t __buffer_write; /** Ordinal number of the last buffer (i.e., when any pointer is decremented * below zero, it is reloaded with this value). */ uint32_t __last_buffer; } __netio_buffer_queue_t; /** * An object for providing Ethernet packets to a process. */ typedef struct __netio_queue_impl_t { /** The queue of packets waiting to be received. */ __netio_packet_queue_t __packet_receive_queue; /** The intr bit mask that IDs this device. */ unsigned int __intr_id; /** Offset to queues of empty buffers, one per size. */ uint32_t __buffer_queue[NETIO_NUM_SIZES]; /** The address of the first EPP tile, or -1 if no EPP. */ /* ISSUE: Actually this is always "0" or "~0". */ uint32_t __epp_location; /** The queue ID that this queue represents. */ unsigned int __queue_id; /** Number of acknowledgements received. */ volatile uint32_t __acks_received; /** Last completion number received for packet_sendv. */ volatile uint32_t __last_completion_rcv; /** Number of packets allowed to be outstanding. */ uint32_t __max_outstanding; /** First VA available for packets. */ void* __va_0; /** First VA in second range available for packets. */ void* __va_1; /** Padding to align the "__packets" field to the size of a netio_pkt_t. */ uint32_t __padding[3]; /** The packets themselves. */ netio_pkt_t __packets[0]; } netio_queue_impl_t; /** * An object for managing the user end of a NetIO queue. */ typedef struct __netio_queue_user_impl_t { /** The next incoming packet to be read. */ uint32_t __packet_receive_read; /** The next empty buffers to be read, one index per size. */ uint8_t __buffer_read[NETIO_NUM_SIZES]; /** Where the empty buffer we next request from the IPP will go, one index * per size. */ uint8_t __buffer_requested_write[NETIO_NUM_SIZES]; /** PCIe interface flag. */ uint8_t __pcie; /** Number of packets left to be received before we send a credit update. */ uint32_t __receive_credit_remaining; /** Value placed in __receive_credit_remaining when it reaches zero. */ uint32_t __receive_credit_interval; /** First fast I/O routine index. */ uint32_t __fastio_index; /** Number of acknowledgements expected. */ uint32_t __acks_outstanding; /** Last completion number requested. */ uint32_t __last_completion_req; /** File descriptor for driver. */ int __fd; } netio_queue_user_impl_t; #define NETIO_GROUP_CHUNK_SIZE 64 /**< Max # groups in one IPP request */ #define NETIO_BUCKET_CHUNK_SIZE 64 /**< Max # buckets in one IPP request */ /** Internal structure used to convey packet send information to the * hypervisor. FIXME: Actually, it's not used for that anymore, but * netio_packet_send() still uses it internally. */ typedef struct { uint16_t flags; /**< Packet flags (__NETIO_SEND_FLG_xxx) */ uint16_t transfer_size; /**< Size of packet */ uint32_t va; /**< VA of start of packet */ __netio_pkt_handle_t handle; /**< Packet handle */ uint32_t csum0; /**< First checksum word */ uint32_t csum1; /**< Second checksum word */ } __netio_send_cmd_t; /** Flags used in two contexts: * - As the "flags" member in the __netio_send_cmd_t, above; used only * for netio_pkt_send_{prepare,commit}. * - As part of the flags passed to the various send packet fast I/O calls. */ /** Need acknowledgement on this packet. Note that some code in the * normal send_pkt fast I/O handler assumes that this is equal to 1. */ #define __NETIO_SEND_FLG_ACK 0x1 /** Do checksum on this packet. (Only used with the __netio_send_cmd_t; * normal packet sends use a special fast I/O index to denote checksumming, * and multi-segment sends test the checksum descriptor.) */ #define __NETIO_SEND_FLG_CSUM 0x2 /** Get a completion on this packet. Only used with multi-segment sends. */ #define __NETIO_SEND_FLG_COMPLETION 0x4 /** Position of the number-of-extra-segments value in the flags word. Only used with multi-segment sends. */ #define __NETIO_SEND_FLG_XSEG_SHIFT 3 /** Width of the number-of-extra-segments value in the flags word. */ #define __NETIO_SEND_FLG_XSEG_WIDTH 2 #endif /* __DRV_XGBE_IMPL_H__ */