1/* 2 * Intel MIC Platform Software Stack (MPSS) 3 * 4 * Copyright(c) 2014 Intel Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License, version 2, as 8 * published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * Intel SCIF driver. 16 * 17 */ 18#ifndef SCIF_MAIN_H 19#define SCIF_MAIN_H 20 21#include <linux/sched.h> 22#include <linux/pci.h> 23#include <linux/miscdevice.h> 24#include <linux/dmaengine.h> 25#include <linux/iova.h> 26#include <linux/anon_inodes.h> 27#include <linux/file.h> 28#include <linux/vmalloc.h> 29#include <linux/scif.h> 30#include "../common/mic_dev.h" 31 32#define SCIF_MGMT_NODE 0 33#define SCIF_DEFAULT_WATCHDOG_TO 30 34#define SCIF_NODE_ACCEPT_TIMEOUT (3 * HZ) 35#define SCIF_NODE_ALIVE_TIMEOUT (SCIF_DEFAULT_WATCHDOG_TO * HZ) 36#define SCIF_RMA_TEMP_CACHE_LIMIT 0x20000 37 38/* 39 * Generic state used for certain node QP message exchanges 40 * like Unregister, Alloc etc. 41 */ 42enum scif_msg_state { 43 OP_IDLE = 1, 44 OP_IN_PROGRESS, 45 OP_COMPLETED, 46 OP_FAILED 47}; 48 49/* 50 * struct scif_info - Global SCIF information 51 * 52 * @nodeid: Node ID this node is to others 53 * @maxid: Max known node ID 54 * @total: Total number of SCIF nodes 55 * @nr_zombies: number of zombie endpoints 56 * @eplock: Lock to synchronize listening, zombie endpoint lists 57 * @connlock: Lock to synchronize connected and disconnected lists 58 * @nb_connect_lock: Synchronize non blocking connect operations 59 * @port_lock: Synchronize access to SCIF ports 60 * @uaccept: List of user acceptreq waiting for acceptreg 61 * @listen: List of listening end points 62 * @zombie: List of zombie end points with pending RMA's 63 * @connected: List of end points in connected state 64 * @disconnected: List of end points in disconnected state 65 * @nb_connect_list: List for non blocking connections 66 * @misc_work: miscellaneous SCIF tasks 67 * @conflock: Lock to synchronize SCIF node configuration changes 68 * @en_msg_log: Enable debug message logging 69 * @p2p_enable: Enable P2P SCIF network 70 * @mdev: The MISC device 71 * @conn_work: Work for workqueue handling all connections 72 * @exitwq: Wait queue for waiting for an EXIT node QP message response 73 * @loopb_dev: Dummy SCIF device used for loopback 74 * @loopb_wq: Workqueue used for handling loopback messages 75 * @loopb_wqname[16]: Name of loopback workqueue 76 * @loopb_work: Used for submitting work to loopb_wq 77 * @loopb_recv_q: List of messages received on the loopb_wq 78 * @card_initiated_exit: set when the card has initiated the exit 79 * @rmalock: Synchronize access to RMA operations 80 * @fencelock: Synchronize access to list of remote fences requested. 81 * @rma: List of temporary registered windows to be destroyed. 82 * @rma_tc: List of temporary registered & cached Windows to be destroyed 83 * @fence: List of remote fence requests 84 * @mmu_notif_work: Work for registration caching MMU notifier workqueue 85 * @mmu_notif_cleanup: List of temporary cached windows for reg cache 86 * @rma_tc_limit: RMA temporary cache limit 87 */ 88struct scif_info { 89 u8 nodeid; 90 u8 maxid; 91 u8 total; 92 u32 nr_zombies; 93 struct mutex eplock; 94 struct mutex connlock; 95 spinlock_t nb_connect_lock; 96 spinlock_t port_lock; 97 struct list_head uaccept; 98 struct list_head listen; 99 struct list_head zombie; 100 struct list_head connected; 101 struct list_head disconnected; 102 struct list_head nb_connect_list; 103 struct work_struct misc_work; 104 struct mutex conflock; 105 u8 en_msg_log; 106 u8 p2p_enable; 107 struct miscdevice mdev; 108 struct work_struct conn_work; 109 wait_queue_head_t exitwq; 110 struct scif_dev *loopb_dev; 111 struct workqueue_struct *loopb_wq; 112 char loopb_wqname[16]; 113 struct work_struct loopb_work; 114 struct list_head loopb_recv_q; 115 bool card_initiated_exit; 116 spinlock_t rmalock; 117 struct mutex fencelock; 118 struct list_head rma; 119 struct list_head rma_tc; 120 struct list_head fence; 121 struct work_struct mmu_notif_work; 122 struct list_head mmu_notif_cleanup; 123 unsigned long rma_tc_limit; 124}; 125 126/* 127 * struct scif_p2p_info - SCIF mapping information used for P2P 128 * 129 * @ppi_peer_id - SCIF peer node id 130 * @ppi_sg - Scatter list for bar information (One for mmio and one for aper) 131 * @sg_nentries - Number of entries in the scatterlist 132 * @ppi_da: DMA address for MMIO and APER bars 133 * @ppi_len: Length of MMIO and APER bars 134 * @ppi_list: Link in list of mapping information 135 */ 136struct scif_p2p_info { 137 u8 ppi_peer_id; 138 struct scatterlist *ppi_sg[2]; 139 u64 sg_nentries[2]; 140 dma_addr_t ppi_da[2]; 141 u64 ppi_len[2]; 142#define SCIF_PPI_MMIO 0 143#define SCIF_PPI_APER 1 144 struct list_head ppi_list; 145}; 146 147/* 148 * struct scif_dev - SCIF remote device specific fields 149 * 150 * @node: Node id 151 * @p2p: List of P2P mapping information 152 * @qpairs: The node queue pair for exchanging control messages 153 * @intr_wq: Workqueue for handling Node QP messages 154 * @intr_wqname: Name of node QP workqueue for handling interrupts 155 * @intr_bh: Used for submitting work to intr_wq 156 * @lock: Lock used for synchronizing access to the scif device 157 * @sdev: SCIF hardware device on the SCIF hardware bus 158 * @db: doorbell the peer will trigger to generate an interrupt on self 159 * @rdb: Doorbell to trigger on the peer to generate an interrupt on the peer 160 * @cookie: Cookie received while registering the interrupt handler 161 * @peer_add_work: Work for handling device_add for peer devices 162 * @p2p_dwork: Delayed work to enable polling for P2P state 163 * @qp_dwork: Delayed work for enabling polling for remote QP information 164 * @p2p_retry: Number of times to retry polling of P2P state 165 * @base_addr: P2P aperture bar base address 166 * @mic_mw mmio: The peer MMIO information used for P2P 167 * @spdev: SCIF peer device on the SCIF peer bus 168 * @node_remove_ack_pending: True if a node_remove_ack is pending 169 * @exit_ack_pending: true if an exit_ack is pending 170 * @disconn_wq: Used while waiting for a node remove response 171 * @disconn_rescnt: Keeps track of number of node remove requests sent 172 * @exit: Status of exit message 173 * @qp_dma_addr: Queue pair DMA address passed to the peer 174 * @dma_ch_idx: Round robin index for DMA channels 175 * @signal_pool: DMA pool used for scheduling scif_fence_signal DMA's 176*/ 177struct scif_dev { 178 u8 node; 179 struct list_head p2p; 180 struct scif_qp *qpairs; 181 struct workqueue_struct *intr_wq; 182 char intr_wqname[16]; 183 struct work_struct intr_bh; 184 struct mutex lock; 185 struct scif_hw_dev *sdev; 186 int db; 187 int rdb; 188 struct mic_irq *cookie; 189 struct work_struct peer_add_work; 190 struct delayed_work p2p_dwork; 191 struct delayed_work qp_dwork; 192 int p2p_retry; 193 dma_addr_t base_addr; 194 struct mic_mw mmio; 195 struct scif_peer_dev __rcu *spdev; 196 bool node_remove_ack_pending; 197 bool exit_ack_pending; 198 wait_queue_head_t disconn_wq; 199 atomic_t disconn_rescnt; 200 enum scif_msg_state exit; 201 dma_addr_t qp_dma_addr; 202 int dma_ch_idx; 203 struct dma_pool *signal_pool; 204}; 205 206extern bool scif_reg_cache_enable; 207extern bool scif_ulimit_check; 208extern struct scif_info scif_info; 209extern struct idr scif_ports; 210extern struct bus_type scif_peer_bus; 211extern struct scif_dev *scif_dev; 212extern const struct file_operations scif_fops; 213extern const struct file_operations scif_anon_fops; 214 215/* Size of the RB for the Node QP */ 216#define SCIF_NODE_QP_SIZE 0x10000 217 218#include "scif_nodeqp.h" 219#include "scif_rma.h" 220#include "scif_rma_list.h" 221 222/* 223 * scifdev_self: 224 * @dev: The remote SCIF Device 225 * 226 * Returns true if the SCIF Device passed is the self aka Loopback SCIF device. 227 */ 228static inline int scifdev_self(struct scif_dev *dev) 229{ 230 return dev->node == scif_info.nodeid; 231} 232 233static inline bool scif_is_mgmt_node(void) 234{ 235 return !scif_info.nodeid; 236} 237 238/* 239 * scifdev_is_p2p: 240 * @dev: The remote SCIF Device 241 * 242 * Returns true if the SCIF Device is a MIC Peer to Peer SCIF device. 243 */ 244static inline bool scifdev_is_p2p(struct scif_dev *dev) 245{ 246 if (scif_is_mgmt_node()) 247 return false; 248 else 249 return dev != &scif_dev[SCIF_MGMT_NODE] && 250 !scifdev_self(dev); 251} 252 253/* 254 * scifdev_alive: 255 * @scifdev: The remote SCIF Device 256 * 257 * Returns true if the remote SCIF Device is running or sleeping for 258 * this endpoint. 259 */ 260static inline int _scifdev_alive(struct scif_dev *scifdev) 261{ 262 struct scif_peer_dev *spdev; 263 264 rcu_read_lock(); 265 spdev = rcu_dereference(scifdev->spdev); 266 rcu_read_unlock(); 267 return !!spdev; 268} 269 270#include "scif_epd.h" 271 272void __init scif_init_debugfs(void); 273void scif_exit_debugfs(void); 274int scif_setup_intr_wq(struct scif_dev *scifdev); 275void scif_destroy_intr_wq(struct scif_dev *scifdev); 276void scif_cleanup_scifdev(struct scif_dev *dev); 277void scif_handle_remove_node(int node); 278void scif_disconnect_node(u32 node_id, bool mgmt_initiated); 279void scif_free_qp(struct scif_dev *dev); 280void scif_misc_handler(struct work_struct *work); 281void scif_stop(struct scif_dev *scifdev); 282irqreturn_t scif_intr_handler(int irq, void *data); 283#endif /* SCIF_MAIN_H */ 284