1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2013 - 2018 Intel Corporation. */
3 
4 #include <linux/list.h>
5 #include <linux/errno.h>
6 
7 #include "iavf.h"
8 #include "iavf_prototype.h"
9 #include "iavf_client.h"
10 
11 static
12 const char iavf_client_interface_version_str[] = IAVF_CLIENT_VERSION_STR;
13 static struct iavf_client *vf_registered_client;
14 static LIST_HEAD(iavf_devices);
15 static DEFINE_MUTEX(iavf_device_mutex);
16 
17 static u32 iavf_client_virtchnl_send(struct iavf_info *ldev,
18 				     struct iavf_client *client,
19 				     u8 *msg, u16 len);
20 
21 static int iavf_client_setup_qvlist(struct iavf_info *ldev,
22 				    struct iavf_client *client,
23 				    struct iavf_qvlist_info *qvlist_info);
24 
25 static struct iavf_ops iavf_lan_ops = {
26 	.virtchnl_send = iavf_client_virtchnl_send,
27 	.setup_qvlist = iavf_client_setup_qvlist,
28 };
29 
30 /**
31  * iavf_client_get_params - retrieve relevant client parameters
32  * @vsi: VSI with parameters
33  * @params: client param struct
34  **/
35 static
36 void iavf_client_get_params(struct iavf_vsi *vsi, struct iavf_params *params)
37 {
38 	int i;
39 
40 	memset(params, 0, sizeof(struct iavf_params));
41 	params->mtu = vsi->netdev->mtu;
42 	params->link_up = vsi->back->link_up;
43 
44 	for (i = 0; i < IAVF_MAX_USER_PRIORITY; i++) {
45 		params->qos.prio_qos[i].tc = 0;
46 		params->qos.prio_qos[i].qs_handle = vsi->qs_handle;
47 	}
48 }
49 
50 /**
51  * iavf_notify_client_message - call the client message receive callback
52  * @vsi: the VSI associated with this client
53  * @msg: message buffer
54  * @len: length of message
55  *
56  * If there is a client to this VSI, call the client
57  **/
58 void iavf_notify_client_message(struct iavf_vsi *vsi, u8 *msg, u16 len)
59 {
60 	struct iavf_client_instance *cinst;
61 
62 	if (!vsi)
63 		return;
64 
65 	cinst = vsi->back->cinst;
66 	if (!cinst || !cinst->client || !cinst->client->ops ||
67 	    !cinst->client->ops->virtchnl_receive) {
68 		dev_dbg(&vsi->back->pdev->dev,
69 			"Cannot locate client instance virtchnl_receive function\n");
70 		return;
71 	}
72 	cinst->client->ops->virtchnl_receive(&cinst->lan_info,  cinst->client,
73 					     msg, len);
74 }
75 
76 /**
77  * iavf_notify_client_l2_params - call the client notify callback
78  * @vsi: the VSI with l2 param changes
79  *
80  * If there is a client to this VSI, call the client
81  **/
82 void iavf_notify_client_l2_params(struct iavf_vsi *vsi)
83 {
84 	struct iavf_client_instance *cinst;
85 	struct iavf_params params;
86 
87 	if (!vsi)
88 		return;
89 
90 	cinst = vsi->back->cinst;
91 
92 	if (!cinst || !cinst->client || !cinst->client->ops ||
93 	    !cinst->client->ops->l2_param_change) {
94 		dev_dbg(&vsi->back->pdev->dev,
95 			"Cannot locate client instance l2_param_change function\n");
96 		return;
97 	}
98 	iavf_client_get_params(vsi, &params);
99 	cinst->lan_info.params = params;
100 	cinst->client->ops->l2_param_change(&cinst->lan_info, cinst->client,
101 					    &params);
102 }
103 
104 /**
105  * iavf_notify_client_open - call the client open callback
106  * @vsi: the VSI with netdev opened
107  *
108  * If there is a client to this netdev, call the client with open
109  **/
110 void iavf_notify_client_open(struct iavf_vsi *vsi)
111 {
112 	struct iavf_adapter *adapter = vsi->back;
113 	struct iavf_client_instance *cinst = adapter->cinst;
114 	int ret;
115 
116 	if (!cinst || !cinst->client || !cinst->client->ops ||
117 	    !cinst->client->ops->open) {
118 		dev_dbg(&vsi->back->pdev->dev,
119 			"Cannot locate client instance open function\n");
120 		return;
121 	}
122 	if (!(test_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state))) {
123 		ret = cinst->client->ops->open(&cinst->lan_info, cinst->client);
124 		if (!ret)
125 			set_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state);
126 	}
127 }
128 
129 /**
130  * iavf_client_release_qvlist - send a message to the PF to release rdma qv map
131  * @ldev: pointer to L2 context.
132  *
133  * Return 0 on success or < 0 on error
134  **/
135 static int iavf_client_release_qvlist(struct iavf_info *ldev)
136 {
137 	struct iavf_adapter *adapter = ldev->vf;
138 	enum iavf_status err;
139 
140 	if (adapter->aq_required)
141 		return -EAGAIN;
142 
143 	err = iavf_aq_send_msg_to_pf(&adapter->hw,
144 				     VIRTCHNL_OP_RELEASE_RDMA_IRQ_MAP,
145 				     IAVF_SUCCESS, NULL, 0, NULL);
146 
147 	if (err)
148 		dev_err(&adapter->pdev->dev,
149 			"Unable to send RDMA vector release message to PF, error %d, aq status %d\n",
150 			err, adapter->hw.aq.asq_last_status);
151 
152 	return err;
153 }
154 
155 /**
156  * iavf_notify_client_close - call the client close callback
157  * @vsi: the VSI with netdev closed
158  * @reset: true when close called due to reset pending
159  *
160  * If there is a client to this netdev, call the client with close
161  **/
162 void iavf_notify_client_close(struct iavf_vsi *vsi, bool reset)
163 {
164 	struct iavf_adapter *adapter = vsi->back;
165 	struct iavf_client_instance *cinst = adapter->cinst;
166 
167 	if (!cinst || !cinst->client || !cinst->client->ops ||
168 	    !cinst->client->ops->close) {
169 		dev_dbg(&vsi->back->pdev->dev,
170 			"Cannot locate client instance close function\n");
171 		return;
172 	}
173 	cinst->client->ops->close(&cinst->lan_info, cinst->client, reset);
174 	iavf_client_release_qvlist(&cinst->lan_info);
175 	clear_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state);
176 }
177 
178 /**
179  * iavf_client_add_instance - add a client instance to the instance list
180  * @adapter: pointer to the board struct
181  *
182  * Returns cinst ptr on success, NULL on failure
183  **/
184 static struct iavf_client_instance *
185 iavf_client_add_instance(struct iavf_adapter *adapter)
186 {
187 	struct iavf_client_instance *cinst = NULL;
188 	struct iavf_vsi *vsi = &adapter->vsi;
189 	struct netdev_hw_addr *mac = NULL;
190 	struct iavf_params params;
191 
192 	if (!vf_registered_client)
193 		goto out;
194 
195 	if (adapter->cinst) {
196 		cinst = adapter->cinst;
197 		goto out;
198 	}
199 
200 	cinst = kzalloc(sizeof(*cinst), GFP_KERNEL);
201 	if (!cinst)
202 		goto out;
203 
204 	cinst->lan_info.vf = (void *)adapter;
205 	cinst->lan_info.netdev = vsi->netdev;
206 	cinst->lan_info.pcidev = adapter->pdev;
207 	cinst->lan_info.fid = 0;
208 	cinst->lan_info.ftype = IAVF_CLIENT_FTYPE_VF;
209 	cinst->lan_info.hw_addr = adapter->hw.hw_addr;
210 	cinst->lan_info.ops = &iavf_lan_ops;
211 	cinst->lan_info.version.major = IAVF_CLIENT_VERSION_MAJOR;
212 	cinst->lan_info.version.minor = IAVF_CLIENT_VERSION_MINOR;
213 	cinst->lan_info.version.build = IAVF_CLIENT_VERSION_BUILD;
214 	iavf_client_get_params(vsi, &params);
215 	cinst->lan_info.params = params;
216 	set_bit(__IAVF_CLIENT_INSTANCE_NONE, &cinst->state);
217 
218 	cinst->lan_info.msix_count = adapter->num_rdma_msix;
219 	cinst->lan_info.msix_entries =
220 			&adapter->msix_entries[adapter->rdma_base_vector];
221 
222 	mac = list_first_entry(&cinst->lan_info.netdev->dev_addrs.list,
223 			       struct netdev_hw_addr, list);
224 	if (mac)
225 		ether_addr_copy(cinst->lan_info.lanmac, mac->addr);
226 	else
227 		dev_err(&adapter->pdev->dev, "MAC address list is empty!\n");
228 
229 	cinst->client = vf_registered_client;
230 	adapter->cinst = cinst;
231 out:
232 	return cinst;
233 }
234 
235 /**
236  * iavf_client_del_instance - removes a client instance from the list
237  * @adapter: pointer to the board struct
238  *
239  **/
240 static
241 void iavf_client_del_instance(struct iavf_adapter *adapter)
242 {
243 	kfree(adapter->cinst);
244 	adapter->cinst = NULL;
245 }
246 
247 /**
248  * iavf_client_subtask - client maintenance work
249  * @adapter: board private structure
250  **/
251 void iavf_client_subtask(struct iavf_adapter *adapter)
252 {
253 	struct iavf_client *client = vf_registered_client;
254 	struct iavf_client_instance *cinst;
255 	int ret = 0;
256 
257 	if (adapter->state < __IAVF_DOWN)
258 		return;
259 
260 	/* first check client is registered */
261 	if (!client)
262 		return;
263 
264 	/* Add the client instance to the instance list */
265 	cinst = iavf_client_add_instance(adapter);
266 	if (!cinst)
267 		return;
268 
269 	dev_info(&adapter->pdev->dev, "Added instance of Client %s\n",
270 		 client->name);
271 
272 	if (!test_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state)) {
273 		/* Send an Open request to the client */
274 
275 		if (client->ops && client->ops->open)
276 			ret = client->ops->open(&cinst->lan_info, client);
277 		if (!ret)
278 			set_bit(__IAVF_CLIENT_INSTANCE_OPENED,
279 				&cinst->state);
280 		else
281 			/* remove client instance */
282 			iavf_client_del_instance(adapter);
283 	}
284 }
285 
286 /**
287  * iavf_lan_add_device - add a lan device struct to the list of lan devices
288  * @adapter: pointer to the board struct
289  *
290  * Returns 0 on success or none 0 on error
291  **/
292 int iavf_lan_add_device(struct iavf_adapter *adapter)
293 {
294 	struct iavf_device *ldev;
295 	int ret = 0;
296 
297 	mutex_lock(&iavf_device_mutex);
298 	list_for_each_entry(ldev, &iavf_devices, list) {
299 		if (ldev->vf == adapter) {
300 			ret = -EEXIST;
301 			goto out;
302 		}
303 	}
304 	ldev = kzalloc(sizeof(*ldev), GFP_KERNEL);
305 	if (!ldev) {
306 		ret = -ENOMEM;
307 		goto out;
308 	}
309 	ldev->vf = adapter;
310 	INIT_LIST_HEAD(&ldev->list);
311 	list_add(&ldev->list, &iavf_devices);
312 	dev_info(&adapter->pdev->dev, "Added LAN device bus=0x%02x dev=0x%02x func=0x%02x\n",
313 		 adapter->hw.bus.bus_id, adapter->hw.bus.device,
314 		 adapter->hw.bus.func);
315 
316 	/* Since in some cases register may have happened before a device gets
317 	 * added, we can schedule a subtask to go initiate the clients.
318 	 */
319 	adapter->flags |= IAVF_FLAG_SERVICE_CLIENT_REQUESTED;
320 
321 out:
322 	mutex_unlock(&iavf_device_mutex);
323 	return ret;
324 }
325 
326 /**
327  * iavf_lan_del_device - removes a lan device from the device list
328  * @adapter: pointer to the board struct
329  *
330  * Returns 0 on success or non-0 on error
331  **/
332 int iavf_lan_del_device(struct iavf_adapter *adapter)
333 {
334 	struct iavf_device *ldev, *tmp;
335 	int ret = -ENODEV;
336 
337 	mutex_lock(&iavf_device_mutex);
338 	list_for_each_entry_safe(ldev, tmp, &iavf_devices, list) {
339 		if (ldev->vf == adapter) {
340 			dev_info(&adapter->pdev->dev,
341 				 "Deleted LAN device bus=0x%02x dev=0x%02x func=0x%02x\n",
342 				 adapter->hw.bus.bus_id, adapter->hw.bus.device,
343 				 adapter->hw.bus.func);
344 			list_del(&ldev->list);
345 			kfree(ldev);
346 			ret = 0;
347 			break;
348 		}
349 	}
350 
351 	mutex_unlock(&iavf_device_mutex);
352 	return ret;
353 }
354 
355 /**
356  * iavf_client_release - release client specific resources
357  * @client: pointer to the registered client
358  *
359  **/
360 static void iavf_client_release(struct iavf_client *client)
361 {
362 	struct iavf_client_instance *cinst;
363 	struct iavf_device *ldev;
364 	struct iavf_adapter *adapter;
365 
366 	mutex_lock(&iavf_device_mutex);
367 	list_for_each_entry(ldev, &iavf_devices, list) {
368 		adapter = ldev->vf;
369 		cinst = adapter->cinst;
370 		if (!cinst)
371 			continue;
372 		if (test_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state)) {
373 			if (client->ops && client->ops->close)
374 				client->ops->close(&cinst->lan_info, client,
375 						   false);
376 			iavf_client_release_qvlist(&cinst->lan_info);
377 			clear_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state);
378 
379 			dev_warn(&adapter->pdev->dev,
380 				 "Client %s instance closed\n", client->name);
381 		}
382 		/* delete the client instance */
383 		iavf_client_del_instance(adapter);
384 		dev_info(&adapter->pdev->dev, "Deleted client instance of Client %s\n",
385 			 client->name);
386 	}
387 	mutex_unlock(&iavf_device_mutex);
388 }
389 
390 /**
391  * iavf_client_prepare - prepare client specific resources
392  * @client: pointer to the registered client
393  *
394  **/
395 static void iavf_client_prepare(struct iavf_client *client)
396 {
397 	struct iavf_device *ldev;
398 	struct iavf_adapter *adapter;
399 
400 	mutex_lock(&iavf_device_mutex);
401 	list_for_each_entry(ldev, &iavf_devices, list) {
402 		adapter = ldev->vf;
403 		/* Signal the watchdog to service the client */
404 		adapter->flags |= IAVF_FLAG_SERVICE_CLIENT_REQUESTED;
405 	}
406 	mutex_unlock(&iavf_device_mutex);
407 }
408 
409 /**
410  * iavf_client_virtchnl_send - send a message to the PF instance
411  * @ldev: pointer to L2 context.
412  * @client: Client pointer.
413  * @msg: pointer to message buffer
414  * @len: message length
415  *
416  * Return 0 on success or < 0 on error
417  **/
418 static u32 iavf_client_virtchnl_send(struct iavf_info *ldev,
419 				     struct iavf_client *client,
420 				     u8 *msg, u16 len)
421 {
422 	struct iavf_adapter *adapter = ldev->vf;
423 	enum iavf_status err;
424 
425 	if (adapter->aq_required)
426 		return -EAGAIN;
427 
428 	err = iavf_aq_send_msg_to_pf(&adapter->hw, VIRTCHNL_OP_RDMA,
429 				     IAVF_SUCCESS, msg, len, NULL);
430 	if (err)
431 		dev_err(&adapter->pdev->dev, "Unable to send RDMA message to PF, error %d, aq status %d\n",
432 			err, adapter->hw.aq.asq_last_status);
433 
434 	return err;
435 }
436 
437 /**
438  * iavf_client_setup_qvlist - send a message to the PF to setup rdma qv map
439  * @ldev: pointer to L2 context.
440  * @client: Client pointer.
441  * @qvlist_info: queue and vector list
442  *
443  * Return 0 on success or < 0 on error
444  **/
445 static int iavf_client_setup_qvlist(struct iavf_info *ldev,
446 				    struct iavf_client *client,
447 				    struct iavf_qvlist_info *qvlist_info)
448 {
449 	struct virtchnl_rdma_qvlist_info *v_qvlist_info;
450 	struct iavf_adapter *adapter = ldev->vf;
451 	struct iavf_qv_info *qv_info;
452 	enum iavf_status err;
453 	u32 v_idx, i;
454 	size_t msg_size;
455 
456 	if (adapter->aq_required)
457 		return -EAGAIN;
458 
459 	/* A quick check on whether the vectors belong to the client */
460 	for (i = 0; i < qvlist_info->num_vectors; i++) {
461 		qv_info = &qvlist_info->qv_info[i];
462 		if (!qv_info)
463 			continue;
464 		v_idx = qv_info->v_idx;
465 		if ((v_idx >=
466 		    (adapter->rdma_base_vector + adapter->num_rdma_msix)) ||
467 		    (v_idx < adapter->rdma_base_vector))
468 			return -EINVAL;
469 	}
470 
471 	v_qvlist_info = (struct virtchnl_rdma_qvlist_info *)qvlist_info;
472 	msg_size = virtchnl_struct_size(v_qvlist_info, qv_info,
473 					v_qvlist_info->num_vectors);
474 
475 	adapter->client_pending |= BIT(VIRTCHNL_OP_CONFIG_RDMA_IRQ_MAP);
476 	err = iavf_aq_send_msg_to_pf(&adapter->hw,
477 				VIRTCHNL_OP_CONFIG_RDMA_IRQ_MAP, IAVF_SUCCESS,
478 				(u8 *)v_qvlist_info, msg_size, NULL);
479 
480 	if (err) {
481 		dev_err(&adapter->pdev->dev,
482 			"Unable to send RDMA vector config message to PF, error %d, aq status %d\n",
483 			err, adapter->hw.aq.asq_last_status);
484 		goto out;
485 	}
486 
487 	err = -EBUSY;
488 	for (i = 0; i < 5; i++) {
489 		msleep(100);
490 		if (!(adapter->client_pending &
491 		      BIT(VIRTCHNL_OP_CONFIG_RDMA_IRQ_MAP))) {
492 			err = 0;
493 			break;
494 		}
495 	}
496 out:
497 	return err;
498 }
499 
500 /**
501  * iavf_register_client - Register a iavf client driver with the L2 driver
502  * @client: pointer to the iavf_client struct
503  *
504  * Returns 0 on success or non-0 on error
505  **/
506 int iavf_register_client(struct iavf_client *client)
507 {
508 	int ret = 0;
509 
510 	if (!client) {
511 		ret = -EIO;
512 		goto out;
513 	}
514 
515 	if (strlen(client->name) == 0) {
516 		pr_info("iavf: Failed to register client with no name\n");
517 		ret = -EIO;
518 		goto out;
519 	}
520 
521 	if (vf_registered_client) {
522 		pr_info("iavf: Client %s has already been registered!\n",
523 			client->name);
524 		ret = -EEXIST;
525 		goto out;
526 	}
527 
528 	if ((client->version.major != IAVF_CLIENT_VERSION_MAJOR) ||
529 	    (client->version.minor != IAVF_CLIENT_VERSION_MINOR)) {
530 		pr_info("iavf: Failed to register client %s due to mismatched client interface version\n",
531 			client->name);
532 		pr_info("Client is using version: %02d.%02d.%02d while LAN driver supports %s\n",
533 			client->version.major, client->version.minor,
534 			client->version.build,
535 			iavf_client_interface_version_str);
536 		ret = -EIO;
537 		goto out;
538 	}
539 
540 	vf_registered_client = client;
541 
542 	iavf_client_prepare(client);
543 
544 	pr_info("iavf: Registered client %s with return code %d\n",
545 		client->name, ret);
546 out:
547 	return ret;
548 }
549 EXPORT_SYMBOL(iavf_register_client);
550 
551 /**
552  * iavf_unregister_client - Unregister a iavf client driver with the L2 driver
553  * @client: pointer to the iavf_client struct
554  *
555  * Returns 0 on success or non-0 on error
556  **/
557 int iavf_unregister_client(struct iavf_client *client)
558 {
559 	int ret = 0;
560 
561 	/* When a unregister request comes through we would have to send
562 	 * a close for each of the client instances that were opened.
563 	 * client_release function is called to handle this.
564 	 */
565 	iavf_client_release(client);
566 
567 	if (vf_registered_client != client) {
568 		pr_info("iavf: Client %s has not been registered\n",
569 			client->name);
570 		ret = -ENODEV;
571 		goto out;
572 	}
573 	vf_registered_client = NULL;
574 	pr_info("iavf: Unregistered client %s\n", client->name);
575 out:
576 	return ret;
577 }
578 EXPORT_SYMBOL(iavf_unregister_client);
579