mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-15 15:15:47 +00:00
1802d0beec
Based on 1 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms of the gnu general public license version 2 as published by the free software foundation this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details extracted by the scancode license scanner the SPDX license identifier GPL-2.0-only has been chosen to replace the boilerplate/reference in 655 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org> Reviewed-by: Richard Fontana <rfontana@redhat.com> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190527070034.575739538@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
274 lines
8.3 KiB
C
274 lines
8.3 KiB
C
/* 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 <linux/sched/signal.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/miscdevice.h>
|
|
#include <linux/dmaengine.h>
|
|
#include <linux/iova.h>
|
|
#include <linux/anon_inodes.h>
|
|
#include <linux/file.h>
|
|
#include <linux/vmalloc.h>
|
|
#include <linux/scif.h>
|
|
#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 */
|