net: xilinx_emacps: Obtain MAC Address from Device Tree if available
[projects/modsched/linux.git] / drivers / net / ethernet / xilinx / xilinx_emacps.c
1 /*
2  * Xilinx Ethernet: Linux driver for Ethernet.
3  *
4  * Author: Xilinx, Inc.
5  *
6  * 2010 (c) Xilinx, Inc. This file is licensed uner the terms of the GNU
7  * General Public License version 2. This program is licensed "as is"
8  * without any warranty of any kind, whether express or implied.
9  *
10  * This is a driver for xilinx processor sub-system (ps) ethernet device.
11  * This driver is mainly used in Linux 2.6.30 and above and it does _not_
12  * support Linux 2.4 kernel due to certain new features (e.g. NAPI) is
13  * introduced in this driver.
14  *
15  * TODO:
16  * 1. JUMBO frame is not enabled per EPs spec. Please update it if this
17  *    support is added in and set MAX_MTU to 9000.
18  * 2. For PEEP boards the Linux PHY driver state machine is not used. Hence
19  *    no autonegotiation happens for PEEP. The speed of 100 Mbps is used and
20  *    it is fixed. The speed cannot be changed to 10 Mbps or 1000 Mbps. However
21  *    for Zynq there is no such issue and it can work at all 3 speeds after
22  *    autonegotiation.
23  * 3. The SLCR clock divisors are hard coded for PEEP board.
24  */
25
26 #include <linux/module.h>
27 #include <linux/kernel.h>
28 #include <linux/init.h>
29 #include <linux/mm.h>
30 #include <linux/netdevice.h>
31 #include <linux/etherdevice.h>
32 #include <linux/platform_device.h>
33 #include <linux/phy.h>
34 #include <linux/mii.h>
35 #include <linux/delay.h>
36 #include <linux/dma-mapping.h>
37 #include <linux/io.h>
38 #include <linux/ethtool.h>
39 #include <linux/vmalloc.h>
40 #include <linux/version.h>
41 #include <linux/of.h>
42 #include <mach/slcr.h>
43 #include <linux/interrupt.h>
44 #include <linux/clocksource.h>
45 #include <linux/timecompare.h>
46 #include <linux/net_tstamp.h>
47 #include <linux/pm_runtime.h>
48 #include <linux/clk.h>
49 #include <linux/of_net.h>
50 #include <linux/of_address.h>
51 #include <linux/of_mdio.h>
52
53 /************************** Constant Definitions *****************************/
54
55 /* Must be shorter than length of ethtool_drvinfo.driver field to fit */
56 #define DRIVER_NAME                     "xemacps"
57 #define DRIVER_DESCRIPTION              "Xilinx Tri-Mode Ethernet MAC driver"
58 #define DRIVER_VERSION                  "1.00a"
59
60 /* Transmission timeout is 3 seconds. */
61 #define TX_TIMEOUT                      (3*HZ)
62
63 /* for RX skb IP header word-aligned */
64 #define RX_IP_ALIGN_OFFSET              2
65
66 /* DMA buffer descriptors must be aligned on a 4-byte boundary. */
67 #define ALIGNMENT_BD                    8
68
69 /* Maximum value for hash bits. 2**6 */
70 #define XEMACPS_MAX_HASH_BITS           64
71
72 /* MDC clock division
73  * currently supporting 8, 16, 32, 48, 64, 96, 128, 224.
74  */
75 enum { MDC_DIV_8 = 0, MDC_DIV_16, MDC_DIV_32, MDC_DIV_48,
76 MDC_DIV_64, MDC_DIV_96, MDC_DIV_128, MDC_DIV_224 };
77
78 /* Specify the receive buffer size in bytes, 64, 128, 192, 10240 */
79 #define XEMACPS_RX_BUF_SIZE             1600
80
81 /* Number of receive buffer bytes as a unit, this is HW setup */
82 #define XEMACPS_RX_BUF_UNIT             64
83
84 /* Default SEND and RECV buffer descriptors (BD) numbers.
85  * BD Space needed is (XEMACPS_SEND_BD_CNT+XEMACPS_RECV_BD_CNT)*8
86  */
87 #undef  DEBUG
88 #define DEBUG
89
90 #define XEMACPS_SEND_BD_CNT             32
91 #define XEMACPS_RECV_BD_CNT             32
92
93 #define XEMACPS_NAPI_WEIGHT             64
94
95 /* Register offset definitions. Unless otherwise noted, register access is
96  * 32 bit. Names are self explained here.
97  */
98 #define XEMACPS_NWCTRL_OFFSET           0x00000000 /* Network Control reg */
99 #define XEMACPS_NWCFG_OFFSET            0x00000004 /* Network Config reg */
100 #define XEMACPS_NWSR_OFFSET             0x00000008 /* Network Status reg */
101 #define XEMACPS_USERIO_OFFSET           0x0000000C /* User IO reg */
102 #define XEMACPS_DMACR_OFFSET            0x00000010 /* DMA Control reg */
103 #define XEMACPS_TXSR_OFFSET             0x00000014 /* TX Status reg */
104 #define XEMACPS_RXQBASE_OFFSET          0x00000018 /* RX Q Base address reg */
105 #define XEMACPS_TXQBASE_OFFSET          0x0000001C /* TX Q Base address reg */
106 #define XEMACPS_RXSR_OFFSET             0x00000020 /* RX Status reg */
107 #define XEMACPS_ISR_OFFSET              0x00000024 /* Interrupt Status reg */
108 #define XEMACPS_IER_OFFSET              0x00000028 /* Interrupt Enable reg */
109 #define XEMACPS_IDR_OFFSET              0x0000002C /* Interrupt Disable reg */
110 #define XEMACPS_IMR_OFFSET              0x00000030 /* Interrupt Mask reg */
111 #define XEMACPS_PHYMNTNC_OFFSET         0x00000034 /* Phy Maintaince reg */
112 #define XEMACPS_RXPAUSE_OFFSET          0x00000038 /* RX Pause Time reg */
113 #define XEMACPS_TXPAUSE_OFFSET          0x0000003C /* TX Pause Time reg */
114 #define XEMACPS_HASHL_OFFSET            0x00000080 /* Hash Low address reg */
115 #define XEMACPS_HASHH_OFFSET            0x00000084 /* Hash High address reg */
116 #define XEMACPS_LADDR1L_OFFSET          0x00000088 /* Specific1 addr low */
117 #define XEMACPS_LADDR1H_OFFSET          0x0000008C /* Specific1 addr high */
118 #define XEMACPS_LADDR2L_OFFSET          0x00000090 /* Specific2 addr low */
119 #define XEMACPS_LADDR2H_OFFSET          0x00000094 /* Specific2 addr high */
120 #define XEMACPS_LADDR3L_OFFSET          0x00000098 /* Specific3 addr low */
121 #define XEMACPS_LADDR3H_OFFSET          0x0000009C /* Specific3 addr high */
122 #define XEMACPS_LADDR4L_OFFSET          0x000000A0 /* Specific4 addr low */
123 #define XEMACPS_LADDR4H_OFFSET          0x000000A4 /* Specific4 addr high */
124 #define XEMACPS_MATCH1_OFFSET           0x000000A8 /* Type ID1 Match reg */
125 #define XEMACPS_MATCH2_OFFSET           0x000000AC /* Type ID2 Match reg */
126 #define XEMACPS_MATCH3_OFFSET           0x000000B0 /* Type ID3 Match reg */
127 #define XEMACPS_MATCH4_OFFSET           0x000000B4 /* Type ID4 Match reg */
128 #define XEMACPS_WOL_OFFSET              0x000000B8 /* Wake on LAN reg */
129 #define XEMACPS_STRETCH_OFFSET          0x000000BC /* IPG Stretch reg */
130 #define XEMACPS_SVLAN_OFFSET            0x000000C0 /* Stacked VLAN reg */
131 #define XEMACPS_MODID_OFFSET            0x000000FC /* Module ID reg */
132 #define XEMACPS_OCTTXL_OFFSET           0x00000100 /* Octects transmitted Low
133                                                 reg */
134 #define XEMACPS_OCTTXH_OFFSET           0x00000104 /* Octects transmitted High
135                                                 reg */
136 #define XEMACPS_TXCNT_OFFSET            0x00000108 /* Error-free Frmaes
137                                                 transmitted counter */
138 #define XEMACPS_TXBCCNT_OFFSET          0x0000010C /* Error-free Broadcast
139                                                 Frames counter*/
140 #define XEMACPS_TXMCCNT_OFFSET          0x00000110 /* Error-free Multicast
141                                                 Frame counter */
142 #define XEMACPS_TXPAUSECNT_OFFSET       0x00000114 /* Pause Frames Transmitted
143                                                 Counter */
144 #define XEMACPS_TX64CNT_OFFSET          0x00000118 /* Error-free 64 byte Frames
145                                                 Transmitted counter */
146 #define XEMACPS_TX65CNT_OFFSET          0x0000011C /* Error-free 65-127 byte
147                                                 Frames Transmitted counter */
148 #define XEMACPS_TX128CNT_OFFSET         0x00000120 /* Error-free 128-255 byte
149                                                 Frames Transmitted counter */
150 #define XEMACPS_TX256CNT_OFFSET         0x00000124 /* Error-free 256-511 byte
151                                                 Frames transmitted counter */
152 #define XEMACPS_TX512CNT_OFFSET         0x00000128 /* Error-free 512-1023 byte
153                                                 Frames transmitted counter */
154 #define XEMACPS_TX1024CNT_OFFSET        0x0000012C /* Error-free 1024-1518 byte
155                                                 Frames transmitted counter */
156 #define XEMACPS_TX1519CNT_OFFSET        0x00000130 /* Error-free larger than
157                                                 1519 byte Frames transmitted
158                                                 Counter */
159 #define XEMACPS_TXURUNCNT_OFFSET        0x00000134 /* TX under run error
160                                                 Counter */
161 #define XEMACPS_SNGLCOLLCNT_OFFSET      0x00000138 /* Single Collision Frame
162                                                 Counter */
163 #define XEMACPS_MULTICOLLCNT_OFFSET     0x0000013C /* Multiple Collision Frame
164                                                 Counter */
165 #define XEMACPS_EXCESSCOLLCNT_OFFSET    0x00000140 /* Excessive Collision Frame
166                                                 Counter */
167 #define XEMACPS_LATECOLLCNT_OFFSET      0x00000144 /* Late Collision Frame
168                                                 Counter */
169 #define XEMACPS_TXDEFERCNT_OFFSET       0x00000148 /* Deferred Transmission
170                                                 Frame Counter */
171 #define XEMACPS_CSENSECNT_OFFSET        0x0000014C /* Carrier Sense Error
172                                                 Counter */
173 #define XEMACPS_OCTRXL_OFFSET           0x00000150 /* Octects Received register
174                                                 Low */
175 #define XEMACPS_OCTRXH_OFFSET           0x00000154 /* Octects Received register
176                                                 High */
177 #define XEMACPS_RXCNT_OFFSET            0x00000158 /* Error-free Frames
178                                                 Received Counter */
179 #define XEMACPS_RXBROADCNT_OFFSET       0x0000015C /* Error-free Broadcast
180                                                 Frames Received Counter */
181 #define XEMACPS_RXMULTICNT_OFFSET       0x00000160 /* Error-free Multicast
182                                                 Frames Received Counter */
183 #define XEMACPS_RXPAUSECNT_OFFSET       0x00000164 /* Pause Frames
184                                                 Received Counter */
185 #define XEMACPS_RX64CNT_OFFSET          0x00000168 /* Error-free 64 byte Frames
186                                                 Received Counter */
187 #define XEMACPS_RX65CNT_OFFSET          0x0000016C /* Error-free 65-127 byte
188                                                 Frames Received Counter */
189 #define XEMACPS_RX128CNT_OFFSET         0x00000170 /* Error-free 128-255 byte
190                                                 Frames Received Counter */
191 #define XEMACPS_RX256CNT_OFFSET         0x00000174 /* Error-free 256-512 byte
192                                                 Frames Received Counter */
193 #define XEMACPS_RX512CNT_OFFSET         0x00000178 /* Error-free 512-1023 byte
194                                                 Frames Received Counter */
195 #define XEMACPS_RX1024CNT_OFFSET        0x0000017C /* Error-free 1024-1518 byte
196                                                 Frames Received Counter */
197 #define XEMACPS_RX1519CNT_OFFSET        0x00000180 /* Error-free 1519-max byte
198                                                 Frames Received Counter */
199 #define XEMACPS_RXUNDRCNT_OFFSET        0x00000184 /* Undersize Frames Received
200                                                 Counter */
201 #define XEMACPS_RXOVRCNT_OFFSET         0x00000188 /* Oversize Frames Received
202                                                 Counter */
203 #define XEMACPS_RXJABCNT_OFFSET         0x0000018C /* Jabbers Received
204                                                 Counter */
205 #define XEMACPS_RXFCSCNT_OFFSET         0x00000190 /* Frame Check Sequence
206                                                 Error Counter */
207 #define XEMACPS_RXLENGTHCNT_OFFSET      0x00000194 /* Length Field Error
208                                                 Counter */
209 #define XEMACPS_RXSYMBCNT_OFFSET        0x00000198 /* Symbol Error Counter */
210 #define XEMACPS_RXALIGNCNT_OFFSET       0x0000019C /* Alignment Error
211                                                 Counter */
212 #define XEMACPS_RXRESERRCNT_OFFSET      0x000001A0 /* Receive Resource Error
213                                                 Counter */
214 #define XEMACPS_RXORCNT_OFFSET          0x000001A4 /* Receive Overrun */
215 #define XEMACPS_RXIPCCNT_OFFSET         0x000001A8 /* IP header Checksum Error
216                                                 Counter */
217 #define XEMACPS_RXTCPCCNT_OFFSET        0x000001AC /* TCP Checksum Error
218                                                 Counter */
219 #define XEMACPS_RXUDPCCNT_OFFSET        0x000001B0 /* UDP Checksum Error
220                                                 Counter */
221
222 #define XEMACPS_1588S_OFFSET            0x000001D0 /* 1588 Timer Seconds */
223 #define XEMACPS_1588NS_OFFSET           0x000001D4 /* 1588 Timer Nanoseconds */
224 #define XEMACPS_1588ADJ_OFFSET          0x000001D8 /* 1588 Timer Adjust */
225 #define XEMACPS_1588INC_OFFSET          0x000001DC /* 1588 Timer Increment */
226 #define XEMACPS_PTPETXS_OFFSET          0x000001E0 /* PTP Event Frame
227                                                 Transmitted Seconds */
228 #define XEMACPS_PTPETXNS_OFFSET         0x000001E4 /* PTP Event Frame
229                                                 Transmitted Nanoseconds */
230 #define XEMACPS_PTPERXS_OFFSET          0x000001E8 /* PTP Event Frame Received
231                                                 Seconds */
232 #define XEMACPS_PTPERXNS_OFFSET         0x000001EC /* PTP Event Frame Received
233                                                 Nanoseconds */
234 #define XEMACPS_PTPPTXS_OFFSET          0x000001E0 /* PTP Peer Frame
235                                                 Transmitted Seconds */
236 #define XEMACPS_PTPPTXNS_OFFSET         0x000001E4 /* PTP Peer Frame
237                                                 Transmitted Nanoseconds */
238 #define XEMACPS_PTPPRXS_OFFSET          0x000001E8 /* PTP Peer Frame Received
239                                                 Seconds */
240 #define XEMACPS_PTPPRXNS_OFFSET         0x000001EC /* PTP Peer Frame Received
241                                                 Nanoseconds */
242
243 /* network control register bit definitions */
244 #define XEMACPS_NWCTRL_RXTSTAMP_MASK    0x00008000 /* RX Timestamp in CRC */
245 #define XEMACPS_NWCTRL_ZEROPAUSETX_MASK 0x00001000 /* Transmit zero quantum
246                                                 pause frame */
247 #define XEMACPS_NWCTRL_PAUSETX_MASK     0x00000800 /* Transmit pause frame */
248 #define XEMACPS_NWCTRL_HALTTX_MASK      0x00000400 /* Halt transmission
249                                                 after current frame */
250 #define XEMACPS_NWCTRL_STARTTX_MASK     0x00000200 /* Start tx (tx_go) */
251
252 #define XEMACPS_NWCTRL_STATWEN_MASK     0x00000080 /* Enable writing to
253                                                 stat counters */
254 #define XEMACPS_NWCTRL_STATINC_MASK     0x00000040 /* Increment statistic
255                                                 registers */
256 #define XEMACPS_NWCTRL_STATCLR_MASK     0x00000020 /* Clear statistic
257                                                 registers */
258 #define XEMACPS_NWCTRL_MDEN_MASK        0x00000010 /* Enable MDIO port */
259 #define XEMACPS_NWCTRL_TXEN_MASK        0x00000008 /* Enable transmit */
260 #define XEMACPS_NWCTRL_RXEN_MASK        0x00000004 /* Enable receive */
261 #define XEMACPS_NWCTRL_LOOPEN_MASK      0x00000002 /* local loopback */
262
263 /* name network configuration register bit definitions */
264 #define XEMACPS_NWCFG_BADPREAMBEN_MASK  0x20000000 /* disable rejection of
265                                                 non-standard preamble */
266 #define XEMACPS_NWCFG_IPDSTRETCH_MASK   0x10000000 /* enable transmit IPG */
267 #define XEMACPS_NWCFG_FCSIGNORE_MASK    0x04000000 /* disable rejection of
268                                                 FCS error */
269 #define XEMACPS_NWCFG_HDRXEN_MASK       0x02000000 /* RX half duplex */
270 #define XEMACPS_NWCFG_RXCHKSUMEN_MASK   0x01000000 /* enable RX checksum
271                                                 offload */
272 #define XEMACPS_NWCFG_PAUSECOPYDI_MASK  0x00800000 /* Do not copy pause
273                                                 Frames to memory */
274 #define XEMACPS_NWCFG_MDC_SHIFT_MASK    18 /* shift bits for MDC */
275 #define XEMACPS_NWCFG_MDCCLKDIV_MASK    0x001C0000 /* MDC Mask PCLK divisor */
276 #define XEMACPS_NWCFG_FCSREM_MASK       0x00020000 /* Discard FCS from
277                                                 received frames */
278 #define XEMACPS_NWCFG_LENGTHERRDSCRD_MASK 0x00010000
279 /* RX length error discard */
280 #define XEMACPS_NWCFG_RXOFFS_MASK       0x0000C000 /* RX buffer offset */
281 #define XEMACPS_NWCFG_PAUSEEN_MASK      0x00002000 /* Enable pause TX */
282 #define XEMACPS_NWCFG_RETRYTESTEN_MASK  0x00001000 /* Retry test */
283 #define XEMACPS_NWCFG_1000_MASK         0x00000400 /* Gigbit mode */
284 #define XEMACPS_NWCFG_EXTADDRMATCHEN_MASK       0x00000200
285 /* External address match enable */
286 #define XEMACPS_NWCFG_UCASTHASHEN_MASK  0x00000080 /* Receive unicast hash
287                                                 frames */
288 #define XEMACPS_NWCFG_MCASTHASHEN_MASK  0x00000040 /* Receive multicast hash
289                                                 frames */
290 #define XEMACPS_NWCFG_BCASTDI_MASK      0x00000020 /* Do not receive
291                                                 broadcast frames */
292 #define XEMACPS_NWCFG_COPYALLEN_MASK    0x00000010 /* Copy all frames */
293
294 #define XEMACPS_NWCFG_NVLANDISC_MASK    0x00000004 /* Receive only VLAN
295                                                 frames */
296 #define XEMACPS_NWCFG_FDEN_MASK         0x00000002 /* Full duplex */
297 #define XEMACPS_NWCFG_100_MASK          0x00000001 /* 10 or 100 Mbs */
298
299 /* network status register bit definitaions */
300 #define XEMACPS_NWSR_MDIOIDLE_MASK      0x00000004 /* PHY management idle */
301 #define XEMACPS_NWSR_MDIO_MASK          0x00000002 /* Status of mdio_in */
302
303 /* MAC address register word 1 mask */
304 #define XEMACPS_LADDR_MACH_MASK         0x0000FFFF /* Address bits[47:32]
305                                                 bit[31:0] are in BOTTOM */
306
307 /* DMA control register bit definitions */
308 #define XEMACPS_DMACR_RXBUF_MASK        0x00FF0000 /* Mask bit for RX buffer
309                                                 size */
310 #define XEMACPS_DMACR_RXBUF_SHIFT       16 /* Shift bit for RX buffer
311                                                 size */
312 #define XEMACPS_DMACR_TCPCKSUM_MASK     0x00000800 /* enable/disable TX
313                                                 checksum offload */
314 #define XEMACPS_DMACR_TXSIZE_MASK       0x00000400 /* TX buffer memory size */
315 #define XEMACPS_DMACR_RXSIZE_MASK       0x00000300 /* RX buffer memory size */
316 #define XEMACPS_DMACR_ENDIAN_MASK       0x00000080 /* Endian configuration */
317 #define XEMACPS_DMACR_BLENGTH_MASK      0x0000001F /* Buffer burst length */
318 #define XEMACPS_DMACR_BLENGTH_INCR16    0x00000010 /* Buffer burst length */
319 #define XEMACPS_DMACR_BLENGTH_INCR8     0x00000008 /* Buffer burst length */
320 #define XEMACPS_DMACR_BLENGTH_INCR4     0x00000004 /* Buffer burst length */
321 #define XEMACPS_DMACR_BLENGTH_SINGLE    0x00000002 /* Buffer burst length */
322
323 /* transmit status register bit definitions */
324 #define XEMACPS_TXSR_HRESPNOK_MASK      0x00000100 /* Transmit hresp not OK */
325 #define XEMACPS_TXSR_COL1000_MASK       0x00000080 /* Collision Gbs mode */
326 #define XEMACPS_TXSR_URUN_MASK          0x00000040 /* Transmit underrun */
327 #define XEMACPS_TXSR_TXCOMPL_MASK       0x00000020 /* Transmit completed OK */
328 #define XEMACPS_TXSR_BUFEXH_MASK        0x00000010 /* Transmit buffs exhausted
329                                                 mid frame */
330 #define XEMACPS_TXSR_TXGO_MASK          0x00000008 /* Status of go flag */
331 #define XEMACPS_TXSR_RXOVR_MASK         0x00000004 /* Retry limit exceeded */
332 #define XEMACPS_TXSR_COL100_MASK        0x00000002 /* Collision 10/100  mode */
333 #define XEMACPS_TXSR_USEDREAD_MASK      0x00000001 /* TX buffer used bit set */
334
335 #define XEMACPS_TXSR_ERROR_MASK (XEMACPS_TXSR_HRESPNOK_MASK |           \
336                                         XEMACPS_TXSR_COL1000_MASK |     \
337                                         XEMACPS_TXSR_URUN_MASK |        \
338                                         XEMACPS_TXSR_BUFEXH_MASK |      \
339                                         XEMACPS_TXSR_RXOVR_MASK |       \
340                                         XEMACPS_TXSR_COL100_MASK |      \
341                                         XEMACPS_TXSR_USEDREAD_MASK)
342
343 /* receive status register bit definitions */
344 #define XEMACPS_RXSR_HRESPNOK_MASK      0x00000008 /* Receive hresp not OK */
345 #define XEMACPS_RXSR_RXOVR_MASK         0x00000004 /* Receive overrun */
346 #define XEMACPS_RXSR_FRAMERX_MASK       0x00000002 /* Frame received OK */
347 #define XEMACPS_RXSR_BUFFNA_MASK        0x00000001 /* RX buffer used bit set */
348
349 #define XEMACPS_RXSR_ERROR_MASK (XEMACPS_RXSR_HRESPNOK_MASK | \
350                                         XEMACPS_RXSR_RXOVR_MASK | \
351                                         XEMACPS_RXSR_BUFFNA_MASK)
352
353 /* interrupts bit definitions
354  * Bits definitions are same in XEMACPS_ISR_OFFSET,
355  * XEMACPS_IER_OFFSET, XEMACPS_IDR_OFFSET, and XEMACPS_IMR_OFFSET
356  */
357 #define XEMACPS_IXR_PTPPSTX_MASK        0x02000000 /* PTP Psync transmitted */
358 #define XEMACPS_IXR_PTPPDRTX_MASK       0x01000000 /* PTP Pdelay_req
359                                                         transmitted */
360 #define XEMACPS_IXR_PTPSTX_MASK         0x00800000 /* PTP Sync transmitted */
361 #define XEMACPS_IXR_PTPDRTX_MASK        0x00400000 /* PTP Delay_req
362                                                         transmitted */
363 #define XEMACPS_IXR_PTPPSRX_MASK        0x00200000 /* PTP Psync received */
364 #define XEMACPS_IXR_PTPPDRRX_MASK       0x00100000 /* PTP Pdelay_req
365                                                         received */
366 #define XEMACPS_IXR_PTPSRX_MASK         0x00080000 /* PTP Sync received */
367 #define XEMACPS_IXR_PTPDRRX_MASK        0x00040000 /* PTP Delay_req received */
368 #define XEMACPS_IXR_PAUSETX_MASK        0x00004000 /* Pause frame
369                                                         transmitted */
370 #define XEMACPS_IXR_PAUSEZERO_MASK      0x00002000 /* Pause time has reached
371                                                         zero */
372 #define XEMACPS_IXR_PAUSENZERO_MASK     0x00001000 /* Pause frame received */
373 #define XEMACPS_IXR_HRESPNOK_MASK       0x00000800 /* hresp not ok */
374 #define XEMACPS_IXR_RXOVR_MASK          0x00000400 /* Receive overrun
375                                                         occurred */
376 #define XEMACPS_IXR_TXCOMPL_MASK        0x00000080 /* Frame transmitted ok */
377 #define XEMACPS_IXR_TXEXH_MASK          0x00000040 /* Transmit err occurred or
378                                                         no buffers*/
379 #define XEMACPS_IXR_RETRY_MASK          0x00000020 /* Retry limit exceeded */
380 #define XEMACPS_IXR_URUN_MASK           0x00000010 /* Transmit underrun */
381 #define XEMACPS_IXR_TXUSED_MASK         0x00000008 /* Tx buffer used bit read */
382 #define XEMACPS_IXR_RXUSED_MASK         0x00000004 /* Rx buffer used bit read */
383 #define XEMACPS_IXR_FRAMERX_MASK        0x00000002 /* Frame received ok */
384 #define XEMACPS_IXR_MGMNT_MASK          0x00000001 /* PHY management complete */
385 #define XEMACPS_IXR_ALL_MASK            0x03FC7FFF /* Everything! */
386
387 #define XEMACPS_IXR_TX_ERR_MASK (XEMACPS_IXR_TXEXH_MASK |               \
388                                         XEMACPS_IXR_RETRY_MASK |        \
389                                         XEMACPS_IXR_URUN_MASK |         \
390                                         XEMACPS_IXR_TXUSED_MASK)
391
392 #define XEMACPS_IXR_RX_ERR_MASK (XEMACPS_IXR_HRESPNOK_MASK |            \
393                                         XEMACPS_IXR_RXUSED_MASK |       \
394                                         XEMACPS_IXR_RXOVR_MASK)
395 /* PHY Maintenance bit definitions */
396 #define XEMACPS_PHYMNTNC_OP_MASK        0x40020000 /* operation mask bits */
397 #define XEMACPS_PHYMNTNC_OP_R_MASK      0x20000000 /* read operation */
398 #define XEMACPS_PHYMNTNC_OP_W_MASK      0x10000000 /* write operation */
399 #define XEMACPS_PHYMNTNC_ADDR_MASK      0x0F800000 /* Address bits */
400 #define XEMACPS_PHYMNTNC_REG_MASK       0x007C0000 /* register bits */
401 #define XEMACPS_PHYMNTNC_DATA_MASK      0x0000FFFF /* data bits */
402 #define XEMACPS_PHYMNTNC_PHYAD_SHIFT_MASK       23 /* Shift bits for PHYAD */
403 #define XEMACPS_PHYMNTNC_PHREG_SHIFT_MASK       18 /* Shift bits for PHREG */
404
405 /* Wake on LAN bit definition */
406 #define XEMACPS_WOL_MCAST_MASK          0x00080000
407 #define XEMACPS_WOL_SPEREG1_MASK        0x00040000
408 #define XEMACPS_WOL_ARP_MASK            0x00020000
409 #define XEMACPS_WOL_MAGIC_MASK          0x00010000
410 #define XEMACPS_WOL_ARP_ADDR_MASK       0x0000FFFF
411
412 /* Buffer descriptor status words offset */
413 #define XEMACPS_BD_ADDR_OFFSET          0x00000000 /**< word 0/addr of BDs */
414 #define XEMACPS_BD_STAT_OFFSET          0x00000004 /**< word 1/status of BDs */
415
416 /* Transmit buffer descriptor status words bit positions.
417  * Transmit buffer descriptor consists of two 32-bit registers,
418  * the first - word0 contains a 32-bit address pointing to the location of
419  * the transmit data.
420  * The following register - word1, consists of various information to
421  * control transmit process.  After transmit, this is updated with status
422  * information, whether the frame was transmitted OK or why it had failed.
423  */
424 #define XEMACPS_TXBUF_USED_MASK         0x80000000 /* Used bit. */
425 #define XEMACPS_TXBUF_WRAP_MASK         0x40000000 /* Wrap bit, last
426                                                         descriptor */
427 #define XEMACPS_TXBUF_RETRY_MASK        0x20000000 /* Retry limit exceeded */
428 #define XEMACPS_TXBUF_EXH_MASK          0x08000000 /* Buffers exhausted */
429 #define XEMACPS_TXBUF_LAC_MASK          0x04000000 /* Late collision. */
430 #define XEMACPS_TXBUF_NOCRC_MASK        0x00010000 /* No CRC */
431 #define XEMACPS_TXBUF_LAST_MASK         0x00008000 /* Last buffer */
432 #define XEMACPS_TXBUF_LEN_MASK          0x00003FFF /* Mask for length field */
433
434 #define XEMACPS_TXBUF_ERR_MASK          0x3C000000 /* Mask for length field */
435
436 /* Receive buffer descriptor status words bit positions.
437  * Receive buffer descriptor consists of two 32-bit registers,
438  * the first - word0 contains a 32-bit word aligned address pointing to the
439  * address of the buffer. The lower two bits make up the wrap bit indicating
440  * the last descriptor and the ownership bit to indicate it has been used.
441  * The following register - word1, contains status information regarding why
442  * the frame was received (the filter match condition) as well as other
443  * useful info.
444  */
445 #define XEMACPS_RXBUF_BCAST_MASK        0x80000000 /* Broadcast frame */
446 #define XEMACPS_RXBUF_MULTIHASH_MASK    0x40000000 /* Multicast hashed frame */
447 #define XEMACPS_RXBUF_UNIHASH_MASK      0x20000000 /* Unicast hashed frame */
448 #define XEMACPS_RXBUF_EXH_MASK          0x08000000 /* buffer exhausted */
449 #define XEMACPS_RXBUF_AMATCH_MASK       0x06000000 /* Specific address
450                                                 matched */
451 #define XEMACPS_RXBUF_IDFOUND_MASK      0x01000000 /* Type ID matched */
452 #define XEMACPS_RXBUF_IDMATCH_MASK      0x00C00000 /* ID matched mask */
453 #define XEMACPS_RXBUF_VLAN_MASK         0x00200000 /* VLAN tagged */
454 #define XEMACPS_RXBUF_PRI_MASK          0x00100000 /* Priority tagged */
455 #define XEMACPS_RXBUF_VPRI_MASK         0x000E0000 /* Vlan priority */
456 #define XEMACPS_RXBUF_CFI_MASK          0x00010000 /* CFI frame */
457 #define XEMACPS_RXBUF_EOF_MASK          0x00008000 /* End of frame. */
458 #define XEMACPS_RXBUF_SOF_MASK          0x00004000 /* Start of frame. */
459 #define XEMACPS_RXBUF_LEN_MASK          0x00003FFF /* Mask for length field */
460
461 #define XEMACPS_RXBUF_WRAP_MASK         0x00000002 /* Wrap bit, last BD */
462 #define XEMACPS_RXBUF_NEW_MASK          0x00000001 /* Used bit.. */
463 #define XEMACPS_RXBUF_ADD_MASK          0xFFFFFFFC /* Mask for address */
464
465
466 #define XSLCR_EMAC0_CLK_CTRL_OFFSET     0x140 /* EMAC0 Reference Clk Control */
467 #define XSLCR_EMAC1_CLK_CTRL_OFFSET     0x144 /* EMAC1 Reference Clk Control */
468 #define BOARD_TYPE_ZYNQ                 0x01
469 #define BOARD_TYPE_PEEP                 0x02
470
471 #define XEMACPS_DFLT_SLCR_DIV0_1000     8
472 #define XEMACPS_DFLT_SLCR_DIV1_1000     1
473 #define XEMACPS_DFLT_SLCR_DIV0_100      8
474 #define XEMACPS_DFLT_SLCR_DIV1_100      5
475 #define XEMACPS_DFLT_SLCR_DIV0_10       8
476 #define XEMACPS_DFLT_SLCR_DIV1_10       50
477 #define XEMACPS_SLCR_DIV_MASK           0xFC0FC0FF
478
479 #ifdef CONFIG_XILINX_PS_EMAC_HWTSTAMP
480 #define NS_PER_SEC                      1000000000ULL /* Nanoseconds per
481                                                         second */
482 #define PEEP_TSU_CLK                    50000000ULL /* PTP TSU CLOCK */
483 #endif
484
485 #define xemacps_read(base, reg)                                         \
486         __raw_readl((u32)(base) + (u32)(reg))
487 #define xemacps_write(base, reg, val)                                   \
488         __raw_writel((val), (u32)(base) + (u32)(reg))
489
490 #define XEMACPS_RING_SEEKAHEAD(ringptr, bdptr, numbd)                   \
491 {                                                                       \
492         u32 addr = (u32)bdptr;                                          \
493         addr += ((ringptr)->separation * numbd);                        \
494         if ((addr > (ringptr)->lastbdaddr) || ((u32)bdptr > addr)) {    \
495                 addr -= (ringptr)->length;                              \
496         }                                                               \
497         bdptr = (struct xemacps_bd *)addr;                              \
498 }
499
500 #define XEMACPS_RING_SEEKBACK(ringptr, bdptr, numbd)                    \
501 {                                                                       \
502         u32 addr = (u32)bdptr;                                          \
503         addr -= ((ringptr)->separation * numbd);                        \
504         if ((addr < (ringptr)->firstbdaddr) || ((u32)bdptr < addr)) {   \
505                 addr += (ringptr)->length;                              \
506         }                                                               \
507         bdptr = (struct xemacps_bd *)addr;                              \
508 }
509
510 #define XEMACPS_BDRING_NEXT(ringptr, bdptr)                             \
511         (((u32)(bdptr) >= (ringptr)->lastbdaddr) ?                      \
512         (struct xemacps_bd *)(ringptr)->firstbdaddr :                   \
513         (struct xemacps_bd *)((u32)(bdptr) + (ringptr)->separation))
514
515 #define XEMACPS_BDRING_PREV(ringptr, bdptr)                             \
516         (((u32)(bdptr) <= (ringptr)->firstbdaddr) ?                     \
517         (struct xemacps_bd *)(ringptr)->lastbdaddr :                    \
518         (struct xemacps_bd *)((u32)(bdptr) - (ringptr)->separation))
519
520 #define XEMACPS_SET_BUFADDR_RX(bdptr, addr)                             \
521         xemacps_write((bdptr), XEMACPS_BD_ADDR_OFFSET,          \
522         ((xemacps_read((bdptr), XEMACPS_BD_ADDR_OFFSET) &               \
523         ~XEMACPS_RXBUF_ADD_MASK) | (u32)(addr)))
524
525 #define XEMACPS_BD_TO_INDEX(ringptr, bdptr)                             \
526         (((u32)bdptr - (u32)(ringptr)->firstbdaddr) / (ringptr)->separation)
527
528 struct ring_info {
529         struct sk_buff *skb;
530         dma_addr_t mapping;
531 };
532
533 /* DMA buffer descriptor structure. Each BD is two words */
534 struct xemacps_bd {
535         u32 addr;
536         u32 ctrl;
537 };
538
539 /* This is an internal structure used to maintain the DMA list */
540 struct xemacps_bdring {
541         u32 physbaseaddr; /* Physical address of 1st BD in list */
542         u32 firstbdaddr; /* Virtual address of 1st BD in list */
543         u32 lastbdaddr; /* Virtual address of last BD in the list */
544         u32 length; /* size of ring in bytes */
545         u32 separation; /* Number of bytes between the starting
546                                 address of adjacent BDs */
547         struct xemacps_bd *freehead; /* First BD in the free group */
548         struct xemacps_bd *prehead; /* First BD in the pre-work group */
549         struct xemacps_bd *hwhead; /* First BD in the work group */
550         struct xemacps_bd *hwtail; /* Last BD in the work group */
551         struct xemacps_bd *posthead; /* First BD in the post-work group */
552         unsigned freecnt; /* Number of BDs in the free group */
553         unsigned hwcnt; /* Number of BDs in work group */
554         unsigned precnt; /* Number of BDs in pre-work group */
555         unsigned postcnt; /* Number of BDs in post-work group */
556         unsigned allcnt; /* Total Number of BDs for channel */
557
558         int is_rx; /* Is this an RX or a TX ring? */
559 };
560
561 /* Our private device data. */
562 struct net_local {
563         void __iomem *baseaddr;
564         struct clk *devclk;
565         struct clk *aperclk;
566         struct notifier_block clk_rate_change_nb;
567
568         struct xemacps_bdring tx_ring;
569         struct xemacps_bdring rx_ring;
570         struct device_node *phy_node;
571         struct ring_info *tx_skb;
572         struct ring_info *rx_skb;
573
574         void *rx_bd; /* virtual address */
575         void *tx_bd; /* virtual address */
576
577         dma_addr_t rx_bd_dma; /* physical address */
578         dma_addr_t tx_bd_dma; /* physical address */
579
580         spinlock_t lock;
581
582         struct platform_device *pdev;
583         struct net_device *ndev; /* this device */
584
585         struct napi_struct napi; /* napi information for device */
586         struct net_device_stats stats; /* Statistics for this device */
587
588         /* Manage internal timer for packet timestamping */
589         struct cyclecounter cycles;
590         struct timecounter clock;
591         struct timecompare compare;
592         struct hwtstamp_config hwtstamp_config;
593
594         struct mii_bus *mii_bus;
595         struct phy_device *phy_dev;
596         unsigned int link;
597         unsigned int speed;
598         unsigned int duplex;
599         /* RX ip/tcp/udp checksum */
600         unsigned ip_summed;
601         unsigned int enetnum;
602         unsigned int board_type;
603 #ifdef CONFIG_XILINX_PS_EMAC_HWTSTAMP
604         unsigned int ptpenetclk;
605 #endif
606 };
607 #define to_net_local(_nb)       container_of(_nb, struct net_local,\
608                 clk_rate_change_nb)
609
610 static struct net_device_ops netdev_ops;
611
612 /**
613  * xemacps_mdio_read - Read current value of phy register indicated by
614  * phyreg.
615  * @bus: mdio bus
616  * @mii_id: mii id
617  * @phyreg: phy register to be read
618  *
619  * @return: value read from specified phy register.
620  *
621  * note: This is for 802.3 clause 22 phys access. For 802.3 clause 45 phys
622  * access, set bit 30 to be 1. e.g. change XEMACPS_PHYMNTNC_OP_MASK to
623  * 0x00020000.
624  */
625 static int xemacps_mdio_read(struct mii_bus *bus, int mii_id, int phyreg)
626 {
627         struct net_local *lp = bus->priv;
628         u32 regval;
629         int value;
630         volatile u32 ipisr;
631
632         regval  = XEMACPS_PHYMNTNC_OP_MASK;
633         regval |= XEMACPS_PHYMNTNC_OP_R_MASK;
634         regval |= (mii_id << XEMACPS_PHYMNTNC_PHYAD_SHIFT_MASK);
635         regval |= (phyreg << XEMACPS_PHYMNTNC_PHREG_SHIFT_MASK);
636
637         xemacps_write(lp->baseaddr, XEMACPS_PHYMNTNC_OFFSET, regval);
638
639         /* wait for end of transfer */
640         do {
641                 cpu_relax();
642                 ipisr = xemacps_read(lp->baseaddr, XEMACPS_NWSR_OFFSET);
643         } while ((ipisr & XEMACPS_NWSR_MDIOIDLE_MASK) == 0);
644
645         value = xemacps_read(lp->baseaddr, XEMACPS_PHYMNTNC_OFFSET) &
646                         XEMACPS_PHYMNTNC_DATA_MASK;
647
648         return value;
649 }
650
651 /**
652  * xemacps_mdio_write - Write passed in value to phy register indicated
653  * by phyreg.
654  * @bus: mdio bus
655  * @mii_id: mii id
656  * @phyreg: phy register to be configured.
657  * @value: value to be written to phy register.
658  * return 0. This API requires to be int type or compile warning generated
659  *
660  * note: This is for 802.3 clause 22 phys access. For 802.3 clause 45 phys
661  * access, set bit 30 to be 1. e.g. change XEMACPS_PHYMNTNC_OP_MASK to
662  * 0x00020000.
663  */
664 static int xemacps_mdio_write(struct mii_bus *bus, int mii_id, int phyreg,
665         u16 value)
666 {
667         struct net_local *lp = bus->priv;
668         u32 regval;
669         volatile u32 ipisr;
670
671         regval  = XEMACPS_PHYMNTNC_OP_MASK;
672         regval |= XEMACPS_PHYMNTNC_OP_W_MASK;
673         regval |= (mii_id << XEMACPS_PHYMNTNC_PHYAD_SHIFT_MASK);
674         regval |= (phyreg << XEMACPS_PHYMNTNC_PHREG_SHIFT_MASK);
675         regval |= value;
676
677         xemacps_write(lp->baseaddr, XEMACPS_PHYMNTNC_OFFSET, regval);
678
679         /* wait for end of transfer */
680         do {
681                 cpu_relax();
682                 ipisr = xemacps_read(lp->baseaddr, XEMACPS_NWSR_OFFSET);
683         } while ((ipisr & XEMACPS_NWSR_MDIOIDLE_MASK) == 0);
684
685         return 0;
686 }
687
688
689 /**
690  * xemacps_mdio_reset - mdio reset. It seems to be required per open
691  * source documentation phy.txt. But there is no reset in this device.
692  * Provide function API for now.
693  * @bus: mdio bus
694  **/
695 static int xemacps_mdio_reset(struct mii_bus *bus)
696 {
697         return 0;
698 }
699
700 static void xemacps_phy_init(struct net_device *ndev)
701 {
702         struct net_local *lp = netdev_priv(ndev);
703         u16 regval;
704         int i = 0;
705
706         /* set RX delay */
707         regval = xemacps_mdio_read(lp->mii_bus, lp->phy_dev->addr, 20);
708         /* 0x0080 for 100Mbps, 0x0060 for 1Gbps. */
709         regval |= 0x0080;
710         xemacps_mdio_write(lp->mii_bus, lp->phy_dev->addr, 20, regval);
711
712         /* 0x2100 for 100Mbps, 0x0140 for 1Gbps. */
713         xemacps_mdio_write(lp->mii_bus, lp->phy_dev->addr, 0, 0x2100);
714
715         regval = xemacps_mdio_read(lp->mii_bus, lp->phy_dev->addr, 0);
716         regval |= 0x8000;
717         xemacps_mdio_write(lp->mii_bus, lp->phy_dev->addr, 0, regval);
718         for (i = 0; i < 10; i++)
719                 mdelay(500);
720 #ifdef DEBUG_VERBOSE
721         dev_dbg(&lp->pdev->dev,
722                         "phy register dump, start from 0, four in a row.");
723         for (i = 0; i <= 30; i++) {
724                 if (!(i%4))
725                         dev_dbg(&lp->pdev->dev, "\n %02d:  ", i);
726                 regval = xemacps_mdio_read(lp->mii_bus, lp->phy_dev->addr, i);
727                 dev_dbg(&lp->pdev->dev, " 0x%08x", regval);
728         }
729         dev_dbg(&lp->pdev->dev, "\n");
730 #endif
731 }
732
733
734 /**
735  * xemacps_adjust_link - handles link status changes, such as speed,
736  * duplex, up/down, ...
737  * @ndev: network device
738  */
739 static void xemacps_adjust_link(struct net_device *ndev)
740 {
741         struct net_local *lp = netdev_priv(ndev);
742         struct phy_device *phydev = lp->phy_dev;
743         unsigned long flags;
744         int status_change = 0;
745         u32 regval;
746         long rate;
747
748         spin_lock_irqsave(&lp->lock, flags);
749
750         if (phydev->link) {
751                 if ((lp->speed != phydev->speed) ||
752                         (lp->duplex != phydev->duplex)) {
753                         regval = xemacps_read(lp->baseaddr,
754                                 XEMACPS_NWCFG_OFFSET);
755                         if (phydev->duplex)
756                                 regval |= XEMACPS_NWCFG_FDEN_MASK;
757                         else
758                                 regval &= ~XEMACPS_NWCFG_FDEN_MASK;
759
760                         if (phydev->speed == SPEED_1000) {
761                                 regval |= XEMACPS_NWCFG_1000_MASK;
762                                 rate = clk_round_rate(lp->devclk, 125000000);
763                                 dev_info(&lp->pdev->dev, "Set clk to %ld Hz\n",
764                                                 rate);
765                                 if (clk_set_rate(lp->devclk, rate))
766                                         dev_err(&lp->pdev->dev,
767                                         "Setting new clock rate failed.\n");
768                         } else {
769                                 regval &= ~XEMACPS_NWCFG_1000_MASK;
770                         }
771
772                         if (phydev->speed == SPEED_100) {
773                                 regval |= XEMACPS_NWCFG_100_MASK;
774                                 rate = clk_round_rate(lp->devclk, 25000000);
775                                 dev_info(&lp->pdev->dev, "Set clk to %ld Hz\n",
776                                                 rate);
777                                 if (clk_set_rate(lp->devclk, rate))
778                                         dev_err(&lp->pdev->dev,
779                                         "Setting new clock rate failed.\n");
780                         } else {
781                                 regval &= ~XEMACPS_NWCFG_100_MASK;
782                         }
783
784                         if (phydev->speed == SPEED_10) {
785                                 rate = clk_round_rate(lp->devclk, 2500000);
786                                 dev_info(&lp->pdev->dev, "Set clk to %ld Hz\n",
787                                                 rate);
788                                 if (clk_set_rate(lp->devclk, rate))
789                                         dev_err(&lp->pdev->dev,
790                                         "Setting new clock rate failed.\n");
791                         }
792
793                         xemacps_write(lp->baseaddr, XEMACPS_NWCFG_OFFSET,
794                                 regval);
795
796                         lp->speed = phydev->speed;
797                         lp->duplex = phydev->duplex;
798                         status_change = 1;
799                 }
800         }
801
802         if (phydev->link != lp->link) {
803                 lp->link = phydev->link;
804                 status_change = 1;
805         }
806
807         spin_unlock_irqrestore(&lp->lock, flags);
808
809         if (status_change) {
810                 if (phydev->link)
811                         dev_info(&lp->pdev->dev, "link up (%d/%s)\n",
812                                 phydev->speed,
813                                 DUPLEX_FULL == phydev->duplex ?
814                                 "FULL" : "HALF");
815                 else
816                         dev_info(&lp->pdev->dev, "link down\n");
817         }
818 }
819
820 static int xemacps_clk_notifier_cb(struct notifier_block *nb, unsigned long
821                 event, void *data)
822 {
823 /*
824         struct clk_notifier_data *ndata = data;
825         struct net_local *nl = to_net_local(nb);
826 */
827
828         switch (event) {
829         case PRE_RATE_CHANGE:
830                 /* if a rate change is announced we need to check whether we can
831                  * maintain the current frequency by changing the clock
832                  * dividers.
833                  * I don't see how this can be done using the current fmwk!?
834                  * For now we always allow the rate change. Otherwise we would
835                  * even prevent ourself to change the rate.
836                  */
837                 return NOTIFY_OK;
838         case POST_RATE_CHANGE:
839                 /* not sure this will work. actually i'm sure it does not. this
840                  * callback is not allowed to call back into COMMON_CLK, what
841                  * adjust_link() does...*/
842                 /*xemacps_adjust_link(nl->ndev); would likely lock up kernel */
843                 return NOTIFY_OK;
844         case ABORT_RATE_CHANGE:
845         default:
846                 return NOTIFY_DONE;
847         }
848 }
849
850 /**
851  * xemacps_mii_probe - probe mii bus, find the right bus_id to register
852  * phy callback function.
853  * @ndev: network interface device structure
854  * return 0 on success, negative value if error
855  **/
856 static int xemacps_mii_probe(struct net_device *ndev)
857 {
858         struct net_local *lp = netdev_priv(ndev);
859         struct phy_device *phydev = NULL;
860
861         if (lp->phy_node) {
862                 phydev = of_phy_connect(lp->ndev,
863                                         lp->phy_node,
864                                         xemacps_adjust_link,
865                                         0,
866                                         PHY_INTERFACE_MODE_RGMII_ID);
867
868                 if (!phydev) {
869                         printk(KERN_ERR "%s: no PHY found\n", ndev->name);
870                         return -1;
871                 }
872         }
873         if (!phydev) {
874                 dev_err(&lp->pdev->dev, "%s: no PHY found\n", ndev->name);
875                 return -1;
876         }
877
878         dev_dbg(&lp->pdev->dev,
879                 "GEM: phydev %p, phydev->phy_id 0x%x, phydev->addr 0x%x\n",
880                 phydev, phydev->phy_id, phydev->addr);
881
882         phydev->supported &= (PHY_GBIT_FEATURES | SUPPORTED_Pause |
883                                                         SUPPORTED_Asym_Pause);
884         phydev->advertising = phydev->supported;
885
886         lp->link    = 0;
887         lp->speed   = 0;
888         lp->duplex  = -1;
889         lp->phy_dev = phydev;
890
891         if (lp->board_type == BOARD_TYPE_ZYNQ)
892                 phy_start(lp->phy_dev);
893         else
894                 xemacps_phy_init(lp->ndev);
895
896         dev_dbg(&lp->pdev->dev, "phy_addr 0x%x, phy_id 0x%08x\n",
897                         lp->phy_dev->addr, lp->phy_dev->phy_id);
898
899         dev_dbg(&lp->pdev->dev, "attach [%s] phy driver\n",
900                         lp->phy_dev->drv->name);
901
902         return 0;
903 }
904
905 /**
906  * xemacps_mii_init - Initialize and register mii bus to network device
907  * @lp: local device instance pointer
908  * return 0 on success, negative value if error
909  **/
910 static int xemacps_mii_init(struct net_local *lp)
911 {
912         int rc = -ENXIO, i;
913         struct resource res;
914         struct device_node *np = of_get_parent(lp->phy_node);
915         struct device_node *npp;
916
917         lp->mii_bus = mdiobus_alloc();
918         if (lp->mii_bus == NULL) {
919                 rc = -ENOMEM;
920                 goto err_out;
921         }
922
923         lp->mii_bus->name  = "XEMACPS mii bus";
924         lp->mii_bus->read  = &xemacps_mdio_read;
925         lp->mii_bus->write = &xemacps_mdio_write;
926         lp->mii_bus->reset = &xemacps_mdio_reset;
927         lp->mii_bus->priv = lp;
928         lp->mii_bus->parent = &lp->ndev->dev;
929
930         lp->mii_bus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL);
931         if (!lp->mii_bus->irq) {
932                 rc = -ENOMEM;
933                 goto err_out_free_mdiobus;
934         }
935
936         for (i = 0; i < PHY_MAX_ADDR; i++)
937                 lp->mii_bus->irq[i] = PHY_POLL;
938         npp = of_get_parent(np);
939         of_address_to_resource(npp, 0, &res);
940         snprintf(lp->mii_bus->id, MII_BUS_ID_SIZE, "%.8llx",
941                  (unsigned long long)res.start);
942         if (of_mdiobus_register(lp->mii_bus, np))
943                 goto err_out_free_mdio_irq;
944
945         return 0;
946
947 err_out_free_mdio_irq:
948         kfree(lp->mii_bus->irq);
949 err_out_free_mdiobus:
950         mdiobus_free(lp->mii_bus);
951 err_out:
952         return rc;
953 }
954
955 /**
956  * xemacps_update_hdaddr - Update device's MAC address when configured
957  * MAC address is not valid, reconfigure with a good one.
958  * @lp: local device instance pointer
959  **/
960 static void __devinit xemacps_update_hwaddr(struct net_local *lp)
961 {
962         u32 regvall;
963         u16 regvalh;
964         u8  addr[6];
965
966         regvall = xemacps_read(lp->baseaddr, XEMACPS_LADDR1L_OFFSET);
967         regvalh = xemacps_read(lp->baseaddr, XEMACPS_LADDR1H_OFFSET);
968         addr[0] = regvall & 0xFF;
969         addr[1] = (regvall >> 8) & 0xFF;
970         addr[2] = (regvall >> 16) & 0xFF;
971         addr[3] = (regvall >> 24) & 0xFF;
972         addr[4] = regvalh & 0xFF;
973         addr[5] = (regvalh >> 8) & 0xFF;
974
975         if (is_valid_ether_addr(addr)) {
976                 memcpy(lp->ndev->dev_addr, addr, sizeof(addr));
977         } else {
978                 dev_info(&lp->pdev->dev, "invalid address, use assigned\n");
979                 random_ether_addr(lp->ndev->dev_addr);
980                 dev_info(&lp->pdev->dev,
981                                 "MAC updated %02x:%02x:%02x:%02x:%02x:%02x\n",
982                                 lp->ndev->dev_addr[0], lp->ndev->dev_addr[1],
983                                 lp->ndev->dev_addr[2], lp->ndev->dev_addr[3],
984                                 lp->ndev->dev_addr[4], lp->ndev->dev_addr[5]);
985         }
986 }
987
988 /**
989  * xemacps_set_hwaddr - Set device's MAC address from ndev->dev_addr
990  * @lp: local device instance pointer
991  **/
992 static void xemacps_set_hwaddr(struct net_local *lp)
993 {
994         u32 regvall = 0;
995         u16 regvalh = 0;
996 #ifdef __LITTLE_ENDIAN
997         regvall = cpu_to_le32(*((u32 *)lp->ndev->dev_addr));
998         regvalh = cpu_to_le16(*((u16 *)(lp->ndev->dev_addr + 4)));
999 #endif
1000 #ifdef __BIG_ENDIAN
1001         regvall = cpu_to_be32(*((u32 *)lp->ndev->dev_addr));
1002         regvalh = cpu_to_be16(*((u16 *)(lp->ndev->dev_addr + 4)));
1003 #endif
1004         /* LADDRXH has to be wriiten latter than LADDRXL to enable
1005          * this address even if these 16 bits are zeros. */
1006         xemacps_write(lp->baseaddr, XEMACPS_LADDR1L_OFFSET, regvall);
1007         xemacps_write(lp->baseaddr, XEMACPS_LADDR1H_OFFSET, regvalh);
1008 #ifdef DEBUG
1009         regvall = xemacps_read(lp->baseaddr, XEMACPS_LADDR1L_OFFSET);
1010         regvalh = xemacps_read(lp->baseaddr, XEMACPS_LADDR1H_OFFSET);
1011         dev_dbg(&lp->pdev->dev,
1012                         "MAC 0x%08x, 0x%08x, %02x:%02x:%02x:%02x:%02x:%02x\n",
1013                 regvall, regvalh,
1014                 (regvall & 0xff), ((regvall >> 8) & 0xff),
1015                 ((regvall >> 16) & 0xff), (regvall >> 24),
1016                 (regvalh & 0xff), (regvalh >> 8));
1017 #endif
1018 }
1019
1020 /*
1021  * xemacps_reset_hw - Helper function to reset the underlying hardware.
1022  * This is called when we get into such deep trouble that we don't know
1023  * how to handle otherwise.
1024  * @lp: local device instance pointer
1025  */
1026 static void xemacps_reset_hw(struct net_local *lp)
1027 {
1028         u32 regisr;
1029         /* make sure we have the buffer for ourselves */
1030         wmb();
1031
1032         /* Have a clean start */
1033         xemacps_write(lp->baseaddr, XEMACPS_NWCTRL_OFFSET, 0);
1034
1035         /* Clear statistic counters */
1036         xemacps_write(lp->baseaddr, XEMACPS_NWCTRL_OFFSET,
1037                 XEMACPS_NWCTRL_STATCLR_MASK);
1038
1039         /* Clear TX and RX status */
1040         xemacps_write(lp->baseaddr, XEMACPS_TXSR_OFFSET, ~0UL);
1041         xemacps_write(lp->baseaddr, XEMACPS_RXSR_OFFSET, ~0UL);
1042
1043         /* Disable all interrupts */
1044         xemacps_write(lp->baseaddr, XEMACPS_IDR_OFFSET, ~0UL);
1045         regisr = xemacps_read(lp->baseaddr, XEMACPS_ISR_OFFSET);
1046         xemacps_write(lp->baseaddr, XEMACPS_ISR_OFFSET, regisr);
1047 }
1048
1049 /**
1050  * xemacps_bdringalloc - reserve locations in BD list.
1051  * @ringptr: pointer to the BD ring instance to be worked on.
1052  * @numbd: number of BDs to allocate.
1053  * @bdptr: output parameter points to the first BD available for
1054  *         modification.
1055  * return 0 on success, negative value if not enough BDs.
1056  **/
1057 int xemacps_bdringalloc(struct xemacps_bdring *ringptr, unsigned numbd,
1058                 struct xemacps_bd **bdptr)
1059 {
1060         /* Enough free BDs available for the request? */
1061         if (ringptr->freecnt < numbd)
1062                 return NETDEV_TX_BUSY;
1063
1064         /* Set the return argument and move FreeHead forward */
1065         *bdptr = ringptr->freehead;
1066         XEMACPS_RING_SEEKAHEAD(ringptr, ringptr->freehead, numbd);
1067         ringptr->freecnt -= numbd;
1068         ringptr->precnt  += numbd;
1069         return 0;
1070 }
1071
1072 /**
1073  * xemacps_bdringunalloc - Fully or partially undo xemacps_bdringalloc().
1074  * @ringptr: pointer to the BD ring instance to be worked on.
1075  * @numbd: number of BDs to unallocate.
1076  * @bdptr: points to the first of BDs to be unallocated.
1077  * return 0 on success, negative value if error.
1078  **/
1079 int xemacps_bdringunalloc(struct xemacps_bdring *ringptr, unsigned numbd,
1080                 struct xemacps_bd *bdptr)
1081 {
1082         /* Enough BDs in the free state for the request? */
1083         if (ringptr->precnt < numbd)
1084                 return -ENOSPC;
1085
1086         /* Set the return argument and move FreeHead backward */
1087         XEMACPS_RING_SEEKBACK(ringptr, ringptr->freehead, numbd);
1088         ringptr->freecnt += numbd;
1089         ringptr->precnt  -= numbd;
1090         return 0;
1091 }
1092
1093 #ifdef DEBUG_VERBOSE
1094 static void print_ring(struct xemacps_bdring *ring)
1095 {
1096         int i;
1097         unsigned regval;
1098         struct xemacps_bd *bd;
1099
1100         pr_info("freehead %p prehead %p hwhead %p hwtail %p posthead %p\n",
1101                         ring->freehead, ring->prehead, ring->hwhead,
1102                         ring->hwtail, ring->posthead);
1103         pr_info("freecnt %d hwcnt %d precnt %d postcnt %d allcnt %d\n",
1104                         ring->freecnt, ring->hwcnt, ring->precnt,
1105                         ring->postcnt, ring->allcnt);
1106
1107         bd = (struct xemacps_bd *)ring->firstbdaddr;
1108         for (i = 0; i < XEMACPS_RECV_BD_CNT; i++) {
1109                 regval = xemacps_read(bd, XEMACPS_BD_ADDR_OFFSET);
1110                 pr_info("BD %p: ADDR: 0x%08x\n", bd, regval);
1111                 regval = xemacps_read(bd, XEMACPS_BD_STAT_OFFSET);
1112                 pr_info("BD %p: STAT: 0x%08x\n", bd, regval);
1113                 bd++;
1114         }
1115 }
1116 #endif
1117
1118 /**
1119  * xemacps_bdringtohw - Enqueue a set of BDs to hardware that were
1120  * previously allocated by xemacps_bdringalloc().
1121  * @ringptr: pointer to the BD ring instance to be worked on.
1122  * @numbd: number of BDs to hardware.
1123  * @bdptr: points to the first of BDs to be processed.
1124  * return 0 on success, negative value if error.
1125  **/
1126 int xemacps_bdringtohw(struct xemacps_bdring *ringptr, unsigned numbd,
1127                 struct xemacps_bd *bdptr)
1128 {
1129         struct xemacps_bd *curbdptr;
1130         unsigned int i;
1131         unsigned int regval;
1132
1133         /* if no bds to process, simply return. */
1134         if (numbd == 0)
1135                 return 0;
1136
1137         /* Make sure we are in sync with xemacps_bdringalloc() */
1138         if ((ringptr->precnt < numbd) || (ringptr->prehead != bdptr))
1139                 return -ENOSPC;
1140
1141         curbdptr = bdptr;
1142         for (i = 0; i < numbd; i++) {
1143                 /* Assign ownership back to hardware */
1144                 if (ringptr->is_rx) {
1145                         xemacps_write(curbdptr, XEMACPS_BD_STAT_OFFSET, 0);
1146                         wmb();
1147
1148                         regval = xemacps_read(curbdptr, XEMACPS_BD_ADDR_OFFSET);
1149                         regval &= ~XEMACPS_RXBUF_NEW_MASK;
1150                         xemacps_write(curbdptr, XEMACPS_BD_ADDR_OFFSET, regval);
1151                 } else {
1152                         regval = xemacps_read(curbdptr, XEMACPS_BD_STAT_OFFSET);
1153                         /* clear used bit - hardware to own this descriptor */
1154                         regval &= ~XEMACPS_TXBUF_USED_MASK;
1155                         xemacps_write(curbdptr, XEMACPS_BD_STAT_OFFSET, regval);
1156                 }
1157                 wmb();
1158                 curbdptr = XEMACPS_BDRING_NEXT(ringptr, curbdptr);
1159         }
1160         /* Adjust ring pointers & counters */
1161         XEMACPS_RING_SEEKAHEAD(ringptr, ringptr->prehead, numbd);
1162         ringptr->hwtail  = curbdptr;
1163         ringptr->precnt -= numbd;
1164         ringptr->hwcnt  += numbd;
1165
1166         return 0;
1167 }
1168
1169 /**
1170  * xemacps_bdringfromhwtx - returns a set of BD(s) that have been
1171  * processed by hardware in tx direction.
1172  * @ringptr: pointer to the BD ring instance to be worked on.
1173  * @bdlimit: maximum number of BDs to return in the set.
1174  * @bdptr: output parameter points to the first BD available for
1175  *         examination.
1176  * return number of BDs processed by hardware.
1177  **/
1178 u32 xemacps_bdringfromhwtx(struct xemacps_bdring *ringptr, unsigned bdlimit,
1179                 struct xemacps_bd **bdptr)
1180 {
1181         struct xemacps_bd *curbdptr;
1182         u32 bdstr = 0;
1183         unsigned int bdcount = 0;
1184         unsigned int bdpartialcount = 0;
1185         unsigned int sop = 0;
1186
1187         curbdptr = ringptr->hwhead;
1188
1189         /* If no BDs in work group, then there's nothing to search */
1190         if (ringptr->hwcnt == 0) {
1191                 *bdptr = NULL;
1192                 return 0;
1193         }
1194
1195         if (bdlimit > ringptr->hwcnt)
1196                 bdlimit = ringptr->hwcnt;
1197
1198         /* Starting at hwhead, keep moving forward in the list until:
1199          *  - ringptr->hwtail is reached.
1200          *  - The number of requested BDs has been processed
1201          */
1202         while (bdcount < bdlimit) {
1203                 /* Read the status */
1204                 bdstr = xemacps_read(curbdptr, XEMACPS_BD_STAT_OFFSET);
1205
1206                 if (sop == 0) {
1207                         if (bdstr & XEMACPS_TXBUF_USED_MASK)
1208                                 sop = 1;
1209                         else
1210                                 break;
1211                 }
1212
1213                 if (sop == 1) {
1214                         bdcount++;
1215                         bdpartialcount++;
1216                 }
1217                 /* hardware has processed this BD so check the "last" bit.
1218                  * If it is clear, then there are more BDs for the current
1219                  * packet. Keep a count of these partial packet BDs.
1220                  */
1221                 if ((sop == 1) && (bdstr & XEMACPS_TXBUF_LAST_MASK)) {
1222                         sop = 0;
1223                         bdpartialcount = 0;
1224                 }
1225
1226                 /* Move on to next BD in work group */
1227                 curbdptr = XEMACPS_BDRING_NEXT(ringptr, curbdptr);
1228         }
1229
1230         /* Subtract off any partial packet BDs found */
1231         bdcount -= bdpartialcount;
1232
1233         /* If bdcount is non-zero then BDs were found to return. Set return
1234          * parameters, update pointers and counters, return number of BDs
1235          */
1236         if (bdcount > 0) {
1237                 *bdptr = ringptr->hwhead;
1238                 ringptr->hwcnt   -= bdcount;
1239                 ringptr->postcnt += bdcount;
1240                 XEMACPS_RING_SEEKAHEAD(ringptr, ringptr->hwhead, bdcount);
1241                 return bdcount;
1242         } else {
1243                 *bdptr = NULL;
1244                 return 0;
1245         }
1246 }
1247
1248 /**
1249  * xemacps_bdringfromhwrx - returns a set of BD(s) that have been
1250  * processed by hardware in rx direction.
1251  * @ringptr: pointer to the BD ring instance to be worked on.
1252  * @bdlimit: maximum number of BDs to return in the set.
1253  * @bdptr: output parameter points to the first BD available for
1254  *         examination.
1255  * return number of BDs processed by hardware.
1256  **/
1257 u32 xemacps_bdringfromhwrx(struct xemacps_bdring *ringptr, int bdlimit,
1258                 struct xemacps_bd **bdptr)
1259 {
1260         struct xemacps_bd *curbdptr;
1261         u32 bdadd = 0;
1262         int bdcount = 0;
1263         curbdptr = ringptr->hwhead;
1264
1265         /* If no BDs in work group, then there's nothing to search */
1266         if (ringptr->hwcnt == 0) {
1267                 *bdptr = NULL;
1268                 return 0;
1269         }
1270
1271         if (bdlimit > ringptr->hwcnt)
1272                 bdlimit = ringptr->hwcnt;
1273
1274         /* Starting at hwhead, keep moving forward in the list until:
1275          *  - A BD is encountered with its new/used bit set which means
1276          *    hardware has not completed processing of that BD.
1277          *  - ringptr->hwtail is reached.
1278          *  - The number of requested BDs has been processed
1279          */
1280         while (bdcount < bdlimit) {
1281                 /* Read the status word to see if BD has been processed. */
1282                 bdadd = xemacps_read(curbdptr, XEMACPS_BD_ADDR_OFFSET);
1283                 if (bdadd & XEMACPS_RXBUF_NEW_MASK)
1284                         bdcount++;
1285                 else
1286                         break;
1287
1288                 /* Move on to next BD in work group */
1289                 curbdptr = XEMACPS_BDRING_NEXT(ringptr, curbdptr);
1290         }
1291
1292         /* If bdcount is non-zero then BDs were found to return. Set return
1293          * parameters, update pointers and counters, return number of BDs
1294          */
1295         if (bdcount > 0) {
1296                 *bdptr = ringptr->hwhead;
1297                 ringptr->hwcnt   -= bdcount;
1298                 ringptr->postcnt += bdcount;
1299                 XEMACPS_RING_SEEKAHEAD(ringptr, ringptr->hwhead, bdcount);
1300                 return bdcount;
1301         } else {
1302                 *bdptr = NULL;
1303                 return 0;
1304         }
1305 }
1306
1307 /**
1308  * xemacps_bdringfree - Free a set of BDs that has been retrieved with
1309  * xemacps_bdringfromhw().
1310  * previously allocated by xemacps_bdringalloc().
1311  * @ringptr: pointer to the BD ring instance to be worked on.
1312  * @numbd: number of BDs to allocate.
1313  * @bdptr: the head of BD list returned by xemacps_bdringfromhw().
1314  * return 0 on success, negative value if error.
1315  **/
1316 int xemacps_bdringfree(struct xemacps_bdring *ringptr, unsigned numbd,
1317                 struct xemacps_bd *bdptr)
1318 {
1319         /* if no bds to free, simply return. */
1320         if (0 == numbd)
1321                 return 0;
1322
1323         /* Make sure we are in sync with xemacps_bdringfromhw() */
1324         if ((ringptr->postcnt < numbd) || (ringptr->posthead != bdptr))
1325                 return -ENOSPC;
1326
1327         /* Update pointers and counters */
1328         ringptr->freecnt += numbd;
1329         ringptr->postcnt -= numbd;
1330         XEMACPS_RING_SEEKAHEAD(ringptr, ringptr->posthead, numbd);
1331         return 0;
1332 }
1333
1334
1335 /**
1336  * xemacps_DmaSetupRecvBuffers - allocates socket buffers (sk_buff's)
1337  * up to the number of free RX buffer descriptors. Then it sets up the RX
1338  * buffer descriptors to DMA into the socket_buffers.
1339  * @ndev: the net_device
1340  **/
1341 static void xemacps_DmaSetupRecvBuffers(struct net_device *ndev)
1342 {
1343         struct net_local *lp;
1344         struct xemacps_bdring *rxringptr;
1345         struct xemacps_bd *bdptr;
1346         struct sk_buff *new_skb;
1347         u32 new_skb_baddr;
1348         int free_bd_count;
1349         int num_sk_buffs;
1350         int bdidx;
1351         int result;
1352
1353         lp = (struct net_local *) netdev_priv(ndev);
1354         rxringptr = &lp->rx_ring;
1355         free_bd_count = rxringptr->freecnt;
1356
1357         for (num_sk_buffs = 0; num_sk_buffs < free_bd_count; num_sk_buffs++) {
1358                 new_skb = netdev_alloc_skb(ndev, XEMACPS_RX_BUF_SIZE);
1359                 if (new_skb == NULL) {
1360                         lp->stats.rx_dropped++;
1361                         break;
1362                 }
1363
1364                 result = xemacps_bdringalloc(rxringptr, 1, &bdptr);
1365                 if (result) {
1366                         dev_err(&lp->pdev->dev, "RX bdringalloc() error.\n");
1367                         break;
1368                 }
1369
1370                 /* Get dma handle of skb->data */
1371                 new_skb_baddr = (u32) dma_map_single(ndev->dev.parent,
1372                         new_skb->data, XEMACPS_RX_BUF_SIZE, DMA_FROM_DEVICE);
1373
1374                 XEMACPS_SET_BUFADDR_RX(bdptr, new_skb_baddr);
1375                 bdidx = XEMACPS_BD_TO_INDEX(rxringptr, bdptr);
1376                 lp->rx_skb[bdidx].skb = new_skb;
1377                 lp->rx_skb[bdidx].mapping = new_skb_baddr;
1378                 wmb();
1379
1380                 /* enqueue RxBD with the attached skb buffers such that it is
1381                  * ready for frame reception
1382                  */
1383                 result = xemacps_bdringtohw(rxringptr, 1, bdptr);
1384                 if (result) {
1385                         dev_err(&lp->pdev->dev,
1386                                         "bdringtohw unsuccessful (%d)\n",
1387                                         result);
1388                         break;
1389                 }
1390         }
1391 }
1392
1393 #ifdef CONFIG_XILINX_PS_EMAC_HWTSTAMP
1394
1395 /**
1396  * xemacps_get_hwticks - get the current value of the GEM internal timer
1397  * @lp: local device instance pointer
1398  * return: nothing
1399  **/
1400 static inline void
1401 xemacps_get_hwticks(struct net_local *lp, u64 *sec, u64 *nsec)
1402 {
1403         do {
1404                 *nsec = xemacps_read(lp->baseaddr, XEMACPS_1588NS_OFFSET);
1405                 *sec = xemacps_read(lp->baseaddr, XEMACPS_1588S_OFFSET);
1406         } while (*nsec > xemacps_read(lp->baseaddr, XEMACPS_1588NS_OFFSET));
1407 }
1408
1409 /**
1410  * xemacps_read_clock - read raw cycle counter (to be used by time counter)
1411  */
1412 static cycle_t xemacps_read_clock(const struct cyclecounter *tc)
1413 {
1414         struct net_local *lp =
1415                         container_of(tc, struct net_local, cycles);
1416         u64 stamp;
1417         u64 sec, nsec;
1418
1419         xemacps_get_hwticks(lp, &sec, &nsec);
1420         stamp = (sec << 32) | nsec;
1421
1422         return stamp;
1423 }
1424
1425
1426 /**
1427  * xemacps_systim_to_hwtstamp - convert system time value to hw timestamp
1428  * @adapter: board private structure
1429  * @shhwtstamps: timestamp structure to update
1430  * @regval: unsigned 64bit system time value.
1431  *
1432  * We need to convert the system time value stored in the RX/TXSTMP registers
1433  * into a hwtstamp which can be used by the upper level timestamping functions
1434  */
1435 static void xemacps_systim_to_hwtstamp(struct net_local *lp,
1436                                 struct skb_shared_hwtstamps *shhwtstamps,
1437                                 u64 regval)
1438 {
1439         u64 ns;
1440
1441         ns = timecounter_cyc2time(&lp->clock, regval);
1442         timecompare_update(&lp->compare, ns);
1443         memset(shhwtstamps, 0, sizeof(struct skb_shared_hwtstamps));
1444         shhwtstamps->hwtstamp = ns_to_ktime(ns);
1445         shhwtstamps->syststamp = timecompare_transform(&lp->compare, ns);
1446 }
1447
1448 static void
1449 xemacps_rx_hwtstamp(struct net_local *lp,
1450                         struct sk_buff *skb, unsigned msg_type)
1451 {
1452         u64 time64, sec, nsec;
1453
1454         if (!msg_type) {
1455                 /* PTP Event Frame packets */
1456                 sec = xemacps_read(lp->baseaddr, XEMACPS_PTPERXS_OFFSET);
1457                 nsec = xemacps_read(lp->baseaddr, XEMACPS_PTPERXNS_OFFSET);
1458         } else {
1459                 /* PTP Peer Event Frame packets */
1460                 sec = xemacps_read(lp->baseaddr, XEMACPS_PTPPRXS_OFFSET);
1461                 nsec = xemacps_read(lp->baseaddr, XEMACPS_PTPPRXNS_OFFSET);
1462         }
1463         time64 = (sec << 32) | nsec;
1464         xemacps_systim_to_hwtstamp(lp, skb_hwtstamps(skb), time64);
1465 }
1466
1467 static void
1468 xemacps_tx_hwtstamp(struct net_local *lp,
1469                         struct sk_buff *skb, unsigned msg_type)
1470 {
1471         u64 time64, sec, nsec;
1472
1473         if (!msg_type) {
1474                 /* PTP Event Frame packets */
1475                 sec = xemacps_read(lp->baseaddr, XEMACPS_PTPETXS_OFFSET);
1476                 nsec = xemacps_read(lp->baseaddr, XEMACPS_PTPETXNS_OFFSET);
1477         } else {
1478                 /* PTP Peer Event Frame packets */
1479                 sec = xemacps_read(lp->baseaddr, XEMACPS_PTPPTXS_OFFSET);
1480                 nsec = xemacps_read(lp->baseaddr, XEMACPS_PTPPTXNS_OFFSET);
1481         }
1482
1483         time64 = (sec << 32) | nsec;
1484         xemacps_systim_to_hwtstamp(lp, skb_hwtstamps(skb), time64);
1485         skb_tstamp_tx(skb, skb_hwtstamps(skb));
1486 }
1487
1488 #endif /* CONFIG_XILINX_PS_EMAC_HWTSTAMP */
1489
1490 /**
1491  * xemacps_rx - process received packets when napi called
1492  * @lp: local device instance pointer
1493  * @budget: NAPI budget
1494  * return: number of BDs processed
1495  **/
1496 static int xemacps_rx(struct net_local *lp, int budget)
1497 {
1498         u32 regval, len = 0;
1499         struct sk_buff *skb = NULL;
1500         struct xemacps_bd *bdptr, *bdptrfree;
1501         unsigned int numbdfree, numbd = 0, bdidx = 0, rc = 0;
1502
1503         numbd = xemacps_bdringfromhwrx(&lp->rx_ring, budget, &bdptr);
1504
1505         numbdfree = numbd;
1506         bdptrfree = bdptr;
1507
1508 #ifdef DEBUG_VERBOSE
1509         dev_dbg(&lp->pdev->dev, "%s: numbd %d\n", __func__, numbd);
1510 #endif
1511
1512         while (numbd) {
1513                 bdidx = XEMACPS_BD_TO_INDEX(&lp->rx_ring, bdptr);
1514                 regval = xemacps_read(bdptr, XEMACPS_BD_STAT_OFFSET);
1515
1516 #ifdef DEBUG_VERBOSE
1517                 dev_dbg(&lp->pdev->dev,
1518                         "%s: RX BD index %d, BDptr %p, BD_STAT 0x%08x\n",
1519                         __func__, bdidx, bdptr, regval);
1520 #endif
1521
1522                 /* look for start of packet */
1523                 if (!(regval & XEMACPS_RXBUF_SOF_MASK) ||
1524                     !(regval & XEMACPS_RXBUF_EOF_MASK)) {
1525                         dev_info(&lp->pdev->dev,
1526                                 "%s: SOF and EOF not set (0x%08x) BD %p\n",
1527                                 __func__, regval, bdptr);
1528                         lp->stats.rx_dropped++;
1529                         return 0;
1530                 }
1531
1532                 /* the packet length */
1533                 len = regval & XEMACPS_RXBUF_LEN_MASK;
1534
1535                 skb = lp->rx_skb[bdidx].skb;
1536                 dma_unmap_single(lp->ndev->dev.parent,
1537                                                 lp->rx_skb[bdidx].mapping,
1538                                                 XEMACPS_RX_BUF_SIZE,
1539                                                 DMA_FROM_DEVICE);
1540
1541                 lp->rx_skb[bdidx].skb = NULL;
1542                 lp->rx_skb[bdidx].mapping = 0;
1543
1544                 /* setup received skb and send it upstream */
1545                 skb_put(skb, len);  /* Tell the skb how much data we got. */
1546                 skb->dev = lp->ndev;
1547
1548                 /* Why does this return the protocol in network bye order ? */
1549                 skb->protocol = eth_type_trans(skb, lp->ndev);
1550
1551                 skb->ip_summed = lp->ip_summed;
1552
1553 #ifdef CONFIG_XILINX_PS_EMAC_HWTSTAMP
1554                 if ((lp->hwtstamp_config.rx_filter == HWTSTAMP_FILTER_ALL) &&
1555                     (ntohs(skb->protocol) == 0x800)) {
1556                         unsigned ip_proto, dest_port, msg_type;
1557
1558                         /* While the GEM can timestamp PTP packets, it does
1559                          * not mark the RX descriptor to identify them.  This
1560                          * is entirely the wrong place to be parsing UDP
1561                          * headers, but some minimal effort must be made.
1562                          * NOTE: the below parsing of ip_proto and dest_port
1563                          * depend on the use of Ethernet_II encapsulation,
1564                          * IPv4 without any options.
1565                          */
1566                         ip_proto = *((u8 *)skb->mac_header + 14 + 9);
1567                         dest_port = ntohs(*(((u16 *)skb->mac_header) +
1568                                                 ((14 + 20 + 2)/2)));
1569                         msg_type = *((u8 *)skb->mac_header + 42);
1570                         if ((ip_proto == IPPROTO_UDP) &&
1571                             (dest_port == 0x13F)) {
1572                                 /* Timestamp this packet */
1573                                 xemacps_rx_hwtstamp(lp, skb, msg_type & 0x2);
1574                         }
1575                 }
1576 #endif /* CONFIG_XILINX_PS_EMAC_HWTSTAMP */
1577
1578                 lp->stats.rx_packets++;
1579                 lp->stats.rx_bytes += len;
1580                 netif_receive_skb(skb);
1581
1582                 bdptr = XEMACPS_BDRING_NEXT(&lp->rx_ring, bdptr);
1583                 numbd--;
1584         }
1585
1586         /* Make used BDs available */
1587         rc = xemacps_bdringfree(&lp->rx_ring, numbdfree, bdptrfree);
1588         if (rc)
1589                 dev_err(&lp->pdev->dev, "RX bdringfree() error.\n");
1590
1591         /* Refill RX buffers */
1592         xemacps_DmaSetupRecvBuffers(lp->ndev);
1593
1594         return numbdfree;
1595 }
1596
1597 /**
1598  * xemacps_rx_poll - NAPI poll routine
1599  * napi: pointer to napi struct
1600  * budget:
1601  **/
1602 static int xemacps_rx_poll(struct napi_struct *napi, int budget)
1603 {
1604         struct net_local *lp = container_of(napi, struct net_local, napi);
1605         int work_done = 0;
1606         int temp_work_done;
1607         u32 regval;
1608
1609         regval = xemacps_read(lp->baseaddr, XEMACPS_RXSR_OFFSET);
1610         xemacps_write(lp->baseaddr, XEMACPS_RXSR_OFFSET, regval);
1611
1612         while (work_done < budget) {
1613                 if (regval & (XEMACPS_RXSR_HRESPNOK_MASK |
1614                                         XEMACPS_RXSR_BUFFNA_MASK))
1615                         lp->stats.rx_errors++;
1616                 temp_work_done = xemacps_rx(lp, budget - work_done);
1617                 work_done += temp_work_done;
1618                 regval = xemacps_read(lp->baseaddr, XEMACPS_RXSR_OFFSET);
1619                 xemacps_write(lp->baseaddr, XEMACPS_RXSR_OFFSET, regval);
1620                 if (temp_work_done <= 0)
1621                         break;
1622         }
1623
1624         if (work_done >= budget)
1625                 return work_done;
1626
1627         napi_complete(napi);
1628         /* We disabled RX interrupts in interrupt service
1629          * routine, now it is time to enable it back.
1630          */
1631         xemacps_write(lp->baseaddr, XEMACPS_IER_OFFSET,
1632                                         (XEMACPS_IXR_FRAMERX_MASK |
1633                                         XEMACPS_IXR_RX_ERR_MASK));
1634
1635         return work_done;
1636 }
1637
1638 /**
1639  * xemacps_tx_poll - tx isr handler routine
1640  * @data: pointer to network interface device structure
1641  **/
1642 static void xemacps_tx_poll(struct net_device *ndev)
1643 {
1644         struct net_local *lp = netdev_priv(ndev);
1645         u32 regval, bdlen = 0;
1646         struct xemacps_bd *bdptr, *bdptrfree;
1647         struct ring_info *rp;
1648         struct sk_buff *skb;
1649         unsigned int numbd, numbdfree, bdidx, rc;
1650
1651         regval = xemacps_read(lp->baseaddr, XEMACPS_TXSR_OFFSET);
1652         xemacps_write(lp->baseaddr, XEMACPS_TXSR_OFFSET, regval);
1653         dev_dbg(&lp->pdev->dev, "TX status 0x%x\n", regval);
1654
1655         /* If this error is seen, it is in deep trouble and nothing
1656          * we can do to revive hardware other than reset hardware.
1657          * Or try to close this interface and reopen it.
1658          */
1659         if (regval & (XEMACPS_TXSR_RXOVR_MASK | XEMACPS_TXSR_HRESPNOK_MASK
1660                                         | XEMACPS_TXSR_BUFEXH_MASK))
1661                 lp->stats.tx_errors++;
1662
1663         /* This may happen when a buffer becomes complete
1664          * between reading the ISR and scanning the descriptors.
1665          * Nothing to worry about.
1666          */
1667         if (!(regval & XEMACPS_TXSR_TXCOMPL_MASK))
1668                 goto tx_poll_out;
1669
1670         numbd = xemacps_bdringfromhwtx(&lp->tx_ring, XEMACPS_SEND_BD_CNT,
1671                 &bdptr);
1672         numbdfree = numbd;
1673         bdptrfree = bdptr;
1674
1675         while (numbd) {
1676                 regval  = xemacps_read(bdptr, XEMACPS_BD_STAT_OFFSET);
1677                 rmb();
1678                 bdlen = regval & XEMACPS_TXBUF_LEN_MASK;
1679                 bdidx = XEMACPS_BD_TO_INDEX(&lp->tx_ring, bdptr);
1680                 rp = &lp->tx_skb[bdidx];
1681                 skb = rp->skb;
1682
1683                 BUG_ON(skb == NULL);
1684
1685 #ifdef CONFIG_XILINX_PS_EMAC_HWTSTAMP
1686                 if ((lp->hwtstamp_config.tx_type == HWTSTAMP_TX_ON) &&
1687                         (ntohs(skb->protocol) == 0x800)) {
1688                         unsigned ip_proto, dest_port, msg_type;
1689
1690                         skb_reset_mac_header(skb);
1691
1692                         ip_proto = *((u8 *)skb->mac_header + 14 + 9);
1693                         dest_port = ntohs(*(((u16 *)skb->mac_header) +
1694                                         ((14 + 20 + 2)/2)));
1695                         msg_type = *((u8 *)skb->mac_header + 42);
1696                         if ((ip_proto == IPPROTO_UDP) &&
1697                                 (dest_port == 0x13F)) {
1698                                 /* Timestamp this packet */
1699                                 xemacps_tx_hwtstamp(lp, skb, msg_type & 0x2);
1700                         }
1701                 }
1702 #endif /* CONFIG_XILINX_PS_EMAC_HWTSTAMP */
1703
1704                 dma_unmap_single(&lp->pdev->dev, rp->mapping, skb->len,
1705                         DMA_TO_DEVICE);
1706                 rp->skb = NULL;
1707                 dev_kfree_skb_irq(skb);
1708 #ifdef DEBUG_VERBOSE_TX
1709                 dev_dbg(&lp->pdev->dev,
1710                                 "TX bd index %d BD_STAT 0x%08x after sent.\n",
1711                                 bdidx, regval);
1712 #endif
1713                 /* log tx completed packets and bytes, errors logs
1714                  * are in other error counters.
1715                  */
1716                 if (regval & XEMACPS_TXBUF_LAST_MASK) {
1717                         if (!(regval & XEMACPS_TXBUF_ERR_MASK)) {
1718                                 lp->stats.tx_packets++;
1719                                 lp->stats.tx_bytes += bdlen;
1720                         }
1721                 }
1722
1723                 /* Preserve used and wrap bits; clear everything else. */
1724                 regval &= (XEMACPS_TXBUF_USED_MASK | XEMACPS_TXBUF_WRAP_MASK);
1725                 xemacps_write(bdptr, XEMACPS_BD_STAT_OFFSET, regval);
1726
1727                 bdptr = XEMACPS_BDRING_NEXT(&lp->tx_ring, bdptr);
1728                 numbd--;
1729                 wmb();
1730         }
1731
1732         rc = xemacps_bdringfree(&lp->tx_ring, numbdfree, bdptrfree);
1733         if (rc)
1734                 dev_err(&lp->pdev->dev, "TX bdringfree() error.\n");
1735
1736 tx_poll_out:
1737         if (netif_queue_stopped(ndev))
1738                 netif_start_queue(ndev);
1739 }
1740
1741 /**
1742  * xemacps_interrupt - interrupt main service routine
1743  * @irq: interrupt number
1744  * @dev_id: pointer to a network device structure
1745  * return IRQ_HANDLED or IRQ_NONE
1746  **/
1747 static irqreturn_t xemacps_interrupt(int irq, void *dev_id)
1748 {
1749         struct net_device *ndev = dev_id;
1750         struct net_local *lp = netdev_priv(ndev);
1751         u32 regisr;
1752
1753         spin_lock(&lp->lock);
1754         regisr = xemacps_read(lp->baseaddr, XEMACPS_ISR_OFFSET);
1755         if (unlikely(!regisr))
1756                 return IRQ_NONE;
1757         xemacps_write(lp->baseaddr, XEMACPS_ISR_OFFSET, regisr);
1758
1759         while (regisr) {
1760                 if (regisr & (XEMACPS_IXR_TXCOMPL_MASK |
1761                                 XEMACPS_IXR_TX_ERR_MASK)) {
1762                         xemacps_tx_poll(ndev);
1763                 } else {
1764                         xemacps_write(lp->baseaddr, XEMACPS_IDR_OFFSET,
1765                                         (XEMACPS_IXR_FRAMERX_MASK |
1766                                         XEMACPS_IXR_RX_ERR_MASK));
1767                         napi_schedule(&lp->napi);
1768                 }
1769                 regisr = xemacps_read(lp->baseaddr, XEMACPS_ISR_OFFSET);
1770                 xemacps_write(lp->baseaddr, XEMACPS_ISR_OFFSET, regisr);
1771         }
1772         spin_unlock(&lp->lock);
1773
1774         return IRQ_HANDLED;
1775 }
1776
1777 /*
1778  * Free all packets presently in the descriptor rings.
1779  */
1780 static void xemacps_clean_rings(struct net_local *lp)
1781 {
1782         int i;
1783
1784         for (i = 0; i < XEMACPS_RECV_BD_CNT; i++) {
1785                 if (lp->rx_skb && lp->rx_skb[i].skb) {
1786                         dma_unmap_single(lp->ndev->dev.parent,
1787                                          lp->rx_skb[i].mapping,
1788                                          XEMACPS_RX_BUF_SIZE,
1789                                          DMA_FROM_DEVICE);
1790
1791                         dev_kfree_skb(lp->rx_skb[i].skb);
1792                         lp->rx_skb[i].skb = NULL;
1793                         lp->rx_skb[i].mapping = 0;
1794                 }
1795         }
1796
1797         for (i = 0; i < XEMACPS_SEND_BD_CNT; i++) {
1798                 if (lp->tx_skb && lp->tx_skb[i].skb) {
1799                         dma_unmap_single(lp->ndev->dev.parent,
1800                                          lp->tx_skb[i].mapping,
1801                                          lp->tx_skb[i].skb->len,
1802                                          DMA_TO_DEVICE);
1803
1804                         dev_kfree_skb(lp->tx_skb[i].skb);
1805                         lp->tx_skb[i].skb = NULL;
1806                         lp->tx_skb[i].mapping = 0;
1807                 }
1808         }
1809 }
1810
1811 /**
1812  * xemacps_descriptor_free - Free allocated TX and RX BDs
1813  * @lp: local device instance pointer
1814  **/
1815 static void xemacps_descriptor_free(struct net_local *lp)
1816 {
1817         int size;
1818
1819         xemacps_clean_rings(lp);
1820
1821         /* kfree(NULL) is safe, no need to check here */
1822         kfree(lp->tx_skb);
1823         lp->tx_skb = NULL;
1824         kfree(lp->rx_skb);
1825         lp->rx_skb = NULL;
1826
1827         size = XEMACPS_RECV_BD_CNT * sizeof(struct xemacps_bd);
1828         if (lp->rx_bd) {
1829                 dma_free_coherent(&lp->pdev->dev, size,
1830                         lp->rx_bd, lp->rx_bd_dma);
1831                 lp->rx_bd = NULL;
1832         }
1833
1834         size = XEMACPS_SEND_BD_CNT * sizeof(struct xemacps_bd);
1835         if (lp->tx_bd) {
1836                 dma_free_coherent(&lp->pdev->dev, size,
1837                         lp->tx_bd, lp->tx_bd_dma);
1838                 lp->tx_bd = NULL;
1839         }
1840 }
1841
1842 /**
1843  * xemacps_descriptor_init - Allocate both TX and RX BDs
1844  * @lp: local device instance pointer
1845  * return 0 on success, negative value if error
1846  **/
1847 static int xemacps_descriptor_init(struct net_local *lp)
1848 {
1849         int size;
1850
1851         size = XEMACPS_SEND_BD_CNT * sizeof(struct ring_info);
1852         lp->tx_skb = kzalloc(size, GFP_KERNEL);
1853         if (!lp->tx_skb)
1854                 goto err_out;
1855         size = XEMACPS_RECV_BD_CNT * sizeof(struct ring_info);
1856         lp->rx_skb = kzalloc(size, GFP_KERNEL);
1857         if (!lp->rx_skb)
1858                 goto err_out;
1859
1860         size = XEMACPS_RECV_BD_CNT * sizeof(struct xemacps_bd);
1861         lp->rx_bd = dma_alloc_coherent(&lp->pdev->dev, size,
1862                         &lp->rx_bd_dma, GFP_KERNEL);
1863         if (!lp->rx_bd)
1864                 goto err_out;
1865         dev_dbg(&lp->pdev->dev, "RX ring %d bytes at 0x%x mapped %p\n",
1866                         size, lp->rx_bd_dma, lp->rx_bd);
1867
1868         size = XEMACPS_SEND_BD_CNT * sizeof(struct xemacps_bd);
1869         lp->tx_bd = dma_alloc_coherent(&lp->pdev->dev, size,
1870                         &lp->tx_bd_dma, GFP_KERNEL);
1871         if (!lp->tx_bd)
1872                 goto err_out;
1873         dev_dbg(&lp->pdev->dev, "TX ring %d bytes at 0x%x mapped %p\n",
1874                         size, lp->tx_bd_dma, lp->tx_bd);
1875
1876         dev_dbg(&lp->pdev->dev,
1877                 "lp->tx_bd %p lp->tx_bd_dma %p lp->tx_skb %p\n",
1878                 lp->tx_bd, (void *)lp->tx_bd_dma, lp->tx_skb);
1879         dev_dbg(&lp->pdev->dev,
1880                 "lp->rx_bd %p lp->rx_bd_dma %p lp->rx_skb %p\n",
1881                 lp->rx_bd, (void *)lp->rx_bd_dma, lp->rx_skb);
1882
1883         return 0;
1884
1885 err_out:
1886         xemacps_descriptor_free(lp);
1887         return -ENOMEM;
1888 }
1889
1890 /**
1891  * xemacps_setup_ring - Setup both TX and RX BD rings
1892  * @lp: local device instance pointer
1893  * return 0 on success, negative value if error
1894  **/
1895 static int xemacps_setup_ring(struct net_local *lp)
1896 {
1897         int i;
1898         u32 regval;
1899         struct xemacps_bd *bdptr;
1900
1901         lp->rx_ring.separation   = (sizeof(struct xemacps_bd) +
1902                 (ALIGNMENT_BD - 1)) & ~(ALIGNMENT_BD - 1);
1903         lp->rx_ring.physbaseaddr = lp->rx_bd_dma;
1904         lp->rx_ring.firstbdaddr  = (u32)lp->rx_bd;
1905         lp->rx_ring.lastbdaddr   = (u32)(lp->rx_bd +
1906                 (XEMACPS_RECV_BD_CNT - 1) * sizeof(struct xemacps_bd));
1907         lp->rx_ring.length       = lp->rx_ring.lastbdaddr -
1908                 lp->rx_ring.firstbdaddr + lp->rx_ring.separation;
1909         lp->rx_ring.freehead     = (struct xemacps_bd *)lp->rx_bd;
1910         lp->rx_ring.prehead      = (struct xemacps_bd *)lp->rx_bd;
1911         lp->rx_ring.hwhead       = (struct xemacps_bd *)lp->rx_bd;
1912         lp->rx_ring.hwtail       = (struct xemacps_bd *)lp->rx_bd;
1913         lp->rx_ring.posthead     = (struct xemacps_bd *)lp->rx_bd;
1914         lp->rx_ring.allcnt       = XEMACPS_RECV_BD_CNT;
1915         lp->rx_ring.freecnt      = XEMACPS_RECV_BD_CNT;
1916         lp->rx_ring.precnt       = 0;
1917         lp->rx_ring.hwcnt        = 0;
1918         lp->rx_ring.postcnt      = 0;
1919         lp->rx_ring.is_rx        = 1;
1920
1921         bdptr = (struct xemacps_bd *)lp->rx_ring.firstbdaddr;
1922
1923         /* Setup RX BD ring structure and populate buffer address. */
1924         for (i = 0; i < (XEMACPS_RECV_BD_CNT - 1); i++) {
1925                 xemacps_write(bdptr, XEMACPS_BD_STAT_OFFSET, 0);
1926                 xemacps_write(bdptr, XEMACPS_BD_ADDR_OFFSET, 0);
1927                 bdptr = XEMACPS_BDRING_NEXT(&lp->rx_ring, bdptr);
1928         }
1929         /* wrap bit set for last BD, bdptr is moved to last here */
1930         xemacps_write(bdptr, XEMACPS_BD_STAT_OFFSET, 0);
1931         xemacps_write(bdptr, XEMACPS_BD_ADDR_OFFSET, XEMACPS_RXBUF_WRAP_MASK);
1932
1933         /* Allocate RX skbuffs; set descriptor buffer addresses */
1934         xemacps_DmaSetupRecvBuffers(lp->ndev);
1935
1936         lp->tx_ring.separation   = (sizeof(struct xemacps_bd) +
1937                 (ALIGNMENT_BD - 1)) & ~(ALIGNMENT_BD - 1);
1938         lp->tx_ring.physbaseaddr = lp->tx_bd_dma;
1939         lp->tx_ring.firstbdaddr  = (u32)lp->tx_bd;
1940         lp->tx_ring.lastbdaddr   = (u32)(lp->tx_bd +
1941                 (XEMACPS_SEND_BD_CNT - 1) * sizeof(struct xemacps_bd));
1942         lp->tx_ring.length       = lp->tx_ring.lastbdaddr -
1943                 lp->tx_ring.firstbdaddr + lp->tx_ring.separation;
1944         lp->tx_ring.freehead     = (struct xemacps_bd *)lp->tx_bd;
1945         lp->tx_ring.prehead      = (struct xemacps_bd *)lp->tx_bd;
1946         lp->tx_ring.hwhead       = (struct xemacps_bd *)lp->tx_bd;
1947         lp->tx_ring.hwtail       = (struct xemacps_bd *)lp->tx_bd;
1948         lp->tx_ring.posthead     = (struct xemacps_bd *)lp->tx_bd;
1949         lp->tx_ring.allcnt       = XEMACPS_SEND_BD_CNT;
1950         lp->tx_ring.freecnt      = XEMACPS_SEND_BD_CNT;
1951         lp->tx_ring.precnt       = 0;
1952         lp->tx_ring.hwcnt        = 0;
1953         lp->tx_ring.postcnt      = 0;
1954         lp->tx_ring.is_rx        = 0;
1955
1956         bdptr = (struct xemacps_bd *)lp->tx_ring.firstbdaddr;
1957
1958         /* Setup TX BD ring structure and assert used bit initially. */
1959         for (i = 0; i < (XEMACPS_SEND_BD_CNT - 1); i++) {
1960                 xemacps_write(bdptr, XEMACPS_BD_ADDR_OFFSET, 0);
1961                 xemacps_write(bdptr, XEMACPS_BD_STAT_OFFSET,
1962                         XEMACPS_TXBUF_USED_MASK);
1963                 bdptr = XEMACPS_BDRING_NEXT(&lp->tx_ring, bdptr);
1964         }
1965         /* wrap bit set for last BD, bdptr is moved to last here */
1966         xemacps_write(bdptr, XEMACPS_BD_ADDR_OFFSET, 0);
1967         regval = (XEMACPS_TXBUF_WRAP_MASK | XEMACPS_TXBUF_USED_MASK);
1968         xemacps_write(bdptr, XEMACPS_BD_STAT_OFFSET, regval);
1969
1970         return 0;
1971 }
1972
1973 #ifdef CONFIG_XILINX_PS_EMAC_HWTSTAMP
1974 /*
1975  * Initialize the GEM Time Stamp Unit
1976  */
1977 static void xemacps_init_tsu(struct net_local *lp)
1978 {
1979
1980         memset(&lp->cycles, 0, sizeof(lp->cycles));
1981         lp->cycles.read = xemacps_read_clock;
1982         lp->cycles.mask = CLOCKSOURCE_MASK(64);
1983         lp->cycles.mult = 1;
1984         lp->cycles.shift = 0;
1985
1986         /* Set registers so that rollover occurs soon to test this. */
1987         xemacps_write(lp->baseaddr, XEMACPS_1588NS_OFFSET, 0x00000000);
1988         xemacps_write(lp->baseaddr, XEMACPS_1588S_OFFSET, 0xFF800000);
1989
1990         /* program the timer increment register with the numer of nanoseconds
1991          * per clock tick.
1992          *
1993          * Note: The value is calculated based on the current operating
1994          * frequency 50MHz
1995          */
1996         xemacps_write(lp->baseaddr, XEMACPS_1588INC_OFFSET,
1997                         (NS_PER_SEC/lp->ptpenetclk));
1998
1999         timecounter_init(&lp->clock, &lp->cycles,
2000                                 ktime_to_ns(ktime_get_real()));
2001         /*
2002          * Synchronize our NIC clock against system wall clock.
2003          */
2004         memset(&lp->compare, 0, sizeof(lp->compare));
2005         lp->compare.source = &lp->clock;
2006         lp->compare.target = ktime_get_real;
2007         lp->compare.num_samples = 10;
2008         timecompare_update(&lp->compare, 0);
2009
2010         /* Initialize hwstamp config */
2011         lp->hwtstamp_config.rx_filter = HWTSTAMP_FILTER_NONE;
2012         lp->hwtstamp_config.tx_type = HWTSTAMP_TX_OFF;
2013
2014 }
2015 #endif /* CONFIG_XILINX_PS_EMAC_HWTSTAMP */
2016
2017 /**
2018  * xemacps_init_hw - Initialize hardware to known good state
2019  * @lp: local device instance pointer
2020  **/
2021 static void xemacps_init_hw(struct net_local *lp)
2022 {
2023         u32 regval;
2024
2025         xemacps_reset_hw(lp);
2026         xemacps_set_hwaddr(lp);
2027
2028         /* network configuration */
2029         regval  = 0;
2030         regval |= XEMACPS_NWCFG_FDEN_MASK;
2031         regval |= XEMACPS_NWCFG_RXCHKSUMEN_MASK;
2032         regval |= XEMACPS_NWCFG_PAUSECOPYDI_MASK;
2033         regval |= XEMACPS_NWCFG_FCSREM_MASK;
2034         regval |= XEMACPS_NWCFG_PAUSEEN_MASK;
2035         regval |= XEMACPS_NWCFG_100_MASK;
2036         regval |= XEMACPS_NWCFG_HDRXEN_MASK;
2037
2038         if (lp->board_type == BOARD_TYPE_ZYNQ)
2039                 regval |= (MDC_DIV_224 << XEMACPS_NWCFG_MDC_SHIFT_MASK);
2040         if (lp->ndev->flags & IFF_PROMISC)      /* copy all */
2041                 regval |= XEMACPS_NWCFG_COPYALLEN_MASK;
2042         if (!(lp->ndev->flags & IFF_BROADCAST)) /* No broadcast */
2043                 regval |= XEMACPS_NWCFG_BCASTDI_MASK;
2044         xemacps_write(lp->baseaddr, XEMACPS_NWCFG_OFFSET, regval);
2045
2046         /* Init TX and RX DMA Q address */
2047         xemacps_write(lp->baseaddr, XEMACPS_RXQBASE_OFFSET,
2048                 lp->rx_ring.physbaseaddr);
2049         xemacps_write(lp->baseaddr, XEMACPS_TXQBASE_OFFSET,
2050                 lp->tx_ring.physbaseaddr);
2051
2052         /* DMACR configurations */
2053         regval  = (((XEMACPS_RX_BUF_SIZE / XEMACPS_RX_BUF_UNIT) +
2054                 ((XEMACPS_RX_BUF_SIZE % XEMACPS_RX_BUF_UNIT) ? 1 : 0)) <<
2055                 XEMACPS_DMACR_RXBUF_SHIFT);
2056         regval |= XEMACPS_DMACR_RXSIZE_MASK;
2057         regval |= XEMACPS_DMACR_TXSIZE_MASK;
2058         regval |= XEMACPS_DMACR_TCPCKSUM_MASK;
2059 #ifdef __LITTLE_ENDIAN
2060         regval &= ~XEMACPS_DMACR_ENDIAN_MASK;
2061 #endif
2062 #ifdef __BIG_ENDIAN
2063         regval |= XEMACPS_DMACR_ENDIAN_MASK;
2064 #endif
2065         regval |= XEMACPS_DMACR_BLENGTH_INCR16;
2066         xemacps_write(lp->baseaddr, XEMACPS_DMACR_OFFSET, regval);
2067
2068         /* Enable TX, RX and MDIO port */
2069         regval  = 0;
2070         regval |= XEMACPS_NWCTRL_MDEN_MASK;
2071         regval |= XEMACPS_NWCTRL_TXEN_MASK;
2072         regval |= XEMACPS_NWCTRL_RXEN_MASK;
2073         xemacps_write(lp->baseaddr, XEMACPS_NWCTRL_OFFSET, regval);
2074
2075 #ifdef CONFIG_XILINX_PS_EMAC_HWTSTAMP
2076         /* Initialize the Time Stamp Unit */
2077         xemacps_init_tsu(lp);
2078 #endif
2079
2080         /* Enable interrupts */
2081         regval  = XEMACPS_IXR_ALL_MASK;
2082         xemacps_write(lp->baseaddr, XEMACPS_IER_OFFSET, regval);
2083 }
2084
2085 /**
2086  * xemacps_open - Called when a network device is made active
2087  * @ndev: network interface device structure
2088  * return 0 on success, negative value if error
2089  *
2090  * The open entry point is called when a network interface is made active
2091  * by the system (IFF_UP). At this point all resources needed for transmit
2092  * and receive operations are allocated, the interrupt handler is
2093  * registered with OS, the watchdog timer is started, and the stack is
2094  * notified that the interface is ready.
2095  *
2096  * note: if error(s), allocated resources before error require to be
2097  * released or system issues (such as memory) leak might happen.
2098  **/
2099 static int xemacps_open(struct net_device *ndev)
2100 {
2101         struct net_local *lp = netdev_priv(ndev);
2102         int rc;
2103
2104         dev_dbg(&lp->pdev->dev, "open\n");
2105         if (!is_valid_ether_addr(ndev->dev_addr))
2106                 return  -EADDRNOTAVAIL;
2107
2108         rc = xemacps_descriptor_init(lp);
2109         if (rc) {
2110                 dev_err(&lp->pdev->dev,
2111                         "Unable to allocate DMA memory, rc %d\n", rc);
2112                 return rc;
2113         }
2114
2115         rc = pm_runtime_get(&lp->pdev->dev);
2116         if (rc < 0) {
2117                 dev_err(&lp->pdev->dev, "pm_runtime_get() failed, rc %d\n", rc);
2118                 goto err_free_rings;
2119         }
2120
2121         rc = xemacps_setup_ring(lp);
2122         if (rc) {
2123                 dev_err(&lp->pdev->dev,
2124                         "Unable to setup BD rings, rc %d\n", rc);
2125                 goto err_pm_put;
2126         }
2127
2128         xemacps_init_hw(lp);
2129         napi_enable(&lp->napi);
2130         rc = xemacps_mii_probe(ndev);
2131         if (rc != 0) {
2132                 dev_err(&lp->pdev->dev,
2133                         "%s mii_probe fail.\n", lp->mii_bus->name);
2134                 if (rc == (-2)) {
2135                         mdiobus_unregister(lp->mii_bus);
2136                         kfree(lp->mii_bus->irq);
2137                         mdiobus_free(lp->mii_bus);
2138                 }
2139                 rc = -ENXIO;
2140                 goto err_pm_put;
2141         }
2142
2143         netif_carrier_on(ndev);
2144
2145         netif_start_queue(ndev);
2146
2147         return 0;
2148
2149 err_pm_put:
2150         pm_runtime_put(&lp->pdev->dev);
2151 err_free_rings:
2152         xemacps_descriptor_free(lp);
2153
2154         return rc;
2155 }
2156
2157 /**
2158  * xemacps_close - disable a network interface
2159  * @ndev: network interface device structure
2160  * return 0
2161  *
2162  * The close entry point is called when a network interface is de-activated
2163  * by OS. The hardware is still under the driver control, but needs to be
2164  * disabled. A global MAC reset is issued to stop the hardware, and all
2165  * transmit and receive resources are freed.
2166  **/
2167 static int xemacps_close(struct net_device *ndev)
2168 {
2169         struct net_local *lp = netdev_priv(ndev);
2170         unsigned long flags;
2171
2172         netif_stop_queue(ndev);
2173         napi_disable(&lp->napi);
2174         spin_lock_irqsave(&lp->lock, flags);
2175         xemacps_reset_hw(lp);
2176         netif_carrier_off(ndev);
2177         spin_unlock_irqrestore(&lp->lock, flags);
2178         if (lp->phy_dev)
2179                 phy_disconnect(lp->phy_dev);
2180         xemacps_descriptor_free(lp);
2181
2182         pm_runtime_put(&lp->pdev->dev);
2183
2184         return 0;
2185 }
2186
2187 /**
2188  * xemacps_tx_timeout - callback uses when the transmitter has not made
2189  * any progress for dev->watchdog ticks.
2190  * @ndev: network interface device structure
2191  **/
2192 static void xemacps_tx_timeout(struct net_device *ndev)
2193 {
2194         struct net_local *lp = netdev_priv(ndev);
2195         int rc;
2196
2197         dev_err(&lp->pdev->dev, "transmit timeout %lu ms, reseting...\n",
2198                 TX_TIMEOUT * 1000UL / HZ);
2199         netif_stop_queue(ndev);
2200
2201         spin_lock(&lp->lock);
2202         napi_disable(&lp->napi);
2203         xemacps_reset_hw(lp);
2204         xemacps_descriptor_free(lp);
2205         if (lp->phy_dev)
2206                 phy_stop(lp->phy_dev);
2207         rc = xemacps_descriptor_init(lp);
2208         if (rc) {
2209                 dev_err(&lp->pdev->dev,
2210                         "Unable to allocate DMA memory, rc %d\n", rc);
2211                 spin_unlock(&lp->lock);
2212                 return;
2213         }
2214
2215         rc = xemacps_setup_ring(lp);
2216         if (rc) {
2217                 dev_err(&lp->pdev->dev, "Unable to setup BD rings, rc %d\n",
2218                                                                         rc);
2219                 spin_unlock(&lp->lock);
2220                 return;
2221         }
2222         xemacps_init_hw(lp);
2223
2224         lp->link    = 0;
2225         lp->speed   = 0;
2226         lp->duplex  = -1;
2227         if (lp->phy_dev)
2228                 phy_start(lp->phy_dev);
2229         napi_enable(&lp->napi);
2230
2231         spin_unlock(&lp->lock);
2232         netif_start_queue(ndev);
2233 }
2234
2235 /**
2236  * xemacps_set_mac_address - set network interface mac address
2237  * @ndev: network interface device structure
2238  * @addr: pointer to MAC address
2239  * return 0 on success, negative value if error
2240  **/
2241 static int xemacps_set_mac_address(struct net_device *ndev, void *addr)
2242 {
2243         struct net_local *lp = netdev_priv(ndev);
2244         struct sockaddr *hwaddr = (struct sockaddr *)addr;
2245
2246         if (netif_running(ndev))
2247                 return -EBUSY;
2248
2249         if (!is_valid_ether_addr(hwaddr->sa_data))
2250                 return -EADDRNOTAVAIL;
2251
2252         dev_dbg(&lp->pdev->dev, "hwaddr 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
2253                 hwaddr->sa_data[0], hwaddr->sa_data[1], hwaddr->sa_data[2],
2254                 hwaddr->sa_data[3], hwaddr->sa_data[4], hwaddr->sa_data[5]);
2255
2256         memcpy(ndev->dev_addr, hwaddr->sa_data, ndev->addr_len);
2257
2258         xemacps_set_hwaddr(lp);
2259         return 0;
2260 }
2261
2262 /**
2263  * xemacps_start_xmit - transmit a packet (called by kernel)
2264  * @skb: socket buffer
2265  * @ndev: network interface device structure
2266  * return 0 on success, other value if error
2267  **/
2268 static int xemacps_start_xmit(struct sk_buff *skb, struct net_device *ndev)
2269 {
2270         struct net_local *lp = netdev_priv(ndev);
2271         dma_addr_t  mapping;
2272         unsigned int nr_frags, bdidx, len;
2273         int i, rc;
2274         u32 regval;
2275         struct xemacps_bd *bdptr, *bdptrs;
2276         void       *virt_addr;
2277         skb_frag_t *frag;
2278
2279 #ifdef DEBUG_VERBOSE_TX
2280         dev_dbg(&lp->pdev->dev, "%s: TX data:", __func__);
2281         for (i = 0; i < 48; i++) {
2282                 if (!(i % 16))
2283                         dev_dbg(&lp->pdev->dev, "\n");
2284                 dev_dbg(&lp->pdev->dev, " %02x", (unsigned int)skb->data[i]);
2285         }
2286         dev_dbg(&lp->pdev->dev, "\n");
2287 #endif
2288
2289         nr_frags = skb_shinfo(skb)->nr_frags + 1;
2290         spin_lock_irq(&lp->lock);
2291
2292         if (nr_frags < lp->tx_ring.freecnt) {
2293                 rc = xemacps_bdringalloc(&lp->tx_ring, nr_frags, &bdptr);
2294                 if (rc) {
2295                         netif_stop_queue(ndev); /* stop send queue */
2296                         spin_unlock_irq(&lp->lock);
2297                         return rc;
2298                 }
2299         } else {
2300                 netif_stop_queue(ndev); /* stop send queue */
2301                 spin_unlock_irq(&lp->lock);
2302                 return NETDEV_TX_BUSY;
2303         }
2304
2305         frag = &skb_shinfo(skb)->frags[0];
2306         bdptrs = bdptr;
2307
2308 #ifdef DEBUG_VERBOSE_TX
2309         dev_dbg(&lp->pdev->dev,
2310                 "TX nr_frags %d, skb->len 0x%x, skb_headlen(skb) 0x%x\n",
2311                 nr_frags, skb->len, skb_headlen(skb));
2312 #endif
2313
2314         for (i = 0; i < nr_frags; i++) {
2315                 if (i == 0) {
2316                         len = skb_headlen(skb);
2317                         mapping = dma_map_single(&lp->pdev->dev, skb->data,
2318                                 len, DMA_TO_DEVICE);
2319                 } else {
2320                         len = skb_frag_size(frag);
2321                         virt_addr = skb_frag_address(frag);
2322                         mapping = dma_map_single(&lp->pdev->dev, virt_addr,
2323                                 len, DMA_TO_DEVICE);
2324                         frag++;
2325                 }
2326
2327                 bdidx = XEMACPS_BD_TO_INDEX(&lp->tx_ring, bdptr);
2328
2329                 lp->tx_skb[bdidx].skb = skb;
2330                 lp->tx_skb[bdidx].mapping = mapping;
2331                 wmb();
2332
2333                 xemacps_write(bdptr, XEMACPS_BD_ADDR_OFFSET, mapping);
2334                 wmb();
2335
2336                 regval = xemacps_read(bdptr, XEMACPS_BD_STAT_OFFSET);
2337                 /* Preserve only critical status bits.  Packet is NOT to be
2338                  * committed to hardware at this time.
2339                  */
2340                 regval &= (XEMACPS_TXBUF_USED_MASK | XEMACPS_TXBUF_WRAP_MASK);
2341                 /* update length field */
2342                 regval |= ((regval & ~XEMACPS_TXBUF_LEN_MASK) | len);
2343                 /* last fragment of this packet? */
2344                 if (i == (nr_frags - 1))
2345                         regval |= XEMACPS_TXBUF_LAST_MASK;
2346                 xemacps_write(bdptr, XEMACPS_BD_STAT_OFFSET, regval);
2347
2348 #ifdef DEBUG_VERBOSE_TX
2349                 dev_dbg(&lp->pdev->dev,
2350                                 "TX BD index %d, BDptr %p, BD_STAT 0x%08x\n",
2351                                 bdidx, bdptr, regval);
2352 #endif
2353                 bdptr = XEMACPS_BDRING_NEXT(&lp->tx_ring, bdptr);
2354         }
2355         wmb();
2356
2357         rc = xemacps_bdringtohw(&lp->tx_ring, nr_frags, bdptrs);
2358
2359         if (rc) {
2360                 netif_stop_queue(ndev);
2361                 dev_kfree_skb(skb);
2362                 lp->stats.tx_dropped++;
2363                 xemacps_bdringunalloc(&lp->tx_ring, nr_frags, bdptrs);
2364                 dev_err(&lp->pdev->dev, "cannot send, commit TX buffer desc\n");
2365                 spin_unlock_irq(&lp->lock);
2366                 return rc;
2367         } else {
2368                 regval = xemacps_read(lp->baseaddr, XEMACPS_NWCTRL_OFFSET);
2369                 xemacps_write(lp->baseaddr, XEMACPS_NWCTRL_OFFSET,
2370                         (regval | XEMACPS_NWCTRL_STARTTX_MASK));
2371         }
2372
2373         spin_unlock_irq(&lp->lock);
2374         ndev->trans_start = jiffies;
2375
2376         return rc;
2377 }
2378
2379 /*
2380  * Get the MAC Address bit from the specified position
2381  */
2382 static unsigned get_bit(u8 *mac, unsigned bit)
2383 {
2384         unsigned byte;
2385
2386         byte = mac[bit / 8];
2387         byte >>= (bit & 0x7);
2388         byte &= 1;
2389
2390         return byte;
2391 }
2392
2393 /*
2394  * Calculate a GEM MAC Address hash index
2395  */
2396 static unsigned calc_mac_hash(u8 *mac)
2397 {
2398         int index_bit, mac_bit;
2399         unsigned hash_index;
2400
2401         hash_index = 0;
2402         mac_bit = 5;
2403         for (index_bit = 5; index_bit >= 0; index_bit--) {
2404                 hash_index |= (get_bit(mac,  mac_bit) ^
2405                                         get_bit(mac, mac_bit + 6) ^
2406                                         get_bit(mac, mac_bit + 12) ^
2407                                         get_bit(mac, mac_bit + 18) ^
2408                                         get_bit(mac, mac_bit + 24) ^
2409                                         get_bit(mac, mac_bit + 30) ^
2410                                         get_bit(mac, mac_bit + 36) ^
2411                                         get_bit(mac, mac_bit + 42))
2412                                                 << index_bit;
2413                 mac_bit--;
2414         }
2415
2416         return hash_index;
2417 }
2418
2419 /**
2420  * xemacps_set_hashtable - Add multicast addresses to the internal
2421  * multicast-hash table. Called from xemac_set_rx_mode().
2422  * @ndev: network interface device structure
2423  *
2424  * The hash address register is 64 bits long and takes up two
2425  * locations in the memory map.  The least significant bits are stored
2426  * in EMAC_HSL and the most significant bits in EMAC_HSH.
2427  *
2428  * The unicast hash enable and the multicast hash enable bits in the
2429  * network configuration register enable the reception of hash matched
2430  * frames. The destination address is reduced to a 6 bit index into
2431  * the 64 bit hash register using the following hash function.  The
2432  * hash function is an exclusive or of every sixth bit of the
2433  * destination address.
2434  *
2435  * hi[5] = da[5] ^ da[11] ^ da[17] ^ da[23] ^ da[29] ^ da[35] ^ da[41] ^ da[47]
2436  * hi[4] = da[4] ^ da[10] ^ da[16] ^ da[22] ^ da[28] ^ da[34] ^ da[40] ^ da[46]
2437  * hi[3] = da[3] ^ da[09] ^ da[15] ^ da[21] ^ da[27] ^ da[33] ^ da[39] ^ da[45]
2438  * hi[2] = da[2] ^ da[08] ^ da[14] ^ da[20] ^ da[26] ^ da[32] ^ da[38] ^ da[44]
2439  * hi[1] = da[1] ^ da[07] ^ da[13] ^ da[19] ^ da[25] ^ da[31] ^ da[37] ^ da[43]
2440  * hi[0] = da[0] ^ da[06] ^ da[12] ^ da[18] ^ da[24] ^ da[30] ^ da[36] ^ da[42]
2441  *
2442  * da[0] represents the least significant bit of the first byte
2443  * received, that is, the multicast/unicast indicator, and da[47]
2444  * represents the most significant bit of the last byte received.  If
2445  * the hash index, hi[n], points to a bit that is set in the hash
2446  * register then the frame will be matched according to whether the
2447  * frame is multicast or unicast.  A multicast match will be signalled
2448  * if the multicast hash enable bit is set, da[0] is 1 and the hash
2449  * index points to a bit set in the hash register.  A unicast match
2450  * will be signalled if the unicast hash enable bit is set, da[0] is 0
2451  * and the hash index points to a bit set in the hash register.  To
2452  * receive all multicast frames, the hash register should be set with
2453  * all ones and the multicast hash enable bit should be set in the
2454  * network configuration register.
2455  **/
2456 static void xemacps_set_hashtable(struct net_device *ndev)
2457 {
2458         struct netdev_hw_addr *curr;
2459         u32 regvalh, regvall, hash_index;
2460         u8 *mc_addr;
2461         struct net_local *lp;
2462
2463         lp = netdev_priv(ndev);
2464
2465         regvalh = regvall = 0;
2466
2467         netdev_for_each_mc_addr(curr, ndev) {
2468                 if (!curr)      /* end of list */
2469                         break;
2470                 mc_addr = curr->addr;
2471                 hash_index = calc_mac_hash(mc_addr);
2472
2473                 if (hash_index >= XEMACPS_MAX_HASH_BITS) {
2474                         dev_err(&lp->pdev->dev,
2475                                         "hash calculation out of range %d\n",
2476                                         hash_index);
2477                         break;
2478                 }
2479                 if (hash_index < 32)
2480                         regvall |= (1 << hash_index);
2481                 else
2482                         regvalh |= (1 << (hash_index - 32));
2483         }
2484
2485         xemacps_write(lp->baseaddr, XEMACPS_HASHL_OFFSET, regvall);
2486         xemacps_write(lp->baseaddr, XEMACPS_HASHH_OFFSET, regvalh);
2487 }
2488
2489 /**
2490  * xemacps_set_rx_mode - enable/disable promiscuous and multicast modes
2491  * @ndev: network interface device structure
2492  **/
2493 static void xemacps_set_rx_mode(struct net_device *ndev)
2494 {
2495         struct net_local *lp = netdev_priv(ndev);
2496         u32 regval;
2497
2498         regval = xemacps_read(lp->baseaddr, XEMACPS_NWCFG_OFFSET);
2499
2500         /* promisc mode */
2501         if (ndev->flags & IFF_PROMISC)
2502                 regval |= XEMACPS_NWCFG_COPYALLEN_MASK;
2503         if (!(ndev->flags & IFF_PROMISC))
2504                 regval &= ~XEMACPS_NWCFG_COPYALLEN_MASK;
2505
2506         /* All multicast mode */
2507         if (ndev->flags & IFF_ALLMULTI) {
2508                 regval |= XEMACPS_NWCFG_MCASTHASHEN_MASK;
2509                 xemacps_write(lp->baseaddr, XEMACPS_HASHL_OFFSET, ~0UL);
2510                 xemacps_write(lp->baseaddr, XEMACPS_HASHH_OFFSET, ~0UL);
2511         /* Specific multicast mode */
2512         } else if ((ndev->flags & IFF_MULTICAST)
2513                         && (netdev_mc_count(ndev) > 0)) {
2514                 regval |= XEMACPS_NWCFG_MCASTHASHEN_MASK;
2515                 xemacps_set_hashtable(ndev);
2516         /* Disable multicast mode */
2517         } else {
2518                 xemacps_write(lp->baseaddr, XEMACPS_HASHL_OFFSET, 0x0);
2519                 xemacps_write(lp->baseaddr, XEMACPS_HASHH_OFFSET, 0x0);
2520                 regval &= ~XEMACPS_NWCFG_MCASTHASHEN_MASK;
2521         }
2522
2523         /* broadcast mode */
2524         if (ndev->flags & IFF_BROADCAST)
2525                 regval &= ~XEMACPS_NWCFG_BCASTDI_MASK;
2526         /* No broadcast */
2527         if (!(ndev->flags & IFF_BROADCAST))
2528                 regval |= XEMACPS_NWCFG_BCASTDI_MASK;
2529
2530         xemacps_write(lp->baseaddr, XEMACPS_NWCFG_OFFSET, regval);
2531 }
2532
2533 #define MIN_MTU 60
2534 #define MAX_MTU 1500
2535 /**
2536  * xemacps_change_mtu - Change maximum transfer unit
2537  * @ndev: network interface device structure
2538  * @new_mtu: new vlaue for maximum frame size
2539  * return: 0 on success, negative value if error.
2540  **/
2541 static int xemacps_change_mtu(struct net_device *ndev, int new_mtu)
2542 {
2543         if ((new_mtu < MIN_MTU) ||
2544                 ((new_mtu + ndev->hard_header_len) > MAX_MTU))
2545                 return -EINVAL;
2546
2547         ndev->mtu = new_mtu;    /* change mtu in net_device structure */
2548         return 0;
2549 }
2550
2551 /**
2552  * xemacps_get_settings - get device specific settings.
2553  * Usage: Issue "ethtool ethX" under linux prompt.
2554  * @ndev: network device
2555  * @ecmd: ethtool command structure
2556  * return: 0 on success, negative value if error.
2557  **/
2558 static int
2559 xemacps_get_settings(struct net_device *ndev, struct ethtool_cmd *ecmd)
2560 {
2561         struct net_local *lp = netdev_priv(ndev);
2562         struct phy_device *phydev = lp->phy_dev;
2563
2564         if (!phydev)
2565                 return -ENODEV;
2566
2567         return phy_ethtool_gset(phydev, ecmd);
2568 }
2569
2570 /**
2571  * xemacps_set_settings - set device specific settings.
2572  * Usage: Issue "ethtool -s ethX speed 1000" under linux prompt
2573  * to change speed
2574  * @ndev: network device
2575  * @ecmd: ethtool command structure
2576  * return: 0 on success, negative value if error.
2577  **/
2578 static int
2579 xemacps_set_settings(struct net_device *ndev, struct ethtool_cmd *ecmd)
2580 {
2581         struct net_local *lp = netdev_priv(ndev);
2582         struct phy_device *phydev = lp->phy_dev;
2583
2584         if (!phydev)
2585                 return -ENODEV;
2586
2587         return phy_ethtool_sset(phydev, ecmd);
2588 }
2589
2590 /**
2591  * xemacps_get_drvinfo - report driver information
2592  * Usage: Issue "ethtool -i ethX" under linux prompt
2593  * @ndev: network device
2594  * @ed: device driver information structure
2595  **/
2596 static void
2597 xemacps_get_drvinfo(struct net_device *ndev, struct ethtool_drvinfo *ed)
2598 {
2599         struct net_local *lp = netdev_priv(ndev);
2600
2601         memset(ed, 0, sizeof(struct ethtool_drvinfo));
2602         strcpy(ed->driver, lp->pdev->dev.driver->name);
2603         strcpy(ed->version, DRIVER_VERSION);
2604 }
2605
2606 /**
2607  * xemacps_get_ringparam - get device dma ring information.
2608  * Usage: Issue "ethtool -g ethX" under linux prompt
2609  * @ndev: network device
2610  * @erp: ethtool ring parameter structure
2611  **/
2612 static void
2613 xemacps_get_ringparam(struct net_device *ndev, struct ethtool_ringparam *erp)
2614 {
2615         struct net_local *lp = netdev_priv(ndev);
2616         memset(erp, 0, sizeof(struct ethtool_ringparam));
2617
2618         erp->rx_max_pending = XEMACPS_RECV_BD_CNT;
2619         erp->tx_max_pending = XEMACPS_SEND_BD_CNT;
2620         erp->rx_pending = lp->rx_ring.hwcnt;
2621         erp->tx_pending = lp->tx_ring.hwcnt;
2622 }
2623
2624 /**
2625  * xemacps_get_wol - get device wake on lan status
2626  * Usage: Issue "ethtool ethX" under linux prompt
2627  * @ndev: network device
2628  * @ewol: wol status
2629  **/
2630 static void
2631 xemacps_get_wol(struct net_device *ndev, struct ethtool_wolinfo *ewol)
2632 {
2633         struct net_local *lp = netdev_priv(ndev);
2634         unsigned long flags;
2635         u32 regval;
2636
2637         ewol->supported = WAKE_MAGIC | WAKE_ARP | WAKE_UCAST | WAKE_MCAST;
2638         spin_lock_irqsave(&lp->lock, flags);
2639         regval = xemacps_read(lp->baseaddr, XEMACPS_WOL_OFFSET);
2640         if (regval | XEMACPS_WOL_MCAST_MASK)
2641                 ewol->wolopts |= WAKE_MCAST;
2642         if (regval | XEMACPS_WOL_ARP_MASK)
2643                 ewol->wolopts |= WAKE_ARP;
2644         if (regval | XEMACPS_WOL_SPEREG1_MASK)
2645                 ewol->wolopts |= WAKE_UCAST;
2646         if (regval | XEMACPS_WOL_MAGIC_MASK)
2647                 ewol->wolopts |= WAKE_MAGIC;
2648         spin_unlock_irqrestore(&lp->lock, flags);
2649 }
2650
2651 /**
2652  * xemacps_set_wol - set device wake on lan configuration
2653  * Usage: Issue "ethtool -s ethX wol u|m|b|g" under linux prompt to enable
2654  * specified type of packet.
2655  * Usage: Issue "ethtool -s ethX wol d" under linux prompt to disable
2656  * this feature.
2657  * @ndev: network device
2658  * @ewol: wol status
2659  * return 0 on success, negative value if not supported
2660  **/
2661 static int
2662 xemacps_set_wol(struct net_device *ndev, struct ethtool_wolinfo *ewol)
2663 {
2664         struct net_local *lp = netdev_priv(ndev);
2665         unsigned long flags;
2666         u32 regval;
2667
2668         if (ewol->wolopts & ~(WAKE_MAGIC | WAKE_ARP | WAKE_UCAST | WAKE_MCAST))
2669                 return -EOPNOTSUPP;
2670
2671         spin_lock_irqsave(&lp->lock, flags);
2672         regval  = xemacps_read(lp->baseaddr, XEMACPS_WOL_OFFSET);
2673         regval &= ~(XEMACPS_WOL_MCAST_MASK | XEMACPS_WOL_ARP_MASK |
2674                 XEMACPS_WOL_SPEREG1_MASK | XEMACPS_WOL_MAGIC_MASK);
2675
2676         if (ewol->wolopts & WAKE_MAGIC)
2677                 regval |= XEMACPS_WOL_MAGIC_MASK;
2678         if (ewol->wolopts & WAKE_ARP)
2679                 regval |= XEMACPS_WOL_ARP_MASK;
2680         if (ewol->wolopts & WAKE_UCAST)
2681                 regval |= XEMACPS_WOL_SPEREG1_MASK;
2682         if (ewol->wolopts & WAKE_MCAST)
2683                 regval |= XEMACPS_WOL_MCAST_MASK;
2684
2685         xemacps_write(lp->baseaddr, XEMACPS_WOL_OFFSET, regval);
2686         spin_unlock_irqrestore(&lp->lock, flags);
2687
2688         return 0;
2689 }
2690
2691 /**
2692  * xemacps_get_pauseparam - get device pause status
2693  * Usage: Issue "ethtool -a ethX" under linux prompt
2694  * @ndev: network device
2695  * @epauseparam: pause parameter
2696  *
2697  * note: hardware supports only tx flow control
2698  **/
2699 static void
2700 xemacps_get_pauseparam(struct net_device *ndev,
2701                 struct ethtool_pauseparam *epauseparm)
2702 {
2703         struct net_local *lp = netdev_priv(ndev);
2704         unsigned long flags;
2705         u32 regval;
2706
2707         epauseparm->autoneg  = 0;
2708         epauseparm->rx_pause = 0;
2709
2710         spin_lock_irqsave(&lp->lock, flags);
2711         regval = xemacps_read(lp->baseaddr, XEMACPS_NWCFG_OFFSET);
2712         epauseparm->tx_pause = regval & XEMACPS_NWCFG_PAUSEEN_MASK;
2713         spin_unlock_irqrestore(&lp->lock, flags);
2714 }
2715
2716 /**
2717  * xemacps_set_pauseparam - set device pause parameter(flow control)
2718  * Usage: Issue "ethtool -A ethX tx on|off" under linux prompt
2719  * @ndev: network device
2720  * @epauseparam: pause parameter
2721  * return 0 on success, negative value if not supported
2722  *
2723  * note: hardware supports only tx flow control
2724  **/
2725 static int
2726 xemacps_set_pauseparam(struct net_device *ndev,
2727                 struct ethtool_pauseparam *epauseparm)
2728 {
2729         struct net_local *lp = netdev_priv(ndev);
2730         unsigned long flags;
2731         u32 regval;
2732
2733         if (netif_running(ndev)) {
2734                 dev_err(&lp->pdev->dev,
2735                         "Please stop netif before apply configruation\n");
2736                 return -EFAULT;
2737         }
2738
2739         spin_lock_irqsave(&lp->lock, flags);
2740         regval = xemacps_read(lp->baseaddr, XEMACPS_NWCFG_OFFSET);
2741
2742         if (epauseparm->tx_pause)
2743                 regval |= XEMACPS_NWCFG_PAUSEEN_MASK;
2744         if (!(epauseparm->tx_pause))
2745                 regval &= ~XEMACPS_NWCFG_PAUSEEN_MASK;
2746
2747         xemacps_write(lp->baseaddr, XEMACPS_NWCFG_OFFSET, regval);
2748         spin_unlock_irqrestore(&lp->lock, flags);
2749
2750         return 0;
2751 }
2752
2753 /**
2754  * xemacps_get_stats - get device statistic raw data in 64bit mode
2755  * @ndev: network device
2756  **/
2757 static struct net_device_stats
2758 *xemacps_get_stats(struct net_device *ndev)
2759 {
2760         struct net_local *lp = netdev_priv(ndev);
2761         struct net_device_stats *nstat = &lp->stats;
2762
2763         nstat->rx_errors +=
2764                 (xemacps_read(lp->baseaddr, XEMACPS_RXUNDRCNT_OFFSET) +
2765                 xemacps_read(lp->baseaddr, XEMACPS_RXOVRCNT_OFFSET) +
2766                 xemacps_read(lp->baseaddr, XEMACPS_RXJABCNT_OFFSET) +
2767                 xemacps_read(lp->baseaddr, XEMACPS_RXFCSCNT_OFFSET) +
2768                 xemacps_read(lp->baseaddr, XEMACPS_RXLENGTHCNT_OFFSET) +
2769                 xemacps_read(lp->baseaddr, XEMACPS_RXALIGNCNT_OFFSET));
2770         nstat->rx_length_errors +=
2771                 (xemacps_read(lp->baseaddr, XEMACPS_RXUNDRCNT_OFFSET) +
2772                 xemacps_read(lp->baseaddr, XEMACPS_RXOVRCNT_OFFSET) +
2773                 xemacps_read(lp->baseaddr, XEMACPS_RXJABCNT_OFFSET) +
2774                 xemacps_read(lp->baseaddr, XEMACPS_RXLENGTHCNT_OFFSET));
2775         nstat->rx_over_errors +=
2776                 xemacps_read(lp->baseaddr, XEMACPS_RXORCNT_OFFSET);
2777         nstat->rx_crc_errors +=
2778                 xemacps_read(lp->baseaddr, XEMACPS_RXFCSCNT_OFFSET);
2779         nstat->rx_frame_errors +=
2780                 xemacps_read(lp->baseaddr, XEMACPS_RXALIGNCNT_OFFSET);
2781         nstat->rx_fifo_errors +=
2782                 xemacps_read(lp->baseaddr, XEMACPS_RXORCNT_OFFSET);
2783         nstat->tx_errors +=
2784                 (xemacps_read(lp->baseaddr, XEMACPS_TXURUNCNT_OFFSET) +
2785                 xemacps_read(lp->baseaddr, XEMACPS_SNGLCOLLCNT_OFFSET) +
2786                 xemacps_read(lp->baseaddr, XEMACPS_MULTICOLLCNT_OFFSET) +
2787                 xemacps_read(lp->baseaddr, XEMACPS_EXCESSCOLLCNT_OFFSET) +
2788                 xemacps_read(lp->baseaddr, XEMACPS_LATECOLLCNT_OFFSET) +
2789                 xemacps_read(lp->baseaddr, XEMACPS_CSENSECNT_OFFSET));
2790         nstat->tx_aborted_errors +=
2791                 xemacps_read(lp->baseaddr, XEMACPS_EXCESSCOLLCNT_OFFSET);
2792         nstat->tx_carrier_errors +=
2793                 xemacps_read(lp->baseaddr, XEMACPS_CSENSECNT_OFFSET);
2794         nstat->tx_fifo_errors +=
2795                 xemacps_read(lp->baseaddr, XEMACPS_TXURUNCNT_OFFSET);
2796         nstat->collisions +=
2797                 (xemacps_read(lp->baseaddr, XEMACPS_SNGLCOLLCNT_OFFSET) +
2798                 xemacps_read(lp->baseaddr, XEMACPS_MULTICOLLCNT_OFFSET) +
2799                 xemacps_read(lp->baseaddr, XEMACPS_EXCESSCOLLCNT_OFFSET) +
2800                 xemacps_read(lp->baseaddr, XEMACPS_LATECOLLCNT_OFFSET));
2801         return nstat;
2802 }
2803
2804 static struct ethtool_ops xemacps_ethtool_ops = {
2805         .get_settings   = xemacps_get_settings,
2806         .set_settings   = xemacps_set_settings,
2807         .get_drvinfo    = xemacps_get_drvinfo,
2808         .get_link       = ethtool_op_get_link, /* ethtool default */
2809         .get_ringparam  = xemacps_get_ringparam,
2810         .get_wol        = xemacps_get_wol,
2811         .set_wol        = xemacps_set_wol,
2812         .get_pauseparam = xemacps_get_pauseparam,
2813         .set_pauseparam = xemacps_set_pauseparam,
2814 };
2815
2816 #ifdef CONFIG_XILINX_PS_EMAC_HWTSTAMP
2817 static int xemacps_hwtstamp_ioctl(struct net_device *netdev,
2818                                 struct ifreq *ifr, int cmd)
2819 {
2820         struct hwtstamp_config config;
2821         struct net_local *lp;
2822         u32 regval;
2823
2824         lp = netdev_priv(netdev);
2825
2826         if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
2827                 return -EFAULT;
2828
2829         /* reserved for future extensions */
2830         if (config.flags)
2831                 return -EINVAL;
2832
2833         if ((config.tx_type != HWTSTAMP_TX_OFF) &&
2834                 (config.tx_type != HWTSTAMP_TX_ON))
2835                 return -ERANGE;
2836
2837         switch (config.rx_filter) {
2838         case HWTSTAMP_FILTER_NONE:
2839                 break;
2840         case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
2841         case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
2842         case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
2843         case HWTSTAMP_FILTER_ALL:
2844         case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
2845         case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
2846         case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
2847         case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
2848         case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
2849         case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
2850         case HWTSTAMP_FILTER_PTP_V2_EVENT:
2851         case HWTSTAMP_FILTER_PTP_V2_SYNC:
2852         case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
2853                 config.rx_filter = HWTSTAMP_FILTER_ALL;
2854                 regval = xemacps_read(lp->baseaddr, XEMACPS_NWCTRL_OFFSET);
2855                 xemacps_write(lp->baseaddr, XEMACPS_NWCTRL_OFFSET,
2856                         (regval | XEMACPS_NWCTRL_RXTSTAMP_MASK));
2857                 break;
2858         default:
2859                 return -ERANGE;
2860         }
2861
2862         config.tx_type = HWTSTAMP_TX_ON;
2863         lp->hwtstamp_config = config;
2864
2865         return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ?
2866                 -EFAULT : 0;
2867 }
2868 #endif /* CONFIG_XILINX_PS_EMAC_HWTSTAMP */
2869
2870 /**
2871  * xemacps_ioctl - ioctl entry point
2872  * @ndev: network device
2873  * @rq: interface request ioctl
2874  * @cmd: command code
2875  *
2876  * Called when user issues an ioctl request to the network device.
2877  **/
2878 static int xemacps_ioctl(struct net_device *ndev, struct ifreq *rq, int cmd)
2879 {
2880         struct net_local *lp = netdev_priv(ndev);
2881         struct phy_device *phydev = lp->phy_dev;
2882
2883         if (!netif_running(ndev))
2884                 return -EINVAL;
2885
2886         if (!phydev)
2887                 return -ENODEV;
2888
2889         switch (cmd) {
2890         case SIOCGMIIPHY:
2891         case SIOCGMIIREG:
2892         case SIOCSMIIREG:
2893                 return phy_mii_ioctl(phydev, rq, cmd);
2894 #ifdef CONFIG_XILINX_PS_EMAC_HWTSTAMP
2895         case SIOCSHWTSTAMP:
2896                 return xemacps_hwtstamp_ioctl(ndev, rq, cmd);
2897 #endif
2898         default:
2899                 dev_info(&lp->pdev->dev, "ioctl %d not implemented.\n", cmd);
2900                 return -EOPNOTSUPP;
2901         }
2902
2903 }
2904
2905 /**
2906  * xemacps_probe - Platform driver probe
2907  * @pdev: Pointer to platform device structure
2908  *
2909  * Return 0 on success, negative value if error
2910  */
2911 static int __devinit xemacps_probe(struct platform_device *pdev)
2912 {
2913         struct resource *r_mem = NULL;
2914         struct resource *r_irq = NULL;
2915         struct net_device *ndev;
2916         struct net_local *lp;
2917         struct device_node *np;
2918         const void *prop;
2919         u32 regval = 0;
2920         int rc = -ENXIO;
2921         int size = 0;
2922
2923         r_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2924         r_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
2925         if (!r_mem || !r_irq) {
2926                 dev_err(&pdev->dev, "no IO resource defined.\n");
2927                 rc = -ENXIO;
2928                 goto err_out;
2929         }
2930
2931         ndev = alloc_etherdev(sizeof(*lp));
2932         if (!ndev) {
2933                 dev_err(&pdev->dev, "etherdev allocation failed.\n");
2934                 rc = -ENOMEM;
2935                 goto err_out;
2936         }
2937
2938         SET_NETDEV_DEV(ndev, &pdev->dev);
2939
2940         lp = netdev_priv(ndev);
2941         lp->pdev = pdev;
2942         lp->ndev = ndev;
2943
2944         spin_lock_init(&lp->lock);
2945
2946         lp->baseaddr = ioremap(r_mem->start, (r_mem->end - r_mem->start + 1));
2947         if (!lp->baseaddr) {
2948                 dev_err(&pdev->dev, "failed to map baseaddress.\n");
2949                 rc = -ENOMEM;
2950                 goto err_out_free_netdev;
2951         }
2952
2953         dev_dbg(&lp->pdev->dev, "BASEADDRESS hw: %p virt: %p\n",
2954                         (void *)r_mem->start, lp->baseaddr);
2955
2956         ndev->irq = platform_get_irq(pdev, 0);
2957
2958         rc = request_irq(ndev->irq, xemacps_interrupt, 0,
2959                 ndev->name, ndev);
2960         if (rc) {
2961                 dev_err(&lp->pdev->dev, "Unable to request IRQ %p, error %d\n",
2962                                 r_irq, rc);
2963                 goto err_out_iounmap;
2964         }
2965
2966         ndev->netdev_ops = &netdev_ops;
2967         ndev->watchdog_timeo = TX_TIMEOUT;
2968         ndev->ethtool_ops = &xemacps_ethtool_ops;
2969         ndev->base_addr = r_mem->start;
2970         ndev->features = NETIF_F_IP_CSUM;
2971         netif_napi_add(ndev, &lp->napi, xemacps_rx_poll, XEMACPS_NAPI_WEIGHT);
2972
2973         lp->ip_summed = CHECKSUM_UNNECESSARY;
2974         lp->board_type = BOARD_TYPE_ZYNQ;
2975
2976         rc = register_netdev(ndev);
2977         if (rc) {
2978                 dev_err(&pdev->dev, "Cannot register net device, aborting.\n");
2979                 goto err_out_free_irq;
2980         }
2981
2982         if (ndev->irq == 54)
2983                 lp->enetnum = 0;
2984         else
2985                 lp->enetnum = 1;
2986
2987         np = of_get_next_parent(lp->pdev->dev.of_node);
2988         np = of_get_next_parent(np);
2989         prop = of_get_property(np, "compatible", NULL);
2990
2991         if (prop != NULL) {
2992                 if ((strcmp((const char *)prop, "xlnx,zynq-ep107")) == 0)