projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'nds32-for-linus-4.19-tag1' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6-block.git] / drivers / net / ethernet / hisilicon / hns / hns_dsaf_mac.c
CommitLineData
511e6bc0 1/*
2 * Copyright (c) 2014-2015 Hisilicon Limited.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 */
9
1d1afa2e 10#include <linux/acpi.h>
511e6bc0 11#include <linux/init.h>
511e6bc0 12#include <linux/interrupt.h>
2e2591b1 13#include <linux/kernel.h>
831d828b 14#include <linux/mfd/syscon.h>
2e2591b1
DH		 15#include <linux/module.h>
16#include <linux/netdevice.h>
511e6bc0 17#include <linux/of.h>
18#include <linux/of_address.h>
652d39b0
KY		 19#include <linux/of_mdio.h>
20#include <linux/phy.h>
2e2591b1 21#include <linux/platform_device.h>
511e6bc0 22
511e6bc0 23#include "hns_dsaf_main.h"
2e2591b1 24#include "hns_dsaf_misc.h"
511e6bc0 25#include "hns_dsaf_rcb.h"
26
27#define MAC_EN_FLAG_V 0xada0328
28
29static const u16 mac_phy_to_speed[] = {
30 [PHY_INTERFACE_MODE_MII] = MAC_SPEED_100,
31 [PHY_INTERFACE_MODE_GMII] = MAC_SPEED_1000,
32 [PHY_INTERFACE_MODE_SGMII] = MAC_SPEED_1000,
33 [PHY_INTERFACE_MODE_TBI] = MAC_SPEED_1000,
34 [PHY_INTERFACE_MODE_RMII] = MAC_SPEED_100,
35 [PHY_INTERFACE_MODE_RGMII] = MAC_SPEED_1000,
36 [PHY_INTERFACE_MODE_RGMII_ID] = MAC_SPEED_1000,
37 [PHY_INTERFACE_MODE_RGMII_RXID] = MAC_SPEED_1000,
38 [PHY_INTERFACE_MODE_RGMII_TXID] = MAC_SPEED_1000,
39 [PHY_INTERFACE_MODE_RTBI] = MAC_SPEED_1000,
40 [PHY_INTERFACE_MODE_XGMII] = MAC_SPEED_10000
41};
42
43static const enum mac_mode g_mac_mode_100[] = {
44 [PHY_INTERFACE_MODE_MII] = MAC_MODE_MII_100,
45 [PHY_INTERFACE_MODE_RMII] = MAC_MODE_RMII_100
46};
47
48static const enum mac_mode g_mac_mode_1000[] = {
49 [PHY_INTERFACE_MODE_GMII] = MAC_MODE_GMII_1000,
50 [PHY_INTERFACE_MODE_SGMII] = MAC_MODE_SGMII_1000,
51 [PHY_INTERFACE_MODE_TBI] = MAC_MODE_TBI_1000,
52 [PHY_INTERFACE_MODE_RGMII] = MAC_MODE_RGMII_1000,
53 [PHY_INTERFACE_MODE_RGMII_ID] = MAC_MODE_RGMII_1000,
54 [PHY_INTERFACE_MODE_RGMII_RXID] = MAC_MODE_RGMII_1000,
55 [PHY_INTERFACE_MODE_RGMII_TXID] = MAC_MODE_RGMII_1000,
56 [PHY_INTERFACE_MODE_RTBI] = MAC_MODE_RTBI_1000
57};
58
511e6bc0 59static enum mac_mode hns_get_enet_interface(const struct hns_mac_cb *mac_cb)
60{
61 switch (mac_cb->max_speed) {
62 case MAC_SPEED_100:
63 return g_mac_mode_100[mac_cb->phy_if];
64 case MAC_SPEED_1000:
65 return g_mac_mode_1000[mac_cb->phy_if];
66 case MAC_SPEED_10000:
67 return MAC_MODE_XGMII_10000;
68 default:
69 return MAC_MODE_MII_100;
70 }
71}
72
511e6bc0 73void hns_mac_get_link_status(struct hns_mac_cb *mac_cb, u32 *link_status)
74{
75 struct mac_driver *mac_ctrl_drv;
76 int ret, sfp_prsnt;
77
78 mac_ctrl_drv = hns_mac_get_drv(mac_cb);
79
80 if (mac_ctrl_drv->get_link_status)
81 mac_ctrl_drv->get_link_status(mac_ctrl_drv, link_status);
82 else
83 *link_status = 0;
84
b917078c
DH		 85 if (mac_cb->media_type == HNAE_MEDIA_TYPE_FIBER) {
86 ret = mac_cb->dsaf_dev->misc_op->get_sfp_prsnt(mac_cb,
87 &sfp_prsnt);
88 if (!ret)
89 *link_status = *link_status && sfp_prsnt;
90 }
511e6bc0 91
92 mac_cb->link = *link_status;
93}
94
95int hns_mac_get_port_info(struct hns_mac_cb *mac_cb,
96 u8 *auto_neg, u16 *speed, u8 *duplex)
97{
98 struct mac_driver *mac_ctrl_drv;
99 struct mac_info info;
100
101 mac_ctrl_drv = hns_mac_get_drv(mac_cb);
102
103 if (!mac_ctrl_drv->get_info)
104 return -ENODEV;
105
106 mac_ctrl_drv->get_info(mac_ctrl_drv, &info);
107 if (auto_neg)
108 *auto_neg = info.auto_neg;
109 if (speed)
110 *speed = info.speed;
111 if (duplex)
112 *duplex = info.duplex;
113
114 return 0;
115}
116
31fabbee
PL		 117/**
118 *hns_mac_is_adjust_link - check is need change mac speed and duplex register
119 *@mac_cb: mac device
120 *@speed: phy device speed
121 *@duplex:phy device duplex
122 *
123 */
124bool hns_mac_need_adjust_link(struct hns_mac_cb *mac_cb, int speed, int duplex)
125{
126 struct mac_driver *mac_ctrl_drv;
127
128 mac_ctrl_drv = (struct mac_driver *)(mac_cb->priv.mac);
129
130 if (mac_ctrl_drv->need_adjust_link)
131 return mac_ctrl_drv->need_adjust_link(mac_ctrl_drv,
132 (enum mac_speed)speed, duplex);
133 else
134 return true;
135}
136
511e6bc0 137void hns_mac_adjust_link(struct hns_mac_cb *mac_cb, int speed, int duplex)
138{
139 int ret;
140 struct mac_driver *mac_ctrl_drv;
141
142 mac_ctrl_drv = (struct mac_driver *)(mac_cb->priv.mac);
143
144 mac_cb->speed = speed;
145 mac_cb->half_duplex = !duplex;
511e6bc0 146
147 if (mac_ctrl_drv->adjust_link) {
148 ret = mac_ctrl_drv->adjust_link(mac_ctrl_drv,
149 (enum mac_speed)speed, duplex);
150 if (ret) {
151 dev_err(mac_cb->dev,
451e856e 152 "adjust_link failed, %s mac%d ret = %#x!\n",
511e6bc0 153 mac_cb->dsaf_dev->ae_dev.name,
154 mac_cb->mac_id, ret);
155 return;
156 }
157 }
158}
159
160/**
161 *hns_mac_get_inner_port_num - get mac table inner port number
162 *@mac_cb: mac device
163 *@vmid: vm id
164 *@port_num:port number
165 *
166 */
58035fd9 167int hns_mac_get_inner_port_num(struct hns_mac_cb *mac_cb, u8 vmid, u8 *port_num)
511e6bc0 168{
58035fd9
DH		 169 int q_num_per_vf, vf_num_per_port;
170 int vm_queue_id;
511e6bc0 171 u8 tmp_port;
511e6bc0 172
173 if (mac_cb->dsaf_dev->dsaf_mode <= DSAF_MODE_ENABLE) {
831d828b 174 if (mac_cb->mac_id != DSAF_MAX_PORT_NUM) {
511e6bc0 175 dev_err(mac_cb->dev,
451e856e 176 "input invalid, %s mac%d vmid%d !\n",
511e6bc0 177 mac_cb->dsaf_dev->ae_dev.name,
178 mac_cb->mac_id, vmid);
179 return -EINVAL;
180 }
181 } else if (mac_cb->dsaf_dev->dsaf_mode < DSAF_MODE_MAX) {
831d828b 182 if (mac_cb->mac_id >= DSAF_MAX_PORT_NUM) {
511e6bc0 183 dev_err(mac_cb->dev,
451e856e 184 "input invalid, %s mac%d vmid%d!\n",
511e6bc0 185 mac_cb->dsaf_dev->ae_dev.name,
186 mac_cb->mac_id, vmid);
187 return -EINVAL;
188 }
189 } else {
451e856e 190 dev_err(mac_cb->dev, "dsaf mode invalid, %s mac%d!\n",
511e6bc0 191 mac_cb->dsaf_dev->ae_dev.name, mac_cb->mac_id);
192 return -EINVAL;
193 }
194
831d828b 195 if (vmid >= mac_cb->dsaf_dev->rcb_common[0]->max_vfn) {
451e856e 196 dev_err(mac_cb->dev, "input invalid, %s mac%d vmid%d !\n",
511e6bc0 197 mac_cb->dsaf_dev->ae_dev.name, mac_cb->mac_id, vmid);
198 return -EINVAL;
199 }
200
58035fd9
DH		 201 q_num_per_vf = mac_cb->dsaf_dev->rcb_common[0]->max_q_per_vf;
202 vf_num_per_port = mac_cb->dsaf_dev->rcb_common[0]->max_vfn;
203
204 vm_queue_id = vmid * q_num_per_vf +
205 vf_num_per_port * q_num_per_vf * mac_cb->mac_id;
206
511e6bc0 207 switch (mac_cb->dsaf_dev->dsaf_mode) {
208 case DSAF_MODE_ENABLE_FIX:
209 tmp_port = 0;
210 break;
211 case DSAF_MODE_DISABLE_FIX:
212 tmp_port = 0;
213 break;
214 case DSAF_MODE_ENABLE_0VM:
215 case DSAF_MODE_ENABLE_8VM:
216 case DSAF_MODE_ENABLE_16VM:
217 case DSAF_MODE_ENABLE_32VM:
218 case DSAF_MODE_ENABLE_128VM:
219 case DSAF_MODE_DISABLE_2PORT_8VM:
220 case DSAF_MODE_DISABLE_2PORT_16VM:
221 case DSAF_MODE_DISABLE_2PORT_64VM:
222 case DSAF_MODE_DISABLE_6PORT_0VM:
223 case DSAF_MODE_DISABLE_6PORT_2VM:
224 case DSAF_MODE_DISABLE_6PORT_4VM:
225 case DSAF_MODE_DISABLE_6PORT_16VM:
58035fd9 226 tmp_port = vm_queue_id;
511e6bc0 227 break;
228 default:
451e856e 229 dev_err(mac_cb->dev, "dsaf mode invalid, %s mac%d!\n",
511e6bc0 230 mac_cb->dsaf_dev->ae_dev.name, mac_cb->mac_id);
231 return -EINVAL;
232 }
233 tmp_port += DSAF_BASE_INNER_PORT_NUM;
234
235 *port_num = tmp_port;
236
237 return 0;
238}
239
240/**
831d828b 241 *hns_mac_change_vf_addr - change vf mac address
511e6bc0 242 *@mac_cb: mac device
243 *@vmid: vmid
244 *@addr:mac address
245 */
246int hns_mac_change_vf_addr(struct hns_mac_cb *mac_cb,
247 u32 vmid, char *addr)
248{
249 int ret;
250 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
251 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
252 struct dsaf_drv_mac_single_dest_entry mac_entry;
253 struct mac_entry_idx *old_entry;
254
255 old_entry = &mac_cb->addr_entry_idx[vmid];
89a44093 256 if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) {
511e6bc0 257 memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr));
258 mac_entry.in_vlan_id = old_entry->vlan_id;
259 mac_entry.in_port_num = mac_cb->mac_id;
260 ret = hns_mac_get_inner_port_num(mac_cb, (u8)vmid,
261 &mac_entry.port_num);
262 if (ret)
263 return ret;
264
265 if ((old_entry->valid != 0) &&
266 (memcmp(old_entry->addr,
267 addr, sizeof(mac_entry.addr)) != 0)) {
268 ret = hns_dsaf_del_mac_entry(dsaf_dev,
269 old_entry->vlan_id,
270 mac_cb->mac_id,
271 old_entry->addr);
272 if (ret)
273 return ret;
274 }
275
276 ret = hns_dsaf_set_mac_uc_entry(dsaf_dev, &mac_entry);
277 if (ret)
278 return ret;
279 }
280
281 if ((mac_ctrl_drv->set_mac_addr) && (vmid == 0))
282 mac_ctrl_drv->set_mac_addr(mac_cb->priv.mac, addr);
283
284 memcpy(old_entry->addr, addr, sizeof(old_entry->addr));
285 old_entry->valid = 1;
286 return 0;
287}
288
66355f52
KY		 289int hns_mac_add_uc_addr(struct hns_mac_cb *mac_cb, u8 vf_id,
290 const unsigned char *addr)
291{
292 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
293 struct dsaf_drv_mac_single_dest_entry mac_entry;
294 int ret;
295
296 if (HNS_DSAF_IS_DEBUG(dsaf_dev))
297 return -ENOSPC;
298
299 memset(&mac_entry, 0, sizeof(mac_entry));
300 memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr));
301 mac_entry.in_port_num = mac_cb->mac_id;
302 ret = hns_mac_get_inner_port_num(mac_cb, vf_id, &mac_entry.port_num);
303 if (ret)
304 return ret;
305
306 return hns_dsaf_set_mac_uc_entry(dsaf_dev, &mac_entry);
307}
308
309int hns_mac_rm_uc_addr(struct hns_mac_cb *mac_cb, u8 vf_id,
310 const unsigned char *addr)
311{
312 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
313 struct dsaf_drv_mac_single_dest_entry mac_entry;
314 int ret;
315
316 if (HNS_DSAF_IS_DEBUG(dsaf_dev))
317 return -ENOSPC;
318
319 memset(&mac_entry, 0, sizeof(mac_entry));
320 memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr));
321 mac_entry.in_port_num = mac_cb->mac_id;
322 ret = hns_mac_get_inner_port_num(mac_cb, vf_id, &mac_entry.port_num);
323 if (ret)
324 return ret;
325
326 return hns_dsaf_rm_mac_addr(dsaf_dev, &mac_entry);
327}
328
511e6bc0 329int hns_mac_set_multi(struct hns_mac_cb *mac_cb,
13ac695e 330 u32 port_num, char *addr, bool enable)
511e6bc0 331{
332 int ret;
333 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
334 struct dsaf_drv_mac_single_dest_entry mac_entry;
335
89a44093 336 if (!HNS_DSAF_IS_DEBUG(dsaf_dev) && addr) {
511e6bc0 337 memcpy(mac_entry.addr, addr, sizeof(mac_entry.addr));
338 mac_entry.in_vlan_id = 0;/*vlan_id;*/
339 mac_entry.in_port_num = mac_cb->mac_id;
340 mac_entry.port_num = port_num;
341
13ac695e 342 if (!enable)
511e6bc0 343 ret = hns_dsaf_del_mac_mc_port(dsaf_dev, &mac_entry);
344 else
345 ret = hns_dsaf_add_mac_mc_port(dsaf_dev, &mac_entry);
346 if (ret) {
347 dev_err(dsaf_dev->dev,
451e856e 348 "set mac mc port failed, %s mac%d ret = %#x!\n",
511e6bc0 349 mac_cb->dsaf_dev->ae_dev.name,
350 mac_cb->mac_id, ret);
351 return ret;
352 }
353 }
354
355 return 0;
356}
357
ec2cafe6
KY		 358int hns_mac_clr_multicast(struct hns_mac_cb *mac_cb, int vfn)
359{
360 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
361 u8 port_num;
362 int ret = hns_mac_get_inner_port_num(mac_cb, vfn, &port_num);
363
364 if (ret)
365 return ret;
366
367 return hns_dsaf_clr_mac_mc_port(dsaf_dev, mac_cb->mac_id, port_num);
368}
369
511e6bc0 370static void hns_mac_param_get(struct mac_params *param,
371 struct hns_mac_cb *mac_cb)
372{
373 param->vaddr = (void *)mac_cb->vaddr;
374 param->mac_mode = hns_get_enet_interface(mac_cb);
153b1d48 375 ether_addr_copy(param->addr, mac_cb->addr_entry_idx[0].addr);
511e6bc0 376 param->mac_id = mac_cb->mac_id;
377 param->dev = mac_cb->dev;
378}
379
380/**
381 *hns_mac_queue_config_bc_en - set broadcast rx&tx enable
382 *@mac_cb: mac device
383 *@queue: queue number
384 *@en:enable
385 *retuen 0 - success , negative --fail
386 */
387static int hns_mac_port_config_bc_en(struct hns_mac_cb *mac_cb,
13ac695e 388 u32 port_num, u16 vlan_id, bool enable)
511e6bc0 389{
390 int ret;
391 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
511e6bc0 392 struct dsaf_drv_mac_single_dest_entry mac_entry;
393
394 /* directy return ok in debug network mode */
395 if (mac_cb->mac_type == HNAE_PORT_DEBUG)
396 return 0;
397
89a44093 398 if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) {
49b44aa2 399 eth_broadcast_addr(mac_entry.addr);
511e6bc0 400 mac_entry.in_vlan_id = vlan_id;
401 mac_entry.in_port_num = mac_cb->mac_id;
402 mac_entry.port_num = port_num;
403
13ac695e 404 if (!enable)
511e6bc0 405 ret = hns_dsaf_del_mac_mc_port(dsaf_dev, &mac_entry);
406 else
407 ret = hns_dsaf_add_mac_mc_port(dsaf_dev, &mac_entry);
408 return ret;
409 }
410
411 return 0;
412}
413
414/**
415 *hns_mac_vm_config_bc_en - set broadcast rx&tx enable
416 *@mac_cb: mac device
417 *@vmid: vm id
418 *@en:enable
419 *retuen 0 - success , negative --fail
420 */
13ac695e 421int hns_mac_vm_config_bc_en(struct hns_mac_cb *mac_cb, u32 vmid, bool enable)
511e6bc0 422{
423 int ret;
424 struct dsaf_device *dsaf_dev = mac_cb->dsaf_dev;
425 u8 port_num;
511e6bc0 426 struct mac_entry_idx *uc_mac_entry;
427 struct dsaf_drv_mac_single_dest_entry mac_entry;
428
429 if (mac_cb->mac_type == HNAE_PORT_DEBUG)
430 return 0;
431
432 uc_mac_entry = &mac_cb->addr_entry_idx[vmid];
433
89a44093 434 if (!HNS_DSAF_IS_DEBUG(dsaf_dev)) {
49b44aa2 435 eth_broadcast_addr(mac_entry.addr);
511e6bc0 436 mac_entry.in_vlan_id = uc_mac_entry->vlan_id;
437 mac_entry.in_port_num = mac_cb->mac_id;
438 ret = hns_mac_get_inner_port_num(mac_cb, vmid, &port_num);
439 if (ret)
440 return ret;
441 mac_entry.port_num = port_num;
442
13ac695e 443 if (!enable)
511e6bc0 444 ret = hns_dsaf_del_mac_mc_port(dsaf_dev, &mac_entry);
445 else
446 ret = hns_dsaf_add_mac_mc_port(dsaf_dev, &mac_entry);
447 return ret;
448 }
449
450 return 0;
451}
452
31fabbee
PL		 453int hns_mac_wait_fifo_clean(struct hns_mac_cb *mac_cb)
454{
455 struct mac_driver *drv = hns_mac_get_drv(mac_cb);
456
457 if (drv->wait_fifo_clean)
458 return drv->wait_fifo_clean(drv);
459
460 return 0;
461}
462
511e6bc0 463void hns_mac_reset(struct hns_mac_cb *mac_cb)
464{
5ada37b5
L		 465 struct mac_driver *drv = hns_mac_get_drv(mac_cb);
466 bool is_ver1 = AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver);
511e6bc0 467
468 drv->mac_init(drv);
469
470 if (drv->config_max_frame_length)
471 drv->config_max_frame_length(drv, mac_cb->max_frm);
472
473 if (drv->set_tx_auto_pause_frames)
474 drv->set_tx_auto_pause_frames(drv, mac_cb->tx_pause_frm_time);
475
476 if (drv->set_an_mode)
477 drv->set_an_mode(drv, 1);
478
479 if (drv->mac_pausefrm_cfg) {
480 if (mac_cb->mac_type == HNAE_PORT_DEBUG)
5ada37b5 481 drv->mac_pausefrm_cfg(drv, !is_ver1, !is_ver1);
511e6bc0 482 else /* mac rx must disable, dsaf pfc close instead of it*/
483 drv->mac_pausefrm_cfg(drv, 0, 1);
484 }
485}
486
b29bd412 487int hns_mac_set_mtu(struct hns_mac_cb *mac_cb, u32 new_mtu, u32 buf_size)
511e6bc0 488{
489 struct mac_driver *drv = hns_mac_get_drv(mac_cb);
511e6bc0 490 u32 new_frm = new_mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN;
211b1384 491
44770e11 492 if (new_frm > HNS_RCB_RING_MAX_BD_PER_PKT * buf_size)
511e6bc0 493 return -EINVAL;
494
495 if (!drv->config_max_frame_length)
496 return -ECHILD;
497
498 /* adjust max frame to be at least the size of a standard frame */
499 if (new_frm < (ETH_FRAME_LEN + ETH_FCS_LEN + VLAN_HLEN))
500 new_frm = (ETH_FRAME_LEN + ETH_FCS_LEN + VLAN_HLEN);
501
502 drv->config_max_frame_length(drv, new_frm);
503
504 mac_cb->max_frm = new_frm;
505
506 return 0;
507}
508
509void hns_mac_start(struct hns_mac_cb *mac_cb)
510{
511 struct mac_driver *mac_drv = hns_mac_get_drv(mac_cb);
512
513 /* for virt */
514 if (mac_drv->mac_en_flg == MAC_EN_FLAG_V) {
515 /*plus 1 when the virtual mac has been enabled */
516 mac_drv->virt_dev_num += 1;
517 return;
518 }
519
520 if (mac_drv->mac_enable) {
521 mac_drv->mac_enable(mac_cb->priv.mac, MAC_COMM_MODE_RX_AND_TX);
522 mac_drv->mac_en_flg = MAC_EN_FLAG_V;
523 }
524}
525
526void hns_mac_stop(struct hns_mac_cb *mac_cb)
527{
528 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
529
530 /*modified for virtualization */
531 if (mac_ctrl_drv->virt_dev_num > 0) {
532 mac_ctrl_drv->virt_dev_num -= 1;
533 if (mac_ctrl_drv->virt_dev_num > 0)
534 return;
535 }
536
537 if (mac_ctrl_drv->mac_disable)
538 mac_ctrl_drv->mac_disable(mac_cb->priv.mac,
539 MAC_COMM_MODE_RX_AND_TX);
540
541 mac_ctrl_drv->mac_en_flg = 0;
542 mac_cb->link = 0;
a24274aa 543 mac_cb->dsaf_dev->misc_op->cpld_reset_led(mac_cb);
511e6bc0 544}
545
546/**
547 * hns_mac_get_autoneg - get auto autonegotiation
548 * @mac_cb: mac control block
549 * @enable: enable or not
550 * retuen 0 - success , negative --fail
551 */
552void hns_mac_get_autoneg(struct hns_mac_cb *mac_cb, u32 *auto_neg)
553{
554 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
555
556 if (mac_ctrl_drv->autoneg_stat)
557 mac_ctrl_drv->autoneg_stat(mac_ctrl_drv, auto_neg);
558 else
559 *auto_neg = 0;
560}
561
562/**
563 * hns_mac_get_pauseparam - set rx & tx pause parameter
564 * @mac_cb: mac control block
565 * @rx_en: rx enable status
566 * @tx_en: tx enable status
567 * retuen 0 - success , negative --fail
568 */
569void hns_mac_get_pauseparam(struct hns_mac_cb *mac_cb, u32 *rx_en, u32 *tx_en)
570{
571 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
572
573 if (mac_ctrl_drv->get_pause_enable) {
574 mac_ctrl_drv->get_pause_enable(mac_ctrl_drv, rx_en, tx_en);
575 } else {
576 *rx_en = 0;
577 *tx_en = 0;
578 }
511e6bc0 579}
580
581/**
582 * hns_mac_set_autoneg - set auto autonegotiation
583 * @mac_cb: mac control block
584 * @enable: enable or not
585 * retuen 0 - success , negative --fail
586 */
587int hns_mac_set_autoneg(struct hns_mac_cb *mac_cb, u8 enable)
588{
589 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
590
591 if (mac_cb->phy_if == PHY_INTERFACE_MODE_XGMII && enable) {
451e856e 592 dev_err(mac_cb->dev, "enabling autoneg is not allowed!\n");
511e6bc0 593 return -ENOTSUPP;
594 }
595
596 if (mac_ctrl_drv->set_an_mode)
597 mac_ctrl_drv->set_an_mode(mac_ctrl_drv, enable);
598
599 return 0;
600}
601
602/**
603 * hns_mac_set_autoneg - set rx & tx pause parameter
604 * @mac_cb: mac control block
605 * @rx_en: rx enable or not
606 * @tx_en: tx enable or not
607 * return 0 - success , negative --fail
608 */
609int hns_mac_set_pauseparam(struct hns_mac_cb *mac_cb, u32 rx_en, u32 tx_en)
610{
611 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
5ada37b5 612 bool is_ver1 = AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver);
511e6bc0 613
5ada37b5
L		 614 if (mac_cb->mac_type == HNAE_PORT_DEBUG) {
615 if (is_ver1 && (tx_en || rx_en)) {
451e856e 616 dev_err(mac_cb->dev, "macv1 can't enable tx/rx_pause!\n");
511e6bc0 617 return -EINVAL;
618 }
511e6bc0 619 }
620
621 if (mac_ctrl_drv->mac_pausefrm_cfg)
622 mac_ctrl_drv->mac_pausefrm_cfg(mac_ctrl_drv, rx_en, tx_en);
623
624 return 0;
625}
626
627/**
628 * hns_mac_init_ex - mac init
629 * @mac_cb: mac control block
630 * retuen 0 - success , negative --fail
631 */
632static int hns_mac_init_ex(struct hns_mac_cb *mac_cb)
633{
634 int ret;
635 struct mac_params param;
636 struct mac_driver *drv;
637
638 hns_dsaf_fix_mac_mode(mac_cb);
639
640 memset(&param, 0, sizeof(struct mac_params));
641 hns_mac_param_get(&param, mac_cb);
642
643 if (MAC_SPEED_FROM_MODE(param.mac_mode) < MAC_SPEED_10000)
644 drv = (struct mac_driver *)hns_gmac_config(mac_cb, &param);
645 else
646 drv = (struct mac_driver *)hns_xgmac_config(mac_cb, &param);
647
648 if (!drv)
649 return -ENOMEM;
650
651 mac_cb->priv.mac = (void *)drv;
652 hns_mac_reset(mac_cb);
653
654 hns_mac_adjust_link(mac_cb, mac_cb->speed, !mac_cb->half_duplex);
655
13ac695e 656 ret = hns_mac_port_config_bc_en(mac_cb, mac_cb->mac_id, 0, true);
511e6bc0 657 if (ret)
658 goto free_mac_drv;
659
660 return 0;
661
662free_mac_drv:
663 drv->mac_free(mac_cb->priv.mac);
664 mac_cb->priv.mac = NULL;
665
666 return ret;
667}
668
1d1afa2e
KY		 669static int
670hns_mac_phy_parse_addr(struct device *dev, struct fwnode_handle *fwnode)
671{
672 u32 addr;
673 int ret;
674
675 ret = fwnode_property_read_u32(fwnode, "phy-addr", &addr);
676 if (ret) {
677 dev_err(dev, "has invalid PHY address ret:%d\n", ret);
678 return ret;
679 }
680
681 if (addr >= PHY_MAX_ADDR) {
682 dev_err(dev, "PHY address %i is too large\n", addr);
683 return -EINVAL;
684 }
685
686 return addr;
687}
688
1d1afa2e
KY		 689static int
690hns_mac_register_phydev(struct mii_bus *mdio, struct hns_mac_cb *mac_cb,
691 u32 addr)
692{
693 struct phy_device *phy;
694 const char *phy_type;
695 bool is_c45;
696 int rc;
697
698 rc = fwnode_property_read_string(mac_cb->fw_port,
699 "phy-mode", &phy_type);
700 if (rc < 0)
701 return rc;
702
703 if (!strcmp(phy_type, phy_modes(PHY_INTERFACE_MODE_XGMII)))
704 is_c45 = 1;
705 else if (!strcmp(phy_type, phy_modes(PHY_INTERFACE_MODE_SGMII)))
706 is_c45 = 0;
707 else
708 return -ENODATA;
709
710 phy = get_phy_device(mdio, addr, is_c45);
711 if (!phy || IS_ERR(phy))
712 return -EIO;
713
cfaace26 714 phy->irq = mdio->irq[addr];
1d1afa2e
KY		 715
716 /* All data is now stored in the phy struct;
717 * register it
718 */
719 rc = phy_device_register(phy);
720 if (rc) {
721 phy_device_free(phy);
804ffe5c 722 dev_err(&mdio->dev, "registered phy fail at address %i\n",
723 addr);
1d1afa2e
KY		 724 return -ENODEV;
725 }
726
727 mac_cb->phy_dev = phy;
728
729 dev_dbg(&mdio->dev, "registered phy at address %i\n", addr);
730
731 return 0;
732}
733
804ffe5c 734static int hns_mac_register_phy(struct hns_mac_cb *mac_cb)
1d1afa2e 735{
977d5ad3 736 struct fwnode_reference_args args;
1d1afa2e
KY		 737 struct platform_device *pdev;
738 struct mii_bus *mii_bus;
739 int rc;
740 int addr;
741
742 /* Loop over the child nodes and register a phy_device for each one */
743 if (!to_acpi_device_node(mac_cb->fw_port))
804ffe5c 744 return -ENODEV;
1d1afa2e
KY		 745
746 rc = acpi_node_get_property_reference(
747 mac_cb->fw_port, "mdio-node", 0, &args);
748 if (rc)
804ffe5c 749 return rc;
977d5ad3
SA		 750 if (!is_acpi_device_node(args.fwnode))
751 return -EINVAL;
1d1afa2e
KY		 752
753 addr = hns_mac_phy_parse_addr(mac_cb->dev, mac_cb->fw_port);
754 if (addr < 0)
804ffe5c 755 return addr;
1d1afa2e
KY		 756
757 /* dev address in adev */
977d5ad3 758 pdev = hns_dsaf_find_platform_device(args.fwnode);
804ffe5c 759 if (!pdev) {
760 dev_err(mac_cb->dev, "mac%d mdio pdev is NULL\n",
761 mac_cb->mac_id);
762 return -EINVAL;
763 }
764
1d1afa2e 765 mii_bus = platform_get_drvdata(pdev);
804ffe5c 766 if (!mii_bus) {
767 dev_err(mac_cb->dev,
768 "mac%d mdio is NULL, dsaf will probe again later\n",
769 mac_cb->mac_id);
770 return -EPROBE_DEFER;
771 }
772
1d1afa2e
KY		 773 rc = hns_mac_register_phydev(mii_bus, mac_cb, addr);
774 if (!rc)
775 dev_dbg(mac_cb->dev, "mac%d register phy addr:%d\n",
776 mac_cb->mac_id, addr);
804ffe5c 777
778 return rc;
1d1afa2e
KY		 779}
780
5d2525f7
KY		 781#define MAC_MEDIA_TYPE_MAX_LEN 16
782
783static const struct {
784 enum hnae_media_type value;
785 const char *name;
786} media_type_defs[] = {
787 {HNAE_MEDIA_TYPE_UNKNOWN, "unknown" },
788 {HNAE_MEDIA_TYPE_FIBER, "fiber" },
789 {HNAE_MEDIA_TYPE_COPPER, "copper" },
790 {HNAE_MEDIA_TYPE_BACKPLANE, "backplane" },
791};
792
511e6bc0 793/**
831d828b 794 *hns_mac_get_info - get mac information from device node
511e6bc0 795 *@mac_cb: mac device
796 *@np:device node
831d828b 797 * return: 0 --success, negative --fail
511e6bc0 798 */
804ffe5c 799static int hns_mac_get_info(struct hns_mac_cb *mac_cb)
511e6bc0 800{
652d39b0 801 struct device_node *np;
831d828b 802 struct regmap *syscon;
1ffdfac9 803 struct of_phandle_args cpld_args;
5d2525f7
KY		 804 const char *media_type;
805 u32 i;
31d4446d
YZZ		 806 u32 ret;
807
511e6bc0 808 mac_cb->link = false;
809 mac_cb->half_duplex = false;
5d2525f7 810 mac_cb->media_type = HNAE_MEDIA_TYPE_UNKNOWN;
511e6bc0 811 mac_cb->speed = mac_phy_to_speed[mac_cb->phy_if];
812 mac_cb->max_speed = mac_cb->speed;
813
814 if (mac_cb->phy_if == PHY_INTERFACE_MODE_SGMII) {
815 mac_cb->if_support = MAC_GMAC_SUPPORTED;
816 mac_cb->if_support |= SUPPORTED_1000baseT_Full;
817 } else if (mac_cb->phy_if == PHY_INTERFACE_MODE_XGMII) {
818 mac_cb->if_support = SUPPORTED_10000baseR_FEC;
819 mac_cb->if_support |= SUPPORTED_10000baseKR_Full;
820 }
821
822 mac_cb->max_frm = MAC_DEFAULT_MTU;
823 mac_cb->tx_pause_frm_time = MAC_DEFAULT_PAUSE_TIME;
850bfa3b 824 mac_cb->port_rst_off = mac_cb->mac_id;
0d768fc6 825 mac_cb->port_mode_off = 0;
511e6bc0 826
831d828b
YZZ		 827 /* if the dsaf node doesn't contain a port subnode, get phy-handle
828 * from dsaf node
829 */
830 if (!mac_cb->fw_port) {
652d39b0
KY		 831 np = of_parse_phandle(mac_cb->dev->of_node, "phy-handle",
832 mac_cb->mac_id);
833 mac_cb->phy_dev = of_phy_find_device(np);
834 if (mac_cb->phy_dev) {
835 /* refcount is held by of_phy_find_device()
836 * if the phy_dev is found
837 */
838 put_device(&mac_cb->phy_dev->mdio.dev);
839
831d828b 840 dev_dbg(mac_cb->dev, "mac%d phy_node: %s\n",
652d39b0
KY		 841 mac_cb->mac_id, np->name);
842 }
b2e45406 843 of_node_put(np);
652d39b0 844
831d828b
YZZ		 845 return 0;
846 }
652d39b0 847
8413b3be 848 if (is_of_node(mac_cb->fw_port)) {
1d1afa2e
KY		 849 /* parse property from port subnode in dsaf */
850 np = of_parse_phandle(to_of_node(mac_cb->fw_port),
851 "phy-handle", 0);
852 mac_cb->phy_dev = of_phy_find_device(np);
853 if (mac_cb->phy_dev) {
854 /* refcount is held by of_phy_find_device()
855 * if the phy_dev is found
856 */
857 put_device(&mac_cb->phy_dev->mdio.dev);
858 dev_dbg(mac_cb->dev, "mac%d phy_node: %s\n",
859 mac_cb->mac_id, np->name);
652d39b0 860 }
b2e45406 861 of_node_put(np);
652d39b0 862
b2e45406 863 np = of_parse_phandle(to_of_node(mac_cb->fw_port),
b917078c 864 "serdes-syscon", 0);
b2e45406
PC		 865 syscon = syscon_node_to_regmap(np);
866 of_node_put(np);
8413b3be
KY		 867 if (IS_ERR_OR_NULL(syscon)) {
868 dev_err(mac_cb->dev, "serdes-syscon is needed!\n");
869 return -EINVAL;
870 }
871 mac_cb->serdes_ctrl = syscon;
850bfa3b 872
8413b3be
KY		 873 ret = fwnode_property_read_u32(mac_cb->fw_port,
874 "port-rst-offset",
875 &mac_cb->port_rst_off);
876 if (ret) {
877 dev_dbg(mac_cb->dev,
878 "mac%d port-rst-offset not found, use default value.\n",
879 mac_cb->mac_id);
880 }
0d768fc6 881
8413b3be
KY		 882 ret = fwnode_property_read_u32(mac_cb->fw_port,
883 "port-mode-offset",
884 &mac_cb->port_mode_off);
885 if (ret) {
886 dev_dbg(mac_cb->dev,
887 "mac%d port-mode-offset not found, use default value.\n",
888 mac_cb->mac_id);
889 }
890
891 ret = of_parse_phandle_with_fixed_args(
892 to_of_node(mac_cb->fw_port), "cpld-syscon", 1, 0,
893 &cpld_args);
894 if (ret) {
895 dev_dbg(mac_cb->dev, "mac%d no cpld-syscon found.\n",
896 mac_cb->mac_id);
1ffdfac9
YZZ		 897 mac_cb->cpld_ctrl = NULL;
898 } else {
8413b3be
KY		 899 syscon = syscon_node_to_regmap(cpld_args.np);
900 if (IS_ERR_OR_NULL(syscon)) {
901 dev_dbg(mac_cb->dev, "no cpld-syscon found!\n");
902 mac_cb->cpld_ctrl = NULL;
903 } else {
904 mac_cb->cpld_ctrl = syscon;
905 mac_cb->cpld_ctrl_reg = cpld_args.args[0];
906 }
31d4446d 907 }
1d1afa2e 908 } else if (is_acpi_node(mac_cb->fw_port)) {
804ffe5c 909 ret = hns_mac_register_phy(mac_cb);
910 /*
911 * Mac can work well if there is phy or not.If the port don't
912 * connect with phy, the return value will be ignored. Only
913 * when there is phy but can't find mdio bus, the return value
914 * will be handled.
915 */
916 if (ret == -EPROBE_DEFER)
917 return ret;
1d1afa2e
KY		 918 } else {
919 dev_err(mac_cb->dev, "mac%d cannot find phy node\n",
920 mac_cb->mac_id);
31d4446d 921 }
1ffdfac9 922
5d2525f7
KY		 923 if (!fwnode_property_read_string(mac_cb->fw_port, "media-type",
924 &media_type)) {
925 for (i = 0; i < ARRAY_SIZE(media_type_defs); i++) {
926 if (!strncmp(media_type_defs[i].name, media_type,
927 MAC_MEDIA_TYPE_MAX_LEN)) {
928 mac_cb->media_type = media_type_defs[i].value;
929 break;
930 }
931 }
932 }
933
153b1d48
KY		 934 if (fwnode_property_read_u8_array(mac_cb->fw_port, "mc-mac-mask",
935 mac_cb->mc_mask, ETH_ALEN)) {
936 dev_warn(mac_cb->dev,
937 "no mc-mac-mask property, set to default value.\n");
938 eth_broadcast_addr(mac_cb->mc_mask);
939 }
940
831d828b 941 return 0;
511e6bc0 942}
943
944/**
945 * hns_mac_get_mode - get mac mode
946 * @phy_if: phy interface
947 * retuen 0 - gmac, 1 - xgmac , negative --fail
948 */
949static int hns_mac_get_mode(phy_interface_t phy_if)
950{
951 switch (phy_if) {
952 case PHY_INTERFACE_MODE_SGMII:
953 return MAC_GMAC_IDX;
954 case PHY_INTERFACE_MODE_XGMII:
955 return MAC_XGMAC_IDX;
956 default:
957 return -EINVAL;
958 }
959}
960
336a443b
Y		 961static u8 __iomem *
962hns_mac_get_vaddr(struct dsaf_device *dsaf_dev,
963 struct hns_mac_cb *mac_cb, u32 mac_mode_idx)
511e6bc0 964{
965 u8 __iomem *base = dsaf_dev->io_base;
966 int mac_id = mac_cb->mac_id;
967
968 if (mac_cb->mac_type == HNAE_PORT_SERVICE)
969 return base + 0x40000 + mac_id * 0x4000 -
970 mac_mode_idx * 0x20000;
971 else
831d828b 972 return dsaf_dev->ppe_base + 0x1000;
511e6bc0 973}
974
975/**
976 * hns_mac_get_cfg - get mac cfg from dtb or acpi table
977 * @dsaf_dev: dsa fabric device struct pointer
831d828b
YZZ		 978 * @mac_cb: mac control block
979 * return 0 - success , negative --fail
511e6bc0 980 */
336a443b
Y		 981static int
982hns_mac_get_cfg(struct dsaf_device *dsaf_dev, struct hns_mac_cb *mac_cb)
511e6bc0 983{
984 int ret;
985 u32 mac_mode_idx;
511e6bc0 986
987 mac_cb->dsaf_dev = dsaf_dev;
988 mac_cb->dev = dsaf_dev->dev;
511e6bc0 989
990 mac_cb->sys_ctl_vaddr = dsaf_dev->sc_base;
991 mac_cb->serdes_vaddr = dsaf_dev->sds_base;
992
511e6bc0 993 mac_cb->sfp_prsnt = 0;
994 mac_cb->txpkt_for_led = 0;
995 mac_cb->rxpkt_for_led = 0;
996
831d828b 997 if (!HNS_DSAF_IS_DEBUG(dsaf_dev))
511e6bc0 998 mac_cb->mac_type = HNAE_PORT_SERVICE;
999 else
1000 mac_cb->mac_type = HNAE_PORT_DEBUG;
1001
a24274aa 1002 mac_cb->phy_if = dsaf_dev->misc_op->get_phy_if(mac_cb);
511e6bc0 1003
1004 ret = hns_mac_get_mode(mac_cb->phy_if);
1005 if (ret < 0) {
1006 dev_err(dsaf_dev->dev,
451e856e 1007 "hns_mac_get_mode failed, mac%d ret = %#x!\n",
511e6bc0 1008 mac_cb->mac_id, ret);
1009 return ret;
1010 }
1011 mac_mode_idx = (u32)ret;
1012
831d828b
YZZ		 1013 ret = hns_mac_get_info(mac_cb);
1014 if (ret)
1015 return ret;
511e6bc0 1016
a24274aa 1017 mac_cb->dsaf_dev->misc_op->cpld_reset_led(mac_cb);
511e6bc0 1018 mac_cb->vaddr = hns_mac_get_vaddr(dsaf_dev, mac_cb, mac_mode_idx);
1019
1020 return 0;
1021}
1022
831d828b
YZZ		 1023static int hns_mac_get_max_port_num(struct dsaf_device *dsaf_dev)
1024{
1025 if (HNS_DSAF_IS_DEBUG(dsaf_dev))
1026 return 1;
1027 else
1028 return DSAF_MAX_PORT_NUM;
1029}
1030
31fabbee
PL		 1031void hns_mac_enable(struct hns_mac_cb *mac_cb, enum mac_commom_mode mode)
1032{
1033 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
1034
1035 mac_ctrl_drv->mac_enable(mac_cb->priv.mac, mode);
1036}
1037
1038void hns_mac_disable(struct hns_mac_cb *mac_cb, enum mac_commom_mode mode)
1039{
1040 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
1041
1042 mac_ctrl_drv->mac_disable(mac_cb->priv.mac, mode);
1043}
1044
511e6bc0 1045/**
1046 * hns_mac_init - init mac
1047 * @dsaf_dev: dsa fabric device struct pointer
831d828b 1048 * return 0 - success , negative --fail
511e6bc0 1049 */
1050int hns_mac_init(struct dsaf_device *dsaf_dev)
1051{
831d828b 1052 bool found = false;
511e6bc0 1053 int ret;
831d828b
YZZ		 1054 u32 port_id;
1055 int max_port_num = hns_mac_get_max_port_num(dsaf_dev);
511e6bc0 1056 struct hns_mac_cb *mac_cb;
831d828b 1057 struct fwnode_handle *child;
511e6bc0 1058
831d828b 1059 device_for_each_child_node(dsaf_dev->dev, child) {
0211b8fb 1060 ret = fwnode_property_read_u32(child, "reg", &port_id);
831d828b
YZZ		 1061 if (ret) {
1062 dev_err(dsaf_dev->dev,
0211b8fb 1063 "get reg fail, ret=%d!\n", ret);
831d828b
YZZ		 1064 return ret;
1065 }
1066 if (port_id >= max_port_num) {
1067 dev_err(dsaf_dev->dev,
0211b8fb 1068 "reg(%u) out of range!\n", port_id);
831d828b
YZZ		 1069 return -EINVAL;
1070 }
1071 mac_cb = devm_kzalloc(dsaf_dev->dev, sizeof(*mac_cb),
1072 GFP_KERNEL);
1073 if (!mac_cb)
1074 return -ENOMEM;
1075 mac_cb->fw_port = child;
1076 mac_cb->mac_id = (u8)port_id;
1077 dsaf_dev->mac_cb[port_id] = mac_cb;
1078 found = true;
1079 }
511e6bc0 1080
831d828b
YZZ		 1081 /* if don't get any port subnode from dsaf node
1082 * will init all port then, this is compatible with the old dts
1083 */
1084 if (!found) {
1085 for (port_id = 0; port_id < max_port_num; port_id++) {
1086 mac_cb = devm_kzalloc(dsaf_dev->dev, sizeof(*mac_cb),
1087 GFP_KERNEL);
1088 if (!mac_cb)
1089 return -ENOMEM;
1090
1091 mac_cb->mac_id = port_id;
1092 dsaf_dev->mac_cb[port_id] = mac_cb;
1093 }
1094 }
804ffe5c 1095
831d828b
YZZ		 1096 /* init mac_cb for all port */
1097 for (port_id = 0; port_id < max_port_num; port_id++) {
1098 mac_cb = dsaf_dev->mac_cb[port_id];
1099 if (!mac_cb)
1100 continue;
511e6bc0 1101
831d828b
YZZ		 1102 ret = hns_mac_get_cfg(dsaf_dev, mac_cb);
1103 if (ret)
1104 return ret;
804ffe5c 1105
511e6bc0 1106 ret = hns_mac_init_ex(mac_cb);
1107 if (ret)
831d828b 1108 return ret;
511e6bc0 1109 }
1110
1111 return 0;
511e6bc0 1112}
1113
1114void hns_mac_uninit(struct dsaf_device *dsaf_dev)
1115{
831d828b
YZZ		 1116 int i;
1117 int max_port_num = hns_mac_get_max_port_num(dsaf_dev);
1118
1119 for (i = 0; i < max_port_num; i++) {
a24274aa 1120 dsaf_dev->misc_op->cpld_reset_led(dsaf_dev->mac_cb[i]);
831d828b
YZZ		 1121 dsaf_dev->mac_cb[i] = NULL;
1122 }
511e6bc0 1123}
1124
1125int hns_mac_config_mac_loopback(struct hns_mac_cb *mac_cb,
1126 enum hnae_loop loop, int en)
1127{
1128 int ret;
1129 struct mac_driver *drv = hns_mac_get_drv(mac_cb);
1130
1131 if (drv->config_loopback)
1132 ret = drv->config_loopback(drv, loop, en);
1133 else
1134 ret = -ENOTSUPP;
1135
1136 return ret;
1137}
1138
1139void hns_mac_update_stats(struct hns_mac_cb *mac_cb)
1140{
1141 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
1142
1143 mac_ctrl_drv->update_stats(mac_ctrl_drv);
1144}
1145
1146void hns_mac_get_stats(struct hns_mac_cb *mac_cb, u64 *data)
1147{
1148 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
1149
1150 mac_ctrl_drv->get_ethtool_stats(mac_ctrl_drv, data);
1151}
1152
1153void hns_mac_get_strings(struct hns_mac_cb *mac_cb,
1154 int stringset, u8 *data)
1155{
1156 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
1157
1158 mac_ctrl_drv->get_strings(stringset, data);
1159}
1160
1161int hns_mac_get_sset_count(struct hns_mac_cb *mac_cb, int stringset)
1162{
1163 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
1164
1165 return mac_ctrl_drv->get_sset_count(stringset);
1166}
1167
d5679849
KY		 1168void hns_mac_set_promisc(struct hns_mac_cb *mac_cb, u8 en)
1169{
1170 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
1171
1f5fa2dd
KY		 1172 hns_dsaf_set_promisc_tcam(mac_cb->dsaf_dev, mac_cb->mac_id, !!en);
1173
d5679849
KY		 1174 if (mac_ctrl_drv->set_promiscuous)
1175 mac_ctrl_drv->set_promiscuous(mac_ctrl_drv, en);
1176}
1177
511e6bc0 1178int hns_mac_get_regs_count(struct hns_mac_cb *mac_cb)
1179{
1180 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
1181
1182 return mac_ctrl_drv->get_regs_count();
1183}
1184
1185void hns_mac_get_regs(struct hns_mac_cb *mac_cb, void *data)
1186{
1187 struct mac_driver *mac_ctrl_drv = hns_mac_get_drv(mac_cb);
1188
1189 mac_ctrl_drv->get_regs(mac_ctrl_drv, data);
1190}
1191
1192void hns_set_led_opt(struct hns_mac_cb *mac_cb)
1193{
1194 int nic_data = 0;
1195 int txpkts, rxpkts;
1196
1197 txpkts = mac_cb->txpkt_for_led - mac_cb->hw_stats.tx_good_pkts;
1198 rxpkts = mac_cb->rxpkt_for_led - mac_cb->hw_stats.rx_good_pkts;
1199 if (txpkts || rxpkts)
1200 nic_data = 1;
1201 else
1202 nic_data = 0;
1203 mac_cb->txpkt_for_led = mac_cb->hw_stats.tx_good_pkts;
1204 mac_cb->rxpkt_for_led = mac_cb->hw_stats.rx_good_pkts;
a24274aa 1205 mac_cb->dsaf_dev->misc_op->cpld_set_led(mac_cb, (int)mac_cb->link,
511e6bc0 1206 mac_cb->speed, nic_data);
1207}
1208
1209int hns_cpld_led_set_id(struct hns_mac_cb *mac_cb,
1210 enum hnae_led_state status)
1211{
3abbcccc 1212 if (!mac_cb)
511e6bc0 1213 return 0;
1214
a24274aa 1215 return mac_cb->dsaf_dev->misc_op->cpld_set_led_id(mac_cb, status);
511e6bc0 1216}
Linux 6.x block layer and io_uring tree(s)