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 */ 37struct 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 */ 53struct 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 63struct 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 */ 80struct 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. */ 94struct 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/* The maximum number of buffers that can be dispatched from the 127 * output/dma queue. Set to 64 assuming 1K buffers in DROQ and the fact that 128 * max packet size from DROQ is 64K. 129 */ 130#define MAX_RECV_BUFS 64 131 132/** Receive Packet format used when dispatching output queue packets 133 * with non-raw opcodes. 134 * The received packet will be sent to the upper layers using this 135 * structure which is passed as a parameter to the dispatch function 136 */ 137struct octeon_recv_pkt { 138 /** Number of buffers in this received packet */ 139 u16 buffer_count; 140 141 /** Id of the device that is sending the packet up */ 142 u16 octeon_id; 143 144 /** Length of data in the packet buffer */ 145 u32 length; 146 147 /** The receive header */ 148 union octeon_rh rh; 149 150 /** Pointer to the OS-specific packet buffer */ 151 void *buffer_ptr[MAX_RECV_BUFS]; 152 153 /** Size of the buffers pointed to by ptr's in buffer_ptr */ 154 u32 buffer_size[MAX_RECV_BUFS]; 155}; 156 157#define OCT_RECV_PKT_SIZE (sizeof(struct octeon_recv_pkt)) 158 159/** The first parameter of a dispatch function. 160 * For a raw mode opcode, the driver dispatches with the device 161 * pointer in this structure. 162 * For non-raw mode opcode, the driver dispatches the recv_pkt 163 * created to contain the buffers with data received from Octeon. 164 * --------------------- 165 * | *recv_pkt ----|--- 166 * |-------------------| | 167 * | 0 or more bytes | | 168 * | reserved by driver| | 169 * |-------------------|<-/ 170 * | octeon_recv_pkt | 171 * | | 172 * |___________________| 173 */ 174struct octeon_recv_info { 175 void *rsvd; 176 struct octeon_recv_pkt *recv_pkt; 177}; 178 179#define OCT_RECV_INFO_SIZE (sizeof(struct octeon_recv_info)) 180 181/** Allocate a recv_info structure. The recv_pkt pointer in the recv_info 182 * structure is filled in before this call returns. 183 * @param extra_bytes - extra bytes to be allocated at the end of the recv info 184 * structure. 185 * @return - pointer to a newly allocated recv_info structure. 186 */ 187static inline struct octeon_recv_info *octeon_alloc_recv_info(int extra_bytes) 188{ 189 struct octeon_recv_info *recv_info; 190 u8 *buf; 191 192 buf = kmalloc(OCT_RECV_PKT_SIZE + OCT_RECV_INFO_SIZE + 193 extra_bytes, GFP_ATOMIC); 194 if (!buf) 195 return NULL; 196 197 recv_info = (struct octeon_recv_info *)buf; 198 recv_info->recv_pkt = 199 (struct octeon_recv_pkt *)(buf + OCT_RECV_INFO_SIZE); 200 recv_info->rsvd = NULL; 201 if (extra_bytes) 202 recv_info->rsvd = buf + OCT_RECV_INFO_SIZE + OCT_RECV_PKT_SIZE; 203 204 return recv_info; 205} 206 207/** Free a recv_info structure. 208 * @param recv_info - Pointer to receive_info to be freed 209 */ 210static inline void octeon_free_recv_info(struct octeon_recv_info *recv_info) 211{ 212 kfree(recv_info); 213} 214 215typedef int (*octeon_dispatch_fn_t)(struct octeon_recv_info *, void *); 216 217/** Used by NIC module to register packet handler and to get device 218 * information for each octeon device. 219 */ 220struct octeon_droq_ops { 221 /** This registered function will be called by the driver with 222 * the octeon id, pointer to buffer from droq and length of 223 * data in the buffer. The receive header gives the port 224 * number to the caller. Function pointer is set by caller. 225 */ 226 void (*fptr)(u32, void *, u32, union octeon_rh *, void *, void *); 227 void *farg; 228 229 /* This function will be called by the driver for all NAPI related 230 * events. The first param is the octeon id. The second param is the 231 * output queue number. The third is the NAPI event that occurred. 232 */ 233 void (*napi_fn)(void *); 234 235 u32 poll_mode; 236 237 /** Flag indicating if the DROQ handler should drop packets that 238 * it cannot handle in one iteration. Set by caller. 239 */ 240 u32 drop_on_max; 241}; 242 243/** The Descriptor Ring Output Queue structure. 244 * This structure has all the information required to implement a 245 * Octeon DROQ. 246 */ 247struct octeon_droq { 248 /** A spinlock to protect access to this ring. */ 249 spinlock_t lock; 250 251 u32 q_no; 252 253 u32 pkt_count; 254 255 struct octeon_droq_ops ops; 256 257 struct octeon_device *oct_dev; 258 259 /** The 8B aligned descriptor ring starts at this address. */ 260 struct octeon_droq_desc *desc_ring; 261 262 /** Index in the ring where the driver should read the next packet */ 263 u32 read_idx; 264 265 /** Index in the ring where Octeon will write the next packet */ 266 u32 write_idx; 267 268 /** Index in the ring where the driver will refill the descriptor's 269 * buffer 270 */ 271 u32 refill_idx; 272 273 /** Packets pending to be processed */ 274 atomic_t pkts_pending; 275 276 /** Number of descriptors in this ring. */ 277 u32 max_count; 278 279 /** The number of descriptors pending refill. */ 280 u32 refill_count; 281 282 u32 pkts_per_intr; 283 u32 refill_threshold; 284 285 /** The max number of descriptors in DROQ without a buffer. 286 * This field is used to keep track of empty space threshold. If the 287 * refill_count reaches this value, the DROQ cannot accept a max-sized 288 * (64K) packet. 289 */ 290 u32 max_empty_descs; 291 292 /** The receive buffer list. This list has the virtual addresses of the 293 * buffers. 294 */ 295 struct octeon_recv_buffer *recv_buf_list; 296 297 /** The size of each buffer pointed by the buffer pointer. */ 298 u32 buffer_size; 299 300 /** Pointer to the mapped packet credit register. 301 * Host writes number of info/buffer ptrs available to this register 302 */ 303 void __iomem *pkts_credit_reg; 304 305 /** Pointer to the mapped packet sent register. 306 * Octeon writes the number of packets DMA'ed to host memory 307 * in this register. 308 */ 309 void __iomem *pkts_sent_reg; 310 311 struct list_head dispatch_list; 312 313 /** Statistics for this DROQ. */ 314 struct oct_droq_stats stats; 315 316 /** DMA mapped address of the DROQ descriptor ring. */ 317 size_t desc_ring_dma; 318 319 /** application context */ 320 void *app_ctx; 321 322 struct napi_struct napi; 323 324 u32 cpu_id; 325 326 call_single_data_t csd; 327}; 328 329#define OCT_DROQ_SIZE (sizeof(struct octeon_droq)) 330 331/** 332 * Allocates space for the descriptor ring for the droq and sets the 333 * base addr, num desc etc in Octeon registers. 334 * 335 * @param oct_dev - pointer to the octeon device structure 336 * @param q_no - droq no. ranges from 0 - 3. 337 * @param app_ctx - pointer to application context 338 * @return Success: 0 Failure: 1 339 */ 340int octeon_init_droq(struct octeon_device *oct_dev, 341 u32 q_no, 342 u32 num_descs, 343 u32 desc_size, 344 void *app_ctx); 345 346/** 347 * Frees the space for descriptor ring for the droq. 348 * 349 * @param oct_dev - pointer to the octeon device structure 350 * @param q_no - droq no. ranges from 0 - 3. 351 * @return: Success: 0 Failure: 1 352 */ 353int octeon_delete_droq(struct octeon_device *oct_dev, u32 q_no); 354 355/** Register a change in droq operations. The ops field has a pointer to a 356 * function which will called by the DROQ handler for all packets arriving 357 * on output queues given by q_no irrespective of the type of packet. 358 * The ops field also has a flag which if set tells the DROQ handler to 359 * drop packets if it receives more than what it can process in one 360 * invocation of the handler. 361 * @param oct - octeon device 362 * @param q_no - octeon output queue number (0 <= q_no <= MAX_OCTEON_DROQ-1 363 * @param ops - the droq_ops settings for this queue 364 * @return - 0 on success, -ENODEV or -EINVAL on error. 365 */ 366int 367octeon_register_droq_ops(struct octeon_device *oct, 368 u32 q_no, 369 struct octeon_droq_ops *ops); 370 371/** Resets the function pointer and flag settings made by 372 * octeon_register_droq_ops(). After this routine is called, the DROQ handler 373 * will lookup dispatch function for each arriving packet on the output queue 374 * given by q_no. 375 * @param oct - octeon device 376 * @param q_no - octeon output queue number (0 <= q_no <= MAX_OCTEON_DROQ-1 377 * @return - 0 on success, -ENODEV or -EINVAL on error. 378 */ 379int octeon_unregister_droq_ops(struct octeon_device *oct, u32 q_no); 380 381/** Register a dispatch function for a opcode/subcode. The driver will call 382 * this dispatch function when it receives a packet with the given 383 * opcode/subcode in its output queues along with the user specified 384 * argument. 385 * @param oct - the octeon device to register with. 386 * @param opcode - the opcode for which the dispatch will be registered. 387 * @param subcode - the subcode for which the dispatch will be registered 388 * @param fn - the dispatch function. 389 * @param fn_arg - user specified that will be passed along with the 390 * dispatch function by the driver. 391 * @return Success: 0; Failure: 1 392 */ 393int octeon_register_dispatch_fn(struct octeon_device *oct, 394 u16 opcode, 395 u16 subcode, 396 octeon_dispatch_fn_t fn, void *fn_arg); 397 398void *octeon_get_dispatch_arg(struct octeon_device *oct, 399 u16 opcode, u16 subcode); 400 401void octeon_droq_print_stats(void); 402 403u32 octeon_droq_check_hw_for_pkts(struct octeon_droq *droq); 404 405int octeon_create_droq(struct octeon_device *oct, u32 q_no, 406 u32 num_descs, u32 desc_size, void *app_ctx); 407 408int octeon_droq_process_packets(struct octeon_device *oct, 409 struct octeon_droq *droq, 410 u32 budget); 411 412int octeon_droq_process_poll_pkts(struct octeon_device *oct, 413 struct octeon_droq *droq, u32 budget); 414 415int octeon_enable_irq(struct octeon_device *oct, u32 q_no); 416 417void octeon_droq_check_oom(struct octeon_droq *droq); 418 419#endif /*__OCTEON_DROQ_H__ */ 420