1/**************************************************************************** 2 * Driver for Solarflare network controllers and boards 3 * Copyright 2010-2012 Solarflare Communications Inc. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 as published 7 * by the Free Software Foundation, incorporated herein by reference. 8 */ 9#ifndef _VFDI_H 10#define _VFDI_H 11 12/** 13 * DOC: Virtual Function Driver Interface 14 * 15 * This file contains software structures used to form a two way 16 * communication channel between the VF driver and the PF driver, 17 * named Virtual Function Driver Interface (VFDI). 18 * 19 * For the purposes of VFDI, a page is a memory region with size and 20 * alignment of 4K. All addresses are DMA addresses to be used within 21 * the domain of the relevant VF. 22 * 23 * The only hardware-defined channels for a VF driver to communicate 24 * with the PF driver are the event mailboxes (%FR_CZ_USR_EV 25 * registers). Writing to these registers generates an event with 26 * EV_CODE = EV_CODE_USR_EV, USER_QID set to the index of the mailbox 27 * and USER_EV_REG_VALUE set to the value written. The PF driver may 28 * direct or disable delivery of these events by setting 29 * %FR_CZ_USR_EV_CFG. 30 * 31 * The PF driver can send arbitrary events to arbitrary event queues. 32 * However, for consistency, VFDI events from the PF are defined to 33 * follow the same form and be sent to the first event queue assigned 34 * to the VF while that queue is enabled by the VF driver. 35 * 36 * The general form of the variable bits of VFDI events is: 37 * 38 * 0 16 24 31 39 * | DATA | TYPE | SEQ | 40 * 41 * SEQ is a sequence number which should be incremented by 1 (modulo 42 * 256) for each event. The sequence numbers used in each direction 43 * are independent. 44 * 45 * The VF submits requests of type &struct vfdi_req by sending the 46 * address of the request (ADDR) in a series of 4 events: 47 * 48 * 0 16 24 31 49 * | ADDR[0:15] | VFDI_EV_TYPE_REQ_WORD0 | SEQ | 50 * | ADDR[16:31] | VFDI_EV_TYPE_REQ_WORD1 | SEQ+1 | 51 * | ADDR[32:47] | VFDI_EV_TYPE_REQ_WORD2 | SEQ+2 | 52 * | ADDR[48:63] | VFDI_EV_TYPE_REQ_WORD3 | SEQ+3 | 53 * 54 * The address must be page-aligned. After receiving such a valid 55 * series of events, the PF driver will attempt to read the request 56 * and write a response to the same address. In case of an invalid 57 * sequence of events or a DMA error, there will be no response. 58 * 59 * The VF driver may request that the PF driver writes status 60 * information into its domain asynchronously. After writing the 61 * status, the PF driver will send an event of the form: 62 * 63 * 0 16 24 31 64 * | reserved | VFDI_EV_TYPE_STATUS | SEQ | 65 * 66 * In case the VF must be reset for any reason, the PF driver will 67 * send an event of the form: 68 * 69 * 0 16 24 31 70 * | reserved | VFDI_EV_TYPE_RESET | SEQ | 71 * 72 * It is then the responsibility of the VF driver to request 73 * reinitialisation of its queues. 74 */ 75#define VFDI_EV_SEQ_LBN 24 76#define VFDI_EV_SEQ_WIDTH 8 77#define VFDI_EV_TYPE_LBN 16 78#define VFDI_EV_TYPE_WIDTH 8 79#define VFDI_EV_TYPE_REQ_WORD0 0 80#define VFDI_EV_TYPE_REQ_WORD1 1 81#define VFDI_EV_TYPE_REQ_WORD2 2 82#define VFDI_EV_TYPE_REQ_WORD3 3 83#define VFDI_EV_TYPE_STATUS 4 84#define VFDI_EV_TYPE_RESET 5 85#define VFDI_EV_DATA_LBN 0 86#define VFDI_EV_DATA_WIDTH 16 87 88struct vfdi_endpoint { 89 u8 mac_addr[ETH_ALEN]; 90 __be16 tci; 91}; 92 93/** 94 * enum vfdi_op - VFDI operation enumeration 95 * @VFDI_OP_RESPONSE: Indicates a response to the request. 96 * @VFDI_OP_INIT_EVQ: Initialize SRAM entries and initialize an EVQ. 97 * @VFDI_OP_INIT_RXQ: Initialize SRAM entries and initialize an RXQ. 98 * @VFDI_OP_INIT_TXQ: Initialize SRAM entries and initialize a TXQ. 99 * @VFDI_OP_FINI_ALL_QUEUES: Flush all queues, finalize all queues, then 100 * finalize the SRAM entries. 101 * @VFDI_OP_INSERT_FILTER: Insert a MAC filter targeting the given RXQ. 102 * @VFDI_OP_REMOVE_ALL_FILTERS: Remove all filters. 103 * @VFDI_OP_SET_STATUS_PAGE: Set the DMA page(s) used for status updates 104 * from PF and write the initial status. 105 * @VFDI_OP_CLEAR_STATUS_PAGE: Clear the DMA page(s) used for status 106 * updates from PF. 107 */ 108enum vfdi_op { 109 VFDI_OP_RESPONSE = 0, 110 VFDI_OP_INIT_EVQ = 1, 111 VFDI_OP_INIT_RXQ = 2, 112 VFDI_OP_INIT_TXQ = 3, 113 VFDI_OP_FINI_ALL_QUEUES = 4, 114 VFDI_OP_INSERT_FILTER = 5, 115 VFDI_OP_REMOVE_ALL_FILTERS = 6, 116 VFDI_OP_SET_STATUS_PAGE = 7, 117 VFDI_OP_CLEAR_STATUS_PAGE = 8, 118 VFDI_OP_LIMIT, 119}; 120 121/* Response codes for VFDI operations. Other values may be used in future. */ 122#define VFDI_RC_SUCCESS 0 123#define VFDI_RC_ENOMEM (-12) 124#define VFDI_RC_EINVAL (-22) 125#define VFDI_RC_EOPNOTSUPP (-95) 126#define VFDI_RC_ETIMEDOUT (-110) 127 128/** 129 * struct vfdi_req - Request from VF driver to PF driver 130 * @op: Operation code or response indicator, taken from &enum vfdi_op. 131 * @rc: Response code. Set to 0 on success or a negative error code on failure. 132 * @u.init_evq.index: Index of event queue to create. 133 * @u.init_evq.buf_count: Number of 4k buffers backing event queue. 134 * @u.init_evq.addr: Array of length %u.init_evq.buf_count containing DMA 135 * address of each page backing the event queue. 136 * @u.init_rxq.index: Index of receive queue to create. 137 * @u.init_rxq.buf_count: Number of 4k buffers backing receive queue. 138 * @u.init_rxq.evq: Instance of event queue to target receive events at. 139 * @u.init_rxq.label: Label used in receive events. 140 * @u.init_rxq.flags: Unused. 141 * @u.init_rxq.addr: Array of length %u.init_rxq.buf_count containing DMA 142 * address of each page backing the receive queue. 143 * @u.init_txq.index: Index of transmit queue to create. 144 * @u.init_txq.buf_count: Number of 4k buffers backing transmit queue. 145 * @u.init_txq.evq: Instance of event queue to target transmit completion 146 * events at. 147 * @u.init_txq.label: Label used in transmit completion events. 148 * @u.init_txq.flags: Checksum offload flags. 149 * @u.init_txq.addr: Array of length %u.init_txq.buf_count containing DMA 150 * address of each page backing the transmit queue. 151 * @u.mac_filter.rxq: Insert MAC filter at VF local address/VLAN targeting 152 * all traffic at this receive queue. 153 * @u.mac_filter.flags: MAC filter flags. 154 * @u.set_status_page.dma_addr: Base address for the &struct vfdi_status. 155 * This address must be page-aligned and the PF may write up to a 156 * whole page (allowing for extension of the structure). 157 * @u.set_status_page.peer_page_count: Number of additional pages the VF 158 * has provided into which peer addresses may be DMAd. 159 * @u.set_status_page.peer_page_addr: Array of DMA addresses of pages. 160 * If the number of peers exceeds 256, then the VF must provide 161 * additional pages in this array. The PF will then DMA up to 162 * 512 vfdi_endpoint structures into each page. These addresses 163 * must be page-aligned. 164 */ 165struct vfdi_req { 166 u32 op; 167 u32 reserved1; 168 s32 rc; 169 u32 reserved2; 170 union { 171 struct { 172 u32 index; 173 u32 buf_count; 174 u64 addr[]; 175 } init_evq; 176 struct { 177 u32 index; 178 u32 buf_count; 179 u32 evq; 180 u32 label; 181 u32 flags; 182#define VFDI_RXQ_FLAG_SCATTER_EN 1 183 u32 reserved; 184 u64 addr[]; 185 } init_rxq; 186 struct { 187 u32 index; 188 u32 buf_count; 189 u32 evq; 190 u32 label; 191 u32 flags; 192#define VFDI_TXQ_FLAG_IP_CSUM_DIS 1 193#define VFDI_TXQ_FLAG_TCPUDP_CSUM_DIS 2 194 u32 reserved; 195 u64 addr[]; 196 } init_txq; 197 struct { 198 u32 rxq; 199 u32 flags; 200#define VFDI_MAC_FILTER_FLAG_RSS 1 201#define VFDI_MAC_FILTER_FLAG_SCATTER 2 202 } mac_filter; 203 struct { 204 u64 dma_addr; 205 u64 peer_page_count; 206 u64 peer_page_addr[]; 207 } set_status_page; 208 } u; 209}; 210 211/** 212 * struct vfdi_status - Status provided by PF driver to VF driver 213 * @generation_start: A generation count DMA'd to VF *before* the 214 * rest of the structure. 215 * @generation_end: A generation count DMA'd to VF *after* the 216 * rest of the structure. 217 * @version: Version of this structure; currently set to 1. Later 218 * versions must either be layout-compatible or only be sent to VFs 219 * that specifically request them. 220 * @length: Total length of this structure including embedded tables 221 * @vi_scale: log2 the number of VIs available on this VF. This quantity 222 * is used by the hardware for register decoding. 223 * @max_tx_channels: The maximum number of transmit queues the VF can use. 224 * @rss_rxq_count: The number of receive queues present in the shared RSS 225 * indirection table. 226 * @peer_count: Total number of peers in the complete peer list. If larger 227 * than ARRAY_SIZE(%peers), then the VF must provide sufficient 228 * additional pages each of which is filled with vfdi_endpoint structures. 229 * @local: The MAC address and outer VLAN tag of *this* VF 230 * @peers: Table of peer addresses. The @tci fields in these structures 231 * are currently unused and must be ignored. Additional peers are 232 * written into any additional pages provided by the VF. 233 * @timer_quantum_ns: Timer quantum (nominal period between timer ticks) 234 * for interrupt moderation timers, in nanoseconds. This member is only 235 * present if @length is sufficiently large. 236 */ 237struct vfdi_status { 238 u32 generation_start; 239 u32 generation_end; 240 u32 version; 241 u32 length; 242 u8 vi_scale; 243 u8 max_tx_channels; 244 u8 rss_rxq_count; 245 u8 reserved1; 246 u16 peer_count; 247 u16 reserved2; 248 struct vfdi_endpoint local; 249 struct vfdi_endpoint peers[256]; 250 251 /* Members below here extend version 1 of this structure */ 252 u32 timer_quantum_ns; 253}; 254 255#endif 256