1 /* Copyright 2008-2015 Freescale Semiconductor, Inc.
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are met:
5 * * Redistributions of source code must retain the above copyright
6 * notice, this list of conditions and the following disclaimer.
7 * * Redistributions in binary form must reproduce the above copyright
8 * notice, this list of conditions and the following disclaimer in the
9 * documentation and/or other materials provided with the distribution.
10 * * Neither the name of Freescale Semiconductor nor the
11 * names of its contributors may be used to endorse or promote products
12 * derived from this software without specific prior written permission.
15 * ALTERNATIVELY, this software may be distributed under the terms of the
16 * GNU General Public License ("GPL") as published by the Free Software
17 * Foundation, either version 2 of that License or (at your option) any
20 * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
21 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
24 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
34 #include <linux/init.h>
35 #include <linux/module.h>
36 #include <linux/of_address.h>
37 #include <linux/of_platform.h>
38 #include <linux/of_net.h>
39 #include <linux/of_mdio.h>
40 #include <linux/device.h>
41 #include <linux/phy.h>
42 #include <linux/netdevice.h>
43 #include <linux/phy_fixed.h>
44 #include <linux/etherdevice.h>
45 #include <linux/libfdt_env.h>
49 #include "fman_dtsec.h"
50 #include "fman_tgec.h"
51 #include "fman_memac.h"
53 MODULE_LICENSE("Dual BSD/GPL");
54 MODULE_DESCRIPTION("FSL FMan MAC API based driver");
60 phy_interface_t phy_if;
62 struct device_node *phy_node;
63 struct device_node *internal_phy_node;
64 /* List of multicast addresses */
65 struct list_head mc_addr_list;
66 struct platform_device *eth_dev;
67 struct fixed_phy_status *fixed_link;
71 int (*enable)(struct fman_mac *mac_dev, enum comm_mode mode);
72 int (*disable)(struct fman_mac *mac_dev, enum comm_mode mode);
77 struct list_head list;
80 static void mac_exception(void *handle, enum fman_mac_exceptions ex)
82 struct mac_device *mac_dev;
83 struct mac_priv_s *priv;
88 if (ex == FM_MAC_EX_10G_RX_FIFO_OVFL) {
89 /* don't flag RX FIFO after the first */
90 mac_dev->set_exception(mac_dev->fman_mac,
91 FM_MAC_EX_10G_RX_FIFO_OVFL, false);
92 dev_err(priv->dev, "10G MAC got RX FIFO Error = %x\n", ex);
95 dev_dbg(priv->dev, "%s:%s() -> %d\n", KBUILD_BASENAME ".c",
99 static int set_fman_mac_params(struct mac_device *mac_dev,
100 struct fman_mac_params *params)
102 struct mac_priv_s *priv = mac_dev->priv;
104 params->base_addr = (typeof(params->base_addr))
105 devm_ioremap(priv->dev, mac_dev->res->start,
106 resource_size(mac_dev->res));
107 if (!params->base_addr)
110 memcpy(¶ms->addr, mac_dev->addr, sizeof(mac_dev->addr));
111 params->max_speed = priv->max_speed;
112 params->phy_if = priv->phy_if;
113 params->basex_if = false;
114 params->mac_id = priv->cell_index;
115 params->fm = (void *)priv->fman;
116 params->exception_cb = mac_exception;
117 params->event_cb = mac_exception;
118 params->dev_id = mac_dev;
119 params->internal_phy_node = priv->internal_phy_node;
124 static int tgec_initialization(struct mac_device *mac_dev)
127 struct mac_priv_s *priv;
128 struct fman_mac_params params;
131 priv = mac_dev->priv;
133 err = set_fman_mac_params(mac_dev, ¶ms);
137 mac_dev->fman_mac = tgec_config(¶ms);
138 if (!mac_dev->fman_mac) {
143 err = tgec_cfg_max_frame_len(mac_dev->fman_mac, fman_get_max_frm());
145 goto _return_fm_mac_free;
147 err = tgec_init(mac_dev->fman_mac);
149 goto _return_fm_mac_free;
151 /* For 10G MAC, disable Tx ECC exception */
152 err = mac_dev->set_exception(mac_dev->fman_mac,
153 FM_MAC_EX_10G_TX_ECC_ER, false);
155 goto _return_fm_mac_free;
157 err = tgec_get_version(mac_dev->fman_mac, &version);
159 goto _return_fm_mac_free;
161 dev_info(priv->dev, "FMan XGEC version: 0x%08x\n", version);
166 tgec_free(mac_dev->fman_mac);
172 static int dtsec_initialization(struct mac_device *mac_dev)
175 struct mac_priv_s *priv;
176 struct fman_mac_params params;
179 priv = mac_dev->priv;
181 err = set_fman_mac_params(mac_dev, ¶ms);
185 mac_dev->fman_mac = dtsec_config(¶ms);
186 if (!mac_dev->fman_mac) {
191 err = dtsec_cfg_max_frame_len(mac_dev->fman_mac, fman_get_max_frm());
193 goto _return_fm_mac_free;
195 err = dtsec_cfg_pad_and_crc(mac_dev->fman_mac, true);
197 goto _return_fm_mac_free;
199 err = dtsec_init(mac_dev->fman_mac);
201 goto _return_fm_mac_free;
203 /* For 1G MAC, disable by default the MIB counters overflow interrupt */
204 err = mac_dev->set_exception(mac_dev->fman_mac,
205 FM_MAC_EX_1G_RX_MIB_CNT_OVFL, false);
207 goto _return_fm_mac_free;
209 err = dtsec_get_version(mac_dev->fman_mac, &version);
211 goto _return_fm_mac_free;
213 dev_info(priv->dev, "FMan dTSEC version: 0x%08x\n", version);
218 dtsec_free(mac_dev->fman_mac);
224 static int memac_initialization(struct mac_device *mac_dev)
227 struct mac_priv_s *priv;
228 struct fman_mac_params params;
230 priv = mac_dev->priv;
232 err = set_fman_mac_params(mac_dev, ¶ms);
236 if (priv->max_speed == SPEED_10000)
237 params.phy_if = PHY_INTERFACE_MODE_XGMII;
239 mac_dev->fman_mac = memac_config(¶ms);
240 if (!mac_dev->fman_mac) {
245 err = memac_cfg_max_frame_len(mac_dev->fman_mac, fman_get_max_frm());
247 goto _return_fm_mac_free;
249 err = memac_cfg_reset_on_init(mac_dev->fman_mac, true);
251 goto _return_fm_mac_free;
253 err = memac_cfg_fixed_link(mac_dev->fman_mac, priv->fixed_link);
255 goto _return_fm_mac_free;
257 err = memac_init(mac_dev->fman_mac);
259 goto _return_fm_mac_free;
261 dev_info(priv->dev, "FMan MEMAC\n");
266 memac_free(mac_dev->fman_mac);
272 static int start(struct mac_device *mac_dev)
275 struct phy_device *phy_dev = mac_dev->phy_dev;
276 struct mac_priv_s *priv = mac_dev->priv;
278 err = priv->enable(mac_dev->fman_mac, COMM_MODE_RX_AND_TX);
285 static int stop(struct mac_device *mac_dev)
287 struct mac_priv_s *priv = mac_dev->priv;
289 if (mac_dev->phy_dev)
290 phy_stop(mac_dev->phy_dev);
292 return priv->disable(mac_dev->fman_mac, COMM_MODE_RX_AND_TX);
295 static int set_multi(struct net_device *net_dev, struct mac_device *mac_dev)
297 struct mac_priv_s *priv;
298 struct mac_address *old_addr, *tmp;
299 struct netdev_hw_addr *ha;
303 priv = mac_dev->priv;
305 /* Clear previous address list */
306 list_for_each_entry_safe(old_addr, tmp, &priv->mc_addr_list, list) {
307 addr = (enet_addr_t *)old_addr->addr;
308 err = mac_dev->remove_hash_mac_addr(mac_dev->fman_mac, addr);
312 list_del(&old_addr->list);
316 /* Add all the addresses from the new list */
317 netdev_for_each_mc_addr(ha, net_dev) {
318 addr = (enet_addr_t *)ha->addr;
319 err = mac_dev->add_hash_mac_addr(mac_dev->fman_mac, addr);
323 tmp = kmalloc(sizeof(*tmp), GFP_ATOMIC);
327 ether_addr_copy(tmp->addr, ha->addr);
328 list_add(&tmp->list, &priv->mc_addr_list);
334 * fman_set_mac_active_pause
335 * @mac_dev: A pointer to the MAC device
336 * @rx: Pause frame setting for RX
337 * @tx: Pause frame setting for TX
339 * Set the MAC RX/TX PAUSE frames settings
341 * Avoid redundant calls to FMD, if the MAC driver already contains the desired
342 * active PAUSE settings. Otherwise, the new active settings should be reflected
345 * Return: 0 on success; Error code otherwise.
347 int fman_set_mac_active_pause(struct mac_device *mac_dev, bool rx, bool tx)
349 struct fman_mac *fman_mac = mac_dev->fman_mac;
352 if (rx != mac_dev->rx_pause_active) {
353 err = mac_dev->set_rx_pause(fman_mac, rx);
354 if (likely(err == 0))
355 mac_dev->rx_pause_active = rx;
358 if (tx != mac_dev->tx_pause_active) {
359 u16 pause_time = (tx ? FSL_FM_PAUSE_TIME_ENABLE :
360 FSL_FM_PAUSE_TIME_DISABLE);
362 err = mac_dev->set_tx_pause(fman_mac, 0, pause_time, 0);
364 if (likely(err == 0))
365 mac_dev->tx_pause_active = tx;
370 EXPORT_SYMBOL(fman_set_mac_active_pause);
374 * @mac_dev: A pointer to the MAC device
375 * @rx: Return value for RX setting
376 * @tx: Return value for TX setting
378 * Determine the MAC RX/TX PAUSE frames settings based on PHY
379 * autonegotiation or values set by eththool.
381 * Return: Pointer to FMan device.
383 void fman_get_pause_cfg(struct mac_device *mac_dev, bool *rx_pause,
386 struct phy_device *phy_dev = mac_dev->phy_dev;
387 u16 lcl_adv, rmt_adv;
390 *rx_pause = *tx_pause = false;
392 if (!phy_dev->duplex)
395 /* If PAUSE autonegotiation is disabled, the TX/RX PAUSE settings
396 * are those set by ethtool.
398 if (!mac_dev->autoneg_pause) {
399 *rx_pause = mac_dev->rx_pause_req;
400 *tx_pause = mac_dev->tx_pause_req;
404 /* Else if PAUSE autonegotiation is enabled, the TX/RX PAUSE
405 * settings depend on the result of the link negotiation.
408 /* get local capabilities */
410 if (phy_dev->advertising & ADVERTISED_Pause)
411 lcl_adv |= ADVERTISE_PAUSE_CAP;
412 if (phy_dev->advertising & ADVERTISED_Asym_Pause)
413 lcl_adv |= ADVERTISE_PAUSE_ASYM;
415 /* get link partner capabilities */
418 rmt_adv |= LPA_PAUSE_CAP;
419 if (phy_dev->asym_pause)
420 rmt_adv |= LPA_PAUSE_ASYM;
422 /* Calculate TX/RX settings based on local and peer advertised
423 * symmetric/asymmetric PAUSE capabilities.
425 flowctrl = mii_resolve_flowctrl_fdx(lcl_adv, rmt_adv);
426 if (flowctrl & FLOW_CTRL_RX)
428 if (flowctrl & FLOW_CTRL_TX)
431 EXPORT_SYMBOL(fman_get_pause_cfg);
433 static void adjust_link_void(struct net_device *net_dev)
437 static void adjust_link_dtsec(struct net_device *net_dev)
439 struct device *dev = net_dev->dev.parent;
440 struct dpaa_eth_data *eth_data = dev->platform_data;
441 struct mac_device *mac_dev = eth_data->mac_dev;
442 struct phy_device *phy_dev = mac_dev->phy_dev;
443 struct fman_mac *fman_mac;
444 bool rx_pause, tx_pause;
447 fman_mac = mac_dev->fman_mac;
448 if (!phy_dev->link) {
449 dtsec_restart_autoneg(fman_mac);
454 dtsec_adjust_link(fman_mac, phy_dev->speed);
455 fman_get_pause_cfg(mac_dev, &rx_pause, &tx_pause);
456 err = fman_set_mac_active_pause(mac_dev, rx_pause, tx_pause);
458 netdev_err(net_dev, "fman_set_mac_active_pause() = %d\n", err);
461 static void adjust_link_memac(struct net_device *net_dev)
463 struct device *dev = net_dev->dev.parent;
464 struct dpaa_eth_data *eth_data = dev->platform_data;
465 struct mac_device *mac_dev = eth_data->mac_dev;
466 struct phy_device *phy_dev = mac_dev->phy_dev;
467 struct fman_mac *fman_mac;
468 bool rx_pause, tx_pause;
471 fman_mac = mac_dev->fman_mac;
472 memac_adjust_link(fman_mac, phy_dev->speed);
474 fman_get_pause_cfg(mac_dev, &rx_pause, &tx_pause);
475 err = fman_set_mac_active_pause(mac_dev, rx_pause, tx_pause);
477 netdev_err(net_dev, "fman_set_mac_active_pause() = %d\n", err);
480 /* Initializes driver's PHY state, and attaches to the PHY.
481 * Returns 0 on success.
483 static struct phy_device *init_phy(struct net_device *net_dev,
484 struct mac_device *mac_dev,
485 void (*adj_lnk)(struct net_device *))
487 struct phy_device *phy_dev;
488 struct mac_priv_s *priv = mac_dev->priv;
490 phy_dev = of_phy_connect(net_dev, priv->phy_node, adj_lnk, 0,
493 netdev_err(net_dev, "Could not connect to PHY\n");
497 /* Remove any features not supported by the controller */
498 phy_dev->supported &= mac_dev->if_support;
499 /* Enable the symmetric and asymmetric PAUSE frame advertisements,
500 * as most of the PHY drivers do not enable them by default.
502 phy_dev->supported |= (SUPPORTED_Pause | SUPPORTED_Asym_Pause);
503 phy_dev->advertising = phy_dev->supported;
505 mac_dev->phy_dev = phy_dev;
510 static struct phy_device *dtsec_init_phy(struct net_device *net_dev,
511 struct mac_device *mac_dev)
513 return init_phy(net_dev, mac_dev, &adjust_link_dtsec);
516 static struct phy_device *tgec_init_phy(struct net_device *net_dev,
517 struct mac_device *mac_dev)
519 return init_phy(net_dev, mac_dev, adjust_link_void);
522 static struct phy_device *memac_init_phy(struct net_device *net_dev,
523 struct mac_device *mac_dev)
525 return init_phy(net_dev, mac_dev, &adjust_link_memac);
528 static void setup_dtsec(struct mac_device *mac_dev)
530 mac_dev->init_phy = dtsec_init_phy;
531 mac_dev->init = dtsec_initialization;
532 mac_dev->set_promisc = dtsec_set_promiscuous;
533 mac_dev->change_addr = dtsec_modify_mac_address;
534 mac_dev->add_hash_mac_addr = dtsec_add_hash_mac_address;
535 mac_dev->remove_hash_mac_addr = dtsec_del_hash_mac_address;
536 mac_dev->set_tx_pause = dtsec_set_tx_pause_frames;
537 mac_dev->set_rx_pause = dtsec_accept_rx_pause_frames;
538 mac_dev->set_exception = dtsec_set_exception;
539 mac_dev->set_multi = set_multi;
540 mac_dev->start = start;
541 mac_dev->stop = stop;
543 mac_dev->priv->enable = dtsec_enable;
544 mac_dev->priv->disable = dtsec_disable;
547 static void setup_tgec(struct mac_device *mac_dev)
549 mac_dev->init_phy = tgec_init_phy;
550 mac_dev->init = tgec_initialization;
551 mac_dev->set_promisc = tgec_set_promiscuous;
552 mac_dev->change_addr = tgec_modify_mac_address;
553 mac_dev->add_hash_mac_addr = tgec_add_hash_mac_address;
554 mac_dev->remove_hash_mac_addr = tgec_del_hash_mac_address;
555 mac_dev->set_tx_pause = tgec_set_tx_pause_frames;
556 mac_dev->set_rx_pause = tgec_accept_rx_pause_frames;
557 mac_dev->set_exception = tgec_set_exception;
558 mac_dev->set_multi = set_multi;
559 mac_dev->start = start;
560 mac_dev->stop = stop;
562 mac_dev->priv->enable = tgec_enable;
563 mac_dev->priv->disable = tgec_disable;
566 static void setup_memac(struct mac_device *mac_dev)
568 mac_dev->init_phy = memac_init_phy;
569 mac_dev->init = memac_initialization;
570 mac_dev->set_promisc = memac_set_promiscuous;
571 mac_dev->change_addr = memac_modify_mac_address;
572 mac_dev->add_hash_mac_addr = memac_add_hash_mac_address;
573 mac_dev->remove_hash_mac_addr = memac_del_hash_mac_address;
574 mac_dev->set_tx_pause = memac_set_tx_pause_frames;
575 mac_dev->set_rx_pause = memac_accept_rx_pause_frames;
576 mac_dev->set_exception = memac_set_exception;
577 mac_dev->set_multi = set_multi;
578 mac_dev->start = start;
579 mac_dev->stop = stop;
581 mac_dev->priv->enable = memac_enable;
582 mac_dev->priv->disable = memac_disable;
585 #define DTSEC_SUPPORTED \
586 (SUPPORTED_10baseT_Half \
587 | SUPPORTED_10baseT_Full \
588 | SUPPORTED_100baseT_Half \
589 | SUPPORTED_100baseT_Full \
590 | SUPPORTED_Autoneg \
592 | SUPPORTED_Asym_Pause \
595 static DEFINE_MUTEX(eth_lock);
597 static const u16 phy2speed[] = {
598 [PHY_INTERFACE_MODE_MII] = SPEED_100,
599 [PHY_INTERFACE_MODE_GMII] = SPEED_1000,
600 [PHY_INTERFACE_MODE_SGMII] = SPEED_1000,
601 [PHY_INTERFACE_MODE_TBI] = SPEED_1000,
602 [PHY_INTERFACE_MODE_RMII] = SPEED_100,
603 [PHY_INTERFACE_MODE_RGMII] = SPEED_1000,
604 [PHY_INTERFACE_MODE_RGMII_ID] = SPEED_1000,
605 [PHY_INTERFACE_MODE_RGMII_RXID] = SPEED_1000,
606 [PHY_INTERFACE_MODE_RGMII_TXID] = SPEED_1000,
607 [PHY_INTERFACE_MODE_RTBI] = SPEED_1000,
608 [PHY_INTERFACE_MODE_XGMII] = SPEED_10000
611 static struct platform_device *dpaa_eth_add_device(int fman_id,
612 struct mac_device *mac_dev,
613 struct device_node *node)
615 struct platform_device *pdev;
616 struct dpaa_eth_data data;
617 struct mac_priv_s *priv;
618 static int dpaa_eth_dev_cnt;
621 priv = mac_dev->priv;
623 data.mac_dev = mac_dev;
624 data.mac_hw_id = priv->cell_index;
625 data.fman_hw_id = fman_id;
626 data.mac_node = node;
628 mutex_lock(ð_lock);
630 pdev = platform_device_alloc("dpaa-ethernet", dpaa_eth_dev_cnt);
636 pdev->dev.of_node = node;
637 pdev->dev.parent = priv->dev;
639 ret = platform_device_add_data(pdev, &data, sizeof(data));
643 ret = platform_device_add(pdev);
648 mutex_unlock(ð_lock);
653 platform_device_put(pdev);
655 mutex_unlock(ð_lock);
660 static const struct of_device_id mac_match[] = {
661 { .compatible = "fsl,fman-dtsec" },
662 { .compatible = "fsl,fman-xgec" },
663 { .compatible = "fsl,fman-memac" },
666 MODULE_DEVICE_TABLE(of, mac_match);
668 static int mac_probe(struct platform_device *_of_dev)
672 struct device_node *mac_node, *dev_node;
673 struct mac_device *mac_dev;
674 struct platform_device *of_dev;
676 struct mac_priv_s *priv;
683 mac_node = dev->of_node;
685 mac_dev = devm_kzalloc(dev, sizeof(*mac_dev), GFP_KERNEL);
688 dev_err(dev, "devm_kzalloc() = %d\n", err);
691 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
697 /* Save private information */
698 mac_dev->priv = priv;
701 if (of_device_is_compatible(mac_node, "fsl,fman-dtsec")) {
702 setup_dtsec(mac_dev);
703 priv->internal_phy_node = of_parse_phandle(mac_node,
705 } else if (of_device_is_compatible(mac_node, "fsl,fman-xgec")) {
707 } else if (of_device_is_compatible(mac_node, "fsl,fman-memac")) {
708 setup_memac(mac_dev);
709 priv->internal_phy_node = of_parse_phandle(mac_node,
712 dev_err(dev, "MAC node (%s) contains unsupported MAC\n",
713 mac_node->full_name);
718 /* Register mac_dev */
719 dev_set_drvdata(dev, mac_dev);
721 INIT_LIST_HEAD(&priv->mc_addr_list);
723 /* Get the FM node */
724 dev_node = of_get_parent(mac_node);
726 dev_err(dev, "of_get_parent(%s) failed\n",
727 mac_node->full_name);
729 goto _return_dev_set_drvdata;
732 of_dev = of_find_device_by_node(dev_node);
734 dev_err(dev, "of_find_device_by_node(%s) failed\n",
735 dev_node->full_name);
737 goto _return_of_node_put;
740 /* Get the FMan cell-index */
741 err = of_property_read_u32(dev_node, "cell-index", &val);
743 dev_err(dev, "failed to read cell-index for %s\n",
744 dev_node->full_name);
746 goto _return_of_node_put;
748 /* cell-index 0 => FMan id 1 */
749 fman_id = (u8)(val + 1);
751 priv->fman = fman_bind(&of_dev->dev);
753 dev_err(dev, "fman_bind(%s) failed\n", dev_node->full_name);
755 goto _return_of_node_put;
758 of_node_put(dev_node);
760 /* Get the address of the memory mapped registers */
761 err = of_address_to_resource(mac_node, 0, &res);
763 dev_err(dev, "of_address_to_resource(%s) = %d\n",
764 mac_node->full_name, err);
765 goto _return_dev_set_drvdata;
768 mac_dev->res = __devm_request_region(dev,
769 fman_get_mem_region(priv->fman),
770 res.start, res.end + 1 - res.start,
773 dev_err(dev, "__devm_request_mem_region(mac) failed\n");
775 goto _return_dev_set_drvdata;
778 priv->vaddr = devm_ioremap(dev, mac_dev->res->start,
779 mac_dev->res->end + 1 - mac_dev->res->start);
781 dev_err(dev, "devm_ioremap() failed\n");
783 goto _return_dev_set_drvdata;
786 if (!of_device_is_available(mac_node)) {
787 devm_iounmap(dev, priv->vaddr);
788 __devm_release_region(dev, fman_get_mem_region(priv->fman),
789 res.start, res.end + 1 - res.start);
790 devm_kfree(dev, mac_dev);
791 dev_set_drvdata(dev, NULL);
795 /* Get the cell-index */
796 err = of_property_read_u32(mac_node, "cell-index", &val);
798 dev_err(dev, "failed to read cell-index for %s\n",
799 mac_node->full_name);
801 goto _return_dev_set_drvdata;
803 priv->cell_index = (u8)val;
805 /* Get the MAC address */
806 mac_addr = of_get_mac_address(mac_node);
808 dev_err(dev, "of_get_mac_address(%s) failed\n",
809 mac_node->full_name);
811 goto _return_dev_set_drvdata;
813 memcpy(mac_dev->addr, mac_addr, sizeof(mac_dev->addr));
815 /* Get the port handles */
816 nph = of_count_phandle_with_args(mac_node, "fsl,fman-ports", NULL);
817 if (unlikely(nph < 0)) {
818 dev_err(dev, "of_count_phandle_with_args(%s, fsl,fman-ports) failed\n",
819 mac_node->full_name);
821 goto _return_dev_set_drvdata;
824 if (nph != ARRAY_SIZE(mac_dev->port)) {
825 dev_err(dev, "Not supported number of fman-ports handles of mac node %s from device tree\n",
826 mac_node->full_name);
828 goto _return_dev_set_drvdata;
831 for (i = 0; i < ARRAY_SIZE(mac_dev->port); i++) {
832 /* Find the port node */
833 dev_node = of_parse_phandle(mac_node, "fsl,fman-ports", i);
835 dev_err(dev, "of_parse_phandle(%s, fsl,fman-ports) failed\n",
836 mac_node->full_name);
838 goto _return_of_node_put;
841 of_dev = of_find_device_by_node(dev_node);
843 dev_err(dev, "of_find_device_by_node(%s) failed\n",
844 dev_node->full_name);
846 goto _return_of_node_put;
849 mac_dev->port[i] = fman_port_bind(&of_dev->dev);
850 if (!mac_dev->port[i]) {
851 dev_err(dev, "dev_get_drvdata(%s) failed\n",
852 dev_node->full_name);
854 goto _return_of_node_put;
856 of_node_put(dev_node);
859 /* Get the PHY connection type */
860 phy_if = of_get_phy_mode(mac_node);
863 "of_get_phy_mode() for %s failed. Defaulting to SGMII\n",
864 mac_node->full_name);
865 phy_if = PHY_INTERFACE_MODE_SGMII;
867 priv->phy_if = phy_if;
869 priv->speed = phy2speed[priv->phy_if];
870 priv->max_speed = priv->speed;
871 mac_dev->if_support = DTSEC_SUPPORTED;
872 /* We don't support half-duplex in SGMII mode */
873 if (priv->phy_if == PHY_INTERFACE_MODE_SGMII)
874 mac_dev->if_support &= ~(SUPPORTED_10baseT_Half |
875 SUPPORTED_100baseT_Half);
877 /* Gigabit support (no half-duplex) */
878 if (priv->max_speed == 1000)
879 mac_dev->if_support |= SUPPORTED_1000baseT_Full;
881 /* The 10G interface only supports one mode */
882 if (priv->phy_if == PHY_INTERFACE_MODE_XGMII)
883 mac_dev->if_support = SUPPORTED_10000baseT_Full;
885 /* Get the rest of the PHY information */
886 priv->phy_node = of_parse_phandle(mac_node, "phy-handle", 0);
887 if (!priv->phy_node && of_phy_is_fixed_link(mac_node)) {
888 struct phy_device *phy;
890 err = of_phy_register_fixed_link(mac_node);
892 goto _return_dev_set_drvdata;
894 priv->fixed_link = kzalloc(sizeof(*priv->fixed_link),
896 if (!priv->fixed_link)
897 goto _return_dev_set_drvdata;
899 priv->phy_node = of_node_get(mac_node);
900 phy = of_phy_find_device(priv->phy_node);
902 goto _return_dev_set_drvdata;
904 priv->fixed_link->link = phy->link;
905 priv->fixed_link->speed = phy->speed;
906 priv->fixed_link->duplex = phy->duplex;
907 priv->fixed_link->pause = phy->pause;
908 priv->fixed_link->asym_pause = phy->asym_pause;
910 put_device(&phy->mdio.dev);
913 err = mac_dev->init(mac_dev);
915 dev_err(dev, "mac_dev->init() = %d\n", err);
916 of_node_put(priv->phy_node);
917 goto _return_dev_set_drvdata;
920 /* pause frame autonegotiation enabled */
921 mac_dev->autoneg_pause = true;
923 /* By intializing the values to false, force FMD to enable PAUSE frames
926 mac_dev->rx_pause_req = true;
927 mac_dev->tx_pause_req = true;
928 mac_dev->rx_pause_active = false;
929 mac_dev->tx_pause_active = false;
930 err = fman_set_mac_active_pause(mac_dev, true, true);
932 dev_err(dev, "fman_set_mac_active_pause() = %d\n", err);
934 dev_info(dev, "FMan MAC address: %02hx:%02hx:%02hx:%02hx:%02hx:%02hx\n",
935 mac_dev->addr[0], mac_dev->addr[1], mac_dev->addr[2],
936 mac_dev->addr[3], mac_dev->addr[4], mac_dev->addr[5]);
938 priv->eth_dev = dpaa_eth_add_device(fman_id, mac_dev, mac_node);
939 if (IS_ERR(priv->eth_dev)) {
940 dev_err(dev, "failed to add Ethernet platform device for MAC %d\n",
942 priv->eth_dev = NULL;
948 of_node_put(dev_node);
949 _return_dev_set_drvdata:
950 kfree(priv->fixed_link);
951 dev_set_drvdata(dev, NULL);
956 static struct platform_driver mac_driver = {
958 .name = KBUILD_MODNAME,
959 .of_match_table = mac_match,
964 builtin_platform_driver(mac_driver);