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         /* 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