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 |
306 | |