?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / net / ethernet / synopsys / dwc-xlgmac-hw.c
blobbf6c1c6779ff37826fa27bf89be1a23bc6d33744
1 /* Synopsys DesignWare Core Enterprise Ethernet (XLGMAC) Driver
2 *
3 * Copyright (c) 2017 Synopsys, Inc. (www.synopsys.com)
4 *
5 * This program is dual-licensed; you may select either version 2 of
6 * the GNU General Public License ("GPL") or BSD license ("BSD").
7 *
8 * This Synopsys DWC XLGMAC software driver and associated documentation
9 * (hereinafter the "Software") is an unsupported proprietary work of
10 * Synopsys, Inc. unless otherwise expressly agreed to in writing between
11 * Synopsys and you. The Software IS NOT an item of Licensed Software or a
12 * Licensed Product under any End User Software License Agreement or
13 * Agreement for Licensed Products with Synopsys or any supplement thereto.
14 * Synopsys is a registered trademark of Synopsys, Inc. Other names included
15 * in the SOFTWARE may be the trademarks of their respective owners.
16 */
17
18 #include <linux/phy.h>
19 #include <linux/mdio.h>
20 #include <linux/clk.h>
21 #include <linux/bitrev.h>
22 #include <linux/crc32.h>
23 #include <linux/crc32poly.h>
24 #include <linux/dcbnl.h>
25
26 #include "dwc-xlgmac.h"
27 #include "dwc-xlgmac-reg.h"
28
29 static int xlgmac_tx_complete(struct xlgmac_dma_desc *dma_desc)
30 {
31 return !XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
32 TX_NORMAL_DESC3_OWN_POS,
33 TX_NORMAL_DESC3_OWN_LEN);
34 }
35
36 static int xlgmac_disable_rx_csum(struct xlgmac_pdata *pdata)
37 {
38 u32 regval;
39
40 regval = readl(pdata->mac_regs + MAC_RCR);
41 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_IPC_POS,
42 MAC_RCR_IPC_LEN, 0);
43 writel(regval, pdata->mac_regs + MAC_RCR);
44
45 return 0;
46 }
47
48 static int xlgmac_enable_rx_csum(struct xlgmac_pdata *pdata)
49 {
50 u32 regval;
51
52 regval = readl(pdata->mac_regs + MAC_RCR);
53 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_IPC_POS,
54 MAC_RCR_IPC_LEN, 1);
55 writel(regval, pdata->mac_regs + MAC_RCR);
56
57 return 0;
58 }
59
60 static int xlgmac_set_mac_address(struct xlgmac_pdata *pdata, u8 *addr)
61 {
62 unsigned int mac_addr_hi, mac_addr_lo;
63
64 mac_addr_hi = (addr[5] << 8) | (addr[4] << 0);
65 mac_addr_lo = (addr[3] << 24) | (addr[2] << 16) |
66 (addr[1] << 8) | (addr[0] << 0);
67
68 writel(mac_addr_hi, pdata->mac_regs + MAC_MACA0HR);
69 writel(mac_addr_lo, pdata->mac_regs + MAC_MACA0LR);
70
71 return 0;
72 }
73
74 static void xlgmac_set_mac_reg(struct xlgmac_pdata *pdata,
75 struct netdev_hw_addr *ha,
76 unsigned int *mac_reg)
77 {
78 unsigned int mac_addr_hi, mac_addr_lo;
79 u8 *mac_addr;
80
81 mac_addr_lo = 0;
82 mac_addr_hi = 0;
83
84 if (ha) {
85 mac_addr = (u8 *)&mac_addr_lo;
86 mac_addr[0] = ha->addr[0];
87 mac_addr[1] = ha->addr[1];
88 mac_addr[2] = ha->addr[2];
89 mac_addr[3] = ha->addr[3];
90 mac_addr = (u8 *)&mac_addr_hi;
91 mac_addr[0] = ha->addr[4];
92 mac_addr[1] = ha->addr[5];
93
94 netif_dbg(pdata, drv, pdata->netdev,
95 "adding mac address %pM at %#x\n",
96 ha->addr, *mac_reg);
97
98 mac_addr_hi = XLGMAC_SET_REG_BITS(mac_addr_hi,
99 MAC_MACA1HR_AE_POS,
100 MAC_MACA1HR_AE_LEN,
101 1);
102 }
103
104 writel(mac_addr_hi, pdata->mac_regs + *mac_reg);
105 *mac_reg += MAC_MACA_INC;
106 writel(mac_addr_lo, pdata->mac_regs + *mac_reg);
107 *mac_reg += MAC_MACA_INC;
108 }
109
110 static int xlgmac_enable_rx_vlan_stripping(struct xlgmac_pdata *pdata)
111 {
112 u32 regval;
113
114 regval = readl(pdata->mac_regs + MAC_VLANTR);
115 /* Put the VLAN tag in the Rx descriptor */
116 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_EVLRXS_POS,
117 MAC_VLANTR_EVLRXS_LEN, 1);
118 /* Don't check the VLAN type */
119 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_DOVLTC_POS,
120 MAC_VLANTR_DOVLTC_LEN, 1);
121 /* Check only C-TAG (0x8100) packets */
122 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_ERSVLM_POS,
123 MAC_VLANTR_ERSVLM_LEN, 0);
124 /* Don't consider an S-TAG (0x88A8) packet as a VLAN packet */
125 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_ESVL_POS,
126 MAC_VLANTR_ESVL_LEN, 0);
127 /* Enable VLAN tag stripping */
128 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_EVLS_POS,
129 MAC_VLANTR_EVLS_LEN, 0x3);
130 writel(regval, pdata->mac_regs + MAC_VLANTR);
131
132 return 0;
133 }
134
135 static int xlgmac_disable_rx_vlan_stripping(struct xlgmac_pdata *pdata)
136 {
137 u32 regval;
138
139 regval = readl(pdata->mac_regs + MAC_VLANTR);
140 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_EVLS_POS,
141 MAC_VLANTR_EVLS_LEN, 0);
142 writel(regval, pdata->mac_regs + MAC_VLANTR);
143
144 return 0;
145 }
146
147 static int xlgmac_enable_rx_vlan_filtering(struct xlgmac_pdata *pdata)
148 {
149 u32 regval;
150
151 regval = readl(pdata->mac_regs + MAC_PFR);
152 /* Enable VLAN filtering */
153 regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_VTFE_POS,
154 MAC_PFR_VTFE_LEN, 1);
155 writel(regval, pdata->mac_regs + MAC_PFR);
156
157 regval = readl(pdata->mac_regs + MAC_VLANTR);
158 /* Enable VLAN Hash Table filtering */
159 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_VTHM_POS,
160 MAC_VLANTR_VTHM_LEN, 1);
161 /* Disable VLAN tag inverse matching */
162 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_VTIM_POS,
163 MAC_VLANTR_VTIM_LEN, 0);
164 /* Only filter on the lower 12-bits of the VLAN tag */
165 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_ETV_POS,
166 MAC_VLANTR_ETV_LEN, 1);
167 /* In order for the VLAN Hash Table filtering to be effective,
168 * the VLAN tag identifier in the VLAN Tag Register must not
169 * be zero. Set the VLAN tag identifier to "1" to enable the
170 * VLAN Hash Table filtering. This implies that a VLAN tag of
171 * 1 will always pass filtering.
172 */
173 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANTR_VL_POS,
174 MAC_VLANTR_VL_LEN, 1);
175 writel(regval, pdata->mac_regs + MAC_VLANTR);
176
177 return 0;
178 }
179
180 static int xlgmac_disable_rx_vlan_filtering(struct xlgmac_pdata *pdata)
181 {
182 u32 regval;
183
184 regval = readl(pdata->mac_regs + MAC_PFR);
185 /* Disable VLAN filtering */
186 regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_VTFE_POS,
187 MAC_PFR_VTFE_LEN, 0);
188 writel(regval, pdata->mac_regs + MAC_PFR);
189
190 return 0;
191 }
192
193 static u32 xlgmac_vid_crc32_le(__le16 vid_le)
194 {
195 unsigned char *data = (unsigned char *)&vid_le;
196 unsigned char data_byte = 0;
197 u32 crc = ~0;
198 u32 temp = 0;
199 int i, bits;
200
201 bits = get_bitmask_order(VLAN_VID_MASK);
202 for (i = 0; i < bits; i++) {
203 if ((i % 8) == 0)
204 data_byte = data[i / 8];
205
206 temp = ((crc & 1) ^ data_byte) & 1;
207 crc >>= 1;
208 data_byte >>= 1;
209
210 if (temp)
211 crc ^= CRC32_POLY_LE;
212 }
213
214 return crc;
215 }
216
217 static int xlgmac_update_vlan_hash_table(struct xlgmac_pdata *pdata)
218 {
219 u16 vlan_hash_table = 0;
220 __le16 vid_le;
221 u32 regval;
222 u32 crc;
223 u16 vid;
224
225 /* Generate the VLAN Hash Table value */
226 for_each_set_bit(vid, pdata->active_vlans, VLAN_N_VID) {
227 /* Get the CRC32 value of the VLAN ID */
228 vid_le = cpu_to_le16(vid);
229 crc = bitrev32(~xlgmac_vid_crc32_le(vid_le)) >> 28;
230
231 vlan_hash_table |= (1 << crc);
232 }
233
234 regval = readl(pdata->mac_regs + MAC_VLANHTR);
235 /* Set the VLAN Hash Table filtering register */
236 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANHTR_VLHT_POS,
237 MAC_VLANHTR_VLHT_LEN, vlan_hash_table);
238 writel(regval, pdata->mac_regs + MAC_VLANHTR);
239
240 return 0;
241 }
242
243 static int xlgmac_set_promiscuous_mode(struct xlgmac_pdata *pdata,
244 unsigned int enable)
245 {
246 unsigned int val = enable ? 1 : 0;
247 u32 regval;
248
249 regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_PFR),
250 MAC_PFR_PR_POS, MAC_PFR_PR_LEN);
251 if (regval == val)
252 return 0;
253
254 netif_dbg(pdata, drv, pdata->netdev, "%s promiscuous mode\n",
255 enable ? "entering" : "leaving");
256
257 regval = readl(pdata->mac_regs + MAC_PFR);
258 regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_PR_POS,
259 MAC_PFR_PR_LEN, val);
260 writel(regval, pdata->mac_regs + MAC_PFR);
261
262 /* Hardware will still perform VLAN filtering in promiscuous mode */
263 if (enable) {
264 xlgmac_disable_rx_vlan_filtering(pdata);
265 } else {
266 if (pdata->netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
267 xlgmac_enable_rx_vlan_filtering(pdata);
268 }
269
270 return 0;
271 }
272
273 static int xlgmac_set_all_multicast_mode(struct xlgmac_pdata *pdata,
274 unsigned int enable)
275 {
276 unsigned int val = enable ? 1 : 0;
277 u32 regval;
278
279 regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_PFR),
280 MAC_PFR_PM_POS, MAC_PFR_PM_LEN);
281 if (regval == val)
282 return 0;
283
284 netif_dbg(pdata, drv, pdata->netdev, "%s allmulti mode\n",
285 enable ? "entering" : "leaving");
286
287 regval = readl(pdata->mac_regs + MAC_PFR);
288 regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_PM_POS,
289 MAC_PFR_PM_LEN, val);
290 writel(regval, pdata->mac_regs + MAC_PFR);
291
292 return 0;
293 }
294
295 static void xlgmac_set_mac_addn_addrs(struct xlgmac_pdata *pdata)
296 {
297 struct net_device *netdev = pdata->netdev;
298 struct netdev_hw_addr *ha;
299 unsigned int addn_macs;
300 unsigned int mac_reg;
301
302 mac_reg = MAC_MACA1HR;
303 addn_macs = pdata->hw_feat.addn_mac;
304
305 if (netdev_uc_count(netdev) > addn_macs) {
306 xlgmac_set_promiscuous_mode(pdata, 1);
307 } else {
308 netdev_for_each_uc_addr(ha, netdev) {
309 xlgmac_set_mac_reg(pdata, ha, &mac_reg);
310 addn_macs--;
311 }
312
313 if (netdev_mc_count(netdev) > addn_macs) {
314 xlgmac_set_all_multicast_mode(pdata, 1);
315 } else {
316 netdev_for_each_mc_addr(ha, netdev) {
317 xlgmac_set_mac_reg(pdata, ha, &mac_reg);
318 addn_macs--;
319 }
320 }
321 }
322
323 /* Clear remaining additional MAC address entries */
324 while (addn_macs--)
325 xlgmac_set_mac_reg(pdata, NULL, &mac_reg);
326 }
327
328 static void xlgmac_set_mac_hash_table(struct xlgmac_pdata *pdata)
329 {
330 unsigned int hash_table_shift, hash_table_count;
331 u32 hash_table[XLGMAC_MAC_HASH_TABLE_SIZE];
332 struct net_device *netdev = pdata->netdev;
333 struct netdev_hw_addr *ha;
334 unsigned int hash_reg;
335 unsigned int i;
336 u32 crc;
337
338 hash_table_shift = 26 - (pdata->hw_feat.hash_table_size >> 7);
339 hash_table_count = pdata->hw_feat.hash_table_size / 32;
340 memset(hash_table, 0, sizeof(hash_table));
341
342 /* Build the MAC Hash Table register values */
343 netdev_for_each_uc_addr(ha, netdev) {
344 crc = bitrev32(~crc32_le(~0, ha->addr, ETH_ALEN));
345 crc >>= hash_table_shift;
346 hash_table[crc >> 5] |= (1 << (crc & 0x1f));
347 }
348
349 netdev_for_each_mc_addr(ha, netdev) {
350 crc = bitrev32(~crc32_le(~0, ha->addr, ETH_ALEN));
351 crc >>= hash_table_shift;
352 hash_table[crc >> 5] |= (1 << (crc & 0x1f));
353 }
354
355 /* Set the MAC Hash Table registers */
356 hash_reg = MAC_HTR0;
357 for (i = 0; i < hash_table_count; i++) {
358 writel(hash_table[i], pdata->mac_regs + hash_reg);
359 hash_reg += MAC_HTR_INC;
360 }
361 }
362
363 static int xlgmac_add_mac_addresses(struct xlgmac_pdata *pdata)
364 {
365 if (pdata->hw_feat.hash_table_size)
366 xlgmac_set_mac_hash_table(pdata);
367 else
368 xlgmac_set_mac_addn_addrs(pdata);
369
370 return 0;
371 }
372
373 static void xlgmac_config_mac_address(struct xlgmac_pdata *pdata)
374 {
375 u32 regval;
376
377 xlgmac_set_mac_address(pdata, pdata->netdev->dev_addr);
378
379 /* Filtering is done using perfect filtering and hash filtering */
380 if (pdata->hw_feat.hash_table_size) {
381 regval = readl(pdata->mac_regs + MAC_PFR);
382 regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_HPF_POS,
383 MAC_PFR_HPF_LEN, 1);
384 regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_HUC_POS,
385 MAC_PFR_HUC_LEN, 1);
386 regval = XLGMAC_SET_REG_BITS(regval, MAC_PFR_HMC_POS,
387 MAC_PFR_HMC_LEN, 1);
388 writel(regval, pdata->mac_regs + MAC_PFR);
389 }
390 }
391
392 static void xlgmac_config_jumbo_enable(struct xlgmac_pdata *pdata)
393 {
394 unsigned int val;
395 u32 regval;
396
397 val = (pdata->netdev->mtu > XLGMAC_STD_PACKET_MTU) ? 1 : 0;
398
399 regval = readl(pdata->mac_regs + MAC_RCR);
400 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_JE_POS,
401 MAC_RCR_JE_LEN, val);
402 writel(regval, pdata->mac_regs + MAC_RCR);
403 }
404
405 static void xlgmac_config_checksum_offload(struct xlgmac_pdata *pdata)
406 {
407 if (pdata->netdev->features & NETIF_F_RXCSUM)
408 xlgmac_enable_rx_csum(pdata);
409 else
410 xlgmac_disable_rx_csum(pdata);
411 }
412
413 static void xlgmac_config_vlan_support(struct xlgmac_pdata *pdata)
414 {
415 u32 regval;
416
417 regval = readl(pdata->mac_regs + MAC_VLANIR);
418 /* Indicate that VLAN Tx CTAGs come from context descriptors */
419 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANIR_CSVL_POS,
420 MAC_VLANIR_CSVL_LEN, 0);
421 regval = XLGMAC_SET_REG_BITS(regval, MAC_VLANIR_VLTI_POS,
422 MAC_VLANIR_VLTI_LEN, 1);
423 writel(regval, pdata->mac_regs + MAC_VLANIR);
424
425 /* Set the current VLAN Hash Table register value */
426 xlgmac_update_vlan_hash_table(pdata);
427
428 if (pdata->netdev->features & NETIF_F_HW_VLAN_CTAG_FILTER)
429 xlgmac_enable_rx_vlan_filtering(pdata);
430 else
431 xlgmac_disable_rx_vlan_filtering(pdata);
432
433 if (pdata->netdev->features & NETIF_F_HW_VLAN_CTAG_RX)
434 xlgmac_enable_rx_vlan_stripping(pdata);
435 else
436 xlgmac_disable_rx_vlan_stripping(pdata);
437 }
438
439 static int xlgmac_config_rx_mode(struct xlgmac_pdata *pdata)
440 {
441 struct net_device *netdev = pdata->netdev;
442 unsigned int pr_mode, am_mode;
443
444 pr_mode = ((netdev->flags & IFF_PROMISC) != 0);
445 am_mode = ((netdev->flags & IFF_ALLMULTI) != 0);
446
447 xlgmac_set_promiscuous_mode(pdata, pr_mode);
448 xlgmac_set_all_multicast_mode(pdata, am_mode);
449
450 xlgmac_add_mac_addresses(pdata);
451
452 return 0;
453 }
454
455 static void xlgmac_prepare_tx_stop(struct xlgmac_pdata *pdata,
456 struct xlgmac_channel *channel)
457 {
458 unsigned int tx_dsr, tx_pos, tx_qidx;
459 unsigned long tx_timeout;
460 unsigned int tx_status;
461
462 /* Calculate the status register to read and the position within */
463 if (channel->queue_index < DMA_DSRX_FIRST_QUEUE) {
464 tx_dsr = DMA_DSR0;
465 tx_pos = (channel->queue_index * DMA_DSR_Q_LEN) +
466 DMA_DSR0_TPS_START;
467 } else {
468 tx_qidx = channel->queue_index - DMA_DSRX_FIRST_QUEUE;
469
470 tx_dsr = DMA_DSR1 + ((tx_qidx / DMA_DSRX_QPR) * DMA_DSRX_INC);
471 tx_pos = ((tx_qidx % DMA_DSRX_QPR) * DMA_DSR_Q_LEN) +
472 DMA_DSRX_TPS_START;
473 }
474
475 /* The Tx engine cannot be stopped if it is actively processing
476 * descriptors. Wait for the Tx engine to enter the stopped or
477 * suspended state. Don't wait forever though...
478 */
479 tx_timeout = jiffies + (XLGMAC_DMA_STOP_TIMEOUT * HZ);
480 while (time_before(jiffies, tx_timeout)) {
481 tx_status = readl(pdata->mac_regs + tx_dsr);
482 tx_status = XLGMAC_GET_REG_BITS(tx_status, tx_pos,
483 DMA_DSR_TPS_LEN);
484 if ((tx_status == DMA_TPS_STOPPED) ||
485 (tx_status == DMA_TPS_SUSPENDED))
486 break;
487
488 usleep_range(500, 1000);
489 }
490
491 if (!time_before(jiffies, tx_timeout))
492 netdev_info(pdata->netdev,
493 "timed out waiting for Tx DMA channel %u to stop\n",
494 channel->queue_index);
495 }
496
497 static void xlgmac_enable_tx(struct xlgmac_pdata *pdata)
498 {
499 struct xlgmac_channel *channel;
500 unsigned int i;
501 u32 regval;
502
503 /* Enable each Tx DMA channel */
504 channel = pdata->channel_head;
505 for (i = 0; i < pdata->channel_count; i++, channel++) {
506 if (!channel->tx_ring)
507 break;
508
509 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_TCR));
510 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_TCR_ST_POS,
511 DMA_CH_TCR_ST_LEN, 1);
512 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_TCR));
513 }
514
515 /* Enable each Tx queue */
516 for (i = 0; i < pdata->tx_q_count; i++) {
517 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
518 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_TXQEN_POS,
519 MTL_Q_TQOMR_TXQEN_LEN,
520 MTL_Q_ENABLED);
521 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
522 }
523
524 /* Enable MAC Tx */
525 regval = readl(pdata->mac_regs + MAC_TCR);
526 regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_TE_POS,
527 MAC_TCR_TE_LEN, 1);
528 writel(regval, pdata->mac_regs + MAC_TCR);
529 }
530
531 static void xlgmac_disable_tx(struct xlgmac_pdata *pdata)
532 {
533 struct xlgmac_channel *channel;
534 unsigned int i;
535 u32 regval;
536
537 /* Prepare for Tx DMA channel stop */
538 channel = pdata->channel_head;
539 for (i = 0; i < pdata->channel_count; i++, channel++) {
540 if (!channel->tx_ring)
541 break;
542
543 xlgmac_prepare_tx_stop(pdata, channel);
544 }
545
546 /* Disable MAC Tx */
547 regval = readl(pdata->mac_regs + MAC_TCR);
548 regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_TE_POS,
549 MAC_TCR_TE_LEN, 0);
550 writel(regval, pdata->mac_regs + MAC_TCR);
551
552 /* Disable each Tx queue */
553 for (i = 0; i < pdata->tx_q_count; i++) {
554 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
555 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_TXQEN_POS,
556 MTL_Q_TQOMR_TXQEN_LEN, 0);
557 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
558 }
559
560 /* Disable each Tx DMA channel */
561 channel = pdata->channel_head;
562 for (i = 0; i < pdata->channel_count; i++, channel++) {
563 if (!channel->tx_ring)
564 break;
565
566 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_TCR));
567 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_TCR_ST_POS,
568 DMA_CH_TCR_ST_LEN, 0);
569 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_TCR));
570 }
571 }
572
573 static void xlgmac_prepare_rx_stop(struct xlgmac_pdata *pdata,
574 unsigned int queue)
575 {
576 unsigned int rx_status, prxq, rxqsts;
577 unsigned long rx_timeout;
578
579 /* The Rx engine cannot be stopped if it is actively processing
580 * packets. Wait for the Rx queue to empty the Rx fifo. Don't
581 * wait forever though...
582 */
583 rx_timeout = jiffies + (XLGMAC_DMA_STOP_TIMEOUT * HZ);
584 while (time_before(jiffies, rx_timeout)) {
585 rx_status = readl(XLGMAC_MTL_REG(pdata, queue, MTL_Q_RQDR));
586 prxq = XLGMAC_GET_REG_BITS(rx_status, MTL_Q_RQDR_PRXQ_POS,
587 MTL_Q_RQDR_PRXQ_LEN);
588 rxqsts = XLGMAC_GET_REG_BITS(rx_status, MTL_Q_RQDR_RXQSTS_POS,
589 MTL_Q_RQDR_RXQSTS_LEN);
590 if ((prxq == 0) && (rxqsts == 0))
591 break;
592
593 usleep_range(500, 1000);
594 }
595
596 if (!time_before(jiffies, rx_timeout))
597 netdev_info(pdata->netdev,
598 "timed out waiting for Rx queue %u to empty\n",
599 queue);
600 }
601
602 static void xlgmac_enable_rx(struct xlgmac_pdata *pdata)
603 {
604 struct xlgmac_channel *channel;
605 unsigned int regval, i;
606
607 /* Enable each Rx DMA channel */
608 channel = pdata->channel_head;
609 for (i = 0; i < pdata->channel_count; i++, channel++) {
610 if (!channel->rx_ring)
611 break;
612
613 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_RCR));
614 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_RCR_SR_POS,
615 DMA_CH_RCR_SR_LEN, 1);
616 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_RCR));
617 }
618
619 /* Enable each Rx queue */
620 regval = 0;
621 for (i = 0; i < pdata->rx_q_count; i++)
622 regval |= (0x02 << (i << 1));
623 writel(regval, pdata->mac_regs + MAC_RQC0R);
624
625 /* Enable MAC Rx */
626 regval = readl(pdata->mac_regs + MAC_RCR);
627 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_DCRCC_POS,
628 MAC_RCR_DCRCC_LEN, 1);
629 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_CST_POS,
630 MAC_RCR_CST_LEN, 1);
631 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_ACS_POS,
632 MAC_RCR_ACS_LEN, 1);
633 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_RE_POS,
634 MAC_RCR_RE_LEN, 1);
635 writel(regval, pdata->mac_regs + MAC_RCR);
636 }
637
638 static void xlgmac_disable_rx(struct xlgmac_pdata *pdata)
639 {
640 struct xlgmac_channel *channel;
641 unsigned int i;
642 u32 regval;
643
644 /* Disable MAC Rx */
645 regval = readl(pdata->mac_regs + MAC_RCR);
646 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_DCRCC_POS,
647 MAC_RCR_DCRCC_LEN, 0);
648 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_CST_POS,
649 MAC_RCR_CST_LEN, 0);
650 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_ACS_POS,
651 MAC_RCR_ACS_LEN, 0);
652 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_RE_POS,
653 MAC_RCR_RE_LEN, 0);
654 writel(regval, pdata->mac_regs + MAC_RCR);
655
656 /* Prepare for Rx DMA channel stop */
657 for (i = 0; i < pdata->rx_q_count; i++)
658 xlgmac_prepare_rx_stop(pdata, i);
659
660 /* Disable each Rx queue */
661 writel(0, pdata->mac_regs + MAC_RQC0R);
662
663 /* Disable each Rx DMA channel */
664 channel = pdata->channel_head;
665 for (i = 0; i < pdata->channel_count; i++, channel++) {
666 if (!channel->rx_ring)
667 break;
668
669 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_RCR));
670 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_RCR_SR_POS,
671 DMA_CH_RCR_SR_LEN, 0);
672 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_RCR));
673 }
674 }
675
676 static void xlgmac_tx_start_xmit(struct xlgmac_channel *channel,
677 struct xlgmac_ring *ring)
678 {
679 struct xlgmac_pdata *pdata = channel->pdata;
680 struct xlgmac_desc_data *desc_data;
681
682 /* Make sure everything is written before the register write */
683 wmb();
684
685 /* Issue a poll command to Tx DMA by writing address
686 * of next immediate free descriptor
687 */
688 desc_data = XLGMAC_GET_DESC_DATA(ring, ring->cur);
689 writel(lower_32_bits(desc_data->dma_desc_addr),
690 XLGMAC_DMA_REG(channel, DMA_CH_TDTR_LO));
691
692 /* Start the Tx timer */
693 if (pdata->tx_usecs && !channel->tx_timer_active) {
694 channel->tx_timer_active = 1;
695 mod_timer(&channel->tx_timer,
696 jiffies + usecs_to_jiffies(pdata->tx_usecs));
697 }
698
699 ring->tx.xmit_more = 0;
700 }
701
702 static void xlgmac_dev_xmit(struct xlgmac_channel *channel)
703 {
704 struct xlgmac_pdata *pdata = channel->pdata;
705 struct xlgmac_ring *ring = channel->tx_ring;
706 unsigned int tso_context, vlan_context;
707 struct xlgmac_desc_data *desc_data;
708 struct xlgmac_dma_desc *dma_desc;
709 struct xlgmac_pkt_info *pkt_info;
710 unsigned int csum, tso, vlan;
711 int start_index = ring->cur;
712 int cur_index = ring->cur;
713 unsigned int tx_set_ic;
714 int i;
715
716 pkt_info = &ring->pkt_info;
717 csum = XLGMAC_GET_REG_BITS(pkt_info->attributes,
718 TX_PACKET_ATTRIBUTES_CSUM_ENABLE_POS,
719 TX_PACKET_ATTRIBUTES_CSUM_ENABLE_LEN);
720 tso = XLGMAC_GET_REG_BITS(pkt_info->attributes,
721 TX_PACKET_ATTRIBUTES_TSO_ENABLE_POS,
722 TX_PACKET_ATTRIBUTES_TSO_ENABLE_LEN);
723 vlan = XLGMAC_GET_REG_BITS(pkt_info->attributes,
724 TX_PACKET_ATTRIBUTES_VLAN_CTAG_POS,
725 TX_PACKET_ATTRIBUTES_VLAN_CTAG_LEN);
726
727 if (tso && (pkt_info->mss != ring->tx.cur_mss))
728 tso_context = 1;
729 else
730 tso_context = 0;
731
732 if (vlan && (pkt_info->vlan_ctag != ring->tx.cur_vlan_ctag))
733 vlan_context = 1;
734 else
735 vlan_context = 0;
736
737 /* Determine if an interrupt should be generated for this Tx:
738 * Interrupt:
739 * - Tx frame count exceeds the frame count setting
740 * - Addition of Tx frame count to the frame count since the
741 * last interrupt was set exceeds the frame count setting
742 * No interrupt:
743 * - No frame count setting specified (ethtool -C ethX tx-frames 0)
744 * - Addition of Tx frame count to the frame count since the
745 * last interrupt was set does not exceed the frame count setting
746 */
747 ring->coalesce_count += pkt_info->tx_packets;
748 if (!pdata->tx_frames)
749 tx_set_ic = 0;
750 else if (pkt_info->tx_packets > pdata->tx_frames)
751 tx_set_ic = 1;
752 else if ((ring->coalesce_count % pdata->tx_frames) <
753 pkt_info->tx_packets)
754 tx_set_ic = 1;
755 else
756 tx_set_ic = 0;
757
758 desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index);
759 dma_desc = desc_data->dma_desc;
760
761 /* Create a context descriptor if this is a TSO pkt_info */
762 if (tso_context || vlan_context) {
763 if (tso_context) {
764 netif_dbg(pdata, tx_queued, pdata->netdev,
765 "TSO context descriptor, mss=%u\n",
766 pkt_info->mss);
767
768 /* Set the MSS size */
769 dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
770 dma_desc->desc2,
771 TX_CONTEXT_DESC2_MSS_POS,
772 TX_CONTEXT_DESC2_MSS_LEN,
773 pkt_info->mss);
774
775 /* Mark it as a CONTEXT descriptor */
776 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
777 dma_desc->desc3,
778 TX_CONTEXT_DESC3_CTXT_POS,
779 TX_CONTEXT_DESC3_CTXT_LEN,
780 1);
781
782 /* Indicate this descriptor contains the MSS */
783 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
784 dma_desc->desc3,
785 TX_CONTEXT_DESC3_TCMSSV_POS,
786 TX_CONTEXT_DESC3_TCMSSV_LEN,
787 1);
788
789 ring->tx.cur_mss = pkt_info->mss;
790 }
791
792 if (vlan_context) {
793 netif_dbg(pdata, tx_queued, pdata->netdev,
794 "VLAN context descriptor, ctag=%u\n",
795 pkt_info->vlan_ctag);
796
797 /* Mark it as a CONTEXT descriptor */
798 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
799 dma_desc->desc3,
800 TX_CONTEXT_DESC3_CTXT_POS,
801 TX_CONTEXT_DESC3_CTXT_LEN,
802 1);
803
804 /* Set the VLAN tag */
805 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
806 dma_desc->desc3,
807 TX_CONTEXT_DESC3_VT_POS,
808 TX_CONTEXT_DESC3_VT_LEN,
809 pkt_info->vlan_ctag);
810
811 /* Indicate this descriptor contains the VLAN tag */
812 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
813 dma_desc->desc3,
814 TX_CONTEXT_DESC3_VLTV_POS,
815 TX_CONTEXT_DESC3_VLTV_LEN,
816 1);
817
818 ring->tx.cur_vlan_ctag = pkt_info->vlan_ctag;
819 }
820
821 cur_index++;
822 desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index);
823 dma_desc = desc_data->dma_desc;
824 }
825
826 /* Update buffer address (for TSO this is the header) */
827 dma_desc->desc0 = cpu_to_le32(lower_32_bits(desc_data->skb_dma));
828 dma_desc->desc1 = cpu_to_le32(upper_32_bits(desc_data->skb_dma));
829
830 /* Update the buffer length */
831 dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
832 dma_desc->desc2,
833 TX_NORMAL_DESC2_HL_B1L_POS,
834 TX_NORMAL_DESC2_HL_B1L_LEN,
835 desc_data->skb_dma_len);
836
837 /* VLAN tag insertion check */
838 if (vlan) {
839 dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
840 dma_desc->desc2,
841 TX_NORMAL_DESC2_VTIR_POS,
842 TX_NORMAL_DESC2_VTIR_LEN,
843 TX_NORMAL_DESC2_VLAN_INSERT);
844 pdata->stats.tx_vlan_packets++;
845 }
846
847 /* Timestamp enablement check */
848 if (XLGMAC_GET_REG_BITS(pkt_info->attributes,
849 TX_PACKET_ATTRIBUTES_PTP_POS,
850 TX_PACKET_ATTRIBUTES_PTP_LEN))
851 dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
852 dma_desc->desc2,
853 TX_NORMAL_DESC2_TTSE_POS,
854 TX_NORMAL_DESC2_TTSE_LEN,
855 1);
856
857 /* Mark it as First Descriptor */
858 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
859 dma_desc->desc3,
860 TX_NORMAL_DESC3_FD_POS,
861 TX_NORMAL_DESC3_FD_LEN,
862 1);
863
864 /* Mark it as a NORMAL descriptor */
865 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
866 dma_desc->desc3,
867 TX_NORMAL_DESC3_CTXT_POS,
868 TX_NORMAL_DESC3_CTXT_LEN,
869 0);
870
871 /* Set OWN bit if not the first descriptor */
872 if (cur_index != start_index)
873 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
874 dma_desc->desc3,
875 TX_NORMAL_DESC3_OWN_POS,
876 TX_NORMAL_DESC3_OWN_LEN,
877 1);
878
879 if (tso) {
880 /* Enable TSO */
881 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
882 dma_desc->desc3,
883 TX_NORMAL_DESC3_TSE_POS,
884 TX_NORMAL_DESC3_TSE_LEN, 1);
885 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
886 dma_desc->desc3,
887 TX_NORMAL_DESC3_TCPPL_POS,
888 TX_NORMAL_DESC3_TCPPL_LEN,
889 pkt_info->tcp_payload_len);
890 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
891 dma_desc->desc3,
892 TX_NORMAL_DESC3_TCPHDRLEN_POS,
893 TX_NORMAL_DESC3_TCPHDRLEN_LEN,
894 pkt_info->tcp_header_len / 4);
895
896 pdata->stats.tx_tso_packets++;
897 } else {
898 /* Enable CRC and Pad Insertion */
899 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
900 dma_desc->desc3,
901 TX_NORMAL_DESC3_CPC_POS,
902 TX_NORMAL_DESC3_CPC_LEN, 0);
903
904 /* Enable HW CSUM */
905 if (csum)
906 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
907 dma_desc->desc3,
908 TX_NORMAL_DESC3_CIC_POS,
909 TX_NORMAL_DESC3_CIC_LEN,
910 0x3);
911
912 /* Set the total length to be transmitted */
913 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
914 dma_desc->desc3,
915 TX_NORMAL_DESC3_FL_POS,
916 TX_NORMAL_DESC3_FL_LEN,
917 pkt_info->length);
918 }
919
920 for (i = cur_index - start_index + 1; i < pkt_info->desc_count; i++) {
921 cur_index++;
922 desc_data = XLGMAC_GET_DESC_DATA(ring, cur_index);
923 dma_desc = desc_data->dma_desc;
924
925 /* Update buffer address */
926 dma_desc->desc0 =
927 cpu_to_le32(lower_32_bits(desc_data->skb_dma));
928 dma_desc->desc1 =
929 cpu_to_le32(upper_32_bits(desc_data->skb_dma));
930
931 /* Update the buffer length */
932 dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
933 dma_desc->desc2,
934 TX_NORMAL_DESC2_HL_B1L_POS,
935 TX_NORMAL_DESC2_HL_B1L_LEN,
936 desc_data->skb_dma_len);
937
938 /* Set OWN bit */
939 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
940 dma_desc->desc3,
941 TX_NORMAL_DESC3_OWN_POS,
942 TX_NORMAL_DESC3_OWN_LEN, 1);
943
944 /* Mark it as NORMAL descriptor */
945 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
946 dma_desc->desc3,
947 TX_NORMAL_DESC3_CTXT_POS,
948 TX_NORMAL_DESC3_CTXT_LEN, 0);
949
950 /* Enable HW CSUM */
951 if (csum)
952 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
953 dma_desc->desc3,
954 TX_NORMAL_DESC3_CIC_POS,
955 TX_NORMAL_DESC3_CIC_LEN,
956 0x3);
957 }
958
959 /* Set LAST bit for the last descriptor */
960 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
961 dma_desc->desc3,
962 TX_NORMAL_DESC3_LD_POS,
963 TX_NORMAL_DESC3_LD_LEN, 1);
964
965 /* Set IC bit based on Tx coalescing settings */
966 if (tx_set_ic)
967 dma_desc->desc2 = XLGMAC_SET_REG_BITS_LE(
968 dma_desc->desc2,
969 TX_NORMAL_DESC2_IC_POS,
970 TX_NORMAL_DESC2_IC_LEN, 1);
971
972 /* Save the Tx info to report back during cleanup */
973 desc_data->tx.packets = pkt_info->tx_packets;
974 desc_data->tx.bytes = pkt_info->tx_bytes;
975
976 /* In case the Tx DMA engine is running, make sure everything
977 * is written to the descriptor(s) before setting the OWN bit
978 * for the first descriptor
979 */
980 dma_wmb();
981
982 /* Set OWN bit for the first descriptor */
983 desc_data = XLGMAC_GET_DESC_DATA(ring, start_index);
984 dma_desc = desc_data->dma_desc;
985 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
986 dma_desc->desc3,
987 TX_NORMAL_DESC3_OWN_POS,
988 TX_NORMAL_DESC3_OWN_LEN, 1);
989
990 if (netif_msg_tx_queued(pdata))
991 xlgmac_dump_tx_desc(pdata, ring, start_index,
992 pkt_info->desc_count, 1);
993
994 /* Make sure ownership is written to the descriptor */
995 smp_wmb();
996
997 ring->cur = cur_index + 1;
998 if (!netdev_xmit_more() ||
999 netif_xmit_stopped(netdev_get_tx_queue(pdata->netdev,
1000 channel->queue_index)))
1001 xlgmac_tx_start_xmit(channel, ring);
1002 else
1003 ring->tx.xmit_more = 1;
1004
1005 XLGMAC_PR("%s: descriptors %u to %u written\n",
1006 channel->name, start_index & (ring->dma_desc_count - 1),
1007 (ring->cur - 1) & (ring->dma_desc_count - 1));
1008 }
1009
1010 static void xlgmac_get_rx_tstamp(struct xlgmac_pkt_info *pkt_info,
1011 struct xlgmac_dma_desc *dma_desc)
1012 {
1013 u32 tsa, tsd;
1014 u64 nsec;
1015
1016 tsa = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
1017 RX_CONTEXT_DESC3_TSA_POS,
1018 RX_CONTEXT_DESC3_TSA_LEN);
1019 tsd = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
1020 RX_CONTEXT_DESC3_TSD_POS,
1021 RX_CONTEXT_DESC3_TSD_LEN);
1022 if (tsa && !tsd) {
1023 nsec = le32_to_cpu(dma_desc->desc1);
1024 nsec <<= 32;
1025 nsec |= le32_to_cpu(dma_desc->desc0);
1026 if (nsec != 0xffffffffffffffffULL) {
1027 pkt_info->rx_tstamp = nsec;
1028 pkt_info->attributes = XLGMAC_SET_REG_BITS(
1029 pkt_info->attributes,
1030 RX_PACKET_ATTRIBUTES_RX_TSTAMP_POS,
1031 RX_PACKET_ATTRIBUTES_RX_TSTAMP_LEN,
1032 1);
1033 }
1034 }
1035 }
1036
1037 static void xlgmac_tx_desc_reset(struct xlgmac_desc_data *desc_data)
1038 {
1039 struct xlgmac_dma_desc *dma_desc = desc_data->dma_desc;
1040
1041 /* Reset the Tx descriptor
1042 * Set buffer 1 (lo) address to zero
1043 * Set buffer 1 (hi) address to zero
1044 * Reset all other control bits (IC, TTSE, B2L & B1L)
1045 * Reset all other control bits (OWN, CTXT, FD, LD, CPC, CIC, etc)
1046 */
1047 dma_desc->desc0 = 0;
1048 dma_desc->desc1 = 0;
1049 dma_desc->desc2 = 0;
1050 dma_desc->desc3 = 0;
1051
1052 /* Make sure ownership is written to the descriptor */
1053 dma_wmb();
1054 }
1055
1056 static void xlgmac_tx_desc_init(struct xlgmac_channel *channel)
1057 {
1058 struct xlgmac_ring *ring = channel->tx_ring;
1059 struct xlgmac_desc_data *desc_data;
1060 int start_index = ring->cur;
1061 int i;
1062
1063 /* Initialze all descriptors */
1064 for (i = 0; i < ring->dma_desc_count; i++) {
1065 desc_data = XLGMAC_GET_DESC_DATA(ring, i);
1066
1067 /* Initialize Tx descriptor */
1068 xlgmac_tx_desc_reset(desc_data);
1069 }
1070
1071 /* Update the total number of Tx descriptors */
1072 writel(ring->dma_desc_count - 1, XLGMAC_DMA_REG(channel, DMA_CH_TDRLR));
1073
1074 /* Update the starting address of descriptor ring */
1075 desc_data = XLGMAC_GET_DESC_DATA(ring, start_index);
1076 writel(upper_32_bits(desc_data->dma_desc_addr),
1077 XLGMAC_DMA_REG(channel, DMA_CH_TDLR_HI));
1078 writel(lower_32_bits(desc_data->dma_desc_addr),
1079 XLGMAC_DMA_REG(channel, DMA_CH_TDLR_LO));
1080 }
1081
1082 static void xlgmac_rx_desc_reset(struct xlgmac_pdata *pdata,
1083 struct xlgmac_desc_data *desc_data,
1084 unsigned int index)
1085 {
1086 struct xlgmac_dma_desc *dma_desc = desc_data->dma_desc;
1087 unsigned int rx_frames = pdata->rx_frames;
1088 unsigned int rx_usecs = pdata->rx_usecs;
1089 dma_addr_t hdr_dma, buf_dma;
1090 unsigned int inte;
1091
1092 if (!rx_usecs && !rx_frames) {
1093 /* No coalescing, interrupt for every descriptor */
1094 inte = 1;
1095 } else {
1096 /* Set interrupt based on Rx frame coalescing setting */
1097 if (rx_frames && !((index + 1) % rx_frames))
1098 inte = 1;
1099 else
1100 inte = 0;
1101 }
1102
1103 /* Reset the Rx descriptor
1104 * Set buffer 1 (lo) address to header dma address (lo)
1105 * Set buffer 1 (hi) address to header dma address (hi)
1106 * Set buffer 2 (lo) address to buffer dma address (lo)
1107 * Set buffer 2 (hi) address to buffer dma address (hi) and
1108 * set control bits OWN and INTE
1109 */
1110 hdr_dma = desc_data->rx.hdr.dma_base + desc_data->rx.hdr.dma_off;
1111 buf_dma = desc_data->rx.buf.dma_base + desc_data->rx.buf.dma_off;
1112 dma_desc->desc0 = cpu_to_le32(lower_32_bits(hdr_dma));
1113 dma_desc->desc1 = cpu_to_le32(upper_32_bits(hdr_dma));
1114 dma_desc->desc2 = cpu_to_le32(lower_32_bits(buf_dma));
1115 dma_desc->desc3 = cpu_to_le32(upper_32_bits(buf_dma));
1116
1117 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
1118 dma_desc->desc3,
1119 RX_NORMAL_DESC3_INTE_POS,
1120 RX_NORMAL_DESC3_INTE_LEN,
1121 inte);
1122
1123 /* Since the Rx DMA engine is likely running, make sure everything
1124 * is written to the descriptor(s) before setting the OWN bit
1125 * for the descriptor
1126 */
1127 dma_wmb();
1128
1129 dma_desc->desc3 = XLGMAC_SET_REG_BITS_LE(
1130 dma_desc->desc3,
1131 RX_NORMAL_DESC3_OWN_POS,
1132 RX_NORMAL_DESC3_OWN_LEN,
1133 1);
1134
1135 /* Make sure ownership is written to the descriptor */
1136 dma_wmb();
1137 }
1138
1139 static void xlgmac_rx_desc_init(struct xlgmac_channel *channel)
1140 {
1141 struct xlgmac_pdata *pdata = channel->pdata;
1142 struct xlgmac_ring *ring = channel->rx_ring;
1143 unsigned int start_index = ring->cur;
1144 struct xlgmac_desc_data *desc_data;
1145 unsigned int i;
1146
1147 /* Initialize all descriptors */
1148 for (i = 0; i < ring->dma_desc_count; i++) {
1149 desc_data = XLGMAC_GET_DESC_DATA(ring, i);
1150
1151 /* Initialize Rx descriptor */
1152 xlgmac_rx_desc_reset(pdata, desc_data, i);
1153 }
1154
1155 /* Update the total number of Rx descriptors */
1156 writel(ring->dma_desc_count - 1, XLGMAC_DMA_REG(channel, DMA_CH_RDRLR));
1157
1158 /* Update the starting address of descriptor ring */
1159 desc_data = XLGMAC_GET_DESC_DATA(ring, start_index);
1160 writel(upper_32_bits(desc_data->dma_desc_addr),
1161 XLGMAC_DMA_REG(channel, DMA_CH_RDLR_HI));
1162 writel(lower_32_bits(desc_data->dma_desc_addr),
1163 XLGMAC_DMA_REG(channel, DMA_CH_RDLR_LO));
1164
1165 /* Update the Rx Descriptor Tail Pointer */
1166 desc_data = XLGMAC_GET_DESC_DATA(ring, start_index +
1167 ring->dma_desc_count - 1);
1168 writel(lower_32_bits(desc_data->dma_desc_addr),
1169 XLGMAC_DMA_REG(channel, DMA_CH_RDTR_LO));
1170 }
1171
1172 static int xlgmac_is_context_desc(struct xlgmac_dma_desc *dma_desc)
1173 {
1174 /* Rx and Tx share CTXT bit, so check TDES3.CTXT bit */
1175 return XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
1176 TX_NORMAL_DESC3_CTXT_POS,
1177 TX_NORMAL_DESC3_CTXT_LEN);
1178 }
1179
1180 static int xlgmac_is_last_desc(struct xlgmac_dma_desc *dma_desc)
1181 {
1182 /* Rx and Tx share LD bit, so check TDES3.LD bit */
1183 return XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
1184 TX_NORMAL_DESC3_LD_POS,
1185 TX_NORMAL_DESC3_LD_LEN);
1186 }
1187
1188 static int xlgmac_disable_tx_flow_control(struct xlgmac_pdata *pdata)
1189 {
1190 unsigned int max_q_count, q_count;
1191 unsigned int reg, regval;
1192 unsigned int i;
1193
1194 /* Clear MTL flow control */
1195 for (i = 0; i < pdata->rx_q_count; i++) {
1196 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1197 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_EHFC_POS,
1198 MTL_Q_RQOMR_EHFC_LEN, 0);
1199 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1200 }
1201
1202 /* Clear MAC flow control */
1203 max_q_count = XLGMAC_MAX_FLOW_CONTROL_QUEUES;
1204 q_count = min_t(unsigned int, pdata->tx_q_count, max_q_count);
1205 reg = MAC_Q0TFCR;
1206 for (i = 0; i < q_count; i++) {
1207 regval = readl(pdata->mac_regs + reg);
1208 regval = XLGMAC_SET_REG_BITS(regval,
1209 MAC_Q0TFCR_TFE_POS,
1210 MAC_Q0TFCR_TFE_LEN,
1211 0);
1212 writel(regval, pdata->mac_regs + reg);
1213
1214 reg += MAC_QTFCR_INC;
1215 }
1216
1217 return 0;
1218 }
1219
1220 static int xlgmac_enable_tx_flow_control(struct xlgmac_pdata *pdata)
1221 {
1222 unsigned int max_q_count, q_count;
1223 unsigned int reg, regval;
1224 unsigned int i;
1225
1226 /* Set MTL flow control */
1227 for (i = 0; i < pdata->rx_q_count; i++) {
1228 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1229 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_EHFC_POS,
1230 MTL_Q_RQOMR_EHFC_LEN, 1);
1231 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1232 }
1233
1234 /* Set MAC flow control */
1235 max_q_count = XLGMAC_MAX_FLOW_CONTROL_QUEUES;
1236 q_count = min_t(unsigned int, pdata->tx_q_count, max_q_count);
1237 reg = MAC_Q0TFCR;
1238 for (i = 0; i < q_count; i++) {
1239 regval = readl(pdata->mac_regs + reg);
1240
1241 /* Enable transmit flow control */
1242 regval = XLGMAC_SET_REG_BITS(regval, MAC_Q0TFCR_TFE_POS,
1243 MAC_Q0TFCR_TFE_LEN, 1);
1244 /* Set pause time */
1245 regval = XLGMAC_SET_REG_BITS(regval, MAC_Q0TFCR_PT_POS,
1246 MAC_Q0TFCR_PT_LEN, 0xffff);
1247
1248 writel(regval, pdata->mac_regs + reg);
1249
1250 reg += MAC_QTFCR_INC;
1251 }
1252
1253 return 0;
1254 }
1255
1256 static int xlgmac_disable_rx_flow_control(struct xlgmac_pdata *pdata)
1257 {
1258 u32 regval;
1259
1260 regval = readl(pdata->mac_regs + MAC_RFCR);
1261 regval = XLGMAC_SET_REG_BITS(regval, MAC_RFCR_RFE_POS,
1262 MAC_RFCR_RFE_LEN, 0);
1263 writel(regval, pdata->mac_regs + MAC_RFCR);
1264
1265 return 0;
1266 }
1267
1268 static int xlgmac_enable_rx_flow_control(struct xlgmac_pdata *pdata)
1269 {
1270 u32 regval;
1271
1272 regval = readl(pdata->mac_regs + MAC_RFCR);
1273 regval = XLGMAC_SET_REG_BITS(regval, MAC_RFCR_RFE_POS,
1274 MAC_RFCR_RFE_LEN, 1);
1275 writel(regval, pdata->mac_regs + MAC_RFCR);
1276
1277 return 0;
1278 }
1279
1280 static int xlgmac_config_tx_flow_control(struct xlgmac_pdata *pdata)
1281 {
1282 if (pdata->tx_pause)
1283 xlgmac_enable_tx_flow_control(pdata);
1284 else
1285 xlgmac_disable_tx_flow_control(pdata);
1286
1287 return 0;
1288 }
1289
1290 static int xlgmac_config_rx_flow_control(struct xlgmac_pdata *pdata)
1291 {
1292 if (pdata->rx_pause)
1293 xlgmac_enable_rx_flow_control(pdata);
1294 else
1295 xlgmac_disable_rx_flow_control(pdata);
1296
1297 return 0;
1298 }
1299
1300 static int xlgmac_config_rx_coalesce(struct xlgmac_pdata *pdata)
1301 {
1302 struct xlgmac_channel *channel;
1303 unsigned int i;
1304 u32 regval;
1305
1306 channel = pdata->channel_head;
1307 for (i = 0; i < pdata->channel_count; i++, channel++) {
1308 if (!channel->rx_ring)
1309 break;
1310
1311 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_RIWT));
1312 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_RIWT_RWT_POS,
1313 DMA_CH_RIWT_RWT_LEN,
1314 pdata->rx_riwt);
1315 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_RIWT));
1316 }
1317
1318 return 0;
1319 }
1320
1321 static void xlgmac_config_flow_control(struct xlgmac_pdata *pdata)
1322 {
1323 xlgmac_config_tx_flow_control(pdata);
1324 xlgmac_config_rx_flow_control(pdata);
1325 }
1326
1327 static void xlgmac_config_rx_fep_enable(struct xlgmac_pdata *pdata)
1328 {
1329 unsigned int i;
1330 u32 regval;
1331
1332 for (i = 0; i < pdata->rx_q_count; i++) {
1333 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1334 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_FEP_POS,
1335 MTL_Q_RQOMR_FEP_LEN, 1);
1336 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1337 }
1338 }
1339
1340 static void xlgmac_config_rx_fup_enable(struct xlgmac_pdata *pdata)
1341 {
1342 unsigned int i;
1343 u32 regval;
1344
1345 for (i = 0; i < pdata->rx_q_count; i++) {
1346 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1347 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_FUP_POS,
1348 MTL_Q_RQOMR_FUP_LEN, 1);
1349 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1350 }
1351 }
1352
1353 static int xlgmac_config_tx_coalesce(struct xlgmac_pdata *pdata)
1354 {
1355 return 0;
1356 }
1357
1358 static void xlgmac_config_rx_buffer_size(struct xlgmac_pdata *pdata)
1359 {
1360 struct xlgmac_channel *channel;
1361 unsigned int i;
1362 u32 regval;
1363
1364 channel = pdata->channel_head;
1365 for (i = 0; i < pdata->channel_count; i++, channel++) {
1366 if (!channel->rx_ring)
1367 break;
1368
1369 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_RCR));
1370 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_RCR_RBSZ_POS,
1371 DMA_CH_RCR_RBSZ_LEN,
1372 pdata->rx_buf_size);
1373 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_RCR));
1374 }
1375 }
1376
1377 static void xlgmac_config_tso_mode(struct xlgmac_pdata *pdata)
1378 {
1379 struct xlgmac_channel *channel;
1380 unsigned int i;
1381 u32 regval;
1382
1383 channel = pdata->channel_head;
1384 for (i = 0; i < pdata->channel_count; i++, channel++) {
1385 if (!channel->tx_ring)
1386 break;
1387
1388 if (pdata->hw_feat.tso) {
1389 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1390 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_TCR_TSE_POS,
1391 DMA_CH_TCR_TSE_LEN, 1);
1392 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1393 }
1394 }
1395 }
1396
1397 static void xlgmac_config_sph_mode(struct xlgmac_pdata *pdata)
1398 {
1399 struct xlgmac_channel *channel;
1400 unsigned int i;
1401 u32 regval;
1402
1403 channel = pdata->channel_head;
1404 for (i = 0; i < pdata->channel_count; i++, channel++) {
1405 if (!channel->rx_ring)
1406 break;
1407
1408 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_CR));
1409 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_CR_SPH_POS,
1410 DMA_CH_CR_SPH_LEN, 1);
1411 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_CR));
1412 }
1413
1414 regval = readl(pdata->mac_regs + MAC_RCR);
1415 regval = XLGMAC_SET_REG_BITS(regval, MAC_RCR_HDSMS_POS,
1416 MAC_RCR_HDSMS_LEN,
1417 XLGMAC_SPH_HDSMS_SIZE);
1418 writel(regval, pdata->mac_regs + MAC_RCR);
1419 }
1420
1421 static unsigned int xlgmac_usec_to_riwt(struct xlgmac_pdata *pdata,
1422 unsigned int usec)
1423 {
1424 unsigned long rate;
1425 unsigned int ret;
1426
1427 rate = pdata->sysclk_rate;
1428
1429 /* Convert the input usec value to the watchdog timer value. Each
1430 * watchdog timer value is equivalent to 256 clock cycles.
1431 * Calculate the required value as:
1432 * ( usec * ( system_clock_mhz / 10^6 ) / 256
1433 */
1434 ret = (usec * (rate / 1000000)) / 256;
1435
1436 return ret;
1437 }
1438
1439 static unsigned int xlgmac_riwt_to_usec(struct xlgmac_pdata *pdata,
1440 unsigned int riwt)
1441 {
1442 unsigned long rate;
1443 unsigned int ret;
1444
1445 rate = pdata->sysclk_rate;
1446
1447 /* Convert the input watchdog timer value to the usec value. Each
1448 * watchdog timer value is equivalent to 256 clock cycles.
1449 * Calculate the required value as:
1450 * ( riwt * 256 ) / ( system_clock_mhz / 10^6 )
1451 */
1452 ret = (riwt * 256) / (rate / 1000000);
1453
1454 return ret;
1455 }
1456
1457 static int xlgmac_config_rx_threshold(struct xlgmac_pdata *pdata,
1458 unsigned int val)
1459 {
1460 unsigned int i;
1461 u32 regval;
1462
1463 for (i = 0; i < pdata->rx_q_count; i++) {
1464 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1465 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_RTC_POS,
1466 MTL_Q_RQOMR_RTC_LEN, val);
1467 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1468 }
1469
1470 return 0;
1471 }
1472
1473 static void xlgmac_config_mtl_mode(struct xlgmac_pdata *pdata)
1474 {
1475 unsigned int i;
1476 u32 regval;
1477
1478 /* Set Tx to weighted round robin scheduling algorithm */
1479 regval = readl(pdata->mac_regs + MTL_OMR);
1480 regval = XLGMAC_SET_REG_BITS(regval, MTL_OMR_ETSALG_POS,
1481 MTL_OMR_ETSALG_LEN, MTL_ETSALG_WRR);
1482 writel(regval, pdata->mac_regs + MTL_OMR);
1483
1484 /* Set Tx traffic classes to use WRR algorithm with equal weights */
1485 for (i = 0; i < pdata->hw_feat.tc_cnt; i++) {
1486 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_TC_ETSCR));
1487 regval = XLGMAC_SET_REG_BITS(regval, MTL_TC_ETSCR_TSA_POS,
1488 MTL_TC_ETSCR_TSA_LEN, MTL_TSA_ETS);
1489 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_TC_ETSCR));
1490
1491 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_TC_QWR));
1492 regval = XLGMAC_SET_REG_BITS(regval, MTL_TC_QWR_QW_POS,
1493 MTL_TC_QWR_QW_LEN, 1);
1494 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_TC_QWR));
1495 }
1496
1497 /* Set Rx to strict priority algorithm */
1498 regval = readl(pdata->mac_regs + MTL_OMR);
1499 regval = XLGMAC_SET_REG_BITS(regval, MTL_OMR_RAA_POS,
1500 MTL_OMR_RAA_LEN, MTL_RAA_SP);
1501 writel(regval, pdata->mac_regs + MTL_OMR);
1502 }
1503
1504 static void xlgmac_config_queue_mapping(struct xlgmac_pdata *pdata)
1505 {
1506 unsigned int ppq, ppq_extra, prio, prio_queues;
1507 unsigned int qptc, qptc_extra, queue;
1508 unsigned int reg, regval;
1509 unsigned int mask;
1510 unsigned int i, j;
1511
1512 /* Map the MTL Tx Queues to Traffic Classes
1513 * Note: Tx Queues >= Traffic Classes
1514 */
1515 qptc = pdata->tx_q_count / pdata->hw_feat.tc_cnt;
1516 qptc_extra = pdata->tx_q_count % pdata->hw_feat.tc_cnt;
1517
1518 for (i = 0, queue = 0; i < pdata->hw_feat.tc_cnt; i++) {
1519 for (j = 0; j < qptc; j++) {
1520 netif_dbg(pdata, drv, pdata->netdev,
1521 "TXq%u mapped to TC%u\n", queue, i);
1522 regval = readl(XLGMAC_MTL_REG(pdata, queue,
1523 MTL_Q_TQOMR));
1524 regval = XLGMAC_SET_REG_BITS(regval,
1525 MTL_Q_TQOMR_Q2TCMAP_POS,
1526 MTL_Q_TQOMR_Q2TCMAP_LEN,
1527 i);
1528 writel(regval, XLGMAC_MTL_REG(pdata, queue,
1529 MTL_Q_TQOMR));
1530 queue++;
1531 }
1532
1533 if (i < qptc_extra) {
1534 netif_dbg(pdata, drv, pdata->netdev,
1535 "TXq%u mapped to TC%u\n", queue, i);
1536 regval = readl(XLGMAC_MTL_REG(pdata, queue,
1537 MTL_Q_TQOMR));
1538 regval = XLGMAC_SET_REG_BITS(regval,
1539 MTL_Q_TQOMR_Q2TCMAP_POS,
1540 MTL_Q_TQOMR_Q2TCMAP_LEN,
1541 i);
1542 writel(regval, XLGMAC_MTL_REG(pdata, queue,
1543 MTL_Q_TQOMR));
1544 queue++;
1545 }
1546 }
1547
1548 /* Map the 8 VLAN priority values to available MTL Rx queues */
1549 prio_queues = min_t(unsigned int, IEEE_8021QAZ_MAX_TCS,
1550 pdata->rx_q_count);
1551 ppq = IEEE_8021QAZ_MAX_TCS / prio_queues;
1552 ppq_extra = IEEE_8021QAZ_MAX_TCS % prio_queues;
1553
1554 reg = MAC_RQC2R;
1555 regval = 0;
1556 for (i = 0, prio = 0; i < prio_queues;) {
1557 mask = 0;
1558 for (j = 0; j < ppq; j++) {
1559 netif_dbg(pdata, drv, pdata->netdev,
1560 "PRIO%u mapped to RXq%u\n", prio, i);
1561 mask |= (1 << prio);
1562 prio++;
1563 }
1564
1565 if (i < ppq_extra) {
1566 netif_dbg(pdata, drv, pdata->netdev,
1567 "PRIO%u mapped to RXq%u\n", prio, i);
1568 mask |= (1 << prio);
1569 prio++;
1570 }
1571
1572 regval |= (mask << ((i++ % MAC_RQC2_Q_PER_REG) << 3));
1573
1574 if ((i % MAC_RQC2_Q_PER_REG) && (i != prio_queues))
1575 continue;
1576
1577 writel(regval, pdata->mac_regs + reg);
1578 reg += MAC_RQC2_INC;
1579 regval = 0;
1580 }
1581
1582 /* Configure one to one, MTL Rx queue to DMA Rx channel mapping
1583 * ie Q0 <--> CH0, Q1 <--> CH1 ... Q11 <--> CH11
1584 */
1585 reg = MTL_RQDCM0R;
1586 regval = readl(pdata->mac_regs + reg);
1587 regval |= (MTL_RQDCM0R_Q0MDMACH | MTL_RQDCM0R_Q1MDMACH |
1588 MTL_RQDCM0R_Q2MDMACH | MTL_RQDCM0R_Q3MDMACH);
1589 writel(regval, pdata->mac_regs + reg);
1590
1591 reg += MTL_RQDCM_INC;
1592 regval = readl(pdata->mac_regs + reg);
1593 regval |= (MTL_RQDCM1R_Q4MDMACH | MTL_RQDCM1R_Q5MDMACH |
1594 MTL_RQDCM1R_Q6MDMACH | MTL_RQDCM1R_Q7MDMACH);
1595 writel(regval, pdata->mac_regs + reg);
1596
1597 reg += MTL_RQDCM_INC;
1598 regval = readl(pdata->mac_regs + reg);
1599 regval |= (MTL_RQDCM2R_Q8MDMACH | MTL_RQDCM2R_Q9MDMACH |
1600 MTL_RQDCM2R_Q10MDMACH | MTL_RQDCM2R_Q11MDMACH);
1601 writel(regval, pdata->mac_regs + reg);
1602 }
1603
1604 static unsigned int xlgmac_calculate_per_queue_fifo(
1605 unsigned int fifo_size,
1606 unsigned int queue_count)
1607 {
1608 unsigned int q_fifo_size;
1609 unsigned int p_fifo;
1610
1611 /* Calculate the configured fifo size */
1612 q_fifo_size = 1 << (fifo_size + 7);
1613
1614 /* The configured value may not be the actual amount of fifo RAM */
1615 q_fifo_size = min_t(unsigned int, XLGMAC_MAX_FIFO, q_fifo_size);
1616
1617 q_fifo_size = q_fifo_size / queue_count;
1618
1619 /* Each increment in the queue fifo size represents 256 bytes of
1620 * fifo, with 0 representing 256 bytes. Distribute the fifo equally
1621 * between the queues.
1622 */
1623 p_fifo = q_fifo_size / 256;
1624 if (p_fifo)
1625 p_fifo--;
1626
1627 return p_fifo;
1628 }
1629
1630 static void xlgmac_config_tx_fifo_size(struct xlgmac_pdata *pdata)
1631 {
1632 unsigned int fifo_size;
1633 unsigned int i;
1634 u32 regval;
1635
1636 fifo_size = xlgmac_calculate_per_queue_fifo(
1637 pdata->hw_feat.tx_fifo_size,
1638 pdata->tx_q_count);
1639
1640 for (i = 0; i < pdata->tx_q_count; i++) {
1641 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1642 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_TQS_POS,
1643 MTL_Q_TQOMR_TQS_LEN, fifo_size);
1644 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1645 }
1646
1647 netif_info(pdata, drv, pdata->netdev,
1648 "%d Tx hardware queues, %d byte fifo per queue\n",
1649 pdata->tx_q_count, ((fifo_size + 1) * 256));
1650 }
1651
1652 static void xlgmac_config_rx_fifo_size(struct xlgmac_pdata *pdata)
1653 {
1654 unsigned int fifo_size;
1655 unsigned int i;
1656 u32 regval;
1657
1658 fifo_size = xlgmac_calculate_per_queue_fifo(
1659 pdata->hw_feat.rx_fifo_size,
1660 pdata->rx_q_count);
1661
1662 for (i = 0; i < pdata->rx_q_count; i++) {
1663 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1664 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_RQS_POS,
1665 MTL_Q_RQOMR_RQS_LEN, fifo_size);
1666 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1667 }
1668
1669 netif_info(pdata, drv, pdata->netdev,
1670 "%d Rx hardware queues, %d byte fifo per queue\n",
1671 pdata->rx_q_count, ((fifo_size + 1) * 256));
1672 }
1673
1674 static void xlgmac_config_flow_control_threshold(struct xlgmac_pdata *pdata)
1675 {
1676 unsigned int i;
1677 u32 regval;
1678
1679 for (i = 0; i < pdata->rx_q_count; i++) {
1680 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQFCR));
1681 /* Activate flow control when less than 4k left in fifo */
1682 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQFCR_RFA_POS,
1683 MTL_Q_RQFCR_RFA_LEN, 2);
1684 /* De-activate flow control when more than 6k left in fifo */
1685 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQFCR_RFD_POS,
1686 MTL_Q_RQFCR_RFD_LEN, 4);
1687 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQFCR));
1688 }
1689 }
1690
1691 static int xlgmac_config_tx_threshold(struct xlgmac_pdata *pdata,
1692 unsigned int val)
1693 {
1694 unsigned int i;
1695 u32 regval;
1696
1697 for (i = 0; i < pdata->tx_q_count; i++) {
1698 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1699 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_TTC_POS,
1700 MTL_Q_TQOMR_TTC_LEN, val);
1701 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1702 }
1703
1704 return 0;
1705 }
1706
1707 static int xlgmac_config_rsf_mode(struct xlgmac_pdata *pdata,
1708 unsigned int val)
1709 {
1710 unsigned int i;
1711 u32 regval;
1712
1713 for (i = 0; i < pdata->rx_q_count; i++) {
1714 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1715 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_RQOMR_RSF_POS,
1716 MTL_Q_RQOMR_RSF_LEN, val);
1717 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_RQOMR));
1718 }
1719
1720 return 0;
1721 }
1722
1723 static int xlgmac_config_tsf_mode(struct xlgmac_pdata *pdata,
1724 unsigned int val)
1725 {
1726 unsigned int i;
1727 u32 regval;
1728
1729 for (i = 0; i < pdata->tx_q_count; i++) {
1730 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1731 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_TSF_POS,
1732 MTL_Q_TQOMR_TSF_LEN, val);
1733 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
1734 }
1735
1736 return 0;
1737 }
1738
1739 static int xlgmac_config_osp_mode(struct xlgmac_pdata *pdata)
1740 {
1741 struct xlgmac_channel *channel;
1742 unsigned int i;
1743 u32 regval;
1744
1745 channel = pdata->channel_head;
1746 for (i = 0; i < pdata->channel_count; i++, channel++) {
1747 if (!channel->tx_ring)
1748 break;
1749
1750 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1751 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_TCR_OSP_POS,
1752 DMA_CH_TCR_OSP_LEN,
1753 pdata->tx_osp_mode);
1754 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1755 }
1756
1757 return 0;
1758 }
1759
1760 static int xlgmac_config_pblx8(struct xlgmac_pdata *pdata)
1761 {
1762 struct xlgmac_channel *channel;
1763 unsigned int i;
1764 u32 regval;
1765
1766 channel = pdata->channel_head;
1767 for (i = 0; i < pdata->channel_count; i++, channel++) {
1768 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_CR));
1769 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_CR_PBLX8_POS,
1770 DMA_CH_CR_PBLX8_LEN,
1771 pdata->pblx8);
1772 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_CR));
1773 }
1774
1775 return 0;
1776 }
1777
1778 static int xlgmac_get_tx_pbl_val(struct xlgmac_pdata *pdata)
1779 {
1780 u32 regval;
1781
1782 regval = readl(XLGMAC_DMA_REG(pdata->channel_head, DMA_CH_TCR));
1783 regval = XLGMAC_GET_REG_BITS(regval, DMA_CH_TCR_PBL_POS,
1784 DMA_CH_TCR_PBL_LEN);
1785 return regval;
1786 }
1787
1788 static int xlgmac_config_tx_pbl_val(struct xlgmac_pdata *pdata)
1789 {
1790 struct xlgmac_channel *channel;
1791 unsigned int i;
1792 u32 regval;
1793
1794 channel = pdata->channel_head;
1795 for (i = 0; i < pdata->channel_count; i++, channel++) {
1796 if (!channel->tx_ring)
1797 break;
1798
1799 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1800 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_TCR_PBL_POS,
1801 DMA_CH_TCR_PBL_LEN,
1802 pdata->tx_pbl);
1803 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_TCR));
1804 }
1805
1806 return 0;
1807 }
1808
1809 static int xlgmac_get_rx_pbl_val(struct xlgmac_pdata *pdata)
1810 {
1811 u32 regval;
1812
1813 regval = readl(XLGMAC_DMA_REG(pdata->channel_head, DMA_CH_RCR));
1814 regval = XLGMAC_GET_REG_BITS(regval, DMA_CH_RCR_PBL_POS,
1815 DMA_CH_RCR_PBL_LEN);
1816 return regval;
1817 }
1818
1819 static int xlgmac_config_rx_pbl_val(struct xlgmac_pdata *pdata)
1820 {
1821 struct xlgmac_channel *channel;
1822 unsigned int i;
1823 u32 regval;
1824
1825 channel = pdata->channel_head;
1826 for (i = 0; i < pdata->channel_count; i++, channel++) {
1827 if (!channel->rx_ring)
1828 break;
1829
1830 regval = readl(XLGMAC_DMA_REG(channel, DMA_CH_RCR));
1831 regval = XLGMAC_SET_REG_BITS(regval, DMA_CH_RCR_PBL_POS,
1832 DMA_CH_RCR_PBL_LEN,
1833 pdata->rx_pbl);
1834 writel(regval, XLGMAC_DMA_REG(channel, DMA_CH_RCR));
1835 }
1836
1837 return 0;
1838 }
1839
1840 static u64 xlgmac_mmc_read(struct xlgmac_pdata *pdata, unsigned int reg_lo)
1841 {
1842 bool read_hi;
1843 u64 val;
1844
1845 switch (reg_lo) {
1846 /* These registers are always 64 bit */
1847 case MMC_TXOCTETCOUNT_GB_LO:
1848 case MMC_TXOCTETCOUNT_G_LO:
1849 case MMC_RXOCTETCOUNT_GB_LO:
1850 case MMC_RXOCTETCOUNT_G_LO:
1851 read_hi = true;
1852 break;
1853
1854 default:
1855 read_hi = false;
1856 }
1857
1858 val = (u64)readl(pdata->mac_regs + reg_lo);
1859
1860 if (read_hi)
1861 val |= ((u64)readl(pdata->mac_regs + reg_lo + 4) << 32);
1862
1863 return val;
1864 }
1865
1866 static void xlgmac_tx_mmc_int(struct xlgmac_pdata *pdata)
1867 {
1868 unsigned int mmc_isr = readl(pdata->mac_regs + MMC_TISR);
1869 struct xlgmac_stats *stats = &pdata->stats;
1870
1871 if (XLGMAC_GET_REG_BITS(mmc_isr,
1872 MMC_TISR_TXOCTETCOUNT_GB_POS,
1873 MMC_TISR_TXOCTETCOUNT_GB_LEN))
1874 stats->txoctetcount_gb +=
1875 xlgmac_mmc_read(pdata, MMC_TXOCTETCOUNT_GB_LO);
1876
1877 if (XLGMAC_GET_REG_BITS(mmc_isr,
1878 MMC_TISR_TXFRAMECOUNT_GB_POS,
1879 MMC_TISR_TXFRAMECOUNT_GB_LEN))
1880 stats->txframecount_gb +=
1881 xlgmac_mmc_read(pdata, MMC_TXFRAMECOUNT_GB_LO);
1882
1883 if (XLGMAC_GET_REG_BITS(mmc_isr,
1884 MMC_TISR_TXBROADCASTFRAMES_G_POS,
1885 MMC_TISR_TXBROADCASTFRAMES_G_LEN))
1886 stats->txbroadcastframes_g +=
1887 xlgmac_mmc_read(pdata, MMC_TXBROADCASTFRAMES_G_LO);
1888
1889 if (XLGMAC_GET_REG_BITS(mmc_isr,
1890 MMC_TISR_TXMULTICASTFRAMES_G_POS,
1891 MMC_TISR_TXMULTICASTFRAMES_G_LEN))
1892 stats->txmulticastframes_g +=
1893 xlgmac_mmc_read(pdata, MMC_TXMULTICASTFRAMES_G_LO);
1894
1895 if (XLGMAC_GET_REG_BITS(mmc_isr,
1896 MMC_TISR_TX64OCTETS_GB_POS,
1897 MMC_TISR_TX64OCTETS_GB_LEN))
1898 stats->tx64octets_gb +=
1899 xlgmac_mmc_read(pdata, MMC_TX64OCTETS_GB_LO);
1900
1901 if (XLGMAC_GET_REG_BITS(mmc_isr,
1902 MMC_TISR_TX65TO127OCTETS_GB_POS,
1903 MMC_TISR_TX65TO127OCTETS_GB_LEN))
1904 stats->tx65to127octets_gb +=
1905 xlgmac_mmc_read(pdata, MMC_TX65TO127OCTETS_GB_LO);
1906
1907 if (XLGMAC_GET_REG_BITS(mmc_isr,
1908 MMC_TISR_TX128TO255OCTETS_GB_POS,
1909 MMC_TISR_TX128TO255OCTETS_GB_LEN))
1910 stats->tx128to255octets_gb +=
1911 xlgmac_mmc_read(pdata, MMC_TX128TO255OCTETS_GB_LO);
1912
1913 if (XLGMAC_GET_REG_BITS(mmc_isr,
1914 MMC_TISR_TX256TO511OCTETS_GB_POS,
1915 MMC_TISR_TX256TO511OCTETS_GB_LEN))
1916 stats->tx256to511octets_gb +=
1917 xlgmac_mmc_read(pdata, MMC_TX256TO511OCTETS_GB_LO);
1918
1919 if (XLGMAC_GET_REG_BITS(mmc_isr,
1920 MMC_TISR_TX512TO1023OCTETS_GB_POS,
1921 MMC_TISR_TX512TO1023OCTETS_GB_LEN))
1922 stats->tx512to1023octets_gb +=
1923 xlgmac_mmc_read(pdata, MMC_TX512TO1023OCTETS_GB_LO);
1924
1925 if (XLGMAC_GET_REG_BITS(mmc_isr,
1926 MMC_TISR_TX1024TOMAXOCTETS_GB_POS,
1927 MMC_TISR_TX1024TOMAXOCTETS_GB_LEN))
1928 stats->tx1024tomaxoctets_gb +=
1929 xlgmac_mmc_read(pdata, MMC_TX1024TOMAXOCTETS_GB_LO);
1930
1931 if (XLGMAC_GET_REG_BITS(mmc_isr,
1932 MMC_TISR_TXUNICASTFRAMES_GB_POS,
1933 MMC_TISR_TXUNICASTFRAMES_GB_LEN))
1934 stats->txunicastframes_gb +=
1935 xlgmac_mmc_read(pdata, MMC_TXUNICASTFRAMES_GB_LO);
1936
1937 if (XLGMAC_GET_REG_BITS(mmc_isr,
1938 MMC_TISR_TXMULTICASTFRAMES_GB_POS,
1939 MMC_TISR_TXMULTICASTFRAMES_GB_LEN))
1940 stats->txmulticastframes_gb +=
1941 xlgmac_mmc_read(pdata, MMC_TXMULTICASTFRAMES_GB_LO);
1942
1943 if (XLGMAC_GET_REG_BITS(mmc_isr,
1944 MMC_TISR_TXBROADCASTFRAMES_GB_POS,
1945 MMC_TISR_TXBROADCASTFRAMES_GB_LEN))
1946 stats->txbroadcastframes_g +=
1947 xlgmac_mmc_read(pdata, MMC_TXBROADCASTFRAMES_GB_LO);
1948
1949 if (XLGMAC_GET_REG_BITS(mmc_isr,
1950 MMC_TISR_TXUNDERFLOWERROR_POS,
1951 MMC_TISR_TXUNDERFLOWERROR_LEN))
1952 stats->txunderflowerror +=
1953 xlgmac_mmc_read(pdata, MMC_TXUNDERFLOWERROR_LO);
1954
1955 if (XLGMAC_GET_REG_BITS(mmc_isr,
1956 MMC_TISR_TXOCTETCOUNT_G_POS,
1957 MMC_TISR_TXOCTETCOUNT_G_LEN))
1958 stats->txoctetcount_g +=
1959 xlgmac_mmc_read(pdata, MMC_TXOCTETCOUNT_G_LO);
1960
1961 if (XLGMAC_GET_REG_BITS(mmc_isr,
1962 MMC_TISR_TXFRAMECOUNT_G_POS,
1963 MMC_TISR_TXFRAMECOUNT_G_LEN))
1964 stats->txframecount_g +=
1965 xlgmac_mmc_read(pdata, MMC_TXFRAMECOUNT_G_LO);
1966
1967 if (XLGMAC_GET_REG_BITS(mmc_isr,
1968 MMC_TISR_TXPAUSEFRAMES_POS,
1969 MMC_TISR_TXPAUSEFRAMES_LEN))
1970 stats->txpauseframes +=
1971 xlgmac_mmc_read(pdata, MMC_TXPAUSEFRAMES_LO);
1972
1973 if (XLGMAC_GET_REG_BITS(mmc_isr,
1974 MMC_TISR_TXVLANFRAMES_G_POS,
1975 MMC_TISR_TXVLANFRAMES_G_LEN))
1976 stats->txvlanframes_g +=
1977 xlgmac_mmc_read(pdata, MMC_TXVLANFRAMES_G_LO);
1978 }
1979
1980 static void xlgmac_rx_mmc_int(struct xlgmac_pdata *pdata)
1981 {
1982 unsigned int mmc_isr = readl(pdata->mac_regs + MMC_RISR);
1983 struct xlgmac_stats *stats = &pdata->stats;
1984
1985 if (XLGMAC_GET_REG_BITS(mmc_isr,
1986 MMC_RISR_RXFRAMECOUNT_GB_POS,
1987 MMC_RISR_RXFRAMECOUNT_GB_LEN))
1988 stats->rxframecount_gb +=
1989 xlgmac_mmc_read(pdata, MMC_RXFRAMECOUNT_GB_LO);
1990
1991 if (XLGMAC_GET_REG_BITS(mmc_isr,
1992 MMC_RISR_RXOCTETCOUNT_GB_POS,
1993 MMC_RISR_RXOCTETCOUNT_GB_LEN))
1994 stats->rxoctetcount_gb +=
1995 xlgmac_mmc_read(pdata, MMC_RXOCTETCOUNT_GB_LO);
1996
1997 if (XLGMAC_GET_REG_BITS(mmc_isr,
1998 MMC_RISR_RXOCTETCOUNT_G_POS,
1999 MMC_RISR_RXOCTETCOUNT_G_LEN))
2000 stats->rxoctetcount_g +=
2001 xlgmac_mmc_read(pdata, MMC_RXOCTETCOUNT_G_LO);
2002
2003 if (XLGMAC_GET_REG_BITS(mmc_isr,
2004 MMC_RISR_RXBROADCASTFRAMES_G_POS,
2005 MMC_RISR_RXBROADCASTFRAMES_G_LEN))
2006 stats->rxbroadcastframes_g +=
2007 xlgmac_mmc_read(pdata, MMC_RXBROADCASTFRAMES_G_LO);
2008
2009 if (XLGMAC_GET_REG_BITS(mmc_isr,
2010 MMC_RISR_RXMULTICASTFRAMES_G_POS,
2011 MMC_RISR_RXMULTICASTFRAMES_G_LEN))
2012 stats->rxmulticastframes_g +=
2013 xlgmac_mmc_read(pdata, MMC_RXMULTICASTFRAMES_G_LO);
2014
2015 if (XLGMAC_GET_REG_BITS(mmc_isr,
2016 MMC_RISR_RXCRCERROR_POS,
2017 MMC_RISR_RXCRCERROR_LEN))
2018 stats->rxcrcerror +=
2019 xlgmac_mmc_read(pdata, MMC_RXCRCERROR_LO);
2020
2021 if (XLGMAC_GET_REG_BITS(mmc_isr,
2022 MMC_RISR_RXRUNTERROR_POS,
2023 MMC_RISR_RXRUNTERROR_LEN))
2024 stats->rxrunterror +=
2025 xlgmac_mmc_read(pdata, MMC_RXRUNTERROR);
2026
2027 if (XLGMAC_GET_REG_BITS(mmc_isr,
2028 MMC_RISR_RXJABBERERROR_POS,
2029 MMC_RISR_RXJABBERERROR_LEN))
2030 stats->rxjabbererror +=
2031 xlgmac_mmc_read(pdata, MMC_RXJABBERERROR);
2032
2033 if (XLGMAC_GET_REG_BITS(mmc_isr,
2034 MMC_RISR_RXUNDERSIZE_G_POS,
2035 MMC_RISR_RXUNDERSIZE_G_LEN))
2036 stats->rxundersize_g +=
2037 xlgmac_mmc_read(pdata, MMC_RXUNDERSIZE_G);
2038
2039 if (XLGMAC_GET_REG_BITS(mmc_isr,
2040 MMC_RISR_RXOVERSIZE_G_POS,
2041 MMC_RISR_RXOVERSIZE_G_LEN))
2042 stats->rxoversize_g +=
2043 xlgmac_mmc_read(pdata, MMC_RXOVERSIZE_G);
2044
2045 if (XLGMAC_GET_REG_BITS(mmc_isr,
2046 MMC_RISR_RX64OCTETS_GB_POS,
2047 MMC_RISR_RX64OCTETS_GB_LEN))
2048 stats->rx64octets_gb +=
2049 xlgmac_mmc_read(pdata, MMC_RX64OCTETS_GB_LO);
2050
2051 if (XLGMAC_GET_REG_BITS(mmc_isr,
2052 MMC_RISR_RX65TO127OCTETS_GB_POS,
2053 MMC_RISR_RX65TO127OCTETS_GB_LEN))
2054 stats->rx65to127octets_gb +=
2055 xlgmac_mmc_read(pdata, MMC_RX65TO127OCTETS_GB_LO);
2056
2057 if (XLGMAC_GET_REG_BITS(mmc_isr,
2058 MMC_RISR_RX128TO255OCTETS_GB_POS,
2059 MMC_RISR_RX128TO255OCTETS_GB_LEN))
2060 stats->rx128to255octets_gb +=
2061 xlgmac_mmc_read(pdata, MMC_RX128TO255OCTETS_GB_LO);
2062
2063 if (XLGMAC_GET_REG_BITS(mmc_isr,
2064 MMC_RISR_RX256TO511OCTETS_GB_POS,
2065 MMC_RISR_RX256TO511OCTETS_GB_LEN))
2066 stats->rx256to511octets_gb +=
2067 xlgmac_mmc_read(pdata, MMC_RX256TO511OCTETS_GB_LO);
2068
2069 if (XLGMAC_GET_REG_BITS(mmc_isr,
2070 MMC_RISR_RX512TO1023OCTETS_GB_POS,
2071 MMC_RISR_RX512TO1023OCTETS_GB_LEN))
2072 stats->rx512to1023octets_gb +=
2073 xlgmac_mmc_read(pdata, MMC_RX512TO1023OCTETS_GB_LO);
2074
2075 if (XLGMAC_GET_REG_BITS(mmc_isr,
2076 MMC_RISR_RX1024TOMAXOCTETS_GB_POS,
2077 MMC_RISR_RX1024TOMAXOCTETS_GB_LEN))
2078 stats->rx1024tomaxoctets_gb +=
2079 xlgmac_mmc_read(pdata, MMC_RX1024TOMAXOCTETS_GB_LO);
2080
2081 if (XLGMAC_GET_REG_BITS(mmc_isr,
2082 MMC_RISR_RXUNICASTFRAMES_G_POS,
2083 MMC_RISR_RXUNICASTFRAMES_G_LEN))
2084 stats->rxunicastframes_g +=
2085 xlgmac_mmc_read(pdata, MMC_RXUNICASTFRAMES_G_LO);
2086
2087 if (XLGMAC_GET_REG_BITS(mmc_isr,
2088 MMC_RISR_RXLENGTHERROR_POS,
2089 MMC_RISR_RXLENGTHERROR_LEN))
2090 stats->rxlengtherror +=
2091 xlgmac_mmc_read(pdata, MMC_RXLENGTHERROR_LO);
2092
2093 if (XLGMAC_GET_REG_BITS(mmc_isr,
2094 MMC_RISR_RXOUTOFRANGETYPE_POS,
2095 MMC_RISR_RXOUTOFRANGETYPE_LEN))
2096 stats->rxoutofrangetype +=
2097 xlgmac_mmc_read(pdata, MMC_RXOUTOFRANGETYPE_LO);
2098
2099 if (XLGMAC_GET_REG_BITS(mmc_isr,
2100 MMC_RISR_RXPAUSEFRAMES_POS,
2101 MMC_RISR_RXPAUSEFRAMES_LEN))
2102 stats->rxpauseframes +=
2103 xlgmac_mmc_read(pdata, MMC_RXPAUSEFRAMES_LO);
2104
2105 if (XLGMAC_GET_REG_BITS(mmc_isr,
2106 MMC_RISR_RXFIFOOVERFLOW_POS,
2107 MMC_RISR_RXFIFOOVERFLOW_LEN))
2108 stats->rxfifooverflow +=
2109 xlgmac_mmc_read(pdata, MMC_RXFIFOOVERFLOW_LO);
2110
2111 if (XLGMAC_GET_REG_BITS(mmc_isr,
2112 MMC_RISR_RXVLANFRAMES_GB_POS,
2113 MMC_RISR_RXVLANFRAMES_GB_LEN))
2114 stats->rxvlanframes_gb +=
2115 xlgmac_mmc_read(pdata, MMC_RXVLANFRAMES_GB_LO);
2116
2117 if (XLGMAC_GET_REG_BITS(mmc_isr,
2118 MMC_RISR_RXWATCHDOGERROR_POS,
2119 MMC_RISR_RXWATCHDOGERROR_LEN))
2120 stats->rxwatchdogerror +=
2121 xlgmac_mmc_read(pdata, MMC_RXWATCHDOGERROR);
2122 }
2123
2124 static void xlgmac_read_mmc_stats(struct xlgmac_pdata *pdata)
2125 {
2126 struct xlgmac_stats *stats = &pdata->stats;
2127 u32 regval;
2128
2129 /* Freeze counters */
2130 regval = readl(pdata->mac_regs + MMC_CR);
2131 regval = XLGMAC_SET_REG_BITS(regval, MMC_CR_MCF_POS,
2132 MMC_CR_MCF_LEN, 1);
2133 writel(regval, pdata->mac_regs + MMC_CR);
2134
2135 stats->txoctetcount_gb +=
2136 xlgmac_mmc_read(pdata, MMC_TXOCTETCOUNT_GB_LO);
2137
2138 stats->txframecount_gb +=
2139 xlgmac_mmc_read(pdata, MMC_TXFRAMECOUNT_GB_LO);
2140
2141 stats->txbroadcastframes_g +=
2142 xlgmac_mmc_read(pdata, MMC_TXBROADCASTFRAMES_G_LO);
2143
2144 stats->txmulticastframes_g +=
2145 xlgmac_mmc_read(pdata, MMC_TXMULTICASTFRAMES_G_LO);
2146
2147 stats->tx64octets_gb +=
2148 xlgmac_mmc_read(pdata, MMC_TX64OCTETS_GB_LO);
2149
2150 stats->tx65to127octets_gb +=
2151 xlgmac_mmc_read(pdata, MMC_TX65TO127OCTETS_GB_LO);
2152
2153 stats->tx128to255octets_gb +=
2154 xlgmac_mmc_read(pdata, MMC_TX128TO255OCTETS_GB_LO);
2155
2156 stats->tx256to511octets_gb +=
2157 xlgmac_mmc_read(pdata, MMC_TX256TO511OCTETS_GB_LO);
2158
2159 stats->tx512to1023octets_gb +=
2160 xlgmac_mmc_read(pdata, MMC_TX512TO1023OCTETS_GB_LO);
2161
2162 stats->tx1024tomaxoctets_gb +=
2163 xlgmac_mmc_read(pdata, MMC_TX1024TOMAXOCTETS_GB_LO);
2164
2165 stats->txunicastframes_gb +=
2166 xlgmac_mmc_read(pdata, MMC_TXUNICASTFRAMES_GB_LO);
2167
2168 stats->txmulticastframes_gb +=
2169 xlgmac_mmc_read(pdata, MMC_TXMULTICASTFRAMES_GB_LO);
2170
2171 stats->txbroadcastframes_g +=
2172 xlgmac_mmc_read(pdata, MMC_TXBROADCASTFRAMES_GB_LO);
2173
2174 stats->txunderflowerror +=
2175 xlgmac_mmc_read(pdata, MMC_TXUNDERFLOWERROR_LO);
2176
2177 stats->txoctetcount_g +=
2178 xlgmac_mmc_read(pdata, MMC_TXOCTETCOUNT_G_LO);
2179
2180 stats->txframecount_g +=
2181 xlgmac_mmc_read(pdata, MMC_TXFRAMECOUNT_G_LO);
2182
2183 stats->txpauseframes +=
2184 xlgmac_mmc_read(pdata, MMC_TXPAUSEFRAMES_LO);
2185
2186 stats->txvlanframes_g +=
2187 xlgmac_mmc_read(pdata, MMC_TXVLANFRAMES_G_LO);
2188
2189 stats->rxframecount_gb +=
2190 xlgmac_mmc_read(pdata, MMC_RXFRAMECOUNT_GB_LO);
2191
2192 stats->rxoctetcount_gb +=
2193 xlgmac_mmc_read(pdata, MMC_RXOCTETCOUNT_GB_LO);
2194
2195 stats->rxoctetcount_g +=
2196 xlgmac_mmc_read(pdata, MMC_RXOCTETCOUNT_G_LO);
2197
2198 stats->rxbroadcastframes_g +=
2199 xlgmac_mmc_read(pdata, MMC_RXBROADCASTFRAMES_G_LO);
2200
2201 stats->rxmulticastframes_g +=
2202 xlgmac_mmc_read(pdata, MMC_RXMULTICASTFRAMES_G_LO);
2203
2204 stats->rxcrcerror +=
2205 xlgmac_mmc_read(pdata, MMC_RXCRCERROR_LO);
2206
2207 stats->rxrunterror +=
2208 xlgmac_mmc_read(pdata, MMC_RXRUNTERROR);
2209
2210 stats->rxjabbererror +=
2211 xlgmac_mmc_read(pdata, MMC_RXJABBERERROR);
2212
2213 stats->rxundersize_g +=
2214 xlgmac_mmc_read(pdata, MMC_RXUNDERSIZE_G);
2215
2216 stats->rxoversize_g +=
2217 xlgmac_mmc_read(pdata, MMC_RXOVERSIZE_G);
2218
2219 stats->rx64octets_gb +=
2220 xlgmac_mmc_read(pdata, MMC_RX64OCTETS_GB_LO);
2221
2222 stats->rx65to127octets_gb +=
2223 xlgmac_mmc_read(pdata, MMC_RX65TO127OCTETS_GB_LO);
2224
2225 stats->rx128to255octets_gb +=
2226 xlgmac_mmc_read(pdata, MMC_RX128TO255OCTETS_GB_LO);
2227
2228 stats->rx256to511octets_gb +=
2229 xlgmac_mmc_read(pdata, MMC_RX256TO511OCTETS_GB_LO);
2230
2231 stats->rx512to1023octets_gb +=
2232 xlgmac_mmc_read(pdata, MMC_RX512TO1023OCTETS_GB_LO);
2233
2234 stats->rx1024tomaxoctets_gb +=
2235 xlgmac_mmc_read(pdata, MMC_RX1024TOMAXOCTETS_GB_LO);
2236
2237 stats->rxunicastframes_g +=
2238 xlgmac_mmc_read(pdata, MMC_RXUNICASTFRAMES_G_LO);
2239
2240 stats->rxlengtherror +=
2241 xlgmac_mmc_read(pdata, MMC_RXLENGTHERROR_LO);
2242
2243 stats->rxoutofrangetype +=
2244 xlgmac_mmc_read(pdata, MMC_RXOUTOFRANGETYPE_LO);
2245
2246 stats->rxpauseframes +=
2247 xlgmac_mmc_read(pdata, MMC_RXPAUSEFRAMES_LO);
2248
2249 stats->rxfifooverflow +=
2250 xlgmac_mmc_read(pdata, MMC_RXFIFOOVERFLOW_LO);
2251
2252 stats->rxvlanframes_gb +=
2253 xlgmac_mmc_read(pdata, MMC_RXVLANFRAMES_GB_LO);
2254
2255 stats->rxwatchdogerror +=
2256 xlgmac_mmc_read(pdata, MMC_RXWATCHDOGERROR);
2257
2258 /* Un-freeze counters */
2259 regval = readl(pdata->mac_regs + MMC_CR);
2260 regval = XLGMAC_SET_REG_BITS(regval, MMC_CR_MCF_POS,
2261 MMC_CR_MCF_LEN, 0);
2262 writel(regval, pdata->mac_regs + MMC_CR);
2263 }
2264
2265 static void xlgmac_config_mmc(struct xlgmac_pdata *pdata)
2266 {
2267 u32 regval;
2268
2269 regval = readl(pdata->mac_regs + MMC_CR);
2270 /* Set counters to reset on read */
2271 regval = XLGMAC_SET_REG_BITS(regval, MMC_CR_ROR_POS,
2272 MMC_CR_ROR_LEN, 1);
2273 /* Reset the counters */
2274 regval = XLGMAC_SET_REG_BITS(regval, MMC_CR_CR_POS,
2275 MMC_CR_CR_LEN, 1);
2276 writel(regval, pdata->mac_regs + MMC_CR);
2277 }
2278
2279 static int xlgmac_write_rss_reg(struct xlgmac_pdata *pdata, unsigned int type,
2280 unsigned int index, unsigned int val)
2281 {
2282 unsigned int wait;
2283 int ret = 0;
2284 u32 regval;
2285
2286 mutex_lock(&pdata->rss_mutex);
2287
2288 regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_RSSAR),
2289 MAC_RSSAR_OB_POS, MAC_RSSAR_OB_LEN);
2290 if (regval) {
2291 ret = -EBUSY;
2292 goto unlock;
2293 }
2294
2295 writel(val, pdata->mac_regs + MAC_RSSDR);
2296
2297 regval = readl(pdata->mac_regs + MAC_RSSAR);
2298 regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSAR_RSSIA_POS,
2299 MAC_RSSAR_RSSIA_LEN, index);
2300 regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSAR_ADDRT_POS,
2301 MAC_RSSAR_ADDRT_LEN, type);
2302 regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSAR_CT_POS,
2303 MAC_RSSAR_CT_LEN, 0);
2304 regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSAR_OB_POS,
2305 MAC_RSSAR_OB_LEN, 1);
2306 writel(regval, pdata->mac_regs + MAC_RSSAR);
2307
2308 wait = 1000;
2309 while (wait--) {
2310 regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_RSSAR),
2311 MAC_RSSAR_OB_POS,
2312 MAC_RSSAR_OB_LEN);
2313 if (!regval)
2314 goto unlock;
2315
2316 usleep_range(1000, 1500);
2317 }
2318
2319 ret = -EBUSY;
2320
2321 unlock:
2322 mutex_unlock(&pdata->rss_mutex);
2323
2324 return ret;
2325 }
2326
2327 static int xlgmac_write_rss_hash_key(struct xlgmac_pdata *pdata)
2328 {
2329 unsigned int key_regs = sizeof(pdata->rss_key) / sizeof(u32);
2330 unsigned int *key = (unsigned int *)&pdata->rss_key;
2331 int ret;
2332
2333 while (key_regs--) {
2334 ret = xlgmac_write_rss_reg(pdata, XLGMAC_RSS_HASH_KEY_TYPE,
2335 key_regs, *key++);
2336 if (ret)
2337 return ret;
2338 }
2339
2340 return 0;
2341 }
2342
2343 static int xlgmac_write_rss_lookup_table(struct xlgmac_pdata *pdata)
2344 {
2345 unsigned int i;
2346 int ret;
2347
2348 for (i = 0; i < ARRAY_SIZE(pdata->rss_table); i++) {
2349 ret = xlgmac_write_rss_reg(pdata,
2350 XLGMAC_RSS_LOOKUP_TABLE_TYPE, i,
2351 pdata->rss_table[i]);
2352 if (ret)
2353 return ret;
2354 }
2355
2356 return 0;
2357 }
2358
2359 static int xlgmac_set_rss_hash_key(struct xlgmac_pdata *pdata, const u8 *key)
2360 {
2361 memcpy(pdata->rss_key, key, sizeof(pdata->rss_key));
2362
2363 return xlgmac_write_rss_hash_key(pdata);
2364 }
2365
2366 static int xlgmac_set_rss_lookup_table(struct xlgmac_pdata *pdata,
2367 const u32 *table)
2368 {
2369 unsigned int i;
2370 u32 tval;
2371
2372 for (i = 0; i < ARRAY_SIZE(pdata->rss_table); i++) {
2373 tval = table[i];
2374 pdata->rss_table[i] = XLGMAC_SET_REG_BITS(
2375 pdata->rss_table[i],
2376 MAC_RSSDR_DMCH_POS,
2377 MAC_RSSDR_DMCH_LEN,
2378 tval);
2379 }
2380
2381 return xlgmac_write_rss_lookup_table(pdata);
2382 }
2383
2384 static int xlgmac_enable_rss(struct xlgmac_pdata *pdata)
2385 {
2386 u32 regval;
2387 int ret;
2388
2389 if (!pdata->hw_feat.rss)
2390 return -EOPNOTSUPP;
2391
2392 /* Program the hash key */
2393 ret = xlgmac_write_rss_hash_key(pdata);
2394 if (ret)
2395 return ret;
2396
2397 /* Program the lookup table */
2398 ret = xlgmac_write_rss_lookup_table(pdata);
2399 if (ret)
2400 return ret;
2401
2402 /* Set the RSS options */
2403 writel(pdata->rss_options, pdata->mac_regs + MAC_RSSCR);
2404
2405 /* Enable RSS */
2406 regval = readl(pdata->mac_regs + MAC_RSSCR);
2407 regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSCR_RSSE_POS,
2408 MAC_RSSCR_RSSE_LEN, 1);
2409 writel(regval, pdata->mac_regs + MAC_RSSCR);
2410
2411 return 0;
2412 }
2413
2414 static int xlgmac_disable_rss(struct xlgmac_pdata *pdata)
2415 {
2416 u32 regval;
2417
2418 if (!pdata->hw_feat.rss)
2419 return -EOPNOTSUPP;
2420
2421 regval = readl(pdata->mac_regs + MAC_RSSCR);
2422 regval = XLGMAC_SET_REG_BITS(regval, MAC_RSSCR_RSSE_POS,
2423 MAC_RSSCR_RSSE_LEN, 0);
2424 writel(regval, pdata->mac_regs + MAC_RSSCR);
2425
2426 return 0;
2427 }
2428
2429 static void xlgmac_config_rss(struct xlgmac_pdata *pdata)
2430 {
2431 int ret;
2432
2433 if (!pdata->hw_feat.rss)
2434 return;
2435
2436 if (pdata->netdev->features & NETIF_F_RXHASH)
2437 ret = xlgmac_enable_rss(pdata);
2438 else
2439 ret = xlgmac_disable_rss(pdata);
2440
2441 if (ret)
2442 netdev_err(pdata->netdev,
2443 "error configuring RSS, RSS disabled\n");
2444 }
2445
2446 static void xlgmac_enable_dma_interrupts(struct xlgmac_pdata *pdata)
2447 {
2448 unsigned int dma_ch_isr, dma_ch_ier;
2449 struct xlgmac_channel *channel;
2450 unsigned int i;
2451
2452 channel = pdata->channel_head;
2453 for (i = 0; i < pdata->channel_count; i++, channel++) {
2454 /* Clear all the interrupts which are set */
2455 dma_ch_isr = readl(XLGMAC_DMA_REG(channel, DMA_CH_SR));
2456 writel(dma_ch_isr, XLGMAC_DMA_REG(channel, DMA_CH_SR));
2457
2458 /* Clear all interrupt enable bits */
2459 dma_ch_ier = 0;
2460
2461 /* Enable following interrupts
2462 * NIE - Normal Interrupt Summary Enable
2463 * AIE - Abnormal Interrupt Summary Enable
2464 * FBEE - Fatal Bus Error Enable
2465 */
2466 dma_ch_ier = XLGMAC_SET_REG_BITS(dma_ch_ier,
2467 DMA_CH_IER_NIE_POS,
2468 DMA_CH_IER_NIE_LEN, 1);
2469 dma_ch_ier = XLGMAC_SET_REG_BITS(dma_ch_ier,
2470 DMA_CH_IER_AIE_POS,
2471 DMA_CH_IER_AIE_LEN, 1);
2472 dma_ch_ier = XLGMAC_SET_REG_BITS(dma_ch_ier,
2473 DMA_CH_IER_FBEE_POS,
2474 DMA_CH_IER_FBEE_LEN, 1);
2475
2476 if (channel->tx_ring) {
2477 /* Enable the following Tx interrupts
2478 * TIE - Transmit Interrupt Enable (unless using
2479 * per channel interrupts)
2480 */
2481 if (!pdata->per_channel_irq)
2482 dma_ch_ier = XLGMAC_SET_REG_BITS(
2483 dma_ch_ier,
2484 DMA_CH_IER_TIE_POS,
2485 DMA_CH_IER_TIE_LEN,
2486 1);
2487 }
2488 if (channel->rx_ring) {
2489 /* Enable following Rx interrupts
2490 * RBUE - Receive Buffer Unavailable Enable
2491 * RIE - Receive Interrupt Enable (unless using
2492 * per channel interrupts)
2493 */
2494 dma_ch_ier = XLGMAC_SET_REG_BITS(
2495 dma_ch_ier,
2496 DMA_CH_IER_RBUE_POS,
2497 DMA_CH_IER_RBUE_LEN,
2498 1);
2499 if (!pdata->per_channel_irq)
2500 dma_ch_ier = XLGMAC_SET_REG_BITS(
2501 dma_ch_ier,
2502 DMA_CH_IER_RIE_POS,
2503 DMA_CH_IER_RIE_LEN,
2504 1);
2505 }
2506
2507 writel(dma_ch_isr, XLGMAC_DMA_REG(channel, DMA_CH_IER));
2508 }
2509 }
2510
2511 static void xlgmac_enable_mtl_interrupts(struct xlgmac_pdata *pdata)
2512 {
2513 unsigned int q_count, i;
2514 unsigned int mtl_q_isr;
2515
2516 q_count = max(pdata->hw_feat.tx_q_cnt, pdata->hw_feat.rx_q_cnt);
2517 for (i = 0; i < q_count; i++) {
2518 /* Clear all the interrupts which are set */
2519 mtl_q_isr = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_ISR));
2520 writel(mtl_q_isr, XLGMAC_MTL_REG(pdata, i, MTL_Q_ISR));
2521
2522 /* No MTL interrupts to be enabled */
2523 writel(0, XLGMAC_MTL_REG(pdata, i, MTL_Q_IER));
2524 }
2525 }
2526
2527 static void xlgmac_enable_mac_interrupts(struct xlgmac_pdata *pdata)
2528 {
2529 unsigned int mac_ier = 0;
2530 u32 regval;
2531
2532 /* Enable Timestamp interrupt */
2533 mac_ier = XLGMAC_SET_REG_BITS(mac_ier, MAC_IER_TSIE_POS,
2534 MAC_IER_TSIE_LEN, 1);
2535
2536 writel(mac_ier, pdata->mac_regs + MAC_IER);
2537
2538 /* Enable all counter interrupts */
2539 regval = readl(pdata->mac_regs + MMC_RIER);
2540 regval = XLGMAC_SET_REG_BITS(regval, MMC_RIER_ALL_INTERRUPTS_POS,
2541 MMC_RIER_ALL_INTERRUPTS_LEN, 0xffffffff);
2542 writel(regval, pdata->mac_regs + MMC_RIER);
2543 regval = readl(pdata->mac_regs + MMC_TIER);
2544 regval = XLGMAC_SET_REG_BITS(regval, MMC_TIER_ALL_INTERRUPTS_POS,
2545 MMC_TIER_ALL_INTERRUPTS_LEN, 0xffffffff);
2546 writel(regval, pdata->mac_regs + MMC_TIER);
2547 }
2548
2549 static int xlgmac_set_xlgmii_25000_speed(struct xlgmac_pdata *pdata)
2550 {
2551 u32 regval;
2552
2553 regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_TCR),
2554 MAC_TCR_SS_POS, MAC_TCR_SS_LEN);
2555 if (regval == 0x1)
2556 return 0;
2557
2558 regval = readl(pdata->mac_regs + MAC_TCR);
2559 regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_SS_POS,
2560 MAC_TCR_SS_LEN, 0x1);
2561 writel(regval, pdata->mac_regs + MAC_TCR);
2562
2563 return 0;
2564 }
2565
2566 static int xlgmac_set_xlgmii_40000_speed(struct xlgmac_pdata *pdata)
2567 {
2568 u32 regval;
2569
2570 regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_TCR),
2571 MAC_TCR_SS_POS, MAC_TCR_SS_LEN);
2572 if (regval == 0)
2573 return 0;
2574
2575 regval = readl(pdata->mac_regs + MAC_TCR);
2576 regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_SS_POS,
2577 MAC_TCR_SS_LEN, 0);
2578 writel(regval, pdata->mac_regs + MAC_TCR);
2579
2580 return 0;
2581 }
2582
2583 static int xlgmac_set_xlgmii_50000_speed(struct xlgmac_pdata *pdata)
2584 {
2585 u32 regval;
2586
2587 regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_TCR),
2588 MAC_TCR_SS_POS, MAC_TCR_SS_LEN);
2589 if (regval == 0x2)
2590 return 0;
2591
2592 regval = readl(pdata->mac_regs + MAC_TCR);
2593 regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_SS_POS,
2594 MAC_TCR_SS_LEN, 0x2);
2595 writel(regval, pdata->mac_regs + MAC_TCR);
2596
2597 return 0;
2598 }
2599
2600 static int xlgmac_set_xlgmii_100000_speed(struct xlgmac_pdata *pdata)
2601 {
2602 u32 regval;
2603
2604 regval = XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + MAC_TCR),
2605 MAC_TCR_SS_POS, MAC_TCR_SS_LEN);
2606 if (regval == 0x3)
2607 return 0;
2608
2609 regval = readl(pdata->mac_regs + MAC_TCR);
2610 regval = XLGMAC_SET_REG_BITS(regval, MAC_TCR_SS_POS,
2611 MAC_TCR_SS_LEN, 0x3);
2612 writel(regval, pdata->mac_regs + MAC_TCR);
2613
2614 return 0;
2615 }
2616
2617 static void xlgmac_config_mac_speed(struct xlgmac_pdata *pdata)
2618 {
2619 switch (pdata->phy_speed) {
2620 case SPEED_100000:
2621 xlgmac_set_xlgmii_100000_speed(pdata);
2622 break;
2623
2624 case SPEED_50000:
2625 xlgmac_set_xlgmii_50000_speed(pdata);
2626 break;
2627
2628 case SPEED_40000:
2629 xlgmac_set_xlgmii_40000_speed(pdata);
2630 break;
2631
2632 case SPEED_25000:
2633 xlgmac_set_xlgmii_25000_speed(pdata);
2634 break;
2635 }
2636 }
2637
2638 static int xlgmac_dev_read(struct xlgmac_channel *channel)
2639 {
2640 struct xlgmac_pdata *pdata = channel->pdata;
2641 struct xlgmac_ring *ring = channel->rx_ring;
2642 struct net_device *netdev = pdata->netdev;
2643 struct xlgmac_desc_data *desc_data;
2644 struct xlgmac_dma_desc *dma_desc;
2645 struct xlgmac_pkt_info *pkt_info;
2646 unsigned int err, etlt, l34t;
2647
2648 desc_data = XLGMAC_GET_DESC_DATA(ring, ring->cur);
2649 dma_desc = desc_data->dma_desc;
2650 pkt_info = &ring->pkt_info;
2651
2652 /* Check for data availability */
2653 if (XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2654 RX_NORMAL_DESC3_OWN_POS,
2655 RX_NORMAL_DESC3_OWN_LEN))
2656 return 1;
2657
2658 /* Make sure descriptor fields are read after reading the OWN bit */
2659 dma_rmb();
2660
2661 if (netif_msg_rx_status(pdata))
2662 xlgmac_dump_rx_desc(pdata, ring, ring->cur);
2663
2664 if (XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2665 RX_NORMAL_DESC3_CTXT_POS,
2666 RX_NORMAL_DESC3_CTXT_LEN)) {
2667 /* Timestamp Context Descriptor */
2668 xlgmac_get_rx_tstamp(pkt_info, dma_desc);
2669
2670 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2671 pkt_info->attributes,
2672 RX_PACKET_ATTRIBUTES_CONTEXT_POS,
2673 RX_PACKET_ATTRIBUTES_CONTEXT_LEN,
2674 1);
2675 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2676 pkt_info->attributes,
2677 RX_PACKET_ATTRIBUTES_CONTEXT_NEXT_POS,
2678 RX_PACKET_ATTRIBUTES_CONTEXT_NEXT_LEN,
2679 0);
2680 return 0;
2681 }
2682
2683 /* Normal Descriptor, be sure Context Descriptor bit is off */
2684 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2685 pkt_info->attributes,
2686 RX_PACKET_ATTRIBUTES_CONTEXT_POS,
2687 RX_PACKET_ATTRIBUTES_CONTEXT_LEN,
2688 0);
2689
2690 /* Indicate if a Context Descriptor is next */
2691 if (XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2692 RX_NORMAL_DESC3_CDA_POS,
2693 RX_NORMAL_DESC3_CDA_LEN))
2694 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2695 pkt_info->attributes,
2696 RX_PACKET_ATTRIBUTES_CONTEXT_NEXT_POS,
2697 RX_PACKET_ATTRIBUTES_CONTEXT_NEXT_LEN,
2698 1);
2699
2700 /* Get the header length */
2701 if (XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2702 RX_NORMAL_DESC3_FD_POS,
2703 RX_NORMAL_DESC3_FD_LEN)) {
2704 desc_data->rx.hdr_len = XLGMAC_GET_REG_BITS_LE(dma_desc->desc2,
2705 RX_NORMAL_DESC2_HL_POS,
2706 RX_NORMAL_DESC2_HL_LEN);
2707 if (desc_data->rx.hdr_len)
2708 pdata->stats.rx_split_header_packets++;
2709 }
2710
2711 /* Get the RSS hash */
2712 if (XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2713 RX_NORMAL_DESC3_RSV_POS,
2714 RX_NORMAL_DESC3_RSV_LEN)) {
2715 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2716 pkt_info->attributes,
2717 RX_PACKET_ATTRIBUTES_RSS_HASH_POS,
2718 RX_PACKET_ATTRIBUTES_RSS_HASH_LEN,
2719 1);
2720
2721 pkt_info->rss_hash = le32_to_cpu(dma_desc->desc1);
2722
2723 l34t = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2724 RX_NORMAL_DESC3_L34T_POS,
2725 RX_NORMAL_DESC3_L34T_LEN);
2726 switch (l34t) {
2727 case RX_DESC3_L34T_IPV4_TCP:
2728 case RX_DESC3_L34T_IPV4_UDP:
2729 case RX_DESC3_L34T_IPV6_TCP:
2730 case RX_DESC3_L34T_IPV6_UDP:
2731 pkt_info->rss_hash_type = PKT_HASH_TYPE_L4;
2732 break;
2733 default:
2734 pkt_info->rss_hash_type = PKT_HASH_TYPE_L3;
2735 }
2736 }
2737
2738 /* Get the pkt_info length */
2739 desc_data->rx.len = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2740 RX_NORMAL_DESC3_PL_POS,
2741 RX_NORMAL_DESC3_PL_LEN);
2742
2743 if (!XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2744 RX_NORMAL_DESC3_LD_POS,
2745 RX_NORMAL_DESC3_LD_LEN)) {
2746 /* Not all the data has been transferred for this pkt_info */
2747 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2748 pkt_info->attributes,
2749 RX_PACKET_ATTRIBUTES_INCOMPLETE_POS,
2750 RX_PACKET_ATTRIBUTES_INCOMPLETE_LEN,
2751 1);
2752 return 0;
2753 }
2754
2755 /* This is the last of the data for this pkt_info */
2756 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2757 pkt_info->attributes,
2758 RX_PACKET_ATTRIBUTES_INCOMPLETE_POS,
2759 RX_PACKET_ATTRIBUTES_INCOMPLETE_LEN,
2760 0);
2761
2762 /* Set checksum done indicator as appropriate */
2763 if (netdev->features & NETIF_F_RXCSUM)
2764 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2765 pkt_info->attributes,
2766 RX_PACKET_ATTRIBUTES_CSUM_DONE_POS,
2767 RX_PACKET_ATTRIBUTES_CSUM_DONE_LEN,
2768 1);
2769
2770 /* Check for errors (only valid in last descriptor) */
2771 err = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2772 RX_NORMAL_DESC3_ES_POS,
2773 RX_NORMAL_DESC3_ES_LEN);
2774 etlt = XLGMAC_GET_REG_BITS_LE(dma_desc->desc3,
2775 RX_NORMAL_DESC3_ETLT_POS,
2776 RX_NORMAL_DESC3_ETLT_LEN);
2777 netif_dbg(pdata, rx_status, netdev, "err=%u, etlt=%#x\n", err, etlt);
2778
2779 if (!err || !etlt) {
2780 /* No error if err is 0 or etlt is 0 */
2781 if ((etlt == 0x09) &&
2782 (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)) {
2783 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2784 pkt_info->attributes,
2785 RX_PACKET_ATTRIBUTES_VLAN_CTAG_POS,
2786 RX_PACKET_ATTRIBUTES_VLAN_CTAG_LEN,
2787 1);
2788 pkt_info->vlan_ctag =
2789 XLGMAC_GET_REG_BITS_LE(dma_desc->desc0,
2790 RX_NORMAL_DESC0_OVT_POS,
2791 RX_NORMAL_DESC0_OVT_LEN);
2792 netif_dbg(pdata, rx_status, netdev, "vlan-ctag=%#06x\n",
2793 pkt_info->vlan_ctag);
2794 }
2795 } else {
2796 if ((etlt == 0x05) || (etlt == 0x06))
2797 pkt_info->attributes = XLGMAC_SET_REG_BITS(
2798 pkt_info->attributes,
2799 RX_PACKET_ATTRIBUTES_CSUM_DONE_POS,
2800 RX_PACKET_ATTRIBUTES_CSUM_DONE_LEN,
2801 0);
2802 else
2803 pkt_info->errors = XLGMAC_SET_REG_BITS(
2804 pkt_info->errors,
2805 RX_PACKET_ERRORS_FRAME_POS,
2806 RX_PACKET_ERRORS_FRAME_LEN,
2807 1);
2808 }
2809
2810 XLGMAC_PR("%s - descriptor=%u (cur=%d)\n", channel->name,
2811 ring->cur & (ring->dma_desc_count - 1), ring->cur);
2812
2813 return 0;
2814 }
2815
2816 static int xlgmac_enable_int(struct xlgmac_channel *channel,
2817 enum xlgmac_int int_id)
2818 {
2819 unsigned int dma_ch_ier;
2820
2821 dma_ch_ier = readl(XLGMAC_DMA_REG(channel, DMA_CH_IER));
2822
2823 switch (int_id) {
2824 case XLGMAC_INT_DMA_CH_SR_TI:
2825 dma_ch_ier = XLGMAC_SET_REG_BITS(
2826 dma_ch_ier, DMA_CH_IER_TIE_POS,
2827 DMA_CH_IER_TIE_LEN, 1);
2828 break;
2829 case XLGMAC_INT_DMA_CH_SR_TPS:
2830 dma_ch_ier = XLGMAC_SET_REG_BITS(
2831 dma_ch_ier, DMA_CH_IER_TXSE_POS,
2832 DMA_CH_IER_TXSE_LEN, 1);
2833 break;
2834 case XLGMAC_INT_DMA_CH_SR_TBU:
2835 dma_ch_ier = XLGMAC_SET_REG_BITS(
2836 dma_ch_ier, DMA_CH_IER_TBUE_POS,
2837 DMA_CH_IER_TBUE_LEN, 1);
2838 break;
2839 case XLGMAC_INT_DMA_CH_SR_RI:
2840 dma_ch_ier = XLGMAC_SET_REG_BITS(
2841 dma_ch_ier, DMA_CH_IER_RIE_POS,
2842 DMA_CH_IER_RIE_LEN, 1);
2843 break;
2844 case XLGMAC_INT_DMA_CH_SR_RBU:
2845 dma_ch_ier = XLGMAC_SET_REG_BITS(
2846 dma_ch_ier, DMA_CH_IER_RBUE_POS,
2847 DMA_CH_IER_RBUE_LEN, 1);
2848 break;
2849 case XLGMAC_INT_DMA_CH_SR_RPS:
2850 dma_ch_ier = XLGMAC_SET_REG_BITS(
2851 dma_ch_ier, DMA_CH_IER_RSE_POS,
2852 DMA_CH_IER_RSE_LEN, 1);
2853 break;
2854 case XLGMAC_INT_DMA_CH_SR_TI_RI:
2855 dma_ch_ier = XLGMAC_SET_REG_BITS(
2856 dma_ch_ier, DMA_CH_IER_TIE_POS,
2857 DMA_CH_IER_TIE_LEN, 1);
2858 dma_ch_ier = XLGMAC_SET_REG_BITS(
2859 dma_ch_ier, DMA_CH_IER_RIE_POS,
2860 DMA_CH_IER_RIE_LEN, 1);
2861 break;
2862 case XLGMAC_INT_DMA_CH_SR_FBE:
2863 dma_ch_ier = XLGMAC_SET_REG_BITS(
2864 dma_ch_ier, DMA_CH_IER_FBEE_POS,
2865 DMA_CH_IER_FBEE_LEN, 1);
2866 break;
2867 case XLGMAC_INT_DMA_ALL:
2868 dma_ch_ier |= channel->saved_ier;
2869 break;
2870 default:
2871 return -1;
2872 }
2873
2874 writel(dma_ch_ier, XLGMAC_DMA_REG(channel, DMA_CH_IER));
2875
2876 return 0;
2877 }
2878
2879 static int xlgmac_disable_int(struct xlgmac_channel *channel,
2880 enum xlgmac_int int_id)
2881 {
2882 unsigned int dma_ch_ier;
2883
2884 dma_ch_ier = readl(XLGMAC_DMA_REG(channel, DMA_CH_IER));
2885
2886 switch (int_id) {
2887 case XLGMAC_INT_DMA_CH_SR_TI:
2888 dma_ch_ier = XLGMAC_SET_REG_BITS(
2889 dma_ch_ier, DMA_CH_IER_TIE_POS,
2890 DMA_CH_IER_TIE_LEN, 0);
2891 break;
2892 case XLGMAC_INT_DMA_CH_SR_TPS:
2893 dma_ch_ier = XLGMAC_SET_REG_BITS(
2894 dma_ch_ier, DMA_CH_IER_TXSE_POS,
2895 DMA_CH_IER_TXSE_LEN, 0);
2896 break;
2897 case XLGMAC_INT_DMA_CH_SR_TBU:
2898 dma_ch_ier = XLGMAC_SET_REG_BITS(
2899 dma_ch_ier, DMA_CH_IER_TBUE_POS,
2900 DMA_CH_IER_TBUE_LEN, 0);
2901 break;
2902 case XLGMAC_INT_DMA_CH_SR_RI:
2903 dma_ch_ier = XLGMAC_SET_REG_BITS(
2904 dma_ch_ier, DMA_CH_IER_RIE_POS,
2905 DMA_CH_IER_RIE_LEN, 0);
2906 break;
2907 case XLGMAC_INT_DMA_CH_SR_RBU:
2908 dma_ch_ier = XLGMAC_SET_REG_BITS(
2909 dma_ch_ier, DMA_CH_IER_RBUE_POS,
2910 DMA_CH_IER_RBUE_LEN, 0);
2911 break;
2912 case XLGMAC_INT_DMA_CH_SR_RPS:
2913 dma_ch_ier = XLGMAC_SET_REG_BITS(
2914 dma_ch_ier, DMA_CH_IER_RSE_POS,
2915 DMA_CH_IER_RSE_LEN, 0);
2916 break;
2917 case XLGMAC_INT_DMA_CH_SR_TI_RI:
2918 dma_ch_ier = XLGMAC_SET_REG_BITS(
2919 dma_ch_ier, DMA_CH_IER_TIE_POS,
2920 DMA_CH_IER_TIE_LEN, 0);
2921 dma_ch_ier = XLGMAC_SET_REG_BITS(
2922 dma_ch_ier, DMA_CH_IER_RIE_POS,
2923 DMA_CH_IER_RIE_LEN, 0);
2924 break;
2925 case XLGMAC_INT_DMA_CH_SR_FBE:
2926 dma_ch_ier = XLGMAC_SET_REG_BITS(
2927 dma_ch_ier, DMA_CH_IER_FBEE_POS,
2928 DMA_CH_IER_FBEE_LEN, 0);
2929 break;
2930 case XLGMAC_INT_DMA_ALL:
2931 channel->saved_ier = dma_ch_ier & XLGMAC_DMA_INTERRUPT_MASK;
2932 dma_ch_ier &= ~XLGMAC_DMA_INTERRUPT_MASK;
2933 break;
2934 default:
2935 return -1;
2936 }
2937
2938 writel(dma_ch_ier, XLGMAC_DMA_REG(channel, DMA_CH_IER));
2939
2940 return 0;
2941 }
2942
2943 static int xlgmac_flush_tx_queues(struct xlgmac_pdata *pdata)
2944 {
2945 unsigned int i, count;
2946 u32 regval;
2947
2948 for (i = 0; i < pdata->tx_q_count; i++) {
2949 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
2950 regval = XLGMAC_SET_REG_BITS(regval, MTL_Q_TQOMR_FTQ_POS,
2951 MTL_Q_TQOMR_FTQ_LEN, 1);
2952 writel(regval, XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
2953 }
2954
2955 /* Poll Until Poll Condition */
2956 for (i = 0; i < pdata->tx_q_count; i++) {
2957 count = 2000;
2958 regval = readl(XLGMAC_MTL_REG(pdata, i, MTL_Q_TQOMR));
2959 regval = XLGMAC_GET_REG_BITS(regval, MTL_Q_TQOMR_FTQ_POS,
2960 MTL_Q_TQOMR_FTQ_LEN);
2961 while (--count && regval)
2962 usleep_range(500, 600);
2963
2964 if (!count)
2965 return -EBUSY;
2966 }
2967
2968 return 0;
2969 }
2970
2971 static void xlgmac_config_dma_bus(struct xlgmac_pdata *pdata)
2972 {
2973 u32 regval;
2974
2975 regval = readl(pdata->mac_regs + DMA_SBMR);
2976 /* Set enhanced addressing mode */
2977 regval = XLGMAC_SET_REG_BITS(regval, DMA_SBMR_EAME_POS,
2978 DMA_SBMR_EAME_LEN, 1);
2979 /* Set the System Bus mode */
2980 regval = XLGMAC_SET_REG_BITS(regval, DMA_SBMR_UNDEF_POS,
2981 DMA_SBMR_UNDEF_LEN, 1);
2982 regval = XLGMAC_SET_REG_BITS(regval, DMA_SBMR_BLEN_256_POS,
2983 DMA_SBMR_BLEN_256_LEN, 1);
2984 writel(regval, pdata->mac_regs + DMA_SBMR);
2985 }
2986
2987 static int xlgmac_hw_init(struct xlgmac_pdata *pdata)
2988 {
2989 struct xlgmac_desc_ops *desc_ops = &pdata->desc_ops;
2990 int ret;
2991
2992 /* Flush Tx queues */
2993 ret = xlgmac_flush_tx_queues(pdata);
2994 if (ret)
2995 return ret;
2996
2997 /* Initialize DMA related features */
2998 xlgmac_config_dma_bus(pdata);
2999 xlgmac_config_osp_mode(pdata);
3000 xlgmac_config_pblx8(pdata);
3001 xlgmac_config_tx_pbl_val(pdata);
3002 xlgmac_config_rx_pbl_val(pdata);
3003 xlgmac_config_rx_coalesce(pdata);
3004 xlgmac_config_tx_coalesce(pdata);
3005 xlgmac_config_rx_buffer_size(pdata);
3006 xlgmac_config_tso_mode(pdata);
3007 xlgmac_config_sph_mode(pdata);
3008 xlgmac_config_rss(pdata);
3009 desc_ops->tx_desc_init(pdata);
3010 desc_ops->rx_desc_init(pdata);
3011 xlgmac_enable_dma_interrupts(pdata);
3012
3013 /* Initialize MTL related features */
3014 xlgmac_config_mtl_mode(pdata);
3015 xlgmac_config_queue_mapping(pdata);
3016 xlgmac_config_tsf_mode(pdata, pdata->tx_sf_mode);
3017 xlgmac_config_rsf_mode(pdata, pdata->rx_sf_mode);
3018 xlgmac_config_tx_threshold(pdata, pdata->tx_threshold);
3019 xlgmac_config_rx_threshold(pdata, pdata->rx_threshold);
3020 xlgmac_config_tx_fifo_size(pdata);
3021 xlgmac_config_rx_fifo_size(pdata);
3022 xlgmac_config_flow_control_threshold(pdata);
3023 xlgmac_config_rx_fep_enable(pdata);
3024 xlgmac_config_rx_fup_enable(pdata);
3025 xlgmac_enable_mtl_interrupts(pdata);
3026
3027 /* Initialize MAC related features */
3028 xlgmac_config_mac_address(pdata);
3029 xlgmac_config_rx_mode(pdata);
3030 xlgmac_config_jumbo_enable(pdata);
3031 xlgmac_config_flow_control(pdata);
3032 xlgmac_config_mac_speed(pdata);
3033 xlgmac_config_checksum_offload(pdata);
3034 xlgmac_config_vlan_support(pdata);
3035 xlgmac_config_mmc(pdata);
3036 xlgmac_enable_mac_interrupts(pdata);
3037
3038 return 0;
3039 }
3040
3041 static int xlgmac_hw_exit(struct xlgmac_pdata *pdata)
3042 {
3043 unsigned int count = 2000;
3044 u32 regval;
3045
3046 /* Issue a software reset */
3047 regval = readl(pdata->mac_regs + DMA_MR);
3048 regval = XLGMAC_SET_REG_BITS(regval, DMA_MR_SWR_POS,
3049 DMA_MR_SWR_LEN, 1);
3050 writel(regval, pdata->mac_regs + DMA_MR);
3051 usleep_range(10, 15);
3052
3053 /* Poll Until Poll Condition */
3054 while (--count &&
3055 XLGMAC_GET_REG_BITS(readl(pdata->mac_regs + DMA_MR),
3056 DMA_MR_SWR_POS, DMA_MR_SWR_LEN))
3057 usleep_range(500, 600);
3058
3059 if (!count)
3060 return -EBUSY;
3061
3062 return 0;
3063 }
3064
3065 void xlgmac_init_hw_ops(struct xlgmac_hw_ops *hw_ops)
3066 {
3067 hw_ops->init = xlgmac_hw_init;
3068 hw_ops->exit = xlgmac_hw_exit;
3069
3070 hw_ops->tx_complete = xlgmac_tx_complete;
3071
3072 hw_ops->enable_tx = xlgmac_enable_tx;
3073 hw_ops->disable_tx = xlgmac_disable_tx;
3074 hw_ops->enable_rx = xlgmac_enable_rx;
3075 hw_ops->disable_rx = xlgmac_disable_rx;
3076
3077 hw_ops->dev_xmit = xlgmac_dev_xmit;
3078 hw_ops->dev_read = xlgmac_dev_read;
3079 hw_ops->enable_int = xlgmac_enable_int;
3080 hw_ops->disable_int = xlgmac_disable_int;
3081
3082 hw_ops->set_mac_address = xlgmac_set_mac_address;
3083 hw_ops->config_rx_mode = xlgmac_config_rx_mode;
3084 hw_ops->enable_rx_csum = xlgmac_enable_rx_csum;
3085 hw_ops->disable_rx_csum = xlgmac_disable_rx_csum;
3086
3087 /* For MII speed configuration */
3088 hw_ops->set_xlgmii_25000_speed = xlgmac_set_xlgmii_25000_speed;
3089 hw_ops->set_xlgmii_40000_speed = xlgmac_set_xlgmii_40000_speed;
3090 hw_ops->set_xlgmii_50000_speed = xlgmac_set_xlgmii_50000_speed;
3091 hw_ops->set_xlgmii_100000_speed = xlgmac_set_xlgmii_100000_speed;
3092
3093 /* For descriptor related operation */
3094 hw_ops->tx_desc_init = xlgmac_tx_desc_init;
3095 hw_ops->rx_desc_init = xlgmac_rx_desc_init;
3096 hw_ops->tx_desc_reset = xlgmac_tx_desc_reset;
3097 hw_ops->rx_desc_reset = xlgmac_rx_desc_reset;
3098 hw_ops->is_last_desc = xlgmac_is_last_desc;
3099 hw_ops->is_context_desc = xlgmac_is_context_desc;
3100 hw_ops->tx_start_xmit = xlgmac_tx_start_xmit;
3101
3102 /* For Flow Control */
3103 hw_ops->config_tx_flow_control = xlgmac_config_tx_flow_control;
3104 hw_ops->config_rx_flow_control = xlgmac_config_rx_flow_control;
3105
3106 /* For Vlan related config */
3107 hw_ops->enable_rx_vlan_stripping = xlgmac_enable_rx_vlan_stripping;
3108 hw_ops->disable_rx_vlan_stripping = xlgmac_disable_rx_vlan_stripping;
3109 hw_ops->enable_rx_vlan_filtering = xlgmac_enable_rx_vlan_filtering;
3110 hw_ops->disable_rx_vlan_filtering = xlgmac_disable_rx_vlan_filtering;
3111 hw_ops->update_vlan_hash_table = xlgmac_update_vlan_hash_table;
3112
3113 /* For RX coalescing */
3114 hw_ops->config_rx_coalesce = xlgmac_config_rx_coalesce;
3115 hw_ops->config_tx_coalesce = xlgmac_config_tx_coalesce;
3116 hw_ops->usec_to_riwt = xlgmac_usec_to_riwt;
3117 hw_ops->riwt_to_usec = xlgmac_riwt_to_usec;
3118
3119 /* For RX and TX threshold config */
3120 hw_ops->config_rx_threshold = xlgmac_config_rx_threshold;
3121 hw_ops->config_tx_threshold = xlgmac_config_tx_threshold;
3122
3123 /* For RX and TX Store and Forward Mode config */
3124 hw_ops->config_rsf_mode = xlgmac_config_rsf_mode;
3125 hw_ops->config_tsf_mode = xlgmac_config_tsf_mode;
3126
3127 /* For TX DMA Operating on Second Frame config */
3128 hw_ops->config_osp_mode = xlgmac_config_osp_mode;
3129
3130 /* For RX and TX PBL config */
3131 hw_ops->config_rx_pbl_val = xlgmac_config_rx_pbl_val;
3132 hw_ops->get_rx_pbl_val = xlgmac_get_rx_pbl_val;
3133 hw_ops->config_tx_pbl_val = xlgmac_config_tx_pbl_val;
3134 hw_ops->get_tx_pbl_val = xlgmac_get_tx_pbl_val;
3135 hw_ops->config_pblx8 = xlgmac_config_pblx8;
3136
3137 /* For MMC statistics support */
3138 hw_ops->tx_mmc_int = xlgmac_tx_mmc_int;
3139 hw_ops->rx_mmc_int = xlgmac_rx_mmc_int;
3140 hw_ops->read_mmc_stats = xlgmac_read_mmc_stats;
3141
3142 /* For Receive Side Scaling */
3143 hw_ops->enable_rss = xlgmac_enable_rss;
3144 hw_ops->disable_rss = xlgmac_disable_rss;
3145 hw_ops->set_rss_hash_key = xlgmac_set_rss_hash_key;
3146 hw_ops->set_rss_lookup_table = xlgmac_set_rss_lookup_table;
3147 }
Linux with added FPC-III support