1 /* SPDX-License-Identifier: GPL-2.0+ */ 2 /* 3 * SSH packet transport layer. 4 * 5 * Copyright (C) 2019-2022 Maximilian Luz <luzmaximilian@gmail.com> 6 */ 7 8 #ifndef _SURFACE_AGGREGATOR_SSH_PACKET_LAYER_H 9 #define _SURFACE_AGGREGATOR_SSH_PACKET_LAYER_H 10 11 #include <linux/atomic.h> 12 #include <linux/kfifo.h> 13 #include <linux/ktime.h> 14 #include <linux/list.h> 15 #include <linux/serdev.h> 16 #include <linux/spinlock.h> 17 #include <linux/types.h> 18 #include <linux/wait.h> 19 #include <linux/workqueue.h> 20 21 #include <linux/surface_aggregator/serial_hub.h> 22 #include "ssh_parser.h" 23 24 /** 25 * enum ssh_ptl_state_flags - State-flags for &struct ssh_ptl. 26 * 27 * @SSH_PTL_SF_SHUTDOWN_BIT: 28 * Indicates that the packet transport layer has been shut down or is 29 * being shut down and should not accept any new packets/data. 30 */ 31 enum ssh_ptl_state_flags { 32 SSH_PTL_SF_SHUTDOWN_BIT, 33 }; 34 35 /** 36 * struct ssh_ptl_ops - Callback operations for packet transport layer. 37 * @data_received: Function called when a data-packet has been received. Both, 38 * the packet layer on which the packet has been received and 39 * the packet's payload data are provided to this function. 40 */ 41 struct ssh_ptl_ops { 42 void (*data_received)(struct ssh_ptl *p, const struct ssam_span *data); 43 }; 44 45 /** 46 * struct ssh_ptl - SSH packet transport layer. 47 * @serdev: Serial device providing the underlying data transport. 48 * @state: State(-flags) of the transport layer. 49 * @queue: Packet submission queue. 50 * @queue.lock: Lock for modifying the packet submission queue. 51 * @queue.head: List-head of the packet submission queue. 52 * @pending: Set/list of pending packets. 53 * @pending.lock: Lock for modifying the pending set. 54 * @pending.head: List-head of the pending set/list. 55 * @pending.count: Number of currently pending packets. 56 * @tx: Transmitter subsystem. 57 * @tx.running: Flag indicating (desired) transmitter thread state. 58 * @tx.thread: Transmitter thread. 59 * @tx.thread_cplt_tx: Completion for transmitter thread waiting on transfer. 60 * @tx.thread_cplt_pkt: Completion for transmitter thread waiting on packets. 61 * @tx.packet_wq: Waitqueue-head for packet transmit completion. 62 * @rx: Receiver subsystem. 63 * @rx.thread: Receiver thread. 64 * @rx.wq: Waitqueue-head for receiver thread. 65 * @rx.fifo: Buffer for receiving data/pushing data to receiver thread. 66 * @rx.buf: Buffer for evaluating data on receiver thread. 67 * @rx.blocked: List of recent/blocked sequence IDs to detect retransmission. 68 * @rx.blocked.seqs: Array of blocked sequence IDs. 69 * @rx.blocked.offset: Offset indicating where a new ID should be inserted. 70 * @rtx_timeout: Retransmission timeout subsystem. 71 * @rtx_timeout.lock: Lock for modifying the retransmission timeout reaper. 72 * @rtx_timeout.timeout: Timeout interval for retransmission. 73 * @rtx_timeout.expires: Time specifying when the reaper work is next scheduled. 74 * @rtx_timeout.reaper: Work performing timeout checks and subsequent actions. 75 * @ops: Packet layer operations. 76 */ 77 struct ssh_ptl { 78 struct serdev_device *serdev; 79 unsigned long state; 80 81 struct { 82 spinlock_t lock; 83 struct list_head head; 84 } queue; 85 86 struct { 87 spinlock_t lock; 88 struct list_head head; 89 atomic_t count; 90 } pending; 91 92 struct { 93 atomic_t running; 94 struct task_struct *thread; 95 struct completion thread_cplt_tx; 96 struct completion thread_cplt_pkt; 97 struct wait_queue_head packet_wq; 98 } tx; 99 100 struct { 101 struct task_struct *thread; 102 struct wait_queue_head wq; 103 struct kfifo fifo; 104 struct sshp_buf buf; 105 106 struct { 107 u16 seqs[8]; 108 u16 offset; 109 } blocked; 110 } rx; 111 112 struct { 113 spinlock_t lock; 114 ktime_t timeout; 115 ktime_t expires; 116 struct delayed_work reaper; 117 } rtx_timeout; 118 119 struct ssh_ptl_ops ops; 120 }; 121 122 #define __ssam_prcond(func, p, fmt, ...) \ 123 do { \ 124 typeof(p) __p = (p); \ 125 \ 126 if (__p) \ 127 func(__p, fmt, ##__VA_ARGS__); \ 128 } while (0) 129 130 #define ptl_dbg(p, fmt, ...) dev_dbg(&(p)->serdev->dev, fmt, ##__VA_ARGS__) 131 #define ptl_info(p, fmt, ...) dev_info(&(p)->serdev->dev, fmt, ##__VA_ARGS__) 132 #define ptl_warn(p, fmt, ...) dev_warn(&(p)->serdev->dev, fmt, ##__VA_ARGS__) 133 #define ptl_err(p, fmt, ...) dev_err(&(p)->serdev->dev, fmt, ##__VA_ARGS__) 134 #define ptl_dbg_cond(p, fmt, ...) __ssam_prcond(ptl_dbg, p, fmt, ##__VA_ARGS__) 135 136 #define to_ssh_ptl(ptr, member) \ 137 container_of(ptr, struct ssh_ptl, member) 138 139 int ssh_ptl_init(struct ssh_ptl *ptl, struct serdev_device *serdev, 140 struct ssh_ptl_ops *ops); 141 142 void ssh_ptl_destroy(struct ssh_ptl *ptl); 143 144 /** 145 * ssh_ptl_get_device() - Get device associated with packet transport layer. 146 * @ptl: The packet transport layer. 147 * 148 * Return: Returns the device on which the given packet transport layer builds 149 * upon. 150 */ 151 static inline struct device *ssh_ptl_get_device(struct ssh_ptl *ptl) 152 { 153 return ptl->serdev ? &ptl->serdev->dev : NULL; 154 } 155 156 int ssh_ptl_tx_start(struct ssh_ptl *ptl); 157 int ssh_ptl_tx_stop(struct ssh_ptl *ptl); 158 int ssh_ptl_rx_start(struct ssh_ptl *ptl); 159 int ssh_ptl_rx_stop(struct ssh_ptl *ptl); 160 void ssh_ptl_shutdown(struct ssh_ptl *ptl); 161 162 int ssh_ptl_submit(struct ssh_ptl *ptl, struct ssh_packet *p); 163 void ssh_ptl_cancel(struct ssh_packet *p); 164 165 ssize_t ssh_ptl_rx_rcvbuf(struct ssh_ptl *ptl, const u8 *buf, size_t n); 166 167 /** 168 * ssh_ptl_tx_wakeup_transfer() - Wake up packet transmitter thread for 169 * transfer. 170 * @ptl: The packet transport layer. 171 * 172 * Wakes up the packet transmitter thread, notifying it that the underlying 173 * transport has more space for data to be transmitted. If the packet 174 * transport layer has been shut down, calls to this function will be ignored. 175 */ 176 static inline void ssh_ptl_tx_wakeup_transfer(struct ssh_ptl *ptl) 177 { 178 if (test_bit(SSH_PTL_SF_SHUTDOWN_BIT, &ptl->state)) 179 return; 180 181 complete(&ptl->tx.thread_cplt_tx); 182 } 183 184 void ssh_packet_init(struct ssh_packet *packet, unsigned long type, 185 u8 priority, const struct ssh_packet_ops *ops); 186 187 int ssh_ctrl_packet_cache_init(void); 188 void ssh_ctrl_packet_cache_destroy(void); 189 190 #endif /* _SURFACE_AGGREGATOR_SSH_PACKET_LAYER_H */ 191