1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /*
3 * SSH request transport layer.
4 *
5 * Copyright (C) 2019-2020 Maximilian Luz <luzmaximilian@gmail.com>
6 */
7
8 #ifndef _SURFACE_AGGREGATOR_SSH_REQUEST_LAYER_H
9 #define _SURFACE_AGGREGATOR_SSH_REQUEST_LAYER_H
10
11 #include <linux/atomic.h>
12 #include <linux/ktime.h>
13 #include <linux/list.h>
14 #include <linux/spinlock.h>
15 #include <linux/workqueue.h>
16
17 #include <linux/surface_aggregator/serial_hub.h>
18 #include <linux/surface_aggregator/controller.h>
19
20 #include "ssh_packet_layer.h"
21
22 /**
23 * enum ssh_rtl_state_flags - State-flags for &struct ssh_rtl.
24 *
25 * @SSH_RTL_SF_SHUTDOWN_BIT:
26 * Indicates that the request transport layer has been shut down or is
27 * being shut down and should not accept any new requests.
28 */
29 enum ssh_rtl_state_flags {
30 SSH_RTL_SF_SHUTDOWN_BIT,
31 };
32
33 /**
34 * struct ssh_rtl_ops - Callback operations for request transport layer.
35 * @handle_event: Function called when a SSH event has been received. The
36 * specified function takes the request layer, received command
37 * struct, and corresponding payload as arguments. If the event
38 * has no payload, the payload span is empty (not %NULL).
39 */
40 struct ssh_rtl_ops {
41 void (*handle_event)(struct ssh_rtl *rtl, const struct ssh_command *cmd,
42 const struct ssam_span *data);
43 };
44
45 /**
46 * struct ssh_rtl - SSH request transport layer.
47 * @ptl: Underlying packet transport layer.
48 * @state: State(-flags) of the transport layer.
49 * @queue: Request submission queue.
50 * @queue.lock: Lock for modifying the request submission queue.
51 * @queue.head: List-head of the request submission queue.
52 * @pending: Set/list of pending requests.
53 * @pending.lock: Lock for modifying the request set.
54 * @pending.head: List-head of the pending set/list.
55 * @pending.count: Number of currently pending requests.
56 * @tx: Transmitter subsystem.
57 * @tx.work: Transmitter work item.
58 * @rtx_timeout: Retransmission timeout subsystem.
59 * @rtx_timeout.lock: Lock for modifying the retransmission timeout reaper.
60 * @rtx_timeout.timeout: Timeout interval for retransmission.
61 * @rtx_timeout.expires: Time specifying when the reaper work is next scheduled.
62 * @rtx_timeout.reaper: Work performing timeout checks and subsequent actions.
63 * @ops: Request layer operations.
64 */
65 struct ssh_rtl {
66 struct ssh_ptl ptl;
67 unsigned long state;
68
69 struct {
70 spinlock_t lock;
71 struct list_head head;
72 } queue;
73
74 struct {
75 spinlock_t lock;
76 struct list_head head;
77 atomic_t count;
78 } pending;
79
80 struct {
81 struct work_struct work;
82 } tx;
83
84 struct {
85 spinlock_t lock;
86 ktime_t timeout;
87 ktime_t expires;
88 struct delayed_work reaper;
89 } rtx_timeout;
90
91 struct ssh_rtl_ops ops;
92 };
93
94 #define rtl_dbg(r, fmt, ...) ptl_dbg(&(r)->ptl, fmt, ##__VA_ARGS__)
95 #define rtl_info(p, fmt, ...) ptl_info(&(p)->ptl, fmt, ##__VA_ARGS__)
96 #define rtl_warn(r, fmt, ...) ptl_warn(&(r)->ptl, fmt, ##__VA_ARGS__)
97 #define rtl_err(r, fmt, ...) ptl_err(&(r)->ptl, fmt, ##__VA_ARGS__)
98 #define rtl_dbg_cond(r, fmt, ...) __ssam_prcond(rtl_dbg, r, fmt, ##__VA_ARGS__)
99
100 #define to_ssh_rtl(ptr, member) \
101 container_of(ptr, struct ssh_rtl, member)
102
103 /**
104 * ssh_rtl_get_device() - Get device associated with request transport layer.
105 * @rtl: The request transport layer.
106 *
107 * Return: Returns the device on which the given request transport layer
108 * builds upon.
109 */
ssh_rtl_get_device(struct ssh_rtl * rtl)110 static inline struct device *ssh_rtl_get_device(struct ssh_rtl *rtl)
111 {
112 return ssh_ptl_get_device(&rtl->ptl);
113 }
114
115 /**
116 * ssh_request_rtl() - Get request transport layer associated with request.
117 * @rqst: The request to get the request transport layer reference for.
118 *
119 * Return: Returns the &struct ssh_rtl associated with the given SSH request.
120 */
ssh_request_rtl(struct ssh_request * rqst)121 static inline struct ssh_rtl *ssh_request_rtl(struct ssh_request *rqst)
122 {
123 struct ssh_ptl *ptl;
124
125 ptl = READ_ONCE(rqst->packet.ptl);
126 return likely(ptl) ? to_ssh_rtl(ptl, ptl) : NULL;
127 }
128
129 int ssh_rtl_submit(struct ssh_rtl *rtl, struct ssh_request *rqst);
130 bool ssh_rtl_cancel(struct ssh_request *rqst, bool pending);
131
132 int ssh_rtl_init(struct ssh_rtl *rtl, struct serdev_device *serdev,
133 const struct ssh_rtl_ops *ops);
134
135 int ssh_rtl_start(struct ssh_rtl *rtl);
136 int ssh_rtl_flush(struct ssh_rtl *rtl, unsigned long timeout);
137 void ssh_rtl_shutdown(struct ssh_rtl *rtl);
138 void ssh_rtl_destroy(struct ssh_rtl *rtl);
139
140 int ssh_request_init(struct ssh_request *rqst, enum ssam_request_flags flags,
141 const struct ssh_request_ops *ops);
142
143 #endif /* _SURFACE_AGGREGATOR_SSH_REQUEST_LAYER_H */
144