GNU Linux-libre 6.9.2-gnu
[releases.git] / include / linux / mhi_ep.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Copyright (c) 2022, Linaro Ltd.
4  *
5  */
6 #ifndef _MHI_EP_H_
7 #define _MHI_EP_H_
8
9 #include <linux/dma-direction.h>
10 #include <linux/mhi.h>
11
12 #define MHI_EP_DEFAULT_MTU 0x8000
13
14 /**
15  * struct mhi_ep_channel_config - Channel configuration structure for controller
16  * @name: The name of this channel
17  * @num: The number assigned to this channel
18  * @num_elements: The number of elements that can be queued to this channel
19  * @dir: Direction that data may flow on this channel
20  */
21 struct mhi_ep_channel_config {
22         char *name;
23         u32 num;
24         u32 num_elements;
25         enum dma_data_direction dir;
26 };
27
28 /**
29  * struct mhi_ep_cntrl_config - MHI Endpoint controller configuration
30  * @mhi_version: MHI spec version supported by the controller
31  * @max_channels: Maximum number of channels supported
32  * @num_channels: Number of channels defined in @ch_cfg
33  * @ch_cfg: Array of defined channels
34  */
35 struct mhi_ep_cntrl_config {
36         u32 mhi_version;
37         u32 max_channels;
38         u32 num_channels;
39         const struct mhi_ep_channel_config *ch_cfg;
40 };
41
42 /**
43  * struct mhi_ep_db_info - MHI Endpoint doorbell info
44  * @mask: Mask of the doorbell interrupt
45  * @status: Status of the doorbell interrupt
46  */
47 struct mhi_ep_db_info {
48         u32 mask;
49         u32 status;
50 };
51
52 /**
53  * struct mhi_ep_buf_info - MHI Endpoint transfer buffer info
54  * @mhi_dev: MHI device associated with this buffer
55  * @dev_addr: Address of the buffer in endpoint
56  * @host_addr: Address of the bufffer in host
57  * @size: Size of the buffer
58  * @code: Transfer completion code
59  * @cb: Callback to be executed by controller drivers after transfer completion (async)
60  * @cb_buf: Opaque buffer to be passed to the callback
61  */
62 struct mhi_ep_buf_info {
63         struct mhi_ep_device *mhi_dev;
64         void *dev_addr;
65         u64 host_addr;
66         size_t size;
67         int code;
68
69         void (*cb)(struct mhi_ep_buf_info *buf_info);
70         void *cb_buf;
71 };
72
73 /**
74  * struct mhi_ep_cntrl - MHI Endpoint controller structure
75  * @cntrl_dev: Pointer to the struct device of physical bus acting as the MHI
76  *             Endpoint controller
77  * @mhi_dev: MHI Endpoint device instance for the controller
78  * @mmio: MMIO region containing the MHI registers
79  * @mhi_chan: Points to the channel configuration table
80  * @mhi_event: Points to the event ring configurations table
81  * @mhi_cmd: Points to the command ring configurations table
82  * @sm: MHI Endpoint state machine
83  * @ch_ctx_cache: Cache of host channel context data structure
84  * @ev_ctx_cache: Cache of host event context data structure
85  * @cmd_ctx_cache: Cache of host command context data structure
86  * @ch_ctx_host_pa: Physical address of host channel context data structure
87  * @ev_ctx_host_pa: Physical address of host event context data structure
88  * @cmd_ctx_host_pa: Physical address of host command context data structure
89  * @ch_ctx_cache_phys: Physical address of the host channel context cache
90  * @ev_ctx_cache_phys: Physical address of the host event context cache
91  * @cmd_ctx_cache_phys: Physical address of the host command context cache
92  * @chdb: Array of channel doorbell interrupt info
93  * @event_lock: Lock for protecting event rings
94  * @state_lock: Lock for protecting state transitions
95  * @list_lock: Lock for protecting state transition and channel doorbell lists
96  * @st_transition_list: List of state transitions
97  * @ch_db_list: List of queued channel doorbells
98  * @wq: Dedicated workqueue for handling rings and state changes
99  * @state_work: State transition worker
100  * @reset_work: Worker for MHI Endpoint reset
101  * @cmd_ring_work: Worker for processing command rings
102  * @ch_ring_work: Worker for processing channel rings
103  * @raise_irq: CB function for raising IRQ to the host
104  * @alloc_map: CB function for allocating memory in endpoint for storing host context and mapping it
105  * @unmap_free: CB function to unmap and free the allocated memory in endpoint for storing host context
106  * @read_sync: CB function for reading from host memory synchronously
107  * @write_sync: CB function for writing to host memory synchronously
108  * @read_async: CB function for reading from host memory asynchronously
109  * @write_async: CB function for writing to host memory asynchronously
110  * @mhi_state: MHI Endpoint state
111  * @max_chan: Maximum channels supported by the endpoint controller
112  * @mru: MRU (Maximum Receive Unit) value of the endpoint controller
113  * @event_rings: Number of event rings supported by the endpoint controller
114  * @hw_event_rings: Number of hardware event rings supported by the endpoint controller
115  * @chdb_offset: Channel doorbell offset set by the host
116  * @erdb_offset: Event ring doorbell offset set by the host
117  * @index: MHI Endpoint controller index
118  * @irq: IRQ used by the endpoint controller
119  * @enabled: Check if the endpoint controller is enabled or not
120  */
121 struct mhi_ep_cntrl {
122         struct device *cntrl_dev;
123         struct mhi_ep_device *mhi_dev;
124         void __iomem *mmio;
125
126         struct mhi_ep_chan *mhi_chan;
127         struct mhi_ep_event *mhi_event;
128         struct mhi_ep_cmd *mhi_cmd;
129         struct mhi_ep_sm *sm;
130
131         struct mhi_chan_ctxt *ch_ctx_cache;
132         struct mhi_event_ctxt *ev_ctx_cache;
133         struct mhi_cmd_ctxt *cmd_ctx_cache;
134         u64 ch_ctx_host_pa;
135         u64 ev_ctx_host_pa;
136         u64 cmd_ctx_host_pa;
137         phys_addr_t ch_ctx_cache_phys;
138         phys_addr_t ev_ctx_cache_phys;
139         phys_addr_t cmd_ctx_cache_phys;
140
141         struct mhi_ep_db_info chdb[4];
142         struct mutex event_lock;
143         struct mutex state_lock;
144         spinlock_t list_lock;
145
146         struct list_head st_transition_list;
147         struct list_head ch_db_list;
148
149         struct workqueue_struct *wq;
150         struct work_struct state_work;
151         struct work_struct reset_work;
152         struct work_struct cmd_ring_work;
153         struct work_struct ch_ring_work;
154         struct kmem_cache *ring_item_cache;
155         struct kmem_cache *ev_ring_el_cache;
156         struct kmem_cache *tre_buf_cache;
157
158         void (*raise_irq)(struct mhi_ep_cntrl *mhi_cntrl, u32 vector);
159         int (*alloc_map)(struct mhi_ep_cntrl *mhi_cntrl, u64 pci_addr, phys_addr_t *phys_ptr,
160                          void __iomem **virt, size_t size);
161         void (*unmap_free)(struct mhi_ep_cntrl *mhi_cntrl, u64 pci_addr, phys_addr_t phys,
162                            void __iomem *virt, size_t size);
163         int (*read_sync)(struct mhi_ep_cntrl *mhi_cntrl, struct mhi_ep_buf_info *buf_info);
164         int (*write_sync)(struct mhi_ep_cntrl *mhi_cntrl, struct mhi_ep_buf_info *buf_info);
165         int (*read_async)(struct mhi_ep_cntrl *mhi_cntrl, struct mhi_ep_buf_info *buf_info);
166         int (*write_async)(struct mhi_ep_cntrl *mhi_cntrl, struct mhi_ep_buf_info *buf_info);
167
168         enum mhi_state mhi_state;
169
170         u32 max_chan;
171         u32 mru;
172         u32 event_rings;
173         u32 hw_event_rings;
174         u32 chdb_offset;
175         u32 erdb_offset;
176         u32 index;
177         int irq;
178         bool enabled;
179 };
180
181 /**
182  * struct mhi_ep_device - Structure representing an MHI Endpoint device that binds
183  *                     to channels or is associated with controllers
184  * @dev: Driver model device node for the MHI Endpoint device
185  * @mhi_cntrl: Controller the device belongs to
186  * @id: Pointer to MHI Endpoint device ID struct
187  * @name: Name of the associated MHI Endpoint device
188  * @ul_chan: UL (from host to endpoint) channel for the device
189  * @dl_chan: DL (from endpoint to host) channel for the device
190  * @dev_type: MHI device type
191  */
192 struct mhi_ep_device {
193         struct device dev;
194         struct mhi_ep_cntrl *mhi_cntrl;
195         const struct mhi_device_id *id;
196         const char *name;
197         struct mhi_ep_chan *ul_chan;
198         struct mhi_ep_chan *dl_chan;
199         enum mhi_device_type dev_type;
200 };
201
202 /**
203  * struct mhi_ep_driver - Structure representing a MHI Endpoint client driver
204  * @id_table: Pointer to MHI Endpoint device ID table
205  * @driver: Device driver model driver
206  * @probe: CB function for client driver probe function
207  * @remove: CB function for client driver remove function
208  * @ul_xfer_cb: CB function for UL (from host to endpoint) data transfer
209  * @dl_xfer_cb: CB function for DL (from endpoint to host) data transfer
210  */
211 struct mhi_ep_driver {
212         const struct mhi_device_id *id_table;
213         struct device_driver driver;
214         int (*probe)(struct mhi_ep_device *mhi_ep,
215                      const struct mhi_device_id *id);
216         void (*remove)(struct mhi_ep_device *mhi_ep);
217         void (*ul_xfer_cb)(struct mhi_ep_device *mhi_dev,
218                            struct mhi_result *result);
219         void (*dl_xfer_cb)(struct mhi_ep_device *mhi_dev,
220                            struct mhi_result *result);
221 };
222
223 #define to_mhi_ep_device(dev) container_of(dev, struct mhi_ep_device, dev)
224 #define to_mhi_ep_driver(drv) container_of(drv, struct mhi_ep_driver, driver)
225
226 /*
227  * module_mhi_ep_driver() - Helper macro for drivers that don't do
228  * anything special other than using default mhi_ep_driver_register() and
229  * mhi_ep_driver_unregister().  This eliminates a lot of boilerplate.
230  * Each module may only use this macro once.
231  */
232 #define module_mhi_ep_driver(mhi_drv) \
233         module_driver(mhi_drv, mhi_ep_driver_register, \
234                       mhi_ep_driver_unregister)
235
236 /*
237  * Macro to avoid include chaining to get THIS_MODULE
238  */
239 #define mhi_ep_driver_register(mhi_drv) \
240         __mhi_ep_driver_register(mhi_drv, THIS_MODULE)
241
242 /**
243  * __mhi_ep_driver_register - Register a driver with MHI Endpoint bus
244  * @mhi_drv: Driver to be associated with the device
245  * @owner: The module owner
246  *
247  * Return: 0 if driver registrations succeeds, a negative error code otherwise.
248  */
249 int __mhi_ep_driver_register(struct mhi_ep_driver *mhi_drv, struct module *owner);
250
251 /**
252  * mhi_ep_driver_unregister - Unregister a driver from MHI Endpoint bus
253  * @mhi_drv: Driver associated with the device
254  */
255 void mhi_ep_driver_unregister(struct mhi_ep_driver *mhi_drv);
256
257 /**
258  * mhi_ep_register_controller - Register MHI Endpoint controller
259  * @mhi_cntrl: MHI Endpoint controller to register
260  * @config: Configuration to use for the controller
261  *
262  * Return: 0 if controller registrations succeeds, a negative error code otherwise.
263  */
264 int mhi_ep_register_controller(struct mhi_ep_cntrl *mhi_cntrl,
265                                const struct mhi_ep_cntrl_config *config);
266
267 /**
268  * mhi_ep_unregister_controller - Unregister MHI Endpoint controller
269  * @mhi_cntrl: MHI Endpoint controller to unregister
270  */
271 void mhi_ep_unregister_controller(struct mhi_ep_cntrl *mhi_cntrl);
272
273 /**
274  * mhi_ep_power_up - Power up the MHI endpoint stack
275  * @mhi_cntrl: MHI Endpoint controller
276  *
277  * Return: 0 if power up succeeds, a negative error code otherwise.
278  */
279 int mhi_ep_power_up(struct mhi_ep_cntrl *mhi_cntrl);
280
281 /**
282  * mhi_ep_power_down - Power down the MHI endpoint stack
283  * @mhi_cntrl: MHI controller
284  */
285 void mhi_ep_power_down(struct mhi_ep_cntrl *mhi_cntrl);
286
287 /**
288  * mhi_ep_queue_is_empty - Determine whether the transfer queue is empty
289  * @mhi_dev: Device associated with the channels
290  * @dir: DMA direction for the channel
291  *
292  * Return: true if the queue is empty, false otherwise.
293  */
294 bool mhi_ep_queue_is_empty(struct mhi_ep_device *mhi_dev, enum dma_data_direction dir);
295
296 /**
297  * mhi_ep_queue_skb - Send SKBs to host over MHI Endpoint
298  * @mhi_dev: Device associated with the DL channel
299  * @skb: SKBs to be queued
300  *
301  * Return: 0 if the SKBs has been sent successfully, a negative error code otherwise.
302  */
303 int mhi_ep_queue_skb(struct mhi_ep_device *mhi_dev, struct sk_buff *skb);
304
305 #endif