net/bnxt: fix Tx and Rx burst for secondary process
[dpdk.git] / drivers / net / axgbe / axgbe_phy_impl.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
10 #define AXGBE_PHY_PORT_SPEED_100        BIT(0)
11 #define AXGBE_PHY_PORT_SPEED_1000       BIT(1)
12 #define AXGBE_PHY_PORT_SPEED_2500       BIT(2)
13 #define AXGBE_PHY_PORT_SPEED_10000      BIT(3)
14
15 #define AXGBE_MUTEX_RELEASE             0x80000000
16
17 #define AXGBE_SFP_DIRECT                7
18
19 /* I2C target addresses */
20 #define AXGBE_SFP_SERIAL_ID_ADDRESS     0x50
21 #define AXGBE_SFP_DIAG_INFO_ADDRESS     0x51
22 #define AXGBE_SFP_PHY_ADDRESS           0x56
23 #define AXGBE_GPIO_ADDRESS_PCA9555      0x20
24
25 /* SFP sideband signal indicators */
26 #define AXGBE_GPIO_NO_TX_FAULT          BIT(0)
27 #define AXGBE_GPIO_NO_RATE_SELECT       BIT(1)
28 #define AXGBE_GPIO_NO_MOD_ABSENT        BIT(2)
29 #define AXGBE_GPIO_NO_RX_LOS            BIT(3)
30
31 /* Rate-change complete wait/retry count */
32 #define AXGBE_RATECHANGE_COUNT          500
33
34 /* CDR delay values for KR support (in usec) */
35 #define AXGBE_CDR_DELAY_INIT            10000
36 #define AXGBE_CDR_DELAY_INC             10000
37 #define AXGBE_CDR_DELAY_MAX             100000
38
39 enum axgbe_port_mode {
40         AXGBE_PORT_MODE_RSVD = 0,
41         AXGBE_PORT_MODE_BACKPLANE,
42         AXGBE_PORT_MODE_BACKPLANE_2500,
43         AXGBE_PORT_MODE_1000BASE_T,
44         AXGBE_PORT_MODE_1000BASE_X,
45         AXGBE_PORT_MODE_NBASE_T,
46         AXGBE_PORT_MODE_10GBASE_T,
47         AXGBE_PORT_MODE_10GBASE_R,
48         AXGBE_PORT_MODE_SFP,
49         AXGBE_PORT_MODE_MAX,
50 };
51
52 enum axgbe_conn_type {
53         AXGBE_CONN_TYPE_NONE = 0,
54         AXGBE_CONN_TYPE_SFP,
55         AXGBE_CONN_TYPE_MDIO,
56         AXGBE_CONN_TYPE_RSVD1,
57         AXGBE_CONN_TYPE_BACKPLANE,
58         AXGBE_CONN_TYPE_MAX,
59 };
60
61 /* SFP/SFP+ related definitions */
62 enum axgbe_sfp_comm {
63         AXGBE_SFP_COMM_DIRECT = 0,
64         AXGBE_SFP_COMM_PCA9545,
65 };
66
67 enum axgbe_sfp_cable {
68         AXGBE_SFP_CABLE_UNKNOWN = 0,
69         AXGBE_SFP_CABLE_ACTIVE,
70         AXGBE_SFP_CABLE_PASSIVE,
71 };
72
73 enum axgbe_sfp_base {
74         AXGBE_SFP_BASE_UNKNOWN = 0,
75         AXGBE_SFP_BASE_1000_T,
76         AXGBE_SFP_BASE_1000_SX,
77         AXGBE_SFP_BASE_1000_LX,
78         AXGBE_SFP_BASE_1000_CX,
79         AXGBE_SFP_BASE_10000_SR,
80         AXGBE_SFP_BASE_10000_LR,
81         AXGBE_SFP_BASE_10000_LRM,
82         AXGBE_SFP_BASE_10000_ER,
83         AXGBE_SFP_BASE_10000_CR,
84 };
85
86 enum axgbe_sfp_speed {
87         AXGBE_SFP_SPEED_UNKNOWN = 0,
88         AXGBE_SFP_SPEED_100_1000,
89         AXGBE_SFP_SPEED_1000,
90         AXGBE_SFP_SPEED_10000,
91 };
92
93 /* SFP Serial ID Base ID values relative to an offset of 0 */
94 #define AXGBE_SFP_BASE_ID                       0
95 #define AXGBE_SFP_ID_SFP                        0x03
96
97 #define AXGBE_SFP_BASE_EXT_ID                   1
98 #define AXGBE_SFP_EXT_ID_SFP                    0x04
99
100 #define AXGBE_SFP_BASE_10GBE_CC                 3
101 #define AXGBE_SFP_BASE_10GBE_CC_SR              BIT(4)
102 #define AXGBE_SFP_BASE_10GBE_CC_LR              BIT(5)
103 #define AXGBE_SFP_BASE_10GBE_CC_LRM             BIT(6)
104 #define AXGBE_SFP_BASE_10GBE_CC_ER              BIT(7)
105
106 #define AXGBE_SFP_BASE_1GBE_CC                  6
107 #define AXGBE_SFP_BASE_1GBE_CC_SX               BIT(0)
108 #define AXGBE_SFP_BASE_1GBE_CC_LX               BIT(1)
109 #define AXGBE_SFP_BASE_1GBE_CC_CX               BIT(2)
110 #define AXGBE_SFP_BASE_1GBE_CC_T                BIT(3)
111
112 #define AXGBE_SFP_BASE_CABLE                    8
113 #define AXGBE_SFP_BASE_CABLE_PASSIVE            BIT(2)
114 #define AXGBE_SFP_BASE_CABLE_ACTIVE             BIT(3)
115
116 #define AXGBE_SFP_BASE_BR                       12
117 #define AXGBE_SFP_BASE_BR_1GBE_MIN              0x0a
118 #define AXGBE_SFP_BASE_BR_1GBE_MAX              0x0d
119 #define AXGBE_SFP_BASE_BR_10GBE_MIN             0x64
120 #define AXGBE_SFP_BASE_BR_10GBE_MAX             0x68
121
122 #define AXGBE_SFP_BASE_CU_CABLE_LEN             18
123
124 #define AXGBE_SFP_BASE_VENDOR_NAME              20
125 #define AXGBE_SFP_BASE_VENDOR_NAME_LEN          16
126 #define AXGBE_SFP_BASE_VENDOR_PN                40
127 #define AXGBE_SFP_BASE_VENDOR_PN_LEN            16
128 #define AXGBE_SFP_BASE_VENDOR_REV               56
129 #define AXGBE_SFP_BASE_VENDOR_REV_LEN           4
130
131 #define AXGBE_SFP_BASE_CC                       63
132
133 /* SFP Serial ID Extended ID values relative to an offset of 64 */
134 #define AXGBE_SFP_BASE_VENDOR_SN                4
135 #define AXGBE_SFP_BASE_VENDOR_SN_LEN            16
136
137 #define AXGBE_SFP_EXTD_DIAG                     28
138 #define AXGBE_SFP_EXTD_DIAG_ADDR_CHANGE         BIT(2)
139
140 #define AXGBE_SFP_EXTD_SFF_8472                 30
141
142 #define AXGBE_SFP_EXTD_CC                       31
143
144 struct axgbe_sfp_eeprom {
145         u8 base[64];
146         u8 extd[32];
147         u8 vendor[32];
148 };
149
150 #define AXGBE_BEL_FUSE_VENDOR   "BEL-FUSE"
151 #define AXGBE_BEL_FUSE_PARTNO   "1GBT-SFP06"
152
153 struct axgbe_sfp_ascii {
154         union {
155                 char vendor[AXGBE_SFP_BASE_VENDOR_NAME_LEN + 1];
156                 char partno[AXGBE_SFP_BASE_VENDOR_PN_LEN + 1];
157                 char rev[AXGBE_SFP_BASE_VENDOR_REV_LEN + 1];
158                 char serno[AXGBE_SFP_BASE_VENDOR_SN_LEN + 1];
159         } u;
160 };
161
162 /* MDIO PHY reset types */
163 enum axgbe_mdio_reset {
164         AXGBE_MDIO_RESET_NONE = 0,
165         AXGBE_MDIO_RESET_I2C_GPIO,
166         AXGBE_MDIO_RESET_INT_GPIO,
167         AXGBE_MDIO_RESET_MAX,
168 };
169
170 /* Re-driver related definitions */
171 enum axgbe_phy_redrv_if {
172         AXGBE_PHY_REDRV_IF_MDIO = 0,
173         AXGBE_PHY_REDRV_IF_I2C,
174         AXGBE_PHY_REDRV_IF_MAX,
175 };
176
177 enum axgbe_phy_redrv_model {
178         AXGBE_PHY_REDRV_MODEL_4223 = 0,
179         AXGBE_PHY_REDRV_MODEL_4227,
180         AXGBE_PHY_REDRV_MODEL_MAX,
181 };
182
183 enum axgbe_phy_redrv_mode {
184         AXGBE_PHY_REDRV_MODE_CX = 5,
185         AXGBE_PHY_REDRV_MODE_SR = 9,
186 };
187
188 #define AXGBE_PHY_REDRV_MODE_REG        0x12b0
189
190 /* PHY related configuration information */
191 struct axgbe_phy_data {
192         enum axgbe_port_mode port_mode;
193
194         unsigned int port_id;
195
196         unsigned int port_speeds;
197
198         enum axgbe_conn_type conn_type;
199
200         enum axgbe_mode cur_mode;
201         enum axgbe_mode start_mode;
202
203         unsigned int rrc_count;
204
205         unsigned int mdio_addr;
206
207         unsigned int comm_owned;
208
209         /* SFP Support */
210         enum axgbe_sfp_comm sfp_comm;
211         unsigned int sfp_mux_address;
212         unsigned int sfp_mux_channel;
213
214         unsigned int sfp_gpio_address;
215         unsigned int sfp_gpio_mask;
216         unsigned int sfp_gpio_rx_los;
217         unsigned int sfp_gpio_tx_fault;
218         unsigned int sfp_gpio_mod_absent;
219         unsigned int sfp_gpio_rate_select;
220
221         unsigned int sfp_rx_los;
222         unsigned int sfp_tx_fault;
223         unsigned int sfp_mod_absent;
224         unsigned int sfp_diags;
225         unsigned int sfp_changed;
226         unsigned int sfp_phy_avail;
227         unsigned int sfp_cable_len;
228         enum axgbe_sfp_base sfp_base;
229         enum axgbe_sfp_cable sfp_cable;
230         enum axgbe_sfp_speed sfp_speed;
231         struct axgbe_sfp_eeprom sfp_eeprom;
232
233         /* External PHY support */
234         enum axgbe_mdio_mode phydev_mode;
235         enum axgbe_mdio_reset mdio_reset;
236         unsigned int mdio_reset_addr;
237         unsigned int mdio_reset_gpio;
238
239         /* Re-driver support */
240         unsigned int redrv;
241         unsigned int redrv_if;
242         unsigned int redrv_addr;
243         unsigned int redrv_lane;
244         unsigned int redrv_model;
245
246         /* KR AN support */
247         unsigned int phy_cdr_notrack;
248         unsigned int phy_cdr_delay;
249 };
250
251 static enum axgbe_an_mode axgbe_phy_an_mode(struct axgbe_port *pdata);
252
253 static int axgbe_phy_i2c_xfer(struct axgbe_port *pdata,
254                               struct axgbe_i2c_op *i2c_op)
255 {
256         struct axgbe_phy_data *phy_data = pdata->phy_data;
257
258         /* Be sure we own the bus */
259         if (!phy_data->comm_owned)
260                 return -EIO;
261
262         return pdata->i2c_if.i2c_xfer(pdata, i2c_op);
263 }
264
265 static int axgbe_phy_redrv_write(struct axgbe_port *pdata, unsigned int reg,
266                                  unsigned int val)
267 {
268         struct axgbe_phy_data *phy_data = pdata->phy_data;
269         struct axgbe_i2c_op i2c_op;
270         uint16_t *redrv_val;
271         u8 redrv_data[5], csum;
272         unsigned int i, retry;
273         int ret;
274
275         /* High byte of register contains read/write indicator */
276         redrv_data[0] = ((reg >> 8) & 0xff) << 1;
277         redrv_data[1] = reg & 0xff;
278         redrv_val = (uint16_t *)&redrv_data[2];
279         *redrv_val = rte_cpu_to_be_16(val);
280
281         /* Calculate 1 byte checksum */
282         csum = 0;
283         for (i = 0; i < 4; i++) {
284                 csum += redrv_data[i];
285                 if (redrv_data[i] > csum)
286                         csum++;
287         }
288         redrv_data[4] = ~csum;
289
290         retry = 1;
291 again1:
292         i2c_op.cmd = AXGBE_I2C_CMD_WRITE;
293         i2c_op.target = phy_data->redrv_addr;
294         i2c_op.len = sizeof(redrv_data);
295         i2c_op.buf = redrv_data;
296         ret = axgbe_phy_i2c_xfer(pdata, &i2c_op);
297         if (ret) {
298                 if ((ret == -EAGAIN) && retry--)
299                         goto again1;
300
301                 return ret;
302         }
303
304         retry = 1;
305 again2:
306         i2c_op.cmd = AXGBE_I2C_CMD_READ;
307         i2c_op.target = phy_data->redrv_addr;
308         i2c_op.len = 1;
309         i2c_op.buf = redrv_data;
310         ret = axgbe_phy_i2c_xfer(pdata, &i2c_op);
311         if (ret) {
312                 if ((ret == -EAGAIN) && retry--)
313                         goto again2;
314
315                 return ret;
316         }
317
318         if (redrv_data[0] != 0xff) {
319                 PMD_DRV_LOG(ERR, "Redriver write checksum error\n");
320                 ret = -EIO;
321         }
322
323         return ret;
324 }
325
326 static int axgbe_phy_i2c_read(struct axgbe_port *pdata, unsigned int target,
327                               void *reg, unsigned int reg_len,
328                               void *val, unsigned int val_len)
329 {
330         struct axgbe_i2c_op i2c_op;
331         int retry, ret;
332
333         retry = 1;
334 again1:
335         /* Set the specified register to read */
336         i2c_op.cmd = AXGBE_I2C_CMD_WRITE;
337         i2c_op.target = target;
338         i2c_op.len = reg_len;
339         i2c_op.buf = reg;
340         ret = axgbe_phy_i2c_xfer(pdata, &i2c_op);
341         if (ret) {
342                 if ((ret == -EAGAIN) && retry--)
343                         goto again1;
344
345                 return ret;
346         }
347
348         retry = 1;
349 again2:
350         /* Read the specfied register */
351         i2c_op.cmd = AXGBE_I2C_CMD_READ;
352         i2c_op.target = target;
353         i2c_op.len = val_len;
354         i2c_op.buf = val;
355         ret = axgbe_phy_i2c_xfer(pdata, &i2c_op);
356         if ((ret == -EAGAIN) && retry--)
357                 goto again2;
358
359         return ret;
360 }
361
362 static int axgbe_phy_sfp_put_mux(struct axgbe_port *pdata)
363 {
364         struct axgbe_phy_data *phy_data = pdata->phy_data;
365         struct axgbe_i2c_op i2c_op;
366         uint8_t mux_channel;
367
368         if (phy_data->sfp_comm == AXGBE_SFP_COMM_DIRECT)
369                 return 0;
370
371         /* Select no mux channels */
372         mux_channel = 0;
373         i2c_op.cmd = AXGBE_I2C_CMD_WRITE;
374         i2c_op.target = phy_data->sfp_mux_address;
375         i2c_op.len = sizeof(mux_channel);
376         i2c_op.buf = &mux_channel;
377
378         return axgbe_phy_i2c_xfer(pdata, &i2c_op);
379 }
380
381 static int axgbe_phy_sfp_get_mux(struct axgbe_port *pdata)
382 {
383         struct axgbe_phy_data *phy_data = pdata->phy_data;
384         struct axgbe_i2c_op i2c_op;
385         u8 mux_channel;
386
387         if (phy_data->sfp_comm == AXGBE_SFP_COMM_DIRECT)
388                 return 0;
389
390         /* Select desired mux channel */
391         mux_channel = 1 << phy_data->sfp_mux_channel;
392         i2c_op.cmd = AXGBE_I2C_CMD_WRITE;
393         i2c_op.target = phy_data->sfp_mux_address;
394         i2c_op.len = sizeof(mux_channel);
395         i2c_op.buf = &mux_channel;
396
397         return axgbe_phy_i2c_xfer(pdata, &i2c_op);
398 }
399
400 static void axgbe_phy_put_comm_ownership(struct axgbe_port *pdata)
401 {
402         struct axgbe_phy_data *phy_data = pdata->phy_data;
403
404         phy_data->comm_owned = 0;
405
406         pthread_mutex_unlock(&pdata->phy_mutex);
407 }
408
409 static int axgbe_phy_get_comm_ownership(struct axgbe_port *pdata)
410 {
411         struct axgbe_phy_data *phy_data = pdata->phy_data;
412         uint64_t timeout;
413         unsigned int mutex_id;
414
415         if (phy_data->comm_owned)
416                 return 0;
417
418         /* The I2C and MDIO/GPIO bus is multiplexed between multiple devices,
419          * the driver needs to take the software mutex and then the hardware
420          * mutexes before being able to use the busses.
421          */
422         pthread_mutex_lock(&pdata->phy_mutex);
423
424         /* Clear the mutexes */
425         XP_IOWRITE(pdata, XP_I2C_MUTEX, AXGBE_MUTEX_RELEASE);
426         XP_IOWRITE(pdata, XP_MDIO_MUTEX, AXGBE_MUTEX_RELEASE);
427
428         /* Mutex formats are the same for I2C and MDIO/GPIO */
429         mutex_id = 0;
430         XP_SET_BITS(mutex_id, XP_I2C_MUTEX, ID, phy_data->port_id);
431         XP_SET_BITS(mutex_id, XP_I2C_MUTEX, ACTIVE, 1);
432
433         timeout = rte_get_timer_cycles() + (rte_get_timer_hz() * 5);
434         while (time_before(rte_get_timer_cycles(), timeout)) {
435                 /* Must be all zeroes in order to obtain the mutex */
436                 if (XP_IOREAD(pdata, XP_I2C_MUTEX) ||
437                     XP_IOREAD(pdata, XP_MDIO_MUTEX)) {
438                         rte_delay_us(100);
439                         continue;
440                 }
441
442                 /* Obtain the mutex */
443                 XP_IOWRITE(pdata, XP_I2C_MUTEX, mutex_id);
444                 XP_IOWRITE(pdata, XP_MDIO_MUTEX, mutex_id);
445
446                 phy_data->comm_owned = 1;
447                 return 0;
448         }
449
450         pthread_mutex_unlock(&pdata->phy_mutex);
451
452         PMD_DRV_LOG(ERR, "unable to obtain hardware mutexes\n");
453
454         return -ETIMEDOUT;
455 }
456
457 static void axgbe_phy_sfp_phy_settings(struct axgbe_port *pdata)
458 {
459         struct axgbe_phy_data *phy_data = pdata->phy_data;
460
461         if (phy_data->sfp_mod_absent) {
462                 pdata->phy.speed = SPEED_UNKNOWN;
463                 pdata->phy.duplex = DUPLEX_UNKNOWN;
464                 pdata->phy.autoneg = AUTONEG_ENABLE;
465                 pdata->phy.advertising = pdata->phy.supported;
466         }
467
468         pdata->phy.advertising &= ~ADVERTISED_Autoneg;
469         pdata->phy.advertising &= ~ADVERTISED_TP;
470         pdata->phy.advertising &= ~ADVERTISED_FIBRE;
471         pdata->phy.advertising &= ~ADVERTISED_100baseT_Full;
472         pdata->phy.advertising &= ~ADVERTISED_1000baseT_Full;
473         pdata->phy.advertising &= ~ADVERTISED_10000baseT_Full;
474         pdata->phy.advertising &= ~ADVERTISED_10000baseR_FEC;
475
476         switch (phy_data->sfp_base) {
477         case AXGBE_SFP_BASE_1000_T:
478         case AXGBE_SFP_BASE_1000_SX:
479         case AXGBE_SFP_BASE_1000_LX:
480         case AXGBE_SFP_BASE_1000_CX:
481                 pdata->phy.speed = SPEED_UNKNOWN;
482                 pdata->phy.duplex = DUPLEX_UNKNOWN;
483                 pdata->phy.autoneg = AUTONEG_ENABLE;
484                 pdata->phy.advertising |= ADVERTISED_Autoneg;
485                 break;
486         case AXGBE_SFP_BASE_10000_SR:
487         case AXGBE_SFP_BASE_10000_LR:
488         case AXGBE_SFP_BASE_10000_LRM:
489         case AXGBE_SFP_BASE_10000_ER:
490         case AXGBE_SFP_BASE_10000_CR:
491         default:
492                 pdata->phy.speed = SPEED_10000;
493                 pdata->phy.duplex = DUPLEX_FULL;
494                 pdata->phy.autoneg = AUTONEG_DISABLE;
495                 break;
496         }
497
498         switch (phy_data->sfp_base) {
499         case AXGBE_SFP_BASE_1000_T:
500         case AXGBE_SFP_BASE_1000_CX:
501         case AXGBE_SFP_BASE_10000_CR:
502                 pdata->phy.advertising |= ADVERTISED_TP;
503                 break;
504         default:
505                 pdata->phy.advertising |= ADVERTISED_FIBRE;
506         }
507
508         switch (phy_data->sfp_speed) {
509         case AXGBE_SFP_SPEED_100_1000:
510                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100)
511                         pdata->phy.advertising |= ADVERTISED_100baseT_Full;
512                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000)
513                         pdata->phy.advertising |= ADVERTISED_1000baseT_Full;
514                 break;
515         case AXGBE_SFP_SPEED_1000:
516                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000)
517                         pdata->phy.advertising |= ADVERTISED_1000baseT_Full;
518                 break;
519         case AXGBE_SFP_SPEED_10000:
520                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000)
521                         pdata->phy.advertising |= ADVERTISED_10000baseT_Full;
522                 break;
523         default:
524                 /* Choose the fastest supported speed */
525                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000)
526                         pdata->phy.advertising |= ADVERTISED_10000baseT_Full;
527                 else if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000)
528                         pdata->phy.advertising |= ADVERTISED_1000baseT_Full;
529                 else if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100)
530                         pdata->phy.advertising |= ADVERTISED_100baseT_Full;
531         }
532 }
533
534 static bool axgbe_phy_sfp_bit_rate(struct axgbe_sfp_eeprom *sfp_eeprom,
535                                    enum axgbe_sfp_speed sfp_speed)
536 {
537         u8 *sfp_base, min, max;
538
539         sfp_base = sfp_eeprom->base;
540
541         switch (sfp_speed) {
542         case AXGBE_SFP_SPEED_1000:
543                 min = AXGBE_SFP_BASE_BR_1GBE_MIN;
544                 max = AXGBE_SFP_BASE_BR_1GBE_MAX;
545                 break;
546         case AXGBE_SFP_SPEED_10000:
547                 min = AXGBE_SFP_BASE_BR_10GBE_MIN;
548                 max = AXGBE_SFP_BASE_BR_10GBE_MAX;
549                 break;
550         default:
551                 return false;
552         }
553
554         return ((sfp_base[AXGBE_SFP_BASE_BR] >= min) &&
555                 (sfp_base[AXGBE_SFP_BASE_BR] <= max));
556 }
557
558 static void axgbe_phy_sfp_external_phy(struct axgbe_port *pdata)
559 {
560         struct axgbe_phy_data *phy_data = pdata->phy_data;
561
562         if (!phy_data->sfp_changed)
563                 return;
564
565         phy_data->sfp_phy_avail = 0;
566
567         if (phy_data->sfp_base != AXGBE_SFP_BASE_1000_T)
568                 return;
569 }
570
571 static bool axgbe_phy_belfuse_parse_quirks(struct axgbe_port *pdata)
572 {
573         struct axgbe_phy_data *phy_data = pdata->phy_data;
574         struct axgbe_sfp_eeprom *sfp_eeprom = &phy_data->sfp_eeprom;
575
576         if (memcmp(&sfp_eeprom->base[AXGBE_SFP_BASE_VENDOR_NAME],
577                    AXGBE_BEL_FUSE_VENDOR, strlen(AXGBE_BEL_FUSE_VENDOR)))
578                 return false;
579
580         if (!memcmp(&sfp_eeprom->base[AXGBE_SFP_BASE_VENDOR_PN],
581                     AXGBE_BEL_FUSE_PARTNO, strlen(AXGBE_BEL_FUSE_PARTNO))) {
582                 phy_data->sfp_base = AXGBE_SFP_BASE_1000_SX;
583                 phy_data->sfp_cable = AXGBE_SFP_CABLE_ACTIVE;
584                 phy_data->sfp_speed = AXGBE_SFP_SPEED_1000;
585                 return true;
586         }
587
588         return false;
589 }
590
591 static bool axgbe_phy_sfp_parse_quirks(struct axgbe_port *pdata)
592 {
593         if (axgbe_phy_belfuse_parse_quirks(pdata))
594                 return true;
595
596         return false;
597 }
598
599 static void axgbe_phy_sfp_parse_eeprom(struct axgbe_port *pdata)
600 {
601         struct axgbe_phy_data *phy_data = pdata->phy_data;
602         struct axgbe_sfp_eeprom *sfp_eeprom = &phy_data->sfp_eeprom;
603         uint8_t *sfp_base;
604
605         sfp_base = sfp_eeprom->base;
606
607         if (sfp_base[AXGBE_SFP_BASE_ID] != AXGBE_SFP_ID_SFP)
608                 return;
609
610         if (sfp_base[AXGBE_SFP_BASE_EXT_ID] != AXGBE_SFP_EXT_ID_SFP)
611                 return;
612
613         if (axgbe_phy_sfp_parse_quirks(pdata))
614                 return;
615
616         /* Assume ACTIVE cable unless told it is PASSIVE */
617         if (sfp_base[AXGBE_SFP_BASE_CABLE] & AXGBE_SFP_BASE_CABLE_PASSIVE) {
618                 phy_data->sfp_cable = AXGBE_SFP_CABLE_PASSIVE;
619                 phy_data->sfp_cable_len = sfp_base[AXGBE_SFP_BASE_CU_CABLE_LEN];
620         } else {
621                 phy_data->sfp_cable = AXGBE_SFP_CABLE_ACTIVE;
622         }
623
624         /* Determine the type of SFP */
625         if (sfp_base[AXGBE_SFP_BASE_10GBE_CC] & AXGBE_SFP_BASE_10GBE_CC_SR)
626                 phy_data->sfp_base = AXGBE_SFP_BASE_10000_SR;
627         else if (sfp_base[AXGBE_SFP_BASE_10GBE_CC] & AXGBE_SFP_BASE_10GBE_CC_LR)
628                 phy_data->sfp_base = AXGBE_SFP_BASE_10000_LR;
629         else if (sfp_base[AXGBE_SFP_BASE_10GBE_CC] &
630                  AXGBE_SFP_BASE_10GBE_CC_LRM)
631                 phy_data->sfp_base = AXGBE_SFP_BASE_10000_LRM;
632         else if (sfp_base[AXGBE_SFP_BASE_10GBE_CC] & AXGBE_SFP_BASE_10GBE_CC_ER)
633                 phy_data->sfp_base = AXGBE_SFP_BASE_10000_ER;
634         else if (sfp_base[AXGBE_SFP_BASE_1GBE_CC] & AXGBE_SFP_BASE_1GBE_CC_SX)
635                 phy_data->sfp_base = AXGBE_SFP_BASE_1000_SX;
636         else if (sfp_base[AXGBE_SFP_BASE_1GBE_CC] & AXGBE_SFP_BASE_1GBE_CC_LX)
637                 phy_data->sfp_base = AXGBE_SFP_BASE_1000_LX;
638         else if (sfp_base[AXGBE_SFP_BASE_1GBE_CC] & AXGBE_SFP_BASE_1GBE_CC_CX)
639                 phy_data->sfp_base = AXGBE_SFP_BASE_1000_CX;
640         else if (sfp_base[AXGBE_SFP_BASE_1GBE_CC] & AXGBE_SFP_BASE_1GBE_CC_T)
641                 phy_data->sfp_base = AXGBE_SFP_BASE_1000_T;
642         else if ((phy_data->sfp_cable == AXGBE_SFP_CABLE_PASSIVE) &&
643                  axgbe_phy_sfp_bit_rate(sfp_eeprom, AXGBE_SFP_SPEED_10000))
644                 phy_data->sfp_base = AXGBE_SFP_BASE_10000_CR;
645
646         switch (phy_data->sfp_base) {
647         case AXGBE_SFP_BASE_1000_T:
648                 phy_data->sfp_speed = AXGBE_SFP_SPEED_100_1000;
649                 break;
650         case AXGBE_SFP_BASE_1000_SX:
651         case AXGBE_SFP_BASE_1000_LX:
652         case AXGBE_SFP_BASE_1000_CX:
653                 phy_data->sfp_speed = AXGBE_SFP_SPEED_1000;
654                 break;
655         case AXGBE_SFP_BASE_10000_SR:
656         case AXGBE_SFP_BASE_10000_LR:
657         case AXGBE_SFP_BASE_10000_LRM:
658         case AXGBE_SFP_BASE_10000_ER:
659         case AXGBE_SFP_BASE_10000_CR:
660                 phy_data->sfp_speed = AXGBE_SFP_SPEED_10000;
661                 break;
662         default:
663                 break;
664         }
665 }
666
667 static bool axgbe_phy_sfp_verify_eeprom(uint8_t cc_in, uint8_t *buf,
668                                         unsigned int len)
669 {
670         uint8_t cc;
671
672         for (cc = 0; len; buf++, len--)
673                 cc += *buf;
674
675         return (cc == cc_in) ? true : false;
676 }
677
678 static int axgbe_phy_sfp_read_eeprom(struct axgbe_port *pdata)
679 {
680         struct axgbe_phy_data *phy_data = pdata->phy_data;
681         struct axgbe_sfp_eeprom sfp_eeprom;
682         uint8_t eeprom_addr;
683         int ret;
684
685         ret = axgbe_phy_sfp_get_mux(pdata);
686         if (ret) {
687                 PMD_DRV_LOG(ERR, "I2C error setting SFP MUX\n");
688                 return ret;
689         }
690
691         /* Read the SFP serial ID eeprom */
692         eeprom_addr = 0;
693         ret = axgbe_phy_i2c_read(pdata, AXGBE_SFP_SERIAL_ID_ADDRESS,
694                                  &eeprom_addr, sizeof(eeprom_addr),
695                                  &sfp_eeprom, sizeof(sfp_eeprom));
696         if (ret) {
697                 PMD_DRV_LOG(ERR, "I2C error reading SFP EEPROM\n");
698                 goto put;
699         }
700
701         /* Validate the contents read */
702         if (!axgbe_phy_sfp_verify_eeprom(sfp_eeprom.base[AXGBE_SFP_BASE_CC],
703                                          sfp_eeprom.base,
704                                          sizeof(sfp_eeprom.base) - 1)) {
705                 ret = -EINVAL;
706                 goto put;
707         }
708
709         if (!axgbe_phy_sfp_verify_eeprom(sfp_eeprom.extd[AXGBE_SFP_EXTD_CC],
710                                          sfp_eeprom.extd,
711                                          sizeof(sfp_eeprom.extd) - 1)) {
712                 ret = -EINVAL;
713                 goto put;
714         }
715
716         /* Check for an added or changed SFP */
717         if (memcmp(&phy_data->sfp_eeprom, &sfp_eeprom, sizeof(sfp_eeprom))) {
718                 phy_data->sfp_changed = 1;
719                 memcpy(&phy_data->sfp_eeprom, &sfp_eeprom, sizeof(sfp_eeprom));
720
721                 if (sfp_eeprom.extd[AXGBE_SFP_EXTD_SFF_8472]) {
722                         uint8_t diag_type;
723                         diag_type = sfp_eeprom.extd[AXGBE_SFP_EXTD_DIAG];
724
725                         if (!(diag_type & AXGBE_SFP_EXTD_DIAG_ADDR_CHANGE))
726                                 phy_data->sfp_diags = 1;
727                 }
728         } else {
729                 phy_data->sfp_changed = 0;
730         }
731
732 put:
733         axgbe_phy_sfp_put_mux(pdata);
734
735         return ret;
736 }
737
738 static void axgbe_phy_sfp_signals(struct axgbe_port *pdata)
739 {
740         struct axgbe_phy_data *phy_data = pdata->phy_data;
741         unsigned int gpio_input;
742         u8 gpio_reg, gpio_ports[2];
743         int ret;
744
745         /* Read the input port registers */
746         gpio_reg = 0;
747         ret = axgbe_phy_i2c_read(pdata, phy_data->sfp_gpio_address,
748                                  &gpio_reg, sizeof(gpio_reg),
749                                  gpio_ports, sizeof(gpio_ports));
750         if (ret) {
751                 PMD_DRV_LOG(ERR, "I2C error reading SFP GPIOs\n");
752                 return;
753         }
754
755         gpio_input = (gpio_ports[1] << 8) | gpio_ports[0];
756
757         if (phy_data->sfp_gpio_mask & AXGBE_GPIO_NO_MOD_ABSENT) {
758                 /* No GPIO, just assume the module is present for now */
759                 phy_data->sfp_mod_absent = 0;
760         } else {
761                 if (!(gpio_input & (1 << phy_data->sfp_gpio_mod_absent)))
762                         phy_data->sfp_mod_absent = 0;
763         }
764
765         if (!(phy_data->sfp_gpio_mask & AXGBE_GPIO_NO_RX_LOS) &&
766             (gpio_input & (1 << phy_data->sfp_gpio_rx_los)))
767                 phy_data->sfp_rx_los = 1;
768
769         if (!(phy_data->sfp_gpio_mask & AXGBE_GPIO_NO_TX_FAULT) &&
770             (gpio_input & (1 << phy_data->sfp_gpio_tx_fault)))
771                 phy_data->sfp_tx_fault = 1;
772 }
773
774 static void axgbe_phy_sfp_mod_absent(struct axgbe_port *pdata)
775 {
776         struct axgbe_phy_data *phy_data = pdata->phy_data;
777
778         phy_data->sfp_mod_absent = 1;
779         phy_data->sfp_phy_avail = 0;
780         memset(&phy_data->sfp_eeprom, 0, sizeof(phy_data->sfp_eeprom));
781 }
782
783 static void axgbe_phy_sfp_reset(struct axgbe_phy_data *phy_data)
784 {
785         phy_data->sfp_rx_los = 0;
786         phy_data->sfp_tx_fault = 0;
787         phy_data->sfp_mod_absent = 1;
788         phy_data->sfp_diags = 0;
789         phy_data->sfp_base = AXGBE_SFP_BASE_UNKNOWN;
790         phy_data->sfp_cable = AXGBE_SFP_CABLE_UNKNOWN;
791         phy_data->sfp_speed = AXGBE_SFP_SPEED_UNKNOWN;
792 }
793
794 static void axgbe_phy_sfp_detect(struct axgbe_port *pdata)
795 {
796         struct axgbe_phy_data *phy_data = pdata->phy_data;
797         int ret;
798
799         /* Reset the SFP signals and info */
800         axgbe_phy_sfp_reset(phy_data);
801
802         ret = axgbe_phy_get_comm_ownership(pdata);
803         if (ret)
804                 return;
805
806         /* Read the SFP signals and check for module presence */
807         axgbe_phy_sfp_signals(pdata);
808         if (phy_data->sfp_mod_absent) {
809                 axgbe_phy_sfp_mod_absent(pdata);
810                 goto put;
811         }
812
813         ret = axgbe_phy_sfp_read_eeprom(pdata);
814         if (ret) {
815                 /* Treat any error as if there isn't an SFP plugged in */
816                 axgbe_phy_sfp_reset(phy_data);
817                 axgbe_phy_sfp_mod_absent(pdata);
818                 goto put;
819         }
820
821         axgbe_phy_sfp_parse_eeprom(pdata);
822         axgbe_phy_sfp_external_phy(pdata);
823
824 put:
825         axgbe_phy_sfp_phy_settings(pdata);
826         axgbe_phy_put_comm_ownership(pdata);
827 }
828
829 static void axgbe_phy_phydev_flowctrl(struct axgbe_port *pdata)
830 {
831         pdata->phy.tx_pause = 0;
832         pdata->phy.rx_pause = 0;
833 }
834
835 static enum axgbe_mode axgbe_phy_an73_redrv_outcome(struct axgbe_port *pdata)
836 {
837         struct axgbe_phy_data *phy_data = pdata->phy_data;
838         enum axgbe_mode mode;
839         unsigned int ad_reg, lp_reg;
840
841         pdata->phy.lp_advertising |= ADVERTISED_Autoneg;
842         pdata->phy.lp_advertising |= ADVERTISED_Backplane;
843
844         /* Use external PHY to determine flow control */
845         if (pdata->phy.pause_autoneg)
846                 axgbe_phy_phydev_flowctrl(pdata);
847
848         /* Compare Advertisement and Link Partner register 2 */
849         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1);
850         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 1);
851         if (lp_reg & 0x80)
852                 pdata->phy.lp_advertising |= ADVERTISED_10000baseKR_Full;
853         if (lp_reg & 0x20)
854                 pdata->phy.lp_advertising |= ADVERTISED_1000baseKX_Full;
855
856         ad_reg &= lp_reg;
857         if (ad_reg & 0x80) {
858                 switch (phy_data->port_mode) {
859                 case AXGBE_PORT_MODE_BACKPLANE:
860                         mode = AXGBE_MODE_KR;
861                         break;
862                 default:
863                         mode = AXGBE_MODE_SFI;
864                         break;
865                 }
866         } else if (ad_reg & 0x20) {
867                 switch (phy_data->port_mode) {
868                 case AXGBE_PORT_MODE_BACKPLANE:
869                         mode = AXGBE_MODE_KX_1000;
870                         break;
871                 case AXGBE_PORT_MODE_1000BASE_X:
872                         mode = AXGBE_MODE_X;
873                         break;
874                 case AXGBE_PORT_MODE_SFP:
875                         switch (phy_data->sfp_base) {
876                         case AXGBE_SFP_BASE_1000_T:
877                                 mode = AXGBE_MODE_SGMII_1000;
878                                 break;
879                         case AXGBE_SFP_BASE_1000_SX:
880                         case AXGBE_SFP_BASE_1000_LX:
881                         case AXGBE_SFP_BASE_1000_CX:
882                         default:
883                                 mode = AXGBE_MODE_X;
884                                 break;
885                         }
886                         break;
887                 default:
888                         mode = AXGBE_MODE_SGMII_1000;
889                         break;
890                 }
891         } else {
892                 mode = AXGBE_MODE_UNKNOWN;
893         }
894
895         /* Compare Advertisement and Link Partner register 3 */
896         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
897         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 2);
898         if (lp_reg & 0xc000)
899                 pdata->phy.lp_advertising |= ADVERTISED_10000baseR_FEC;
900
901         return mode;
902 }
903
904 static enum axgbe_mode axgbe_phy_an73_outcome(struct axgbe_port *pdata)
905 {
906         enum axgbe_mode mode;
907         unsigned int ad_reg, lp_reg;
908
909         pdata->phy.lp_advertising |= ADVERTISED_Autoneg;
910         pdata->phy.lp_advertising |= ADVERTISED_Backplane;
911
912         /* Compare Advertisement and Link Partner register 1 */
913         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE);
914         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA);
915         if (lp_reg & 0x400)
916                 pdata->phy.lp_advertising |= ADVERTISED_Pause;
917         if (lp_reg & 0x800)
918                 pdata->phy.lp_advertising |= ADVERTISED_Asym_Pause;
919
920         if (pdata->phy.pause_autoneg) {
921                 /* Set flow control based on auto-negotiation result */
922                 pdata->phy.tx_pause = 0;
923                 pdata->phy.rx_pause = 0;
924
925                 if (ad_reg & lp_reg & 0x400) {
926                         pdata->phy.tx_pause = 1;
927                         pdata->phy.rx_pause = 1;
928                 } else if (ad_reg & lp_reg & 0x800) {
929                         if (ad_reg & 0x400)
930                                 pdata->phy.rx_pause = 1;
931                         else if (lp_reg & 0x400)
932                                 pdata->phy.tx_pause = 1;
933                 }
934         }
935
936         /* Compare Advertisement and Link Partner register 2 */
937         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1);
938         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 1);
939         if (lp_reg & 0x80)
940                 pdata->phy.lp_advertising |= ADVERTISED_10000baseKR_Full;
941         if (lp_reg & 0x20)
942                 pdata->phy.lp_advertising |= ADVERTISED_1000baseKX_Full;
943
944         ad_reg &= lp_reg;
945         if (ad_reg & 0x80)
946                 mode = AXGBE_MODE_KR;
947         else if (ad_reg & 0x20)
948                 mode = AXGBE_MODE_KX_1000;
949         else
950                 mode = AXGBE_MODE_UNKNOWN;
951
952         /* Compare Advertisement and Link Partner register 3 */
953         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
954         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 2);
955         if (lp_reg & 0xc000)
956                 pdata->phy.lp_advertising |= ADVERTISED_10000baseR_FEC;
957
958         return mode;
959 }
960
961 static enum axgbe_mode axgbe_phy_an_outcome(struct axgbe_port *pdata)
962 {
963         switch (pdata->an_mode) {
964         case AXGBE_AN_MODE_CL73:
965                 return axgbe_phy_an73_outcome(pdata);
966         case AXGBE_AN_MODE_CL73_REDRV:
967                 return axgbe_phy_an73_redrv_outcome(pdata);
968         case AXGBE_AN_MODE_CL37:
969         case AXGBE_AN_MODE_CL37_SGMII:
970         default:
971                 return AXGBE_MODE_UNKNOWN;
972         }
973 }
974
975 static unsigned int axgbe_phy_an_advertising(struct axgbe_port *pdata)
976 {
977         struct axgbe_phy_data *phy_data = pdata->phy_data;
978         unsigned int advertising;
979
980         /* Without a re-driver, just return current advertising */
981         if (!phy_data->redrv)
982                 return pdata->phy.advertising;
983
984         /* With the KR re-driver we need to advertise a single speed */
985         advertising = pdata->phy.advertising;
986         advertising &= ~ADVERTISED_1000baseKX_Full;
987         advertising &= ~ADVERTISED_10000baseKR_Full;
988
989         switch (phy_data->port_mode) {
990         case AXGBE_PORT_MODE_BACKPLANE:
991                 advertising |= ADVERTISED_10000baseKR_Full;
992                 break;
993         case AXGBE_PORT_MODE_BACKPLANE_2500:
994                 advertising |= ADVERTISED_1000baseKX_Full;
995                 break;
996         case AXGBE_PORT_MODE_1000BASE_T:
997         case AXGBE_PORT_MODE_1000BASE_X:
998         case AXGBE_PORT_MODE_NBASE_T:
999                 advertising |= ADVERTISED_1000baseKX_Full;
1000                 break;
1001         case AXGBE_PORT_MODE_10GBASE_T:
1002                 PMD_DRV_LOG(ERR, "10GBASE_T mode is not supported\n");
1003                 break;
1004         case AXGBE_PORT_MODE_10GBASE_R:
1005                 advertising |= ADVERTISED_10000baseKR_Full;
1006                 break;
1007         case AXGBE_PORT_MODE_SFP:
1008                 switch (phy_data->sfp_base) {
1009                 case AXGBE_SFP_BASE_1000_T:
1010                 case AXGBE_SFP_BASE_1000_SX:
1011                 case AXGBE_SFP_BASE_1000_LX:
1012                 case AXGBE_SFP_BASE_1000_CX:
1013                         advertising |= ADVERTISED_1000baseKX_Full;
1014                         break;
1015                 default:
1016                         advertising |= ADVERTISED_10000baseKR_Full;
1017                         break;
1018                 }
1019                 break;
1020         default:
1021                 advertising |= ADVERTISED_10000baseKR_Full;
1022                 break;
1023         }
1024
1025         return advertising;
1026 }
1027
1028 static int axgbe_phy_an_config(struct axgbe_port *pdata __rte_unused)
1029 {
1030         return 0;
1031         /* Dummy API since there is no case to support
1032          * external phy devices registred through kerenl apis
1033          */
1034 }
1035
1036 static enum axgbe_an_mode axgbe_phy_an_sfp_mode(struct axgbe_phy_data *phy_data)
1037 {
1038         switch (phy_data->sfp_base) {
1039         case AXGBE_SFP_BASE_1000_T:
1040                 return AXGBE_AN_MODE_CL37_SGMII;
1041         case AXGBE_SFP_BASE_1000_SX:
1042         case AXGBE_SFP_BASE_1000_LX:
1043         case AXGBE_SFP_BASE_1000_CX:
1044                 return AXGBE_AN_MODE_CL37;
1045         default:
1046                 return AXGBE_AN_MODE_NONE;
1047         }
1048 }
1049
1050 static enum axgbe_an_mode axgbe_phy_an_mode(struct axgbe_port *pdata)
1051 {
1052         struct axgbe_phy_data *phy_data = pdata->phy_data;
1053
1054         /* A KR re-driver will always require CL73 AN */
1055         if (phy_data->redrv)
1056                 return AXGBE_AN_MODE_CL73_REDRV;
1057
1058         switch (phy_data->port_mode) {
1059         case AXGBE_PORT_MODE_BACKPLANE:
1060                 return AXGBE_AN_MODE_CL73;
1061         case AXGBE_PORT_MODE_BACKPLANE_2500:
1062                 return AXGBE_AN_MODE_NONE;
1063         case AXGBE_PORT_MODE_1000BASE_T:
1064                 return AXGBE_AN_MODE_CL37_SGMII;
1065         case AXGBE_PORT_MODE_1000BASE_X:
1066                 return AXGBE_AN_MODE_CL37;
1067         case AXGBE_PORT_MODE_NBASE_T:
1068                 return AXGBE_AN_MODE_CL37_SGMII;
1069         case AXGBE_PORT_MODE_10GBASE_T:
1070                 return AXGBE_AN_MODE_CL73;
1071         case AXGBE_PORT_MODE_10GBASE_R:
1072                 return AXGBE_AN_MODE_NONE;
1073         case AXGBE_PORT_MODE_SFP:
1074                 return axgbe_phy_an_sfp_mode(phy_data);
1075         default:
1076                 return AXGBE_AN_MODE_NONE;
1077         }
1078 }
1079
1080 static int axgbe_phy_set_redrv_mode_mdio(struct axgbe_port *pdata,
1081                                          enum axgbe_phy_redrv_mode mode)
1082 {
1083         struct axgbe_phy_data *phy_data = pdata->phy_data;
1084         u16 redrv_reg, redrv_val;
1085
1086         redrv_reg = AXGBE_PHY_REDRV_MODE_REG + (phy_data->redrv_lane * 0x1000);
1087         redrv_val = (u16)mode;
1088
1089         return pdata->hw_if.write_ext_mii_regs(pdata, phy_data->redrv_addr,
1090                                                redrv_reg, redrv_val);
1091 }
1092
1093 static int axgbe_phy_set_redrv_mode_i2c(struct axgbe_port *pdata,
1094                                         enum axgbe_phy_redrv_mode mode)
1095 {
1096         struct axgbe_phy_data *phy_data = pdata->phy_data;
1097         unsigned int redrv_reg;
1098         int ret;
1099
1100         /* Calculate the register to write */
1101         redrv_reg = AXGBE_PHY_REDRV_MODE_REG + (phy_data->redrv_lane * 0x1000);
1102
1103         ret = axgbe_phy_redrv_write(pdata, redrv_reg, mode);
1104
1105         return ret;
1106 }
1107
1108 static void axgbe_phy_set_redrv_mode(struct axgbe_port *pdata)
1109 {
1110         struct axgbe_phy_data *phy_data = pdata->phy_data;
1111         enum axgbe_phy_redrv_mode mode;
1112         int ret;
1113
1114         if (!phy_data->redrv)
1115                 return;
1116
1117         mode = AXGBE_PHY_REDRV_MODE_CX;
1118         if ((phy_data->port_mode == AXGBE_PORT_MODE_SFP) &&
1119             (phy_data->sfp_base != AXGBE_SFP_BASE_1000_CX) &&
1120             (phy_data->sfp_base != AXGBE_SFP_BASE_10000_CR))
1121                 mode = AXGBE_PHY_REDRV_MODE_SR;
1122
1123         ret = axgbe_phy_get_comm_ownership(pdata);
1124         if (ret)
1125                 return;
1126
1127         if (phy_data->redrv_if)
1128                 axgbe_phy_set_redrv_mode_i2c(pdata, mode);
1129         else
1130                 axgbe_phy_set_redrv_mode_mdio(pdata, mode);
1131
1132         axgbe_phy_put_comm_ownership(pdata);
1133 }
1134
1135 static void axgbe_phy_start_ratechange(struct axgbe_port *pdata)
1136 {
1137         if (!XP_IOREAD_BITS(pdata, XP_DRIVER_INT_RO, STATUS))
1138                 return;
1139 }
1140
1141 static void axgbe_phy_complete_ratechange(struct axgbe_port *pdata)
1142 {
1143         unsigned int wait;
1144
1145         /* Wait for command to complete */
1146         wait = AXGBE_RATECHANGE_COUNT;
1147         while (wait--) {
1148                 if (!XP_IOREAD_BITS(pdata, XP_DRIVER_INT_RO, STATUS))
1149                         return;
1150
1151                 rte_delay_us(1500);
1152         }
1153 }
1154
1155 static void axgbe_phy_rrc(struct axgbe_port *pdata)
1156 {
1157         unsigned int s0;
1158
1159         axgbe_phy_start_ratechange(pdata);
1160
1161         /* Receiver Reset Cycle */
1162         s0 = 0;
1163         XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, 5);
1164         XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 0);
1165
1166         /* Call FW to make the change */
1167         XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, s0);
1168         XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0);
1169         XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1);
1170
1171         axgbe_phy_complete_ratechange(pdata);
1172 }
1173
1174 static void axgbe_phy_power_off(struct axgbe_port *pdata)
1175 {
1176         struct axgbe_phy_data *phy_data = pdata->phy_data;
1177
1178         axgbe_phy_start_ratechange(pdata);
1179
1180         /* Call FW to make the change */
1181         XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, 0);
1182         XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0);
1183         XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1);
1184         axgbe_phy_complete_ratechange(pdata);
1185         phy_data->cur_mode = AXGBE_MODE_UNKNOWN;
1186 }
1187
1188 static void axgbe_phy_sfi_mode(struct axgbe_port *pdata)
1189 {
1190         struct axgbe_phy_data *phy_data = pdata->phy_data;
1191         unsigned int s0;
1192
1193         axgbe_phy_set_redrv_mode(pdata);
1194
1195         axgbe_phy_start_ratechange(pdata);
1196
1197         /* 10G/SFI */
1198         s0 = 0;
1199         XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, 3);
1200         if (phy_data->sfp_cable != AXGBE_SFP_CABLE_PASSIVE) {
1201                 XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 0);
1202         } else {
1203                 if (phy_data->sfp_cable_len <= 1)
1204                         XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 1);
1205                 else if (phy_data->sfp_cable_len <= 3)
1206                         XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 2);
1207                 else
1208                         XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 3);
1209         }
1210
1211         /* Call FW to make the change */
1212         XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, s0);
1213         XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0);
1214         XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1);
1215         axgbe_phy_complete_ratechange(pdata);
1216         phy_data->cur_mode = AXGBE_MODE_SFI;
1217 }
1218
1219 static void axgbe_phy_kr_mode(struct axgbe_port *pdata)
1220 {
1221         struct axgbe_phy_data *phy_data = pdata->phy_data;
1222         unsigned int s0;
1223
1224         axgbe_phy_set_redrv_mode(pdata);
1225
1226         axgbe_phy_start_ratechange(pdata);
1227
1228         /* 10G/KR */
1229         s0 = 0;
1230         XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, 4);
1231         XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, 0);
1232
1233         /* Call FW to make the change */
1234         XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, s0);
1235         XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0);
1236         XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1);
1237         axgbe_phy_complete_ratechange(pdata);
1238         phy_data->cur_mode = AXGBE_MODE_KR;
1239 }
1240
1241 static enum axgbe_mode axgbe_phy_cur_mode(struct axgbe_port *pdata)
1242 {
1243         struct axgbe_phy_data *phy_data = pdata->phy_data;
1244
1245         return phy_data->cur_mode;
1246 }
1247
1248 static enum axgbe_mode axgbe_phy_switch_baset_mode(struct axgbe_port *pdata)
1249 {
1250         struct axgbe_phy_data *phy_data = pdata->phy_data;
1251
1252         /* No switching if not 10GBase-T */
1253         if (phy_data->port_mode != AXGBE_PORT_MODE_10GBASE_T)
1254                 return axgbe_phy_cur_mode(pdata);
1255
1256         switch (axgbe_phy_cur_mode(pdata)) {
1257         case AXGBE_MODE_SGMII_100:
1258         case AXGBE_MODE_SGMII_1000:
1259                 return AXGBE_MODE_KR;
1260         case AXGBE_MODE_KR:
1261         default:
1262                 return AXGBE_MODE_SGMII_1000;
1263         }
1264 }
1265
1266 static enum axgbe_mode axgbe_phy_switch_bp_2500_mode(struct axgbe_port *pdata
1267                                                      __rte_unused)
1268 {
1269         return AXGBE_MODE_KX_2500;
1270 }
1271
1272 static enum axgbe_mode axgbe_phy_switch_bp_mode(struct axgbe_port *pdata)
1273 {
1274         /* If we are in KR switch to KX, and vice-versa */
1275         switch (axgbe_phy_cur_mode(pdata)) {
1276         case AXGBE_MODE_KX_1000:
1277                 return AXGBE_MODE_KR;
1278         case AXGBE_MODE_KR:
1279         default:
1280                 return AXGBE_MODE_KX_1000;
1281         }
1282 }
1283
1284 static enum axgbe_mode axgbe_phy_switch_mode(struct axgbe_port *pdata)
1285 {
1286         struct axgbe_phy_data *phy_data = pdata->phy_data;
1287
1288         switch (phy_data->port_mode) {
1289         case AXGBE_PORT_MODE_BACKPLANE:
1290                 return axgbe_phy_switch_bp_mode(pdata);
1291         case AXGBE_PORT_MODE_BACKPLANE_2500:
1292                 return axgbe_phy_switch_bp_2500_mode(pdata);
1293         case AXGBE_PORT_MODE_1000BASE_T:
1294         case AXGBE_PORT_MODE_NBASE_T:
1295         case AXGBE_PORT_MODE_10GBASE_T:
1296                 return axgbe_phy_switch_baset_mode(pdata);
1297         case AXGBE_PORT_MODE_1000BASE_X:
1298         case AXGBE_PORT_MODE_10GBASE_R:
1299         case AXGBE_PORT_MODE_SFP:
1300                 /* No switching, so just return current mode */
1301                 return axgbe_phy_cur_mode(pdata);
1302         default:
1303                 return AXGBE_MODE_UNKNOWN;
1304         }
1305 }
1306
1307 static enum axgbe_mode axgbe_phy_get_basex_mode(struct axgbe_phy_data *phy_data
1308                                                 __rte_unused,
1309                                                 int speed)
1310 {
1311         switch (speed) {
1312         case SPEED_1000:
1313                 return AXGBE_MODE_X;
1314         case SPEED_10000:
1315                 return AXGBE_MODE_KR;
1316         default:
1317                 return AXGBE_MODE_UNKNOWN;
1318         }
1319 }
1320
1321 static enum axgbe_mode axgbe_phy_get_baset_mode(struct axgbe_phy_data *phy_data
1322                                                 __rte_unused,
1323                                                 int speed)
1324 {
1325         switch (speed) {
1326         case SPEED_100:
1327                 return AXGBE_MODE_SGMII_100;
1328         case SPEED_1000:
1329                 return AXGBE_MODE_SGMII_1000;
1330         case SPEED_10000:
1331                 return AXGBE_MODE_KR;
1332         default:
1333                 return AXGBE_MODE_UNKNOWN;
1334         }
1335 }
1336
1337 static enum axgbe_mode axgbe_phy_get_sfp_mode(struct axgbe_phy_data *phy_data,
1338                                               int speed)
1339 {
1340         switch (speed) {
1341         case SPEED_100:
1342                 return AXGBE_MODE_SGMII_100;
1343         case SPEED_1000:
1344                 if (phy_data->sfp_base == AXGBE_SFP_BASE_1000_T)
1345                         return AXGBE_MODE_SGMII_1000;
1346                 else
1347                         return AXGBE_MODE_X;
1348         case SPEED_10000:
1349         case SPEED_UNKNOWN:
1350                 return AXGBE_MODE_SFI;
1351         default:
1352                 return AXGBE_MODE_UNKNOWN;
1353         }
1354 }
1355
1356 static enum axgbe_mode axgbe_phy_get_bp_2500_mode(int speed)
1357 {
1358         switch (speed) {
1359         case SPEED_2500:
1360                 return AXGBE_MODE_KX_2500;
1361         default:
1362                 return AXGBE_MODE_UNKNOWN;
1363         }
1364 }
1365
1366 static enum axgbe_mode axgbe_phy_get_bp_mode(int speed)
1367 {
1368         switch (speed) {
1369         case SPEED_1000:
1370                 return AXGBE_MODE_KX_1000;
1371         case SPEED_10000:
1372                 return AXGBE_MODE_KR;
1373         default:
1374                 return AXGBE_MODE_UNKNOWN;
1375         }
1376 }
1377
1378 static enum axgbe_mode axgbe_phy_get_mode(struct axgbe_port *pdata,
1379                                           int speed)
1380 {
1381         struct axgbe_phy_data *phy_data = pdata->phy_data;
1382
1383         switch (phy_data->port_mode) {
1384         case AXGBE_PORT_MODE_BACKPLANE:
1385                 return axgbe_phy_get_bp_mode(speed);
1386         case AXGBE_PORT_MODE_BACKPLANE_2500:
1387                 return axgbe_phy_get_bp_2500_mode(speed);
1388         case AXGBE_PORT_MODE_1000BASE_T:
1389         case AXGBE_PORT_MODE_NBASE_T:
1390         case AXGBE_PORT_MODE_10GBASE_T:
1391                 return axgbe_phy_get_baset_mode(phy_data, speed);
1392         case AXGBE_PORT_MODE_1000BASE_X:
1393         case AXGBE_PORT_MODE_10GBASE_R:
1394                 return axgbe_phy_get_basex_mode(phy_data, speed);
1395         case AXGBE_PORT_MODE_SFP:
1396                 return axgbe_phy_get_sfp_mode(phy_data, speed);
1397         default:
1398                 return AXGBE_MODE_UNKNOWN;
1399         }
1400 }
1401
1402 static void axgbe_phy_set_mode(struct axgbe_port *pdata, enum axgbe_mode mode)
1403 {
1404         switch (mode) {
1405         case AXGBE_MODE_KR:
1406                 axgbe_phy_kr_mode(pdata);
1407                 break;
1408         case AXGBE_MODE_SFI:
1409                 axgbe_phy_sfi_mode(pdata);
1410                 break;
1411         default:
1412                 break;
1413         }
1414 }
1415
1416 static bool axgbe_phy_check_mode(struct axgbe_port *pdata,
1417                                  enum axgbe_mode mode, u32 advert)
1418 {
1419         if (pdata->phy.autoneg == AUTONEG_ENABLE) {
1420                 if (pdata->phy.advertising & advert)
1421                         return true;
1422         } else {
1423                 enum axgbe_mode cur_mode;
1424
1425                 cur_mode = axgbe_phy_get_mode(pdata, pdata->phy.speed);
1426                 if (cur_mode == mode)
1427                         return true;
1428         }
1429
1430         return false;
1431 }
1432
1433 static bool axgbe_phy_use_basex_mode(struct axgbe_port *pdata,
1434                                      enum axgbe_mode mode)
1435 {
1436         switch (mode) {
1437         case AXGBE_MODE_X:
1438                 return axgbe_phy_check_mode(pdata, mode,
1439                                             ADVERTISED_1000baseT_Full);
1440         case AXGBE_MODE_KR:
1441                 return axgbe_phy_check_mode(pdata, mode,
1442                                             ADVERTISED_10000baseT_Full);
1443         default:
1444                 return false;
1445         }
1446 }
1447
1448 static bool axgbe_phy_use_baset_mode(struct axgbe_port *pdata,
1449                                      enum axgbe_mode mode)
1450 {
1451         switch (mode) {
1452         case AXGBE_MODE_SGMII_100:
1453                 return axgbe_phy_check_mode(pdata, mode,
1454                                             ADVERTISED_100baseT_Full);
1455         case AXGBE_MODE_SGMII_1000:
1456                 return axgbe_phy_check_mode(pdata, mode,
1457                                             ADVERTISED_1000baseT_Full);
1458         case AXGBE_MODE_KR:
1459                 return axgbe_phy_check_mode(pdata, mode,
1460                                             ADVERTISED_10000baseT_Full);
1461         default:
1462                 return false;
1463         }
1464 }
1465
1466 static bool axgbe_phy_use_sfp_mode(struct axgbe_port *pdata,
1467                                    enum axgbe_mode mode)
1468 {
1469         struct axgbe_phy_data *phy_data = pdata->phy_data;
1470
1471         switch (mode) {
1472         case AXGBE_MODE_X:
1473                 if (phy_data->sfp_base == AXGBE_SFP_BASE_1000_T)
1474                         return false;
1475                 return axgbe_phy_check_mode(pdata, mode,
1476                                             ADVERTISED_1000baseT_Full);
1477         case AXGBE_MODE_SGMII_100:
1478                 if (phy_data->sfp_base != AXGBE_SFP_BASE_1000_T)
1479                         return false;
1480                 return axgbe_phy_check_mode(pdata, mode,
1481                                             ADVERTISED_100baseT_Full);
1482         case AXGBE_MODE_SGMII_1000:
1483                 if (phy_data->sfp_base != AXGBE_SFP_BASE_1000_T)
1484                         return false;
1485                 return axgbe_phy_check_mode(pdata, mode,
1486                                             ADVERTISED_1000baseT_Full);
1487         case AXGBE_MODE_SFI:
1488                 return axgbe_phy_check_mode(pdata, mode,
1489                                             ADVERTISED_10000baseT_Full);
1490         default:
1491                 return false;
1492         }
1493 }
1494
1495 static bool axgbe_phy_use_bp_2500_mode(struct axgbe_port *pdata,
1496                                        enum axgbe_mode mode)
1497 {
1498         switch (mode) {
1499         case AXGBE_MODE_KX_2500:
1500                 return axgbe_phy_check_mode(pdata, mode,
1501                                             ADVERTISED_2500baseX_Full);
1502         default:
1503                 return false;
1504         }
1505 }
1506
1507 static bool axgbe_phy_use_bp_mode(struct axgbe_port *pdata,
1508                                   enum axgbe_mode mode)
1509 {
1510         switch (mode) {
1511         case AXGBE_MODE_KX_1000:
1512                 return axgbe_phy_check_mode(pdata, mode,
1513                                             ADVERTISED_1000baseKX_Full);
1514         case AXGBE_MODE_KR:
1515                 return axgbe_phy_check_mode(pdata, mode,
1516                                             ADVERTISED_10000baseKR_Full);
1517         default:
1518                 return false;
1519         }
1520 }
1521
1522 static bool axgbe_phy_use_mode(struct axgbe_port *pdata, enum axgbe_mode mode)
1523 {
1524         struct axgbe_phy_data *phy_data = pdata->phy_data;
1525
1526         switch (phy_data->port_mode) {
1527         case AXGBE_PORT_MODE_BACKPLANE:
1528                 return axgbe_phy_use_bp_mode(pdata, mode);
1529         case AXGBE_PORT_MODE_BACKPLANE_2500:
1530                 return axgbe_phy_use_bp_2500_mode(pdata, mode);
1531         case AXGBE_PORT_MODE_1000BASE_T:
1532         case AXGBE_PORT_MODE_NBASE_T:
1533         case AXGBE_PORT_MODE_10GBASE_T:
1534                 return axgbe_phy_use_baset_mode(pdata, mode);
1535         case AXGBE_PORT_MODE_1000BASE_X:
1536         case AXGBE_PORT_MODE_10GBASE_R:
1537                 return axgbe_phy_use_basex_mode(pdata, mode);
1538         case AXGBE_PORT_MODE_SFP:
1539                 return axgbe_phy_use_sfp_mode(pdata, mode);
1540         default:
1541                 return false;
1542         }
1543 }
1544
1545 static int axgbe_phy_link_status(struct axgbe_port *pdata, int *an_restart)
1546 {
1547         struct axgbe_phy_data *phy_data = pdata->phy_data;
1548         unsigned int reg;
1549
1550         *an_restart = 0;
1551
1552         if (phy_data->port_mode == AXGBE_PORT_MODE_SFP) {
1553                 /* Check SFP signals */
1554                 axgbe_phy_sfp_detect(pdata);
1555
1556                 if (phy_data->sfp_changed) {
1557                         *an_restart = 1;
1558                         return 0;
1559                 }
1560
1561                 if (phy_data->sfp_mod_absent || phy_data->sfp_rx_los)
1562                         return 0;
1563         }
1564
1565         /* Link status is latched low, so read once to clear
1566          * and then read again to get current state
1567          */
1568         reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_STAT1);
1569         reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_STAT1);
1570         if (reg & MDIO_STAT1_LSTATUS)
1571                 return 1;
1572
1573         /* No link, attempt a receiver reset cycle */
1574         if (phy_data->rrc_count++) {
1575                 phy_data->rrc_count = 0;
1576                 axgbe_phy_rrc(pdata);
1577         }
1578
1579         return 0;
1580 }
1581
1582 static void axgbe_phy_sfp_gpio_setup(struct axgbe_port *pdata)
1583 {
1584         struct axgbe_phy_data *phy_data = pdata->phy_data;
1585         unsigned int reg;
1586
1587         reg = XP_IOREAD(pdata, XP_PROP_3);
1588
1589         phy_data->sfp_gpio_address = AXGBE_GPIO_ADDRESS_PCA9555 +
1590                 XP_GET_BITS(reg, XP_PROP_3, GPIO_ADDR);
1591
1592         phy_data->sfp_gpio_mask = XP_GET_BITS(reg, XP_PROP_3, GPIO_MASK);
1593
1594         phy_data->sfp_gpio_rx_los = XP_GET_BITS(reg, XP_PROP_3,
1595                                                 GPIO_RX_LOS);
1596         phy_data->sfp_gpio_tx_fault = XP_GET_BITS(reg, XP_PROP_3,
1597                                                   GPIO_TX_FAULT);
1598         phy_data->sfp_gpio_mod_absent = XP_GET_BITS(reg, XP_PROP_3,
1599                                                     GPIO_MOD_ABS);
1600         phy_data->sfp_gpio_rate_select = XP_GET_BITS(reg, XP_PROP_3,
1601                                                      GPIO_RATE_SELECT);
1602 }
1603
1604 static void axgbe_phy_sfp_comm_setup(struct axgbe_port *pdata)
1605 {
1606         struct axgbe_phy_data *phy_data = pdata->phy_data;
1607         unsigned int reg, mux_addr_hi, mux_addr_lo;
1608
1609         reg = XP_IOREAD(pdata, XP_PROP_4);
1610
1611         mux_addr_hi = XP_GET_BITS(reg, XP_PROP_4, MUX_ADDR_HI);
1612         mux_addr_lo = XP_GET_BITS(reg, XP_PROP_4, MUX_ADDR_LO);
1613         if (mux_addr_lo == AXGBE_SFP_DIRECT)
1614                 return;
1615
1616         phy_data->sfp_comm = AXGBE_SFP_COMM_PCA9545;
1617         phy_data->sfp_mux_address = (mux_addr_hi << 2) + mux_addr_lo;
1618         phy_data->sfp_mux_channel = XP_GET_BITS(reg, XP_PROP_4, MUX_CHAN);
1619 }
1620
1621 static void axgbe_phy_sfp_setup(struct axgbe_port *pdata)
1622 {
1623         axgbe_phy_sfp_comm_setup(pdata);
1624         axgbe_phy_sfp_gpio_setup(pdata);
1625 }
1626
1627 static bool axgbe_phy_redrv_error(struct axgbe_phy_data *phy_data)
1628 {
1629         if (!phy_data->redrv)
1630                 return false;
1631
1632         if (phy_data->redrv_if >= AXGBE_PHY_REDRV_IF_MAX)
1633                 return true;
1634
1635         switch (phy_data->redrv_model) {
1636         case AXGBE_PHY_REDRV_MODEL_4223:
1637                 if (phy_data->redrv_lane > 3)
1638                         return true;
1639                 break;
1640         case AXGBE_PHY_REDRV_MODEL_4227:
1641                 if (phy_data->redrv_lane > 1)
1642                         return true;
1643                 break;
1644         default:
1645                 return true;
1646         }
1647
1648         return false;
1649 }
1650
1651 static int axgbe_phy_mdio_reset_setup(struct axgbe_port *pdata)
1652 {
1653         struct axgbe_phy_data *phy_data = pdata->phy_data;
1654         unsigned int reg;
1655
1656         if (phy_data->conn_type != AXGBE_CONN_TYPE_MDIO)
1657                 return 0;
1658         reg = XP_IOREAD(pdata, XP_PROP_3);
1659         phy_data->mdio_reset = XP_GET_BITS(reg, XP_PROP_3, MDIO_RESET);
1660         switch (phy_data->mdio_reset) {
1661         case AXGBE_MDIO_RESET_NONE:
1662         case AXGBE_MDIO_RESET_I2C_GPIO:
1663         case AXGBE_MDIO_RESET_INT_GPIO:
1664                 break;
1665         default:
1666                 PMD_DRV_LOG(ERR, "unsupported MDIO reset (%#x)\n",
1667                             phy_data->mdio_reset);
1668                 return -EINVAL;
1669         }
1670         if (phy_data->mdio_reset == AXGBE_MDIO_RESET_I2C_GPIO) {
1671                 phy_data->mdio_reset_addr = AXGBE_GPIO_ADDRESS_PCA9555 +
1672                         XP_GET_BITS(reg, XP_PROP_3,
1673                                     MDIO_RESET_I2C_ADDR);
1674                 phy_data->mdio_reset_gpio = XP_GET_BITS(reg, XP_PROP_3,
1675                                                         MDIO_RESET_I2C_GPIO);
1676         } else if (phy_data->mdio_reset == AXGBE_MDIO_RESET_INT_GPIO) {
1677                 phy_data->mdio_reset_gpio = XP_GET_BITS(reg, XP_PROP_3,
1678                                                         MDIO_RESET_INT_GPIO);
1679         }
1680
1681         return 0;
1682 }
1683
1684 static bool axgbe_phy_port_mode_mismatch(struct axgbe_port *pdata)
1685 {
1686         struct axgbe_phy_data *phy_data = pdata->phy_data;
1687
1688         switch (phy_data->port_mode) {
1689         case AXGBE_PORT_MODE_BACKPLANE:
1690                 if ((phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) ||
1691                     (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000))
1692                         return false;
1693                 break;
1694         case AXGBE_PORT_MODE_BACKPLANE_2500:
1695                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_2500)
1696                         return false;
1697                 break;
1698         case AXGBE_PORT_MODE_1000BASE_T:
1699                 if ((phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) ||
1700                     (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000))
1701                         return false;
1702                 break;
1703         case AXGBE_PORT_MODE_1000BASE_X:
1704                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000)
1705                         return false;
1706                 break;
1707         case AXGBE_PORT_MODE_NBASE_T:
1708                 if ((phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) ||
1709                     (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) ||
1710                     (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_2500))
1711                         return false;
1712                 break;
1713         case AXGBE_PORT_MODE_10GBASE_T:
1714                 if ((phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) ||
1715                     (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) ||
1716                     (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000))
1717                         return false;
1718                 break;
1719         case AXGBE_PORT_MODE_10GBASE_R:
1720                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000)
1721                         return false;
1722                 break;
1723         case AXGBE_PORT_MODE_SFP:
1724                 if ((phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) ||
1725                     (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) ||
1726                     (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000))
1727                         return false;
1728                 break;
1729         default:
1730                 break;
1731         }
1732
1733         return true;
1734 }
1735
1736 static bool axgbe_phy_conn_type_mismatch(struct axgbe_port *pdata)
1737 {
1738         struct axgbe_phy_data *phy_data = pdata->phy_data;
1739
1740         switch (phy_data->port_mode) {
1741         case AXGBE_PORT_MODE_BACKPLANE:
1742         case AXGBE_PORT_MODE_BACKPLANE_2500:
1743                 if (phy_data->conn_type == AXGBE_CONN_TYPE_BACKPLANE)
1744                         return false;
1745                 break;
1746         case AXGBE_PORT_MODE_1000BASE_T:
1747         case AXGBE_PORT_MODE_1000BASE_X:
1748         case AXGBE_PORT_MODE_NBASE_T:
1749         case AXGBE_PORT_MODE_10GBASE_T:
1750         case AXGBE_PORT_MODE_10GBASE_R:
1751                 if (phy_data->conn_type == AXGBE_CONN_TYPE_MDIO)
1752                         return false;
1753                 break;
1754         case AXGBE_PORT_MODE_SFP:
1755                 if (phy_data->conn_type == AXGBE_CONN_TYPE_SFP)
1756                         return false;
1757                 break;
1758         default:
1759                 break;
1760         }
1761
1762         return true;
1763 }
1764
1765 static bool axgbe_phy_port_enabled(struct axgbe_port *pdata)
1766 {
1767         unsigned int reg;
1768
1769         reg = XP_IOREAD(pdata, XP_PROP_0);
1770         if (!XP_GET_BITS(reg, XP_PROP_0, PORT_SPEEDS))
1771                 return false;
1772         if (!XP_GET_BITS(reg, XP_PROP_0, CONN_TYPE))
1773                 return false;
1774
1775         return true;
1776 }
1777
1778 static void axgbe_phy_cdr_track(struct axgbe_port *pdata)
1779 {
1780         struct axgbe_phy_data *phy_data = pdata->phy_data;
1781
1782         if (!pdata->vdata->an_cdr_workaround)
1783                 return;
1784
1785         if (!phy_data->phy_cdr_notrack)
1786                 return;
1787
1788         rte_delay_us(phy_data->phy_cdr_delay + 400);
1789
1790         XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_VEND2_PMA_CDR_CONTROL,
1791                          AXGBE_PMA_CDR_TRACK_EN_MASK,
1792                          AXGBE_PMA_CDR_TRACK_EN_ON);
1793
1794         phy_data->phy_cdr_notrack = 0;
1795 }
1796
1797 static void axgbe_phy_cdr_notrack(struct axgbe_port *pdata)
1798 {
1799         struct axgbe_phy_data *phy_data = pdata->phy_data;
1800
1801         if (!pdata->vdata->an_cdr_workaround)
1802                 return;
1803
1804         if (phy_data->phy_cdr_notrack)
1805                 return;
1806
1807         XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_VEND2_PMA_CDR_CONTROL,
1808                          AXGBE_PMA_CDR_TRACK_EN_MASK,
1809                          AXGBE_PMA_CDR_TRACK_EN_OFF);
1810
1811         axgbe_phy_rrc(pdata);
1812
1813         phy_data->phy_cdr_notrack = 1;
1814 }
1815
1816 static void axgbe_phy_kr_training_post(struct axgbe_port *pdata)
1817 {
1818         if (!pdata->cdr_track_early)
1819                 axgbe_phy_cdr_track(pdata);
1820 }
1821
1822 static void axgbe_phy_kr_training_pre(struct axgbe_port *pdata)
1823 {
1824         if (pdata->cdr_track_early)
1825                 axgbe_phy_cdr_track(pdata);
1826 }
1827
1828 static void axgbe_phy_an_post(struct axgbe_port *pdata)
1829 {
1830         struct axgbe_phy_data *phy_data = pdata->phy_data;
1831
1832         switch (pdata->an_mode) {
1833         case AXGBE_AN_MODE_CL73:
1834         case AXGBE_AN_MODE_CL73_REDRV:
1835                 if (phy_data->cur_mode != AXGBE_MODE_KR)
1836                         break;
1837
1838                 axgbe_phy_cdr_track(pdata);
1839
1840                 switch (pdata->an_result) {
1841                 case AXGBE_AN_READY:
1842                 case AXGBE_AN_COMPLETE:
1843                         break;
1844                 default:
1845                         if (phy_data->phy_cdr_delay < AXGBE_CDR_DELAY_MAX)
1846                                 phy_data->phy_cdr_delay += AXGBE_CDR_DELAY_INC;
1847                         break;
1848                 }
1849                 break;
1850         default:
1851                 break;
1852         }
1853 }
1854
1855 static void axgbe_phy_an_pre(struct axgbe_port *pdata)
1856 {
1857         struct axgbe_phy_data *phy_data = pdata->phy_data;
1858
1859         switch (pdata->an_mode) {
1860         case AXGBE_AN_MODE_CL73:
1861         case AXGBE_AN_MODE_CL73_REDRV:
1862                 if (phy_data->cur_mode != AXGBE_MODE_KR)
1863                         break;
1864
1865                 axgbe_phy_cdr_notrack(pdata);
1866                 break;
1867         default:
1868                 break;
1869         }
1870 }
1871
1872 static void axgbe_phy_stop(struct axgbe_port *pdata)
1873 {
1874         struct axgbe_phy_data *phy_data = pdata->phy_data;
1875
1876         /* Reset SFP data */
1877         axgbe_phy_sfp_reset(phy_data);
1878         axgbe_phy_sfp_mod_absent(pdata);
1879
1880         /* Reset CDR support */
1881         axgbe_phy_cdr_track(pdata);
1882
1883         /* Power off the PHY */
1884         axgbe_phy_power_off(pdata);
1885
1886         /* Stop the I2C controller */
1887         pdata->i2c_if.i2c_stop(pdata);
1888 }
1889
1890 static int axgbe_phy_start(struct axgbe_port *pdata)
1891 {
1892         struct axgbe_phy_data *phy_data = pdata->phy_data;
1893         int ret;
1894
1895         /* Start the I2C controller */
1896         ret = pdata->i2c_if.i2c_start(pdata);
1897         if (ret)
1898                 return ret;
1899
1900         /* Start in highest supported mode */
1901         axgbe_phy_set_mode(pdata, phy_data->start_mode);
1902
1903         /* Reset CDR support */
1904         axgbe_phy_cdr_track(pdata);
1905
1906         /* After starting the I2C controller, we can check for an SFP */
1907         switch (phy_data->port_mode) {
1908         case AXGBE_PORT_MODE_SFP:
1909                 axgbe_phy_sfp_detect(pdata);
1910                 break;
1911         default:
1912                 break;
1913         }
1914
1915         return ret;
1916 }
1917
1918 static int axgbe_phy_reset(struct axgbe_port *pdata)
1919 {
1920         struct axgbe_phy_data *phy_data = pdata->phy_data;
1921         enum axgbe_mode cur_mode;
1922
1923         /* Reset by power cycling the PHY */
1924         cur_mode = phy_data->cur_mode;
1925         axgbe_phy_power_off(pdata);
1926         /* First time reset is done with passed unknown mode*/
1927         axgbe_phy_set_mode(pdata, cur_mode);
1928         return 0;
1929 }
1930
1931 static int axgbe_phy_init(struct axgbe_port *pdata)
1932 {
1933         struct axgbe_phy_data *phy_data;
1934         unsigned int reg;
1935         int ret;
1936
1937         /* Check if enabled */
1938         if (!axgbe_phy_port_enabled(pdata)) {
1939                 PMD_DRV_LOG(ERR, "device is not enabled\n");
1940                 return -ENODEV;
1941         }
1942
1943         /* Initialize the I2C controller */
1944         ret = pdata->i2c_if.i2c_init(pdata);
1945         if (ret)
1946                 return ret;
1947
1948         phy_data = rte_zmalloc("phy_data memory", sizeof(*phy_data), 0);
1949         if (!phy_data) {
1950                 PMD_DRV_LOG(ERR, "phy_data allocation failed\n");
1951                 return -ENOMEM;
1952         }
1953         pdata->phy_data = phy_data;
1954
1955         reg = XP_IOREAD(pdata, XP_PROP_0);
1956         phy_data->port_mode = XP_GET_BITS(reg, XP_PROP_0, PORT_MODE);
1957         phy_data->port_id = XP_GET_BITS(reg, XP_PROP_0, PORT_ID);
1958         phy_data->port_speeds = XP_GET_BITS(reg, XP_PROP_0, PORT_SPEEDS);
1959         phy_data->conn_type = XP_GET_BITS(reg, XP_PROP_0, CONN_TYPE);
1960         phy_data->mdio_addr = XP_GET_BITS(reg, XP_PROP_0, MDIO_ADDR);
1961
1962         reg = XP_IOREAD(pdata, XP_PROP_4);
1963         phy_data->redrv = XP_GET_BITS(reg, XP_PROP_4, REDRV_PRESENT);
1964         phy_data->redrv_if = XP_GET_BITS(reg, XP_PROP_4, REDRV_IF);
1965         phy_data->redrv_addr = XP_GET_BITS(reg, XP_PROP_4, REDRV_ADDR);
1966         phy_data->redrv_lane = XP_GET_BITS(reg, XP_PROP_4, REDRV_LANE);
1967         phy_data->redrv_model = XP_GET_BITS(reg, XP_PROP_4, REDRV_MODEL);
1968
1969         /* Validate the connection requested */
1970         if (axgbe_phy_conn_type_mismatch(pdata)) {
1971                 PMD_DRV_LOG(ERR, "phy mode/connection mismatch (%#x/%#x)\n",
1972                             phy_data->port_mode, phy_data->conn_type);
1973                 return -EINVAL;
1974         }
1975
1976         /* Validate the mode requested */
1977         if (axgbe_phy_port_mode_mismatch(pdata)) {
1978                 PMD_DRV_LOG(ERR, "phy mode/speed mismatch (%#x/%#x)\n",
1979                             phy_data->port_mode, phy_data->port_speeds);
1980                 return -EINVAL;
1981         }
1982
1983         /* Check for and validate MDIO reset support */
1984         ret = axgbe_phy_mdio_reset_setup(pdata);
1985         if (ret)
1986                 return ret;
1987
1988         /* Validate the re-driver information */
1989         if (axgbe_phy_redrv_error(phy_data)) {
1990                 PMD_DRV_LOG(ERR, "phy re-driver settings error\n");
1991                 return -EINVAL;
1992         }
1993         pdata->kr_redrv = phy_data->redrv;
1994
1995         /* Indicate current mode is unknown */
1996         phy_data->cur_mode = AXGBE_MODE_UNKNOWN;
1997
1998         /* Initialize supported features */
1999         pdata->phy.supported = 0;
2000
2001         switch (phy_data->port_mode) {
2002                 /* Backplane support */
2003         case AXGBE_PORT_MODE_BACKPLANE:
2004                 pdata->phy.supported |= SUPPORTED_Autoneg;
2005                 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
2006                 pdata->phy.supported |= SUPPORTED_Backplane;
2007                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) {
2008                         pdata->phy.supported |= SUPPORTED_1000baseKX_Full;
2009                         phy_data->start_mode = AXGBE_MODE_KX_1000;
2010                 }
2011                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000) {
2012                         pdata->phy.supported |= SUPPORTED_10000baseKR_Full;
2013                         if (pdata->fec_ability & MDIO_PMA_10GBR_FECABLE_ABLE)
2014                                 pdata->phy.supported |=
2015                                         SUPPORTED_10000baseR_FEC;
2016                         phy_data->start_mode = AXGBE_MODE_KR;
2017                 }
2018
2019                 phy_data->phydev_mode = AXGBE_MDIO_MODE_NONE;
2020                 break;
2021         case AXGBE_PORT_MODE_BACKPLANE_2500:
2022                 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
2023                 pdata->phy.supported |= SUPPORTED_Backplane;
2024                 pdata->phy.supported |= SUPPORTED_2500baseX_Full;
2025                 phy_data->start_mode = AXGBE_MODE_KX_2500;
2026
2027                 phy_data->phydev_mode = AXGBE_MDIO_MODE_NONE;
2028                 break;
2029
2030                 /* MDIO 1GBase-T support */
2031         case AXGBE_PORT_MODE_1000BASE_T:
2032                 pdata->phy.supported |= SUPPORTED_Autoneg;
2033                 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
2034                 pdata->phy.supported |= SUPPORTED_TP;
2035                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) {
2036                         pdata->phy.supported |= SUPPORTED_100baseT_Full;
2037                         phy_data->start_mode = AXGBE_MODE_SGMII_100;
2038                 }
2039                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) {
2040                         pdata->phy.supported |= SUPPORTED_1000baseT_Full;
2041                         phy_data->start_mode = AXGBE_MODE_SGMII_1000;
2042                 }
2043
2044                 phy_data->phydev_mode = AXGBE_MDIO_MODE_CL22;
2045                 break;
2046
2047                 /* MDIO Base-X support */
2048         case AXGBE_PORT_MODE_1000BASE_X:
2049                 pdata->phy.supported |= SUPPORTED_Autoneg;
2050                 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
2051                 pdata->phy.supported |= SUPPORTED_FIBRE;
2052                 pdata->phy.supported |= SUPPORTED_1000baseT_Full;
2053                 phy_data->start_mode = AXGBE_MODE_X;
2054
2055                 phy_data->phydev_mode = AXGBE_MDIO_MODE_CL22;
2056                 break;
2057
2058                 /* MDIO NBase-T support */
2059         case AXGBE_PORT_MODE_NBASE_T:
2060                 pdata->phy.supported |= SUPPORTED_Autoneg;
2061                 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
2062                 pdata->phy.supported |= SUPPORTED_TP;
2063                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) {
2064                         pdata->phy.supported |= SUPPORTED_100baseT_Full;
2065                         phy_data->start_mode = AXGBE_MODE_SGMII_100;
2066                 }
2067                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) {
2068                         pdata->phy.supported |= SUPPORTED_1000baseT_Full;
2069                         phy_data->start_mode = AXGBE_MODE_SGMII_1000;
2070                 }
2071                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_2500) {
2072                         pdata->phy.supported |= SUPPORTED_2500baseX_Full;
2073                         phy_data->start_mode = AXGBE_MODE_KX_2500;
2074                 }
2075
2076                 phy_data->phydev_mode = AXGBE_MDIO_MODE_CL45;
2077                 break;
2078
2079                 /* 10GBase-T support */
2080         case AXGBE_PORT_MODE_10GBASE_T:
2081                 pdata->phy.supported |= SUPPORTED_Autoneg;
2082                 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
2083                 pdata->phy.supported |= SUPPORTED_TP;
2084                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) {
2085                         pdata->phy.supported |= SUPPORTED_100baseT_Full;
2086                         phy_data->start_mode = AXGBE_MODE_SGMII_100;
2087                 }
2088                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) {
2089                         pdata->phy.supported |= SUPPORTED_1000baseT_Full;
2090                         phy_data->start_mode = AXGBE_MODE_SGMII_1000;
2091                 }
2092                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000) {
2093                         pdata->phy.supported |= SUPPORTED_10000baseT_Full;
2094                         phy_data->start_mode = AXGBE_MODE_KR;
2095                 }
2096
2097                 phy_data->phydev_mode = AXGBE_MDIO_MODE_NONE;
2098                 break;
2099
2100                 /* 10GBase-R support */
2101         case AXGBE_PORT_MODE_10GBASE_R:
2102                 pdata->phy.supported |= SUPPORTED_Autoneg;
2103                 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
2104                 pdata->phy.supported |= SUPPORTED_TP;
2105                 pdata->phy.supported |= SUPPORTED_10000baseT_Full;
2106                 if (pdata->fec_ability & MDIO_PMA_10GBR_FECABLE_ABLE)
2107                         pdata->phy.supported |= SUPPORTED_10000baseR_FEC;
2108                 phy_data->start_mode = AXGBE_MODE_SFI;
2109
2110                 phy_data->phydev_mode = AXGBE_MDIO_MODE_NONE;
2111                 break;
2112
2113                 /* SFP support */
2114         case AXGBE_PORT_MODE_SFP:
2115                 pdata->phy.supported |= SUPPORTED_Autoneg;
2116                 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
2117                 pdata->phy.supported |= SUPPORTED_TP;
2118                 pdata->phy.supported |= SUPPORTED_FIBRE;
2119                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_100) {
2120                         pdata->phy.supported |= SUPPORTED_100baseT_Full;
2121                         phy_data->start_mode = AXGBE_MODE_SGMII_100;
2122                 }
2123                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_1000) {
2124                         pdata->phy.supported |= SUPPORTED_1000baseT_Full;
2125                         phy_data->start_mode = AXGBE_MODE_SGMII_1000;
2126                 }
2127                 if (phy_data->port_speeds & AXGBE_PHY_PORT_SPEED_10000) {
2128                         pdata->phy.supported |= SUPPORTED_10000baseT_Full;
2129                         phy_data->start_mode = AXGBE_MODE_SFI;
2130                         if (pdata->fec_ability & MDIO_PMA_10GBR_FECABLE_ABLE)
2131                                 pdata->phy.supported |=
2132                                         SUPPORTED_10000baseR_FEC;
2133                 }
2134
2135                 phy_data->phydev_mode = AXGBE_MDIO_MODE_CL22;
2136
2137                 axgbe_phy_sfp_setup(pdata);
2138                 break;
2139         default:
2140                 return -EINVAL;
2141         }
2142
2143         if ((phy_data->conn_type & AXGBE_CONN_TYPE_MDIO) &&
2144             (phy_data->phydev_mode != AXGBE_MDIO_MODE_NONE)) {
2145                 ret = pdata->hw_if.set_ext_mii_mode(pdata, phy_data->mdio_addr,
2146                                                     phy_data->phydev_mode);
2147                 if (ret) {
2148                         PMD_DRV_LOG(ERR, "mdio port/clause not compatible (%d/%u)\n",
2149                                     phy_data->mdio_addr, phy_data->phydev_mode);
2150                         return -EINVAL;
2151                 }
2152         }
2153
2154         if (phy_data->redrv && !phy_data->redrv_if) {
2155                 ret = pdata->hw_if.set_ext_mii_mode(pdata, phy_data->redrv_addr,
2156                                                     AXGBE_MDIO_MODE_CL22);
2157                 if (ret) {
2158                         PMD_DRV_LOG(ERR, "redriver mdio port not compatible (%u)\n",
2159                                     phy_data->redrv_addr);
2160                         return -EINVAL;
2161                 }
2162         }
2163
2164         phy_data->phy_cdr_delay = AXGBE_CDR_DELAY_INIT;
2165         return 0;
2166 }
2167 void axgbe_init_function_ptrs_phy_v2(struct axgbe_phy_if *phy_if)
2168 {
2169         struct axgbe_phy_impl_if *phy_impl = &phy_if->phy_impl;
2170
2171         phy_impl->init                  = axgbe_phy_init;
2172         phy_impl->reset                 = axgbe_phy_reset;
2173         phy_impl->start                 = axgbe_phy_start;
2174         phy_impl->stop                  = axgbe_phy_stop;
2175         phy_impl->link_status           = axgbe_phy_link_status;
2176         phy_impl->use_mode              = axgbe_phy_use_mode;
2177         phy_impl->set_mode              = axgbe_phy_set_mode;
2178         phy_impl->get_mode              = axgbe_phy_get_mode;
2179         phy_impl->switch_mode           = axgbe_phy_switch_mode;
2180         phy_impl->cur_mode              = axgbe_phy_cur_mode;
2181         phy_impl->an_mode               = axgbe_phy_an_mode;
2182         phy_impl->an_config             = axgbe_phy_an_config;
2183         phy_impl->an_advertising        = axgbe_phy_an_advertising;
2184         phy_impl->an_outcome            = axgbe_phy_an_outcome;
2185
2186         phy_impl->an_pre                = axgbe_phy_an_pre;
2187         phy_impl->an_post               = axgbe_phy_an_post;
2188
2189         phy_impl->kr_training_pre       = axgbe_phy_kr_training_pre;
2190         phy_impl->kr_training_post      = axgbe_phy_kr_training_post;
2191 }