1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/list.h>
28#include <linux/errno.h>
29
30#include "i40e.h"
31#include "i40e_prototype.h"
32#include "i40e_client.h"
33
34static const char i40e_client_interface_version_str[] = I40E_CLIENT_VERSION_STR;
35static struct i40e_client *registered_client;
36static LIST_HEAD(i40e_devices);
37static DEFINE_MUTEX(i40e_device_mutex);
38
39static int i40e_client_virtchnl_send(struct i40e_info *ldev,
40 struct i40e_client *client,
41 u32 vf_id, u8 *msg, u16 len);
42
43static int i40e_client_setup_qvlist(struct i40e_info *ldev,
44 struct i40e_client *client,
45 struct i40e_qvlist_info *qvlist_info);
46
47static void i40e_client_request_reset(struct i40e_info *ldev,
48 struct i40e_client *client,
49 u32 reset_level);
50
51static int i40e_client_update_vsi_ctxt(struct i40e_info *ldev,
52 struct i40e_client *client,
53 bool is_vf, u32 vf_id,
54 u32 flag, u32 valid_flag);
55
56static struct i40e_ops i40e_lan_ops = {
57 .virtchnl_send = i40e_client_virtchnl_send,
58 .setup_qvlist = i40e_client_setup_qvlist,
59 .request_reset = i40e_client_request_reset,
60 .update_vsi_ctxt = i40e_client_update_vsi_ctxt,
61};
62
63
64
65
66
67
68
69static
70int i40e_client_get_params(struct i40e_vsi *vsi, struct i40e_params *params)
71{
72 struct i40e_dcbx_config *dcb_cfg = &vsi->back->hw.local_dcbx_config;
73 int i = 0;
74
75 for (i = 0; i < I40E_MAX_USER_PRIORITY; i++) {
76 u8 tc = dcb_cfg->etscfg.prioritytable[i];
77 u16 qs_handle;
78
79
80 if (!(vsi->tc_config.enabled_tc & BIT(tc)))
81 tc = 0;
82
83 qs_handle = le16_to_cpu(vsi->info.qs_handle[tc]);
84 params->qos.prio_qos[i].tc = tc;
85 params->qos.prio_qos[i].qs_handle = qs_handle;
86 if (qs_handle == I40E_AQ_VSI_QS_HANDLE_INVALID) {
87 dev_err(&vsi->back->pdev->dev, "Invalid queue set handle for TC = %d, vsi id = %d\n",
88 tc, vsi->id);
89 return -EINVAL;
90 }
91 }
92
93 params->mtu = vsi->netdev->mtu;
94 return 0;
95}
96
97
98
99
100
101
102
103
104
105
106void
107i40e_notify_client_of_vf_msg(struct i40e_vsi *vsi, u32 vf_id, u8 *msg, u16 len)
108{
109 struct i40e_pf *pf = vsi->back;
110 struct i40e_client_instance *cdev = pf->cinst;
111
112 if (!cdev || !cdev->client)
113 return;
114 if (!cdev->client->ops || !cdev->client->ops->virtchnl_receive) {
115 dev_dbg(&pf->pdev->dev,
116 "Cannot locate client instance virtual channel receive routine\n");
117 return;
118 }
119 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) {
120 dev_dbg(&pf->pdev->dev, "Client is not open, abort virtchnl_receive\n");
121 return;
122 }
123 cdev->client->ops->virtchnl_receive(&cdev->lan_info, cdev->client,
124 vf_id, msg, len);
125}
126
127
128
129
130
131
132
133void i40e_notify_client_of_l2_param_changes(struct i40e_vsi *vsi)
134{
135 struct i40e_pf *pf = vsi->back;
136 struct i40e_client_instance *cdev = pf->cinst;
137 struct i40e_params params;
138
139 if (!cdev || !cdev->client)
140 return;
141 if (!cdev->client->ops || !cdev->client->ops->l2_param_change) {
142 dev_dbg(&vsi->back->pdev->dev,
143 "Cannot locate client instance l2_param_change routine\n");
144 return;
145 }
146 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) {
147 dev_dbg(&vsi->back->pdev->dev, "Client is not open, abort l2 param change\n");
148 return;
149 }
150 memset(¶ms, 0, sizeof(params));
151 i40e_client_get_params(vsi, ¶ms);
152 memcpy(&cdev->lan_info.params, ¶ms, sizeof(struct i40e_params));
153 cdev->client->ops->l2_param_change(&cdev->lan_info, cdev->client,
154 ¶ms);
155}
156
157
158
159
160
161
162static void i40e_client_release_qvlist(struct i40e_info *ldev)
163{
164 struct i40e_qvlist_info *qvlist_info = ldev->qvlist_info;
165 u32 i;
166
167 if (!ldev->qvlist_info)
168 return;
169
170 for (i = 0; i < qvlist_info->num_vectors; i++) {
171 struct i40e_pf *pf = ldev->pf;
172 struct i40e_qv_info *qv_info;
173 u32 reg_idx;
174
175 qv_info = &qvlist_info->qv_info[i];
176 if (!qv_info)
177 continue;
178 reg_idx = I40E_PFINT_LNKLSTN(qv_info->v_idx - 1);
179 wr32(&pf->hw, reg_idx, I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK);
180 }
181 kfree(ldev->qvlist_info);
182 ldev->qvlist_info = NULL;
183}
184
185
186
187
188
189
190
191
192void i40e_notify_client_of_netdev_close(struct i40e_vsi *vsi, bool reset)
193{
194 struct i40e_pf *pf = vsi->back;
195 struct i40e_client_instance *cdev = pf->cinst;
196
197 if (!cdev || !cdev->client)
198 return;
199 if (!cdev->client->ops || !cdev->client->ops->close) {
200 dev_dbg(&vsi->back->pdev->dev,
201 "Cannot locate client instance close routine\n");
202 return;
203 }
204 cdev->client->ops->close(&cdev->lan_info, cdev->client, reset);
205 clear_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state);
206 i40e_client_release_qvlist(&cdev->lan_info);
207}
208
209
210
211
212
213
214
215
216void i40e_notify_client_of_vf_reset(struct i40e_pf *pf, u32 vf_id)
217{
218 struct i40e_client_instance *cdev = pf->cinst;
219
220 if (!cdev || !cdev->client)
221 return;
222 if (!cdev->client->ops || !cdev->client->ops->vf_reset) {
223 dev_dbg(&pf->pdev->dev,
224 "Cannot locate client instance VF reset routine\n");
225 return;
226 }
227 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) {
228 dev_dbg(&pf->pdev->dev, "Client is not open, abort vf-reset\n");
229 return;
230 }
231 cdev->client->ops->vf_reset(&cdev->lan_info, cdev->client, vf_id);
232}
233
234
235
236
237
238
239
240
241void i40e_notify_client_of_vf_enable(struct i40e_pf *pf, u32 num_vfs)
242{
243 struct i40e_client_instance *cdev = pf->cinst;
244
245 if (!cdev || !cdev->client)
246 return;
247 if (!cdev->client->ops || !cdev->client->ops->vf_enable) {
248 dev_dbg(&pf->pdev->dev,
249 "Cannot locate client instance VF enable routine\n");
250 return;
251 }
252 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED,
253 &cdev->state)) {
254 dev_dbg(&pf->pdev->dev, "Client is not open, abort vf-enable\n");
255 return;
256 }
257 cdev->client->ops->vf_enable(&cdev->lan_info, cdev->client, num_vfs);
258}
259
260
261
262
263
264
265
266
267
268int i40e_vf_client_capable(struct i40e_pf *pf, u32 vf_id)
269{
270 struct i40e_client_instance *cdev = pf->cinst;
271 int capable = false;
272
273 if (!cdev || !cdev->client)
274 goto out;
275 if (!cdev->client->ops || !cdev->client->ops->vf_capable) {
276 dev_dbg(&pf->pdev->dev,
277 "Cannot locate client instance VF capability routine\n");
278 goto out;
279 }
280 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state))
281 goto out;
282
283 capable = cdev->client->ops->vf_capable(&cdev->lan_info,
284 cdev->client,
285 vf_id);
286out:
287 return capable;
288}
289
290
291
292
293
294
295
296
297static void i40e_client_add_instance(struct i40e_pf *pf)
298{
299 struct i40e_client_instance *cdev = NULL;
300 struct netdev_hw_addr *mac = NULL;
301 struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
302
303 if (!registered_client || pf->cinst)
304 return;
305
306 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
307 if (!cdev)
308 return;
309
310 cdev->lan_info.pf = (void *)pf;
311 cdev->lan_info.netdev = vsi->netdev;
312 cdev->lan_info.pcidev = pf->pdev;
313 cdev->lan_info.fid = pf->hw.pf_id;
314 cdev->lan_info.ftype = I40E_CLIENT_FTYPE_PF;
315 cdev->lan_info.hw_addr = pf->hw.hw_addr;
316 cdev->lan_info.ops = &i40e_lan_ops;
317 cdev->lan_info.version.major = I40E_CLIENT_VERSION_MAJOR;
318 cdev->lan_info.version.minor = I40E_CLIENT_VERSION_MINOR;
319 cdev->lan_info.version.build = I40E_CLIENT_VERSION_BUILD;
320 cdev->lan_info.fw_maj_ver = pf->hw.aq.fw_maj_ver;
321 cdev->lan_info.fw_min_ver = pf->hw.aq.fw_min_ver;
322 cdev->lan_info.fw_build = pf->hw.aq.fw_build;
323 set_bit(__I40E_CLIENT_INSTANCE_NONE, &cdev->state);
324
325 if (i40e_client_get_params(vsi, &cdev->lan_info.params)) {
326 kfree(cdev);
327 cdev = NULL;
328 return;
329 }
330
331 cdev->lan_info.msix_count = pf->num_iwarp_msix;
332 cdev->lan_info.msix_entries = &pf->msix_entries[pf->iwarp_base_vector];
333
334 mac = list_first_entry(&cdev->lan_info.netdev->dev_addrs.list,
335 struct netdev_hw_addr, list);
336 if (mac)
337 ether_addr_copy(cdev->lan_info.lanmac, mac->addr);
338 else
339 dev_err(&pf->pdev->dev, "MAC address list is empty!\n");
340
341 cdev->client = registered_client;
342 pf->cinst = cdev;
343}
344
345
346
347
348
349
350static
351void i40e_client_del_instance(struct i40e_pf *pf)
352{
353 kfree(pf->cinst);
354 pf->cinst = NULL;
355}
356
357
358
359
360
361void i40e_client_subtask(struct i40e_pf *pf)
362{
363 struct i40e_client *client = registered_client;
364 struct i40e_client_instance *cdev;
365 struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
366 int ret = 0;
367
368 if (!(pf->flags & I40E_FLAG_SERVICE_CLIENT_REQUESTED))
369 return;
370 pf->flags &= ~I40E_FLAG_SERVICE_CLIENT_REQUESTED;
371 cdev = pf->cinst;
372
373
374 if (test_bit(__I40E_DOWN, pf->state) ||
375 test_bit(__I40E_CONFIG_BUSY, pf->state))
376 return;
377
378 if (!client || !cdev)
379 return;
380
381
382
383
384 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) {
385 if (!test_bit(__I40E_VSI_DOWN, vsi->state) &&
386 client->ops && client->ops->open) {
387 set_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state);
388 ret = client->ops->open(&cdev->lan_info, client);
389 if (ret) {
390
391 clear_bit(__I40E_CLIENT_INSTANCE_OPENED,
392 &cdev->state);
393 i40e_client_del_instance(pf);
394 }
395 }
396 } else {
397
398
399
400 if (test_bit(__I40E_VSI_DOWN, vsi->state) &&
401 client->ops && client->ops->close) {
402 clear_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state);
403 client->ops->close(&cdev->lan_info, client, false);
404 i40e_client_release_qvlist(&cdev->lan_info);
405 }
406 }
407}
408
409
410
411
412
413
414
415int i40e_lan_add_device(struct i40e_pf *pf)
416{
417 struct i40e_device *ldev;
418 int ret = 0;
419
420 mutex_lock(&i40e_device_mutex);
421 list_for_each_entry(ldev, &i40e_devices, list) {
422 if (ldev->pf == pf) {
423 ret = -EEXIST;
424 goto out;
425 }
426 }
427 ldev = kzalloc(sizeof(*ldev), GFP_KERNEL);
428 if (!ldev) {
429 ret = -ENOMEM;
430 goto out;
431 }
432 ldev->pf = pf;
433 INIT_LIST_HEAD(&ldev->list);
434 list_add(&ldev->list, &i40e_devices);
435 dev_info(&pf->pdev->dev, "Added LAN device PF%d bus=0x%02x dev=0x%02x func=0x%02x\n",
436 pf->hw.pf_id, pf->hw.bus.bus_id,
437 pf->hw.bus.device, pf->hw.bus.func);
438
439
440
441
442 if (registered_client)
443 i40e_client_add_instance(pf);
444
445
446
447
448
449 pf->flags |= I40E_FLAG_SERVICE_CLIENT_REQUESTED;
450 i40e_service_event_schedule(pf);
451
452out:
453 mutex_unlock(&i40e_device_mutex);
454 return ret;
455}
456
457
458
459
460
461
462
463int i40e_lan_del_device(struct i40e_pf *pf)
464{
465 struct i40e_device *ldev, *tmp;
466 int ret = -ENODEV;
467
468
469 i40e_client_del_instance(pf);
470
471 mutex_lock(&i40e_device_mutex);
472 list_for_each_entry_safe(ldev, tmp, &i40e_devices, list) {
473 if (ldev->pf == pf) {
474 dev_info(&pf->pdev->dev, "Deleted LAN device PF%d bus=0x%02x dev=0x%02x func=0x%02x\n",
475 pf->hw.pf_id, pf->hw.bus.bus_id,
476 pf->hw.bus.device, pf->hw.bus.func);
477 list_del(&ldev->list);
478 kfree(ldev);
479 ret = 0;
480 break;
481 }
482 }
483 mutex_unlock(&i40e_device_mutex);
484 return ret;
485}
486
487
488
489
490
491
492static void i40e_client_release(struct i40e_client *client)
493{
494 struct i40e_client_instance *cdev;
495 struct i40e_device *ldev;
496 struct i40e_pf *pf;
497
498 mutex_lock(&i40e_device_mutex);
499 list_for_each_entry(ldev, &i40e_devices, list) {
500 pf = ldev->pf;
501 cdev = pf->cinst;
502 if (!cdev)
503 continue;
504
505 while (test_and_set_bit(__I40E_SERVICE_SCHED,
506 pf->state))
507 usleep_range(500, 1000);
508
509 if (test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) {
510 if (client->ops && client->ops->close)
511 client->ops->close(&cdev->lan_info, client,
512 false);
513 i40e_client_release_qvlist(&cdev->lan_info);
514 clear_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state);
515
516 dev_warn(&pf->pdev->dev,
517 "Client %s instance for PF id %d closed\n",
518 client->name, pf->hw.pf_id);
519 }
520
521 i40e_client_del_instance(pf);
522 dev_info(&pf->pdev->dev, "Deleted client instance of Client %s\n",
523 client->name);
524 clear_bit(__I40E_SERVICE_SCHED, pf->state);
525 }
526 mutex_unlock(&i40e_device_mutex);
527}
528
529
530
531
532
533
534static void i40e_client_prepare(struct i40e_client *client)
535{
536 struct i40e_device *ldev;
537 struct i40e_pf *pf;
538
539 mutex_lock(&i40e_device_mutex);
540 list_for_each_entry(ldev, &i40e_devices, list) {
541 pf = ldev->pf;
542 i40e_client_add_instance(pf);
543
544 pf->flags |= I40E_FLAG_SERVICE_CLIENT_REQUESTED;
545 i40e_service_event_schedule(pf);
546 }
547 mutex_unlock(&i40e_device_mutex);
548}
549
550
551
552
553
554
555
556
557
558
559
560static int i40e_client_virtchnl_send(struct i40e_info *ldev,
561 struct i40e_client *client,
562 u32 vf_id, u8 *msg, u16 len)
563{
564 struct i40e_pf *pf = ldev->pf;
565 struct i40e_hw *hw = &pf->hw;
566 i40e_status err;
567
568 err = i40e_aq_send_msg_to_vf(hw, vf_id, VIRTCHNL_OP_IWARP,
569 0, msg, len, NULL);
570 if (err)
571 dev_err(&pf->pdev->dev, "Unable to send iWarp message to VF, error %d, aq status %d\n",
572 err, hw->aq.asq_last_status);
573
574 return err;
575}
576
577
578
579
580
581
582
583
584
585static int i40e_client_setup_qvlist(struct i40e_info *ldev,
586 struct i40e_client *client,
587 struct i40e_qvlist_info *qvlist_info)
588{
589 struct i40e_pf *pf = ldev->pf;
590 struct i40e_hw *hw = &pf->hw;
591 struct i40e_qv_info *qv_info;
592 u32 v_idx, i, reg_idx, reg;
593 u32 size;
594
595 size = sizeof(struct i40e_qvlist_info) +
596 (sizeof(struct i40e_qv_info) * (qvlist_info->num_vectors - 1));
597 ldev->qvlist_info = kzalloc(size, GFP_KERNEL);
598 if (!ldev->qvlist_info)
599 return -ENOMEM;
600 ldev->qvlist_info->num_vectors = qvlist_info->num_vectors;
601
602 for (i = 0; i < qvlist_info->num_vectors; i++) {
603 qv_info = &qvlist_info->qv_info[i];
604 if (!qv_info)
605 continue;
606 v_idx = qv_info->v_idx;
607
608
609 if ((v_idx >= (pf->iwarp_base_vector + pf->num_iwarp_msix)) ||
610 (v_idx < pf->iwarp_base_vector))
611 goto err;
612
613 ldev->qvlist_info->qv_info[i] = *qv_info;
614 reg_idx = I40E_PFINT_LNKLSTN(v_idx - 1);
615
616 if (qv_info->ceq_idx == I40E_QUEUE_INVALID_IDX) {
617
618 wr32(hw, reg_idx, I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK);
619 } else {
620 reg = (qv_info->ceq_idx &
621 I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK) |
622 (I40E_QUEUE_TYPE_PE_CEQ <<
623 I40E_PFINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
624 wr32(hw, reg_idx, reg);
625
626 reg = (I40E_PFINT_CEQCTL_CAUSE_ENA_MASK |
627 (v_idx << I40E_PFINT_CEQCTL_MSIX_INDX_SHIFT) |
628 (qv_info->itr_idx <<
629 I40E_PFINT_CEQCTL_ITR_INDX_SHIFT) |
630 (I40E_QUEUE_END_OF_LIST <<
631 I40E_PFINT_CEQCTL_NEXTQ_INDX_SHIFT));
632 wr32(hw, I40E_PFINT_CEQCTL(qv_info->ceq_idx), reg);
633 }
634 if (qv_info->aeq_idx != I40E_QUEUE_INVALID_IDX) {
635 reg = (I40E_PFINT_AEQCTL_CAUSE_ENA_MASK |
636 (v_idx << I40E_PFINT_AEQCTL_MSIX_INDX_SHIFT) |
637 (qv_info->itr_idx <<
638 I40E_PFINT_AEQCTL_ITR_INDX_SHIFT));
639
640 wr32(hw, I40E_PFINT_AEQCTL, reg);
641 }
642 }
643
644 i40e_flush(hw);
645 return 0;
646err:
647 kfree(ldev->qvlist_info);
648 ldev->qvlist_info = NULL;
649 return -EINVAL;
650}
651
652
653
654
655
656
657
658static void i40e_client_request_reset(struct i40e_info *ldev,
659 struct i40e_client *client,
660 u32 reset_level)
661{
662 struct i40e_pf *pf = ldev->pf;
663
664 switch (reset_level) {
665 case I40E_CLIENT_RESET_LEVEL_PF:
666 set_bit(__I40E_PF_RESET_REQUESTED, pf->state);
667 break;
668 case I40E_CLIENT_RESET_LEVEL_CORE:
669 set_bit(__I40E_PF_RESET_REQUESTED, pf->state);
670 break;
671 default:
672 dev_warn(&pf->pdev->dev,
673 "Client for PF id %d requested an unsupported reset: %d.\n",
674 pf->hw.pf_id, reset_level);
675 break;
676 }
677
678 i40e_service_event_schedule(pf);
679}
680
681
682
683
684
685
686
687
688
689
690
691
692static int i40e_client_update_vsi_ctxt(struct i40e_info *ldev,
693 struct i40e_client *client,
694 bool is_vf, u32 vf_id,
695 u32 flag, u32 valid_flag)
696{
697 struct i40e_pf *pf = ldev->pf;
698 struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
699 struct i40e_vsi_context ctxt;
700 bool update = true;
701 i40e_status err;
702
703
704 if (is_vf)
705 return -EINVAL;
706
707 ctxt.seid = pf->main_vsi_seid;
708 ctxt.pf_num = pf->hw.pf_id;
709 err = i40e_aq_get_vsi_params(&pf->hw, &ctxt, NULL);
710 ctxt.flags = I40E_AQ_VSI_TYPE_PF;
711 if (err) {
712 dev_info(&pf->pdev->dev,
713 "couldn't get PF vsi config, err %s aq_err %s\n",
714 i40e_stat_str(&pf->hw, err),
715 i40e_aq_str(&pf->hw,
716 pf->hw.aq.asq_last_status));
717 return -ENOENT;
718 }
719
720 if ((valid_flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE) &&
721 (flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE)) {
722 ctxt.info.valid_sections =
723 cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID);
724 ctxt.info.queueing_opt_flags |= I40E_AQ_VSI_QUE_OPT_TCP_ENA;
725 } else if ((valid_flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE) &&
726 !(flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE)) {
727 ctxt.info.valid_sections =
728 cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID);
729 ctxt.info.queueing_opt_flags &= ~I40E_AQ_VSI_QUE_OPT_TCP_ENA;
730 } else {
731 update = false;
732 dev_warn(&pf->pdev->dev,
733 "Client for PF id %d request an unsupported Config: %x.\n",
734 pf->hw.pf_id, flag);
735 }
736
737 if (update) {
738 err = i40e_aq_update_vsi_params(&vsi->back->hw, &ctxt, NULL);
739 if (err) {
740 dev_info(&pf->pdev->dev,
741 "update VSI ctxt for PE failed, err %s aq_err %s\n",
742 i40e_stat_str(&pf->hw, err),
743 i40e_aq_str(&pf->hw,
744 pf->hw.aq.asq_last_status));
745 }
746 }
747 return err;
748}
749
750
751
752
753
754
755
756int i40e_register_client(struct i40e_client *client)
757{
758 int ret = 0;
759
760 if (!client) {
761 ret = -EIO;
762 goto out;
763 }
764
765 if (strlen(client->name) == 0) {
766 pr_info("i40e: Failed to register client with no name\n");
767 ret = -EIO;
768 goto out;
769 }
770
771 if (registered_client) {
772 pr_info("i40e: Client %s has already been registered!\n",
773 client->name);
774 ret = -EEXIST;
775 goto out;
776 }
777
778 if ((client->version.major != I40E_CLIENT_VERSION_MAJOR) ||
779 (client->version.minor != I40E_CLIENT_VERSION_MINOR)) {
780 pr_info("i40e: Failed to register client %s due to mismatched client interface version\n",
781 client->name);
782 pr_info("Client is using version: %02d.%02d.%02d while LAN driver supports %s\n",
783 client->version.major, client->version.minor,
784 client->version.build,
785 i40e_client_interface_version_str);
786 ret = -EIO;
787 goto out;
788 }
789
790 registered_client = client;
791
792 i40e_client_prepare(client);
793
794 pr_info("i40e: Registered client %s\n", client->name);
795out:
796 return ret;
797}
798EXPORT_SYMBOL(i40e_register_client);
799
800
801
802
803
804
805
806int i40e_unregister_client(struct i40e_client *client)
807{
808 int ret = 0;
809
810 if (registered_client != client) {
811 pr_info("i40e: Client %s has not been registered\n",
812 client->name);
813 ret = -ENODEV;
814 goto out;
815 }
816 registered_client = NULL;
817
818
819
820
821 i40e_client_release(client);
822
823 pr_info("i40e: Unregistered client %s\n", client->name);
824out:
825 return ret;
826}
827EXPORT_SYMBOL(i40e_unregister_client);
828