drivers/infiniband/hw/vmw_pvrdma/pvrdma.h

   1 /*
   2  * Copyright (c) 2012-2016 VMware, Inc.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of EITHER the GNU General Public License
   6  * version 2 as published by the Free Software Foundation or the BSD
   7  * 2-Clause License. This program is distributed in the hope that it
   8  * will be useful, but WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED
   9  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  10  * See the GNU General Public License version 2 for more details at
  11  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program available in the file COPYING in the main
  15  * directory of this source tree.
  16  *
  17  * The BSD 2-Clause License
  18  *
  19  *     Redistribution and use in source and binary forms, with or
  20  *     without modification, are permitted provided that the following
  21  *     conditions are met:
  22  *
  23  *      - Redistributions of source code must retain the above
  24  *        copyright notice, this list of conditions and the following
  25  *        disclaimer.
  26  *
  27  *      - Redistributions in binary form must reproduce the above
  28  *        copyright notice, this list of conditions and the following
  29  *        disclaimer in the documentation and/or other materials
  30  *        provided with the distribution.
  31  *
  32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  35  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  36  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  37  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  38  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  39  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  40  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  41  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  42  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  43  * OF THE POSSIBILITY OF SUCH DAMAGE.
  44  */
  45
  46 #ifndef __PVRDMA_H__
  47 #define __PVRDMA_H__
  48
  49 #include <linux/compiler.h>
  50 #include <linux/interrupt.h>
  51 #include <linux/list.h>
  52 #include <linux/mutex.h>
  53 #include <linux/pci.h>
  54 #include <linux/semaphore.h>
  55 #include <linux/workqueue.h>
  56 #include <rdma/ib_umem.h>
  57 #include <rdma/ib_verbs.h>
  58 #include <rdma/vmw_pvrdma-abi.h>
  59
  60 #include "pvrdma_ring.h"
  61 #include "pvrdma_dev_api.h"
  62 #include "pvrdma_verbs.h"
  63
  64 /* NOT the same as BIT_MASK(). */
  65 #define PVRDMA_MASK(n) ((n << 1) - 1)
  66
  67 /*
  68  * VMware PVRDMA PCI device id.
  69  */
  70 #define PCI_DEVICE_ID_VMWARE_PVRDMA     0x0820
  71
  72 #define PVRDMA_NUM_RING_PAGES           4
  73 #define PVRDMA_QP_NUM_HEADER_PAGES      1
  74
  75 struct pvrdma_dev;
  76
  77 struct pvrdma_page_dir {
  78         dma_addr_t dir_dma;
  79         u64 *dir;
  80         int ntables;
  81         u64 **tables;
  82         u64 npages;
  83         void **pages;
  84 };
  85
  86 struct pvrdma_cq {
  87         struct ib_cq ibcq;
  88         int offset;
  89         spinlock_t cq_lock; /* Poll lock. */
  90         struct pvrdma_uar_map *uar;
  91         struct ib_umem *umem;
  92         struct pvrdma_ring_state *ring_state;
  93         struct pvrdma_page_dir pdir;
  94         u32 cq_handle;
  95         bool is_kernel;
  96         atomic_t refcnt;
  97         wait_queue_head_t wait;
  98 };
  99
 100 struct pvrdma_id_table {
 101         u32 last;
 102         u32 top;
 103         u32 max;
 104         u32 mask;
 105         spinlock_t lock; /* Table lock. */
 106         unsigned long *table;
 107 };
 108
 109 struct pvrdma_uar_map {
 110         unsigned long pfn;
 111         void __iomem *map;
 112         int index;
 113 };
 114
 115 struct pvrdma_uar_table {
 116         struct pvrdma_id_table tbl;
 117         int size;
 118 };
 119
 120 struct pvrdma_ucontext {
 121         struct ib_ucontext ibucontext;
 122         struct pvrdma_dev *dev;
 123         struct pvrdma_uar_map uar;
 124         u64 ctx_handle;
 125 };
 126
 127 struct pvrdma_pd {
 128         struct ib_pd ibpd;
 129         u32 pdn;
 130         u32 pd_handle;
 131         int privileged;
 132 };
 133
 134 struct pvrdma_mr {
 135         u32 mr_handle;
 136         u64 iova;
 137         u64 size;
 138 };
 139
 140 struct pvrdma_user_mr {
 141         struct ib_mr ibmr;
 142         struct ib_umem *umem;
 143         struct pvrdma_mr mmr;
 144         struct pvrdma_page_dir pdir;
 145         u64 *pages;
 146         u32 npages;
 147         u32 max_pages;
 148         u32 page_shift;
 149 };
 150
 151 struct pvrdma_wq {
 152         struct pvrdma_ring *ring;
 153         spinlock_t lock; /* Work queue lock. */
 154         int wqe_cnt;
 155         int wqe_size;
 156         int max_sg;
 157         int offset;
 158 };
 159
 160 struct pvrdma_ah {
 161         struct ib_ah ibah;
 162         struct pvrdma_av av;
 163 };
 164
 165 struct pvrdma_qp {
 166         struct ib_qp ibqp;
 167         u32 qp_handle;
 168         u32 qkey;
 169         struct pvrdma_wq sq;
 170         struct pvrdma_wq rq;
 171         struct ib_umem *rumem;
 172         struct ib_umem *sumem;
 173         struct pvrdma_page_dir pdir;
 174         int npages;
 175         int npages_send;
 176         int npages_recv;
 177         u32 flags;
 178         u8 port;
 179         u8 state;
 180         bool is_kernel;
 181         struct mutex mutex; /* QP state mutex. */
 182         atomic_t refcnt;
 183         wait_queue_head_t wait;
 184 };
 185
 186 struct pvrdma_dev {
 187         /* PCI device-related information. */
 188         struct ib_device ib_dev;
 189         struct pci_dev *pdev;
 190         void __iomem *regs;
 191         struct pvrdma_device_shared_region *dsr; /* Shared region pointer */
 192         dma_addr_t dsrbase; /* Shared region base address */
 193         void *cmd_slot;
 194         void *resp_slot;
 195         unsigned long flags;
 196         struct list_head device_link;
 197
 198         /* Locking and interrupt information. */
 199         spinlock_t cmd_lock; /* Command lock. */
 200         struct semaphore cmd_sema;
 201         struct completion cmd_done;
 202         unsigned int nr_vectors;
 203
 204         /* RDMA-related device information. */
 205         union ib_gid *sgid_tbl;
 206         struct pvrdma_ring_state *async_ring_state;
 207         struct pvrdma_page_dir async_pdir;
 208         struct pvrdma_ring_state *cq_ring_state;
 209         struct pvrdma_page_dir cq_pdir;
 210         struct pvrdma_cq **cq_tbl;
 211         spinlock_t cq_tbl_lock;
 212         struct pvrdma_qp **qp_tbl;
 213         spinlock_t qp_tbl_lock;
 214         struct pvrdma_uar_table uar_table;
 215         struct pvrdma_uar_map driver_uar;
 216         __be64 sys_image_guid;
 217         spinlock_t desc_lock; /* Device modification lock. */
 218         u32 port_cap_mask;
 219         struct mutex port_mutex; /* Port modification mutex. */
 220         bool ib_active;
 221         atomic_t num_qps;
 222         atomic_t num_cqs;
 223         atomic_t num_pds;
 224         atomic_t num_ahs;
 225
 226         /* Network device information. */
 227         struct net_device *netdev;
 228         struct notifier_block nb_netdev;
 229 };
 230
 231 struct pvrdma_netdevice_work {
 232         struct work_struct work;
 233         struct net_device *event_netdev;
 234         unsigned long event;
 235 };
 236
 237 static inline struct pvrdma_dev *to_vdev(struct ib_device *ibdev)
 238 {
 239         return container_of(ibdev, struct pvrdma_dev, ib_dev);
 240 }
 241
 242 static inline struct
 243 pvrdma_ucontext *to_vucontext(struct ib_ucontext *ibucontext)
 244 {
 245         return container_of(ibucontext, struct pvrdma_ucontext, ibucontext);
 246 }
 247
 248 static inline struct pvrdma_pd *to_vpd(struct ib_pd *ibpd)
 249 {
 250         return container_of(ibpd, struct pvrdma_pd, ibpd);
 251 }
 252
 253 static inline struct pvrdma_cq *to_vcq(struct ib_cq *ibcq)
 254 {
 255         return container_of(ibcq, struct pvrdma_cq, ibcq);
 256 }
 257
 258 static inline struct pvrdma_user_mr *to_vmr(struct ib_mr *ibmr)
 259 {
 260         return container_of(ibmr, struct pvrdma_user_mr, ibmr);
 261 }
 262
 263 static inline struct pvrdma_qp *to_vqp(struct ib_qp *ibqp)
 264 {
 265         return container_of(ibqp, struct pvrdma_qp, ibqp);
 266 }
 267
 268 static inline struct pvrdma_ah *to_vah(struct ib_ah *ibah)
 269 {
 270         return container_of(ibah, struct pvrdma_ah, ibah);
 271 }
 272
 273 static inline void pvrdma_write_reg(struct pvrdma_dev *dev, u32 reg, u32 val)
 274 {
 275         writel(cpu_to_le32(val), dev->regs + reg);
 276 }
 277
 278 static inline u32 pvrdma_read_reg(struct pvrdma_dev *dev, u32 reg)
 279 {
 280         return le32_to_cpu(readl(dev->regs + reg));
 281 }
 282
 283 static inline void pvrdma_write_uar_cq(struct pvrdma_dev *dev, u32 val)
 284 {
 285         writel(cpu_to_le32(val), dev->driver_uar.map + PVRDMA_UAR_CQ_OFFSET);
 286 }
 287
 288 static inline void pvrdma_write_uar_qp(struct pvrdma_dev *dev, u32 val)
 289 {
 290         writel(cpu_to_le32(val), dev->driver_uar.map + PVRDMA_UAR_QP_OFFSET);
 291 }
 292
 293 static inline void *pvrdma_page_dir_get_ptr(struct pvrdma_page_dir *pdir,
 294                                             u64 offset)
 295 {
 296         return pdir->pages[offset / PAGE_SIZE] + (offset % PAGE_SIZE);
 297 }
 298
 299 static inline enum pvrdma_mtu ib_mtu_to_pvrdma(enum ib_mtu mtu)
 300 {
 301         return (enum pvrdma_mtu)mtu;
 302 }
 303
 304 static inline enum ib_mtu pvrdma_mtu_to_ib(enum pvrdma_mtu mtu)
 305 {
 306         return (enum ib_mtu)mtu;
 307 }
 308
 309 static inline enum pvrdma_port_state ib_port_state_to_pvrdma(
 310                                         enum ib_port_state state)
 311 {
 312         return (enum pvrdma_port_state)state;
 313 }
 314
 315 static inline enum ib_port_state pvrdma_port_state_to_ib(
 316                                         enum pvrdma_port_state state)
 317 {
 318         return (enum ib_port_state)state;
 319 }
 320
 321 static inline int ib_port_cap_flags_to_pvrdma(int flags)
 322 {
 323         return flags & PVRDMA_MASK(PVRDMA_PORT_CAP_FLAGS_MAX);
 324 }
 325
 326 static inline int pvrdma_port_cap_flags_to_ib(int flags)
 327 {
 328         return flags;
 329 }
 330
 331 static inline enum pvrdma_port_width ib_port_width_to_pvrdma(
 332                                         enum ib_port_width width)
 333 {
 334         return (enum pvrdma_port_width)width;
 335 }
 336
 337 static inline enum ib_port_width pvrdma_port_width_to_ib(
 338                                         enum pvrdma_port_width width)
 339 {
 340         return (enum ib_port_width)width;
 341 }
 342
 343 static inline enum pvrdma_port_speed ib_port_speed_to_pvrdma(
 344                                         enum ib_port_speed speed)
 345 {
 346         return (enum pvrdma_port_speed)speed;
 347 }
 348
 349 static inline enum ib_port_speed pvrdma_port_speed_to_ib(
 350                                         enum pvrdma_port_speed speed)
 351 {
 352         return (enum ib_port_speed)speed;
 353 }
 354
 355 static inline int pvrdma_qp_attr_mask_to_ib(int attr_mask)
 356 {
 357         return attr_mask;
 358 }
 359
 360 static inline int ib_qp_attr_mask_to_pvrdma(int attr_mask)
 361 {
 362         return attr_mask & PVRDMA_MASK(PVRDMA_QP_ATTR_MASK_MAX);
 363 }
 364
 365 static inline enum pvrdma_mig_state ib_mig_state_to_pvrdma(
 366                                         enum ib_mig_state state)
 367 {
 368         return (enum pvrdma_mig_state)state;
 369 }
 370
 371 static inline enum ib_mig_state pvrdma_mig_state_to_ib(
 372                                         enum pvrdma_mig_state state)
 373 {
 374         return (enum ib_mig_state)state;
 375 }
 376
 377 static inline int ib_access_flags_to_pvrdma(int flags)
 378 {
 379         return flags;
 380 }
 381
 382 static inline int pvrdma_access_flags_to_ib(int flags)
 383 {
 384         return flags & PVRDMA_MASK(PVRDMA_ACCESS_FLAGS_MAX);
 385 }
 386
 387 static inline enum pvrdma_qp_type ib_qp_type_to_pvrdma(enum ib_qp_type type)
 388 {
 389         return (enum pvrdma_qp_type)type;
 390 }
 391
 392 static inline enum ib_qp_type pvrdma_qp_type_to_ib(enum pvrdma_qp_type type)
 393 {
 394         return (enum ib_qp_type)type;
 395 }
 396
 397 static inline enum pvrdma_qp_state ib_qp_state_to_pvrdma(enum ib_qp_state state)
 398 {
 399         return (enum pvrdma_qp_state)state;
 400 }
 401
 402 static inline enum ib_qp_state pvrdma_qp_state_to_ib(enum pvrdma_qp_state state)
 403 {
 404         return (enum ib_qp_state)state;
 405 }
 406
 407 static inline enum pvrdma_wr_opcode ib_wr_opcode_to_pvrdma(enum ib_wr_opcode op)
 408 {
 409         return (enum pvrdma_wr_opcode)op;
 410 }
 411
 412 static inline enum ib_wc_status pvrdma_wc_status_to_ib(
 413                                         enum pvrdma_wc_status status)
 414 {
 415         return (enum ib_wc_status)status;
 416 }
 417
 418 static inline int pvrdma_wc_opcode_to_ib(int opcode)
 419 {
 420         return opcode;
 421 }
 422
 423 static inline int pvrdma_wc_flags_to_ib(int flags)
 424 {
 425         return flags;
 426 }
 427
 428 static inline int ib_send_flags_to_pvrdma(int flags)
 429 {
 430         return flags & PVRDMA_MASK(PVRDMA_SEND_FLAGS_MAX);
 431 }
 432
 433 void pvrdma_qp_cap_to_ib(struct ib_qp_cap *dst,
 434                          const struct pvrdma_qp_cap *src);
 435 void ib_qp_cap_to_pvrdma(struct pvrdma_qp_cap *dst,
 436                          const struct ib_qp_cap *src);
 437 void pvrdma_gid_to_ib(union ib_gid *dst, const union pvrdma_gid *src);
 438 void ib_gid_to_pvrdma(union pvrdma_gid *dst, const union ib_gid *src);
 439 void pvrdma_global_route_to_ib(struct ib_global_route *dst,
 440                                const struct pvrdma_global_route *src);
 441 void ib_global_route_to_pvrdma(struct pvrdma_global_route *dst,
 442                                const struct ib_global_route *src);
 443 void pvrdma_ah_attr_to_ib(struct ib_ah_attr *dst,
 444                           const struct pvrdma_ah_attr *src);
 445 void ib_ah_attr_to_pvrdma(struct pvrdma_ah_attr *dst,
 446                           const struct ib_ah_attr *src);
 447
 448 int pvrdma_uar_table_init(struct pvrdma_dev *dev);
 449 void pvrdma_uar_table_cleanup(struct pvrdma_dev *dev);
 450
 451 int pvrdma_uar_alloc(struct pvrdma_dev *dev, struct pvrdma_uar_map *uar);
 452 void pvrdma_uar_free(struct pvrdma_dev *dev, struct pvrdma_uar_map *uar);
 453
 454 void _pvrdma_flush_cqe(struct pvrdma_qp *qp, struct pvrdma_cq *cq);
 455
 456 int pvrdma_page_dir_init(struct pvrdma_dev *dev, struct pvrdma_page_dir *pdir,
 457                          u64 npages, bool alloc_pages);
 458 void pvrdma_page_dir_cleanup(struct pvrdma_dev *dev,
 459                              struct pvrdma_page_dir *pdir);
 460 int pvrdma_page_dir_insert_dma(struct pvrdma_page_dir *pdir, u64 idx,
 461                                dma_addr_t daddr);
 462 int pvrdma_page_dir_insert_umem(struct pvrdma_page_dir *pdir,
 463                                 struct ib_umem *umem, u64 offset);
 464 dma_addr_t pvrdma_page_dir_get_dma(struct pvrdma_page_dir *pdir, u64 idx);
 465 int pvrdma_page_dir_insert_page_list(struct pvrdma_page_dir *pdir,
 466                                      u64 *page_list, int num_pages);
 467
 468 int pvrdma_cmd_post(struct pvrdma_dev *dev, union pvrdma_cmd_req *req,
 469                     union pvrdma_cmd_resp *rsp, unsigned resp_code);
 470
 471 #endif /* __PVRDMA_H__ */