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_info(&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, I40E_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 ldev->qvlist_info->num_vectors = qvlist_info->num_vectors;
599
600 for (i = 0; i < qvlist_info->num_vectors; i++) {
601 qv_info = &qvlist_info->qv_info[i];
602 if (!qv_info)
603 continue;
604 v_idx = qv_info->v_idx;
605
606
607 if ((v_idx >= (pf->iwarp_base_vector + pf->num_iwarp_msix)) ||
608 (v_idx < pf->iwarp_base_vector))
609 goto err;
610
611 ldev->qvlist_info->qv_info[i] = *qv_info;
612 reg_idx = I40E_PFINT_LNKLSTN(v_idx - 1);
613
614 if (qv_info->ceq_idx == I40E_QUEUE_INVALID_IDX) {
615
616 wr32(hw, reg_idx, I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK);
617 } else {
618 reg = (qv_info->ceq_idx &
619 I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK) |
620 (I40E_QUEUE_TYPE_PE_CEQ <<
621 I40E_PFINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
622 wr32(hw, reg_idx, reg);
623
624 reg = (I40E_PFINT_CEQCTL_CAUSE_ENA_MASK |
625 (v_idx << I40E_PFINT_CEQCTL_MSIX_INDX_SHIFT) |
626 (qv_info->itr_idx <<
627 I40E_PFINT_CEQCTL_ITR_INDX_SHIFT) |
628 (I40E_QUEUE_END_OF_LIST <<
629 I40E_PFINT_CEQCTL_NEXTQ_INDX_SHIFT));
630 wr32(hw, I40E_PFINT_CEQCTL(qv_info->ceq_idx), reg);
631 }
632 if (qv_info->aeq_idx != I40E_QUEUE_INVALID_IDX) {
633 reg = (I40E_PFINT_AEQCTL_CAUSE_ENA_MASK |
634 (v_idx << I40E_PFINT_AEQCTL_MSIX_INDX_SHIFT) |
635 (qv_info->itr_idx <<
636 I40E_PFINT_AEQCTL_ITR_INDX_SHIFT));
637
638 wr32(hw, I40E_PFINT_AEQCTL, reg);
639 }
640 }
641
642 i40e_flush(hw);
643 return 0;
644err:
645 kfree(ldev->qvlist_info);
646 ldev->qvlist_info = NULL;
647 return -EINVAL;
648}
649
650
651
652
653
654
655
656static void i40e_client_request_reset(struct i40e_info *ldev,
657 struct i40e_client *client,
658 u32 reset_level)
659{
660 struct i40e_pf *pf = ldev->pf;
661
662 switch (reset_level) {
663 case I40E_CLIENT_RESET_LEVEL_PF:
664 set_bit(__I40E_PF_RESET_REQUESTED, pf->state);
665 break;
666 case I40E_CLIENT_RESET_LEVEL_CORE:
667 set_bit(__I40E_PF_RESET_REQUESTED, pf->state);
668 break;
669 default:
670 dev_warn(&pf->pdev->dev,
671 "Client for PF id %d requested an unsupported reset: %d.\n",
672 pf->hw.pf_id, reset_level);
673 break;
674 }
675
676 i40e_service_event_schedule(pf);
677}
678
679
680
681
682
683
684
685
686
687
688
689
690static int i40e_client_update_vsi_ctxt(struct i40e_info *ldev,
691 struct i40e_client *client,
692 bool is_vf, u32 vf_id,
693 u32 flag, u32 valid_flag)
694{
695 struct i40e_pf *pf = ldev->pf;
696 struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
697 struct i40e_vsi_context ctxt;
698 bool update = true;
699 i40e_status err;
700
701
702 if (is_vf)
703 return -EINVAL;
704
705 ctxt.seid = pf->main_vsi_seid;
706 ctxt.pf_num = pf->hw.pf_id;
707 err = i40e_aq_get_vsi_params(&pf->hw, &ctxt, NULL);
708 ctxt.flags = I40E_AQ_VSI_TYPE_PF;
709 if (err) {
710 dev_info(&pf->pdev->dev,
711 "couldn't get PF vsi config, err %s aq_err %s\n",
712 i40e_stat_str(&pf->hw, err),
713 i40e_aq_str(&pf->hw,
714 pf->hw.aq.asq_last_status));
715 return -ENOENT;
716 }
717
718 if ((valid_flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE) &&
719 (flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE)) {
720 ctxt.info.valid_sections =
721 cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID);
722 ctxt.info.queueing_opt_flags |= I40E_AQ_VSI_QUE_OPT_TCP_ENA;
723 } else if ((valid_flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE) &&
724 !(flag & I40E_CLIENT_VSI_FLAG_TCP_PACKET_ENABLE)) {
725 ctxt.info.valid_sections =
726 cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID);
727 ctxt.info.queueing_opt_flags &= ~I40E_AQ_VSI_QUE_OPT_TCP_ENA;
728 } else {
729 update = false;
730 dev_warn(&pf->pdev->dev,
731 "Client for PF id %d request an unsupported Config: %x.\n",
732 pf->hw.pf_id, flag);
733 }
734
735 if (update) {
736 err = i40e_aq_update_vsi_params(&vsi->back->hw, &ctxt, NULL);
737 if (err) {
738 dev_info(&pf->pdev->dev,
739 "update VSI ctxt for PE failed, err %s aq_err %s\n",
740 i40e_stat_str(&pf->hw, err),
741 i40e_aq_str(&pf->hw,
742 pf->hw.aq.asq_last_status));
743 }
744 }
745 return err;
746}
747
748
749
750
751
752
753
754int i40e_register_client(struct i40e_client *client)
755{
756 int ret = 0;
757
758 if (!client) {
759 ret = -EIO;
760 goto out;
761 }
762
763 if (strlen(client->name) == 0) {
764 pr_info("i40e: Failed to register client with no name\n");
765 ret = -EIO;
766 goto out;
767 }
768
769 if (registered_client) {
770 pr_info("i40e: Client %s has already been registered!\n",
771 client->name);
772 ret = -EEXIST;
773 goto out;
774 }
775
776 if ((client->version.major != I40E_CLIENT_VERSION_MAJOR) ||
777 (client->version.minor != I40E_CLIENT_VERSION_MINOR)) {
778 pr_info("i40e: Failed to register client %s due to mismatched client interface version\n",
779 client->name);
780 pr_info("Client is using version: %02d.%02d.%02d while LAN driver supports %s\n",
781 client->version.major, client->version.minor,
782 client->version.build,
783 i40e_client_interface_version_str);
784 ret = -EIO;
785 goto out;
786 }
787
788 registered_client = client;
789
790 i40e_client_prepare(client);
791
792 pr_info("i40e: Registered client %s\n", client->name);
793out:
794 return ret;
795}
796EXPORT_SYMBOL(i40e_register_client);
797
798
799
800
801
802
803
804int i40e_unregister_client(struct i40e_client *client)
805{
806 int ret = 0;
807
808 if (registered_client != client) {
809 pr_info("i40e: Client %s has not been registered\n",
810 client->name);
811 ret = -ENODEV;
812 goto out;
813 }
814 registered_client = NULL;
815
816
817
818
819 i40e_client_release(client);
820
821 pr_info("i40e: Unregistered client %s\n", client->name);
822out:
823 return ret;
824}
825EXPORT_SYMBOL(i40e_unregister_client);
826