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 17 * details. 18 **********************************************************************/ 19 20 /*! \file octeon_network.h 21 * \brief Host NIC Driver: Structure and Macro definitions used by NIC Module. 22 */ 23 24 #ifndef __OCTEON_NETWORK_H__ 25 #define __OCTEON_NETWORK_H__ 26 #include <linux/ptp_clock_kernel.h> 27 28 #define LIO_MAX_MTU_SIZE (OCTNET_MAX_FRM_SIZE - OCTNET_FRM_HEADER_SIZE) 29 #define LIO_MIN_MTU_SIZE ETH_MIN_MTU 30 31 /* Bit mask values for lio->ifstate */ 32 #define LIO_IFSTATE_DROQ_OPS 0x01 33 #define LIO_IFSTATE_REGISTERED 0x02 34 #define LIO_IFSTATE_RUNNING 0x04 35 #define LIO_IFSTATE_RX_TIMESTAMP_ENABLED 0x08 36 #define LIO_IFSTATE_RESETTING 0x10 37 38 struct oct_nic_stats_resp { 39 u64 rh; 40 struct oct_link_stats stats; 41 u64 status; 42 }; 43 44 struct oct_nic_stats_ctrl { 45 struct completion complete; 46 struct net_device *netdev; 47 }; 48 49 /** LiquidIO per-interface network private data */ 50 struct lio { 51 /** State of the interface. Rx/Tx happens only in the RUNNING state. */ 52 atomic_t ifstate; 53 54 /** Octeon Interface index number. This device will be represented as 55 * oct<ifidx> in the system. 56 */ 57 int ifidx; 58 59 /** Octeon Input queue to use to transmit for this network interface. */ 60 int txq; 61 62 /** Octeon Output queue from which pkts arrive 63 * for this network interface. 64 */ 65 int rxq; 66 67 /** Guards each glist */ 68 spinlock_t *glist_lock; 69 70 /** Array of gather component linked lists */ 71 struct list_head *glist; 72 void **glists_virt_base; 73 dma_addr_t *glists_dma_base; 74 u32 glist_entry_size; 75 76 /** Pointer to the NIC properties for the Octeon device this network 77 * interface is associated with. 78 */ 79 struct octdev_props *octprops; 80 81 /** Pointer to the octeon device structure. */ 82 struct octeon_device *oct_dev; 83 84 struct net_device *netdev; 85 86 /** Link information sent by the core application for this interface. */ 87 struct oct_link_info linfo; 88 89 /** counter of link changes */ 90 u64 link_changes; 91 92 /** Size of Tx queue for this octeon device. */ 93 u32 tx_qsize; 94 95 /** Size of Rx queue for this octeon device. */ 96 u32 rx_qsize; 97 98 /** Size of MTU this octeon device. */ 99 u32 mtu; 100 101 /** msg level flag per interface. */ 102 u32 msg_enable; 103 104 /** Copy of Interface capabilities: TSO, TSO6, LRO, Chescksums . */ 105 u64 dev_capability; 106 107 /* Copy of transmit encapsulation capabilities: 108 * TSO, TSO6, Checksums for this device for Kernel 109 * 3.10.0 onwards 110 */ 111 u64 enc_dev_capability; 112 113 /** Copy of beacaon reg in phy */ 114 u32 phy_beacon_val; 115 116 /** Copy of ctrl reg in phy */ 117 u32 led_ctrl_val; 118 119 /* PTP clock information */ 120 struct ptp_clock_info ptp_info; 121 struct ptp_clock *ptp_clock; 122 s64 ptp_adjust; 123 124 /* for atomic access to Octeon PTP reg and data struct */ 125 spinlock_t ptp_lock; 126 127 /* Interface info */ 128 u32 intf_open; 129 130 /* work queue for txq status */ 131 struct cavium_wq txq_status_wq; 132 133 /* work queue for rxq oom status */ 134 struct cavium_wq rxq_status_wq; 135 136 /* work queue for link status */ 137 struct cavium_wq link_status_wq; 138 139 /* work queue to regularly send local time to octeon firmware */ 140 struct cavium_wq sync_octeon_time_wq; 141 142 int netdev_uc_count; 143 }; 144 145 #define LIO_SIZE (sizeof(struct lio)) 146 #define GET_LIO(netdev) ((struct lio *)netdev_priv(netdev)) 147 148 #define LIO_MAX_CORES 12 149 150 /** 151 * \brief Enable or disable feature 152 * @param netdev pointer to network device 153 * @param cmd Command that just requires acknowledgment 154 * @param param1 Parameter to command 155 */ 156 int liquidio_set_feature(struct net_device *netdev, int cmd, u16 param1); 157 158 int setup_rx_oom_poll_fn(struct net_device *netdev); 159 160 void cleanup_rx_oom_poll_fn(struct net_device *netdev); 161 162 /** 163 * \brief Link control command completion callback 164 * @param nctrl_ptr pointer to control packet structure 165 * 166 * This routine is called by the callback function when a ctrl pkt sent to 167 * core app completes. The nctrl_ptr contains a copy of the command type 168 * and data sent to the core app. This routine is only called if the ctrl 169 * pkt was sent successfully to the core app. 170 */ 171 void liquidio_link_ctrl_cmd_completion(void *nctrl_ptr); 172 173 int liquidio_setup_io_queues(struct octeon_device *octeon_dev, int ifidx, 174 u32 num_iqs, u32 num_oqs); 175 176 irqreturn_t liquidio_msix_intr_handler(int irq __attribute__((unused)), 177 void *dev); 178 179 int octeon_setup_interrupt(struct octeon_device *oct, u32 num_ioqs); 180 181 /** 182 * \brief Register ethtool operations 183 * @param netdev pointer to network device 184 */ 185 void liquidio_set_ethtool_ops(struct net_device *netdev); 186 187 #define SKB_ADJ_MASK 0x3F 188 #define SKB_ADJ (SKB_ADJ_MASK + 1) 189 190 #define MIN_SKB_SIZE 256 /* 8 bytes and more - 8 bytes for PTP */ 191 #define LIO_RXBUFFER_SZ 2048 192 193 static inline void 194 *recv_buffer_alloc(struct octeon_device *oct, 195 struct octeon_skb_page_info *pg_info) 196 { 197 struct page *page; 198 struct sk_buff *skb; 199 struct octeon_skb_page_info *skb_pg_info; 200 201 page = alloc_page(GFP_ATOMIC); 202 if (unlikely(!page)) 203 return NULL; 204 205 skb = dev_alloc_skb(MIN_SKB_SIZE + SKB_ADJ); 206 if (unlikely(!skb)) { 207 __free_page(page); 208 pg_info->page = NULL; 209 return NULL; 210 } 211 212 if ((unsigned long)skb->data & SKB_ADJ_MASK) { 213 u32 r = SKB_ADJ - ((unsigned long)skb->data & SKB_ADJ_MASK); 214 215 skb_reserve(skb, r); 216 } 217 218 skb_pg_info = ((struct octeon_skb_page_info *)(skb->cb)); 219 /* Get DMA info */ 220 pg_info->dma = dma_map_page(&oct->pci_dev->dev, page, 0, 221 PAGE_SIZE, DMA_FROM_DEVICE); 222 223 /* Mapping failed!! */ 224 if (dma_mapping_error(&oct->pci_dev->dev, pg_info->dma)) { 225 __free_page(page); 226 dev_kfree_skb_any((struct sk_buff *)skb); 227 pg_info->page = NULL; 228 return NULL; 229 } 230 231 pg_info->page = page; 232 pg_info->page_offset = 0; 233 skb_pg_info->page = page; 234 skb_pg_info->page_offset = 0; 235 skb_pg_info->dma = pg_info->dma; 236 237 return (void *)skb; 238 } 239 240 static inline void 241 *recv_buffer_fast_alloc(u32 size) 242 { 243 struct sk_buff *skb; 244 struct octeon_skb_page_info *skb_pg_info; 245 246 skb = dev_alloc_skb(size + SKB_ADJ); 247 if (unlikely(!skb)) 248 return NULL; 249 250 if ((unsigned long)skb->data & SKB_ADJ_MASK) { 251 u32 r = SKB_ADJ - ((unsigned long)skb->data & SKB_ADJ_MASK); 252 253 skb_reserve(skb, r); 254 } 255 256 skb_pg_info = ((struct octeon_skb_page_info *)(skb->cb)); 257 skb_pg_info->page = NULL; 258 skb_pg_info->page_offset = 0; 259 skb_pg_info->dma = 0; 260 261 return skb; 262 } 263 264 static inline int 265 recv_buffer_recycle(struct octeon_device *oct, void *buf) 266 { 267 struct octeon_skb_page_info *pg_info = buf; 268 269 if (!pg_info->page) { 270 dev_err(&oct->pci_dev->dev, "%s: pg_info->page NULL\n", 271 __func__); 272 return -ENOMEM; 273 } 274 275 if (unlikely(page_count(pg_info->page) != 1) || 276 unlikely(page_to_nid(pg_info->page) != numa_node_id())) { 277 dma_unmap_page(&oct->pci_dev->dev, 278 pg_info->dma, (PAGE_SIZE << 0), 279 DMA_FROM_DEVICE); 280 pg_info->dma = 0; 281 pg_info->page = NULL; 282 pg_info->page_offset = 0; 283 return -ENOMEM; 284 } 285 286 /* Flip to other half of the buffer */ 287 if (pg_info->page_offset == 0) 288 pg_info->page_offset = LIO_RXBUFFER_SZ; 289 else 290 pg_info->page_offset = 0; 291 page_ref_inc(pg_info->page); 292 293 return 0; 294 } 295 296 static inline void 297 *recv_buffer_reuse(struct octeon_device *oct, void *buf) 298 { 299 struct octeon_skb_page_info *pg_info = buf, *skb_pg_info; 300 struct sk_buff *skb; 301 302 skb = dev_alloc_skb(MIN_SKB_SIZE + SKB_ADJ); 303 if (unlikely(!skb)) { 304 dma_unmap_page(&oct->pci_dev->dev, 305 pg_info->dma, (PAGE_SIZE << 0), 306 DMA_FROM_DEVICE); 307 return NULL; 308 } 309 310 if ((unsigned long)skb->data & SKB_ADJ_MASK) { 311 u32 r = SKB_ADJ - ((unsigned long)skb->data & SKB_ADJ_MASK); 312 313 skb_reserve(skb, r); 314 } 315 316 skb_pg_info = ((struct octeon_skb_page_info *)(skb->cb)); 317 skb_pg_info->page = pg_info->page; 318 skb_pg_info->page_offset = pg_info->page_offset; 319 skb_pg_info->dma = pg_info->dma; 320 321 return skb; 322 } 323 324 static inline void 325 recv_buffer_destroy(void *buffer, struct octeon_skb_page_info *pg_info) 326 { 327 struct sk_buff *skb = (struct sk_buff *)buffer; 328 329 put_page(pg_info->page); 330 pg_info->dma = 0; 331 pg_info->page = NULL; 332 pg_info->page_offset = 0; 333 334 if (skb) 335 dev_kfree_skb_any(skb); 336 } 337 338 static inline void recv_buffer_free(void *buffer) 339 { 340 struct sk_buff *skb = (struct sk_buff *)buffer; 341 struct octeon_skb_page_info *pg_info; 342 343 pg_info = ((struct octeon_skb_page_info *)(skb->cb)); 344 345 if (pg_info->page) { 346 put_page(pg_info->page); 347 pg_info->dma = 0; 348 pg_info->page = NULL; 349 pg_info->page_offset = 0; 350 } 351 352 dev_kfree_skb_any((struct sk_buff *)buffer); 353 } 354 355 static inline void 356 recv_buffer_fast_free(void *buffer) 357 { 358 dev_kfree_skb_any((struct sk_buff *)buffer); 359 } 360 361 static inline void tx_buffer_free(void *buffer) 362 { 363 dev_kfree_skb_any((struct sk_buff *)buffer); 364 } 365 366 #define lio_dma_alloc(oct, size, dma_addr) \ 367 dma_alloc_coherent(&(oct)->pci_dev->dev, size, dma_addr, GFP_KERNEL) 368 #define lio_dma_free(oct, size, virt_addr, dma_addr) \ 369 dma_free_coherent(&(oct)->pci_dev->dev, size, virt_addr, dma_addr) 370 371 static inline 372 void *get_rbd(struct sk_buff *skb) 373 { 374 struct octeon_skb_page_info *pg_info; 375 unsigned char *va; 376 377 pg_info = ((struct octeon_skb_page_info *)(skb->cb)); 378 va = page_address(pg_info->page) + pg_info->page_offset; 379 380 return va; 381 } 382 383 static inline u64 384 lio_map_ring(void *buf) 385 { 386 dma_addr_t dma_addr; 387 388 struct sk_buff *skb = (struct sk_buff *)buf; 389 struct octeon_skb_page_info *pg_info; 390 391 pg_info = ((struct octeon_skb_page_info *)(skb->cb)); 392 if (!pg_info->page) { 393 pr_err("%s: pg_info->page NULL\n", __func__); 394 WARN_ON(1); 395 } 396 397 /* Get DMA info */ 398 dma_addr = pg_info->dma; 399 if (!pg_info->dma) { 400 pr_err("%s: ERROR it should be already available\n", 401 __func__); 402 WARN_ON(1); 403 } 404 dma_addr += pg_info->page_offset; 405 406 return (u64)dma_addr; 407 } 408 409 static inline void 410 lio_unmap_ring(struct pci_dev *pci_dev, 411 u64 buf_ptr) 412 413 { 414 dma_unmap_page(&pci_dev->dev, 415 buf_ptr, (PAGE_SIZE << 0), 416 DMA_FROM_DEVICE); 417 } 418 419 static inline void *octeon_fast_packet_alloc(u32 size) 420 { 421 return recv_buffer_fast_alloc(size); 422 } 423 424 static inline void octeon_fast_packet_next(struct octeon_droq *droq, 425 struct sk_buff *nicbuf, 426 int copy_len, 427 int idx) 428 { 429 skb_put_data(nicbuf, get_rbd(droq->recv_buf_list[idx].buffer), 430 copy_len); 431 } 432 433 /** 434 * \brief check interface state 435 * @param lio per-network private data 436 * @param state_flag flag state to check 437 */ 438 static inline int ifstate_check(struct lio *lio, int state_flag) 439 { 440 return atomic_read(&lio->ifstate) & state_flag; 441 } 442 443 /** 444 * \brief set interface state 445 * @param lio per-network private data 446 * @param state_flag flag state to set 447 */ 448 static inline void ifstate_set(struct lio *lio, int state_flag) 449 { 450 atomic_set(&lio->ifstate, (atomic_read(&lio->ifstate) | state_flag)); 451 } 452 453 /** 454 * \brief clear interface state 455 * @param lio per-network private data 456 * @param state_flag flag state to clear 457 */ 458 static inline void ifstate_reset(struct lio *lio, int state_flag) 459 { 460 atomic_set(&lio->ifstate, (atomic_read(&lio->ifstate) & ~(state_flag))); 461 } 462 463 /** 464 * \brief wait for all pending requests to complete 465 * @param oct Pointer to Octeon device 466 * 467 * Called during shutdown sequence 468 */ 469 static inline int wait_for_pending_requests(struct octeon_device *oct) 470 { 471 int i, pcount = 0; 472 473 for (i = 0; i < MAX_IO_PENDING_PKT_COUNT; i++) { 474 pcount = atomic_read( 475 &oct->response_list[OCTEON_ORDERED_SC_LIST] 476 .pending_req_count); 477 if (pcount) 478 schedule_timeout_uninterruptible(HZ / 10); 479 else 480 break; 481 } 482 483 if (pcount) 484 return 1; 485 486 return 0; 487 } 488 489 #endif 490