1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2021 Gerhard Engleder <gerhard@engleder-embedded.com> */
4 /* TSN endpoint Ethernet MAC driver
6 * The TSN endpoint Ethernet MAC is a FPGA based network device for real-time
7 * communication. It is designed for endpoints within TSN (Time Sensitive
8 * Networking) networks; e.g., for PLCs in the industrial automation case.
10 * It supports multiple TX/RX queue pairs. The first TX/RX queue pair is used
13 * More information can be found here:
14 * - www.embedded-experts.at/tsn
15 * - www.engleder-embedded.com
21 #include <linux/module.h>
23 #include <linux/of_net.h>
24 #include <linux/of_mdio.h>
25 #include <linux/interrupt.h>
26 #include <linux/etherdevice.h>
27 #include <linux/phy.h>
28 #include <linux/iopoll.h>
30 #define TSNEP_SKB_PAD (NET_SKB_PAD + NET_IP_ALIGN)
31 #define TSNEP_HEADROOM ALIGN(TSNEP_SKB_PAD, 4)
32 #define TSNEP_MAX_RX_BUF_SIZE (PAGE_SIZE - TSNEP_HEADROOM - \
33 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
35 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
36 #define DMA_ADDR_HIGH(dma_addr) ((u32)(((dma_addr) >> 32) & 0xFFFFFFFF))
38 #define DMA_ADDR_HIGH(dma_addr) ((u32)(0))
40 #define DMA_ADDR_LOW(dma_addr) ((u32)((dma_addr) & 0xFFFFFFFF))
42 #define TSNEP_COALESCE_USECS_DEFAULT 64
43 #define TSNEP_COALESCE_USECS_MAX ((ECM_INT_DELAY_MASK >> ECM_INT_DELAY_SHIFT) * \
44 ECM_INT_DELAY_BASE_US + ECM_INT_DELAY_BASE_US - 1)
46 static void tsnep_enable_irq(struct tsnep_adapter *adapter, u32 mask)
48 iowrite32(mask, adapter->addr + ECM_INT_ENABLE);
51 static void tsnep_disable_irq(struct tsnep_adapter *adapter, u32 mask)
53 mask |= ECM_INT_DISABLE;
54 iowrite32(mask, adapter->addr + ECM_INT_ENABLE);
57 static irqreturn_t tsnep_irq(int irq, void *arg)
59 struct tsnep_adapter *adapter = arg;
60 u32 active = ioread32(adapter->addr + ECM_INT_ACTIVE);
62 /* acknowledge interrupt */
64 iowrite32(active, adapter->addr + ECM_INT_ACKNOWLEDGE);
66 /* handle link interrupt */
67 if ((active & ECM_INT_LINK) != 0)
68 phy_mac_interrupt(adapter->netdev->phydev);
70 /* handle TX/RX queue 0 interrupt */
71 if ((active & adapter->queue[0].irq_mask) != 0) {
72 tsnep_disable_irq(adapter, adapter->queue[0].irq_mask);
73 napi_schedule(&adapter->queue[0].napi);
79 static irqreturn_t tsnep_irq_txrx(int irq, void *arg)
81 struct tsnep_queue *queue = arg;
83 /* handle TX/RX queue interrupt */
84 tsnep_disable_irq(queue->adapter, queue->irq_mask);
85 napi_schedule(&queue->napi);
90 int tsnep_set_irq_coalesce(struct tsnep_queue *queue, u32 usecs)
92 if (usecs > TSNEP_COALESCE_USECS_MAX)
95 usecs /= ECM_INT_DELAY_BASE_US;
96 usecs <<= ECM_INT_DELAY_SHIFT;
97 usecs &= ECM_INT_DELAY_MASK;
99 queue->irq_delay &= ~ECM_INT_DELAY_MASK;
100 queue->irq_delay |= usecs;
101 iowrite8(queue->irq_delay, queue->irq_delay_addr);
106 u32 tsnep_get_irq_coalesce(struct tsnep_queue *queue)
110 usecs = (queue->irq_delay & ECM_INT_DELAY_MASK);
111 usecs >>= ECM_INT_DELAY_SHIFT;
112 usecs *= ECM_INT_DELAY_BASE_US;
117 static int tsnep_mdiobus_read(struct mii_bus *bus, int addr, int regnum)
119 struct tsnep_adapter *adapter = bus->priv;
123 if (regnum & MII_ADDR_C45)
127 if (!adapter->suppress_preamble)
128 md |= ECM_MD_PREAMBLE;
129 md |= (regnum << ECM_MD_ADDR_SHIFT) & ECM_MD_ADDR_MASK;
130 md |= (addr << ECM_MD_PHY_ADDR_SHIFT) & ECM_MD_PHY_ADDR_MASK;
131 iowrite32(md, adapter->addr + ECM_MD_CONTROL);
132 retval = readl_poll_timeout_atomic(adapter->addr + ECM_MD_STATUS, md,
133 !(md & ECM_MD_BUSY), 16, 1000);
137 return (md & ECM_MD_DATA_MASK) >> ECM_MD_DATA_SHIFT;
140 static int tsnep_mdiobus_write(struct mii_bus *bus, int addr, int regnum,
143 struct tsnep_adapter *adapter = bus->priv;
147 if (regnum & MII_ADDR_C45)
151 if (!adapter->suppress_preamble)
152 md |= ECM_MD_PREAMBLE;
153 md |= (regnum << ECM_MD_ADDR_SHIFT) & ECM_MD_ADDR_MASK;
154 md |= (addr << ECM_MD_PHY_ADDR_SHIFT) & ECM_MD_PHY_ADDR_MASK;
155 md |= ((u32)val << ECM_MD_DATA_SHIFT) & ECM_MD_DATA_MASK;
156 iowrite32(md, adapter->addr + ECM_MD_CONTROL);
157 retval = readl_poll_timeout_atomic(adapter->addr + ECM_MD_STATUS, md,
158 !(md & ECM_MD_BUSY), 16, 1000);
165 static void tsnep_set_link_mode(struct tsnep_adapter *adapter)
169 switch (adapter->phydev->speed) {
171 mode = ECM_LINK_MODE_100;
174 mode = ECM_LINK_MODE_1000;
177 mode = ECM_LINK_MODE_OFF;
180 iowrite32(mode, adapter->addr + ECM_STATUS);
183 static void tsnep_phy_link_status_change(struct net_device *netdev)
185 struct tsnep_adapter *adapter = netdev_priv(netdev);
186 struct phy_device *phydev = netdev->phydev;
189 tsnep_set_link_mode(adapter);
191 phy_print_status(netdev->phydev);
194 static int tsnep_phy_loopback(struct tsnep_adapter *adapter, bool enable)
198 retval = phy_loopback(adapter->phydev, enable);
200 /* PHY link state change is not signaled if loopback is enabled, it
201 * would delay a working loopback anyway, let's ensure that loopback
202 * is working immediately by setting link mode directly
204 if (!retval && enable)
205 tsnep_set_link_mode(adapter);
210 static int tsnep_phy_open(struct tsnep_adapter *adapter)
212 struct phy_device *phydev;
213 struct ethtool_eee ethtool_eee;
216 retval = phy_connect_direct(adapter->netdev, adapter->phydev,
217 tsnep_phy_link_status_change,
221 phydev = adapter->netdev->phydev;
223 /* MAC supports only 100Mbps|1000Mbps full duplex
224 * SPE (Single Pair Ethernet) is also an option but not implemented yet
226 phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_10baseT_Half_BIT);
227 phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_10baseT_Full_BIT);
228 phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_100baseT_Half_BIT);
229 phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
231 /* disable EEE autoneg, EEE not supported by TSNEP */
232 memset(ðtool_eee, 0, sizeof(ethtool_eee));
233 phy_ethtool_set_eee(adapter->phydev, ðtool_eee);
235 adapter->phydev->irq = PHY_MAC_INTERRUPT;
236 phy_start(adapter->phydev);
241 static void tsnep_phy_close(struct tsnep_adapter *adapter)
243 phy_stop(adapter->netdev->phydev);
244 phy_disconnect(adapter->netdev->phydev);
245 adapter->netdev->phydev = NULL;
248 static void tsnep_tx_ring_cleanup(struct tsnep_tx *tx)
250 struct device *dmadev = tx->adapter->dmadev;
253 memset(tx->entry, 0, sizeof(tx->entry));
255 for (i = 0; i < TSNEP_RING_PAGE_COUNT; i++) {
257 dma_free_coherent(dmadev, PAGE_SIZE, tx->page[i],
265 static int tsnep_tx_ring_init(struct tsnep_tx *tx)
267 struct device *dmadev = tx->adapter->dmadev;
268 struct tsnep_tx_entry *entry;
269 struct tsnep_tx_entry *next_entry;
273 for (i = 0; i < TSNEP_RING_PAGE_COUNT; i++) {
275 dma_alloc_coherent(dmadev, PAGE_SIZE, &tx->page_dma[i],
281 for (j = 0; j < TSNEP_RING_ENTRIES_PER_PAGE; j++) {
282 entry = &tx->entry[TSNEP_RING_ENTRIES_PER_PAGE * i + j];
283 entry->desc_wb = (struct tsnep_tx_desc_wb *)
284 (((u8 *)tx->page[i]) + TSNEP_DESC_SIZE * j);
285 entry->desc = (struct tsnep_tx_desc *)
286 (((u8 *)entry->desc_wb) + TSNEP_DESC_OFFSET);
287 entry->desc_dma = tx->page_dma[i] + TSNEP_DESC_SIZE * j;
290 for (i = 0; i < TSNEP_RING_SIZE; i++) {
291 entry = &tx->entry[i];
292 next_entry = &tx->entry[(i + 1) % TSNEP_RING_SIZE];
293 entry->desc->next = __cpu_to_le64(next_entry->desc_dma);
299 tsnep_tx_ring_cleanup(tx);
303 static void tsnep_tx_activate(struct tsnep_tx *tx, int index, int length,
306 struct tsnep_tx_entry *entry = &tx->entry[index];
308 entry->properties = 0;
310 entry->properties = length & TSNEP_DESC_LENGTH_MASK;
311 entry->properties |= TSNEP_DESC_INTERRUPT_FLAG;
312 if (skb_shinfo(entry->skb)->tx_flags & SKBTX_IN_PROGRESS)
313 entry->properties |= TSNEP_DESC_EXTENDED_WRITEBACK_FLAG;
315 /* toggle user flag to prevent false acknowledge
317 * Only the first fragment is acknowledged. For all other
318 * fragments no acknowledge is done and the last written owner
319 * counter stays in the writeback descriptor. Therefore, it is
320 * possible that the last written owner counter is identical to
321 * the new incremented owner counter and a false acknowledge is
322 * detected before the real acknowledge has been done by
325 * The user flag is used to prevent this situation. The user
326 * flag is copied to the writeback descriptor by the hardware
327 * and is used as additional acknowledge data. By toggeling the
328 * user flag only for the first fragment (which is
329 * acknowledged), it is guaranteed that the last acknowledge
330 * done for this descriptor has used a different user flag and
331 * cannot be detected as false acknowledge.
333 entry->owner_user_flag = !entry->owner_user_flag;
336 entry->properties |= TSNEP_TX_DESC_LAST_FRAGMENT_FLAG;
337 if (index == tx->increment_owner_counter) {
339 if (tx->owner_counter == 4)
340 tx->owner_counter = 1;
341 tx->increment_owner_counter--;
342 if (tx->increment_owner_counter < 0)
343 tx->increment_owner_counter = TSNEP_RING_SIZE - 1;
346 (tx->owner_counter << TSNEP_DESC_OWNER_COUNTER_SHIFT) &
347 TSNEP_DESC_OWNER_COUNTER_MASK;
348 if (entry->owner_user_flag)
349 entry->properties |= TSNEP_TX_DESC_OWNER_USER_FLAG;
350 entry->desc->more_properties =
351 __cpu_to_le32(entry->len & TSNEP_DESC_LENGTH_MASK);
353 /* descriptor properties shall be written last, because valid data is
358 entry->desc->properties = __cpu_to_le32(entry->properties);
361 static int tsnep_tx_desc_available(struct tsnep_tx *tx)
363 if (tx->read <= tx->write)
364 return TSNEP_RING_SIZE - tx->write + tx->read - 1;
366 return tx->read - tx->write - 1;
369 static int tsnep_tx_map(struct sk_buff *skb, struct tsnep_tx *tx, int count)
371 struct device *dmadev = tx->adapter->dmadev;
372 struct tsnep_tx_entry *entry;
378 for (i = 0; i < count; i++) {
379 entry = &tx->entry[(tx->write + i) % TSNEP_RING_SIZE];
382 len = skb_headlen(skb);
383 dma = dma_map_single(dmadev, skb->data, len,
386 len = skb_frag_size(&skb_shinfo(skb)->frags[i - 1]);
387 dma = skb_frag_dma_map(dmadev,
388 &skb_shinfo(skb)->frags[i - 1],
389 0, len, DMA_TO_DEVICE);
391 if (dma_mapping_error(dmadev, dma))
395 dma_unmap_addr_set(entry, dma, dma);
397 entry->desc->tx = __cpu_to_le64(dma);
405 static int tsnep_tx_unmap(struct tsnep_tx *tx, int index, int count)
407 struct device *dmadev = tx->adapter->dmadev;
408 struct tsnep_tx_entry *entry;
412 for (i = 0; i < count; i++) {
413 entry = &tx->entry[(index + i) % TSNEP_RING_SIZE];
417 dma_unmap_single(dmadev,
418 dma_unmap_addr(entry, dma),
419 dma_unmap_len(entry, len),
422 dma_unmap_page(dmadev,
423 dma_unmap_addr(entry, dma),
424 dma_unmap_len(entry, len),
426 map_len += entry->len;
434 static netdev_tx_t tsnep_xmit_frame_ring(struct sk_buff *skb,
439 struct tsnep_tx_entry *entry;
444 if (skb_shinfo(skb)->nr_frags > 0)
445 count += skb_shinfo(skb)->nr_frags;
447 spin_lock_irqsave(&tx->lock, flags);
449 if (tsnep_tx_desc_available(tx) < count) {
450 /* ring full, shall not happen because queue is stopped if full
453 netif_stop_subqueue(tx->adapter->netdev, tx->queue_index);
455 spin_unlock_irqrestore(&tx->lock, flags);
457 return NETDEV_TX_BUSY;
460 entry = &tx->entry[tx->write];
463 retval = tsnep_tx_map(skb, tx, count);
465 tsnep_tx_unmap(tx, tx->write, count);
466 dev_kfree_skb_any(entry->skb);
471 spin_unlock_irqrestore(&tx->lock, flags);
473 netdev_err(tx->adapter->netdev, "TX DMA map failed\n");
479 if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)
480 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
482 for (i = 0; i < count; i++)
483 tsnep_tx_activate(tx, (tx->write + i) % TSNEP_RING_SIZE, length,
485 tx->write = (tx->write + count) % TSNEP_RING_SIZE;
487 skb_tx_timestamp(skb);
489 /* descriptor properties shall be valid before hardware is notified */
492 iowrite32(TSNEP_CONTROL_TX_ENABLE, tx->addr + TSNEP_CONTROL);
494 if (tsnep_tx_desc_available(tx) < (MAX_SKB_FRAGS + 1)) {
495 /* ring can get full with next frame */
496 netif_stop_subqueue(tx->adapter->netdev, tx->queue_index);
499 spin_unlock_irqrestore(&tx->lock, flags);
504 static bool tsnep_tx_poll(struct tsnep_tx *tx, int napi_budget)
506 struct tsnep_tx_entry *entry;
507 struct netdev_queue *nq;
513 nq = netdev_get_tx_queue(tx->adapter->netdev, tx->queue_index);
515 spin_lock_irqsave(&tx->lock, flags);
518 if (tx->read == tx->write)
521 entry = &tx->entry[tx->read];
522 if ((__le32_to_cpu(entry->desc_wb->properties) &
523 TSNEP_TX_DESC_OWNER_MASK) !=
524 (entry->properties & TSNEP_TX_DESC_OWNER_MASK))
527 /* descriptor properties shall be read first, because valid data
533 if (skb_shinfo(entry->skb)->nr_frags > 0)
534 count += skb_shinfo(entry->skb)->nr_frags;
536 length = tsnep_tx_unmap(tx, tx->read, count);
538 if ((skb_shinfo(entry->skb)->tx_flags & SKBTX_IN_PROGRESS) &&
539 (__le32_to_cpu(entry->desc_wb->properties) &
540 TSNEP_DESC_EXTENDED_WRITEBACK_FLAG)) {
541 struct skb_shared_hwtstamps hwtstamps;
544 if (skb_shinfo(entry->skb)->tx_flags &
545 SKBTX_HW_TSTAMP_USE_CYCLES)
547 __le64_to_cpu(entry->desc_wb->counter);
550 __le64_to_cpu(entry->desc_wb->timestamp);
552 memset(&hwtstamps, 0, sizeof(hwtstamps));
553 hwtstamps.hwtstamp = ns_to_ktime(timestamp);
555 skb_tstamp_tx(entry->skb, &hwtstamps);
558 napi_consume_skb(entry->skb, budget);
561 tx->read = (tx->read + count) % TSNEP_RING_SIZE;
564 tx->bytes += length + ETH_FCS_LEN;
567 } while (likely(budget));
569 if ((tsnep_tx_desc_available(tx) >= ((MAX_SKB_FRAGS + 1) * 2)) &&
570 netif_tx_queue_stopped(nq)) {
571 netif_tx_wake_queue(nq);
574 spin_unlock_irqrestore(&tx->lock, flags);
576 return (budget != 0);
579 static bool tsnep_tx_pending(struct tsnep_tx *tx)
582 struct tsnep_tx_entry *entry;
583 bool pending = false;
585 spin_lock_irqsave(&tx->lock, flags);
587 if (tx->read != tx->write) {
588 entry = &tx->entry[tx->read];
589 if ((__le32_to_cpu(entry->desc_wb->properties) &
590 TSNEP_TX_DESC_OWNER_MASK) ==
591 (entry->properties & TSNEP_TX_DESC_OWNER_MASK))
595 spin_unlock_irqrestore(&tx->lock, flags);
600 static int tsnep_tx_open(struct tsnep_adapter *adapter, void __iomem *addr,
601 int queue_index, struct tsnep_tx *tx)
606 memset(tx, 0, sizeof(*tx));
607 tx->adapter = adapter;
609 tx->queue_index = queue_index;
611 retval = tsnep_tx_ring_init(tx);
615 dma = tx->entry[0].desc_dma | TSNEP_RESET_OWNER_COUNTER;
616 iowrite32(DMA_ADDR_LOW(dma), tx->addr + TSNEP_TX_DESC_ADDR_LOW);
617 iowrite32(DMA_ADDR_HIGH(dma), tx->addr + TSNEP_TX_DESC_ADDR_HIGH);
618 tx->owner_counter = 1;
619 tx->increment_owner_counter = TSNEP_RING_SIZE - 1;
621 spin_lock_init(&tx->lock);
626 static void tsnep_tx_close(struct tsnep_tx *tx)
630 readx_poll_timeout(ioread32, tx->addr + TSNEP_CONTROL, val,
631 ((val & TSNEP_CONTROL_TX_ENABLE) == 0), 10000,
634 tsnep_tx_ring_cleanup(tx);
637 static void tsnep_rx_ring_cleanup(struct tsnep_rx *rx)
639 struct device *dmadev = rx->adapter->dmadev;
640 struct tsnep_rx_entry *entry;
643 for (i = 0; i < TSNEP_RING_SIZE; i++) {
644 entry = &rx->entry[i];
646 page_pool_put_full_page(rx->page_pool, entry->page,
652 page_pool_destroy(rx->page_pool);
654 memset(rx->entry, 0, sizeof(rx->entry));
656 for (i = 0; i < TSNEP_RING_PAGE_COUNT; i++) {
658 dma_free_coherent(dmadev, PAGE_SIZE, rx->page[i],
666 static int tsnep_rx_ring_init(struct tsnep_rx *rx)
668 struct device *dmadev = rx->adapter->dmadev;
669 struct tsnep_rx_entry *entry;
670 struct page_pool_params pp_params = { 0 };
671 struct tsnep_rx_entry *next_entry;
675 for (i = 0; i < TSNEP_RING_PAGE_COUNT; i++) {
677 dma_alloc_coherent(dmadev, PAGE_SIZE, &rx->page_dma[i],
683 for (j = 0; j < TSNEP_RING_ENTRIES_PER_PAGE; j++) {
684 entry = &rx->entry[TSNEP_RING_ENTRIES_PER_PAGE * i + j];
685 entry->desc_wb = (struct tsnep_rx_desc_wb *)
686 (((u8 *)rx->page[i]) + TSNEP_DESC_SIZE * j);
687 entry->desc = (struct tsnep_rx_desc *)
688 (((u8 *)entry->desc_wb) + TSNEP_DESC_OFFSET);
689 entry->desc_dma = rx->page_dma[i] + TSNEP_DESC_SIZE * j;
693 pp_params.flags = PP_FLAG_DMA_MAP | PP_FLAG_DMA_SYNC_DEV;
695 pp_params.pool_size = TSNEP_RING_SIZE;
696 pp_params.nid = dev_to_node(dmadev);
697 pp_params.dev = dmadev;
698 pp_params.dma_dir = DMA_FROM_DEVICE;
699 pp_params.max_len = TSNEP_MAX_RX_BUF_SIZE;
700 pp_params.offset = TSNEP_SKB_PAD;
701 rx->page_pool = page_pool_create(&pp_params);
702 if (IS_ERR(rx->page_pool)) {
703 retval = PTR_ERR(rx->page_pool);
704 rx->page_pool = NULL;
708 for (i = 0; i < TSNEP_RING_SIZE; i++) {
709 entry = &rx->entry[i];
710 next_entry = &rx->entry[(i + 1) % TSNEP_RING_SIZE];
711 entry->desc->next = __cpu_to_le64(next_entry->desc_dma);
717 tsnep_rx_ring_cleanup(rx);
721 static int tsnep_rx_desc_available(struct tsnep_rx *rx)
723 if (rx->read <= rx->write)
724 return TSNEP_RING_SIZE - rx->write + rx->read - 1;
726 return rx->read - rx->write - 1;
729 static void tsnep_rx_set_page(struct tsnep_rx *rx, struct tsnep_rx_entry *entry,
733 entry->len = TSNEP_MAX_RX_BUF_SIZE;
734 entry->dma = page_pool_get_dma_addr(entry->page);
735 entry->desc->rx = __cpu_to_le64(entry->dma + TSNEP_SKB_PAD);
738 static int tsnep_rx_alloc_buffer(struct tsnep_rx *rx, int index)
740 struct tsnep_rx_entry *entry = &rx->entry[index];
743 page = page_pool_dev_alloc_pages(rx->page_pool);
746 tsnep_rx_set_page(rx, entry, page);
751 static void tsnep_rx_reuse_buffer(struct tsnep_rx *rx, int index)
753 struct tsnep_rx_entry *entry = &rx->entry[index];
754 struct tsnep_rx_entry *read = &rx->entry[rx->read];
756 tsnep_rx_set_page(rx, entry, read->page);
760 static void tsnep_rx_activate(struct tsnep_rx *rx, int index)
762 struct tsnep_rx_entry *entry = &rx->entry[index];
764 /* TSNEP_MAX_RX_BUF_SIZE is a multiple of 4 */
765 entry->properties = entry->len & TSNEP_DESC_LENGTH_MASK;
766 entry->properties |= TSNEP_DESC_INTERRUPT_FLAG;
767 if (index == rx->increment_owner_counter) {
769 if (rx->owner_counter == 4)
770 rx->owner_counter = 1;
771 rx->increment_owner_counter--;
772 if (rx->increment_owner_counter < 0)
773 rx->increment_owner_counter = TSNEP_RING_SIZE - 1;
776 (rx->owner_counter << TSNEP_DESC_OWNER_COUNTER_SHIFT) &
777 TSNEP_DESC_OWNER_COUNTER_MASK;
779 /* descriptor properties shall be written last, because valid data is
784 entry->desc->properties = __cpu_to_le32(entry->properties);
787 static int tsnep_rx_refill(struct tsnep_rx *rx, int count, bool reuse)
790 bool alloc_failed = false;
795 for (i = 0; i < count && !alloc_failed; i++) {
796 index = (rx->write + i) % TSNEP_RING_SIZE;
798 retval = tsnep_rx_alloc_buffer(rx, index);
799 if (unlikely(retval)) {
803 /* reuse only if no other allocation was successful */
805 tsnep_rx_reuse_buffer(rx, index);
810 tsnep_rx_activate(rx, index);
816 rx->write = (rx->write + i) % TSNEP_RING_SIZE;
818 /* descriptor properties shall be valid before hardware is
823 iowrite32(TSNEP_CONTROL_RX_ENABLE, rx->addr + TSNEP_CONTROL);
829 static struct sk_buff *tsnep_build_skb(struct tsnep_rx *rx, struct page *page,
834 skb = napi_build_skb(page_address(page), PAGE_SIZE);
838 /* update pointers within the skb to store the data */
839 skb_reserve(skb, TSNEP_SKB_PAD + TSNEP_RX_INLINE_METADATA_SIZE);
840 __skb_put(skb, length - TSNEP_RX_INLINE_METADATA_SIZE - ETH_FCS_LEN);
842 if (rx->adapter->hwtstamp_config.rx_filter == HWTSTAMP_FILTER_ALL) {
843 struct skb_shared_hwtstamps *hwtstamps = skb_hwtstamps(skb);
844 struct tsnep_rx_inline *rx_inline =
845 (struct tsnep_rx_inline *)(page_address(page) +
848 skb_shinfo(skb)->tx_flags |=
849 SKBTX_HW_TSTAMP_NETDEV;
850 memset(hwtstamps, 0, sizeof(*hwtstamps));
851 hwtstamps->netdev_data = rx_inline;
854 skb_record_rx_queue(skb, rx->queue_index);
855 skb->protocol = eth_type_trans(skb, rx->adapter->netdev);
860 static int tsnep_rx_poll(struct tsnep_rx *rx, struct napi_struct *napi,
863 struct device *dmadev = rx->adapter->dmadev;
866 enum dma_data_direction dma_dir;
867 struct tsnep_rx_entry *entry;
871 desc_available = tsnep_rx_desc_available(rx);
872 dma_dir = page_pool_get_dma_dir(rx->page_pool);
874 while (likely(done < budget) && (rx->read != rx->write)) {
875 entry = &rx->entry[rx->read];
876 if ((__le32_to_cpu(entry->desc_wb->properties) &
877 TSNEP_DESC_OWNER_COUNTER_MASK) !=
878 (entry->properties & TSNEP_DESC_OWNER_COUNTER_MASK))
882 if (desc_available >= TSNEP_RING_RX_REFILL) {
883 bool reuse = desc_available >= TSNEP_RING_RX_REUSE;
885 desc_available -= tsnep_rx_refill(rx, desc_available,
888 /* buffer has been reused for refill to prevent
889 * empty RX ring, thus buffer cannot be used for
892 rx->read = (rx->read + 1) % TSNEP_RING_SIZE;
901 /* descriptor properties shall be read first, because valid data
906 prefetch(page_address(entry->page) + TSNEP_SKB_PAD);
907 length = __le32_to_cpu(entry->desc_wb->properties) &
908 TSNEP_DESC_LENGTH_MASK;
909 dma_sync_single_range_for_cpu(dmadev, entry->dma, TSNEP_SKB_PAD,
912 rx->read = (rx->read + 1) % TSNEP_RING_SIZE;
915 skb = tsnep_build_skb(rx, entry->page, length);
917 page_pool_release_page(rx->page_pool, entry->page);
920 rx->bytes += length - TSNEP_RX_INLINE_METADATA_SIZE;
921 if (skb->pkt_type == PACKET_MULTICAST)
924 napi_gro_receive(napi, skb);
926 page_pool_recycle_direct(rx->page_pool, entry->page);
934 tsnep_rx_refill(rx, desc_available, false);
939 static bool tsnep_rx_pending(struct tsnep_rx *rx)
941 struct tsnep_rx_entry *entry;
943 if (rx->read != rx->write) {
944 entry = &rx->entry[rx->read];
945 if ((__le32_to_cpu(entry->desc_wb->properties) &
946 TSNEP_DESC_OWNER_COUNTER_MASK) ==
947 (entry->properties & TSNEP_DESC_OWNER_COUNTER_MASK))
954 static int tsnep_rx_open(struct tsnep_adapter *adapter, void __iomem *addr,
955 int queue_index, struct tsnep_rx *rx)
960 memset(rx, 0, sizeof(*rx));
961 rx->adapter = adapter;
963 rx->queue_index = queue_index;
965 retval = tsnep_rx_ring_init(rx);
969 dma = rx->entry[0].desc_dma | TSNEP_RESET_OWNER_COUNTER;
970 iowrite32(DMA_ADDR_LOW(dma), rx->addr + TSNEP_RX_DESC_ADDR_LOW);
971 iowrite32(DMA_ADDR_HIGH(dma), rx->addr + TSNEP_RX_DESC_ADDR_HIGH);
972 rx->owner_counter = 1;
973 rx->increment_owner_counter = TSNEP_RING_SIZE - 1;
975 tsnep_rx_refill(rx, tsnep_rx_desc_available(rx), false);
980 static void tsnep_rx_close(struct tsnep_rx *rx)
984 iowrite32(TSNEP_CONTROL_RX_DISABLE, rx->addr + TSNEP_CONTROL);
985 readx_poll_timeout(ioread32, rx->addr + TSNEP_CONTROL, val,
986 ((val & TSNEP_CONTROL_RX_ENABLE) == 0), 10000,
989 tsnep_rx_ring_cleanup(rx);
992 static bool tsnep_pending(struct tsnep_queue *queue)
994 if (queue->tx && tsnep_tx_pending(queue->tx))
997 if (queue->rx && tsnep_rx_pending(queue->rx))
1003 static int tsnep_poll(struct napi_struct *napi, int budget)
1005 struct tsnep_queue *queue = container_of(napi, struct tsnep_queue,
1007 bool complete = true;
1011 complete = tsnep_tx_poll(queue->tx, budget);
1014 done = tsnep_rx_poll(queue->rx, napi, budget);
1019 /* if all work not completed, return budget and keep polling */
1023 if (likely(napi_complete_done(napi, done))) {
1024 tsnep_enable_irq(queue->adapter, queue->irq_mask);
1026 /* reschedule if work is already pending, prevent rotten packets
1027 * which are transmitted or received after polling but before
1030 if (tsnep_pending(queue)) {
1031 tsnep_disable_irq(queue->adapter, queue->irq_mask);
1032 napi_schedule(napi);
1036 return min(done, budget - 1);
1039 static int tsnep_request_irq(struct tsnep_queue *queue, bool first)
1041 const char *name = netdev_name(queue->adapter->netdev);
1042 irq_handler_t handler;
1047 sprintf(queue->name, "%s-mac", name);
1048 handler = tsnep_irq;
1049 dev = queue->adapter;
1051 if (queue->tx && queue->rx)
1052 sprintf(queue->name, "%s-txrx-%d", name,
1053 queue->rx->queue_index);
1055 sprintf(queue->name, "%s-tx-%d", name,
1056 queue->tx->queue_index);
1058 sprintf(queue->name, "%s-rx-%d", name,
1059 queue->rx->queue_index);
1060 handler = tsnep_irq_txrx;
1064 retval = request_irq(queue->irq, handler, 0, queue->name, dev);
1066 /* if name is empty, then interrupt won't be freed */
1067 memset(queue->name, 0, sizeof(queue->name));
1073 static void tsnep_free_irq(struct tsnep_queue *queue, bool first)
1077 if (!strlen(queue->name))
1081 dev = queue->adapter;
1085 free_irq(queue->irq, dev);
1086 memset(queue->name, 0, sizeof(queue->name));
1089 static int tsnep_netdev_open(struct net_device *netdev)
1091 struct tsnep_adapter *adapter = netdev_priv(netdev);
1094 int tx_queue_index = 0;
1095 int rx_queue_index = 0;
1098 for (i = 0; i < adapter->num_queues; i++) {
1099 adapter->queue[i].adapter = adapter;
1100 if (adapter->queue[i].tx) {
1101 addr = adapter->addr + TSNEP_QUEUE(tx_queue_index);
1102 retval = tsnep_tx_open(adapter, addr, tx_queue_index,
1103 adapter->queue[i].tx);
1108 if (adapter->queue[i].rx) {
1109 addr = adapter->addr + TSNEP_QUEUE(rx_queue_index);
1110 retval = tsnep_rx_open(adapter, addr,
1112 adapter->queue[i].rx);
1118 retval = tsnep_request_irq(&adapter->queue[i], i == 0);
1120 netif_err(adapter, drv, adapter->netdev,
1121 "can't get assigned irq %d.\n",
1122 adapter->queue[i].irq);
1127 retval = netif_set_real_num_tx_queues(adapter->netdev,
1128 adapter->num_tx_queues);
1131 retval = netif_set_real_num_rx_queues(adapter->netdev,
1132 adapter->num_rx_queues);
1136 tsnep_enable_irq(adapter, ECM_INT_LINK);
1137 retval = tsnep_phy_open(adapter);
1141 for (i = 0; i < adapter->num_queues; i++) {
1142 netif_napi_add(adapter->netdev, &adapter->queue[i].napi,
1144 napi_enable(&adapter->queue[i].napi);
1146 tsnep_enable_irq(adapter, adapter->queue[i].irq_mask);
1152 tsnep_disable_irq(adapter, ECM_INT_LINK);
1153 tsnep_phy_close(adapter);
1155 for (i = 0; i < adapter->num_queues; i++) {
1156 tsnep_free_irq(&adapter->queue[i], i == 0);
1158 if (adapter->queue[i].rx)
1159 tsnep_rx_close(adapter->queue[i].rx);
1160 if (adapter->queue[i].tx)
1161 tsnep_tx_close(adapter->queue[i].tx);
1166 static int tsnep_netdev_close(struct net_device *netdev)
1168 struct tsnep_adapter *adapter = netdev_priv(netdev);
1171 tsnep_disable_irq(adapter, ECM_INT_LINK);
1172 tsnep_phy_close(adapter);
1174 for (i = 0; i < adapter->num_queues; i++) {
1175 tsnep_disable_irq(adapter, adapter->queue[i].irq_mask);
1177 napi_disable(&adapter->queue[i].napi);
1178 netif_napi_del(&adapter->queue[i].napi);
1180 tsnep_free_irq(&adapter->queue[i], i == 0);
1182 if (adapter->queue[i].rx)
1183 tsnep_rx_close(adapter->queue[i].rx);
1184 if (adapter->queue[i].tx)
1185 tsnep_tx_close(adapter->queue[i].tx);
1191 static netdev_tx_t tsnep_netdev_xmit_frame(struct sk_buff *skb,
1192 struct net_device *netdev)
1194 struct tsnep_adapter *adapter = netdev_priv(netdev);
1195 u16 queue_mapping = skb_get_queue_mapping(skb);
1197 if (queue_mapping >= adapter->num_tx_queues)
1200 return tsnep_xmit_frame_ring(skb, &adapter->tx[queue_mapping]);
1203 static int tsnep_netdev_ioctl(struct net_device *netdev, struct ifreq *ifr,
1206 if (!netif_running(netdev))
1208 if (cmd == SIOCSHWTSTAMP || cmd == SIOCGHWTSTAMP)
1209 return tsnep_ptp_ioctl(netdev, ifr, cmd);
1210 return phy_mii_ioctl(netdev->phydev, ifr, cmd);
1213 static void tsnep_netdev_set_multicast(struct net_device *netdev)
1215 struct tsnep_adapter *adapter = netdev_priv(netdev);
1219 /* configured MAC address and broadcasts are never filtered */
1220 if (netdev->flags & IFF_PROMISC) {
1221 rx_filter |= TSNEP_RX_FILTER_ACCEPT_ALL_MULTICASTS;
1222 rx_filter |= TSNEP_RX_FILTER_ACCEPT_ALL_UNICASTS;
1223 } else if (!netdev_mc_empty(netdev) || (netdev->flags & IFF_ALLMULTI)) {
1224 rx_filter |= TSNEP_RX_FILTER_ACCEPT_ALL_MULTICASTS;
1226 iowrite16(rx_filter, adapter->addr + TSNEP_RX_FILTER);
1229 static void tsnep_netdev_get_stats64(struct net_device *netdev,
1230 struct rtnl_link_stats64 *stats)
1232 struct tsnep_adapter *adapter = netdev_priv(netdev);
1237 for (i = 0; i < adapter->num_tx_queues; i++) {
1238 stats->tx_packets += adapter->tx[i].packets;
1239 stats->tx_bytes += adapter->tx[i].bytes;
1240 stats->tx_dropped += adapter->tx[i].dropped;
1242 for (i = 0; i < adapter->num_rx_queues; i++) {
1243 stats->rx_packets += adapter->rx[i].packets;
1244 stats->rx_bytes += adapter->rx[i].bytes;
1245 stats->rx_dropped += adapter->rx[i].dropped;
1246 stats->multicast += adapter->rx[i].multicast;
1248 reg = ioread32(adapter->addr + TSNEP_QUEUE(i) +
1249 TSNEP_RX_STATISTIC);
1250 val = (reg & TSNEP_RX_STATISTIC_NO_DESC_MASK) >>
1251 TSNEP_RX_STATISTIC_NO_DESC_SHIFT;
1252 stats->rx_dropped += val;
1253 val = (reg & TSNEP_RX_STATISTIC_BUFFER_TOO_SMALL_MASK) >>
1254 TSNEP_RX_STATISTIC_BUFFER_TOO_SMALL_SHIFT;
1255 stats->rx_dropped += val;
1256 val = (reg & TSNEP_RX_STATISTIC_FIFO_OVERFLOW_MASK) >>
1257 TSNEP_RX_STATISTIC_FIFO_OVERFLOW_SHIFT;
1258 stats->rx_errors += val;
1259 stats->rx_fifo_errors += val;
1260 val = (reg & TSNEP_RX_STATISTIC_INVALID_FRAME_MASK) >>
1261 TSNEP_RX_STATISTIC_INVALID_FRAME_SHIFT;
1262 stats->rx_errors += val;
1263 stats->rx_frame_errors += val;
1266 reg = ioread32(adapter->addr + ECM_STAT);
1267 val = (reg & ECM_STAT_RX_ERR_MASK) >> ECM_STAT_RX_ERR_SHIFT;
1268 stats->rx_errors += val;
1269 val = (reg & ECM_STAT_INV_FRM_MASK) >> ECM_STAT_INV_FRM_SHIFT;
1270 stats->rx_errors += val;
1271 stats->rx_crc_errors += val;
1272 val = (reg & ECM_STAT_FWD_RX_ERR_MASK) >> ECM_STAT_FWD_RX_ERR_SHIFT;
1273 stats->rx_errors += val;
1276 static void tsnep_mac_set_address(struct tsnep_adapter *adapter, u8 *addr)
1278 iowrite32(*(u32 *)addr, adapter->addr + TSNEP_MAC_ADDRESS_LOW);
1279 iowrite16(*(u16 *)(addr + sizeof(u32)),
1280 adapter->addr + TSNEP_MAC_ADDRESS_HIGH);
1282 ether_addr_copy(adapter->mac_address, addr);
1283 netif_info(adapter, drv, adapter->netdev, "MAC address set to %pM\n",
1287 static int tsnep_netdev_set_mac_address(struct net_device *netdev, void *addr)
1289 struct tsnep_adapter *adapter = netdev_priv(netdev);
1290 struct sockaddr *sock_addr = addr;
1293 retval = eth_prepare_mac_addr_change(netdev, sock_addr);
1296 eth_hw_addr_set(netdev, sock_addr->sa_data);
1297 tsnep_mac_set_address(adapter, sock_addr->sa_data);
1302 static int tsnep_netdev_set_features(struct net_device *netdev,
1303 netdev_features_t features)
1305 struct tsnep_adapter *adapter = netdev_priv(netdev);
1306 netdev_features_t changed = netdev->features ^ features;
1310 if (changed & NETIF_F_LOOPBACK) {
1311 enable = !!(features & NETIF_F_LOOPBACK);
1312 retval = tsnep_phy_loopback(adapter, enable);
1318 static ktime_t tsnep_netdev_get_tstamp(struct net_device *netdev,
1319 const struct skb_shared_hwtstamps *hwtstamps,
1322 struct tsnep_rx_inline *rx_inline = hwtstamps->netdev_data;
1326 timestamp = __le64_to_cpu(rx_inline->counter);
1328 timestamp = __le64_to_cpu(rx_inline->timestamp);
1330 return ns_to_ktime(timestamp);
1333 static const struct net_device_ops tsnep_netdev_ops = {
1334 .ndo_open = tsnep_netdev_open,
1335 .ndo_stop = tsnep_netdev_close,
1336 .ndo_start_xmit = tsnep_netdev_xmit_frame,
1337 .ndo_eth_ioctl = tsnep_netdev_ioctl,
1338 .ndo_set_rx_mode = tsnep_netdev_set_multicast,
1339 .ndo_get_stats64 = tsnep_netdev_get_stats64,
1340 .ndo_set_mac_address = tsnep_netdev_set_mac_address,
1341 .ndo_set_features = tsnep_netdev_set_features,
1342 .ndo_get_tstamp = tsnep_netdev_get_tstamp,
1343 .ndo_setup_tc = tsnep_tc_setup,
1346 static int tsnep_mac_init(struct tsnep_adapter *adapter)
1350 /* initialize RX filtering, at least configured MAC address and
1351 * broadcast are not filtered
1353 iowrite16(0, adapter->addr + TSNEP_RX_FILTER);
1355 /* try to get MAC address in the following order:
1357 * - valid MAC address already set
1358 * - MAC address register if valid
1359 * - random MAC address
1361 retval = of_get_mac_address(adapter->pdev->dev.of_node,
1362 adapter->mac_address);
1363 if (retval == -EPROBE_DEFER)
1365 if (retval && !is_valid_ether_addr(adapter->mac_address)) {
1366 *(u32 *)adapter->mac_address =
1367 ioread32(adapter->addr + TSNEP_MAC_ADDRESS_LOW);
1368 *(u16 *)(adapter->mac_address + sizeof(u32)) =
1369 ioread16(adapter->addr + TSNEP_MAC_ADDRESS_HIGH);
1370 if (!is_valid_ether_addr(adapter->mac_address))
1371 eth_random_addr(adapter->mac_address);
1374 tsnep_mac_set_address(adapter, adapter->mac_address);
1375 eth_hw_addr_set(adapter->netdev, adapter->mac_address);
1380 static int tsnep_mdio_init(struct tsnep_adapter *adapter)
1382 struct device_node *np = adapter->pdev->dev.of_node;
1386 np = of_get_child_by_name(np, "mdio");
1390 adapter->suppress_preamble =
1391 of_property_read_bool(np, "suppress-preamble");
1394 adapter->mdiobus = devm_mdiobus_alloc(&adapter->pdev->dev);
1395 if (!adapter->mdiobus) {
1401 adapter->mdiobus->priv = (void *)adapter;
1402 adapter->mdiobus->parent = &adapter->pdev->dev;
1403 adapter->mdiobus->read = tsnep_mdiobus_read;
1404 adapter->mdiobus->write = tsnep_mdiobus_write;
1405 adapter->mdiobus->name = TSNEP "-mdiobus";
1406 snprintf(adapter->mdiobus->id, MII_BUS_ID_SIZE, "%s",
1407 adapter->pdev->name);
1409 /* do not scan broadcast address */
1410 adapter->mdiobus->phy_mask = 0x0000001;
1412 retval = of_mdiobus_register(adapter->mdiobus, np);
1420 static int tsnep_phy_init(struct tsnep_adapter *adapter)
1422 struct device_node *phy_node;
1425 retval = of_get_phy_mode(adapter->pdev->dev.of_node,
1426 &adapter->phy_mode);
1428 adapter->phy_mode = PHY_INTERFACE_MODE_GMII;
1430 phy_node = of_parse_phandle(adapter->pdev->dev.of_node, "phy-handle",
1432 adapter->phydev = of_phy_find_device(phy_node);
1433 of_node_put(phy_node);
1434 if (!adapter->phydev && adapter->mdiobus)
1435 adapter->phydev = phy_find_first(adapter->mdiobus);
1436 if (!adapter->phydev)
1442 static int tsnep_queue_init(struct tsnep_adapter *adapter, int queue_count)
1444 u32 irq_mask = ECM_INT_TX_0 | ECM_INT_RX_0;
1449 /* one TX/RX queue pair for netdev is mandatory */
1450 if (platform_irq_count(adapter->pdev) == 1)
1451 retval = platform_get_irq(adapter->pdev, 0);
1453 retval = platform_get_irq_byname(adapter->pdev, "mac");
1456 adapter->num_tx_queues = 1;
1457 adapter->num_rx_queues = 1;
1458 adapter->num_queues = 1;
1459 adapter->queue[0].irq = retval;
1460 adapter->queue[0].tx = &adapter->tx[0];
1461 adapter->queue[0].rx = &adapter->rx[0];
1462 adapter->queue[0].irq_mask = irq_mask;
1463 adapter->queue[0].irq_delay_addr = adapter->addr + ECM_INT_DELAY;
1464 retval = tsnep_set_irq_coalesce(&adapter->queue[0],
1465 TSNEP_COALESCE_USECS_DEFAULT);
1469 adapter->netdev->irq = adapter->queue[0].irq;
1471 /* add additional TX/RX queue pairs only if dedicated interrupt is
1474 for (i = 1; i < queue_count; i++) {
1475 sprintf(name, "txrx-%d", i);
1476 retval = platform_get_irq_byname_optional(adapter->pdev, name);
1480 adapter->num_tx_queues++;
1481 adapter->num_rx_queues++;
1482 adapter->num_queues++;
1483 adapter->queue[i].irq = retval;
1484 adapter->queue[i].tx = &adapter->tx[i];
1485 adapter->queue[i].rx = &adapter->rx[i];
1486 adapter->queue[i].irq_mask =
1487 irq_mask << (ECM_INT_TXRX_SHIFT * i);
1488 adapter->queue[i].irq_delay_addr =
1489 adapter->addr + ECM_INT_DELAY + ECM_INT_DELAY_OFFSET * i;
1490 retval = tsnep_set_irq_coalesce(&adapter->queue[i],
1491 TSNEP_COALESCE_USECS_DEFAULT);
1499 static int tsnep_probe(struct platform_device *pdev)
1501 struct tsnep_adapter *adapter;
1502 struct net_device *netdev;
1503 struct resource *io;
1510 netdev = devm_alloc_etherdev_mqs(&pdev->dev,
1511 sizeof(struct tsnep_adapter),
1512 TSNEP_MAX_QUEUES, TSNEP_MAX_QUEUES);
1515 SET_NETDEV_DEV(netdev, &pdev->dev);
1516 adapter = netdev_priv(netdev);
1517 platform_set_drvdata(pdev, adapter);
1518 adapter->pdev = pdev;
1519 adapter->dmadev = &pdev->dev;
1520 adapter->netdev = netdev;
1521 adapter->msg_enable = NETIF_MSG_DRV | NETIF_MSG_PROBE |
1522 NETIF_MSG_LINK | NETIF_MSG_IFUP |
1523 NETIF_MSG_IFDOWN | NETIF_MSG_TX_QUEUED;
1525 netdev->min_mtu = ETH_MIN_MTU;
1526 netdev->max_mtu = TSNEP_MAX_FRAME_SIZE;
1528 mutex_init(&adapter->gate_control_lock);
1529 mutex_init(&adapter->rxnfc_lock);
1530 INIT_LIST_HEAD(&adapter->rxnfc_rules);
1532 io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1533 adapter->addr = devm_ioremap_resource(&pdev->dev, io);
1534 if (IS_ERR(adapter->addr))
1535 return PTR_ERR(adapter->addr);
1536 netdev->mem_start = io->start;
1537 netdev->mem_end = io->end;
1539 type = ioread32(adapter->addr + ECM_TYPE);
1540 revision = (type & ECM_REVISION_MASK) >> ECM_REVISION_SHIFT;
1541 version = (type & ECM_VERSION_MASK) >> ECM_VERSION_SHIFT;
1542 queue_count = (type & ECM_QUEUE_COUNT_MASK) >> ECM_QUEUE_COUNT_SHIFT;
1543 adapter->gate_control = type & ECM_GATE_CONTROL;
1544 adapter->rxnfc_max = TSNEP_RX_ASSIGN_ETHER_TYPE_COUNT;
1546 tsnep_disable_irq(adapter, ECM_INT_ALL);
1548 retval = tsnep_queue_init(adapter, queue_count);
1552 retval = dma_set_mask_and_coherent(&adapter->pdev->dev,
1555 dev_err(&adapter->pdev->dev, "no usable DMA configuration.\n");
1559 retval = tsnep_mac_init(adapter);
1563 retval = tsnep_mdio_init(adapter);
1565 goto mdio_init_failed;
1567 retval = tsnep_phy_init(adapter);
1569 goto phy_init_failed;
1571 retval = tsnep_ptp_init(adapter);
1573 goto ptp_init_failed;
1575 retval = tsnep_tc_init(adapter);
1577 goto tc_init_failed;
1579 retval = tsnep_rxnfc_init(adapter);
1581 goto rxnfc_init_failed;
1583 netdev->netdev_ops = &tsnep_netdev_ops;
1584 netdev->ethtool_ops = &tsnep_ethtool_ops;
1585 netdev->features = NETIF_F_SG;
1586 netdev->hw_features = netdev->features | NETIF_F_LOOPBACK;
1588 /* carrier off reporting is important to ethtool even BEFORE open */
1589 netif_carrier_off(netdev);
1591 retval = register_netdev(netdev);
1593 goto register_failed;
1595 dev_info(&adapter->pdev->dev, "device version %d.%02d\n", version,
1597 if (adapter->gate_control)
1598 dev_info(&adapter->pdev->dev, "gate control detected\n");
1603 tsnep_rxnfc_cleanup(adapter);
1605 tsnep_tc_cleanup(adapter);
1607 tsnep_ptp_cleanup(adapter);
1610 if (adapter->mdiobus)
1611 mdiobus_unregister(adapter->mdiobus);
1616 static int tsnep_remove(struct platform_device *pdev)
1618 struct tsnep_adapter *adapter = platform_get_drvdata(pdev);
1620 unregister_netdev(adapter->netdev);
1622 tsnep_rxnfc_cleanup(adapter);
1624 tsnep_tc_cleanup(adapter);
1626 tsnep_ptp_cleanup(adapter);
1628 if (adapter->mdiobus)
1629 mdiobus_unregister(adapter->mdiobus);
1631 tsnep_disable_irq(adapter, ECM_INT_ALL);
1636 static const struct of_device_id tsnep_of_match[] = {
1637 { .compatible = "engleder,tsnep", },
1640 MODULE_DEVICE_TABLE(of, tsnep_of_match);
1642 static struct platform_driver tsnep_driver = {
1645 .of_match_table = tsnep_of_match,
1647 .probe = tsnep_probe,
1648 .remove = tsnep_remove,
1650 module_platform_driver(tsnep_driver);
1652 MODULE_AUTHOR("Gerhard Engleder <gerhard@engleder-embedded.com>");
1653 MODULE_DESCRIPTION("TSN endpoint Ethernet MAC driver");
1654 MODULE_LICENSE("GPL");