1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2021, Intel Corporation. */
3 
4 /* Inter-Driver Communication */
5 #include "ice.h"
6 #include "ice_lib.h"
7 #include "ice_dcb_lib.h"
8 
9 static DEFINE_XARRAY_ALLOC1(ice_aux_id);
10 
11 /**
12  * ice_get_auxiliary_drv - retrieve iidc_auxiliary_drv struct
13  * @pf: pointer to PF struct
14  *
15  * This function has to be called with a device_lock on the
16  * pf->adev.dev to avoid race conditions.
17  */
18 static struct iidc_auxiliary_drv *ice_get_auxiliary_drv(struct ice_pf *pf)
19 {
20 	struct auxiliary_device *adev;
21 
22 	adev = pf->adev;
23 	if (!adev || !adev->dev.driver)
24 		return NULL;
25 
26 	return container_of(adev->dev.driver, struct iidc_auxiliary_drv,
27 			    adrv.driver);
28 }
29 
30 /**
31  * ice_send_event_to_aux - send event to RDMA AUX driver
32  * @pf: pointer to PF struct
33  * @event: event struct
34  */
35 void ice_send_event_to_aux(struct ice_pf *pf, struct iidc_event *event)
36 {
37 	struct iidc_auxiliary_drv *iadrv;
38 
39 	if (WARN_ON_ONCE(!in_task()))
40 		return;
41 
42 	mutex_lock(&pf->adev_mutex);
43 	if (!pf->adev)
44 		goto finish;
45 
46 	device_lock(&pf->adev->dev);
47 	iadrv = ice_get_auxiliary_drv(pf);
48 	if (iadrv && iadrv->event_handler)
49 		iadrv->event_handler(pf, event);
50 	device_unlock(&pf->adev->dev);
51 finish:
52 	mutex_unlock(&pf->adev_mutex);
53 }
54 
55 /**
56  * ice_add_rdma_qset - Add Leaf Node for RDMA Qset
57  * @pf: PF struct
58  * @qset: Resource to be allocated
59  */
60 int ice_add_rdma_qset(struct ice_pf *pf, struct iidc_rdma_qset_params *qset)
61 {
62 	u16 max_rdmaqs[ICE_MAX_TRAFFIC_CLASS];
63 	struct ice_vsi *vsi;
64 	struct device *dev;
65 	u32 qset_teid;
66 	u16 qs_handle;
67 	int status;
68 	int i;
69 
70 	if (WARN_ON(!pf || !qset))
71 		return -EINVAL;
72 
73 	dev = ice_pf_to_dev(pf);
74 
75 	if (!ice_is_rdma_ena(pf))
76 		return -EINVAL;
77 
78 	vsi = ice_get_main_vsi(pf);
79 	if (!vsi) {
80 		dev_err(dev, "RDMA QSet invalid VSI\n");
81 		return -EINVAL;
82 	}
83 
84 	ice_for_each_traffic_class(i)
85 		max_rdmaqs[i] = 0;
86 
87 	max_rdmaqs[qset->tc]++;
88 	qs_handle = qset->qs_handle;
89 
90 	status = ice_cfg_vsi_rdma(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc,
91 				  max_rdmaqs);
92 	if (status) {
93 		dev_err(dev, "Failed VSI RDMA Qset config\n");
94 		return status;
95 	}
96 
97 	status = ice_ena_vsi_rdma_qset(vsi->port_info, vsi->idx, qset->tc,
98 				       &qs_handle, 1, &qset_teid);
99 	if (status) {
100 		dev_err(dev, "Failed VSI RDMA Qset enable\n");
101 		return status;
102 	}
103 	vsi->qset_handle[qset->tc] = qset->qs_handle;
104 	qset->teid = qset_teid;
105 
106 	return 0;
107 }
108 EXPORT_SYMBOL_GPL(ice_add_rdma_qset);
109 
110 /**
111  * ice_del_rdma_qset - Delete leaf node for RDMA Qset
112  * @pf: PF struct
113  * @qset: Resource to be freed
114  */
115 int ice_del_rdma_qset(struct ice_pf *pf, struct iidc_rdma_qset_params *qset)
116 {
117 	struct ice_vsi *vsi;
118 	u32 teid;
119 	u16 q_id;
120 
121 	if (WARN_ON(!pf || !qset))
122 		return -EINVAL;
123 
124 	vsi = ice_find_vsi(pf, qset->vport_id);
125 	if (!vsi) {
126 		dev_err(ice_pf_to_dev(pf), "RDMA Invalid VSI\n");
127 		return -EINVAL;
128 	}
129 
130 	q_id = qset->qs_handle;
131 	teid = qset->teid;
132 
133 	vsi->qset_handle[qset->tc] = 0;
134 
135 	return ice_dis_vsi_rdma_qset(vsi->port_info, 1, &teid, &q_id);
136 }
137 EXPORT_SYMBOL_GPL(ice_del_rdma_qset);
138 
139 /**
140  * ice_rdma_request_reset - accept request from RDMA to perform a reset
141  * @pf: struct for PF
142  * @reset_type: type of reset
143  */
144 int ice_rdma_request_reset(struct ice_pf *pf, enum iidc_reset_type reset_type)
145 {
146 	enum ice_reset_req reset;
147 
148 	if (WARN_ON(!pf))
149 		return -EINVAL;
150 
151 	switch (reset_type) {
152 	case IIDC_PFR:
153 		reset = ICE_RESET_PFR;
154 		break;
155 	case IIDC_CORER:
156 		reset = ICE_RESET_CORER;
157 		break;
158 	case IIDC_GLOBR:
159 		reset = ICE_RESET_GLOBR;
160 		break;
161 	default:
162 		dev_err(ice_pf_to_dev(pf), "incorrect reset request\n");
163 		return -EINVAL;
164 	}
165 
166 	return ice_schedule_reset(pf, reset);
167 }
168 EXPORT_SYMBOL_GPL(ice_rdma_request_reset);
169 
170 /**
171  * ice_rdma_update_vsi_filter - update main VSI filters for RDMA
172  * @pf: pointer to struct for PF
173  * @vsi_id: VSI HW idx to update filter on
174  * @enable: bool whether to enable or disable filters
175  */
176 int ice_rdma_update_vsi_filter(struct ice_pf *pf, u16 vsi_id, bool enable)
177 {
178 	struct ice_vsi *vsi;
179 	int status;
180 
181 	if (WARN_ON(!pf))
182 		return -EINVAL;
183 
184 	vsi = ice_find_vsi(pf, vsi_id);
185 	if (!vsi)
186 		return -EINVAL;
187 
188 	status = ice_cfg_rdma_fltr(&pf->hw, vsi->idx, enable);
189 	if (status) {
190 		dev_err(ice_pf_to_dev(pf), "Failed to  %sable RDMA filtering\n",
191 			enable ? "en" : "dis");
192 	} else {
193 		if (enable)
194 			vsi->info.q_opt_flags |= ICE_AQ_VSI_Q_OPT_PE_FLTR_EN;
195 		else
196 			vsi->info.q_opt_flags &= ~ICE_AQ_VSI_Q_OPT_PE_FLTR_EN;
197 	}
198 
199 	return status;
200 }
201 EXPORT_SYMBOL_GPL(ice_rdma_update_vsi_filter);
202 
203 /**
204  * ice_get_qos_params - parse QoS params for RDMA consumption
205  * @pf: pointer to PF struct
206  * @qos: set of QoS values
207  */
208 void ice_get_qos_params(struct ice_pf *pf, struct iidc_qos_params *qos)
209 {
210 	struct ice_dcbx_cfg *dcbx_cfg;
211 	unsigned int i;
212 	u32 up2tc;
213 
214 	dcbx_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
215 	up2tc = rd32(&pf->hw, PRTDCB_TUP2TC);
216 
217 	qos->num_tc = ice_dcb_get_num_tc(dcbx_cfg);
218 	for (i = 0; i < IIDC_MAX_USER_PRIORITY; i++)
219 		qos->up2tc[i] = (up2tc >> (i * 3)) & 0x7;
220 
221 	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
222 		qos->tc_info[i].rel_bw = dcbx_cfg->etscfg.tcbwtable[i];
223 
224 	qos->pfc_mode = dcbx_cfg->pfc_mode;
225 	if (qos->pfc_mode == IIDC_DSCP_PFC_MODE)
226 		for (i = 0; i < IIDC_MAX_DSCP_MAPPING; i++)
227 			qos->dscp_map[i] = dcbx_cfg->dscp_map[i];
228 }
229 EXPORT_SYMBOL_GPL(ice_get_qos_params);
230 
231 /**
232  * ice_alloc_rdma_qvectors - Allocate vector resources for RDMA driver
233  * @pf: board private structure to initialize
234  */
235 static int ice_alloc_rdma_qvectors(struct ice_pf *pf)
236 {
237 	if (ice_is_rdma_ena(pf)) {
238 		int i;
239 
240 		pf->msix_entries = kcalloc(pf->num_rdma_msix,
241 					   sizeof(*pf->msix_entries),
242 						  GFP_KERNEL);
243 		if (!pf->msix_entries)
244 			return -ENOMEM;
245 
246 		/* RDMA is the only user of pf->msix_entries array */
247 		pf->rdma_base_vector = 0;
248 
249 		for (i = 0; i < pf->num_rdma_msix; i++) {
250 			struct msix_entry *entry = &pf->msix_entries[i];
251 			struct msi_map map;
252 
253 			map = ice_alloc_irq(pf, false);
254 			if (map.index < 0)
255 				break;
256 
257 			entry->entry = map.index;
258 			entry->vector = map.virq;
259 		}
260 	}
261 	return 0;
262 }
263 
264 /**
265  * ice_free_rdma_qvector - free vector resources reserved for RDMA driver
266  * @pf: board private structure to initialize
267  */
268 static void ice_free_rdma_qvector(struct ice_pf *pf)
269 {
270 	int i;
271 
272 	if (!pf->msix_entries)
273 		return;
274 
275 	for (i = 0; i < pf->num_rdma_msix; i++) {
276 		struct msi_map map;
277 
278 		map.index = pf->msix_entries[i].entry;
279 		map.virq = pf->msix_entries[i].vector;
280 		ice_free_irq(pf, map);
281 	}
282 
283 	kfree(pf->msix_entries);
284 	pf->msix_entries = NULL;
285 }
286 
287 /**
288  * ice_adev_release - function to be mapped to AUX dev's release op
289  * @dev: pointer to device to free
290  */
291 static void ice_adev_release(struct device *dev)
292 {
293 	struct iidc_auxiliary_dev *iadev;
294 
295 	iadev = container_of(dev, struct iidc_auxiliary_dev, adev.dev);
296 	kfree(iadev);
297 }
298 
299 /**
300  * ice_plug_aux_dev - allocate and register AUX device
301  * @pf: pointer to pf struct
302  */
303 int ice_plug_aux_dev(struct ice_pf *pf)
304 {
305 	struct iidc_auxiliary_dev *iadev;
306 	struct auxiliary_device *adev;
307 	int ret;
308 
309 	/* if this PF doesn't support a technology that requires auxiliary
310 	 * devices, then gracefully exit
311 	 */
312 	if (!ice_is_rdma_ena(pf))
313 		return 0;
314 
315 	iadev = kzalloc(sizeof(*iadev), GFP_KERNEL);
316 	if (!iadev)
317 		return -ENOMEM;
318 
319 	adev = &iadev->adev;
320 	iadev->pf = pf;
321 
322 	adev->id = pf->aux_idx;
323 	adev->dev.release = ice_adev_release;
324 	adev->dev.parent = &pf->pdev->dev;
325 	adev->name = pf->rdma_mode & IIDC_RDMA_PROTOCOL_ROCEV2 ? "roce" : "iwarp";
326 
327 	ret = auxiliary_device_init(adev);
328 	if (ret) {
329 		kfree(iadev);
330 		return ret;
331 	}
332 
333 	ret = auxiliary_device_add(adev);
334 	if (ret) {
335 		auxiliary_device_uninit(adev);
336 		return ret;
337 	}
338 
339 	mutex_lock(&pf->adev_mutex);
340 	pf->adev = adev;
341 	mutex_unlock(&pf->adev_mutex);
342 
343 	return 0;
344 }
345 
346 /* ice_unplug_aux_dev - unregister and free AUX device
347  * @pf: pointer to pf struct
348  */
349 void ice_unplug_aux_dev(struct ice_pf *pf)
350 {
351 	struct auxiliary_device *adev;
352 
353 	mutex_lock(&pf->adev_mutex);
354 	adev = pf->adev;
355 	pf->adev = NULL;
356 	mutex_unlock(&pf->adev_mutex);
357 
358 	if (adev) {
359 		auxiliary_device_delete(adev);
360 		auxiliary_device_uninit(adev);
361 	}
362 }
363 
364 /**
365  * ice_init_rdma - initializes PF for RDMA use
366  * @pf: ptr to ice_pf
367  */
368 int ice_init_rdma(struct ice_pf *pf)
369 {
370 	struct device *dev = &pf->pdev->dev;
371 	int ret;
372 
373 	if (!ice_is_rdma_ena(pf)) {
374 		dev_warn(dev, "RDMA is not supported on this device\n");
375 		return 0;
376 	}
377 
378 	ret = xa_alloc(&ice_aux_id, &pf->aux_idx, NULL, XA_LIMIT(1, INT_MAX),
379 		       GFP_KERNEL);
380 	if (ret) {
381 		dev_err(dev, "Failed to allocate device ID for AUX driver\n");
382 		return -ENOMEM;
383 	}
384 
385 	/* Reserve vector resources */
386 	ret = ice_alloc_rdma_qvectors(pf);
387 	if (ret < 0) {
388 		dev_err(dev, "failed to reserve vectors for RDMA\n");
389 		goto err_reserve_rdma_qvector;
390 	}
391 	pf->rdma_mode |= IIDC_RDMA_PROTOCOL_ROCEV2;
392 	ret = ice_plug_aux_dev(pf);
393 	if (ret)
394 		goto err_plug_aux_dev;
395 	return 0;
396 
397 err_plug_aux_dev:
398 	ice_free_rdma_qvector(pf);
399 err_reserve_rdma_qvector:
400 	pf->adev = NULL;
401 	xa_erase(&ice_aux_id, pf->aux_idx);
402 	return ret;
403 }
404 
405 /**
406  * ice_deinit_rdma - deinitialize RDMA on PF
407  * @pf: ptr to ice_pf
408  */
409 void ice_deinit_rdma(struct ice_pf *pf)
410 {
411 	if (!ice_is_rdma_ena(pf))
412 		return;
413 
414 	ice_unplug_aux_dev(pf);
415 	ice_free_rdma_qvector(pf);
416 	xa_erase(&ice_aux_id, pf->aux_idx);
417 }
418