2 * Xilinx EmacLite Linux driver for the Xilinx Ethernet MAC Lite device.
4 * This is a new flat driver which is based on the original emac_lite
5 * driver from John Williams <john.williams@petalogix.com>.
7 * 2007-2009 (c) Xilinx, Inc.
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
15 #include <linux/module.h>
16 #include <linux/uaccess.h>
17 #include <linux/init.h>
18 #include <linux/netdevice.h>
19 #include <linux/etherdevice.h>
20 #include <linux/skbuff.h>
23 #include <linux/of_device.h>
24 #include <linux/of_platform.h>
25 #include <linux/of_mdio.h>
26 #include <linux/phy.h>
28 #define DRIVER_NAME "xilinx_emaclite"
30 /* Register offsets for the EmacLite Core */
31 #define XEL_TXBUFF_OFFSET 0x0 /* Transmit Buffer */
32 #define XEL_MDIOADDR_OFFSET 0x07E4 /* MDIO Address Register */
33 #define XEL_MDIOWR_OFFSET 0x07E8 /* MDIO Write Data Register */
34 #define XEL_MDIORD_OFFSET 0x07EC /* MDIO Read Data Register */
35 #define XEL_MDIOCTRL_OFFSET 0x07F0 /* MDIO Control Register */
36 #define XEL_GIER_OFFSET 0x07F8 /* GIE Register */
37 #define XEL_TSR_OFFSET 0x07FC /* Tx status */
38 #define XEL_TPLR_OFFSET 0x07F4 /* Tx packet length */
40 #define XEL_RXBUFF_OFFSET 0x1000 /* Receive Buffer */
41 #define XEL_RPLR_OFFSET 0x100C /* Rx packet length */
42 #define XEL_RSR_OFFSET 0x17FC /* Rx status */
44 #define XEL_BUFFER_OFFSET 0x0800 /* Next Tx/Rx buffer's offset */
46 /* MDIO Address Register Bit Masks */
47 #define XEL_MDIOADDR_REGADR_MASK 0x0000001F /* Register Address */
48 #define XEL_MDIOADDR_PHYADR_MASK 0x000003E0 /* PHY Address */
49 #define XEL_MDIOADDR_PHYADR_SHIFT 5
50 #define XEL_MDIOADDR_OP_MASK 0x00000400 /* RD/WR Operation */
52 /* MDIO Write Data Register Bit Masks */
53 #define XEL_MDIOWR_WRDATA_MASK 0x0000FFFF /* Data to be Written */
55 /* MDIO Read Data Register Bit Masks */
56 #define XEL_MDIORD_RDDATA_MASK 0x0000FFFF /* Data to be Read */
58 /* MDIO Control Register Bit Masks */
59 #define XEL_MDIOCTRL_MDIOSTS_MASK 0x00000001 /* MDIO Status Mask */
60 #define XEL_MDIOCTRL_MDIOEN_MASK 0x00000008 /* MDIO Enable */
62 /* Global Interrupt Enable Register (GIER) Bit Masks */
63 #define XEL_GIER_GIE_MASK 0x80000000 /* Global Enable */
65 /* Transmit Status Register (TSR) Bit Masks */
66 #define XEL_TSR_XMIT_BUSY_MASK 0x00000001 /* Tx complete */
67 #define XEL_TSR_PROGRAM_MASK 0x00000002 /* Program the MAC address */
68 #define XEL_TSR_XMIT_IE_MASK 0x00000008 /* Tx interrupt enable bit */
69 #define XEL_TSR_XMIT_ACTIVE_MASK 0x80000000 /* Buffer is active, SW bit
70 * only. This is not documented
73 /* Define for programming the MAC address into the EmacLite */
74 #define XEL_TSR_PROG_MAC_ADDR (XEL_TSR_XMIT_BUSY_MASK | XEL_TSR_PROGRAM_MASK)
76 /* Receive Status Register (RSR) */
77 #define XEL_RSR_RECV_DONE_MASK 0x00000001 /* Rx complete */
78 #define XEL_RSR_RECV_IE_MASK 0x00000008 /* Rx interrupt enable bit */
80 /* Transmit Packet Length Register (TPLR) */
81 #define XEL_TPLR_LENGTH_MASK 0x0000FFFF /* Tx packet length */
83 /* Receive Packet Length Register (RPLR) */
84 #define XEL_RPLR_LENGTH_MASK 0x0000FFFF /* Rx packet length */
86 #define XEL_HEADER_OFFSET 12 /* Offset to length field */
87 #define XEL_HEADER_SHIFT 16 /* Shift value for length */
89 /* General Ethernet Definitions */
90 #define XEL_ARP_PACKET_SIZE 28 /* Max ARP packet size */
91 #define XEL_HEADER_IP_LENGTH_OFFSET 16 /* IP Length Offset */
95 #define TX_TIMEOUT (60*HZ) /* Tx timeout is 60 seconds. */
98 /* BUFFER_ALIGN(adr) calculates the number of bytes to the next alignment. */
99 #define BUFFER_ALIGN(adr) ((ALIGNMENT - ((u32) adr)) % ALIGNMENT)
102 * struct net_local - Our private per device data
103 * @ndev: instance of the network device
104 * @tx_ping_pong: indicates whether Tx Pong buffer is configured in HW
105 * @rx_ping_pong: indicates whether Rx Pong buffer is configured in HW
106 * @next_tx_buf_to_use: next Tx buffer to write to
107 * @next_rx_buf_to_use: next Rx buffer to read from
108 * @base_addr: base address of the Emaclite device
109 * @reset_lock: lock used for synchronization
110 * @deferred_skb: holds an skb (for transmission at a later time) when the
111 * Tx buffer is not free
112 * @phy_dev: pointer to the PHY device
113 * @phy_node: pointer to the PHY device node
114 * @mii_bus: pointer to the MII bus
115 * @mdio_irqs: IRQs table for MDIO bus
116 * @last_link: last link status
117 * @has_mdio: indicates whether MDIO is included in the HW
121 struct net_device
*ndev
;
125 u32 next_tx_buf_to_use
;
126 u32 next_rx_buf_to_use
;
127 void __iomem
*base_addr
;
129 spinlock_t reset_lock
;
130 struct sk_buff
*deferred_skb
;
132 struct phy_device
*phy_dev
;
133 struct device_node
*phy_node
;
135 struct mii_bus
*mii_bus
;
136 int mdio_irqs
[PHY_MAX_ADDR
];
143 /*************************/
144 /* EmacLite driver calls */
145 /*************************/
148 * xemaclite_enable_interrupts - Enable the interrupts for the EmacLite device
149 * @drvdata: Pointer to the Emaclite device private data
151 * This function enables the Tx and Rx interrupts for the Emaclite device along
152 * with the Global Interrupt Enable.
154 static void xemaclite_enable_interrupts(struct net_local
*drvdata
)
158 /* Enable the Tx interrupts for the first Buffer */
159 reg_data
= in_be32(drvdata
->base_addr
+ XEL_TSR_OFFSET
);
160 out_be32(drvdata
->base_addr
+ XEL_TSR_OFFSET
,
161 reg_data
| XEL_TSR_XMIT_IE_MASK
);
163 /* Enable the Tx interrupts for the second Buffer if
164 * configured in HW */
165 if (drvdata
->tx_ping_pong
!= 0) {
166 reg_data
= in_be32(drvdata
->base_addr
+
167 XEL_BUFFER_OFFSET
+ XEL_TSR_OFFSET
);
168 out_be32(drvdata
->base_addr
+ XEL_BUFFER_OFFSET
+
170 reg_data
| XEL_TSR_XMIT_IE_MASK
);
173 /* Enable the Rx interrupts for the first buffer */
174 out_be32(drvdata
->base_addr
+ XEL_RSR_OFFSET
,
175 XEL_RSR_RECV_IE_MASK
);
177 /* Enable the Rx interrupts for the second Buffer if
178 * configured in HW */
179 if (drvdata
->rx_ping_pong
!= 0) {
180 out_be32(drvdata
->base_addr
+ XEL_BUFFER_OFFSET
+
182 XEL_RSR_RECV_IE_MASK
);
185 /* Enable the Global Interrupt Enable */
186 out_be32(drvdata
->base_addr
+ XEL_GIER_OFFSET
, XEL_GIER_GIE_MASK
);
190 * xemaclite_disable_interrupts - Disable the interrupts for the EmacLite device
191 * @drvdata: Pointer to the Emaclite device private data
193 * This function disables the Tx and Rx interrupts for the Emaclite device,
194 * along with the Global Interrupt Enable.
196 static void xemaclite_disable_interrupts(struct net_local
*drvdata
)
200 /* Disable the Global Interrupt Enable */
201 out_be32(drvdata
->base_addr
+ XEL_GIER_OFFSET
, XEL_GIER_GIE_MASK
);
203 /* Disable the Tx interrupts for the first buffer */
204 reg_data
= in_be32(drvdata
->base_addr
+ XEL_TSR_OFFSET
);
205 out_be32(drvdata
->base_addr
+ XEL_TSR_OFFSET
,
206 reg_data
& (~XEL_TSR_XMIT_IE_MASK
));
208 /* Disable the Tx interrupts for the second Buffer
209 * if configured in HW */
210 if (drvdata
->tx_ping_pong
!= 0) {
211 reg_data
= in_be32(drvdata
->base_addr
+ XEL_BUFFER_OFFSET
+
213 out_be32(drvdata
->base_addr
+ XEL_BUFFER_OFFSET
+
215 reg_data
& (~XEL_TSR_XMIT_IE_MASK
));
218 /* Disable the Rx interrupts for the first buffer */
219 reg_data
= in_be32(drvdata
->base_addr
+ XEL_RSR_OFFSET
);
220 out_be32(drvdata
->base_addr
+ XEL_RSR_OFFSET
,
221 reg_data
& (~XEL_RSR_RECV_IE_MASK
));
223 /* Disable the Rx interrupts for the second buffer
224 * if configured in HW */
225 if (drvdata
->rx_ping_pong
!= 0) {
227 reg_data
= in_be32(drvdata
->base_addr
+ XEL_BUFFER_OFFSET
+
229 out_be32(drvdata
->base_addr
+ XEL_BUFFER_OFFSET
+
231 reg_data
& (~XEL_RSR_RECV_IE_MASK
));
236 * xemaclite_aligned_write - Write from 16-bit aligned to 32-bit aligned address
237 * @src_ptr: Void pointer to the 16-bit aligned source address
238 * @dest_ptr: Pointer to the 32-bit aligned destination address
239 * @length: Number bytes to write from source to destination
241 * This function writes data from a 16-bit aligned buffer to a 32-bit aligned
242 * address in the EmacLite device.
244 static void xemaclite_aligned_write(void *src_ptr
, u32
*dest_ptr
,
249 u16
*from_u16_ptr
, *to_u16_ptr
;
251 to_u32_ptr
= dest_ptr
;
252 from_u16_ptr
= (u16
*) src_ptr
;
255 for (; length
> 3; length
-= 4) {
256 to_u16_ptr
= (u16
*) ((void *) &align_buffer
);
257 *to_u16_ptr
++ = *from_u16_ptr
++;
258 *to_u16_ptr
++ = *from_u16_ptr
++;
261 *to_u32_ptr
++ = align_buffer
;
264 u8
*from_u8_ptr
, *to_u8_ptr
;
266 /* Set up to output the remaining data */
268 to_u8_ptr
= (u8
*) &align_buffer
;
269 from_u8_ptr
= (u8
*) from_u16_ptr
;
271 /* Output the remaining data */
272 for (; length
> 0; length
--)
273 *to_u8_ptr
++ = *from_u8_ptr
++;
275 *to_u32_ptr
= align_buffer
;
280 * xemaclite_aligned_read - Read from 32-bit aligned to 16-bit aligned buffer
281 * @src_ptr: Pointer to the 32-bit aligned source address
282 * @dest_ptr: Pointer to the 16-bit aligned destination address
283 * @length: Number bytes to read from source to destination
285 * This function reads data from a 32-bit aligned address in the EmacLite device
286 * to a 16-bit aligned buffer.
288 static void xemaclite_aligned_read(u32
*src_ptr
, u8
*dest_ptr
,
291 u16
*to_u16_ptr
, *from_u16_ptr
;
295 from_u32_ptr
= src_ptr
;
296 to_u16_ptr
= (u16
*) dest_ptr
;
298 for (; length
> 3; length
-= 4) {
299 /* Copy each word into the temporary buffer */
300 align_buffer
= *from_u32_ptr
++;
301 from_u16_ptr
= (u16
*)&align_buffer
;
303 /* Read data from source */
304 *to_u16_ptr
++ = *from_u16_ptr
++;
305 *to_u16_ptr
++ = *from_u16_ptr
++;
309 u8
*to_u8_ptr
, *from_u8_ptr
;
311 /* Set up to read the remaining data */
312 to_u8_ptr
= (u8
*) to_u16_ptr
;
313 align_buffer
= *from_u32_ptr
++;
314 from_u8_ptr
= (u8
*) &align_buffer
;
316 /* Read the remaining data */
317 for (; length
> 0; length
--)
318 *to_u8_ptr
= *from_u8_ptr
;
323 * xemaclite_send_data - Send an Ethernet frame
324 * @drvdata: Pointer to the Emaclite device private data
325 * @data: Pointer to the data to be sent
326 * @byte_count: Total frame size, including header
328 * This function checks if the Tx buffer of the Emaclite device is free to send
329 * data. If so, it fills the Tx buffer with data for transmission. Otherwise, it
332 * Return: 0 upon success or -1 if the buffer(s) are full.
334 * Note: The maximum Tx packet size can not be more than Ethernet header
335 * (14 Bytes) + Maximum MTU (1500 bytes). This is excluding FCS.
337 static int xemaclite_send_data(struct net_local
*drvdata
, u8
*data
,
338 unsigned int byte_count
)
343 /* Determine the expected Tx buffer address */
344 addr
= drvdata
->base_addr
+ drvdata
->next_tx_buf_to_use
;
346 /* If the length is too large, truncate it */
347 if (byte_count
> ETH_FRAME_LEN
)
348 byte_count
= ETH_FRAME_LEN
;
350 /* Check if the expected buffer is available */
351 reg_data
= in_be32(addr
+ XEL_TSR_OFFSET
);
352 if ((reg_data
& (XEL_TSR_XMIT_BUSY_MASK
|
353 XEL_TSR_XMIT_ACTIVE_MASK
)) == 0) {
355 /* Switch to next buffer if configured */
356 if (drvdata
->tx_ping_pong
!= 0)
357 drvdata
->next_tx_buf_to_use
^= XEL_BUFFER_OFFSET
;
358 } else if (drvdata
->tx_ping_pong
!= 0) {
359 /* If the expected buffer is full, try the other buffer,
360 * if it is configured in HW */
362 addr
= (void __iomem __force
*)((u32 __force
)addr
^
364 reg_data
= in_be32(addr
+ XEL_TSR_OFFSET
);
366 if ((reg_data
& (XEL_TSR_XMIT_BUSY_MASK
|
367 XEL_TSR_XMIT_ACTIVE_MASK
)) != 0)
368 return -1; /* Buffers were full, return failure */
370 return -1; /* Buffer was full, return failure */
372 /* Write the frame to the buffer */
373 xemaclite_aligned_write(data
, (u32 __force
*) addr
, byte_count
);
375 out_be32(addr
+ XEL_TPLR_OFFSET
, (byte_count
& XEL_TPLR_LENGTH_MASK
));
377 /* Update the Tx Status Register to indicate that there is a
378 * frame to send. Set the XEL_TSR_XMIT_ACTIVE_MASK flag which
379 * is used by the interrupt handler to check whether a frame
380 * has been transmitted */
381 reg_data
= in_be32(addr
+ XEL_TSR_OFFSET
);
382 reg_data
|= (XEL_TSR_XMIT_BUSY_MASK
| XEL_TSR_XMIT_ACTIVE_MASK
);
383 out_be32(addr
+ XEL_TSR_OFFSET
, reg_data
);
389 * xemaclite_recv_data - Receive a frame
390 * @drvdata: Pointer to the Emaclite device private data
391 * @data: Address where the data is to be received
393 * This function is intended to be called from the interrupt context or
394 * with a wrapper which waits for the receive frame to be available.
396 * Return: Total number of bytes received
398 static u16
xemaclite_recv_data(struct net_local
*drvdata
, u8
*data
)
401 u16 length
, proto_type
;
404 /* Determine the expected buffer address */
405 addr
= (drvdata
->base_addr
+ drvdata
->next_rx_buf_to_use
);
407 /* Verify which buffer has valid data */
408 reg_data
= in_be32(addr
+ XEL_RSR_OFFSET
);
410 if ((reg_data
& XEL_RSR_RECV_DONE_MASK
) == XEL_RSR_RECV_DONE_MASK
) {
411 if (drvdata
->rx_ping_pong
!= 0)
412 drvdata
->next_rx_buf_to_use
^= XEL_BUFFER_OFFSET
;
414 /* The instance is out of sync, try other buffer if other
415 * buffer is configured, return 0 otherwise. If the instance is
416 * out of sync, do not update the 'next_rx_buf_to_use' since it
417 * will correct on subsequent calls */
418 if (drvdata
->rx_ping_pong
!= 0)
419 addr
= (void __iomem __force
*)((u32 __force
)addr
^
422 return 0; /* No data was available */
424 /* Verify that buffer has valid data */
425 reg_data
= in_be32(addr
+ XEL_RSR_OFFSET
);
426 if ((reg_data
& XEL_RSR_RECV_DONE_MASK
) !=
427 XEL_RSR_RECV_DONE_MASK
)
428 return 0; /* No data was available */
431 /* Get the protocol type of the ethernet frame that arrived */
432 proto_type
= ((in_be32(addr
+ XEL_HEADER_OFFSET
+
433 XEL_RXBUFF_OFFSET
) >> XEL_HEADER_SHIFT
) &
434 XEL_RPLR_LENGTH_MASK
);
436 /* Check if received ethernet frame is a raw ethernet frame
437 * or an IP packet or an ARP packet */
438 if (proto_type
> (ETH_FRAME_LEN
+ ETH_FCS_LEN
)) {
440 if (proto_type
== ETH_P_IP
) {
441 length
= ((in_be32(addr
+
442 XEL_HEADER_IP_LENGTH_OFFSET
+
443 XEL_RXBUFF_OFFSET
) >>
445 XEL_RPLR_LENGTH_MASK
);
446 length
+= ETH_HLEN
+ ETH_FCS_LEN
;
448 } else if (proto_type
== ETH_P_ARP
)
449 length
= XEL_ARP_PACKET_SIZE
+ ETH_HLEN
+ ETH_FCS_LEN
;
451 /* Field contains type other than IP or ARP, use max
452 * frame size and let user parse it */
453 length
= ETH_FRAME_LEN
+ ETH_FCS_LEN
;
455 /* Use the length in the frame, plus the header and trailer */
456 length
= proto_type
+ ETH_HLEN
+ ETH_FCS_LEN
;
458 /* Read from the EmacLite device */
459 xemaclite_aligned_read((u32 __force
*) (addr
+ XEL_RXBUFF_OFFSET
),
462 /* Acknowledge the frame */
463 reg_data
= in_be32(addr
+ XEL_RSR_OFFSET
);
464 reg_data
&= ~XEL_RSR_RECV_DONE_MASK
;
465 out_be32(addr
+ XEL_RSR_OFFSET
, reg_data
);
471 * xemaclite_update_address - Update the MAC address in the device
472 * @drvdata: Pointer to the Emaclite device private data
473 * @address_ptr:Pointer to the MAC address (MAC address is a 48-bit value)
475 * Tx must be idle and Rx should be idle for deterministic results.
476 * It is recommended that this function should be called after the
477 * initialization and before transmission of any packets from the device.
478 * The MAC address can be programmed using any of the two transmit
479 * buffers (if configured).
481 static void xemaclite_update_address(struct net_local
*drvdata
,
487 /* Determine the expected Tx buffer address */
488 addr
= drvdata
->base_addr
+ drvdata
->next_tx_buf_to_use
;
490 xemaclite_aligned_write(address_ptr
, (u32 __force
*) addr
, ETH_ALEN
);
492 out_be32(addr
+ XEL_TPLR_OFFSET
, ETH_ALEN
);
494 /* Update the MAC address in the EmacLite */
495 reg_data
= in_be32(addr
+ XEL_TSR_OFFSET
);
496 out_be32(addr
+ XEL_TSR_OFFSET
, reg_data
| XEL_TSR_PROG_MAC_ADDR
);
498 /* Wait for EmacLite to finish with the MAC address update */
499 while ((in_be32(addr
+ XEL_TSR_OFFSET
) &
500 XEL_TSR_PROG_MAC_ADDR
) != 0)
505 * xemaclite_set_mac_address - Set the MAC address for this device
506 * @dev: Pointer to the network device instance
507 * @addr: Void pointer to the sockaddr structure
509 * This function copies the HW address from the sockaddr strucutre to the
510 * net_device structure and updates the address in HW.
512 * Return: Error if the net device is busy or 0 if the addr is set
515 static int xemaclite_set_mac_address(struct net_device
*dev
, void *address
)
517 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
518 struct sockaddr
*addr
= address
;
520 if (netif_running(dev
))
523 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
524 xemaclite_update_address(lp
, dev
->dev_addr
);
529 * xemaclite_tx_timeout - Callback for Tx Timeout
530 * @dev: Pointer to the network device
532 * This function is called when Tx time out occurs for Emaclite device.
534 static void xemaclite_tx_timeout(struct net_device
*dev
)
536 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
539 dev_err(&lp
->ndev
->dev
, "Exceeded transmit timeout of %lu ms\n",
540 TX_TIMEOUT
* 1000UL / HZ
);
542 dev
->stats
.tx_errors
++;
544 /* Reset the device */
545 spin_lock_irqsave(&lp
->reset_lock
, flags
);
547 /* Shouldn't really be necessary, but shouldn't hurt */
548 netif_stop_queue(dev
);
550 xemaclite_disable_interrupts(lp
);
551 xemaclite_enable_interrupts(lp
);
553 if (lp
->deferred_skb
) {
554 dev_kfree_skb(lp
->deferred_skb
);
555 lp
->deferred_skb
= NULL
;
556 dev
->stats
.tx_errors
++;
559 /* To exclude tx timeout */
560 dev
->trans_start
= 0xffffffff - TX_TIMEOUT
- TX_TIMEOUT
;
562 /* We're all ready to go. Start the queue */
563 netif_wake_queue(dev
);
564 spin_unlock_irqrestore(&lp
->reset_lock
, flags
);
567 /**********************/
568 /* Interrupt Handlers */
569 /**********************/
572 * xemaclite_tx_handler - Interrupt handler for frames sent
573 * @dev: Pointer to the network device
575 * This function updates the number of packets transmitted and handles the
576 * deferred skb, if there is one.
578 static void xemaclite_tx_handler(struct net_device
*dev
)
580 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
582 dev
->stats
.tx_packets
++;
583 if (lp
->deferred_skb
) {
584 if (xemaclite_send_data(lp
,
585 (u8
*) lp
->deferred_skb
->data
,
586 lp
->deferred_skb
->len
) != 0)
589 dev
->stats
.tx_bytes
+= lp
->deferred_skb
->len
;
590 dev_kfree_skb_irq(lp
->deferred_skb
);
591 lp
->deferred_skb
= NULL
;
592 dev
->trans_start
= jiffies
;
593 netif_wake_queue(dev
);
599 * xemaclite_rx_handler- Interrupt handler for frames received
600 * @dev: Pointer to the network device
602 * This function allocates memory for a socket buffer, fills it with data
603 * received and hands it over to the TCP/IP stack.
605 static void xemaclite_rx_handler(struct net_device
*dev
)
607 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
612 len
= ETH_FRAME_LEN
+ ETH_FCS_LEN
;
613 skb
= dev_alloc_skb(len
+ ALIGNMENT
);
615 /* Couldn't get memory. */
616 dev
->stats
.rx_dropped
++;
617 dev_err(&lp
->ndev
->dev
, "Could not allocate receive buffer\n");
622 * A new skb should have the data halfword aligned, but this code is
623 * here just in case that isn't true. Calculate how many
624 * bytes we should reserve to get the data to start on a word
626 align
= BUFFER_ALIGN(skb
->data
);
628 skb_reserve(skb
, align
);
632 len
= xemaclite_recv_data(lp
, (u8
*) skb
->data
);
635 dev
->stats
.rx_errors
++;
636 dev_kfree_skb_irq(skb
);
640 skb_put(skb
, len
); /* Tell the skb how much data we got */
641 skb
->dev
= dev
; /* Fill out required meta-data */
643 skb
->protocol
= eth_type_trans(skb
, dev
);
644 skb
->ip_summed
= CHECKSUM_NONE
;
646 dev
->stats
.rx_packets
++;
647 dev
->stats
.rx_bytes
+= len
;
649 netif_rx(skb
); /* Send the packet upstream */
653 * xemaclite_interrupt - Interrupt handler for this driver
654 * @irq: Irq of the Emaclite device
655 * @dev_id: Void pointer to the network device instance used as callback
658 * This function handles the Tx and Rx interrupts of the EmacLite device.
660 static irqreturn_t
xemaclite_interrupt(int irq
, void *dev_id
)
662 bool tx_complete
= 0;
663 struct net_device
*dev
= dev_id
;
664 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
665 void __iomem
*base_addr
= lp
->base_addr
;
668 /* Check if there is Rx Data available */
669 if ((in_be32(base_addr
+ XEL_RSR_OFFSET
) & XEL_RSR_RECV_DONE_MASK
) ||
670 (in_be32(base_addr
+ XEL_BUFFER_OFFSET
+ XEL_RSR_OFFSET
)
671 & XEL_RSR_RECV_DONE_MASK
))
673 xemaclite_rx_handler(dev
);
675 /* Check if the Transmission for the first buffer is completed */
676 tx_status
= in_be32(base_addr
+ XEL_TSR_OFFSET
);
677 if (((tx_status
& XEL_TSR_XMIT_BUSY_MASK
) == 0) &&
678 (tx_status
& XEL_TSR_XMIT_ACTIVE_MASK
) != 0) {
680 tx_status
&= ~XEL_TSR_XMIT_ACTIVE_MASK
;
681 out_be32(base_addr
+ XEL_TSR_OFFSET
, tx_status
);
686 /* Check if the Transmission for the second buffer is completed */
687 tx_status
= in_be32(base_addr
+ XEL_BUFFER_OFFSET
+ XEL_TSR_OFFSET
);
688 if (((tx_status
& XEL_TSR_XMIT_BUSY_MASK
) == 0) &&
689 (tx_status
& XEL_TSR_XMIT_ACTIVE_MASK
) != 0) {
691 tx_status
&= ~XEL_TSR_XMIT_ACTIVE_MASK
;
692 out_be32(base_addr
+ XEL_BUFFER_OFFSET
+ XEL_TSR_OFFSET
,
698 /* If there was a Tx interrupt, call the Tx Handler */
699 if (tx_complete
!= 0)
700 xemaclite_tx_handler(dev
);
705 /**********************/
706 /* MDIO Bus functions */
707 /**********************/
710 * xemaclite_mdio_wait - Wait for the MDIO to be ready to use
711 * @lp: Pointer to the Emaclite device private data
713 * This function waits till the device is ready to accept a new MDIO
716 * Return: 0 for success or ETIMEDOUT for a timeout
719 static int xemaclite_mdio_wait(struct net_local
*lp
)
721 long end
= jiffies
+ 2;
723 /* wait for the MDIO interface to not be busy or timeout
726 while (in_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
) &
727 XEL_MDIOCTRL_MDIOSTS_MASK
) {
728 if (end
- jiffies
<= 0) {
738 * xemaclite_mdio_read - Read from a given MII management register
739 * @bus: the mii_bus struct
740 * @phy_id: the phy address
741 * @reg: register number to read from
743 * This function waits till the device is ready to accept a new MDIO
744 * request and then writes the phy address to the MDIO Address register
745 * and reads data from MDIO Read Data register, when its available.
747 * Return: Value read from the MII management register
749 static int xemaclite_mdio_read(struct mii_bus
*bus
, int phy_id
, int reg
)
751 struct net_local
*lp
= bus
->priv
;
755 if (xemaclite_mdio_wait(lp
))
758 /* Write the PHY address, register number and set the OP bit in the
759 * MDIO Address register. Set the Status bit in the MDIO Control
760 * register to start a MDIO read transaction.
762 ctrl_reg
= in_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
);
763 out_be32(lp
->base_addr
+ XEL_MDIOADDR_OFFSET
,
764 XEL_MDIOADDR_OP_MASK
|
765 ((phy_id
<< XEL_MDIOADDR_PHYADR_SHIFT
) | reg
));
766 out_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
,
767 ctrl_reg
| XEL_MDIOCTRL_MDIOSTS_MASK
);
769 if (xemaclite_mdio_wait(lp
))
772 rc
= in_be32(lp
->base_addr
+ XEL_MDIORD_OFFSET
);
774 dev_dbg(&lp
->ndev
->dev
,
775 "xemaclite_mdio_read(phy_id=%i, reg=%x) == %x\n",
782 * xemaclite_mdio_write - Write to a given MII management register
783 * @bus: the mii_bus struct
784 * @phy_id: the phy address
785 * @reg: register number to write to
786 * @val: value to write to the register number specified by reg
788 * This fucntion waits till the device is ready to accept a new MDIO
789 * request and then writes the val to the MDIO Write Data register.
791 static int xemaclite_mdio_write(struct mii_bus
*bus
, int phy_id
, int reg
,
794 struct net_local
*lp
= bus
->priv
;
797 dev_dbg(&lp
->ndev
->dev
,
798 "xemaclite_mdio_write(phy_id=%i, reg=%x, val=%x)\n",
801 if (xemaclite_mdio_wait(lp
))
804 /* Write the PHY address, register number and clear the OP bit in the
805 * MDIO Address register and then write the value into the MDIO Write
806 * Data register. Finally, set the Status bit in the MDIO Control
807 * register to start a MDIO write transaction.
809 ctrl_reg
= in_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
);
810 out_be32(lp
->base_addr
+ XEL_MDIOADDR_OFFSET
,
811 ~XEL_MDIOADDR_OP_MASK
&
812 ((phy_id
<< XEL_MDIOADDR_PHYADR_SHIFT
) | reg
));
813 out_be32(lp
->base_addr
+ XEL_MDIOWR_OFFSET
, val
);
814 out_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
,
815 ctrl_reg
| XEL_MDIOCTRL_MDIOSTS_MASK
);
821 * xemaclite_mdio_reset - Reset the mdio bus.
822 * @bus: Pointer to the MII bus
824 * This function is required(?) as per Documentation/networking/phy.txt.
825 * There is no reset in this device; this function always returns 0.
827 static int xemaclite_mdio_reset(struct mii_bus
*bus
)
833 * xemaclite_mdio_setup - Register mii_bus for the Emaclite device
834 * @lp: Pointer to the Emaclite device private data
835 * @ofdev: Pointer to OF device structure
837 * This function enables MDIO bus in the Emaclite device and registers a
840 * Return: 0 upon success or a negative error upon failure
842 static int xemaclite_mdio_setup(struct net_local
*lp
, struct device
*dev
)
847 struct device_node
*np
= of_get_parent(lp
->phy_node
);
849 /* Don't register the MDIO bus if the phy_node or its parent node
855 /* Enable the MDIO bus by asserting the enable bit in MDIO Control
858 out_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
,
859 XEL_MDIOCTRL_MDIOEN_MASK
);
861 bus
= mdiobus_alloc();
865 of_address_to_resource(np
, 0, &res
);
866 snprintf(bus
->id
, MII_BUS_ID_SIZE
, "%.8llx",
867 (unsigned long long)res
.start
);
869 bus
->name
= "Xilinx Emaclite MDIO";
870 bus
->read
= xemaclite_mdio_read
;
871 bus
->write
= xemaclite_mdio_write
;
872 bus
->reset
= xemaclite_mdio_reset
;
874 bus
->irq
= lp
->mdio_irqs
; /* preallocated IRQ table */
878 rc
= of_mdiobus_register(bus
, np
);
890 * xemaclite_adjust_link - Link state callback for the Emaclite device
891 * @ndev: pointer to net_device struct
893 * There's nothing in the Emaclite device to be configured when the link
894 * state changes. We just print the status.
896 void xemaclite_adjust_link(struct net_device
*ndev
)
898 struct net_local
*lp
= netdev_priv(ndev
);
899 struct phy_device
*phy
= lp
->phy_dev
;
902 /* hash together the state values to decide if something has changed */
903 link_state
= phy
->speed
| (phy
->duplex
<< 1) | phy
->link
;
905 if (lp
->last_link
!= link_state
) {
906 lp
->last_link
= link_state
;
907 phy_print_status(phy
);
912 * xemaclite_open - Open the network device
913 * @dev: Pointer to the network device
915 * This function sets the MAC address, requests an IRQ and enables interrupts
916 * for the Emaclite device and starts the Tx queue.
917 * It also connects to the phy device, if MDIO is included in Emaclite device.
919 static int xemaclite_open(struct net_device
*dev
)
921 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
924 /* Just to be safe, stop the device first */
925 xemaclite_disable_interrupts(lp
);
930 lp
->phy_dev
= of_phy_connect(lp
->ndev
, lp
->phy_node
,
931 xemaclite_adjust_link
, 0,
932 PHY_INTERFACE_MODE_MII
);
934 dev_err(&lp
->ndev
->dev
, "of_phy_connect() failed\n");
938 /* EmacLite doesn't support giga-bit speeds */
939 lp
->phy_dev
->supported
&= (PHY_BASIC_FEATURES
);
940 lp
->phy_dev
->advertising
= lp
->phy_dev
->supported
;
942 /* Don't advertise 1000BASE-T Full/Half duplex speeds */
943 phy_write(lp
->phy_dev
, MII_CTRL1000
, 0);
945 /* Advertise only 10 and 100mbps full/half duplex speeds */
946 phy_write(lp
->phy_dev
, MII_ADVERTISE
, ADVERTISE_ALL
);
948 /* Restart auto negotiation */
949 bmcr
= phy_read(lp
->phy_dev
, MII_BMCR
);
950 bmcr
|= (BMCR_ANENABLE
| BMCR_ANRESTART
);
951 phy_write(lp
->phy_dev
, MII_BMCR
, bmcr
);
953 phy_start(lp
->phy_dev
);
956 /* Set the MAC address each time opened */
957 xemaclite_update_address(lp
, dev
->dev_addr
);
960 retval
= request_irq(dev
->irq
, xemaclite_interrupt
, 0, dev
->name
, dev
);
962 dev_err(&lp
->ndev
->dev
, "Could not allocate interrupt %d\n",
965 phy_disconnect(lp
->phy_dev
);
971 /* Enable Interrupts */
972 xemaclite_enable_interrupts(lp
);
974 /* We're ready to go */
975 netif_start_queue(dev
);
981 * xemaclite_close - Close the network device
982 * @dev: Pointer to the network device
984 * This function stops the Tx queue, disables interrupts and frees the IRQ for
985 * the Emaclite device.
986 * It also disconnects the phy device associated with the Emaclite device.
988 static int xemaclite_close(struct net_device
*dev
)
990 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
992 netif_stop_queue(dev
);
993 xemaclite_disable_interrupts(lp
);
994 free_irq(dev
->irq
, dev
);
997 phy_disconnect(lp
->phy_dev
);
1004 * xemaclite_get_stats - Get the stats for the net_device
1005 * @dev: Pointer to the network device
1007 * This function returns the address of the 'net_device_stats' structure for the
1008 * given network device. This structure holds usage statistics for the network
1011 * Return: Pointer to the net_device_stats structure.
1013 static struct net_device_stats
*xemaclite_get_stats(struct net_device
*dev
)
1019 * xemaclite_send - Transmit a frame
1020 * @orig_skb: Pointer to the socket buffer to be transmitted
1021 * @dev: Pointer to the network device
1023 * This function checks if the Tx buffer of the Emaclite device is free to send
1024 * data. If so, it fills the Tx buffer with data from socket buffer data,
1025 * updates the stats and frees the socket buffer. The Tx completion is signaled
1026 * by an interrupt. If the Tx buffer isn't free, then the socket buffer is
1027 * deferred and the Tx queue is stopped so that the deferred socket buffer can
1028 * be transmitted when the Emaclite device is free to transmit data.
1030 * Return: 0, always.
1032 static int xemaclite_send(struct sk_buff
*orig_skb
, struct net_device
*dev
)
1034 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
1035 struct sk_buff
*new_skb
;
1037 unsigned long flags
;
1039 len
= orig_skb
->len
;
1043 spin_lock_irqsave(&lp
->reset_lock
, flags
);
1044 if (xemaclite_send_data(lp
, (u8
*) new_skb
->data
, len
) != 0) {
1045 /* If the Emaclite Tx buffer is busy, stop the Tx queue and
1046 * defer the skb for transmission at a later point when the
1047 * current transmission is complete */
1048 netif_stop_queue(dev
);
1049 lp
->deferred_skb
= new_skb
;
1050 spin_unlock_irqrestore(&lp
->reset_lock
, flags
);
1053 spin_unlock_irqrestore(&lp
->reset_lock
, flags
);
1055 dev
->stats
.tx_bytes
+= len
;
1056 dev_kfree_skb(new_skb
);
1057 dev
->trans_start
= jiffies
;
1063 * xemaclite_remove_ndev - Free the network device
1064 * @ndev: Pointer to the network device to be freed
1066 * This function un maps the IO region of the Emaclite device and frees the net
1069 static void xemaclite_remove_ndev(struct net_device
*ndev
)
1072 struct net_local
*lp
= (struct net_local
*) netdev_priv(ndev
);
1075 iounmap((void __iomem __force
*) (lp
->base_addr
));
1081 * get_bool - Get a parameter from the OF device
1082 * @ofdev: Pointer to OF device structure
1083 * @s: Property to be retrieved
1085 * This function looks for a property in the device node and returns the value
1086 * of the property if its found or 0 if the property is not found.
1088 * Return: Value of the parameter if the parameter is found, or 0 otherwise
1090 static bool get_bool(struct of_device
*ofdev
, const char *s
)
1092 u32
*p
= (u32
*)of_get_property(ofdev
->node
, s
, NULL
);
1097 dev_warn(&ofdev
->dev
, "Parameter %s not found,"
1098 "defaulting to false\n", s
);
1103 static struct net_device_ops xemaclite_netdev_ops
;
1106 * xemaclite_of_probe - Probe method for the Emaclite device.
1107 * @ofdev: Pointer to OF device structure
1108 * @match: Pointer to the structure used for matching a device
1110 * This function probes for the Emaclite device in the device tree.
1111 * It initializes the driver data structure and the hardware, sets the MAC
1112 * address and registers the network device.
1113 * It also registers a mii_bus for the Emaclite device, if MDIO is included
1116 * Return: 0, if the driver is bound to the Emaclite device, or
1117 * a negative error if there is failure.
1119 static int __devinit
xemaclite_of_probe(struct of_device
*ofdev
,
1120 const struct of_device_id
*match
)
1122 struct resource r_irq
; /* Interrupt resources */
1123 struct resource r_mem
; /* IO mem resources */
1124 struct net_device
*ndev
= NULL
;
1125 struct net_local
*lp
= NULL
;
1126 struct device
*dev
= &ofdev
->dev
;
1127 const void *mac_address
;
1131 dev_info(dev
, "Device Tree Probing\n");
1133 /* Get iospace for the device */
1134 rc
= of_address_to_resource(ofdev
->node
, 0, &r_mem
);
1136 dev_err(dev
, "invalid address\n");
1140 /* Get IRQ for the device */
1141 rc
= of_irq_to_resource(ofdev
->node
, 0, &r_irq
);
1143 dev_err(dev
, "no IRQ found\n");
1147 /* Create an ethernet device instance */
1148 ndev
= alloc_etherdev(sizeof(struct net_local
));
1150 dev_err(dev
, "Could not allocate network device\n");
1154 dev_set_drvdata(dev
, ndev
);
1155 SET_NETDEV_DEV(ndev
, &ofdev
->dev
);
1157 ndev
->irq
= r_irq
.start
;
1158 ndev
->mem_start
= r_mem
.start
;
1159 ndev
->mem_end
= r_mem
.end
;
1161 lp
= netdev_priv(ndev
);
1164 if (!request_mem_region(ndev
->mem_start
,
1165 ndev
->mem_end
- ndev
->mem_start
+ 1,
1167 dev_err(dev
, "Couldn't lock memory region at %p\n",
1168 (void *)ndev
->mem_start
);
1173 /* Get the virtual base address for the device */
1174 lp
->base_addr
= ioremap(r_mem
.start
, r_mem
.end
- r_mem
.start
+ 1);
1175 if (NULL
== lp
->base_addr
) {
1176 dev_err(dev
, "EmacLite: Could not allocate iomem\n");
1181 spin_lock_init(&lp
->reset_lock
);
1182 lp
->next_tx_buf_to_use
= 0x0;
1183 lp
->next_rx_buf_to_use
= 0x0;
1184 lp
->tx_ping_pong
= get_bool(ofdev
, "xlnx,tx-ping-pong");
1185 lp
->rx_ping_pong
= get_bool(ofdev
, "xlnx,rx-ping-pong");
1186 mac_address
= of_get_mac_address(ofdev
->node
);
1189 /* Set the MAC address. */
1190 memcpy(ndev
->dev_addr
, mac_address
, 6);
1192 dev_warn(dev
, "No MAC address found\n");
1194 /* Clear the Tx CSR's in case this is a restart */
1195 out_be32(lp
->base_addr
+ XEL_TSR_OFFSET
, 0);
1196 out_be32(lp
->base_addr
+ XEL_BUFFER_OFFSET
+ XEL_TSR_OFFSET
, 0);
1198 /* Set the MAC address in the EmacLite device */
1199 xemaclite_update_address(lp
, ndev
->dev_addr
);
1201 lp
->phy_node
= of_parse_phandle(ofdev
->node
, "phy-handle", 0);
1202 rc
= xemaclite_mdio_setup(lp
, &ofdev
->dev
);
1204 dev_warn(&ofdev
->dev
, "error registering MDIO bus\n");
1206 dev_info(dev
, "MAC address is now %pM\n", ndev
->dev_addr
);
1208 ndev
->netdev_ops
= &xemaclite_netdev_ops
;
1209 ndev
->flags
&= ~IFF_MULTICAST
;
1210 ndev
->watchdog_timeo
= TX_TIMEOUT
;
1212 /* Finally, register the device */
1213 rc
= register_netdev(ndev
);
1216 "Cannot register network device, aborting\n");
1221 "Xilinx EmacLite at 0x%08X mapped to 0x%08X, irq=%d\n",
1222 (unsigned int __force
)ndev
->mem_start
,
1223 (unsigned int __force
)lp
->base_addr
, ndev
->irq
);
1227 release_mem_region(ndev
->mem_start
, r_mem
.end
- r_mem
.start
+ 1);
1230 xemaclite_remove_ndev(ndev
);
1235 * xemaclite_of_remove - Unbind the driver from the Emaclite device.
1236 * @of_dev: Pointer to OF device structure
1238 * This function is called if a device is physically removed from the system or
1239 * if the driver module is being unloaded. It frees any resources allocated to
1242 * Return: 0, always.
1244 static int __devexit
xemaclite_of_remove(struct of_device
*of_dev
)
1246 struct device
*dev
= &of_dev
->dev
;
1247 struct net_device
*ndev
= dev_get_drvdata(dev
);
1249 struct net_local
*lp
= (struct net_local
*) netdev_priv(ndev
);
1251 /* Un-register the mii_bus, if configured */
1253 mdiobus_unregister(lp
->mii_bus
);
1254 kfree(lp
->mii_bus
->irq
);
1255 mdiobus_free(lp
->mii_bus
);
1259 unregister_netdev(ndev
);
1262 of_node_put(lp
->phy_node
);
1263 lp
->phy_node
= NULL
;
1265 release_mem_region(ndev
->mem_start
, ndev
->mem_end
-ndev
->mem_start
+ 1);
1267 xemaclite_remove_ndev(ndev
);
1268 dev_set_drvdata(dev
, NULL
);
1273 static struct net_device_ops xemaclite_netdev_ops
= {
1274 .ndo_open
= xemaclite_open
,
1275 .ndo_stop
= xemaclite_close
,
1276 .ndo_start_xmit
= xemaclite_send
,
1277 .ndo_set_mac_address
= xemaclite_set_mac_address
,
1278 .ndo_tx_timeout
= xemaclite_tx_timeout
,
1279 .ndo_get_stats
= xemaclite_get_stats
,
1282 /* Match table for OF platform binding */
1283 static struct of_device_id xemaclite_of_match
[] __devinitdata
= {
1284 { .compatible
= "xlnx,opb-ethernetlite-1.01.a", },
1285 { .compatible
= "xlnx,opb-ethernetlite-1.01.b", },
1286 { .compatible
= "xlnx,xps-ethernetlite-1.00.a", },
1287 { .compatible
= "xlnx,xps-ethernetlite-2.00.a", },
1288 { .compatible
= "xlnx,xps-ethernetlite-2.01.a", },
1289 { .compatible
= "xlnx,xps-ethernetlite-3.00.a", },
1290 { /* end of list */ },
1292 MODULE_DEVICE_TABLE(of
, xemaclite_of_match
);
1294 static struct of_platform_driver xemaclite_of_driver
= {
1295 .name
= DRIVER_NAME
,
1296 .match_table
= xemaclite_of_match
,
1297 .probe
= xemaclite_of_probe
,
1298 .remove
= __devexit_p(xemaclite_of_remove
),
1302 * xgpiopss_init - Initial driver registration call
1304 * Return: 0 upon success, or a negative error upon failure.
1306 static int __init
xemaclite_init(void)
1308 /* No kernel boot options used, we just need to register the driver */
1309 return of_register_platform_driver(&xemaclite_of_driver
);
1313 * xemaclite_cleanup - Driver un-registration call
1315 static void __exit
xemaclite_cleanup(void)
1317 of_unregister_platform_driver(&xemaclite_of_driver
);
1320 module_init(xemaclite_init
);
1321 module_exit(xemaclite_cleanup
);
1323 MODULE_AUTHOR("Xilinx, Inc.");
1324 MODULE_DESCRIPTION("Xilinx Ethernet MAC Lite driver");
1325 MODULE_LICENSE("GPL");