1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Driver for Alibaba Elastic Ethernet Adapter.
4 *
5 * Copyright (C) 2025 Alibaba Inc.
6 */
7
8 #include <linux/etherdevice.h>
9 #include <linux/module.h>
10 #include <linux/netdevice.h>
11 #include <linux/rtnetlink.h>
12 #include <net/netdev_queues.h>
13
14 #include "eea_adminq.h"
15 #include "eea_net.h"
16 #include "eea_pci.h"
17 #include "eea_ring.h"
18
19 #define EEA_SPLIT_HDR_SIZE ALIGN(128, L1_CACHE_BYTES)
20
eea_irq_handler(int irq,void * data)21 static irqreturn_t eea_irq_handler(int irq, void *data)
22 {
23 struct eea_irq_blk *blk = data;
24
25 napi_schedule_irqoff(&blk->napi);
26
27 return IRQ_HANDLED;
28 }
29
eea_free_irq_blk(struct eea_net * enet)30 static void eea_free_irq_blk(struct eea_net *enet)
31 {
32 struct eea_irq_blk *blk;
33 u32 num;
34 int i;
35
36 if (!enet->irq_blks)
37 return;
38
39 num = enet->edev->rx_num;
40
41 for (i = 0; i < num; i++) {
42 blk = &enet->irq_blks[i];
43
44 if (blk->ready)
45 eea_pci_free_irq(blk);
46
47 blk->ready = false;
48 }
49
50 kvfree(enet->irq_blks);
51 enet->irq_blks = NULL;
52 }
53
54 /* The driver will always attempt to allocate IRQ blocks based on the maximum
55 * possible queue num.
56 */
eea_alloc_irq_blks(struct eea_net * enet)57 static int eea_alloc_irq_blks(struct eea_net *enet)
58 {
59 struct eea_device *edev = enet->edev;
60 struct eea_irq_blk *blk, *irq_blks;
61 int i, err, num;
62
63 num = enet->edev->rx_num;
64
65 irq_blks = kvzalloc_objs(*blk, num);
66 if (!irq_blks)
67 return -ENOMEM;
68
69 enet->irq_blks = irq_blks;
70
71 for (i = 0; i < num; i++) {
72 blk = &irq_blks[i];
73 blk->idx = i;
74
75 /* vec 0 is for error notify. */
76 blk->msix_vec = i + 1;
77
78 err = eea_pci_request_irq(edev, blk, eea_irq_handler);
79 if (err)
80 goto err_free_irq_blk;
81
82 blk->ready = true;
83 }
84
85 return 0;
86
87 err_free_irq_blk:
88 eea_free_irq_blk(enet);
89 return err;
90 }
91
eea_update_queues(struct eea_net * enet)92 static int eea_update_queues(struct eea_net *enet)
93 {
94 return netif_set_real_num_queues(enet->netdev, enet->cfg.tx_ring_num,
95 enet->cfg.rx_ring_num);
96 }
97
eea_init_ctx(struct eea_net * enet,struct eea_net_init_ctx * ctx)98 void eea_init_ctx(struct eea_net *enet, struct eea_net_init_ctx *ctx)
99 {
100 memset(ctx, 0, sizeof(*ctx));
101
102 ctx->netdev = enet->netdev;
103 ctx->edev = enet->edev;
104 ctx->cfg = enet->cfg;
105 }
106
eea_bind_q_and_cfg(struct eea_net * enet,struct eea_net_init_ctx * ctx)107 static void eea_bind_q_and_cfg(struct eea_net *enet,
108 struct eea_net_init_ctx *ctx)
109 {
110 struct eea_irq_blk *blk;
111 struct eea_net_rx *rx;
112 struct eea_net_tx *tx;
113 int i;
114
115 /* Since 'ndo_get_stats64' is not called in softirq context, there is no
116 * need to use 'spin_lock_bh'.
117 */
118 spin_lock(&enet->stats_lock);
119
120 enet->cfg = ctx->cfg;
121 enet->rx = ctx->rx;
122 enet->tx = ctx->tx;
123
124 for (i = 0; i < ctx->cfg.rx_ring_num; i++) {
125 blk = &enet->irq_blks[i];
126
127 rx = ctx->rx[i];
128 tx = &ctx->tx[i];
129
130 rx->enet = enet;
131 rx->napi = &blk->napi;
132 rx->ering->msix_vec = blk->msix_vec;
133
134 tx->enet = enet;
135 tx->ering->msix_vec = blk->msix_vec;
136
137 blk->rx = rx;
138 }
139
140 spin_unlock(&enet->stats_lock);
141 }
142
eea_unbind_q_and_cfg(struct eea_net * enet,struct eea_net_init_ctx * ctx)143 static void eea_unbind_q_and_cfg(struct eea_net *enet,
144 struct eea_net_init_ctx *ctx)
145 {
146 struct eea_irq_blk *blk;
147 struct eea_net_rx *rx;
148 int i;
149
150 spin_lock(&enet->stats_lock);
151
152 ctx->cfg = enet->cfg;
153 ctx->rx = enet->rx;
154 ctx->tx = enet->tx;
155
156 enet->rx = NULL;
157 enet->tx = NULL;
158
159 for (i = 0; i < ctx->cfg.rx_ring_num; i++) {
160 blk = &enet->irq_blks[i];
161
162 rx = ctx->rx[i];
163
164 rx->napi = NULL;
165
166 blk->rx = NULL;
167 }
168
169 spin_unlock(&enet->stats_lock);
170 }
171
eea_free_rxtx_q_mem(struct eea_net_init_ctx * ctx)172 static void eea_free_rxtx_q_mem(struct eea_net_init_ctx *ctx)
173 {
174 struct eea_net_rx *rx;
175 struct eea_net_tx *tx;
176 int i;
177
178 for (i = 0; i < ctx->cfg.rx_ring_num; i++) {
179 rx = ctx->rx[i];
180 tx = &ctx->tx[i];
181
182 eea_free_rx(rx, &ctx->cfg);
183 eea_free_tx(tx, &ctx->cfg);
184 }
185
186 kvfree(ctx->rx);
187 kvfree(ctx->tx);
188 }
189
190 /* alloc tx/rx: struct, ring, meta, pp, napi */
eea_alloc_rxtx_q_mem(struct eea_net_init_ctx * ctx)191 static int eea_alloc_rxtx_q_mem(struct eea_net_init_ctx *ctx)
192 {
193 struct eea_net_rx *rx;
194 struct eea_net_tx *tx;
195 int err, i;
196
197 ctx->tx = kvzalloc_objs(*ctx->tx, ctx->cfg.tx_ring_num);
198 if (!ctx->tx)
199 return -ENOMEM;
200
201 ctx->rx = kvzalloc_objs(*ctx->rx, ctx->cfg.rx_ring_num);
202 if (!ctx->rx)
203 goto err_free_tx;
204
205 ctx->cfg.rx_sq_desc_size = sizeof(struct eea_rx_desc);
206 ctx->cfg.rx_cq_desc_size = sizeof(struct eea_rx_cdesc);
207 ctx->cfg.tx_sq_desc_size = sizeof(struct eea_tx_desc);
208 ctx->cfg.tx_cq_desc_size = sizeof(struct eea_tx_cdesc);
209
210 /* ethtool may config this. */
211 if (!ctx->cfg.split_hdr)
212 ctx->cfg.rx_sq_desc_size = sizeof(struct eea_rx_desc_no_hdr);
213
214 for (i = 0; i < ctx->cfg.rx_ring_num; i++) {
215 rx = eea_alloc_rx(ctx, i);
216 if (!rx)
217 goto err_free;
218
219 ctx->rx[i] = rx;
220
221 tx = ctx->tx + i;
222 err = eea_alloc_tx(ctx, tx, i);
223 if (err)
224 goto err_free;
225 }
226
227 return 0;
228
229 err_free:
230 for (i = 0; i < ctx->cfg.rx_ring_num; i++) {
231 rx = ctx->rx[i];
232 tx = ctx->tx + i;
233
234 eea_free_rx(rx, &ctx->cfg);
235 eea_free_tx(tx, &ctx->cfg);
236 }
237
238 kvfree(ctx->rx);
239
240 err_free_tx:
241 kvfree(ctx->tx);
242 return -ENOMEM;
243 }
244
eea_hw_active_ring(struct eea_net * enet)245 static int eea_hw_active_ring(struct eea_net *enet)
246 {
247 return eea_adminq_create_q(enet, enet->cfg.rx_ring_num
248 + enet->cfg.tx_ring_num, 0);
249 }
250
eea_hw_unactive_ring(struct eea_net * enet)251 static int eea_hw_unactive_ring(struct eea_net *enet)
252 {
253 int err;
254
255 err = eea_adminq_destroy_all_q(enet);
256 if (err)
257 netdev_warn(enet->netdev, "unactive rxtx ring failed.\n");
258
259 return err;
260 }
261
262 /* stop rx napi, stop tx queue. */
eea_stop_rxtx(struct net_device * netdev)263 static void eea_stop_rxtx(struct net_device *netdev)
264 {
265 struct eea_net *enet = netdev_priv(netdev);
266 int i;
267
268 netif_tx_disable(netdev);
269
270 for (i = 0; i < enet->cfg.rx_ring_num; i++)
271 enet_rx_stop(enet->rx[i]);
272
273 netif_carrier_off(netdev);
274 }
275
eea_start_rxtx(struct eea_net * enet)276 static void eea_start_rxtx(struct eea_net *enet)
277 {
278 int i;
279
280 for (i = 0; i < enet->cfg.rx_ring_num; i++)
281 enet_rx_start(enet->rx[i]);
282
283 netif_tx_start_all_queues(enet->netdev);
284 netif_carrier_on(enet->netdev);
285
286 enet->started = true;
287 }
288
eea_netdev_stop(struct net_device * netdev)289 static int eea_netdev_stop(struct net_device *netdev)
290 {
291 struct eea_net *enet = netdev_priv(netdev);
292 struct eea_net_init_ctx ctx;
293
294 /* This function can be called during device anomaly recovery. To
295 * prevent duplicate stop operations, the `started` flag is introduced
296 * for checking.
297 */
298
299 if (!enet->started) {
300 netdev_warn(netdev, "eea netdev stop: but dev is not started.\n");
301 return 0;
302 }
303
304 eea_init_ctx(enet, &ctx);
305
306 eea_stop_rxtx(netdev);
307 eea_hw_unactive_ring(enet);
308 eea_unbind_q_and_cfg(enet, &ctx);
309 eea_free_rxtx_q_mem(&ctx);
310
311 enet->started = false;
312
313 return 0;
314 }
315
eea_netdev_open(struct net_device * netdev)316 static int eea_netdev_open(struct net_device *netdev)
317 {
318 struct eea_net *enet = netdev_priv(netdev);
319 struct eea_net_init_ctx ctx;
320 int err;
321
322 if (enet->link_err) {
323 netdev_err(netdev, "netdev open err, because link error: %d\n",
324 enet->link_err);
325 return -EBUSY;
326 }
327
328 eea_init_ctx(enet, &ctx);
329
330 err = eea_alloc_rxtx_q_mem(&ctx);
331 if (err)
332 goto err_done;
333
334 eea_bind_q_and_cfg(enet, &ctx);
335
336 err = eea_update_queues(enet);
337 if (err)
338 goto err_free_q;
339
340 err = eea_hw_active_ring(enet);
341 if (err)
342 goto err_free_q;
343
344 eea_start_rxtx(enet);
345
346 return 0;
347
348 err_free_q:
349 eea_unbind_q_and_cfg(enet, &ctx);
350 eea_free_rxtx_q_mem(&ctx);
351
352 err_done:
353 return err;
354 }
355
356 /* Statistics may be reset to zero upon device reset. This is expected behavior
357 * for now and will be addressed in the future.
358 */
eea_stats(struct net_device * netdev,struct rtnl_link_stats64 * tot)359 static void eea_stats(struct net_device *netdev, struct rtnl_link_stats64 *tot)
360 {
361 struct eea_net *enet = netdev_priv(netdev);
362 u64 packets, bytes, drop, lerr;
363 u32 start;
364 int i;
365
366 spin_lock(&enet->stats_lock);
367
368 if (enet->rx) {
369 for (i = 0; i < enet->cfg.rx_ring_num; i++) {
370 struct eea_net_rx *rx = enet->rx[i];
371
372 do {
373 start = u64_stats_fetch_begin(&rx->stats.syncp);
374 packets = u64_stats_read(&rx->stats.packets);
375 bytes = u64_stats_read(&rx->stats.bytes);
376 drop = u64_stats_read(&rx->stats.drops);
377 lerr = u64_stats_read(&rx->stats.length_errors);
378 } while (u64_stats_fetch_retry(&rx->stats.syncp,
379 start));
380
381 tot->rx_packets += packets;
382 tot->rx_bytes += bytes;
383 tot->rx_dropped += drop;
384 tot->rx_length_errors += lerr;
385 tot->rx_errors += lerr;
386 }
387 }
388
389 if (enet->tx) {
390 for (i = 0; i < enet->cfg.tx_ring_num; i++) {
391 struct eea_net_tx *tx = &enet->tx[i];
392
393 do {
394 start = u64_stats_fetch_begin(&tx->stats.syncp);
395 packets = u64_stats_read(&tx->stats.packets);
396 bytes = u64_stats_read(&tx->stats.bytes);
397 drop = u64_stats_read(&tx->stats.drops);
398 } while (u64_stats_fetch_retry(&tx->stats.syncp,
399 start));
400
401 tot->tx_packets += packets;
402 tot->tx_bytes += bytes;
403 tot->tx_dropped += drop;
404 }
405 }
406
407 spin_unlock(&enet->stats_lock);
408 }
409
410 /* resources: ring, buffers, irq */
eea_reset_hw_resources(struct eea_net * enet,struct eea_net_init_ctx * ctx)411 int eea_reset_hw_resources(struct eea_net *enet, struct eea_net_init_ctx *ctx)
412 {
413 struct eea_net_init_ctx ctx_old = {0};
414 int err, error;
415
416 if (!netif_running(enet->netdev) || !enet->started) {
417 spin_lock(&enet->stats_lock);
418 enet->cfg = ctx->cfg;
419 spin_unlock(&enet->stats_lock);
420 return 0;
421 }
422
423 err = eea_alloc_rxtx_q_mem(ctx);
424 if (err) {
425 netdev_warn(enet->netdev,
426 "eea reset: alloc q failed. stop reset. err %d\n",
427 err);
428 return err;
429 }
430
431 eea_stop_rxtx(enet->netdev);
432 eea_hw_unactive_ring(enet);
433
434 eea_unbind_q_and_cfg(enet, &ctx_old);
435 eea_bind_q_and_cfg(enet, ctx);
436
437 err = eea_update_queues(enet);
438 if (err) {
439 netdev_err(enet->netdev,
440 "eea reset: set real num queues failed. err %d\n",
441 err);
442 goto err_bind_old;
443 }
444
445 err = eea_hw_active_ring(enet);
446 if (err) {
447 netdev_err(enet->netdev, "eea reset: active new ring. err %d\n",
448 err);
449 eea_unbind_q_and_cfg(enet, ctx);
450 goto err_free_q;
451 }
452
453 eea_start_rxtx(enet);
454 eea_free_rxtx_q_mem(&ctx_old);
455 return 0;
456
457 err_bind_old:
458 eea_unbind_q_and_cfg(enet, ctx);
459 eea_bind_q_and_cfg(enet, &ctx_old);
460 error = eea_hw_active_ring(enet);
461 if (error) {
462 netdev_err(enet->netdev, "eea reset: active old ring. err %d\n",
463 error);
464 eea_unbind_q_and_cfg(enet, &ctx_old);
465 err = error;
466 goto err_free_q;
467 }
468
469 eea_start_rxtx(enet);
470 eea_free_rxtx_q_mem(ctx);
471 return err;
472
473 err_free_q:
474
475 /* An exception occurred at the hardware level, and there's not much we
476 * can do about it -- we can only release the resources first.
477 */
478 eea_free_rxtx_q_mem(ctx);
479 eea_free_rxtx_q_mem(&ctx_old);
480 enet->started = false;
481 return err;
482 }
483
eea_queues_check_and_reset(struct eea_device * edev)484 int eea_queues_check_and_reset(struct eea_device *edev)
485 {
486 struct eea_aq_dev_status dstatus = {0};
487 struct eea_aq_queue_status *qstatus;
488 struct eea_aq_queue_status *qs;
489 struct eea_net_init_ctx ctx;
490 bool need_reset = false;
491 int i, err = 0;
492
493 rtnl_lock();
494
495 if (!netif_running(edev->enet->netdev))
496 goto err_unlock;
497
498 /* Maybe stopped by ha. */
499 if (!edev->enet->started || edev->enet->link_err)
500 goto err_unlock;
501
502 err = eea_adminq_dev_status(edev->enet, &dstatus);
503 if (err) {
504 netdev_warn(edev->enet->netdev, "query queue status failed.\n");
505 goto err_unlock;
506 }
507
508 if (le16_to_cpu(dstatus.status->link_status) == EEA_LINK_DOWN_STATUS) {
509 /* The device is broken, can not be up. */
510 eea_netdev_stop(edev->enet->netdev);
511 edev->enet->link_err = EEA_LINK_ERR_LINK_DOWN;
512 netdev_warn(edev->enet->netdev, "device link is down. stop device.\n");
513 goto err_free;
514 }
515
516 qstatus = dstatus.status->q_status;
517
518 for (i = 0; i < dstatus.num; ++i) {
519 qs = &qstatus[i];
520
521 if (le16_to_cpu(qs->status) == EEA_QUEUE_STATUS_NEED_RESET) {
522 netdev_warn(edev->enet->netdev,
523 "queue status: queue %u needs to reset\n",
524 le16_to_cpu(qs->qidx));
525 need_reset = true;
526 }
527 }
528
529 if (need_reset) {
530 eea_init_ctx(edev->enet, &ctx);
531 err = eea_reset_hw_resources(edev->enet, &ctx);
532 }
533
534 err_free:
535 kfree(dstatus.status);
536
537 err_unlock:
538 rtnl_unlock();
539 return err;
540 }
541
eea_update_cfg(struct eea_net * enet,struct eea_device * edev,struct eea_aq_cfg * hwcfg)542 static int eea_update_cfg(struct eea_net *enet,
543 struct eea_device *edev,
544 struct eea_aq_cfg *hwcfg)
545 {
546 u32 rx_max = le32_to_cpu(hwcfg->rx_depth_max);
547 u32 tx_max = le32_to_cpu(hwcfg->tx_depth_max);
548 u32 rx_def = le32_to_cpu(hwcfg->rx_depth_def);
549 u32 tx_def = le32_to_cpu(hwcfg->tx_depth_def);
550
551 /* Now, we assert that the rx ring num is equal to the tx ring num. */
552 if (edev->rx_num != edev->tx_num) {
553 dev_err(edev->dma_dev, "Inconsistent ring num: RX %u, TX %u\n",
554 edev->rx_num, edev->tx_num);
555 return -EINVAL;
556 }
557
558 if (rx_max > EEA_NET_IO_HW_RING_DEPTH_MAX ||
559 rx_max < EEA_NET_IO_HW_RING_DEPTH_MIN ||
560 tx_max > EEA_NET_IO_HW_RING_DEPTH_MAX ||
561 tx_max < EEA_NET_IO_HW_RING_DEPTH_MIN) {
562 dev_err(edev->dma_dev, "Invalid HW max depth: RX %u, TX %u\n",
563 rx_max, tx_max);
564 return -EINVAL;
565 }
566
567 if (rx_def > rx_max ||
568 tx_def > tx_max ||
569 rx_def < EEA_NET_IO_HW_RING_DEPTH_MIN ||
570 tx_def < EEA_NET_IO_HW_RING_DEPTH_MIN) {
571 dev_err(edev->dma_dev, "Invalid default depth: RX %u (max %u), TX %u (max %u)\n",
572 rx_def, rx_max, tx_def, tx_max);
573 return -EINVAL;
574 }
575
576 if (!is_power_of_2(rx_max) || !is_power_of_2(tx_max) ||
577 !is_power_of_2(rx_def) || !is_power_of_2(tx_def)) {
578 dev_err(edev->dma_dev, "Ring depth must be power of 2\n");
579 return -EINVAL;
580 }
581
582 enet->cfg_hw.rx_ring_depth = rx_max;
583 enet->cfg_hw.tx_ring_depth = tx_max;
584 enet->cfg_hw.rx_ring_num = edev->rx_num;
585 enet->cfg_hw.tx_ring_num = edev->tx_num;
586 enet->cfg_hw.split_hdr = EEA_SPLIT_HDR_SIZE;
587
588 enet->cfg.rx_ring_depth = rx_def;
589 enet->cfg.tx_ring_depth = tx_def;
590 enet->cfg.rx_ring_num = edev->rx_num;
591 enet->cfg.tx_ring_num = edev->tx_num;
592
593 return 0;
594 }
595
eea_netdev_init_features(struct net_device * netdev,struct eea_net * enet,struct eea_device * edev)596 static int eea_netdev_init_features(struct net_device *netdev,
597 struct eea_net *enet,
598 struct eea_device *edev)
599 {
600 struct eea_aq_cfg *cfg;
601 int err;
602 u32 mtu;
603
604 cfg = kzalloc_obj(*cfg);
605 if (!cfg)
606 return -ENOMEM;
607
608 err = eea_adminq_query_cfg(enet, cfg);
609 if (err)
610 goto err_free;
611
612 mtu = le16_to_cpu(cfg->mtu);
613 if (mtu < ETH_MIN_MTU) {
614 dev_err(edev->dma_dev, "The device gave us an invalid MTU. Here we can only exit the initialization. %u < %u\n",
615 mtu, ETH_MIN_MTU);
616 err = -EINVAL;
617 goto err_free;
618 }
619
620 err = eea_update_cfg(enet, edev, cfg);
621 if (err)
622 goto err_free;
623
624 netdev->priv_flags |= IFF_UNICAST_FLT;
625 netdev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
626
627 netdev->hw_features |= NETIF_F_HW_CSUM;
628 netdev->hw_features |= NETIF_F_GRO_HW;
629 netdev->hw_features |= NETIF_F_SG;
630 netdev->hw_features |= NETIF_F_TSO;
631 netdev->hw_features |= NETIF_F_TSO_ECN;
632 netdev->hw_features |= NETIF_F_TSO6;
633 netdev->hw_features |= NETIF_F_GSO_UDP_L4;
634
635 netdev->features |= NETIF_F_HIGHDMA;
636 netdev->features |= NETIF_F_HW_CSUM;
637 netdev->features |= NETIF_F_SG;
638 netdev->features |= NETIF_F_GSO_ROBUST;
639 netdev->features |= netdev->hw_features & NETIF_F_ALL_TSO;
640 netdev->features |= NETIF_F_RXCSUM;
641 netdev->features |= NETIF_F_GRO_HW;
642
643 netdev->vlan_features = netdev->features;
644
645 if (!is_valid_ether_addr(cfg->mac)) {
646 dev_err(edev->dma_dev, "The device gave invalid mac %pM\n",
647 cfg->mac);
648 err = -EINVAL;
649 goto err_free;
650 }
651
652 eth_hw_addr_set(netdev, cfg->mac);
653
654 enet->speed = SPEED_UNKNOWN;
655 enet->duplex = DUPLEX_UNKNOWN;
656
657 netdev->min_mtu = ETH_MIN_MTU;
658
659 netdev->mtu = mtu;
660
661 /* If jumbo frames are already enabled, then the returned MTU will be a
662 * jumbo MTU, and the driver will automatically enable jumbo frame
663 * support by default.
664 */
665 netdev->max_mtu = mtu;
666
667 err_free:
668 kfree(cfg);
669 return err;
670 }
671
672 static const struct net_device_ops eea_netdev = {
673 .ndo_open = eea_netdev_open,
674 .ndo_stop = eea_netdev_stop,
675 .ndo_start_xmit = eea_tx_xmit,
676 .ndo_validate_addr = eth_validate_addr,
677 .ndo_get_stats64 = eea_stats,
678 .ndo_features_check = passthru_features_check,
679 };
680
eea_netdev_alloc(struct eea_device * edev,u32 pairs)681 static struct eea_net *eea_netdev_alloc(struct eea_device *edev, u32 pairs)
682 {
683 struct net_device *netdev;
684 struct eea_net *enet;
685 int err;
686
687 netdev = alloc_etherdev_mq(sizeof(struct eea_net), pairs);
688 if (!netdev) {
689 dev_err(edev->dma_dev,
690 "alloc_etherdev_mq failed with pairs %d\n", pairs);
691 return NULL;
692 }
693
694 netdev->netdev_ops = &eea_netdev;
695 netdev->ethtool_ops = &eea_ethtool_ops;
696 SET_NETDEV_DEV(netdev, edev->dma_dev);
697
698 enet = netdev_priv(netdev);
699 enet->netdev = netdev;
700 enet->edev = edev;
701 edev->enet = enet;
702
703 err = eea_alloc_irq_blks(enet);
704 if (err) {
705 dev_err(edev->dma_dev,
706 "eea_alloc_irq_blks failed with pairs %d\n", pairs);
707 free_netdev(netdev);
708 return NULL;
709 }
710
711 spin_lock_init(&enet->stats_lock);
712
713 return enet;
714 }
715
eea_update_ts_off(struct eea_device * edev,struct eea_net * enet)716 static void eea_update_ts_off(struct eea_device *edev, struct eea_net *enet)
717 {
718 u64 ts;
719
720 ts = eea_pci_device_ts(edev);
721
722 enet->hw_ts_offset = ktime_get_real() - ts;
723 }
724
eea_net_reprobe(struct eea_device * edev)725 static int eea_net_reprobe(struct eea_device *edev)
726 {
727 struct eea_net *enet = edev->enet;
728 int err = 0;
729
730 enet->edev = edev;
731
732 if (!enet->adminq.ring) {
733 err = eea_create_adminq(enet, edev->rx_num + edev->tx_num);
734 if (err)
735 return err;
736 }
737
738 err = eea_alloc_irq_blks(enet);
739 if (err)
740 goto err_destroy_aq;
741
742 eea_update_ts_off(edev, enet);
743
744 rtnl_lock();
745
746 enet->link_err = 0;
747 if (edev->ha_reset_netdev_running &&
748 netif_running(edev->enet->netdev)) {
749 err = eea_netdev_open(enet->netdev);
750 if (err) {
751 enet->link_err = EEA_LINK_ERR_HA_RESET_DEV;
752 rtnl_unlock();
753 goto err_free_irq_blks;
754 }
755 }
756
757 rtnl_unlock();
758
759 enet->wait_pci_ready = false;
760 return 0;
761
762 err_free_irq_blks:
763 eea_free_irq_blk(enet);
764
765 err_destroy_aq:
766 eea_destroy_adminq(enet);
767
768 return err;
769 }
770
eea_net_probe(struct eea_device * edev)771 int eea_net_probe(struct eea_device *edev)
772 {
773 struct eea_net *enet;
774 int err = -ENOMEM;
775
776 /* If edev->enet is not null, then this is called from ha reset worker.
777 * Call eea_net_reprobe() directly.
778 */
779 if (edev->enet)
780 return eea_net_reprobe(edev);
781
782 enet = eea_netdev_alloc(edev, edev->rx_num);
783 if (!enet)
784 return -ENOMEM;
785
786 err = eea_create_adminq(enet, edev->rx_num + edev->tx_num);
787 if (err)
788 goto err_free_netdev;
789
790 eea_adminq_config_host_info(enet);
791
792 err = eea_netdev_init_features(enet->netdev, enet, edev);
793 if (err)
794 goto err_reset_dev;
795
796 eea_update_ts_off(edev, enet);
797
798 netif_carrier_off(enet->netdev);
799
800 err = register_netdev(enet->netdev);
801 if (err)
802 goto err_reset_dev;
803
804 netdev_dbg(enet->netdev, "eea probe success.\n");
805
806 return 0;
807
808 err_reset_dev:
809 eea_device_reset(edev);
810 eea_destroy_adminq(enet);
811
812 err_free_netdev:
813 eea_free_irq_blk(enet);
814 free_netdev(enet->netdev);
815 return err;
816 }
817
eea_net_ha_reset_remove(struct eea_net * enet,struct eea_device * edev)818 static void eea_net_ha_reset_remove(struct eea_net *enet,
819 struct eea_device *edev)
820 {
821 rtnl_lock();
822 edev->ha_reset_netdev_running = false;
823 if (netif_running(enet->netdev)) {
824 eea_netdev_stop(enet->netdev);
825 edev->ha_reset_netdev_running = true;
826 }
827
828 /* Prevent that the user set up the net device. */
829 enet->link_err = EEA_LINK_ERR_HA_RESET_DEV;
830
831 rtnl_unlock();
832
833 eea_device_reset(edev);
834 eea_destroy_adminq(enet);
835 eea_free_irq_blk(enet);
836
837 enet->wait_pci_ready = true;
838 }
839
eea_net_remove(struct eea_device * edev,bool ha)840 void eea_net_remove(struct eea_device *edev, bool ha)
841 {
842 struct net_device *netdev;
843 struct eea_net *enet;
844
845 enet = edev->enet;
846 netdev = enet->netdev;
847
848 if (ha) {
849 if (enet->wait_pci_ready)
850 return;
851
852 eea_net_ha_reset_remove(enet, edev);
853 return;
854 }
855
856 unregister_netdev(netdev);
857
858 if (!enet->wait_pci_ready) {
859 eea_device_reset(edev);
860 eea_destroy_adminq(enet);
861 eea_free_irq_blk(enet);
862 }
863
864 free_netdev(netdev);
865 }
866
eea_net_shutdown(struct eea_device * edev)867 void eea_net_shutdown(struct eea_device *edev)
868 {
869 struct net_device *netdev;
870 struct eea_net *enet;
871
872 enet = edev->enet;
873 netdev = enet->netdev;
874
875 rtnl_lock();
876
877 netif_device_detach(netdev);
878 dev_close(netdev);
879
880 if (!enet->wait_pci_ready) {
881 eea_device_reset(edev);
882 eea_destroy_adminq(enet);
883 eea_free_irq_blk(enet);
884 }
885
886 rtnl_unlock();
887 }
888