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 struct oct_nic_stats_resp {
  32         u64     rh;
  33         struct oct_link_stats stats;
  34         u64     status;
  35 };
  36
  37 struct oct_nic_stats_ctrl {
  38         struct completion complete;
  39         struct net_device *netdev;
  40 };
  41
  42 /** LiquidIO per-interface network private data */
  43 struct lio {
  44         /** State of the interface. Rx/Tx happens only in the RUNNING state.  */
  45         atomic_t ifstate;
  46
  47         /** Octeon Interface index number. This device will be represented as
  48          *  oct<ifidx> in the system.
  49          */
  50         int ifidx;
  51
  52         /** Octeon Input queue to use to transmit for this network interface. */
  53         int txq;
  54
  55         /** Octeon Output queue from which pkts arrive
  56          * for this network interface.
  57          */
  58         int rxq;
  59
  60         /** Guards each glist */
  61         spinlock_t *glist_lock;
  62
  63         /** Array of gather component linked lists */
  64         struct list_head *glist;
  65
  66         /** Pointer to the NIC properties for the Octeon device this network
  67          *  interface is associated with.
  68          */
  69         struct octdev_props *octprops;
  70
  71         /** Pointer to the octeon device structure. */
  72         struct octeon_device *oct_dev;
  73
  74         struct net_device *netdev;
  75
  76         /** Link information sent by the core application for this interface. */
  77         struct oct_link_info linfo;
  78
  79         /** counter of link changes */
  80         u64 link_changes;
  81
  82         /** Size of Tx queue for this octeon device. */
  83         u32 tx_qsize;
  84
  85         /** Size of Rx queue for this octeon device. */
  86         u32 rx_qsize;
  87
  88         /** Size of MTU this octeon device. */
  89         u32 mtu;
  90
  91         /** msg level flag per interface. */
  92         u32 msg_enable;
  93
  94         /** Copy of Interface capabilities: TSO, TSO6, LRO, Chescksums . */
  95         u64 dev_capability;
  96
  97         /* Copy of transmit encapsulation capabilities:
  98          * TSO, TSO6, Checksums for this device for Kernel
  99          * 3.10.0 onwards
 100          */
 101         u64 enc_dev_capability;
 102
 103         /** Copy of beacaon reg in phy */
 104         u32 phy_beacon_val;
 105
 106         /** Copy of ctrl reg in phy */
 107         u32 led_ctrl_val;
 108
 109         /* PTP clock information */
 110         struct ptp_clock_info ptp_info;
 111         struct ptp_clock *ptp_clock;
 112         s64 ptp_adjust;
 113
 114         /* for atomic access to Octeon PTP reg and data struct */
 115         spinlock_t ptp_lock;
 116
 117         /* Interface info */
 118         u32     intf_open;
 119
 120         /* work queue for  txq status */
 121         struct cavium_wq        txq_status_wq;
 122
 123         /* work queue for  link status */
 124         struct cavium_wq        link_status_wq;
 125
 126         int netdev_uc_count;
 127 };
 128
 129 #define LIO_SIZE         (sizeof(struct lio))
 130 #define GET_LIO(netdev)  ((struct lio *)netdev_priv(netdev))
 131
 132 #define CIU3_WDOG(c)                 (0x1010000020000ULL + ((c) << 3))
 133 #define CIU3_WDOG_MASK               12ULL
 134 #define LIO_MONITOR_WDOG_EXPIRE      1
 135 #define LIO_MONITOR_CORE_STUCK_MSGD  2
 136 #define LIO_MAX_CORES                12
 137
 138 /**
 139  * \brief Enable or disable feature
 140  * @param netdev    pointer to network device
 141  * @param cmd       Command that just requires acknowledgment
 142  * @param param1    Parameter to command
 143  */
 144 int liquidio_set_feature(struct net_device *netdev, int cmd, u16 param1);
 145
 146 /**
 147  * \brief Link control command completion callback
 148  * @param nctrl_ptr pointer to control packet structure
 149  *
 150  * This routine is called by the callback function when a ctrl pkt sent to
 151  * core app completes. The nctrl_ptr contains a copy of the command type
 152  * and data sent to the core app. This routine is only called if the ctrl
 153  * pkt was sent successfully to the core app.
 154  */
 155 void liquidio_link_ctrl_cmd_completion(void *nctrl_ptr);
 156
 157 /**
 158  * \brief Register ethtool operations
 159  * @param netdev    pointer to network device
 160  */
 161 void liquidio_set_ethtool_ops(struct net_device *netdev);
 162
 163 #define SKB_ADJ_MASK  0x3F
 164 #define SKB_ADJ       (SKB_ADJ_MASK + 1)
 165
 166 #define MIN_SKB_SIZE       256 /* 8 bytes and more - 8 bytes for PTP */
 167 #define LIO_RXBUFFER_SZ    2048
 168
 169 static inline void
 170 *recv_buffer_alloc(struct octeon_device *oct,
 171                    struct octeon_skb_page_info *pg_info)
 172 {
 173         struct page *page;
 174         struct sk_buff *skb;
 175         struct octeon_skb_page_info *skb_pg_info;
 176
 177         page = alloc_page(GFP_ATOMIC | __GFP_COLD);
 178         if (unlikely(!page))
 179                 return NULL;
 180
 181         skb = dev_alloc_skb(MIN_SKB_SIZE + SKB_ADJ);
 182         if (unlikely(!skb)) {
 183                 __free_page(page);
 184                 pg_info->page = NULL;
 185                 return NULL;
 186         }
 187
 188         if ((unsigned long)skb->data & SKB_ADJ_MASK) {
 189                 u32 r = SKB_ADJ - ((unsigned long)skb->data & SKB_ADJ_MASK);
 190
 191                 skb_reserve(skb, r);
 192         }
 193
 194         skb_pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 195         /* Get DMA info */
 196         pg_info->dma = dma_map_page(&oct->pci_dev->dev, page, 0,
 197                                     PAGE_SIZE, DMA_FROM_DEVICE);
 198
 199         /* Mapping failed!! */
 200         if (dma_mapping_error(&oct->pci_dev->dev, pg_info->dma)) {
 201                 __free_page(page);
 202                 dev_kfree_skb_any((struct sk_buff *)skb);
 203                 pg_info->page = NULL;
 204                 return NULL;
 205         }
 206
 207         pg_info->page = page;
 208         pg_info->page_offset = 0;
 209         skb_pg_info->page = page;
 210         skb_pg_info->page_offset = 0;
 211         skb_pg_info->dma = pg_info->dma;
 212
 213         return (void *)skb;
 214 }
 215
 216 static inline void
 217 *recv_buffer_fast_alloc(u32 size)
 218 {
 219         struct sk_buff *skb;
 220         struct octeon_skb_page_info *skb_pg_info;
 221
 222         skb = dev_alloc_skb(size + SKB_ADJ);
 223         if (unlikely(!skb))
 224                 return NULL;
 225
 226         if ((unsigned long)skb->data & SKB_ADJ_MASK) {
 227                 u32 r = SKB_ADJ - ((unsigned long)skb->data & SKB_ADJ_MASK);
 228
 229                 skb_reserve(skb, r);
 230         }
 231
 232         skb_pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 233         skb_pg_info->page = NULL;
 234         skb_pg_info->page_offset = 0;
 235         skb_pg_info->dma = 0;
 236
 237         return skb;
 238 }
 239
 240 static inline int
 241 recv_buffer_recycle(struct octeon_device *oct, void *buf)
 242 {
 243         struct octeon_skb_page_info *pg_info = buf;
 244
 245         if (!pg_info->page) {
 246                 dev_err(&oct->pci_dev->dev, "%s: pg_info->page NULL\n",
 247                         __func__);
 248                 return -ENOMEM;
 249         }
 250
 251         if (unlikely(page_count(pg_info->page) != 1) ||
 252             unlikely(page_to_nid(pg_info->page) != numa_node_id())) {
 253                 dma_unmap_page(&oct->pci_dev->dev,
 254                                pg_info->dma, (PAGE_SIZE << 0),
 255                                DMA_FROM_DEVICE);
 256                 pg_info->dma = 0;
 257                 pg_info->page = NULL;
 258                 pg_info->page_offset = 0;
 259                 return -ENOMEM;
 260         }
 261
 262         /* Flip to other half of the buffer */
 263         if (pg_info->page_offset == 0)
 264                 pg_info->page_offset = LIO_RXBUFFER_SZ;
 265         else
 266                 pg_info->page_offset = 0;
 267         page_ref_inc(pg_info->page);
 268
 269         return 0;
 270 }
 271
 272 static inline void
 273 *recv_buffer_reuse(struct octeon_device *oct, void *buf)
 274 {
 275         struct octeon_skb_page_info *pg_info = buf, *skb_pg_info;
 276         struct sk_buff *skb;
 277
 278         skb = dev_alloc_skb(MIN_SKB_SIZE + SKB_ADJ);
 279         if (unlikely(!skb)) {
 280                 dma_unmap_page(&oct->pci_dev->dev,
 281                                pg_info->dma, (PAGE_SIZE << 0),
 282                                DMA_FROM_DEVICE);
 283                 return NULL;
 284         }
 285
 286         if ((unsigned long)skb->data & SKB_ADJ_MASK) {
 287                 u32 r = SKB_ADJ - ((unsigned long)skb->data & SKB_ADJ_MASK);
 288
 289                 skb_reserve(skb, r);
 290         }
 291
 292         skb_pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 293         skb_pg_info->page = pg_info->page;
 294         skb_pg_info->page_offset = pg_info->page_offset;
 295         skb_pg_info->dma = pg_info->dma;
 296
 297         return skb;
 298 }
 299
 300 static inline void
 301 recv_buffer_destroy(void *buffer, struct octeon_skb_page_info *pg_info)
 302 {
 303         struct sk_buff *skb = (struct sk_buff *)buffer;
 304
 305         put_page(pg_info->page);
 306         pg_info->dma = 0;
 307         pg_info->page = NULL;
 308         pg_info->page_offset = 0;
 309
 310         if (skb)
 311                 dev_kfree_skb_any(skb);
 312 }
 313
 314 static inline void recv_buffer_free(void *buffer)
 315 {
 316         struct sk_buff *skb = (struct sk_buff *)buffer;
 317         struct octeon_skb_page_info *pg_info;
 318
 319         pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 320
 321         if (pg_info->page) {
 322                 put_page(pg_info->page);
 323                 pg_info->dma = 0;
 324                 pg_info->page = NULL;
 325                 pg_info->page_offset = 0;
 326         }
 327
 328         dev_kfree_skb_any((struct sk_buff *)buffer);
 329 }
 330
 331 static inline void
 332 recv_buffer_fast_free(void *buffer)
 333 {
 334         dev_kfree_skb_any((struct sk_buff *)buffer);
 335 }
 336
 337 static inline void tx_buffer_free(void *buffer)
 338 {
 339         dev_kfree_skb_any((struct sk_buff *)buffer);
 340 }
 341
 342 #define lio_dma_alloc(oct, size, dma_addr) \
 343         dma_alloc_coherent(&(oct)->pci_dev->dev, size, dma_addr, GFP_KERNEL)
 344 #define lio_dma_free(oct, size, virt_addr, dma_addr) \
 345         dma_free_coherent(&(oct)->pci_dev->dev, size, virt_addr, dma_addr)
 346
 347 static inline
 348 void *get_rbd(struct sk_buff *skb)
 349 {
 350         struct octeon_skb_page_info *pg_info;
 351         unsigned char *va;
 352
 353         pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 354         va = page_address(pg_info->page) + pg_info->page_offset;
 355
 356         return va;
 357 }
 358
 359 static inline u64
 360 lio_map_ring_info(struct octeon_droq *droq, u32 i)
 361 {
 362         dma_addr_t dma_addr;
 363         struct octeon_device *oct = droq->oct_dev;
 364
 365         dma_addr = dma_map_single(&oct->pci_dev->dev, &droq->info_list[i],
 366                                   OCT_DROQ_INFO_SIZE, DMA_FROM_DEVICE);
 367
 368         WARN_ON(dma_mapping_error(&oct->pci_dev->dev, dma_addr));
 369
 370         return (u64)dma_addr;
 371 }
 372
 373 static inline void
 374 lio_unmap_ring_info(struct pci_dev *pci_dev,
 375                     u64 info_ptr, u32 size)
 376 {
 377         dma_unmap_single(&pci_dev->dev, info_ptr, size, DMA_FROM_DEVICE);
 378 }
 379
 380 static inline u64
 381 lio_map_ring(void *buf)
 382 {
 383         dma_addr_t dma_addr;
 384
 385         struct sk_buff *skb = (struct sk_buff *)buf;
 386         struct octeon_skb_page_info *pg_info;
 387
 388         pg_info = ((struct octeon_skb_page_info *)(skb->cb));
 389         if (!pg_info->page) {
 390                 pr_err("%s: pg_info->page NULL\n", __func__);
 391                 WARN_ON(1);
 392         }
 393
 394         /* Get DMA info */
 395         dma_addr = pg_info->dma;
 396         if (!pg_info->dma) {
 397                 pr_err("%s: ERROR it should be already available\n",
 398                        __func__);
 399                 WARN_ON(1);
 400         }
 401         dma_addr += pg_info->page_offset;
 402
 403         return (u64)dma_addr;
 404 }
 405
 406 static inline void
 407 lio_unmap_ring(struct pci_dev *pci_dev,
 408                u64 buf_ptr)
 409
 410 {
 411         dma_unmap_page(&pci_dev->dev,
 412                        buf_ptr, (PAGE_SIZE << 0),
 413                        DMA_FROM_DEVICE);
 414 }
 415
 416 static inline void *octeon_fast_packet_alloc(u32 size)
 417 {
 418         return recv_buffer_fast_alloc(size);
 419 }
 420
 421 static inline void octeon_fast_packet_next(struct octeon_droq *droq,
 422                                            struct sk_buff *nicbuf,
 423                                            int copy_len,
 424                                            int idx)
 425 {
 426         memcpy(skb_put(nicbuf, copy_len),
 427                get_rbd(droq->recv_buf_list[idx].buffer), copy_len);
 428 }
 429
 430 #endif