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 */
642 skb
->protocol
= eth_type_trans(skb
, dev
);
643 skb
->ip_summed
= CHECKSUM_NONE
;
645 dev
->stats
.rx_packets
++;
646 dev
->stats
.rx_bytes
+= len
;
648 netif_rx(skb
); /* Send the packet upstream */
652 * xemaclite_interrupt - Interrupt handler for this driver
653 * @irq: Irq of the Emaclite device
654 * @dev_id: Void pointer to the network device instance used as callback
657 * This function handles the Tx and Rx interrupts of the EmacLite device.
659 static irqreturn_t
xemaclite_interrupt(int irq
, void *dev_id
)
661 bool tx_complete
= 0;
662 struct net_device
*dev
= dev_id
;
663 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
664 void __iomem
*base_addr
= lp
->base_addr
;
667 /* Check if there is Rx Data available */
668 if ((in_be32(base_addr
+ XEL_RSR_OFFSET
) & XEL_RSR_RECV_DONE_MASK
) ||
669 (in_be32(base_addr
+ XEL_BUFFER_OFFSET
+ XEL_RSR_OFFSET
)
670 & XEL_RSR_RECV_DONE_MASK
))
672 xemaclite_rx_handler(dev
);
674 /* Check if the Transmission for the first buffer is completed */
675 tx_status
= in_be32(base_addr
+ XEL_TSR_OFFSET
);
676 if (((tx_status
& XEL_TSR_XMIT_BUSY_MASK
) == 0) &&
677 (tx_status
& XEL_TSR_XMIT_ACTIVE_MASK
) != 0) {
679 tx_status
&= ~XEL_TSR_XMIT_ACTIVE_MASK
;
680 out_be32(base_addr
+ XEL_TSR_OFFSET
, tx_status
);
685 /* Check if the Transmission for the second buffer is completed */
686 tx_status
= in_be32(base_addr
+ XEL_BUFFER_OFFSET
+ XEL_TSR_OFFSET
);
687 if (((tx_status
& XEL_TSR_XMIT_BUSY_MASK
) == 0) &&
688 (tx_status
& XEL_TSR_XMIT_ACTIVE_MASK
) != 0) {
690 tx_status
&= ~XEL_TSR_XMIT_ACTIVE_MASK
;
691 out_be32(base_addr
+ XEL_BUFFER_OFFSET
+ XEL_TSR_OFFSET
,
697 /* If there was a Tx interrupt, call the Tx Handler */
698 if (tx_complete
!= 0)
699 xemaclite_tx_handler(dev
);
704 /**********************/
705 /* MDIO Bus functions */
706 /**********************/
709 * xemaclite_mdio_wait - Wait for the MDIO to be ready to use
710 * @lp: Pointer to the Emaclite device private data
712 * This function waits till the device is ready to accept a new MDIO
715 * Return: 0 for success or ETIMEDOUT for a timeout
718 static int xemaclite_mdio_wait(struct net_local
*lp
)
720 long end
= jiffies
+ 2;
722 /* wait for the MDIO interface to not be busy or timeout
725 while (in_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
) &
726 XEL_MDIOCTRL_MDIOSTS_MASK
) {
727 if (end
- jiffies
<= 0) {
737 * xemaclite_mdio_read - Read from a given MII management register
738 * @bus: the mii_bus struct
739 * @phy_id: the phy address
740 * @reg: register number to read from
742 * This function waits till the device is ready to accept a new MDIO
743 * request and then writes the phy address to the MDIO Address register
744 * and reads data from MDIO Read Data register, when its available.
746 * Return: Value read from the MII management register
748 static int xemaclite_mdio_read(struct mii_bus
*bus
, int phy_id
, int reg
)
750 struct net_local
*lp
= bus
->priv
;
754 if (xemaclite_mdio_wait(lp
))
757 /* Write the PHY address, register number and set the OP bit in the
758 * MDIO Address register. Set the Status bit in the MDIO Control
759 * register to start a MDIO read transaction.
761 ctrl_reg
= in_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
);
762 out_be32(lp
->base_addr
+ XEL_MDIOADDR_OFFSET
,
763 XEL_MDIOADDR_OP_MASK
|
764 ((phy_id
<< XEL_MDIOADDR_PHYADR_SHIFT
) | reg
));
765 out_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
,
766 ctrl_reg
| XEL_MDIOCTRL_MDIOSTS_MASK
);
768 if (xemaclite_mdio_wait(lp
))
771 rc
= in_be32(lp
->base_addr
+ XEL_MDIORD_OFFSET
);
773 dev_dbg(&lp
->ndev
->dev
,
774 "xemaclite_mdio_read(phy_id=%i, reg=%x) == %x\n",
781 * xemaclite_mdio_write - Write to a given MII management register
782 * @bus: the mii_bus struct
783 * @phy_id: the phy address
784 * @reg: register number to write to
785 * @val: value to write to the register number specified by reg
787 * This fucntion waits till the device is ready to accept a new MDIO
788 * request and then writes the val to the MDIO Write Data register.
790 static int xemaclite_mdio_write(struct mii_bus
*bus
, int phy_id
, int reg
,
793 struct net_local
*lp
= bus
->priv
;
796 dev_dbg(&lp
->ndev
->dev
,
797 "xemaclite_mdio_write(phy_id=%i, reg=%x, val=%x)\n",
800 if (xemaclite_mdio_wait(lp
))
803 /* Write the PHY address, register number and clear the OP bit in the
804 * MDIO Address register and then write the value into the MDIO Write
805 * Data register. Finally, set the Status bit in the MDIO Control
806 * register to start a MDIO write transaction.
808 ctrl_reg
= in_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
);
809 out_be32(lp
->base_addr
+ XEL_MDIOADDR_OFFSET
,
810 ~XEL_MDIOADDR_OP_MASK
&
811 ((phy_id
<< XEL_MDIOADDR_PHYADR_SHIFT
) | reg
));
812 out_be32(lp
->base_addr
+ XEL_MDIOWR_OFFSET
, val
);
813 out_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
,
814 ctrl_reg
| XEL_MDIOCTRL_MDIOSTS_MASK
);
820 * xemaclite_mdio_reset - Reset the mdio bus.
821 * @bus: Pointer to the MII bus
823 * This function is required(?) as per Documentation/networking/phy.txt.
824 * There is no reset in this device; this function always returns 0.
826 static int xemaclite_mdio_reset(struct mii_bus
*bus
)
832 * xemaclite_mdio_setup - Register mii_bus for the Emaclite device
833 * @lp: Pointer to the Emaclite device private data
834 * @ofdev: Pointer to OF device structure
836 * This function enables MDIO bus in the Emaclite device and registers a
839 * Return: 0 upon success or a negative error upon failure
841 static int xemaclite_mdio_setup(struct net_local
*lp
, struct device
*dev
)
846 struct device_node
*np
= of_get_parent(lp
->phy_node
);
848 /* Don't register the MDIO bus if the phy_node or its parent node
854 /* Enable the MDIO bus by asserting the enable bit in MDIO Control
857 out_be32(lp
->base_addr
+ XEL_MDIOCTRL_OFFSET
,
858 XEL_MDIOCTRL_MDIOEN_MASK
);
860 bus
= mdiobus_alloc();
864 of_address_to_resource(np
, 0, &res
);
865 snprintf(bus
->id
, MII_BUS_ID_SIZE
, "%.8llx",
866 (unsigned long long)res
.start
);
868 bus
->name
= "Xilinx Emaclite MDIO";
869 bus
->read
= xemaclite_mdio_read
;
870 bus
->write
= xemaclite_mdio_write
;
871 bus
->reset
= xemaclite_mdio_reset
;
873 bus
->irq
= lp
->mdio_irqs
; /* preallocated IRQ table */
877 rc
= of_mdiobus_register(bus
, np
);
889 * xemaclite_adjust_link - Link state callback for the Emaclite device
890 * @ndev: pointer to net_device struct
892 * There's nothing in the Emaclite device to be configured when the link
893 * state changes. We just print the status.
895 void xemaclite_adjust_link(struct net_device
*ndev
)
897 struct net_local
*lp
= netdev_priv(ndev
);
898 struct phy_device
*phy
= lp
->phy_dev
;
901 /* hash together the state values to decide if something has changed */
902 link_state
= phy
->speed
| (phy
->duplex
<< 1) | phy
->link
;
904 if (lp
->last_link
!= link_state
) {
905 lp
->last_link
= link_state
;
906 phy_print_status(phy
);
911 * xemaclite_open - Open the network device
912 * @dev: Pointer to the network device
914 * This function sets the MAC address, requests an IRQ and enables interrupts
915 * for the Emaclite device and starts the Tx queue.
916 * It also connects to the phy device, if MDIO is included in Emaclite device.
918 static int xemaclite_open(struct net_device
*dev
)
920 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
923 /* Just to be safe, stop the device first */
924 xemaclite_disable_interrupts(lp
);
929 lp
->phy_dev
= of_phy_connect(lp
->ndev
, lp
->phy_node
,
930 xemaclite_adjust_link
, 0,
931 PHY_INTERFACE_MODE_MII
);
933 dev_err(&lp
->ndev
->dev
, "of_phy_connect() failed\n");
937 /* EmacLite doesn't support giga-bit speeds */
938 lp
->phy_dev
->supported
&= (PHY_BASIC_FEATURES
);
939 lp
->phy_dev
->advertising
= lp
->phy_dev
->supported
;
941 /* Don't advertise 1000BASE-T Full/Half duplex speeds */
942 phy_write(lp
->phy_dev
, MII_CTRL1000
, 0);
944 /* Advertise only 10 and 100mbps full/half duplex speeds */
945 phy_write(lp
->phy_dev
, MII_ADVERTISE
, ADVERTISE_ALL
);
947 /* Restart auto negotiation */
948 bmcr
= phy_read(lp
->phy_dev
, MII_BMCR
);
949 bmcr
|= (BMCR_ANENABLE
| BMCR_ANRESTART
);
950 phy_write(lp
->phy_dev
, MII_BMCR
, bmcr
);
952 phy_start(lp
->phy_dev
);
955 /* Set the MAC address each time opened */
956 xemaclite_update_address(lp
, dev
->dev_addr
);
959 retval
= request_irq(dev
->irq
, xemaclite_interrupt
, 0, dev
->name
, dev
);
961 dev_err(&lp
->ndev
->dev
, "Could not allocate interrupt %d\n",
964 phy_disconnect(lp
->phy_dev
);
970 /* Enable Interrupts */
971 xemaclite_enable_interrupts(lp
);
973 /* We're ready to go */
974 netif_start_queue(dev
);
980 * xemaclite_close - Close the network device
981 * @dev: Pointer to the network device
983 * This function stops the Tx queue, disables interrupts and frees the IRQ for
984 * the Emaclite device.
985 * It also disconnects the phy device associated with the Emaclite device.
987 static int xemaclite_close(struct net_device
*dev
)
989 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
991 netif_stop_queue(dev
);
992 xemaclite_disable_interrupts(lp
);
993 free_irq(dev
->irq
, dev
);
996 phy_disconnect(lp
->phy_dev
);
1003 * xemaclite_get_stats - Get the stats for the net_device
1004 * @dev: Pointer to the network device
1006 * This function returns the address of the 'net_device_stats' structure for the
1007 * given network device. This structure holds usage statistics for the network
1010 * Return: Pointer to the net_device_stats structure.
1012 static struct net_device_stats
*xemaclite_get_stats(struct net_device
*dev
)
1018 * xemaclite_send - Transmit a frame
1019 * @orig_skb: Pointer to the socket buffer to be transmitted
1020 * @dev: Pointer to the network device
1022 * This function checks if the Tx buffer of the Emaclite device is free to send
1023 * data. If so, it fills the Tx buffer with data from socket buffer data,
1024 * updates the stats and frees the socket buffer. The Tx completion is signaled
1025 * by an interrupt. If the Tx buffer isn't free, then the socket buffer is
1026 * deferred and the Tx queue is stopped so that the deferred socket buffer can
1027 * be transmitted when the Emaclite device is free to transmit data.
1029 * Return: 0, always.
1031 static int xemaclite_send(struct sk_buff
*orig_skb
, struct net_device
*dev
)
1033 struct net_local
*lp
= (struct net_local
*) netdev_priv(dev
);
1034 struct sk_buff
*new_skb
;
1036 unsigned long flags
;
1038 len
= orig_skb
->len
;
1042 spin_lock_irqsave(&lp
->reset_lock
, flags
);
1043 if (xemaclite_send_data(lp
, (u8
*) new_skb
->data
, len
) != 0) {
1044 /* If the Emaclite Tx buffer is busy, stop the Tx queue and
1045 * defer the skb for transmission at a later point when the
1046 * current transmission is complete */
1047 netif_stop_queue(dev
);
1048 lp
->deferred_skb
= new_skb
;
1049 spin_unlock_irqrestore(&lp
->reset_lock
, flags
);
1052 spin_unlock_irqrestore(&lp
->reset_lock
, flags
);
1054 dev
->stats
.tx_bytes
+= len
;
1055 dev_kfree_skb(new_skb
);
1056 dev
->trans_start
= jiffies
;
1062 * xemaclite_remove_ndev - Free the network device
1063 * @ndev: Pointer to the network device to be freed
1065 * This function un maps the IO region of the Emaclite device and frees the net
1068 static void xemaclite_remove_ndev(struct net_device
*ndev
)
1071 struct net_local
*lp
= (struct net_local
*) netdev_priv(ndev
);
1074 iounmap((void __iomem __force
*) (lp
->base_addr
));
1080 * get_bool - Get a parameter from the OF device
1081 * @ofdev: Pointer to OF device structure
1082 * @s: Property to be retrieved
1084 * This function looks for a property in the device node and returns the value
1085 * of the property if its found or 0 if the property is not found.
1087 * Return: Value of the parameter if the parameter is found, or 0 otherwise
1089 static bool get_bool(struct of_device
*ofdev
, const char *s
)
1091 u32
*p
= (u32
*)of_get_property(ofdev
->node
, s
, NULL
);
1096 dev_warn(&ofdev
->dev
, "Parameter %s not found,"
1097 "defaulting to false\n", s
);
1102 static struct net_device_ops xemaclite_netdev_ops
;
1105 * xemaclite_of_probe - Probe method for the Emaclite device.
1106 * @ofdev: Pointer to OF device structure
1107 * @match: Pointer to the structure used for matching a device
1109 * This function probes for the Emaclite device in the device tree.
1110 * It initializes the driver data structure and the hardware, sets the MAC
1111 * address and registers the network device.
1112 * It also registers a mii_bus for the Emaclite device, if MDIO is included
1115 * Return: 0, if the driver is bound to the Emaclite device, or
1116 * a negative error if there is failure.
1118 static int __devinit
xemaclite_of_probe(struct of_device
*ofdev
,
1119 const struct of_device_id
*match
)
1121 struct resource r_irq
; /* Interrupt resources */
1122 struct resource r_mem
; /* IO mem resources */
1123 struct net_device
*ndev
= NULL
;
1124 struct net_local
*lp
= NULL
;
1125 struct device
*dev
= &ofdev
->dev
;
1126 const void *mac_address
;
1130 dev_info(dev
, "Device Tree Probing\n");
1132 /* Get iospace for the device */
1133 rc
= of_address_to_resource(ofdev
->node
, 0, &r_mem
);
1135 dev_err(dev
, "invalid address\n");
1139 /* Get IRQ for the device */
1140 rc
= of_irq_to_resource(ofdev
->node
, 0, &r_irq
);
1142 dev_err(dev
, "no IRQ found\n");
1146 /* Create an ethernet device instance */
1147 ndev
= alloc_etherdev(sizeof(struct net_local
));
1149 dev_err(dev
, "Could not allocate network device\n");
1153 dev_set_drvdata(dev
, ndev
);
1154 SET_NETDEV_DEV(ndev
, &ofdev
->dev
);
1156 ndev
->irq
= r_irq
.start
;
1157 ndev
->mem_start
= r_mem
.start
;
1158 ndev
->mem_end
= r_mem
.end
;
1160 lp
= netdev_priv(ndev
);
1163 if (!request_mem_region(ndev
->mem_start
,
1164 ndev
->mem_end
- ndev
->mem_start
+ 1,
1166 dev_err(dev
, "Couldn't lock memory region at %p\n",
1167 (void *)ndev
->mem_start
);
1172 /* Get the virtual base address for the device */
1173 lp
->base_addr
= ioremap(r_mem
.start
, r_mem
.end
- r_mem
.start
+ 1);
1174 if (NULL
== lp
->base_addr
) {
1175 dev_err(dev
, "EmacLite: Could not allocate iomem\n");
1180 spin_lock_init(&lp
->reset_lock
);
1181 lp
->next_tx_buf_to_use
= 0x0;
1182 lp
->next_rx_buf_to_use
= 0x0;
1183 lp
->tx_ping_pong
= get_bool(ofdev
, "xlnx,tx-ping-pong");
1184 lp
->rx_ping_pong
= get_bool(ofdev
, "xlnx,rx-ping-pong");
1185 mac_address
= of_get_mac_address(ofdev
->node
);
1188 /* Set the MAC address. */
1189 memcpy(ndev
->dev_addr
, mac_address
, 6);
1191 dev_warn(dev
, "No MAC address found\n");
1193 /* Clear the Tx CSR's in case this is a restart */
1194 out_be32(lp
->base_addr
+ XEL_TSR_OFFSET
, 0);
1195 out_be32(lp
->base_addr
+ XEL_BUFFER_OFFSET
+ XEL_TSR_OFFSET
, 0);
1197 /* Set the MAC address in the EmacLite device */
1198 xemaclite_update_address(lp
, ndev
->dev_addr
);
1200 lp
->phy_node
= of_parse_phandle(ofdev
->node
, "phy-handle", 0);
1201 rc
= xemaclite_mdio_setup(lp
, &ofdev
->dev
);
1203 dev_warn(&ofdev
->dev
, "error registering MDIO bus\n");
1205 dev_info(dev
, "MAC address is now %pM\n", ndev
->dev_addr
);
1207 ndev
->netdev_ops
= &xemaclite_netdev_ops
;
1208 ndev
->flags
&= ~IFF_MULTICAST
;
1209 ndev
->watchdog_timeo
= TX_TIMEOUT
;
1211 /* Finally, register the device */
1212 rc
= register_netdev(ndev
);
1215 "Cannot register network device, aborting\n");
1220 "Xilinx EmacLite at 0x%08X mapped to 0x%08X, irq=%d\n",
1221 (unsigned int __force
)ndev
->mem_start
,
1222 (unsigned int __force
)lp
->base_addr
, ndev
->irq
);
1226 release_mem_region(ndev
->mem_start
, r_mem
.end
- r_mem
.start
+ 1);
1229 xemaclite_remove_ndev(ndev
);
1234 * xemaclite_of_remove - Unbind the driver from the Emaclite device.
1235 * @of_dev: Pointer to OF device structure
1237 * This function is called if a device is physically removed from the system or
1238 * if the driver module is being unloaded. It frees any resources allocated to
1241 * Return: 0, always.
1243 static int __devexit
xemaclite_of_remove(struct of_device
*of_dev
)
1245 struct device
*dev
= &of_dev
->dev
;
1246 struct net_device
*ndev
= dev_get_drvdata(dev
);
1248 struct net_local
*lp
= (struct net_local
*) netdev_priv(ndev
);
1250 /* Un-register the mii_bus, if configured */
1252 mdiobus_unregister(lp
->mii_bus
);
1253 kfree(lp
->mii_bus
->irq
);
1254 mdiobus_free(lp
->mii_bus
);
1258 unregister_netdev(ndev
);
1261 of_node_put(lp
->phy_node
);
1262 lp
->phy_node
= NULL
;
1264 release_mem_region(ndev
->mem_start
, ndev
->mem_end
-ndev
->mem_start
+ 1);
1266 xemaclite_remove_ndev(ndev
);
1267 dev_set_drvdata(dev
, NULL
);
1272 static struct net_device_ops xemaclite_netdev_ops
= {
1273 .ndo_open
= xemaclite_open
,
1274 .ndo_stop
= xemaclite_close
,
1275 .ndo_start_xmit
= xemaclite_send
,
1276 .ndo_set_mac_address
= xemaclite_set_mac_address
,
1277 .ndo_tx_timeout
= xemaclite_tx_timeout
,
1278 .ndo_get_stats
= xemaclite_get_stats
,
1281 /* Match table for OF platform binding */
1282 static struct of_device_id xemaclite_of_match
[] __devinitdata
= {
1283 { .compatible
= "xlnx,opb-ethernetlite-1.01.a", },
1284 { .compatible
= "xlnx,opb-ethernetlite-1.01.b", },
1285 { .compatible
= "xlnx,xps-ethernetlite-1.00.a", },
1286 { .compatible
= "xlnx,xps-ethernetlite-2.00.a", },
1287 { .compatible
= "xlnx,xps-ethernetlite-2.01.a", },
1288 { .compatible
= "xlnx,xps-ethernetlite-3.00.a", },
1289 { /* end of list */ },
1291 MODULE_DEVICE_TABLE(of
, xemaclite_of_match
);
1293 static struct of_platform_driver xemaclite_of_driver
= {
1294 .name
= DRIVER_NAME
,
1295 .match_table
= xemaclite_of_match
,
1296 .probe
= xemaclite_of_probe
,
1297 .remove
= __devexit_p(xemaclite_of_remove
),
1301 * xgpiopss_init - Initial driver registration call
1303 * Return: 0 upon success, or a negative error upon failure.
1305 static int __init
xemaclite_init(void)
1307 /* No kernel boot options used, we just need to register the driver */
1308 return of_register_platform_driver(&xemaclite_of_driver
);
1312 * xemaclite_cleanup - Driver un-registration call
1314 static void __exit
xemaclite_cleanup(void)
1316 of_unregister_platform_driver(&xemaclite_of_driver
);
1319 module_init(xemaclite_init
);
1320 module_exit(xemaclite_cleanup
);
1322 MODULE_AUTHOR("Xilinx, Inc.");
1323 MODULE_DESCRIPTION("Xilinx Ethernet MAC Lite driver");
1324 MODULE_LICENSE("GPL");