/* SPDX-License-Identifier: GPL-2.0-only */ /* * Intel MIC Platform Software Stack (MPSS) * * Copyright(c) 2014 Intel Corporation. * * Intel SCIF driver. */ #ifndef SCIF_MAIN_H #define SCIF_MAIN_H #include #include #include #include #include #include #include #include #include #include "../common/mic_dev.h" #define SCIF_MGMT_NODE 0 #define SCIF_DEFAULT_WATCHDOG_TO 30 #define SCIF_NODE_ACCEPT_TIMEOUT (3 * HZ) #define SCIF_NODE_ALIVE_TIMEOUT (SCIF_DEFAULT_WATCHDOG_TO * HZ) #define SCIF_RMA_TEMP_CACHE_LIMIT 0x20000 /* * Generic state used for certain node QP message exchanges * like Unregister, Alloc etc. */ enum scif_msg_state { OP_IDLE = 1, OP_IN_PROGRESS, OP_COMPLETED, OP_FAILED }; /* * struct scif_info - Global SCIF information * * @nodeid: Node ID this node is to others * @maxid: Max known node ID * @total: Total number of SCIF nodes * @nr_zombies: number of zombie endpoints * @eplock: Lock to synchronize listening, zombie endpoint lists * @connlock: Lock to synchronize connected and disconnected lists * @nb_connect_lock: Synchronize non blocking connect operations * @port_lock: Synchronize access to SCIF ports * @uaccept: List of user acceptreq waiting for acceptreg * @listen: List of listening end points * @zombie: List of zombie end points with pending RMA's * @connected: List of end points in connected state * @disconnected: List of end points in disconnected state * @nb_connect_list: List for non blocking connections * @misc_work: miscellaneous SCIF tasks * @conflock: Lock to synchronize SCIF node configuration changes * @en_msg_log: Enable debug message logging * @p2p_enable: Enable P2P SCIF network * @mdev: The MISC device * @conn_work: Work for workqueue handling all connections * @exitwq: Wait queue for waiting for an EXIT node QP message response * @loopb_dev: Dummy SCIF device used for loopback * @loopb_wq: Workqueue used for handling loopback messages * @loopb_wqname[16]: Name of loopback workqueue * @loopb_work: Used for submitting work to loopb_wq * @loopb_recv_q: List of messages received on the loopb_wq * @card_initiated_exit: set when the card has initiated the exit * @rmalock: Synchronize access to RMA operations * @fencelock: Synchronize access to list of remote fences requested. * @rma: List of temporary registered windows to be destroyed. * @rma_tc: List of temporary registered & cached Windows to be destroyed * @fence: List of remote fence requests * @mmu_notif_work: Work for registration caching MMU notifier workqueue * @mmu_notif_cleanup: List of temporary cached windows for reg cache * @rma_tc_limit: RMA temporary cache limit */ struct scif_info { u8 nodeid; u8 maxid; u8 total; u32 nr_zombies; struct mutex eplock; struct mutex connlock; spinlock_t nb_connect_lock; spinlock_t port_lock; struct list_head uaccept; struct list_head listen; struct list_head zombie; struct list_head connected; struct list_head disconnected; struct list_head nb_connect_list; struct work_struct misc_work; struct mutex conflock; u8 en_msg_log; u8 p2p_enable; struct miscdevice mdev; struct work_struct conn_work; wait_queue_head_t exitwq; struct scif_dev *loopb_dev; struct workqueue_struct *loopb_wq; char loopb_wqname[16]; struct work_struct loopb_work; struct list_head loopb_recv_q; bool card_initiated_exit; spinlock_t rmalock; struct mutex fencelock; struct list_head rma; struct list_head rma_tc; struct list_head fence; struct work_struct mmu_notif_work; struct list_head mmu_notif_cleanup; unsigned long rma_tc_limit; }; /* * struct scif_p2p_info - SCIF mapping information used for P2P * * @ppi_peer_id - SCIF peer node id * @ppi_sg - Scatter list for bar information (One for mmio and one for aper) * @sg_nentries - Number of entries in the scatterlist * @ppi_da: DMA address for MMIO and APER bars * @ppi_len: Length of MMIO and APER bars * @ppi_list: Link in list of mapping information */ struct scif_p2p_info { u8 ppi_peer_id; struct scatterlist *ppi_sg[2]; u64 sg_nentries[2]; dma_addr_t ppi_da[2]; u64 ppi_len[2]; #define SCIF_PPI_MMIO 0 #define SCIF_PPI_APER 1 struct list_head ppi_list; }; /* * struct scif_dev - SCIF remote device specific fields * * @node: Node id * @p2p: List of P2P mapping information * @qpairs: The node queue pair for exchanging control messages * @intr_wq: Workqueue for handling Node QP messages * @intr_wqname: Name of node QP workqueue for handling interrupts * @intr_bh: Used for submitting work to intr_wq * @lock: Lock used for synchronizing access to the scif device * @sdev: SCIF hardware device on the SCIF hardware bus * @db: doorbell the peer will trigger to generate an interrupt on self * @rdb: Doorbell to trigger on the peer to generate an interrupt on the peer * @cookie: Cookie received while registering the interrupt handler * @peer_add_work: Work for handling device_add for peer devices * @p2p_dwork: Delayed work to enable polling for P2P state * @qp_dwork: Delayed work for enabling polling for remote QP information * @p2p_retry: Number of times to retry polling of P2P state * @base_addr: P2P aperture bar base address * @mic_mw mmio: The peer MMIO information used for P2P * @spdev: SCIF peer device on the SCIF peer bus * @node_remove_ack_pending: True if a node_remove_ack is pending * @exit_ack_pending: true if an exit_ack is pending * @disconn_wq: Used while waiting for a node remove response * @disconn_rescnt: Keeps track of number of node remove requests sent * @exit: Status of exit message * @qp_dma_addr: Queue pair DMA address passed to the peer * @dma_ch_idx: Round robin index for DMA channels * @signal_pool: DMA pool used for scheduling scif_fence_signal DMA's */ struct scif_dev { u8 node; struct list_head p2p; struct scif_qp *qpairs; struct workqueue_struct *intr_wq; char intr_wqname[16]; struct work_struct intr_bh; struct mutex lock; struct scif_hw_dev *sdev; int db; int rdb; struct mic_irq *cookie; struct work_struct peer_add_work; struct delayed_work p2p_dwork; struct delayed_work qp_dwork; int p2p_retry; dma_addr_t base_addr; struct mic_mw mmio; struct scif_peer_dev __rcu *spdev; bool node_remove_ack_pending; bool exit_ack_pending; wait_queue_head_t disconn_wq; atomic_t disconn_rescnt; enum scif_msg_state exit; dma_addr_t qp_dma_addr; int dma_ch_idx; struct dma_pool *signal_pool; }; extern bool scif_reg_cache_enable; extern bool scif_ulimit_check; extern struct scif_info scif_info; extern struct idr scif_ports; extern struct bus_type scif_peer_bus; extern struct scif_dev *scif_dev; extern const struct file_operations scif_fops; extern const struct file_operations scif_anon_fops; /* Size of the RB for the Node QP */ #define SCIF_NODE_QP_SIZE 0x10000 #include "scif_nodeqp.h" #include "scif_rma.h" #include "scif_rma_list.h" /* * scifdev_self: * @dev: The remote SCIF Device * * Returns true if the SCIF Device passed is the self aka Loopback SCIF device. */ static inline int scifdev_self(struct scif_dev *dev) { return dev->node == scif_info.nodeid; } static inline bool scif_is_mgmt_node(void) { return !scif_info.nodeid; } /* * scifdev_is_p2p: * @dev: The remote SCIF Device * * Returns true if the SCIF Device is a MIC Peer to Peer SCIF device. */ static inline bool scifdev_is_p2p(struct scif_dev *dev) { if (scif_is_mgmt_node()) return false; else return dev != &scif_dev[SCIF_MGMT_NODE] && !scifdev_self(dev); } /* * scifdev_alive: * @scifdev: The remote SCIF Device * * Returns true if the remote SCIF Device is running or sleeping for * this endpoint. */ static inline int _scifdev_alive(struct scif_dev *scifdev) { struct scif_peer_dev *spdev; rcu_read_lock(); spdev = rcu_dereference(scifdev->spdev); rcu_read_unlock(); return !!spdev; } #include "scif_epd.h" void __init scif_init_debugfs(void); void scif_exit_debugfs(void); int scif_setup_intr_wq(struct scif_dev *scifdev); void scif_destroy_intr_wq(struct scif_dev *scifdev); void scif_cleanup_scifdev(struct scif_dev *dev); void scif_handle_remove_node(int node); void scif_disconnect_node(u32 node_id, bool mgmt_initiated); void scif_free_qp(struct scif_dev *dev); void scif_misc_handler(struct work_struct *work); void scif_stop(struct scif_dev *scifdev); irqreturn_t scif_intr_handler(int irq, void *data); #endif /* SCIF_MAIN_H */