1 /*
2  * Copyright (C) 2004-2013 Synopsys, Inc. (www.synopsys.com)
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 version 2 as
6  * published by the Free Software Foundation.
7  *
8  * Driver for the ARC EMAC 10100 (hardware revision 5)
9  *
10  * Contributors:
11  *		Amit Bhor
12  *		Sameer Dhavale
13  *		Vineet Gupta
14  */
15 
16 #include <linux/crc32.h>
17 #include <linux/etherdevice.h>
18 #include <linux/interrupt.h>
19 #include <linux/io.h>
20 #include <linux/module.h>
21 #include <linux/of_address.h>
22 #include <linux/of_irq.h>
23 #include <linux/of_mdio.h>
24 #include <linux/of_net.h>
25 #include <linux/of_platform.h>
26 
27 #include "emac.h"
28 
29 /**
30  * arc_emac_tx_avail - Return the number of available slots in the tx ring.
31  * @priv: Pointer to ARC EMAC private data structure.
32  *
33  * returns: the number of slots available for transmission in tx the ring.
34  */
35 static inline int arc_emac_tx_avail(struct arc_emac_priv *priv)
36 {
37 	return (priv->txbd_dirty + TX_BD_NUM - priv->txbd_curr - 1) % TX_BD_NUM;
38 }
39 
40 /**
41  * arc_emac_adjust_link - Adjust the PHY link duplex.
42  * @ndev:	Pointer to the net_device structure.
43  *
44  * This function is called to change the duplex setting after auto negotiation
45  * is done by the PHY.
46  */
47 static void arc_emac_adjust_link(struct net_device *ndev)
48 {
49 	struct arc_emac_priv *priv = netdev_priv(ndev);
50 	struct phy_device *phy_dev = ndev->phydev;
51 	unsigned int reg, state_changed = 0;
52 
53 	if (priv->link != phy_dev->link) {
54 		priv->link = phy_dev->link;
55 		state_changed = 1;
56 	}
57 
58 	if (priv->speed != phy_dev->speed) {
59 		priv->speed = phy_dev->speed;
60 		state_changed = 1;
61 		if (priv->set_mac_speed)
62 			priv->set_mac_speed(priv, priv->speed);
63 	}
64 
65 	if (priv->duplex != phy_dev->duplex) {
66 		reg = arc_reg_get(priv, R_CTRL);
67 
68 		if (phy_dev->duplex == DUPLEX_FULL)
69 			reg |= ENFL_MASK;
70 		else
71 			reg &= ~ENFL_MASK;
72 
73 		arc_reg_set(priv, R_CTRL, reg);
74 		priv->duplex = phy_dev->duplex;
75 		state_changed = 1;
76 	}
77 
78 	if (state_changed)
79 		phy_print_status(phy_dev);
80 }
81 
82 /**
83  * arc_emac_get_drvinfo - Get EMAC driver information.
84  * @ndev:	Pointer to net_device structure.
85  * @info:	Pointer to ethtool_drvinfo structure.
86  *
87  * This implements ethtool command for getting the driver information.
88  * Issue "ethtool -i ethX" under linux prompt to execute this function.
89  */
90 static void arc_emac_get_drvinfo(struct net_device *ndev,
91 				 struct ethtool_drvinfo *info)
92 {
93 	struct arc_emac_priv *priv = netdev_priv(ndev);
94 
95 	strlcpy(info->driver, priv->drv_name, sizeof(info->driver));
96 	strlcpy(info->version, priv->drv_version, sizeof(info->version));
97 }
98 
99 static const struct ethtool_ops arc_emac_ethtool_ops = {
100 	.get_drvinfo	= arc_emac_get_drvinfo,
101 	.get_link	= ethtool_op_get_link,
102 	.get_link_ksettings = phy_ethtool_get_link_ksettings,
103 	.set_link_ksettings = phy_ethtool_set_link_ksettings,
104 };
105 
106 #define FIRST_OR_LAST_MASK	(FIRST_MASK | LAST_MASK)
107 
108 /**
109  * arc_emac_tx_clean - clears processed by EMAC Tx BDs.
110  * @ndev:	Pointer to the network device.
111  */
112 static void arc_emac_tx_clean(struct net_device *ndev)
113 {
114 	struct arc_emac_priv *priv = netdev_priv(ndev);
115 	struct net_device_stats *stats = &ndev->stats;
116 	unsigned int i;
117 
118 	for (i = 0; i < TX_BD_NUM; i++) {
119 		unsigned int *txbd_dirty = &priv->txbd_dirty;
120 		struct arc_emac_bd *txbd = &priv->txbd[*txbd_dirty];
121 		struct buffer_state *tx_buff = &priv->tx_buff[*txbd_dirty];
122 		struct sk_buff *skb = tx_buff->skb;
123 		unsigned int info = le32_to_cpu(txbd->info);
124 
125 		if ((info & FOR_EMAC) || !txbd->data || !skb)
126 			break;
127 
128 		if (unlikely(info & (DROP | DEFR | LTCL | UFLO))) {
129 			stats->tx_errors++;
130 			stats->tx_dropped++;
131 
132 			if (info & DEFR)
133 				stats->tx_carrier_errors++;
134 
135 			if (info & LTCL)
136 				stats->collisions++;
137 
138 			if (info & UFLO)
139 				stats->tx_fifo_errors++;
140 		} else if (likely(info & FIRST_OR_LAST_MASK)) {
141 			stats->tx_packets++;
142 			stats->tx_bytes += skb->len;
143 		}
144 
145 		dma_unmap_single(&ndev->dev, dma_unmap_addr(tx_buff, addr),
146 				 dma_unmap_len(tx_buff, len), DMA_TO_DEVICE);
147 
148 		/* return the sk_buff to system */
149 		dev_kfree_skb_irq(skb);
150 
151 		txbd->data = 0;
152 		txbd->info = 0;
153 		tx_buff->skb = NULL;
154 
155 		*txbd_dirty = (*txbd_dirty + 1) % TX_BD_NUM;
156 	}
157 
158 	/* Ensure that txbd_dirty is visible to tx() before checking
159 	 * for queue stopped.
160 	 */
161 	smp_mb();
162 
163 	if (netif_queue_stopped(ndev) && arc_emac_tx_avail(priv))
164 		netif_wake_queue(ndev);
165 }
166 
167 /**
168  * arc_emac_rx - processing of Rx packets.
169  * @ndev:	Pointer to the network device.
170  * @budget:	How many BDs to process on 1 call.
171  *
172  * returns:	Number of processed BDs
173  *
174  * Iterate through Rx BDs and deliver received packages to upper layer.
175  */
176 static int arc_emac_rx(struct net_device *ndev, int budget)
177 {
178 	struct arc_emac_priv *priv = netdev_priv(ndev);
179 	unsigned int work_done;
180 
181 	for (work_done = 0; work_done < budget; work_done++) {
182 		unsigned int *last_rx_bd = &priv->last_rx_bd;
183 		struct net_device_stats *stats = &ndev->stats;
184 		struct buffer_state *rx_buff = &priv->rx_buff[*last_rx_bd];
185 		struct arc_emac_bd *rxbd = &priv->rxbd[*last_rx_bd];
186 		unsigned int pktlen, info = le32_to_cpu(rxbd->info);
187 		struct sk_buff *skb;
188 		dma_addr_t addr;
189 
190 		if (unlikely((info & OWN_MASK) == FOR_EMAC))
191 			break;
192 
193 		/* Make a note that we saw a packet at this BD.
194 		 * So next time, driver starts from this + 1
195 		 */
196 		*last_rx_bd = (*last_rx_bd + 1) % RX_BD_NUM;
197 
198 		if (unlikely((info & FIRST_OR_LAST_MASK) !=
199 			     FIRST_OR_LAST_MASK)) {
200 			/* We pre-allocate buffers of MTU size so incoming
201 			 * packets won't be split/chained.
202 			 */
203 			if (net_ratelimit())
204 				netdev_err(ndev, "incomplete packet received\n");
205 
206 			/* Return ownership to EMAC */
207 			rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE);
208 			stats->rx_errors++;
209 			stats->rx_length_errors++;
210 			continue;
211 		}
212 
213 		pktlen = info & LEN_MASK;
214 		stats->rx_packets++;
215 		stats->rx_bytes += pktlen;
216 		skb = rx_buff->skb;
217 		skb_put(skb, pktlen);
218 		skb->dev = ndev;
219 		skb->protocol = eth_type_trans(skb, ndev);
220 
221 		dma_unmap_single(&ndev->dev, dma_unmap_addr(rx_buff, addr),
222 				 dma_unmap_len(rx_buff, len), DMA_FROM_DEVICE);
223 
224 		/* Prepare the BD for next cycle */
225 		rx_buff->skb = netdev_alloc_skb_ip_align(ndev,
226 							 EMAC_BUFFER_SIZE);
227 		if (unlikely(!rx_buff->skb)) {
228 			stats->rx_errors++;
229 			/* Because receive_skb is below, increment rx_dropped */
230 			stats->rx_dropped++;
231 			continue;
232 		}
233 
234 		/* receive_skb only if new skb was allocated to avoid holes */
235 		netif_receive_skb(skb);
236 
237 		addr = dma_map_single(&ndev->dev, (void *)rx_buff->skb->data,
238 				      EMAC_BUFFER_SIZE, DMA_FROM_DEVICE);
239 		if (dma_mapping_error(&ndev->dev, addr)) {
240 			if (net_ratelimit())
241 				netdev_err(ndev, "cannot dma map\n");
242 			dev_kfree_skb(rx_buff->skb);
243 			stats->rx_errors++;
244 			continue;
245 		}
246 		dma_unmap_addr_set(rx_buff, addr, addr);
247 		dma_unmap_len_set(rx_buff, len, EMAC_BUFFER_SIZE);
248 
249 		rxbd->data = cpu_to_le32(addr);
250 
251 		/* Make sure pointer to data buffer is set */
252 		wmb();
253 
254 		/* Return ownership to EMAC */
255 		rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE);
256 	}
257 
258 	return work_done;
259 }
260 
261 /**
262  * arc_emac_poll - NAPI poll handler.
263  * @napi:	Pointer to napi_struct structure.
264  * @budget:	How many BDs to process on 1 call.
265  *
266  * returns:	Number of processed BDs
267  */
268 static int arc_emac_poll(struct napi_struct *napi, int budget)
269 {
270 	struct net_device *ndev = napi->dev;
271 	struct arc_emac_priv *priv = netdev_priv(ndev);
272 	unsigned int work_done;
273 
274 	arc_emac_tx_clean(ndev);
275 
276 	work_done = arc_emac_rx(ndev, budget);
277 	if (work_done < budget) {
278 		napi_complete(napi);
279 		arc_reg_or(priv, R_ENABLE, RXINT_MASK | TXINT_MASK);
280 	}
281 
282 	return work_done;
283 }
284 
285 /**
286  * arc_emac_intr - Global interrupt handler for EMAC.
287  * @irq:		irq number.
288  * @dev_instance:	device instance.
289  *
290  * returns: IRQ_HANDLED for all cases.
291  *
292  * ARC EMAC has only 1 interrupt line, and depending on bits raised in
293  * STATUS register we may tell what is a reason for interrupt to fire.
294  */
295 static irqreturn_t arc_emac_intr(int irq, void *dev_instance)
296 {
297 	struct net_device *ndev = dev_instance;
298 	struct arc_emac_priv *priv = netdev_priv(ndev);
299 	struct net_device_stats *stats = &ndev->stats;
300 	unsigned int status;
301 
302 	status = arc_reg_get(priv, R_STATUS);
303 	status &= ~MDIO_MASK;
304 
305 	/* Reset all flags except "MDIO complete" */
306 	arc_reg_set(priv, R_STATUS, status);
307 
308 	if (status & (RXINT_MASK | TXINT_MASK)) {
309 		if (likely(napi_schedule_prep(&priv->napi))) {
310 			arc_reg_clr(priv, R_ENABLE, RXINT_MASK | TXINT_MASK);
311 			__napi_schedule(&priv->napi);
312 		}
313 	}
314 
315 	if (status & ERR_MASK) {
316 		/* MSER/RXCR/RXFR/RXFL interrupt fires on corresponding
317 		 * 8-bit error counter overrun.
318 		 */
319 
320 		if (status & MSER_MASK) {
321 			stats->rx_missed_errors += 0x100;
322 			stats->rx_errors += 0x100;
323 		}
324 
325 		if (status & RXCR_MASK) {
326 			stats->rx_crc_errors += 0x100;
327 			stats->rx_errors += 0x100;
328 		}
329 
330 		if (status & RXFR_MASK) {
331 			stats->rx_frame_errors += 0x100;
332 			stats->rx_errors += 0x100;
333 		}
334 
335 		if (status & RXFL_MASK) {
336 			stats->rx_over_errors += 0x100;
337 			stats->rx_errors += 0x100;
338 		}
339 	}
340 
341 	return IRQ_HANDLED;
342 }
343 
344 #ifdef CONFIG_NET_POLL_CONTROLLER
345 static void arc_emac_poll_controller(struct net_device *dev)
346 {
347 	disable_irq(dev->irq);
348 	arc_emac_intr(dev->irq, dev);
349 	enable_irq(dev->irq);
350 }
351 #endif
352 
353 /**
354  * arc_emac_open - Open the network device.
355  * @ndev:	Pointer to the network device.
356  *
357  * returns: 0, on success or non-zero error value on failure.
358  *
359  * This function sets the MAC address, requests and enables an IRQ
360  * for the EMAC device and starts the Tx queue.
361  * It also connects to the phy device.
362  */
363 static int arc_emac_open(struct net_device *ndev)
364 {
365 	struct arc_emac_priv *priv = netdev_priv(ndev);
366 	struct phy_device *phy_dev = ndev->phydev;
367 	int i;
368 
369 	phy_dev->autoneg = AUTONEG_ENABLE;
370 	phy_dev->speed = 0;
371 	phy_dev->duplex = 0;
372 	phy_dev->advertising &= phy_dev->supported;
373 
374 	priv->last_rx_bd = 0;
375 
376 	/* Allocate and set buffers for Rx BD's */
377 	for (i = 0; i < RX_BD_NUM; i++) {
378 		dma_addr_t addr;
379 		unsigned int *last_rx_bd = &priv->last_rx_bd;
380 		struct arc_emac_bd *rxbd = &priv->rxbd[*last_rx_bd];
381 		struct buffer_state *rx_buff = &priv->rx_buff[*last_rx_bd];
382 
383 		rx_buff->skb = netdev_alloc_skb_ip_align(ndev,
384 							 EMAC_BUFFER_SIZE);
385 		if (unlikely(!rx_buff->skb))
386 			return -ENOMEM;
387 
388 		addr = dma_map_single(&ndev->dev, (void *)rx_buff->skb->data,
389 				      EMAC_BUFFER_SIZE, DMA_FROM_DEVICE);
390 		if (dma_mapping_error(&ndev->dev, addr)) {
391 			netdev_err(ndev, "cannot dma map\n");
392 			dev_kfree_skb(rx_buff->skb);
393 			return -ENOMEM;
394 		}
395 		dma_unmap_addr_set(rx_buff, addr, addr);
396 		dma_unmap_len_set(rx_buff, len, EMAC_BUFFER_SIZE);
397 
398 		rxbd->data = cpu_to_le32(addr);
399 
400 		/* Make sure pointer to data buffer is set */
401 		wmb();
402 
403 		/* Return ownership to EMAC */
404 		rxbd->info = cpu_to_le32(FOR_EMAC | EMAC_BUFFER_SIZE);
405 
406 		*last_rx_bd = (*last_rx_bd + 1) % RX_BD_NUM;
407 	}
408 
409 	priv->txbd_curr = 0;
410 	priv->txbd_dirty = 0;
411 
412 	/* Clean Tx BD's */
413 	memset(priv->txbd, 0, TX_RING_SZ);
414 
415 	/* Initialize logical address filter */
416 	arc_reg_set(priv, R_LAFL, 0);
417 	arc_reg_set(priv, R_LAFH, 0);
418 
419 	/* Set BD ring pointers for device side */
420 	arc_reg_set(priv, R_RX_RING, (unsigned int)priv->rxbd_dma);
421 	arc_reg_set(priv, R_TX_RING, (unsigned int)priv->txbd_dma);
422 
423 	/* Enable interrupts */
424 	arc_reg_set(priv, R_ENABLE, RXINT_MASK | TXINT_MASK | ERR_MASK);
425 
426 	/* Set CONTROL */
427 	arc_reg_set(priv, R_CTRL,
428 		    (RX_BD_NUM << 24) |	/* RX BD table length */
429 		    (TX_BD_NUM << 16) |	/* TX BD table length */
430 		    TXRN_MASK | RXRN_MASK);
431 
432 	napi_enable(&priv->napi);
433 
434 	/* Enable EMAC */
435 	arc_reg_or(priv, R_CTRL, EN_MASK);
436 
437 	phy_start_aneg(ndev->phydev);
438 
439 	netif_start_queue(ndev);
440 
441 	return 0;
442 }
443 
444 /**
445  * arc_emac_set_rx_mode - Change the receive filtering mode.
446  * @ndev:	Pointer to the network device.
447  *
448  * This function enables/disables promiscuous or all-multicast mode
449  * and updates the multicast filtering list of the network device.
450  */
451 static void arc_emac_set_rx_mode(struct net_device *ndev)
452 {
453 	struct arc_emac_priv *priv = netdev_priv(ndev);
454 
455 	if (ndev->flags & IFF_PROMISC) {
456 		arc_reg_or(priv, R_CTRL, PROM_MASK);
457 	} else {
458 		arc_reg_clr(priv, R_CTRL, PROM_MASK);
459 
460 		if (ndev->flags & IFF_ALLMULTI) {
461 			arc_reg_set(priv, R_LAFL, ~0);
462 			arc_reg_set(priv, R_LAFH, ~0);
463 		} else {
464 			struct netdev_hw_addr *ha;
465 			unsigned int filter[2] = { 0, 0 };
466 			int bit;
467 
468 			netdev_for_each_mc_addr(ha, ndev) {
469 				bit = ether_crc_le(ETH_ALEN, ha->addr) >> 26;
470 				filter[bit >> 5] |= 1 << (bit & 31);
471 			}
472 
473 			arc_reg_set(priv, R_LAFL, filter[0]);
474 			arc_reg_set(priv, R_LAFH, filter[1]);
475 		}
476 	}
477 }
478 
479 /**
480  * arc_free_tx_queue - free skb from tx queue
481  * @ndev:	Pointer to the network device.
482  *
483  * This function must be called while EMAC disable
484  */
485 static void arc_free_tx_queue(struct net_device *ndev)
486 {
487 	struct arc_emac_priv *priv = netdev_priv(ndev);
488 	unsigned int i;
489 
490 	for (i = 0; i < TX_BD_NUM; i++) {
491 		struct arc_emac_bd *txbd = &priv->txbd[i];
492 		struct buffer_state *tx_buff = &priv->tx_buff[i];
493 
494 		if (tx_buff->skb) {
495 			dma_unmap_single(&ndev->dev,
496 					 dma_unmap_addr(tx_buff, addr),
497 					 dma_unmap_len(tx_buff, len),
498 					 DMA_TO_DEVICE);
499 
500 			/* return the sk_buff to system */
501 			dev_kfree_skb_irq(tx_buff->skb);
502 		}
503 
504 		txbd->info = 0;
505 		txbd->data = 0;
506 		tx_buff->skb = NULL;
507 	}
508 }
509 
510 /**
511  * arc_free_rx_queue - free skb from rx queue
512  * @ndev:	Pointer to the network device.
513  *
514  * This function must be called while EMAC disable
515  */
516 static void arc_free_rx_queue(struct net_device *ndev)
517 {
518 	struct arc_emac_priv *priv = netdev_priv(ndev);
519 	unsigned int i;
520 
521 	for (i = 0; i < RX_BD_NUM; i++) {
522 		struct arc_emac_bd *rxbd = &priv->rxbd[i];
523 		struct buffer_state *rx_buff = &priv->rx_buff[i];
524 
525 		if (rx_buff->skb) {
526 			dma_unmap_single(&ndev->dev,
527 					 dma_unmap_addr(rx_buff, addr),
528 					 dma_unmap_len(rx_buff, len),
529 					 DMA_FROM_DEVICE);
530 
531 			/* return the sk_buff to system */
532 			dev_kfree_skb_irq(rx_buff->skb);
533 		}
534 
535 		rxbd->info = 0;
536 		rxbd->data = 0;
537 		rx_buff->skb = NULL;
538 	}
539 }
540 
541 /**
542  * arc_emac_stop - Close the network device.
543  * @ndev:	Pointer to the network device.
544  *
545  * This function stops the Tx queue, disables interrupts and frees the IRQ for
546  * the EMAC device.
547  * It also disconnects the PHY device associated with the EMAC device.
548  */
549 static int arc_emac_stop(struct net_device *ndev)
550 {
551 	struct arc_emac_priv *priv = netdev_priv(ndev);
552 
553 	napi_disable(&priv->napi);
554 	netif_stop_queue(ndev);
555 
556 	/* Disable interrupts */
557 	arc_reg_clr(priv, R_ENABLE, RXINT_MASK | TXINT_MASK | ERR_MASK);
558 
559 	/* Disable EMAC */
560 	arc_reg_clr(priv, R_CTRL, EN_MASK);
561 
562 	/* Return the sk_buff to system */
563 	arc_free_tx_queue(ndev);
564 	arc_free_rx_queue(ndev);
565 
566 	return 0;
567 }
568 
569 /**
570  * arc_emac_stats - Get system network statistics.
571  * @ndev:	Pointer to net_device structure.
572  *
573  * Returns the address of the device statistics structure.
574  * Statistics are updated in interrupt handler.
575  */
576 static struct net_device_stats *arc_emac_stats(struct net_device *ndev)
577 {
578 	struct arc_emac_priv *priv = netdev_priv(ndev);
579 	struct net_device_stats *stats = &ndev->stats;
580 	unsigned long miss, rxerr;
581 	u8 rxcrc, rxfram, rxoflow;
582 
583 	rxerr = arc_reg_get(priv, R_RXERR);
584 	miss = arc_reg_get(priv, R_MISS);
585 
586 	rxcrc = rxerr;
587 	rxfram = rxerr >> 8;
588 	rxoflow = rxerr >> 16;
589 
590 	stats->rx_errors += miss;
591 	stats->rx_errors += rxcrc + rxfram + rxoflow;
592 
593 	stats->rx_over_errors += rxoflow;
594 	stats->rx_frame_errors += rxfram;
595 	stats->rx_crc_errors += rxcrc;
596 	stats->rx_missed_errors += miss;
597 
598 	return stats;
599 }
600 
601 /**
602  * arc_emac_tx - Starts the data transmission.
603  * @skb:	sk_buff pointer that contains data to be Transmitted.
604  * @ndev:	Pointer to net_device structure.
605  *
606  * returns: NETDEV_TX_OK, on success
607  *		NETDEV_TX_BUSY, if any of the descriptors are not free.
608  *
609  * This function is invoked from upper layers to initiate transmission.
610  */
611 static int arc_emac_tx(struct sk_buff *skb, struct net_device *ndev)
612 {
613 	struct arc_emac_priv *priv = netdev_priv(ndev);
614 	unsigned int len, *txbd_curr = &priv->txbd_curr;
615 	struct net_device_stats *stats = &ndev->stats;
616 	__le32 *info = &priv->txbd[*txbd_curr].info;
617 	dma_addr_t addr;
618 
619 	if (skb_padto(skb, ETH_ZLEN))
620 		return NETDEV_TX_OK;
621 
622 	len = max_t(unsigned int, ETH_ZLEN, skb->len);
623 
624 	if (unlikely(!arc_emac_tx_avail(priv))) {
625 		netif_stop_queue(ndev);
626 		netdev_err(ndev, "BUG! Tx Ring full when queue awake!\n");
627 		return NETDEV_TX_BUSY;
628 	}
629 
630 	addr = dma_map_single(&ndev->dev, (void *)skb->data, len,
631 			      DMA_TO_DEVICE);
632 
633 	if (unlikely(dma_mapping_error(&ndev->dev, addr))) {
634 		stats->tx_dropped++;
635 		stats->tx_errors++;
636 		dev_kfree_skb(skb);
637 		return NETDEV_TX_OK;
638 	}
639 	dma_unmap_addr_set(&priv->tx_buff[*txbd_curr], addr, addr);
640 	dma_unmap_len_set(&priv->tx_buff[*txbd_curr], len, len);
641 
642 	priv->txbd[*txbd_curr].data = cpu_to_le32(addr);
643 
644 	/* Make sure pointer to data buffer is set */
645 	wmb();
646 
647 	skb_tx_timestamp(skb);
648 
649 	*info = cpu_to_le32(FOR_EMAC | FIRST_OR_LAST_MASK | len);
650 
651 	/* Make sure info word is set */
652 	wmb();
653 
654 	priv->tx_buff[*txbd_curr].skb = skb;
655 
656 	/* Increment index to point to the next BD */
657 	*txbd_curr = (*txbd_curr + 1) % TX_BD_NUM;
658 
659 	/* Ensure that tx_clean() sees the new txbd_curr before
660 	 * checking the queue status. This prevents an unneeded wake
661 	 * of the queue in tx_clean().
662 	 */
663 	smp_mb();
664 
665 	if (!arc_emac_tx_avail(priv)) {
666 		netif_stop_queue(ndev);
667 		/* Refresh tx_dirty */
668 		smp_mb();
669 		if (arc_emac_tx_avail(priv))
670 			netif_start_queue(ndev);
671 	}
672 
673 	arc_reg_set(priv, R_STATUS, TXPL_MASK);
674 
675 	return NETDEV_TX_OK;
676 }
677 
678 static void arc_emac_set_address_internal(struct net_device *ndev)
679 {
680 	struct arc_emac_priv *priv = netdev_priv(ndev);
681 	unsigned int addr_low, addr_hi;
682 
683 	addr_low = le32_to_cpu(*(__le32 *)&ndev->dev_addr[0]);
684 	addr_hi = le16_to_cpu(*(__le16 *)&ndev->dev_addr[4]);
685 
686 	arc_reg_set(priv, R_ADDRL, addr_low);
687 	arc_reg_set(priv, R_ADDRH, addr_hi);
688 }
689 
690 /**
691  * arc_emac_set_address - Set the MAC address for this device.
692  * @ndev:	Pointer to net_device structure.
693  * @p:		6 byte Address to be written as MAC address.
694  *
695  * This function copies the HW address from the sockaddr structure to the
696  * net_device structure and updates the address in HW.
697  *
698  * returns:	-EBUSY if the net device is busy or 0 if the address is set
699  *		successfully.
700  */
701 static int arc_emac_set_address(struct net_device *ndev, void *p)
702 {
703 	struct sockaddr *addr = p;
704 
705 	if (netif_running(ndev))
706 		return -EBUSY;
707 
708 	if (!is_valid_ether_addr(addr->sa_data))
709 		return -EADDRNOTAVAIL;
710 
711 	memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len);
712 
713 	arc_emac_set_address_internal(ndev);
714 
715 	return 0;
716 }
717 
718 static const struct net_device_ops arc_emac_netdev_ops = {
719 	.ndo_open		= arc_emac_open,
720 	.ndo_stop		= arc_emac_stop,
721 	.ndo_start_xmit		= arc_emac_tx,
722 	.ndo_set_mac_address	= arc_emac_set_address,
723 	.ndo_get_stats		= arc_emac_stats,
724 	.ndo_set_rx_mode	= arc_emac_set_rx_mode,
725 #ifdef CONFIG_NET_POLL_CONTROLLER
726 	.ndo_poll_controller	= arc_emac_poll_controller,
727 #endif
728 };
729 
730 int arc_emac_probe(struct net_device *ndev, int interface)
731 {
732 	struct device *dev = ndev->dev.parent;
733 	struct resource res_regs;
734 	struct device_node *phy_node;
735 	struct phy_device *phydev = NULL;
736 	struct arc_emac_priv *priv;
737 	const char *mac_addr;
738 	unsigned int id, clock_frequency, irq;
739 	int err;
740 
741 	/* Get PHY from device tree */
742 	phy_node = of_parse_phandle(dev->of_node, "phy", 0);
743 	if (!phy_node) {
744 		dev_err(dev, "failed to retrieve phy description from device tree\n");
745 		return -ENODEV;
746 	}
747 
748 	/* Get EMAC registers base address from device tree */
749 	err = of_address_to_resource(dev->of_node, 0, &res_regs);
750 	if (err) {
751 		dev_err(dev, "failed to retrieve registers base from device tree\n");
752 		err = -ENODEV;
753 		goto out_put_node;
754 	}
755 
756 	/* Get IRQ from device tree */
757 	irq = irq_of_parse_and_map(dev->of_node, 0);
758 	if (!irq) {
759 		dev_err(dev, "failed to retrieve <irq> value from device tree\n");
760 		err = -ENODEV;
761 		goto out_put_node;
762 	}
763 
764 	ndev->netdev_ops = &arc_emac_netdev_ops;
765 	ndev->ethtool_ops = &arc_emac_ethtool_ops;
766 	ndev->watchdog_timeo = TX_TIMEOUT;
767 	/* FIXME :: no multicast support yet */
768 	ndev->flags &= ~IFF_MULTICAST;
769 
770 	priv = netdev_priv(ndev);
771 	priv->dev = dev;
772 
773 	priv->regs = devm_ioremap_resource(dev, &res_regs);
774 	if (IS_ERR(priv->regs)) {
775 		err = PTR_ERR(priv->regs);
776 		goto out_put_node;
777 	}
778 
779 	dev_dbg(dev, "Registers base address is 0x%p\n", priv->regs);
780 
781 	if (priv->clk) {
782 		err = clk_prepare_enable(priv->clk);
783 		if (err) {
784 			dev_err(dev, "failed to enable clock\n");
785 			goto out_put_node;
786 		}
787 
788 		clock_frequency = clk_get_rate(priv->clk);
789 	} else {
790 		/* Get CPU clock frequency from device tree */
791 		if (of_property_read_u32(dev->of_node, "clock-frequency",
792 					 &clock_frequency)) {
793 			dev_err(dev, "failed to retrieve <clock-frequency> from device tree\n");
794 			err = -EINVAL;
795 			goto out_put_node;
796 		}
797 	}
798 
799 	id = arc_reg_get(priv, R_ID);
800 
801 	/* Check for EMAC revision 5 or 7, magic number */
802 	if (!(id == 0x0005fd02 || id == 0x0007fd02)) {
803 		dev_err(dev, "ARC EMAC not detected, id=0x%x\n", id);
804 		err = -ENODEV;
805 		goto out_clken;
806 	}
807 	dev_info(dev, "ARC EMAC detected with id: 0x%x\n", id);
808 
809 	/* Set poll rate so that it polls every 1 ms */
810 	arc_reg_set(priv, R_POLLRATE, clock_frequency / 1000000);
811 
812 	ndev->irq = irq;
813 	dev_info(dev, "IRQ is %d\n", ndev->irq);
814 
815 	/* Register interrupt handler for device */
816 	err = devm_request_irq(dev, ndev->irq, arc_emac_intr, 0,
817 			       ndev->name, ndev);
818 	if (err) {
819 		dev_err(dev, "could not allocate IRQ\n");
820 		goto out_clken;
821 	}
822 
823 	/* Get MAC address from device tree */
824 	mac_addr = of_get_mac_address(dev->of_node);
825 
826 	if (mac_addr)
827 		memcpy(ndev->dev_addr, mac_addr, ETH_ALEN);
828 	else
829 		eth_hw_addr_random(ndev);
830 
831 	arc_emac_set_address_internal(ndev);
832 	dev_info(dev, "MAC address is now %pM\n", ndev->dev_addr);
833 
834 	/* Do 1 allocation instead of 2 separate ones for Rx and Tx BD rings */
835 	priv->rxbd = dmam_alloc_coherent(dev, RX_RING_SZ + TX_RING_SZ,
836 					 &priv->rxbd_dma, GFP_KERNEL);
837 
838 	if (!priv->rxbd) {
839 		dev_err(dev, "failed to allocate data buffers\n");
840 		err = -ENOMEM;
841 		goto out_clken;
842 	}
843 
844 	priv->txbd = priv->rxbd + RX_BD_NUM;
845 
846 	priv->txbd_dma = priv->rxbd_dma + RX_RING_SZ;
847 	dev_dbg(dev, "EMAC Device addr: Rx Ring [0x%x], Tx Ring[%x]\n",
848 		(unsigned int)priv->rxbd_dma, (unsigned int)priv->txbd_dma);
849 
850 	err = arc_mdio_probe(priv);
851 	if (err) {
852 		dev_err(dev, "failed to probe MII bus\n");
853 		goto out_clken;
854 	}
855 
856 	phydev = of_phy_connect(ndev, phy_node, arc_emac_adjust_link, 0,
857 				interface);
858 	if (!phydev) {
859 		dev_err(dev, "of_phy_connect() failed\n");
860 		err = -ENODEV;
861 		goto out_mdio;
862 	}
863 
864 	dev_info(dev, "connected to %s phy with id 0x%x\n",
865 		 phydev->drv->name, phydev->phy_id);
866 
867 	netif_napi_add(ndev, &priv->napi, arc_emac_poll, ARC_EMAC_NAPI_WEIGHT);
868 
869 	err = register_netdev(ndev);
870 	if (err) {
871 		dev_err(dev, "failed to register network device\n");
872 		goto out_netif_api;
873 	}
874 
875 	of_node_put(phy_node);
876 	return 0;
877 
878 out_netif_api:
879 	netif_napi_del(&priv->napi);
880 	phy_disconnect(phydev);
881 out_mdio:
882 	arc_mdio_remove(priv);
883 out_clken:
884 	if (priv->clk)
885 		clk_disable_unprepare(priv->clk);
886 out_put_node:
887 	of_node_put(phy_node);
888 
889 	return err;
890 }
891 EXPORT_SYMBOL_GPL(arc_emac_probe);
892 
893 int arc_emac_remove(struct net_device *ndev)
894 {
895 	struct arc_emac_priv *priv = netdev_priv(ndev);
896 
897 	phy_disconnect(ndev->phydev);
898 	arc_mdio_remove(priv);
899 	unregister_netdev(ndev);
900 	netif_napi_del(&priv->napi);
901 
902 	if (!IS_ERR(priv->clk))
903 		clk_disable_unprepare(priv->clk);
904 
905 	return 0;
906 }
907 EXPORT_SYMBOL_GPL(arc_emac_remove);
908 
909 MODULE_AUTHOR("Alexey Brodkin <abrodkin@synopsys.com>");
910 MODULE_DESCRIPTION("ARC EMAC driver");
911 MODULE_LICENSE("GPL");
912