1 /********************************************************************** 2 * Author: Cavium, Inc. 3 * 4 * Contact: support@cavium.com 5 * Please include "LiquidIO" in the subject. 6 * 7 * Copyright (c) 2003-2016 Cavium, Inc. 8 * 9 * This file is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License, Version 2, as 11 * published by the Free Software Foundation. 12 * 13 * This file is distributed in the hope that it will be useful, but 14 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty 15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or 16 * NONINFRINGEMENT. See the GNU General Public License for more details. 17 ***********************************************************************/ 18 /*! \file octeon_droq.h 19 * \brief Implementation of Octeon Output queues. "Output" is with 20 * respect to the Octeon device on the NIC. From this driver's point of 21 * view they are ingress queues. 22 */ 23 24 #ifndef __OCTEON_DROQ_H__ 25 #define __OCTEON_DROQ_H__ 26 27 /* Default number of packets that will be processed in one iteration. */ 28 #define MAX_PACKET_BUDGET 0xFFFFFFFF 29 30 /** Octeon descriptor format. 31 * The descriptor ring is made of descriptors which have 2 64-bit values: 32 * -# Physical (bus) address of the data buffer. 33 * -# Physical (bus) address of a octeon_droq_info structure. 34 * The Octeon device DMA's incoming packets and its information at the address 35 * given by these descriptor fields. 36 */ 37 struct octeon_droq_desc { 38 /** The buffer pointer */ 39 u64 buffer_ptr; 40 41 /** The Info pointer */ 42 u64 info_ptr; 43 }; 44 45 #define OCT_DROQ_DESC_SIZE (sizeof(struct octeon_droq_desc)) 46 47 /** Information about packet DMA'ed by Octeon. 48 * The format of the information available at Info Pointer after Octeon 49 * has posted a packet. Not all descriptors have valid information. Only 50 * the Info field of the first descriptor for a packet has information 51 * about the packet. 52 */ 53 struct octeon_droq_info { 54 /** The Length of the packet. */ 55 u64 length; 56 57 /** The Output Receive Header. */ 58 union octeon_rh rh; 59 }; 60 61 #define OCT_DROQ_INFO_SIZE (sizeof(struct octeon_droq_info)) 62 63 struct octeon_skb_page_info { 64 /* DMA address for the page */ 65 dma_addr_t dma; 66 67 /* Page for the rx dma **/ 68 struct page *page; 69 70 /** which offset into page */ 71 unsigned int page_offset; 72 }; 73 74 /** Pointer to data buffer. 75 * Driver keeps a pointer to the data buffer that it made available to 76 * the Octeon device. Since the descriptor ring keeps physical (bus) 77 * addresses, this field is required for the driver to keep track of 78 * the virtual address pointers. 79 */ 80 struct octeon_recv_buffer { 81 /** Packet buffer, including metadata. */ 82 void *buffer; 83 84 /** Data in the packet buffer. */ 85 u8 *data; 86 87 /** pg_info **/ 88 struct octeon_skb_page_info pg_info; 89 }; 90 91 #define OCT_DROQ_RECVBUF_SIZE (sizeof(struct octeon_recv_buffer)) 92 93 /** Output Queue statistics. Each output queue has four stats fields. */ 94 struct oct_droq_stats { 95 /** Number of packets received in this queue. */ 96 u64 pkts_received; 97 98 /** Bytes received by this queue. */ 99 u64 bytes_received; 100 101 /** Packets dropped due to no dispatch function. */ 102 u64 dropped_nodispatch; 103 104 /** Packets dropped due to no memory available. */ 105 u64 dropped_nomem; 106 107 /** Packets dropped due to large number of pkts to process. */ 108 u64 dropped_toomany; 109 110 /** Number of packets sent to stack from this queue. */ 111 u64 rx_pkts_received; 112 113 /** Number of Bytes sent to stack from this queue. */ 114 u64 rx_bytes_received; 115 116 /** Num of Packets dropped due to receive path failures. */ 117 u64 rx_dropped; 118 119 u64 rx_vxlan; 120 121 /** Num of failures of recv_buffer_alloc() */ 122 u64 rx_alloc_failure; 123 124 }; 125 126 #define POLL_EVENT_INTR_ARRIVED 1 127 #define POLL_EVENT_PROCESS_PKTS 2 128 #define POLL_EVENT_PENDING_PKTS 3 129 #define POLL_EVENT_ENABLE_INTR 4 130 131 /* The maximum number of buffers that can be dispatched from the 132 * output/dma queue. Set to 64 assuming 1K buffers in DROQ and the fact that 133 * max packet size from DROQ is 64K. 134 */ 135 #define MAX_RECV_BUFS 64 136 137 /** Receive Packet format used when dispatching output queue packets 138 * with non-raw opcodes. 139 * The received packet will be sent to the upper layers using this 140 * structure which is passed as a parameter to the dispatch function 141 */ 142 struct octeon_recv_pkt { 143 /** Number of buffers in this received packet */ 144 u16 buffer_count; 145 146 /** Id of the device that is sending the packet up */ 147 u16 octeon_id; 148 149 /** Length of data in the packet buffer */ 150 u32 length; 151 152 /** The receive header */ 153 union octeon_rh rh; 154 155 /** Pointer to the OS-specific packet buffer */ 156 void *buffer_ptr[MAX_RECV_BUFS]; 157 158 /** Size of the buffers pointed to by ptr's in buffer_ptr */ 159 u32 buffer_size[MAX_RECV_BUFS]; 160 }; 161 162 #define OCT_RECV_PKT_SIZE (sizeof(struct octeon_recv_pkt)) 163 164 /** The first parameter of a dispatch function. 165 * For a raw mode opcode, the driver dispatches with the device 166 * pointer in this structure. 167 * For non-raw mode opcode, the driver dispatches the recv_pkt 168 * created to contain the buffers with data received from Octeon. 169 * --------------------- 170 * | *recv_pkt ----|--- 171 * |-------------------| | 172 * | 0 or more bytes | | 173 * | reserved by driver| | 174 * |-------------------|<-/ 175 * | octeon_recv_pkt | 176 * | | 177 * |___________________| 178 */ 179 struct octeon_recv_info { 180 void *rsvd; 181 struct octeon_recv_pkt *recv_pkt; 182 }; 183 184 #define OCT_RECV_INFO_SIZE (sizeof(struct octeon_recv_info)) 185 186 /** Allocate a recv_info structure. The recv_pkt pointer in the recv_info 187 * structure is filled in before this call returns. 188 * @param extra_bytes - extra bytes to be allocated at the end of the recv info 189 * structure. 190 * @return - pointer to a newly allocated recv_info structure. 191 */ 192 static inline struct octeon_recv_info *octeon_alloc_recv_info(int extra_bytes) 193 { 194 struct octeon_recv_info *recv_info; 195 u8 *buf; 196 197 buf = kmalloc(OCT_RECV_PKT_SIZE + OCT_RECV_INFO_SIZE + 198 extra_bytes, GFP_ATOMIC); 199 if (!buf) 200 return NULL; 201 202 recv_info = (struct octeon_recv_info *)buf; 203 recv_info->recv_pkt = 204 (struct octeon_recv_pkt *)(buf + OCT_RECV_INFO_SIZE); 205 recv_info->rsvd = NULL; 206 if (extra_bytes) 207 recv_info->rsvd = buf + OCT_RECV_INFO_SIZE + OCT_RECV_PKT_SIZE; 208 209 return recv_info; 210 } 211 212 /** Free a recv_info structure. 213 * @param recv_info - Pointer to receive_info to be freed 214 */ 215 static inline void octeon_free_recv_info(struct octeon_recv_info *recv_info) 216 { 217 kfree(recv_info); 218 } 219 220 typedef int (*octeon_dispatch_fn_t)(struct octeon_recv_info *, void *); 221 222 /** Used by NIC module to register packet handler and to get device 223 * information for each octeon device. 224 */ 225 struct octeon_droq_ops { 226 /** This registered function will be called by the driver with 227 * the octeon id, pointer to buffer from droq and length of 228 * data in the buffer. The receive header gives the port 229 * number to the caller. Function pointer is set by caller. 230 */ 231 void (*fptr)(u32, void *, u32, union octeon_rh *, void *, void *); 232 void *farg; 233 234 /* This function will be called by the driver for all NAPI related 235 * events. The first param is the octeon id. The second param is the 236 * output queue number. The third is the NAPI event that occurred. 237 */ 238 void (*napi_fn)(void *); 239 240 u32 poll_mode; 241 242 /** Flag indicating if the DROQ handler should drop packets that 243 * it cannot handle in one iteration. Set by caller. 244 */ 245 u32 drop_on_max; 246 }; 247 248 /** The Descriptor Ring Output Queue structure. 249 * This structure has all the information required to implement a 250 * Octeon DROQ. 251 */ 252 struct octeon_droq { 253 /** A spinlock to protect access to this ring. */ 254 spinlock_t lock; 255 256 u32 q_no; 257 258 u32 pkt_count; 259 260 struct octeon_droq_ops ops; 261 262 struct octeon_device *oct_dev; 263 264 /** The 8B aligned descriptor ring starts at this address. */ 265 struct octeon_droq_desc *desc_ring; 266 267 /** Index in the ring where the driver should read the next packet */ 268 u32 read_idx; 269 270 /** Index in the ring where Octeon will write the next packet */ 271 u32 write_idx; 272 273 /** Index in the ring where the driver will refill the descriptor's 274 * buffer 275 */ 276 u32 refill_idx; 277 278 /** Packets pending to be processed */ 279 atomic_t pkts_pending; 280 281 /** Number of descriptors in this ring. */ 282 u32 max_count; 283 284 /** The number of descriptors pending refill. */ 285 u32 refill_count; 286 287 u32 pkts_per_intr; 288 u32 refill_threshold; 289 290 /** The max number of descriptors in DROQ without a buffer. 291 * This field is used to keep track of empty space threshold. If the 292 * refill_count reaches this value, the DROQ cannot accept a max-sized 293 * (64K) packet. 294 */ 295 u32 max_empty_descs; 296 297 /** The receive buffer list. This list has the virtual addresses of the 298 * buffers. 299 */ 300 struct octeon_recv_buffer *recv_buf_list; 301 302 /** The size of each buffer pointed by the buffer pointer. */ 303 u32 buffer_size; 304 305 /** Pointer to the mapped packet credit register. 306 * Host writes number of info/buffer ptrs available to this register 307 */ 308 void __iomem *pkts_credit_reg; 309 310 /** Pointer to the mapped packet sent register. 311 * Octeon writes the number of packets DMA'ed to host memory 312 * in this register. 313 */ 314 void __iomem *pkts_sent_reg; 315 316 struct list_head dispatch_list; 317 318 /** Statistics for this DROQ. */ 319 struct oct_droq_stats stats; 320 321 /** DMA mapped address of the DROQ descriptor ring. */ 322 size_t desc_ring_dma; 323 324 /** application context */ 325 void *app_ctx; 326 327 struct napi_struct napi; 328 329 u32 cpu_id; 330 331 call_single_data_t csd; 332 }; 333 334 #define OCT_DROQ_SIZE (sizeof(struct octeon_droq)) 335 336 /** 337 * Allocates space for the descriptor ring for the droq and sets the 338 * base addr, num desc etc in Octeon registers. 339 * 340 * @param oct_dev - pointer to the octeon device structure 341 * @param q_no - droq no. ranges from 0 - 3. 342 * @param app_ctx - pointer to application context 343 * @return Success: 0 Failure: 1 344 */ 345 int octeon_init_droq(struct octeon_device *oct_dev, 346 u32 q_no, 347 u32 num_descs, 348 u32 desc_size, 349 void *app_ctx); 350 351 /** 352 * Frees the space for descriptor ring for the droq. 353 * 354 * @param oct_dev - pointer to the octeon device structure 355 * @param q_no - droq no. ranges from 0 - 3. 356 * @return: Success: 0 Failure: 1 357 */ 358 int octeon_delete_droq(struct octeon_device *oct_dev, u32 q_no); 359 360 /** Register a change in droq operations. The ops field has a pointer to a 361 * function which will called by the DROQ handler for all packets arriving 362 * on output queues given by q_no irrespective of the type of packet. 363 * The ops field also has a flag which if set tells the DROQ handler to 364 * drop packets if it receives more than what it can process in one 365 * invocation of the handler. 366 * @param oct - octeon device 367 * @param q_no - octeon output queue number (0 <= q_no <= MAX_OCTEON_DROQ-1 368 * @param ops - the droq_ops settings for this queue 369 * @return - 0 on success, -ENODEV or -EINVAL on error. 370 */ 371 int 372 octeon_register_droq_ops(struct octeon_device *oct, 373 u32 q_no, 374 struct octeon_droq_ops *ops); 375 376 /** Resets the function pointer and flag settings made by 377 * octeon_register_droq_ops(). After this routine is called, the DROQ handler 378 * will lookup dispatch function for each arriving packet on the output queue 379 * given by q_no. 380 * @param oct - octeon device 381 * @param q_no - octeon output queue number (0 <= q_no <= MAX_OCTEON_DROQ-1 382 * @return - 0 on success, -ENODEV or -EINVAL on error. 383 */ 384 int octeon_unregister_droq_ops(struct octeon_device *oct, u32 q_no); 385 386 /** Register a dispatch function for a opcode/subcode. The driver will call 387 * this dispatch function when it receives a packet with the given 388 * opcode/subcode in its output queues along with the user specified 389 * argument. 390 * @param oct - the octeon device to register with. 391 * @param opcode - the opcode for which the dispatch will be registered. 392 * @param subcode - the subcode for which the dispatch will be registered 393 * @param fn - the dispatch function. 394 * @param fn_arg - user specified that will be passed along with the 395 * dispatch function by the driver. 396 * @return Success: 0; Failure: 1 397 */ 398 int octeon_register_dispatch_fn(struct octeon_device *oct, 399 u16 opcode, 400 u16 subcode, 401 octeon_dispatch_fn_t fn, void *fn_arg); 402 403 void octeon_droq_print_stats(void); 404 405 u32 octeon_droq_check_hw_for_pkts(struct octeon_droq *droq); 406 407 int octeon_create_droq(struct octeon_device *oct, u32 q_no, 408 u32 num_descs, u32 desc_size, void *app_ctx); 409 410 int octeon_droq_process_packets(struct octeon_device *oct, 411 struct octeon_droq *droq, 412 u32 budget); 413 414 int octeon_process_droq_poll_cmd(struct octeon_device *oct, u32 q_no, 415 int cmd, u32 arg); 416 417 void octeon_droq_check_oom(struct octeon_droq *droq); 418 419 #endif /*__OCTEON_DROQ_H__ */ 420