drivers/net/ethernet/cavium/liquidio/octeon_network.h

   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         int netdev_uc_count;
 140 };
 141
 142 #define LIO_SIZE         (sizeof(struct lio))
 143 #define GET_LIO(netdev)  ((struct lio *)netdev_priv(netdev))
 144
 145 #define LIO_MAX_CORES                12
 146
 147 /**
 148  * \brief Enable or disable feature
 149  * @param netdev    pointer to network device
 150  * @param cmd       Command that just requires acknowledgment
 151  * @param param1    Parameter to command
 152  */
 153 int liquidio_set_feature(struct net_device *netdev, int cmd, u16 param1);
 154
 155 int setup_rx_oom_poll_fn(struct net_device *netdev);
 156
 157 void cleanup_rx_oom_poll_fn(struct net_device *netdev);
 158
 159 /**
 160  * \brief Link control command completion callback
 161  * @param nctrl_ptr pointer to control packet structure
 162  *
 163  * This routine is called by the callback function when a ctrl pkt sent to
 164  * core app completes. The nctrl_ptr contains a copy of the command type
 165  * and data sent to the core app. This routine is only called if the ctrl
 166  * pkt was sent successfully to the core app.
 167  */
 168 void liquidio_link_ctrl_cmd_completion(void *nctrl_ptr);
 169
 170 int liquidio_setup_io_queues(struct octeon_device *octeon_dev, int ifidx);
 171
 172 /**
 173  * \brief Register ethtool operations
 174  * @param netdev    pointer to network device
 175  */
 176 void liquidio_set_ethtool_ops(struct net_device *netdev);
 177
 178 #define SKB_ADJ_MASK  0x3F
 179 #define SKB_ADJ       (SKB_ADJ_MASK + 1)
 180
 181 #define MIN_SKB_SIZE       256 /* 8 bytes and more - 8 bytes for PTP */
 182 #define LIO_RXBUFFER_SZ    2048
 183
 184 static inline void
 185 *recv_buffer_alloc(struct octeon_device *oct,
 186                    struct octeon_skb_page_info *pg_info)
 187 {
 188         struct page *page;
 189         struct sk_buff *skb;
 190         struct octeon_skb_page_info *skb_pg_info;
 191
 192         page = alloc_page(GFP_ATOMIC | __GFP_COLD);
 193         if (unlikely(!page))
 194                 return NULL;
 195
 196         skb = dev_alloc_skb(MIN_SKB_SIZE + SKB_ADJ);
 197         if (unlikely(!skb)) {
 198                 __free_page(page);
 199                 pg_info->page = NULL;
 200                 return NULL;
 201         }
 202
 203         if ((unsigned long)skb->data & SKB_ADJ_MASK) {
 204                 u32 r = SKB_ADJ - ((unsigned long)skb->data & SKB_ADJ_MASK);
 205
 206                 skb_reserve(skb, r);
 207         }
 208
 209         skb_pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 210         /* Get DMA info */
 211         pg_info->dma = dma_map_page(&oct->pci_dev->dev, page, 0,
 212                                     PAGE_SIZE, DMA_FROM_DEVICE);
 213
 214         /* Mapping failed!! */
 215         if (dma_mapping_error(&oct->pci_dev->dev, pg_info->dma)) {
 216                 __free_page(page);
 217                 dev_kfree_skb_any((struct sk_buff *)skb);
 218                 pg_info->page = NULL;
 219                 return NULL;
 220         }
 221
 222         pg_info->page = page;
 223         pg_info->page_offset = 0;
 224         skb_pg_info->page = page;
 225         skb_pg_info->page_offset = 0;
 226         skb_pg_info->dma = pg_info->dma;
 227
 228         return (void *)skb;
 229 }
 230
 231 static inline void
 232 *recv_buffer_fast_alloc(u32 size)
 233 {
 234         struct sk_buff *skb;
 235         struct octeon_skb_page_info *skb_pg_info;
 236
 237         skb = dev_alloc_skb(size + SKB_ADJ);
 238         if (unlikely(!skb))
 239                 return NULL;
 240
 241         if ((unsigned long)skb->data & SKB_ADJ_MASK) {
 242                 u32 r = SKB_ADJ - ((unsigned long)skb->data & SKB_ADJ_MASK);
 243
 244                 skb_reserve(skb, r);
 245         }
 246
 247         skb_pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 248         skb_pg_info->page = NULL;
 249         skb_pg_info->page_offset = 0;
 250         skb_pg_info->dma = 0;
 251
 252         return skb;
 253 }
 254
 255 static inline int
 256 recv_buffer_recycle(struct octeon_device *oct, void *buf)
 257 {
 258         struct octeon_skb_page_info *pg_info = buf;
 259
 260         if (!pg_info->page) {
 261                 dev_err(&oct->pci_dev->dev, "%s: pg_info->page NULL\n",
 262                         __func__);
 263                 return -ENOMEM;
 264         }
 265
 266         if (unlikely(page_count(pg_info->page) != 1) ||
 267             unlikely(page_to_nid(pg_info->page) != numa_node_id())) {
 268                 dma_unmap_page(&oct->pci_dev->dev,
 269                                pg_info->dma, (PAGE_SIZE << 0),
 270                                DMA_FROM_DEVICE);
 271                 pg_info->dma = 0;
 272                 pg_info->page = NULL;
 273                 pg_info->page_offset = 0;
 274                 return -ENOMEM;
 275         }
 276
 277         /* Flip to other half of the buffer */
 278         if (pg_info->page_offset == 0)
 279                 pg_info->page_offset = LIO_RXBUFFER_SZ;
 280         else
 281                 pg_info->page_offset = 0;
 282         page_ref_inc(pg_info->page);
 283
 284         return 0;
 285 }
 286
 287 static inline void
 288 *recv_buffer_reuse(struct octeon_device *oct, void *buf)
 289 {
 290         struct octeon_skb_page_info *pg_info = buf, *skb_pg_info;
 291         struct sk_buff *skb;
 292
 293         skb = dev_alloc_skb(MIN_SKB_SIZE + SKB_ADJ);
 294         if (unlikely(!skb)) {
 295                 dma_unmap_page(&oct->pci_dev->dev,
 296                                pg_info->dma, (PAGE_SIZE << 0),
 297                                DMA_FROM_DEVICE);
 298                 return NULL;
 299         }
 300
 301         if ((unsigned long)skb->data & SKB_ADJ_MASK) {
 302                 u32 r = SKB_ADJ - ((unsigned long)skb->data & SKB_ADJ_MASK);
 303
 304                 skb_reserve(skb, r);
 305         }
 306
 307         skb_pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 308         skb_pg_info->page = pg_info->page;
 309         skb_pg_info->page_offset = pg_info->page_offset;
 310         skb_pg_info->dma = pg_info->dma;
 311
 312         return skb;
 313 }
 314
 315 static inline void
 316 recv_buffer_destroy(void *buffer, struct octeon_skb_page_info *pg_info)
 317 {
 318         struct sk_buff *skb = (struct sk_buff *)buffer;
 319
 320         put_page(pg_info->page);
 321         pg_info->dma = 0;
 322         pg_info->page = NULL;
 323         pg_info->page_offset = 0;
 324
 325         if (skb)
 326                 dev_kfree_skb_any(skb);
 327 }
 328
 329 static inline void recv_buffer_free(void *buffer)
 330 {
 331         struct sk_buff *skb = (struct sk_buff *)buffer;
 332         struct octeon_skb_page_info *pg_info;
 333
 334         pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 335
 336         if (pg_info->page) {
 337                 put_page(pg_info->page);
 338                 pg_info->dma = 0;
 339                 pg_info->page = NULL;
 340                 pg_info->page_offset = 0;
 341         }
 342
 343         dev_kfree_skb_any((struct sk_buff *)buffer);
 344 }
 345
 346 static inline void
 347 recv_buffer_fast_free(void *buffer)
 348 {
 349         dev_kfree_skb_any((struct sk_buff *)buffer);
 350 }
 351
 352 static inline void tx_buffer_free(void *buffer)
 353 {
 354         dev_kfree_skb_any((struct sk_buff *)buffer);
 355 }
 356
 357 #define lio_dma_alloc(oct, size, dma_addr) \
 358         dma_alloc_coherent(&(oct)->pci_dev->dev, size, dma_addr, GFP_KERNEL)
 359 #define lio_dma_free(oct, size, virt_addr, dma_addr) \
 360         dma_free_coherent(&(oct)->pci_dev->dev, size, virt_addr, dma_addr)
 361
 362 static inline
 363 void *get_rbd(struct sk_buff *skb)
 364 {
 365         struct octeon_skb_page_info *pg_info;
 366         unsigned char *va;
 367
 368         pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 369         va = page_address(pg_info->page) + pg_info->page_offset;
 370
 371         return va;
 372 }
 373
 374 static inline u64
 375 lio_map_ring(void *buf)
 376 {
 377         dma_addr_t dma_addr;
 378
 379         struct sk_buff *skb = (struct sk_buff *)buf;
 380         struct octeon_skb_page_info *pg_info;
 381
 382         pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 383         if (!pg_info->page) {
 384                 pr_err("%s: pg_info->page NULL\n", __func__);
 385                 WARN_ON(1);
 386         }
 387
 388         /* Get DMA info */
 389         dma_addr = pg_info->dma;
 390         if (!pg_info->dma) {
 391                 pr_err("%s: ERROR it should be already available\n",
 392                        __func__);
 393                 WARN_ON(1);
 394         }
 395         dma_addr += pg_info->page_offset;
 396
 397         return (u64)dma_addr;
 398 }
 399
 400 static inline void
 401 lio_unmap_ring(struct pci_dev *pci_dev,
 402                u64 buf_ptr)
 403
 404 {
 405         dma_unmap_page(&pci_dev->dev,
 406                        buf_ptr, (PAGE_SIZE << 0),
 407                        DMA_FROM_DEVICE);
 408 }
 409
 410 static inline void *octeon_fast_packet_alloc(u32 size)
 411 {
 412         return recv_buffer_fast_alloc(size);
 413 }
 414
 415 static inline void octeon_fast_packet_next(struct octeon_droq *droq,
 416                                            struct sk_buff *nicbuf,
 417                                            int copy_len,
 418                                            int idx)
 419 {
 420         skb_put_data(nicbuf, get_rbd(droq->recv_buf_list[idx].buffer),
 421                      copy_len);
 422 }
 423
 424 /**
 425  * \brief check interface state
 426  * @param lio per-network private data
 427  * @param state_flag flag state to check
 428  */
 429 static inline int ifstate_check(struct lio *lio, int state_flag)
 430 {
 431         return atomic_read(&lio->ifstate) & state_flag;
 432 }
 433
 434 /**
 435  * \brief set interface state
 436  * @param lio per-network private data
 437  * @param state_flag flag state to set
 438  */
 439 static inline void ifstate_set(struct lio *lio, int state_flag)
 440 {
 441         atomic_set(&lio->ifstate, (atomic_read(&lio->ifstate) | state_flag));
 442 }
 443
 444 /**
 445  * \brief clear interface state
 446  * @param lio per-network private data
 447  * @param state_flag flag state to clear
 448  */
 449 static inline void ifstate_reset(struct lio *lio, int state_flag)
 450 {
 451         atomic_set(&lio->ifstate, (atomic_read(&lio->ifstate) & ~(state_flag)));
 452 }
 453
 454 /**
 455  * \brief wait for all pending requests to complete
 456  * @param oct Pointer to Octeon device
 457  *
 458  * Called during shutdown sequence
 459  */
 460 static inline int wait_for_pending_requests(struct octeon_device *oct)
 461 {
 462         int i, pcount = 0;
 463
 464         for (i = 0; i < MAX_IO_PENDING_PKT_COUNT; i++) {
 465                 pcount = atomic_read(
 466                     &oct->response_list[OCTEON_ORDERED_SC_LIST]
 467                          .pending_req_count);
 468                 if (pcount)
 469                         schedule_timeout_uninterruptible(HZ / 10);
 470                 else
 471                         break;
 472         }
 473
 474         if (pcount)
 475                 return 1;
 476
 477         return 0;
 478 }
 479
 480 #endif