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_cntrl - MHI Endpoint controller structure
54  * @cntrl_dev: Pointer to the struct device of physical bus acting as the MHI
55  *             Endpoint controller
56  * @mhi_dev: MHI Endpoint device instance for the controller
57  * @mmio: MMIO region containing the MHI registers
58  * @mhi_chan: Points to the channel configuration table
59  * @mhi_event: Points to the event ring configurations table
60  * @mhi_cmd: Points to the command ring configurations table
61  * @sm: MHI Endpoint state machine
62  * @ch_ctx_cache: Cache of host channel context data structure
63  * @ev_ctx_cache: Cache of host event context data structure
64  * @cmd_ctx_cache: Cache of host command context data structure
65  * @ch_ctx_host_pa: Physical address of host channel context data structure
66  * @ev_ctx_host_pa: Physical address of host event context data structure
67  * @cmd_ctx_host_pa: Physical address of host command context data structure
68  * @ch_ctx_cache_phys: Physical address of the host channel context cache
69  * @ev_ctx_cache_phys: Physical address of the host event context cache
70  * @cmd_ctx_cache_phys: Physical address of the host command context cache
71  * @chdb: Array of channel doorbell interrupt info
72  * @event_lock: Lock for protecting event rings
73  * @state_lock: Lock for protecting state transitions
74  * @list_lock: Lock for protecting state transition and channel doorbell lists
75  * @st_transition_list: List of state transitions
76  * @ch_db_list: List of queued channel doorbells
77  * @wq: Dedicated workqueue for handling rings and state changes
78  * @state_work: State transition worker
79  * @reset_work: Worker for MHI Endpoint reset
80  * @cmd_ring_work: Worker for processing command rings
81  * @ch_ring_work: Worker for processing channel rings
82  * @raise_irq: CB function for raising IRQ to the host
83  * @alloc_map: CB function for allocating memory in endpoint for storing host context and mapping it
84  * @unmap_free: CB function to unmap and free the allocated memory in endpoint for storing host context
85  * @read_from_host: CB function for reading from host memory from endpoint
86  * @write_to_host: CB function for writing to host memory from endpoint
87  * @mhi_state: MHI Endpoint state
88  * @max_chan: Maximum channels supported by the endpoint controller
89  * @mru: MRU (Maximum Receive Unit) value of the endpoint controller
90  * @event_rings: Number of event rings supported by the endpoint controller
91  * @hw_event_rings: Number of hardware event rings supported by the endpoint controller
92  * @chdb_offset: Channel doorbell offset set by the host
93  * @erdb_offset: Event ring doorbell offset set by the host
94  * @index: MHI Endpoint controller index
95  * @irq: IRQ used by the endpoint controller
96  * @enabled: Check if the endpoint controller is enabled or not
97  */
98 struct mhi_ep_cntrl {
99 	struct device *cntrl_dev;
100 	struct mhi_ep_device *mhi_dev;
101 	void __iomem *mmio;
102 
103 	struct mhi_ep_chan *mhi_chan;
104 	struct mhi_ep_event *mhi_event;
105 	struct mhi_ep_cmd *mhi_cmd;
106 	struct mhi_ep_sm *sm;
107 
108 	struct mhi_chan_ctxt *ch_ctx_cache;
109 	struct mhi_event_ctxt *ev_ctx_cache;
110 	struct mhi_cmd_ctxt *cmd_ctx_cache;
111 	u64 ch_ctx_host_pa;
112 	u64 ev_ctx_host_pa;
113 	u64 cmd_ctx_host_pa;
114 	phys_addr_t ch_ctx_cache_phys;
115 	phys_addr_t ev_ctx_cache_phys;
116 	phys_addr_t cmd_ctx_cache_phys;
117 
118 	struct mhi_ep_db_info chdb[4];
119 	struct mutex event_lock;
120 	struct mutex state_lock;
121 	spinlock_t list_lock;
122 
123 	struct list_head st_transition_list;
124 	struct list_head ch_db_list;
125 
126 	struct workqueue_struct *wq;
127 	struct work_struct state_work;
128 	struct work_struct reset_work;
129 	struct work_struct cmd_ring_work;
130 	struct work_struct ch_ring_work;
131 
132 	void (*raise_irq)(struct mhi_ep_cntrl *mhi_cntrl, u32 vector);
133 	int (*alloc_map)(struct mhi_ep_cntrl *mhi_cntrl, u64 pci_addr, phys_addr_t *phys_ptr,
134 			 void __iomem **virt, size_t size);
135 	void (*unmap_free)(struct mhi_ep_cntrl *mhi_cntrl, u64 pci_addr, phys_addr_t phys,
136 			   void __iomem *virt, size_t size);
137 	int (*read_from_host)(struct mhi_ep_cntrl *mhi_cntrl, u64 from, void *to, size_t size);
138 	int (*write_to_host)(struct mhi_ep_cntrl *mhi_cntrl, void *from, u64 to, size_t size);
139 
140 	enum mhi_state mhi_state;
141 
142 	u32 max_chan;
143 	u32 mru;
144 	u32 event_rings;
145 	u32 hw_event_rings;
146 	u32 chdb_offset;
147 	u32 erdb_offset;
148 	u32 index;
149 	int irq;
150 	bool enabled;
151 };
152 
153 /**
154  * struct mhi_ep_device - Structure representing an MHI Endpoint device that binds
155  *                     to channels or is associated with controllers
156  * @dev: Driver model device node for the MHI Endpoint device
157  * @mhi_cntrl: Controller the device belongs to
158  * @id: Pointer to MHI Endpoint device ID struct
159  * @name: Name of the associated MHI Endpoint device
160  * @ul_chan: UL (from host to endpoint) channel for the device
161  * @dl_chan: DL (from endpoint to host) channel for the device
162  * @dev_type: MHI device type
163  */
164 struct mhi_ep_device {
165 	struct device dev;
166 	struct mhi_ep_cntrl *mhi_cntrl;
167 	const struct mhi_device_id *id;
168 	const char *name;
169 	struct mhi_ep_chan *ul_chan;
170 	struct mhi_ep_chan *dl_chan;
171 	enum mhi_device_type dev_type;
172 };
173 
174 /**
175  * struct mhi_ep_driver - Structure representing a MHI Endpoint client driver
176  * @id_table: Pointer to MHI Endpoint device ID table
177  * @driver: Device driver model driver
178  * @probe: CB function for client driver probe function
179  * @remove: CB function for client driver remove function
180  * @ul_xfer_cb: CB function for UL (from host to endpoint) data transfer
181  * @dl_xfer_cb: CB function for DL (from endpoint to host) data transfer
182  */
183 struct mhi_ep_driver {
184 	const struct mhi_device_id *id_table;
185 	struct device_driver driver;
186 	int (*probe)(struct mhi_ep_device *mhi_ep,
187 		     const struct mhi_device_id *id);
188 	void (*remove)(struct mhi_ep_device *mhi_ep);
189 	void (*ul_xfer_cb)(struct mhi_ep_device *mhi_dev,
190 			   struct mhi_result *result);
191 	void (*dl_xfer_cb)(struct mhi_ep_device *mhi_dev,
192 			   struct mhi_result *result);
193 };
194 
195 #define to_mhi_ep_device(dev) container_of(dev, struct mhi_ep_device, dev)
196 #define to_mhi_ep_driver(drv) container_of(drv, struct mhi_ep_driver, driver)
197 
198 /*
199  * module_mhi_ep_driver() - Helper macro for drivers that don't do
200  * anything special other than using default mhi_ep_driver_register() and
201  * mhi_ep_driver_unregister().  This eliminates a lot of boilerplate.
202  * Each module may only use this macro once.
203  */
204 #define module_mhi_ep_driver(mhi_drv) \
205 	module_driver(mhi_drv, mhi_ep_driver_register, \
206 		      mhi_ep_driver_unregister)
207 
208 /*
209  * Macro to avoid include chaining to get THIS_MODULE
210  */
211 #define mhi_ep_driver_register(mhi_drv) \
212 	__mhi_ep_driver_register(mhi_drv, THIS_MODULE)
213 
214 /**
215  * __mhi_ep_driver_register - Register a driver with MHI Endpoint bus
216  * @mhi_drv: Driver to be associated with the device
217  * @owner: The module owner
218  *
219  * Return: 0 if driver registrations succeeds, a negative error code otherwise.
220  */
221 int __mhi_ep_driver_register(struct mhi_ep_driver *mhi_drv, struct module *owner);
222 
223 /**
224  * mhi_ep_driver_unregister - Unregister a driver from MHI Endpoint bus
225  * @mhi_drv: Driver associated with the device
226  */
227 void mhi_ep_driver_unregister(struct mhi_ep_driver *mhi_drv);
228 
229 /**
230  * mhi_ep_register_controller - Register MHI Endpoint controller
231  * @mhi_cntrl: MHI Endpoint controller to register
232  * @config: Configuration to use for the controller
233  *
234  * Return: 0 if controller registrations succeeds, a negative error code otherwise.
235  */
236 int mhi_ep_register_controller(struct mhi_ep_cntrl *mhi_cntrl,
237 			       const struct mhi_ep_cntrl_config *config);
238 
239 /**
240  * mhi_ep_unregister_controller - Unregister MHI Endpoint controller
241  * @mhi_cntrl: MHI Endpoint controller to unregister
242  */
243 void mhi_ep_unregister_controller(struct mhi_ep_cntrl *mhi_cntrl);
244 
245 /**
246  * mhi_ep_power_up - Power up the MHI endpoint stack
247  * @mhi_cntrl: MHI Endpoint controller
248  *
249  * Return: 0 if power up succeeds, a negative error code otherwise.
250  */
251 int mhi_ep_power_up(struct mhi_ep_cntrl *mhi_cntrl);
252 
253 /**
254  * mhi_ep_power_down - Power down the MHI endpoint stack
255  * @mhi_cntrl: MHI controller
256  */
257 void mhi_ep_power_down(struct mhi_ep_cntrl *mhi_cntrl);
258 
259 /**
260  * mhi_ep_queue_is_empty - Determine whether the transfer queue is empty
261  * @mhi_dev: Device associated with the channels
262  * @dir: DMA direction for the channel
263  *
264  * Return: true if the queue is empty, false otherwise.
265  */
266 bool mhi_ep_queue_is_empty(struct mhi_ep_device *mhi_dev, enum dma_data_direction dir);
267 
268 /**
269  * mhi_ep_queue_skb - Send SKBs to host over MHI Endpoint
270  * @mhi_dev: Device associated with the DL channel
271  * @skb: SKBs to be queued
272  *
273  * Return: 0 if the SKBs has been sent successfully, a negative error code otherwise.
274  */
275 int mhi_ep_queue_skb(struct mhi_ep_device *mhi_dev, struct sk_buff *skb);
276 
277 #endif
278