net/axgbe: support RSS RETA/hash query and update
[dpdk.git] / drivers / net / axgbe / axgbe_dev.c
1 /*   SPDX-License-Identifier: BSD-3-Clause
2  *   Copyright(c) 2018 Advanced Micro Devices, Inc. All rights reserved.
3  *   Copyright(c) 2018 Synopsys, Inc. All rights reserved.
4  */
5
6 #include "axgbe_ethdev.h"
7 #include "axgbe_common.h"
8 #include "axgbe_phy.h"
9 #include "axgbe_rxtx.h"
10
11 static inline unsigned int axgbe_get_max_frame(struct axgbe_port *pdata)
12 {
13         return pdata->eth_dev->data->mtu + RTE_ETHER_HDR_LEN +
14                 RTE_ETHER_CRC_LEN + VLAN_HLEN;
15 }
16
17 /* query busy bit */
18 static int mdio_complete(struct axgbe_port *pdata)
19 {
20         if (!AXGMAC_IOREAD_BITS(pdata, MAC_MDIOSCCDR, BUSY))
21                 return 1;
22
23         return 0;
24 }
25
26 static int axgbe_write_ext_mii_regs(struct axgbe_port *pdata, int addr,
27                                     int reg, u16 val)
28 {
29         unsigned int mdio_sca, mdio_sccd;
30         uint64_t timeout;
31
32         mdio_sca = 0;
33         AXGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, REG, reg);
34         AXGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, DA, addr);
35         AXGMAC_IOWRITE(pdata, MAC_MDIOSCAR, mdio_sca);
36
37         mdio_sccd = 0;
38         AXGMAC_SET_BITS(mdio_sccd, MAC_MDIOSCCDR, DATA, val);
39         AXGMAC_SET_BITS(mdio_sccd, MAC_MDIOSCCDR, CMD, 1);
40         AXGMAC_SET_BITS(mdio_sccd, MAC_MDIOSCCDR, BUSY, 1);
41         AXGMAC_IOWRITE(pdata, MAC_MDIOSCCDR, mdio_sccd);
42
43         timeout = rte_get_timer_cycles() + rte_get_timer_hz();
44         while (time_before(rte_get_timer_cycles(), timeout)) {
45                 rte_delay_us(100);
46                 if (mdio_complete(pdata))
47                         return 0;
48         }
49
50         PMD_DRV_LOG(ERR, "Mdio write operation timed out\n");
51         return -ETIMEDOUT;
52 }
53
54 static int axgbe_read_ext_mii_regs(struct axgbe_port *pdata, int addr,
55                                    int reg)
56 {
57         unsigned int mdio_sca, mdio_sccd;
58         uint64_t timeout;
59
60         mdio_sca = 0;
61         AXGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, REG, reg);
62         AXGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, DA, addr);
63         AXGMAC_IOWRITE(pdata, MAC_MDIOSCAR, mdio_sca);
64
65         mdio_sccd = 0;
66         AXGMAC_SET_BITS(mdio_sccd, MAC_MDIOSCCDR, CMD, 3);
67         AXGMAC_SET_BITS(mdio_sccd, MAC_MDIOSCCDR, BUSY, 1);
68         AXGMAC_IOWRITE(pdata, MAC_MDIOSCCDR, mdio_sccd);
69
70         timeout = rte_get_timer_cycles() + rte_get_timer_hz();
71
72         while (time_before(rte_get_timer_cycles(), timeout)) {
73                 rte_delay_us(100);
74                 if (mdio_complete(pdata))
75                         goto success;
76         }
77
78         PMD_DRV_LOG(ERR, "Mdio read operation timed out\n");
79         return -ETIMEDOUT;
80
81 success:
82         return AXGMAC_IOREAD_BITS(pdata, MAC_MDIOSCCDR, DATA);
83 }
84
85 static int axgbe_set_ext_mii_mode(struct axgbe_port *pdata, unsigned int port,
86                                   enum axgbe_mdio_mode mode)
87 {
88         unsigned int reg_val = 0;
89
90         switch (mode) {
91         case AXGBE_MDIO_MODE_CL22:
92                 if (port > AXGMAC_MAX_C22_PORT)
93                         return -EINVAL;
94                 reg_val |= (1 << port);
95                 break;
96         case AXGBE_MDIO_MODE_CL45:
97                 break;
98         default:
99                 return -EINVAL;
100         }
101         AXGMAC_IOWRITE(pdata, MAC_MDIOCL22R, reg_val);
102
103         return 0;
104 }
105
106 static int axgbe_read_mmd_regs_v2(struct axgbe_port *pdata,
107                                   int prtad __rte_unused, int mmd_reg)
108 {
109         unsigned int mmd_address, index, offset;
110         int mmd_data;
111
112         if (mmd_reg & MII_ADDR_C45)
113                 mmd_address = mmd_reg & ~MII_ADDR_C45;
114         else
115                 mmd_address = (pdata->mdio_mmd << 16) | (mmd_reg & 0xffff);
116
117         /* The PCS registers are accessed using mmio. The underlying
118          * management interface uses indirect addressing to access the MMD
119          * register sets. This requires accessing of the PCS register in two
120          * phases, an address phase and a data phase.
121          *
122          * The mmio interface is based on 16-bit offsets and values. All
123          * register offsets must therefore be adjusted by left shifting the
124          * offset 1 bit and reading 16 bits of data.
125          */
126         mmd_address <<= 1;
127         index = mmd_address & ~pdata->xpcs_window_mask;
128         offset = pdata->xpcs_window + (mmd_address & pdata->xpcs_window_mask);
129
130         pthread_mutex_lock(&pdata->xpcs_mutex);
131
132         XPCS32_IOWRITE(pdata, pdata->xpcs_window_sel_reg, index);
133         mmd_data = XPCS16_IOREAD(pdata, offset);
134
135         pthread_mutex_unlock(&pdata->xpcs_mutex);
136
137         return mmd_data;
138 }
139
140 static void axgbe_write_mmd_regs_v2(struct axgbe_port *pdata,
141                                     int prtad __rte_unused,
142                                     int mmd_reg, int mmd_data)
143 {
144         unsigned int mmd_address, index, offset;
145
146         if (mmd_reg & MII_ADDR_C45)
147                 mmd_address = mmd_reg & ~MII_ADDR_C45;
148         else
149                 mmd_address = (pdata->mdio_mmd << 16) | (mmd_reg & 0xffff);
150
151         /* The PCS registers are accessed using mmio. The underlying
152          * management interface uses indirect addressing to access the MMD
153          * register sets. This requires accessing of the PCS register in two
154          * phases, an address phase and a data phase.
155          *
156          * The mmio interface is based on 16-bit offsets and values. All
157          * register offsets must therefore be adjusted by left shifting the
158          * offset 1 bit and writing 16 bits of data.
159          */
160         mmd_address <<= 1;
161         index = mmd_address & ~pdata->xpcs_window_mask;
162         offset = pdata->xpcs_window + (mmd_address & pdata->xpcs_window_mask);
163
164         pthread_mutex_lock(&pdata->xpcs_mutex);
165
166         XPCS32_IOWRITE(pdata, pdata->xpcs_window_sel_reg, index);
167         XPCS16_IOWRITE(pdata, offset, mmd_data);
168
169         pthread_mutex_unlock(&pdata->xpcs_mutex);
170 }
171
172 static int axgbe_read_mmd_regs(struct axgbe_port *pdata, int prtad,
173                                int mmd_reg)
174 {
175         switch (pdata->vdata->xpcs_access) {
176         case AXGBE_XPCS_ACCESS_V1:
177                 PMD_DRV_LOG(ERR, "PHY_Version 1 is not supported\n");
178                 return -1;
179         case AXGBE_XPCS_ACCESS_V2:
180         default:
181                 return axgbe_read_mmd_regs_v2(pdata, prtad, mmd_reg);
182         }
183 }
184
185 static void axgbe_write_mmd_regs(struct axgbe_port *pdata, int prtad,
186                                  int mmd_reg, int mmd_data)
187 {
188         switch (pdata->vdata->xpcs_access) {
189         case AXGBE_XPCS_ACCESS_V1:
190                 PMD_DRV_LOG(ERR, "PHY_Version 1 is not supported\n");
191                 return;
192         case AXGBE_XPCS_ACCESS_V2:
193         default:
194                 return axgbe_write_mmd_regs_v2(pdata, prtad, mmd_reg, mmd_data);
195         }
196 }
197
198 static int axgbe_set_speed(struct axgbe_port *pdata, int speed)
199 {
200         unsigned int ss;
201
202         switch (speed) {
203         case SPEED_1000:
204                 ss = 0x03;
205                 break;
206         case SPEED_2500:
207                 ss = 0x02;
208                 break;
209         case SPEED_10000:
210                 ss = 0x00;
211                 break;
212         default:
213                 return -EINVAL;
214         }
215
216         if (AXGMAC_IOREAD_BITS(pdata, MAC_TCR, SS) != ss)
217                 AXGMAC_IOWRITE_BITS(pdata, MAC_TCR, SS, ss);
218
219         return 0;
220 }
221
222 static int axgbe_disable_tx_flow_control(struct axgbe_port *pdata)
223 {
224         unsigned int max_q_count, q_count;
225         unsigned int reg, reg_val;
226         unsigned int i;
227
228         /* Clear MTL flow control */
229         for (i = 0; i < pdata->rx_q_count; i++)
230                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQOMR, EHFC, 0);
231
232         /* Clear MAC flow control */
233         max_q_count = AXGMAC_MAX_FLOW_CONTROL_QUEUES;
234         q_count = RTE_MIN(pdata->tx_q_count,
235                         max_q_count);
236         reg = MAC_Q0TFCR;
237         for (i = 0; i < q_count; i++) {
238                 reg_val = AXGMAC_IOREAD(pdata, reg);
239                 AXGMAC_SET_BITS(reg_val, MAC_Q0TFCR, TFE, 0);
240                 AXGMAC_IOWRITE(pdata, reg, reg_val);
241
242                 reg += MAC_QTFCR_INC;
243         }
244
245         return 0;
246 }
247
248 static int axgbe_enable_tx_flow_control(struct axgbe_port *pdata)
249 {
250         unsigned int max_q_count, q_count;
251         unsigned int reg, reg_val;
252         unsigned int i;
253
254         /* Set MTL flow control */
255         for (i = 0; i < pdata->rx_q_count; i++) {
256                 unsigned int ehfc = 0;
257
258                 /* Flow control thresholds are established */
259                 if (pdata->rx_rfd[i])
260                         ehfc = 1;
261
262                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQOMR, EHFC, ehfc);
263
264                 PMD_DRV_LOG(DEBUG, "flow control %s for RXq%u\n",
265                             ehfc ? "enabled" : "disabled", i);
266         }
267
268         /* Set MAC flow control */
269         max_q_count = AXGMAC_MAX_FLOW_CONTROL_QUEUES;
270         q_count = RTE_MIN(pdata->tx_q_count,
271                         max_q_count);
272         reg = MAC_Q0TFCR;
273         for (i = 0; i < q_count; i++) {
274                 reg_val = AXGMAC_IOREAD(pdata, reg);
275
276                 /* Enable transmit flow control */
277                 AXGMAC_SET_BITS(reg_val, MAC_Q0TFCR, TFE, 1);
278                 /* Set pause time */
279                 AXGMAC_SET_BITS(reg_val, MAC_Q0TFCR, PT, 0xffff);
280
281                 AXGMAC_IOWRITE(pdata, reg, reg_val);
282
283                 reg += MAC_QTFCR_INC;
284         }
285
286         return 0;
287 }
288
289 static int axgbe_disable_rx_flow_control(struct axgbe_port *pdata)
290 {
291         AXGMAC_IOWRITE_BITS(pdata, MAC_RFCR, RFE, 0);
292
293         return 0;
294 }
295
296 static int axgbe_enable_rx_flow_control(struct axgbe_port *pdata)
297 {
298         AXGMAC_IOWRITE_BITS(pdata, MAC_RFCR, RFE, 1);
299
300         return 0;
301 }
302
303 static int axgbe_config_tx_flow_control(struct axgbe_port *pdata)
304 {
305         if (pdata->tx_pause)
306                 axgbe_enable_tx_flow_control(pdata);
307         else
308                 axgbe_disable_tx_flow_control(pdata);
309
310         return 0;
311 }
312
313 static int axgbe_config_rx_flow_control(struct axgbe_port *pdata)
314 {
315         if (pdata->rx_pause)
316                 axgbe_enable_rx_flow_control(pdata);
317         else
318                 axgbe_disable_rx_flow_control(pdata);
319
320         return 0;
321 }
322
323 static void axgbe_config_flow_control(struct axgbe_port *pdata)
324 {
325         axgbe_config_tx_flow_control(pdata);
326         axgbe_config_rx_flow_control(pdata);
327
328         AXGMAC_IOWRITE_BITS(pdata, MAC_RFCR, PFCE, 0);
329 }
330
331 static void axgbe_queue_flow_control_threshold(struct axgbe_port *pdata,
332                                                unsigned int queue,
333                                                unsigned int q_fifo_size)
334 {
335         unsigned int frame_fifo_size;
336         unsigned int rfa, rfd;
337
338         frame_fifo_size = AXGMAC_FLOW_CONTROL_ALIGN(axgbe_get_max_frame(pdata));
339
340         /* This path deals with just maximum frame sizes which are
341          * limited to a jumbo frame of 9,000 (plus headers, etc.)
342          * so we can never exceed the maximum allowable RFA/RFD
343          * values.
344          */
345         if (q_fifo_size <= 2048) {
346                 /* rx_rfd to zero to signal no flow control */
347                 pdata->rx_rfa[queue] = 0;
348                 pdata->rx_rfd[queue] = 0;
349                 return;
350         }
351
352         if (q_fifo_size <= 4096) {
353                 /* Between 2048 and 4096 */
354                 pdata->rx_rfa[queue] = 0;       /* Full - 1024 bytes */
355                 pdata->rx_rfd[queue] = 1;       /* Full - 1536 bytes */
356                 return;
357         }
358
359         if (q_fifo_size <= frame_fifo_size) {
360                 /* Between 4096 and max-frame */
361                 pdata->rx_rfa[queue] = 2;       /* Full - 2048 bytes */
362                 pdata->rx_rfd[queue] = 5;       /* Full - 3584 bytes */
363                 return;
364         }
365
366         if (q_fifo_size <= (frame_fifo_size * 3)) {
367                 /* Between max-frame and 3 max-frames,
368                  * trigger if we get just over a frame of data and
369                  * resume when we have just under half a frame left.
370                  */
371                 rfa = q_fifo_size - frame_fifo_size;
372                 rfd = rfa + (frame_fifo_size / 2);
373         } else {
374                 /* Above 3 max-frames - trigger when just over
375                  * 2 frames of space available
376                  */
377                 rfa = frame_fifo_size * 2;
378                 rfa += AXGMAC_FLOW_CONTROL_UNIT;
379                 rfd = rfa + frame_fifo_size;
380         }
381
382         pdata->rx_rfa[queue] = AXGMAC_FLOW_CONTROL_VALUE(rfa);
383         pdata->rx_rfd[queue] = AXGMAC_FLOW_CONTROL_VALUE(rfd);
384 }
385
386 static void axgbe_calculate_flow_control_threshold(struct axgbe_port *pdata)
387 {
388         unsigned int q_fifo_size;
389         unsigned int i;
390
391         for (i = 0; i < pdata->rx_q_count; i++) {
392                 q_fifo_size = (pdata->fifo + 1) * AXGMAC_FIFO_UNIT;
393
394                 axgbe_queue_flow_control_threshold(pdata, i, q_fifo_size);
395         }
396 }
397
398 static void axgbe_config_flow_control_threshold(struct axgbe_port *pdata)
399 {
400         unsigned int i;
401
402         for (i = 0; i < pdata->rx_q_count; i++) {
403                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQFCR, RFA,
404                                         pdata->rx_rfa[i]);
405                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQFCR, RFD,
406                                         pdata->rx_rfd[i]);
407         }
408 }
409
410 static int __axgbe_exit(struct axgbe_port *pdata)
411 {
412         unsigned int count = 2000;
413
414         /* Issue a software reset */
415         AXGMAC_IOWRITE_BITS(pdata, DMA_MR, SWR, 1);
416         rte_delay_us(10);
417
418         /* Poll Until Poll Condition */
419         while (--count && AXGMAC_IOREAD_BITS(pdata, DMA_MR, SWR))
420                 rte_delay_us(500);
421
422         if (!count)
423                 return -EBUSY;
424
425         return 0;
426 }
427
428 static int axgbe_exit(struct axgbe_port *pdata)
429 {
430         int ret;
431
432         /* To guard against possible incorrectly generated interrupts,
433          * issue the software reset twice.
434          */
435         ret = __axgbe_exit(pdata);
436         if (ret)
437                 return ret;
438
439         return __axgbe_exit(pdata);
440 }
441
442 static int axgbe_flush_tx_queues(struct axgbe_port *pdata)
443 {
444         unsigned int i, count;
445
446         if (AXGMAC_GET_BITS(pdata->hw_feat.version, MAC_VR, SNPSVER) < 0x21)
447                 return 0;
448
449         for (i = 0; i < pdata->tx_q_count; i++)
450                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_TQOMR, FTQ, 1);
451
452         /* Poll Until Poll Condition */
453         for (i = 0; i < pdata->tx_q_count; i++) {
454                 count = 2000;
455                 while (--count && AXGMAC_MTL_IOREAD_BITS(pdata, i,
456                                                          MTL_Q_TQOMR, FTQ))
457                         rte_delay_us(500);
458
459                 if (!count)
460                         return -EBUSY;
461         }
462
463         return 0;
464 }
465
466 static void axgbe_config_dma_bus(struct axgbe_port *pdata)
467 {
468         /* Set enhanced addressing mode */
469         AXGMAC_IOWRITE_BITS(pdata, DMA_SBMR, EAME, 1);
470
471         /* Out standing read/write requests*/
472         AXGMAC_IOWRITE_BITS(pdata, DMA_SBMR, RD_OSR, 0x3f);
473         AXGMAC_IOWRITE_BITS(pdata, DMA_SBMR, WR_OSR, 0x3f);
474
475         /* Set the System Bus mode */
476         AXGMAC_IOWRITE_BITS(pdata, DMA_SBMR, UNDEF, 1);
477         AXGMAC_IOWRITE_BITS(pdata, DMA_SBMR, BLEN_32, 1);
478         AXGMAC_IOWRITE_BITS(pdata, DMA_SBMR, AAL, 1);
479 }
480
481 static void axgbe_config_dma_cache(struct axgbe_port *pdata)
482 {
483         unsigned int arcache, awcache, arwcache;
484
485         arcache = 0;
486         AXGMAC_SET_BITS(arcache, DMA_AXIARCR, DRC, 0x3);
487         AXGMAC_IOWRITE(pdata, DMA_AXIARCR, arcache);
488
489         awcache = 0;
490         AXGMAC_SET_BITS(awcache, DMA_AXIAWCR, DWC, 0x3);
491         AXGMAC_SET_BITS(awcache, DMA_AXIAWCR, RPC, 0x3);
492         AXGMAC_SET_BITS(awcache, DMA_AXIAWCR, RPD, 0x1);
493         AXGMAC_SET_BITS(awcache, DMA_AXIAWCR, RHC, 0x3);
494         AXGMAC_SET_BITS(awcache, DMA_AXIAWCR, RHD, 0x1);
495         AXGMAC_SET_BITS(awcache, DMA_AXIAWCR, RDC, 0x3);
496         AXGMAC_SET_BITS(awcache, DMA_AXIAWCR, RDD, 0x1);
497         AXGMAC_IOWRITE(pdata, DMA_AXIAWCR, awcache);
498
499         arwcache = 0;
500         AXGMAC_SET_BITS(arwcache, DMA_AXIAWRCR, TDWD, 0x1);
501         AXGMAC_SET_BITS(arwcache, DMA_AXIAWRCR, TDWC, 0x3);
502         AXGMAC_SET_BITS(arwcache, DMA_AXIAWRCR, RDRC, 0x3);
503         AXGMAC_IOWRITE(pdata, DMA_AXIAWRCR, arwcache);
504 }
505
506 static void axgbe_config_edma_control(struct axgbe_port *pdata)
507 {
508         AXGMAC_IOWRITE(pdata, EDMA_TX_CONTROL, 0x5);
509         AXGMAC_IOWRITE(pdata, EDMA_RX_CONTROL, 0x5);
510 }
511
512 static int axgbe_config_osp_mode(struct axgbe_port *pdata)
513 {
514         /* Force DMA to operate on second packet before closing descriptors
515          *  of first packet
516          */
517         struct axgbe_tx_queue *txq;
518         unsigned int i;
519
520         for (i = 0; i < pdata->eth_dev->data->nb_tx_queues; i++) {
521                 txq = pdata->eth_dev->data->tx_queues[i];
522                 AXGMAC_DMA_IOWRITE_BITS(txq, DMA_CH_TCR, OSP,
523                                         pdata->tx_osp_mode);
524         }
525
526         return 0;
527 }
528
529 static int axgbe_config_pblx8(struct axgbe_port *pdata)
530 {
531         struct axgbe_tx_queue *txq;
532         unsigned int i;
533
534         for (i = 0; i < pdata->eth_dev->data->nb_tx_queues; i++) {
535                 txq = pdata->eth_dev->data->tx_queues[i];
536                 AXGMAC_DMA_IOWRITE_BITS(txq, DMA_CH_CR, PBLX8,
537                                         pdata->pblx8);
538         }
539         return 0;
540 }
541
542 static int axgbe_config_tx_pbl_val(struct axgbe_port *pdata)
543 {
544         struct axgbe_tx_queue *txq;
545         unsigned int i;
546
547         for (i = 0; i < pdata->eth_dev->data->nb_tx_queues; i++) {
548                 txq = pdata->eth_dev->data->tx_queues[i];
549                 AXGMAC_DMA_IOWRITE_BITS(txq, DMA_CH_TCR, PBL,
550                                 pdata->tx_pbl);
551         }
552
553         return 0;
554 }
555
556 static int axgbe_config_rx_pbl_val(struct axgbe_port *pdata)
557 {
558         struct axgbe_rx_queue *rxq;
559         unsigned int i;
560
561         for (i = 0; i < pdata->eth_dev->data->nb_rx_queues; i++) {
562                 rxq = pdata->eth_dev->data->rx_queues[i];
563                 AXGMAC_DMA_IOWRITE_BITS(rxq, DMA_CH_RCR, PBL,
564                                 pdata->rx_pbl);
565         }
566
567         return 0;
568 }
569
570 static void axgbe_config_rx_buffer_size(struct axgbe_port *pdata)
571 {
572         struct axgbe_rx_queue *rxq;
573         unsigned int i;
574
575         for (i = 0; i < pdata->eth_dev->data->nb_rx_queues; i++) {
576                 rxq = pdata->eth_dev->data->rx_queues[i];
577
578                 rxq->buf_size = rte_pktmbuf_data_room_size(rxq->mb_pool) -
579                         RTE_PKTMBUF_HEADROOM;
580                 rxq->buf_size = (rxq->buf_size + AXGBE_RX_BUF_ALIGN - 1) &
581                         ~(AXGBE_RX_BUF_ALIGN - 1);
582
583                 if (rxq->buf_size > pdata->rx_buf_size)
584                         pdata->rx_buf_size = rxq->buf_size;
585
586                 AXGMAC_DMA_IOWRITE_BITS(rxq, DMA_CH_RCR, RBSZ,
587                                         rxq->buf_size);
588         }
589 }
590
591 static int axgbe_write_rss_reg(struct axgbe_port *pdata, unsigned int type,
592                                unsigned int index, unsigned int val)
593 {
594         unsigned int wait;
595
596         if (AXGMAC_IOREAD_BITS(pdata, MAC_RSSAR, OB))
597                 return -EBUSY;
598
599         AXGMAC_IOWRITE(pdata, MAC_RSSDR, val);
600
601         AXGMAC_IOWRITE_BITS(pdata, MAC_RSSAR, RSSIA, index);
602         AXGMAC_IOWRITE_BITS(pdata, MAC_RSSAR, ADDRT, type);
603         AXGMAC_IOWRITE_BITS(pdata, MAC_RSSAR, CT, 0);
604         AXGMAC_IOWRITE_BITS(pdata, MAC_RSSAR, OB, 1);
605
606         wait = 1000;
607         while (wait--) {
608                 if (!AXGMAC_IOREAD_BITS(pdata, MAC_RSSAR, OB))
609                         return 0;
610
611                 rte_delay_us(1500);
612         }
613
614         return -EBUSY;
615 }
616
617 int axgbe_write_rss_hash_key(struct axgbe_port *pdata)
618 {
619         struct rte_eth_rss_conf *rss_conf;
620         unsigned int key_regs = sizeof(pdata->rss_key) / sizeof(u32);
621         unsigned int *key;
622         int ret;
623
624         rss_conf = &pdata->eth_dev->data->dev_conf.rx_adv_conf.rss_conf;
625
626         if (!rss_conf->rss_key)
627                 key = (unsigned int *)&pdata->rss_key;
628         else
629                 key = (unsigned int *)&rss_conf->rss_key;
630
631         while (key_regs--) {
632                 ret = axgbe_write_rss_reg(pdata, AXGBE_RSS_HASH_KEY_TYPE,
633                                           key_regs, *key++);
634                 if (ret)
635                         return ret;
636         }
637
638         return 0;
639 }
640
641 int axgbe_write_rss_lookup_table(struct axgbe_port *pdata)
642 {
643         unsigned int i;
644         int ret;
645
646         for (i = 0; i < ARRAY_SIZE(pdata->rss_table); i++) {
647                 ret = axgbe_write_rss_reg(pdata,
648                                           AXGBE_RSS_LOOKUP_TABLE_TYPE, i,
649                                           pdata->rss_table[i]);
650                 if (ret)
651                         return ret;
652         }
653
654         return 0;
655 }
656
657 static int axgbe_enable_rss(struct axgbe_port *pdata)
658 {
659         int ret;
660
661         /* Program the hash key */
662         ret = axgbe_write_rss_hash_key(pdata);
663         if (ret)
664                 return ret;
665
666         /* Program the lookup table */
667         ret = axgbe_write_rss_lookup_table(pdata);
668         if (ret)
669                 return ret;
670
671         /* Set the RSS options */
672         AXGMAC_IOWRITE(pdata, MAC_RSSCR, pdata->rss_options);
673
674         /* Enable RSS */
675         AXGMAC_IOWRITE_BITS(pdata, MAC_RSSCR, RSSE, 1);
676
677         return 0;
678 }
679
680 static void axgbe_rss_options(struct axgbe_port *pdata)
681 {
682         struct rte_eth_rss_conf *rss_conf;
683         uint64_t rss_hf;
684
685         rss_conf = &pdata->eth_dev->data->dev_conf.rx_adv_conf.rss_conf;
686         pdata->rss_hf = rss_conf->rss_hf;
687         rss_hf = rss_conf->rss_hf;
688
689         if (rss_hf & (ETH_RSS_IPV4 | ETH_RSS_IPV6))
690                 AXGMAC_SET_BITS(pdata->rss_options, MAC_RSSCR, IP2TE, 1);
691         if (rss_hf & (ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_NONFRAG_IPV6_TCP))
692                 AXGMAC_SET_BITS(pdata->rss_options, MAC_RSSCR, TCP4TE, 1);
693         if (rss_hf & (ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_NONFRAG_IPV6_UDP))
694                 AXGMAC_SET_BITS(pdata->rss_options, MAC_RSSCR, UDP4TE, 1);
695 }
696
697 static int axgbe_config_rss(struct axgbe_port *pdata)
698 {
699         uint32_t i;
700
701         if (pdata->rss_enable) {
702                 /* Initialize RSS hash key and lookup table */
703                 uint32_t *key = (uint32_t *)pdata->rss_key;
704
705                 for (i = 0; i < sizeof(pdata->rss_key) / 4; i++)
706                         *key++ = (uint32_t)rte_rand();
707                 for (i = 0; i < AXGBE_RSS_MAX_TABLE_SIZE; i++)
708                         AXGMAC_SET_BITS(pdata->rss_table[i], MAC_RSSDR, DMCH,
709                                         i % pdata->eth_dev->data->nb_rx_queues);
710                 axgbe_rss_options(pdata);
711                 if (axgbe_enable_rss(pdata)) {
712                         PMD_DRV_LOG(ERR, "Error in enabling RSS support\n");
713                         return -1;
714                 }
715         } else {
716                 AXGMAC_IOWRITE_BITS(pdata, MAC_RSSCR, RSSE, 0);
717         }
718
719         return 0;
720 }
721
722 static void axgbe_enable_dma_interrupts(struct axgbe_port *pdata)
723 {
724         struct axgbe_tx_queue *txq;
725         unsigned int dma_ch_isr, dma_ch_ier;
726         unsigned int i;
727
728         for (i = 0; i < pdata->eth_dev->data->nb_tx_queues; i++) {
729                 txq = pdata->eth_dev->data->tx_queues[i];
730
731                 /* Clear all the interrupts which are set */
732                 dma_ch_isr = AXGMAC_DMA_IOREAD(txq, DMA_CH_SR);
733                 AXGMAC_DMA_IOWRITE(txq, DMA_CH_SR, dma_ch_isr);
734
735                 /* Clear all interrupt enable bits */
736                 dma_ch_ier = 0;
737
738                 /* Enable following interrupts
739                  *   NIE  - Normal Interrupt Summary Enable
740                  *   AIE  - Abnormal Interrupt Summary Enable
741                  *   FBEE - Fatal Bus Error Enable
742                  */
743                 AXGMAC_SET_BITS(dma_ch_ier, DMA_CH_IER, NIE, 0);
744                 AXGMAC_SET_BITS(dma_ch_ier, DMA_CH_IER, AIE, 1);
745                 AXGMAC_SET_BITS(dma_ch_ier, DMA_CH_IER, FBEE, 1);
746
747                 /* Enable following Rx interrupts
748                  *   RBUE - Receive Buffer Unavailable Enable
749                  *   RIE  - Receive Interrupt Enable (unless using
750                  *          per channel interrupts in edge triggered
751                  *          mode)
752                  */
753                 AXGMAC_SET_BITS(dma_ch_ier, DMA_CH_IER, RBUE, 0);
754
755                 AXGMAC_DMA_IOWRITE(txq, DMA_CH_IER, dma_ch_ier);
756         }
757 }
758
759 static void wrapper_tx_desc_init(struct axgbe_port *pdata)
760 {
761         struct axgbe_tx_queue *txq;
762         unsigned int i;
763
764         for (i = 0; i < pdata->eth_dev->data->nb_tx_queues; i++) {
765                 txq = pdata->eth_dev->data->tx_queues[i];
766                 txq->cur = 0;
767                 txq->dirty = 0;
768                 /* Update the total number of Tx descriptors */
769                 AXGMAC_DMA_IOWRITE(txq, DMA_CH_TDRLR, txq->nb_desc - 1);
770                 /* Update the starting address of descriptor ring */
771                 AXGMAC_DMA_IOWRITE(txq, DMA_CH_TDLR_HI,
772                                         high32_value(txq->ring_phys_addr));
773                 AXGMAC_DMA_IOWRITE(txq, DMA_CH_TDLR_LO,
774                                         low32_value(txq->ring_phys_addr));
775         }
776 }
777
778 static int wrapper_rx_desc_init(struct axgbe_port *pdata)
779 {
780         struct axgbe_rx_queue *rxq;
781         struct rte_mbuf *mbuf;
782         volatile union axgbe_rx_desc *desc;
783         unsigned int i, j;
784
785         for (i = 0; i < pdata->eth_dev->data->nb_rx_queues; i++) {
786                 rxq = pdata->eth_dev->data->rx_queues[i];
787
788                 /* Initialize software ring entries */
789                 rxq->mbuf_alloc = 0;
790                 rxq->cur = 0;
791                 rxq->dirty = 0;
792                 desc = AXGBE_GET_DESC_PT(rxq, 0);
793
794                 for (j = 0; j < rxq->nb_desc; j++) {
795                         mbuf = rte_mbuf_raw_alloc(rxq->mb_pool);
796                         if (mbuf == NULL) {
797                                 PMD_DRV_LOG(ERR, "RX mbuf alloc failed queue_id = %u, idx = %d\n",
798                                             (unsigned int)rxq->queue_id, j);
799                                 axgbe_dev_rx_queue_release(rxq);
800                                 return -ENOMEM;
801                         }
802                         rxq->sw_ring[j] = mbuf;
803                         /* Mbuf populate */
804                         mbuf->next = NULL;
805                         mbuf->data_off = RTE_PKTMBUF_HEADROOM;
806                         mbuf->nb_segs = 1;
807                         mbuf->port = rxq->port_id;
808                         desc->read.baddr =
809                                 rte_cpu_to_le_64(
810                                         rte_mbuf_data_iova_default(mbuf));
811                         rte_wmb();
812                         AXGMAC_SET_BITS_LE(desc->read.desc3,
813                                                 RX_NORMAL_DESC3, OWN, 1);
814                         rte_wmb();
815                         rxq->mbuf_alloc++;
816                         desc++;
817                 }
818                 /* Update the total number of Rx descriptors */
819                 AXGMAC_DMA_IOWRITE(rxq, DMA_CH_RDRLR,
820                                         rxq->nb_desc - 1);
821                 /* Update the starting address of descriptor ring */
822                 AXGMAC_DMA_IOWRITE(rxq, DMA_CH_RDLR_HI,
823                                         high32_value(rxq->ring_phys_addr));
824                 AXGMAC_DMA_IOWRITE(rxq, DMA_CH_RDLR_LO,
825                                         low32_value(rxq->ring_phys_addr));
826                 /* Update the Rx Descriptor Tail Pointer */
827                 AXGMAC_DMA_IOWRITE(rxq, DMA_CH_RDTR_LO,
828                                    low32_value(rxq->ring_phys_addr +
829                                    (rxq->nb_desc - 1) *
830                                    sizeof(union axgbe_rx_desc)));
831         }
832         return 0;
833 }
834
835 static void axgbe_config_mtl_mode(struct axgbe_port *pdata)
836 {
837         unsigned int i;
838
839         /* Set Tx to weighted round robin scheduling algorithm */
840         AXGMAC_IOWRITE_BITS(pdata, MTL_OMR, ETSALG, MTL_ETSALG_WRR);
841
842         /* Set Tx traffic classes to use WRR algorithm with equal weights */
843         for (i = 0; i < pdata->hw_feat.tc_cnt; i++) {
844                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_TC_ETSCR, TSA,
845                                 MTL_TSA_ETS);
846                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_TC_QWR, QW, 1);
847         }
848
849         /* Set Rx to strict priority algorithm */
850         AXGMAC_IOWRITE_BITS(pdata, MTL_OMR, RAA, MTL_RAA_SP);
851 }
852
853 static int axgbe_config_tsf_mode(struct axgbe_port *pdata, unsigned int val)
854 {
855         unsigned int i;
856
857         for (i = 0; i < pdata->tx_q_count; i++)
858                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_TQOMR, TSF, val);
859
860         return 0;
861 }
862
863 static int axgbe_config_rsf_mode(struct axgbe_port *pdata, unsigned int val)
864 {
865         unsigned int i;
866
867         for (i = 0; i < pdata->rx_q_count; i++)
868                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQOMR, RSF, val);
869
870         return 0;
871 }
872
873 static int axgbe_config_tx_threshold(struct axgbe_port *pdata,
874                                      unsigned int val)
875 {
876         unsigned int i;
877
878         for (i = 0; i < pdata->tx_q_count; i++)
879                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_TQOMR, TTC, val);
880
881         return 0;
882 }
883
884 static int axgbe_config_rx_threshold(struct axgbe_port *pdata,
885                                      unsigned int val)
886 {
887         unsigned int i;
888
889         for (i = 0; i < pdata->rx_q_count; i++)
890                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQOMR, RTC, val);
891
892         return 0;
893 }
894
895 /*Distrubting fifo size  */
896 static void axgbe_config_rx_fifo_size(struct axgbe_port *pdata)
897 {
898         unsigned int fifo_size;
899         unsigned int q_fifo_size;
900         unsigned int p_fifo, i;
901
902         fifo_size = RTE_MIN(pdata->rx_max_fifo_size,
903                           pdata->hw_feat.rx_fifo_size);
904         q_fifo_size = fifo_size / pdata->rx_q_count;
905
906         /* Calculate the fifo setting by dividing the queue's fifo size
907          * by the fifo allocation increment (with 0 representing the
908          * base allocation increment so decrement the result
909          * by 1).
910          */
911         p_fifo = q_fifo_size / AXGMAC_FIFO_UNIT;
912         if (p_fifo)
913                 p_fifo--;
914
915         for (i = 0; i < pdata->rx_q_count; i++)
916                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_RQOMR, RQS, p_fifo);
917         pdata->fifo = p_fifo;
918
919         /*Calculate and config Flow control threshold*/
920         axgbe_calculate_flow_control_threshold(pdata);
921         axgbe_config_flow_control_threshold(pdata);
922
923         PMD_DRV_LOG(DEBUG, "%d Rx hardware queues, %d byte fifo per queue\n",
924                     pdata->rx_q_count, q_fifo_size);
925 }
926
927 static void axgbe_config_tx_fifo_size(struct axgbe_port *pdata)
928 {
929         unsigned int fifo_size;
930         unsigned int q_fifo_size;
931         unsigned int p_fifo, i;
932
933         fifo_size = RTE_MIN(pdata->tx_max_fifo_size,
934                                 pdata->hw_feat.tx_fifo_size);
935         q_fifo_size = fifo_size / pdata->tx_q_count;
936
937         /* Calculate the fifo setting by dividing the queue's fifo size
938          * by the fifo allocation increment (with 0 representing the
939          * base allocation increment so decrement the result
940          * by 1).
941          */
942         p_fifo = q_fifo_size / AXGMAC_FIFO_UNIT;
943         if (p_fifo)
944                 p_fifo--;
945
946         for (i = 0; i < pdata->tx_q_count; i++)
947                 AXGMAC_MTL_IOWRITE_BITS(pdata, i, MTL_Q_TQOMR, TQS, p_fifo);
948
949         PMD_DRV_LOG(DEBUG, "%d Tx hardware queues, %d byte fifo per queue\n",
950                     pdata->tx_q_count, q_fifo_size);
951 }
952
953 static void axgbe_config_queue_mapping(struct axgbe_port *pdata)
954 {
955         unsigned int qptc, qptc_extra, queue;
956         unsigned int i, j, reg, reg_val;
957
958         /* Map the MTL Tx Queues to Traffic Classes
959          *   Note: Tx Queues >= Traffic Classes
960          */
961         qptc = pdata->tx_q_count / pdata->hw_feat.tc_cnt;
962         qptc_extra = pdata->tx_q_count % pdata->hw_feat.tc_cnt;
963
964         for (i = 0, queue = 0; i < pdata->hw_feat.tc_cnt; i++) {
965                 for (j = 0; j < qptc; j++) {
966                         PMD_DRV_LOG(DEBUG, "TXq%u mapped to TC%u\n", queue, i);
967                         AXGMAC_MTL_IOWRITE_BITS(pdata, queue, MTL_Q_TQOMR,
968                                                 Q2TCMAP, i);
969                 }
970                 if (i < qptc_extra) {
971                         PMD_DRV_LOG(DEBUG, "TXq%u mapped to TC%u\n", queue, i);
972                         AXGMAC_MTL_IOWRITE_BITS(pdata, queue, MTL_Q_TQOMR,
973                                                 Q2TCMAP, i);
974                 }
975         }
976
977         if (pdata->rss_enable) {
978                 /* Select dynamic mapping of MTL Rx queue to DMA Rx channel */
979                 reg = MTL_RQDCM0R;
980                 reg_val = 0;
981                 for (i = 0; i < pdata->rx_q_count;) {
982                         reg_val |= (0x80 << ((i++ % MTL_RQDCM_Q_PER_REG) << 3));
983
984                         if ((i % MTL_RQDCM_Q_PER_REG) &&
985                             (i != pdata->rx_q_count))
986                                 continue;
987
988                         AXGMAC_IOWRITE(pdata, reg, reg_val);
989
990                         reg += MTL_RQDCM_INC;
991                         reg_val = 0;
992                 }
993         }
994 }
995
996 static void axgbe_enable_mtl_interrupts(struct axgbe_port *pdata)
997 {
998         unsigned int mtl_q_isr;
999         unsigned int q_count, i;
1000
1001         q_count = RTE_MAX(pdata->hw_feat.tx_q_cnt, pdata->hw_feat.rx_q_cnt);
1002         for (i = 0; i < q_count; i++) {
1003                 /* Clear all the interrupts which are set */
1004                 mtl_q_isr = AXGMAC_MTL_IOREAD(pdata, i, MTL_Q_ISR);
1005                 AXGMAC_MTL_IOWRITE(pdata, i, MTL_Q_ISR, mtl_q_isr);
1006
1007                 /* No MTL interrupts to be enabled */
1008                 AXGMAC_MTL_IOWRITE(pdata, i, MTL_Q_IER, 0);
1009         }
1010 }
1011
1012 static uint32_t bitrev32(uint32_t x)
1013 {
1014         x = (x >> 16) | (x << 16);
1015         x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
1016         x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
1017         x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
1018         x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
1019         return x;
1020 }
1021
1022 static uint32_t crc32_le(uint32_t crc, uint8_t *p, uint32_t len)
1023 {
1024         int i;
1025         while (len--) {
1026                 crc ^= *p++;
1027                 for (i = 0; i < 8; i++)
1028                         crc = (crc >> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
1029         }
1030         return crc;
1031 }
1032
1033 void axgbe_set_mac_hash_table(struct axgbe_port *pdata, u8 *addr, bool add)
1034 {
1035         uint32_t crc, htable_index, htable_bitmask;
1036
1037         crc = bitrev32(~crc32_le(~0, addr, RTE_ETHER_ADDR_LEN));
1038         crc >>= pdata->hash_table_shift;
1039         htable_index = crc >> 5;
1040         htable_bitmask = 1 << (crc & 0x1f);
1041
1042         if (add) {
1043                 pdata->uc_hash_table[htable_index] |= htable_bitmask;
1044                 pdata->uc_hash_mac_addr++;
1045         } else {
1046                 pdata->uc_hash_table[htable_index] &= ~htable_bitmask;
1047                 pdata->uc_hash_mac_addr--;
1048         }
1049         PMD_DRV_LOG(DEBUG, "%s MAC hash table Bit %d at Index %#x\n",
1050                     add ? "set" : "clear", (crc & 0x1f), htable_index);
1051
1052         AXGMAC_IOWRITE(pdata, MAC_HTR(htable_index),
1053                        pdata->uc_hash_table[htable_index]);
1054 }
1055
1056 void axgbe_set_mac_addn_addr(struct axgbe_port *pdata, u8 *addr, uint32_t index)
1057 {
1058         unsigned int mac_addr_hi, mac_addr_lo;
1059         u8 *mac_addr;
1060
1061         mac_addr_lo = 0;
1062         mac_addr_hi = 0;
1063
1064         if (addr) {
1065                 mac_addr = (u8 *)&mac_addr_lo;
1066                 mac_addr[0] = addr[0];
1067                 mac_addr[1] = addr[1];
1068                 mac_addr[2] = addr[2];
1069                 mac_addr[3] = addr[3];
1070                 mac_addr = (u8 *)&mac_addr_hi;
1071                 mac_addr[0] = addr[4];
1072                 mac_addr[1] = addr[5];
1073
1074                 /*Address Enable: Use this Addr for Perfect Filtering */
1075                 AXGMAC_SET_BITS(mac_addr_hi, MAC_MACA1HR, AE, 1);
1076         }
1077
1078         PMD_DRV_LOG(DEBUG, "%s mac address at %#x\n",
1079                     addr ? "set" : "clear", index);
1080
1081         AXGMAC_IOWRITE(pdata, MAC_MACAHR(index), mac_addr_hi);
1082         AXGMAC_IOWRITE(pdata, MAC_MACALR(index), mac_addr_lo);
1083 }
1084
1085 static int axgbe_set_mac_address(struct axgbe_port *pdata, u8 *addr)
1086 {
1087         unsigned int mac_addr_hi, mac_addr_lo;
1088
1089         mac_addr_hi = (addr[5] <<  8) | (addr[4] <<  0);
1090         mac_addr_lo = (addr[3] << 24) | (addr[2] << 16) |
1091                 (addr[1] <<  8) | (addr[0] <<  0);
1092
1093         AXGMAC_IOWRITE(pdata, MAC_MACA0HR, mac_addr_hi);
1094         AXGMAC_IOWRITE(pdata, MAC_MACA0LR, mac_addr_lo);
1095
1096         return 0;
1097 }
1098
1099 static void axgbe_config_mac_hash_table(struct axgbe_port *pdata)
1100 {
1101         struct axgbe_hw_features *hw_feat = &pdata->hw_feat;
1102
1103         pdata->hash_table_shift = 0;
1104         pdata->hash_table_count = 0;
1105         pdata->uc_hash_mac_addr = 0;
1106         memset(pdata->uc_hash_table, 0, sizeof(pdata->uc_hash_table));
1107
1108         if (hw_feat->hash_table_size) {
1109                 pdata->hash_table_shift = 26 - (hw_feat->hash_table_size >> 7);
1110                 pdata->hash_table_count = hw_feat->hash_table_size / 32;
1111         }
1112 }
1113
1114 static void axgbe_config_mac_address(struct axgbe_port *pdata)
1115 {
1116         axgbe_set_mac_address(pdata, pdata->mac_addr.addr_bytes);
1117 }
1118
1119 static void axgbe_config_jumbo_enable(struct axgbe_port *pdata)
1120 {
1121         unsigned int val;
1122
1123         val = (pdata->rx_buf_size > AXGMAC_STD_PACKET_MTU) ? 1 : 0;
1124
1125         AXGMAC_IOWRITE_BITS(pdata, MAC_RCR, JE, val);
1126 }
1127
1128 static void axgbe_config_mac_speed(struct axgbe_port *pdata)
1129 {
1130         axgbe_set_speed(pdata, pdata->phy_speed);
1131 }
1132
1133 static void axgbe_config_checksum_offload(struct axgbe_port *pdata)
1134 {
1135         if (pdata->rx_csum_enable)
1136                 AXGMAC_IOWRITE_BITS(pdata, MAC_RCR, IPC, 1);
1137         else
1138                 AXGMAC_IOWRITE_BITS(pdata, MAC_RCR, IPC, 0);
1139 }
1140
1141 static void axgbe_config_mmc(struct axgbe_port *pdata)
1142 {
1143         struct axgbe_mmc_stats *stats = &pdata->mmc_stats;
1144
1145         /* Reset stats */
1146         memset(stats, 0, sizeof(*stats));
1147
1148         /* Set counters to reset on read */
1149         AXGMAC_IOWRITE_BITS(pdata, MMC_CR, ROR, 1);
1150
1151         /* Reset the counters */
1152         AXGMAC_IOWRITE_BITS(pdata, MMC_CR, CR, 1);
1153 }
1154
1155 static int axgbe_init(struct axgbe_port *pdata)
1156 {
1157         int ret;
1158
1159         /* Flush Tx queues */
1160         ret = axgbe_flush_tx_queues(pdata);
1161         if (ret)
1162                 return ret;
1163         /* Initialize DMA related features */
1164         axgbe_config_dma_bus(pdata);
1165         axgbe_config_dma_cache(pdata);
1166         axgbe_config_edma_control(pdata);
1167         axgbe_config_osp_mode(pdata);
1168         axgbe_config_pblx8(pdata);
1169         axgbe_config_tx_pbl_val(pdata);
1170         axgbe_config_rx_pbl_val(pdata);
1171         axgbe_config_rx_buffer_size(pdata);
1172         axgbe_config_rss(pdata);
1173         wrapper_tx_desc_init(pdata);
1174         ret = wrapper_rx_desc_init(pdata);
1175         if (ret)
1176                 return ret;
1177         axgbe_enable_dma_interrupts(pdata);
1178
1179         /* Initialize MTL related features */
1180         axgbe_config_mtl_mode(pdata);
1181         axgbe_config_queue_mapping(pdata);
1182         axgbe_config_tsf_mode(pdata, pdata->tx_sf_mode);
1183         axgbe_config_rsf_mode(pdata, pdata->rx_sf_mode);
1184         axgbe_config_tx_threshold(pdata, pdata->tx_threshold);
1185         axgbe_config_rx_threshold(pdata, pdata->rx_threshold);
1186         axgbe_config_tx_fifo_size(pdata);
1187         axgbe_config_rx_fifo_size(pdata);
1188
1189         axgbe_enable_mtl_interrupts(pdata);
1190
1191         /* Initialize MAC related features */
1192         axgbe_config_mac_hash_table(pdata);
1193         axgbe_config_mac_address(pdata);
1194         axgbe_config_jumbo_enable(pdata);
1195         axgbe_config_flow_control(pdata);
1196         axgbe_config_mac_speed(pdata);
1197         axgbe_config_checksum_offload(pdata);
1198         axgbe_config_mmc(pdata);
1199
1200         return 0;
1201 }
1202
1203 void axgbe_init_function_ptrs_dev(struct axgbe_hw_if *hw_if)
1204 {
1205         hw_if->exit = axgbe_exit;
1206         hw_if->config_flow_control = axgbe_config_flow_control;
1207
1208         hw_if->init = axgbe_init;
1209
1210         hw_if->read_mmd_regs = axgbe_read_mmd_regs;
1211         hw_if->write_mmd_regs = axgbe_write_mmd_regs;
1212
1213         hw_if->set_speed = axgbe_set_speed;
1214
1215         hw_if->set_ext_mii_mode = axgbe_set_ext_mii_mode;
1216         hw_if->read_ext_mii_regs = axgbe_read_ext_mii_regs;
1217         hw_if->write_ext_mii_regs = axgbe_write_ext_mii_regs;
1218         /* For FLOW ctrl */
1219         hw_if->config_tx_flow_control = axgbe_config_tx_flow_control;
1220         hw_if->config_rx_flow_control = axgbe_config_rx_flow_control;
1221 }