/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */ /* * Copyright(c) 2015 - 2018 Intel Corporation. */ #ifndef _HFI1_IOWAIT_H #define _HFI1_IOWAIT_H #include <linux/list.h> #include <linux/workqueue.h> #include <linux/wait.h> #include <linux/sched.h> #include "sdma_txreq.h" /* * typedef (*restart_t)() - restart callback * @work: pointer to work structure */ restart_t; #define IOWAIT_PENDING_IB … #define IOWAIT_PENDING_TID … /* * A QP can have multiple Send Engines (SEs). * * The current use case is for supporting a TID RDMA * packet build/xmit mechanism independent from verbs. */ #define IOWAIT_SES … #define IOWAIT_IB_SE … #define IOWAIT_TID_SE … struct sdma_txreq; struct sdma_engine; /** * @iowork: the work struct * @tx_head: list of prebuilt packets * @iow: the parent iowait structure * * This structure is the work item (process) specific * details associated with the each of the two SEs of the * QP. * * The workstruct and the queued TXs are unique to each * SE. */ struct iowait; struct iowait_work { … }; /** * @list: used to add/insert into QP/PQ wait lists * @tx_head: overflow list of sdma_txreq's * @sleep: no space callback * @wakeup: space callback wakeup * @sdma_drained: sdma count drained * @init_priority: callback to manipulate priority * @lock: lock protected head of wait queue * @iowork: workqueue overhead * @wait_dma: wait for sdma_busy == 0 * @wait_pio: wait for pio_busy == 0 * @sdma_busy: # of packets in flight * @count: total number of descriptors in tx_head'ed list * @tx_limit: limit for overflow queuing * @tx_count: number of tx entry's in tx_head'ed list * @flags: wait flags (one per QP) * @wait: SE array for multiple legs * * This is to be embedded in user's state structure * (QP or PQ). * * The sleep and wakeup members are a * bit misnamed. They do not strictly * speaking sleep or wake up, but they * are callbacks for the ULP to implement * what ever queuing/dequeuing of * the embedded iowait and its containing struct * when a resource shortage like SDMA ring space * or PIO credit space is seen. * * Both potentially have locks help * so sleeping is not allowed and it is not * supported to submit txreqs from the wakeup * call directly because of lock conflicts. * * The wait_dma member along with the iow * * The lock field is used by waiters to record * the seqlock_t that guards the list head. * Waiters explicity know that, but the destroy * code that unwaits QPs does not. */ struct iowait { … }; #define SDMA_AVAIL_REASON … void iowait_set_flag(struct iowait *wait, u32 flag); bool iowait_flag_set(struct iowait *wait, u32 flag); void iowait_clear_flag(struct iowait *wait, u32 flag); void iowait_init(struct iowait *wait, u32 tx_limit, void (*func)(struct work_struct *work), void (*tidfunc)(struct work_struct *work), int (*sleep)(struct sdma_engine *sde, struct iowait_work *wait, struct sdma_txreq *tx, uint seq, bool pkts_sent), void (*wakeup)(struct iowait *wait, int reason), void (*sdma_drained)(struct iowait *wait), void (*init_priority)(struct iowait *wait)); /** * iowait_schedule() - schedule the default send engine work * @wait: wait struct to schedule * @wq: workqueue for schedule * @cpu: cpu */ static inline bool iowait_schedule(struct iowait *wait, struct workqueue_struct *wq, int cpu) { … } /** * iowait_tid_schedule - schedule the tid SE * @wait: the iowait structure * @wq: the work queue * @cpu: the cpu */ static inline bool iowait_tid_schedule(struct iowait *wait, struct workqueue_struct *wq, int cpu) { … } /** * iowait_sdma_drain() - wait for DMAs to drain * * @wait: iowait structure * * This will delay until the iowait sdmas have * completed. */ static inline void iowait_sdma_drain(struct iowait *wait) { … } /** * iowait_sdma_pending() - return sdma pending count * * @wait: iowait structure * */ static inline int iowait_sdma_pending(struct iowait *wait) { … } /** * iowait_sdma_inc - note sdma io pending * @wait: iowait structure */ static inline void iowait_sdma_inc(struct iowait *wait) { … } /** * iowait_sdma_add - add count to pending * @wait: iowait structure */ static inline void iowait_sdma_add(struct iowait *wait, int count) { … } /** * iowait_sdma_dec - note sdma complete * @wait: iowait structure */ static inline int iowait_sdma_dec(struct iowait *wait) { … } /** * iowait_pio_drain() - wait for pios to drain * * @wait: iowait structure * * This will delay until the iowait pios have * completed. */ static inline void iowait_pio_drain(struct iowait *wait) { … } /** * iowait_pio_pending() - return pio pending count * * @wait: iowait structure * */ static inline int iowait_pio_pending(struct iowait *wait) { … } /** * iowait_pio_inc - note pio pending * @wait: iowait structure */ static inline void iowait_pio_inc(struct iowait *wait) { … } /** * iowait_pio_dec - note pio complete * @wait: iowait structure */ static inline int iowait_pio_dec(struct iowait *wait) { … } /** * iowait_drain_wakeup() - trigger iowait_drain() waiter * * @wait: iowait structure * * This will trigger any waiters. */ static inline void iowait_drain_wakeup(struct iowait *wait) { … } /** * iowait_get_txhead() - get packet off of iowait list * * @wait: iowait_work structure */ static inline struct sdma_txreq *iowait_get_txhead(struct iowait_work *wait) { … } static inline u16 iowait_get_desc(struct iowait_work *w) { … } static inline u32 iowait_get_all_desc(struct iowait *w) { … } static inline void iowait_update_priority(struct iowait_work *w) { … } static inline void iowait_update_all_priority(struct iowait *w) { … } static inline void iowait_init_priority(struct iowait *w) { … } static inline void iowait_get_priority(struct iowait *w) { … } /** * iowait_queue - Put the iowait on a wait queue * @pkts_sent: have some packets been sent before queuing? * @w: the iowait struct * @wait_head: the wait queue * * This function is called to insert an iowait struct into a * wait queue after a resource (eg, sdma descriptor or pio * buffer) is run out. */ static inline void iowait_queue(bool pkts_sent, struct iowait *w, struct list_head *wait_head) { … } /** * iowait_starve_clear - clear the wait queue's starve count * @pkts_sent: have some packets been sent? * @w: the iowait struct * * This function is called to clear the starve count. If no * packets have been sent, the starve count will not be cleared. */ static inline void iowait_starve_clear(bool pkts_sent, struct iowait *w) { … } /* Update the top priority index */ uint iowait_priority_update_top(struct iowait *w, struct iowait *top, uint idx, uint top_idx); /** * iowait_packet_queued() - determine if a packet is queued * @wait: the iowait_work structure */ static inline bool iowait_packet_queued(struct iowait_work *wait) { … } /** * inc_wait_count - increment wait counts * @w: the log work struct * @n: the count */ static inline void iowait_inc_wait_count(struct iowait_work *w, u16 n) { … } /** * iowait_get_tid_work - return iowait_work for tid SE * @w: the iowait struct */ static inline struct iowait_work *iowait_get_tid_work(struct iowait *w) { … } /** * iowait_get_ib_work - return iowait_work for ib SE * @w: the iowait struct */ static inline struct iowait_work *iowait_get_ib_work(struct iowait *w) { … } /** * iowait_ioww_to_iow - return iowait given iowait_work * @w: the iowait_work struct */ static inline struct iowait *iowait_ioww_to_iow(struct iowait_work *w) { … } void iowait_cancel_work(struct iowait *w); int iowait_set_work_flag(struct iowait_work *w); #endif
Codebase Browser
linux