1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /* Copyright (C) 2018 Microchip Technology Inc. */
4 #include <linux/module.h>
6 #include <linux/netdevice.h>
7 #include <linux/etherdevice.h>
8 #include <linux/crc32.h>
9 #include <linux/microchipphy.h>
10 #include <linux/net_tstamp.h>
11 #include <linux/phy.h>
12 #include <linux/rtnetlink.h>
13 #include <linux/iopoll.h>
14 #include <linux/crc16.h>
15 #include "lan743x_main.h"
16 #include "lan743x_ethtool.h"
18 static void lan743x_pci_cleanup(struct lan743x_adapter
*adapter
)
20 pci_release_selected_regions(adapter
->pdev
,
21 pci_select_bars(adapter
->pdev
,
23 pci_disable_device(adapter
->pdev
);
26 static int lan743x_pci_init(struct lan743x_adapter
*adapter
,
29 unsigned long bars
= 0;
33 ret
= pci_enable_device_mem(pdev
);
37 netif_info(adapter
, probe
, adapter
->netdev
,
38 "PCI: Vendor ID = 0x%04X, Device ID = 0x%04X\n",
39 pdev
->vendor
, pdev
->device
);
40 bars
= pci_select_bars(pdev
, IORESOURCE_MEM
);
41 if (!test_bit(0, &bars
))
44 ret
= pci_request_selected_regions(pdev
, bars
, DRIVER_NAME
);
52 pci_disable_device(adapter
->pdev
);
58 u32
lan743x_csr_read(struct lan743x_adapter
*adapter
, int offset
)
60 return ioread32(&adapter
->csr
.csr_address
[offset
]);
63 void lan743x_csr_write(struct lan743x_adapter
*adapter
, int offset
,
66 iowrite32(data
, &adapter
->csr
.csr_address
[offset
]);
69 #define LAN743X_CSR_READ_OP(offset) lan743x_csr_read(adapter, offset)
71 static int lan743x_csr_light_reset(struct lan743x_adapter
*adapter
)
75 data
= lan743x_csr_read(adapter
, HW_CFG
);
77 lan743x_csr_write(adapter
, HW_CFG
, data
);
79 return readx_poll_timeout(LAN743X_CSR_READ_OP
, HW_CFG
, data
,
80 !(data
& HW_CFG_LRST_
), 100000, 10000000);
83 static int lan743x_csr_wait_for_bit(struct lan743x_adapter
*adapter
,
84 int offset
, u32 bit_mask
,
85 int target_value
, int usleep_min
,
86 int usleep_max
, int count
)
90 return readx_poll_timeout(LAN743X_CSR_READ_OP
, offset
, data
,
91 target_value
== ((data
& bit_mask
) ? 1 : 0),
92 usleep_max
, usleep_min
* count
);
95 static int lan743x_csr_init(struct lan743x_adapter
*adapter
)
97 struct lan743x_csr
*csr
= &adapter
->csr
;
98 resource_size_t bar_start
, bar_length
;
101 bar_start
= pci_resource_start(adapter
->pdev
, 0);
102 bar_length
= pci_resource_len(adapter
->pdev
, 0);
103 csr
->csr_address
= devm_ioremap(&adapter
->pdev
->dev
,
104 bar_start
, bar_length
);
105 if (!csr
->csr_address
) {
110 csr
->id_rev
= lan743x_csr_read(adapter
, ID_REV
);
111 csr
->fpga_rev
= lan743x_csr_read(adapter
, FPGA_REV
);
112 netif_info(adapter
, probe
, adapter
->netdev
,
113 "ID_REV = 0x%08X, FPGA_REV = %d.%d\n",
114 csr
->id_rev
, FPGA_REV_GET_MAJOR_(csr
->fpga_rev
),
115 FPGA_REV_GET_MINOR_(csr
->fpga_rev
));
116 if (!ID_REV_IS_VALID_CHIP_ID_(csr
->id_rev
)) {
121 csr
->flags
= LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR
;
122 switch (csr
->id_rev
& ID_REV_CHIP_REV_MASK_
) {
123 case ID_REV_CHIP_REV_A0_
:
124 csr
->flags
|= LAN743X_CSR_FLAG_IS_A0
;
125 csr
->flags
&= ~LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR
;
127 case ID_REV_CHIP_REV_B0_
:
128 csr
->flags
|= LAN743X_CSR_FLAG_IS_B0
;
132 result
= lan743x_csr_light_reset(adapter
);
140 static void lan743x_intr_software_isr(void *context
)
142 struct lan743x_adapter
*adapter
= context
;
143 struct lan743x_intr
*intr
= &adapter
->intr
;
146 int_sts
= lan743x_csr_read(adapter
, INT_STS
);
147 if (int_sts
& INT_BIT_SW_GP_
) {
148 lan743x_csr_write(adapter
, INT_STS
, INT_BIT_SW_GP_
);
149 intr
->software_isr_flag
= 1;
153 static void lan743x_tx_isr(void *context
, u32 int_sts
, u32 flags
)
155 struct lan743x_tx
*tx
= context
;
156 struct lan743x_adapter
*adapter
= tx
->adapter
;
157 bool enable_flag
= true;
160 int_en
= lan743x_csr_read(adapter
, INT_EN_SET
);
161 if (flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR
) {
162 lan743x_csr_write(adapter
, INT_EN_CLR
,
163 INT_BIT_DMA_TX_(tx
->channel_number
));
166 if (int_sts
& INT_BIT_DMA_TX_(tx
->channel_number
)) {
167 u32 ioc_bit
= DMAC_INT_BIT_TX_IOC_(tx
->channel_number
);
171 if (flags
& LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ
)
172 dmac_int_sts
= lan743x_csr_read(adapter
, DMAC_INT_STS
);
174 dmac_int_sts
= ioc_bit
;
175 if (flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK
)
176 dmac_int_en
= lan743x_csr_read(adapter
,
179 dmac_int_en
= ioc_bit
;
181 dmac_int_en
&= ioc_bit
;
182 dmac_int_sts
&= dmac_int_en
;
183 if (dmac_int_sts
& ioc_bit
) {
184 napi_schedule(&tx
->napi
);
185 enable_flag
= false;/* poll func will enable later */
191 lan743x_csr_write(adapter
, INT_EN_SET
,
192 INT_BIT_DMA_TX_(tx
->channel_number
));
195 static void lan743x_rx_isr(void *context
, u32 int_sts
, u32 flags
)
197 struct lan743x_rx
*rx
= context
;
198 struct lan743x_adapter
*adapter
= rx
->adapter
;
199 bool enable_flag
= true;
201 if (flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR
) {
202 lan743x_csr_write(adapter
, INT_EN_CLR
,
203 INT_BIT_DMA_RX_(rx
->channel_number
));
206 if (int_sts
& INT_BIT_DMA_RX_(rx
->channel_number
)) {
207 u32 rx_frame_bit
= DMAC_INT_BIT_RXFRM_(rx
->channel_number
);
211 if (flags
& LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ
)
212 dmac_int_sts
= lan743x_csr_read(adapter
, DMAC_INT_STS
);
214 dmac_int_sts
= rx_frame_bit
;
215 if (flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK
)
216 dmac_int_en
= lan743x_csr_read(adapter
,
219 dmac_int_en
= rx_frame_bit
;
221 dmac_int_en
&= rx_frame_bit
;
222 dmac_int_sts
&= dmac_int_en
;
223 if (dmac_int_sts
& rx_frame_bit
) {
224 napi_schedule(&rx
->napi
);
225 enable_flag
= false;/* poll funct will enable later */
231 lan743x_csr_write(adapter
, INT_EN_SET
,
232 INT_BIT_DMA_RX_(rx
->channel_number
));
236 static void lan743x_intr_shared_isr(void *context
, u32 int_sts
, u32 flags
)
238 struct lan743x_adapter
*adapter
= context
;
239 unsigned int channel
;
241 if (int_sts
& INT_BIT_ALL_RX_
) {
242 for (channel
= 0; channel
< LAN743X_USED_RX_CHANNELS
;
244 u32 int_bit
= INT_BIT_DMA_RX_(channel
);
246 if (int_sts
& int_bit
) {
247 lan743x_rx_isr(&adapter
->rx
[channel
],
253 if (int_sts
& INT_BIT_ALL_TX_
) {
254 for (channel
= 0; channel
< LAN743X_USED_TX_CHANNELS
;
256 u32 int_bit
= INT_BIT_DMA_TX_(channel
);
258 if (int_sts
& int_bit
) {
259 lan743x_tx_isr(&adapter
->tx
[channel
],
265 if (int_sts
& INT_BIT_ALL_OTHER_
) {
266 if (int_sts
& INT_BIT_SW_GP_
) {
267 lan743x_intr_software_isr(adapter
);
268 int_sts
&= ~INT_BIT_SW_GP_
;
270 if (int_sts
& INT_BIT_1588_
) {
271 lan743x_ptp_isr(adapter
);
272 int_sts
&= ~INT_BIT_1588_
;
276 lan743x_csr_write(adapter
, INT_EN_CLR
, int_sts
);
279 static irqreturn_t
lan743x_intr_entry_isr(int irq
, void *ptr
)
281 struct lan743x_vector
*vector
= ptr
;
282 struct lan743x_adapter
*adapter
= vector
->adapter
;
283 irqreturn_t result
= IRQ_NONE
;
287 if (vector
->flags
& LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ
) {
288 int_sts
= lan743x_csr_read(adapter
, INT_STS
);
289 } else if (vector
->flags
&
290 (LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C
|
291 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C
)) {
292 int_sts
= lan743x_csr_read(adapter
, INT_STS_R2C
);
294 /* use mask as implied status */
295 int_sts
= vector
->int_mask
| INT_BIT_MAS_
;
298 if (!(int_sts
& INT_BIT_MAS_
))
301 if (vector
->flags
& LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR
)
302 /* disable vector interrupt */
303 lan743x_csr_write(adapter
,
305 INT_VEC_EN_(vector
->vector_index
));
307 if (vector
->flags
& LAN743X_VECTOR_FLAG_MASTER_ENABLE_CLEAR
)
308 /* disable master interrupt */
309 lan743x_csr_write(adapter
, INT_EN_CLR
, INT_BIT_MAS_
);
311 if (vector
->flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK
) {
312 int_enables
= lan743x_csr_read(adapter
, INT_EN_SET
);
314 /* use vector mask as implied enable mask */
315 int_enables
= vector
->int_mask
;
318 int_sts
&= int_enables
;
319 int_sts
&= vector
->int_mask
;
321 if (vector
->handler
) {
322 vector
->handler(vector
->context
,
323 int_sts
, vector
->flags
);
325 /* disable interrupts on this vector */
326 lan743x_csr_write(adapter
, INT_EN_CLR
,
329 result
= IRQ_HANDLED
;
332 if (vector
->flags
& LAN743X_VECTOR_FLAG_MASTER_ENABLE_SET
)
333 /* enable master interrupt */
334 lan743x_csr_write(adapter
, INT_EN_SET
, INT_BIT_MAS_
);
336 if (vector
->flags
& LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET
)
337 /* enable vector interrupt */
338 lan743x_csr_write(adapter
,
340 INT_VEC_EN_(vector
->vector_index
));
345 static int lan743x_intr_test_isr(struct lan743x_adapter
*adapter
)
347 struct lan743x_intr
*intr
= &adapter
->intr
;
348 int result
= -ENODEV
;
351 intr
->software_isr_flag
= 0;
353 /* enable interrupt */
354 lan743x_csr_write(adapter
, INT_EN_SET
, INT_BIT_SW_GP_
);
356 /* activate interrupt here */
357 lan743x_csr_write(adapter
, INT_SET
, INT_BIT_SW_GP_
);
358 while ((timeout
> 0) && (!(intr
->software_isr_flag
))) {
359 usleep_range(1000, 20000);
363 if (intr
->software_isr_flag
)
366 /* disable interrupts */
367 lan743x_csr_write(adapter
, INT_EN_CLR
, INT_BIT_SW_GP_
);
371 static int lan743x_intr_register_isr(struct lan743x_adapter
*adapter
,
372 int vector_index
, u32 flags
,
374 lan743x_vector_handler handler
,
377 struct lan743x_vector
*vector
= &adapter
->intr
.vector_list
381 vector
->adapter
= adapter
;
382 vector
->flags
= flags
;
383 vector
->vector_index
= vector_index
;
384 vector
->int_mask
= int_mask
;
385 vector
->handler
= handler
;
386 vector
->context
= context
;
388 ret
= request_irq(vector
->irq
,
389 lan743x_intr_entry_isr
,
390 (flags
& LAN743X_VECTOR_FLAG_IRQ_SHARED
) ?
391 IRQF_SHARED
: 0, DRIVER_NAME
, vector
);
393 vector
->handler
= NULL
;
394 vector
->context
= NULL
;
395 vector
->int_mask
= 0;
401 static void lan743x_intr_unregister_isr(struct lan743x_adapter
*adapter
,
404 struct lan743x_vector
*vector
= &adapter
->intr
.vector_list
407 free_irq(vector
->irq
, vector
);
408 vector
->handler
= NULL
;
409 vector
->context
= NULL
;
410 vector
->int_mask
= 0;
414 static u32
lan743x_intr_get_vector_flags(struct lan743x_adapter
*adapter
,
419 for (index
= 0; index
< LAN743X_MAX_VECTOR_COUNT
; index
++) {
420 if (adapter
->intr
.vector_list
[index
].int_mask
& int_mask
)
421 return adapter
->intr
.vector_list
[index
].flags
;
426 static void lan743x_intr_close(struct lan743x_adapter
*adapter
)
428 struct lan743x_intr
*intr
= &adapter
->intr
;
431 lan743x_csr_write(adapter
, INT_EN_CLR
, INT_BIT_MAS_
);
432 lan743x_csr_write(adapter
, INT_VEC_EN_CLR
, 0x000000FF);
434 for (index
= 0; index
< LAN743X_MAX_VECTOR_COUNT
; index
++) {
435 if (intr
->flags
& INTR_FLAG_IRQ_REQUESTED(index
)) {
436 lan743x_intr_unregister_isr(adapter
, index
);
437 intr
->flags
&= ~INTR_FLAG_IRQ_REQUESTED(index
);
441 if (intr
->flags
& INTR_FLAG_MSI_ENABLED
) {
442 pci_disable_msi(adapter
->pdev
);
443 intr
->flags
&= ~INTR_FLAG_MSI_ENABLED
;
446 if (intr
->flags
& INTR_FLAG_MSIX_ENABLED
) {
447 pci_disable_msix(adapter
->pdev
);
448 intr
->flags
&= ~INTR_FLAG_MSIX_ENABLED
;
452 static int lan743x_intr_open(struct lan743x_adapter
*adapter
)
454 struct msix_entry msix_entries
[LAN743X_MAX_VECTOR_COUNT
];
455 struct lan743x_intr
*intr
= &adapter
->intr
;
456 u32 int_vec_en_auto_clr
= 0;
457 u32 int_vec_map0
= 0;
458 u32 int_vec_map1
= 0;
463 intr
->number_of_vectors
= 0;
465 /* Try to set up MSIX interrupts */
466 memset(&msix_entries
[0], 0,
467 sizeof(struct msix_entry
) * LAN743X_MAX_VECTOR_COUNT
);
468 for (index
= 0; index
< LAN743X_MAX_VECTOR_COUNT
; index
++)
469 msix_entries
[index
].entry
= index
;
470 ret
= pci_enable_msix_range(adapter
->pdev
,
472 1 + LAN743X_USED_TX_CHANNELS
+
473 LAN743X_USED_RX_CHANNELS
);
476 intr
->flags
|= INTR_FLAG_MSIX_ENABLED
;
477 intr
->number_of_vectors
= ret
;
478 intr
->using_vectors
= true;
479 for (index
= 0; index
< intr
->number_of_vectors
; index
++)
480 intr
->vector_list
[index
].irq
= msix_entries
482 netif_info(adapter
, ifup
, adapter
->netdev
,
483 "using MSIX interrupts, number of vectors = %d\n",
484 intr
->number_of_vectors
);
487 /* If MSIX failed try to setup using MSI interrupts */
488 if (!intr
->number_of_vectors
) {
489 if (!(adapter
->csr
.flags
& LAN743X_CSR_FLAG_IS_A0
)) {
490 if (!pci_enable_msi(adapter
->pdev
)) {
491 intr
->flags
|= INTR_FLAG_MSI_ENABLED
;
492 intr
->number_of_vectors
= 1;
493 intr
->using_vectors
= true;
494 intr
->vector_list
[0].irq
=
496 netif_info(adapter
, ifup
, adapter
->netdev
,
497 "using MSI interrupts, number of vectors = %d\n",
498 intr
->number_of_vectors
);
503 /* If MSIX, and MSI failed, setup using legacy interrupt */
504 if (!intr
->number_of_vectors
) {
505 intr
->number_of_vectors
= 1;
506 intr
->using_vectors
= false;
507 intr
->vector_list
[0].irq
= intr
->irq
;
508 netif_info(adapter
, ifup
, adapter
->netdev
,
509 "using legacy interrupts\n");
512 /* At this point we must have at least one irq */
513 lan743x_csr_write(adapter
, INT_VEC_EN_CLR
, 0xFFFFFFFF);
515 /* map all interrupts to vector 0 */
516 lan743x_csr_write(adapter
, INT_VEC_MAP0
, 0x00000000);
517 lan743x_csr_write(adapter
, INT_VEC_MAP1
, 0x00000000);
518 lan743x_csr_write(adapter
, INT_VEC_MAP2
, 0x00000000);
519 flags
= LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ
|
520 LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C
|
521 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK
|
522 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR
;
524 if (intr
->using_vectors
) {
525 flags
|= LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR
|
526 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET
;
528 flags
|= LAN743X_VECTOR_FLAG_MASTER_ENABLE_CLEAR
|
529 LAN743X_VECTOR_FLAG_MASTER_ENABLE_SET
|
530 LAN743X_VECTOR_FLAG_IRQ_SHARED
;
533 if (adapter
->csr
.flags
& LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR
) {
534 flags
&= ~LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ
;
535 flags
&= ~LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C
;
536 flags
&= ~LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR
;
537 flags
&= ~LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK
;
538 flags
|= LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C
;
539 flags
|= LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C
;
542 ret
= lan743x_intr_register_isr(adapter
, 0, flags
,
543 INT_BIT_ALL_RX_
| INT_BIT_ALL_TX_
|
545 lan743x_intr_shared_isr
, adapter
);
548 intr
->flags
|= INTR_FLAG_IRQ_REQUESTED(0);
550 if (intr
->using_vectors
)
551 lan743x_csr_write(adapter
, INT_VEC_EN_SET
,
554 if (!(adapter
->csr
.flags
& LAN743X_CSR_FLAG_IS_A0
)) {
555 lan743x_csr_write(adapter
, INT_MOD_CFG0
, LAN743X_INT_MOD
);
556 lan743x_csr_write(adapter
, INT_MOD_CFG1
, LAN743X_INT_MOD
);
557 lan743x_csr_write(adapter
, INT_MOD_CFG2
, LAN743X_INT_MOD
);
558 lan743x_csr_write(adapter
, INT_MOD_CFG3
, LAN743X_INT_MOD
);
559 lan743x_csr_write(adapter
, INT_MOD_CFG4
, LAN743X_INT_MOD
);
560 lan743x_csr_write(adapter
, INT_MOD_CFG5
, LAN743X_INT_MOD
);
561 lan743x_csr_write(adapter
, INT_MOD_CFG6
, LAN743X_INT_MOD
);
562 lan743x_csr_write(adapter
, INT_MOD_CFG7
, LAN743X_INT_MOD
);
563 lan743x_csr_write(adapter
, INT_MOD_MAP0
, 0x00005432);
564 lan743x_csr_write(adapter
, INT_MOD_MAP1
, 0x00000001);
565 lan743x_csr_write(adapter
, INT_MOD_MAP2
, 0x00FFFFFF);
568 /* enable interrupts */
569 lan743x_csr_write(adapter
, INT_EN_SET
, INT_BIT_MAS_
);
570 ret
= lan743x_intr_test_isr(adapter
);
574 if (intr
->number_of_vectors
> 1) {
575 int number_of_tx_vectors
= intr
->number_of_vectors
- 1;
577 if (number_of_tx_vectors
> LAN743X_USED_TX_CHANNELS
)
578 number_of_tx_vectors
= LAN743X_USED_TX_CHANNELS
;
579 flags
= LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ
|
580 LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C
|
581 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK
|
582 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR
|
583 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR
|
584 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET
;
586 if (adapter
->csr
.flags
&
587 LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR
) {
588 flags
= LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_CLEAR
|
589 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET
|
590 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET
|
591 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR
|
592 LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR
;
595 for (index
= 0; index
< number_of_tx_vectors
; index
++) {
596 u32 int_bit
= INT_BIT_DMA_TX_(index
);
597 int vector
= index
+ 1;
599 /* map TX interrupt to vector */
600 int_vec_map1
|= INT_VEC_MAP1_TX_VEC_(index
, vector
);
601 lan743x_csr_write(adapter
, INT_VEC_MAP1
, int_vec_map1
);
603 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_CLEAR
) {
604 int_vec_en_auto_clr
|= INT_VEC_EN_(vector
);
605 lan743x_csr_write(adapter
, INT_VEC_EN_AUTO_CLR
,
606 int_vec_en_auto_clr
);
609 /* Remove TX interrupt from shared mask */
610 intr
->vector_list
[0].int_mask
&= ~int_bit
;
611 ret
= lan743x_intr_register_isr(adapter
, vector
, flags
,
612 int_bit
, lan743x_tx_isr
,
613 &adapter
->tx
[index
]);
616 intr
->flags
|= INTR_FLAG_IRQ_REQUESTED(vector
);
618 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET
))
619 lan743x_csr_write(adapter
, INT_VEC_EN_SET
,
620 INT_VEC_EN_(vector
));
623 if ((intr
->number_of_vectors
- LAN743X_USED_TX_CHANNELS
) > 1) {
624 int number_of_rx_vectors
= intr
->number_of_vectors
-
625 LAN743X_USED_TX_CHANNELS
- 1;
627 if (number_of_rx_vectors
> LAN743X_USED_RX_CHANNELS
)
628 number_of_rx_vectors
= LAN743X_USED_RX_CHANNELS
;
630 flags
= LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ
|
631 LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C
|
632 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK
|
633 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR
|
634 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR
|
635 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET
;
637 if (adapter
->csr
.flags
&
638 LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR
) {
639 flags
= LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_CLEAR
|
640 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET
|
641 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET
|
642 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR
|
643 LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR
;
645 for (index
= 0; index
< number_of_rx_vectors
; index
++) {
646 int vector
= index
+ 1 + LAN743X_USED_TX_CHANNELS
;
647 u32 int_bit
= INT_BIT_DMA_RX_(index
);
649 /* map RX interrupt to vector */
650 int_vec_map0
|= INT_VEC_MAP0_RX_VEC_(index
, vector
);
651 lan743x_csr_write(adapter
, INT_VEC_MAP0
, int_vec_map0
);
653 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_CLEAR
) {
654 int_vec_en_auto_clr
|= INT_VEC_EN_(vector
);
655 lan743x_csr_write(adapter
, INT_VEC_EN_AUTO_CLR
,
656 int_vec_en_auto_clr
);
659 /* Remove RX interrupt from shared mask */
660 intr
->vector_list
[0].int_mask
&= ~int_bit
;
661 ret
= lan743x_intr_register_isr(adapter
, vector
, flags
,
662 int_bit
, lan743x_rx_isr
,
663 &adapter
->rx
[index
]);
666 intr
->flags
|= INTR_FLAG_IRQ_REQUESTED(vector
);
668 lan743x_csr_write(adapter
, INT_VEC_EN_SET
,
669 INT_VEC_EN_(vector
));
675 lan743x_intr_close(adapter
);
679 static int lan743x_dp_write(struct lan743x_adapter
*adapter
,
680 u32 select
, u32 addr
, u32 length
, u32
*buf
)
686 mutex_lock(&adapter
->dp_lock
);
687 if (lan743x_csr_wait_for_bit(adapter
, DP_SEL
, DP_SEL_DPRDY_
,
690 dp_sel
= lan743x_csr_read(adapter
, DP_SEL
);
691 dp_sel
&= ~DP_SEL_MASK_
;
693 lan743x_csr_write(adapter
, DP_SEL
, dp_sel
);
695 for (i
= 0; i
< length
; i
++) {
696 lan743x_csr_write(adapter
, DP_ADDR
, addr
+ i
);
697 lan743x_csr_write(adapter
, DP_DATA_0
, buf
[i
]);
698 lan743x_csr_write(adapter
, DP_CMD
, DP_CMD_WRITE_
);
699 if (lan743x_csr_wait_for_bit(adapter
, DP_SEL
, DP_SEL_DPRDY_
,
706 mutex_unlock(&adapter
->dp_lock
);
710 static u32
lan743x_mac_mii_access(u16 id
, u16 index
, int read
)
714 ret
= (id
<< MAC_MII_ACC_PHY_ADDR_SHIFT_
) &
715 MAC_MII_ACC_PHY_ADDR_MASK_
;
716 ret
|= (index
<< MAC_MII_ACC_MIIRINDA_SHIFT_
) &
717 MAC_MII_ACC_MIIRINDA_MASK_
;
720 ret
|= MAC_MII_ACC_MII_READ_
;
722 ret
|= MAC_MII_ACC_MII_WRITE_
;
723 ret
|= MAC_MII_ACC_MII_BUSY_
;
728 static int lan743x_mac_mii_wait_till_not_busy(struct lan743x_adapter
*adapter
)
732 return readx_poll_timeout(LAN743X_CSR_READ_OP
, MAC_MII_ACC
, data
,
733 !(data
& MAC_MII_ACC_MII_BUSY_
), 0, 1000000);
736 static int lan743x_mdiobus_read(struct mii_bus
*bus
, int phy_id
, int index
)
738 struct lan743x_adapter
*adapter
= bus
->priv
;
742 /* comfirm MII not busy */
743 ret
= lan743x_mac_mii_wait_till_not_busy(adapter
);
747 /* set the address, index & direction (read from PHY) */
748 mii_access
= lan743x_mac_mii_access(phy_id
, index
, MAC_MII_READ
);
749 lan743x_csr_write(adapter
, MAC_MII_ACC
, mii_access
);
750 ret
= lan743x_mac_mii_wait_till_not_busy(adapter
);
754 val
= lan743x_csr_read(adapter
, MAC_MII_DATA
);
755 return (int)(val
& 0xFFFF);
758 static int lan743x_mdiobus_write(struct mii_bus
*bus
,
759 int phy_id
, int index
, u16 regval
)
761 struct lan743x_adapter
*adapter
= bus
->priv
;
765 /* confirm MII not busy */
766 ret
= lan743x_mac_mii_wait_till_not_busy(adapter
);
770 lan743x_csr_write(adapter
, MAC_MII_DATA
, val
);
772 /* set the address, index & direction (write to PHY) */
773 mii_access
= lan743x_mac_mii_access(phy_id
, index
, MAC_MII_WRITE
);
774 lan743x_csr_write(adapter
, MAC_MII_ACC
, mii_access
);
775 ret
= lan743x_mac_mii_wait_till_not_busy(adapter
);
779 static void lan743x_mac_set_address(struct lan743x_adapter
*adapter
,
782 u32 addr_lo
, addr_hi
;
790 lan743x_csr_write(adapter
, MAC_RX_ADDRL
, addr_lo
);
791 lan743x_csr_write(adapter
, MAC_RX_ADDRH
, addr_hi
);
793 ether_addr_copy(adapter
->mac_address
, addr
);
794 netif_info(adapter
, drv
, adapter
->netdev
,
795 "MAC address set to %pM\n", addr
);
798 static int lan743x_mac_init(struct lan743x_adapter
*adapter
)
800 bool mac_address_valid
= true;
801 struct net_device
*netdev
;
806 netdev
= adapter
->netdev
;
808 /* setup auto duplex, and speed detection */
809 data
= lan743x_csr_read(adapter
, MAC_CR
);
810 data
|= MAC_CR_ADD_
| MAC_CR_ASD_
;
811 data
|= MAC_CR_CNTR_RST_
;
812 lan743x_csr_write(adapter
, MAC_CR
, data
);
814 mac_addr_hi
= lan743x_csr_read(adapter
, MAC_RX_ADDRH
);
815 mac_addr_lo
= lan743x_csr_read(adapter
, MAC_RX_ADDRL
);
816 adapter
->mac_address
[0] = mac_addr_lo
& 0xFF;
817 adapter
->mac_address
[1] = (mac_addr_lo
>> 8) & 0xFF;
818 adapter
->mac_address
[2] = (mac_addr_lo
>> 16) & 0xFF;
819 adapter
->mac_address
[3] = (mac_addr_lo
>> 24) & 0xFF;
820 adapter
->mac_address
[4] = mac_addr_hi
& 0xFF;
821 adapter
->mac_address
[5] = (mac_addr_hi
>> 8) & 0xFF;
823 if (((mac_addr_hi
& 0x0000FFFF) == 0x0000FFFF) &&
824 mac_addr_lo
== 0xFFFFFFFF) {
825 mac_address_valid
= false;
826 } else if (!is_valid_ether_addr(adapter
->mac_address
)) {
827 mac_address_valid
= false;
830 if (!mac_address_valid
)
831 eth_random_addr(adapter
->mac_address
);
832 lan743x_mac_set_address(adapter
, adapter
->mac_address
);
833 ether_addr_copy(netdev
->dev_addr
, adapter
->mac_address
);
837 static int lan743x_mac_open(struct lan743x_adapter
*adapter
)
842 temp
= lan743x_csr_read(adapter
, MAC_RX
);
843 lan743x_csr_write(adapter
, MAC_RX
, temp
| MAC_RX_RXEN_
);
844 temp
= lan743x_csr_read(adapter
, MAC_TX
);
845 lan743x_csr_write(adapter
, MAC_TX
, temp
| MAC_TX_TXEN_
);
849 static void lan743x_mac_close(struct lan743x_adapter
*adapter
)
853 temp
= lan743x_csr_read(adapter
, MAC_TX
);
854 temp
&= ~MAC_TX_TXEN_
;
855 lan743x_csr_write(adapter
, MAC_TX
, temp
);
856 lan743x_csr_wait_for_bit(adapter
, MAC_TX
, MAC_TX_TXD_
,
857 1, 1000, 20000, 100);
859 temp
= lan743x_csr_read(adapter
, MAC_RX
);
860 temp
&= ~MAC_RX_RXEN_
;
861 lan743x_csr_write(adapter
, MAC_RX
, temp
);
862 lan743x_csr_wait_for_bit(adapter
, MAC_RX
, MAC_RX_RXD_
,
863 1, 1000, 20000, 100);
866 static void lan743x_mac_flow_ctrl_set_enables(struct lan743x_adapter
*adapter
,
867 bool tx_enable
, bool rx_enable
)
869 u32 flow_setting
= 0;
871 /* set maximum pause time because when fifo space frees
872 * up a zero value pause frame will be sent to release the pause
874 flow_setting
= MAC_FLOW_CR_FCPT_MASK_
;
876 flow_setting
|= MAC_FLOW_CR_TX_FCEN_
;
878 flow_setting
|= MAC_FLOW_CR_RX_FCEN_
;
879 lan743x_csr_write(adapter
, MAC_FLOW
, flow_setting
);
882 static int lan743x_mac_set_mtu(struct lan743x_adapter
*adapter
, int new_mtu
)
887 mac_rx
= lan743x_csr_read(adapter
, MAC_RX
);
888 if (mac_rx
& MAC_RX_RXEN_
) {
890 if (mac_rx
& MAC_RX_RXD_
) {
891 lan743x_csr_write(adapter
, MAC_RX
, mac_rx
);
892 mac_rx
&= ~MAC_RX_RXD_
;
894 mac_rx
&= ~MAC_RX_RXEN_
;
895 lan743x_csr_write(adapter
, MAC_RX
, mac_rx
);
896 lan743x_csr_wait_for_bit(adapter
, MAC_RX
, MAC_RX_RXD_
,
897 1, 1000, 20000, 100);
898 lan743x_csr_write(adapter
, MAC_RX
, mac_rx
| MAC_RX_RXD_
);
901 mac_rx
&= ~(MAC_RX_MAX_SIZE_MASK_
);
902 mac_rx
|= (((new_mtu
+ ETH_HLEN
+ 4) << MAC_RX_MAX_SIZE_SHIFT_
) &
903 MAC_RX_MAX_SIZE_MASK_
);
904 lan743x_csr_write(adapter
, MAC_RX
, mac_rx
);
907 mac_rx
|= MAC_RX_RXEN_
;
908 lan743x_csr_write(adapter
, MAC_RX
, mac_rx
);
914 static int lan743x_phy_reset(struct lan743x_adapter
*adapter
)
918 /* Only called with in probe, and before mdiobus_register */
920 data
= lan743x_csr_read(adapter
, PMT_CTL
);
921 data
|= PMT_CTL_ETH_PHY_RST_
;
922 lan743x_csr_write(adapter
, PMT_CTL
, data
);
924 return readx_poll_timeout(LAN743X_CSR_READ_OP
, PMT_CTL
, data
,
925 (!(data
& PMT_CTL_ETH_PHY_RST_
) &&
926 (data
& PMT_CTL_READY_
)),
930 static void lan743x_phy_update_flowcontrol(struct lan743x_adapter
*adapter
,
931 u8 duplex
, u16 local_adv
,
934 struct lan743x_phy
*phy
= &adapter
->phy
;
938 cap
= mii_resolve_flowctrl_fdx(local_adv
, remote_adv
);
940 cap
= phy
->fc_request_control
;
942 lan743x_mac_flow_ctrl_set_enables(adapter
,
947 static int lan743x_phy_init(struct lan743x_adapter
*adapter
)
949 return lan743x_phy_reset(adapter
);
952 static void lan743x_phy_link_status_change(struct net_device
*netdev
)
954 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
955 struct phy_device
*phydev
= netdev
->phydev
;
957 phy_print_status(phydev
);
958 if (phydev
->state
== PHY_RUNNING
) {
959 struct ethtool_link_ksettings ksettings
;
960 int remote_advertisement
= 0;
961 int local_advertisement
= 0;
963 memset(&ksettings
, 0, sizeof(ksettings
));
964 phy_ethtool_get_link_ksettings(netdev
, &ksettings
);
965 local_advertisement
= phy_read(phydev
, MII_ADVERTISE
);
966 if (local_advertisement
< 0)
969 remote_advertisement
= phy_read(phydev
, MII_LPA
);
970 if (remote_advertisement
< 0)
973 lan743x_phy_update_flowcontrol(adapter
,
974 ksettings
.base
.duplex
,
976 remote_advertisement
);
977 lan743x_ptp_update_latency(adapter
, ksettings
.base
.speed
);
981 static void lan743x_phy_close(struct lan743x_adapter
*adapter
)
983 struct net_device
*netdev
= adapter
->netdev
;
985 phy_stop(netdev
->phydev
);
986 phy_disconnect(netdev
->phydev
);
987 netdev
->phydev
= NULL
;
990 static int lan743x_phy_open(struct lan743x_adapter
*adapter
)
992 struct lan743x_phy
*phy
= &adapter
->phy
;
993 struct phy_device
*phydev
;
994 struct net_device
*netdev
;
997 netdev
= adapter
->netdev
;
998 phydev
= phy_find_first(adapter
->mdiobus
);
1002 ret
= phy_connect_direct(netdev
, phydev
,
1003 lan743x_phy_link_status_change
,
1004 PHY_INTERFACE_MODE_GMII
);
1008 /* MAC doesn't support 1000T Half */
1009 phy_remove_link_mode(phydev
, ETHTOOL_LINK_MODE_1000baseT_Half_BIT
);
1011 /* support both flow controls */
1012 phy_support_asym_pause(phydev
);
1013 phy
->fc_request_control
= (FLOW_CTRL_RX
| FLOW_CTRL_TX
);
1014 phy
->fc_autoneg
= phydev
->autoneg
;
1017 phy_start_aneg(phydev
);
1024 static void lan743x_rfe_open(struct lan743x_adapter
*adapter
)
1026 lan743x_csr_write(adapter
, RFE_RSS_CFG
,
1027 RFE_RSS_CFG_UDP_IPV6_EX_
|
1028 RFE_RSS_CFG_TCP_IPV6_EX_
|
1029 RFE_RSS_CFG_IPV6_EX_
|
1030 RFE_RSS_CFG_UDP_IPV6_
|
1031 RFE_RSS_CFG_TCP_IPV6_
|
1033 RFE_RSS_CFG_UDP_IPV4_
|
1034 RFE_RSS_CFG_TCP_IPV4_
|
1036 RFE_RSS_CFG_VALID_HASH_BITS_
|
1037 RFE_RSS_CFG_RSS_QUEUE_ENABLE_
|
1038 RFE_RSS_CFG_RSS_HASH_STORE_
|
1039 RFE_RSS_CFG_RSS_ENABLE_
);
1042 static void lan743x_rfe_update_mac_address(struct lan743x_adapter
*adapter
)
1045 u32 mac_addr_hi
= 0;
1046 u32 mac_addr_lo
= 0;
1048 /* Add mac address to perfect Filter */
1049 mac_addr
= adapter
->mac_address
;
1050 mac_addr_lo
= ((((u32
)(mac_addr
[0])) << 0) |
1051 (((u32
)(mac_addr
[1])) << 8) |
1052 (((u32
)(mac_addr
[2])) << 16) |
1053 (((u32
)(mac_addr
[3])) << 24));
1054 mac_addr_hi
= ((((u32
)(mac_addr
[4])) << 0) |
1055 (((u32
)(mac_addr
[5])) << 8));
1057 lan743x_csr_write(adapter
, RFE_ADDR_FILT_LO(0), mac_addr_lo
);
1058 lan743x_csr_write(adapter
, RFE_ADDR_FILT_HI(0),
1059 mac_addr_hi
| RFE_ADDR_FILT_HI_VALID_
);
1062 static void lan743x_rfe_set_multicast(struct lan743x_adapter
*adapter
)
1064 struct net_device
*netdev
= adapter
->netdev
;
1065 u32 hash_table
[DP_SEL_VHF_HASH_LEN
];
1069 rfctl
= lan743x_csr_read(adapter
, RFE_CTL
);
1070 rfctl
&= ~(RFE_CTL_AU_
| RFE_CTL_AM_
|
1071 RFE_CTL_DA_PERFECT_
| RFE_CTL_MCAST_HASH_
);
1072 rfctl
|= RFE_CTL_AB_
;
1073 if (netdev
->flags
& IFF_PROMISC
) {
1074 rfctl
|= RFE_CTL_AM_
| RFE_CTL_AU_
;
1076 if (netdev
->flags
& IFF_ALLMULTI
)
1077 rfctl
|= RFE_CTL_AM_
;
1080 memset(hash_table
, 0, DP_SEL_VHF_HASH_LEN
* sizeof(u32
));
1081 if (netdev_mc_count(netdev
)) {
1082 struct netdev_hw_addr
*ha
;
1085 rfctl
|= RFE_CTL_DA_PERFECT_
;
1087 netdev_for_each_mc_addr(ha
, netdev
) {
1088 /* set first 32 into Perfect Filter */
1090 lan743x_csr_write(adapter
,
1091 RFE_ADDR_FILT_HI(i
), 0);
1093 data
= ha
->addr
[2] | (data
<< 8);
1094 data
= ha
->addr
[1] | (data
<< 8);
1095 data
= ha
->addr
[0] | (data
<< 8);
1096 lan743x_csr_write(adapter
,
1097 RFE_ADDR_FILT_LO(i
), data
);
1099 data
= ha
->addr
[4] | (data
<< 8);
1100 data
|= RFE_ADDR_FILT_HI_VALID_
;
1101 lan743x_csr_write(adapter
,
1102 RFE_ADDR_FILT_HI(i
), data
);
1104 u32 bitnum
= (ether_crc(ETH_ALEN
, ha
->addr
) >>
1106 hash_table
[bitnum
/ 32] |= (1 << (bitnum
% 32));
1107 rfctl
|= RFE_CTL_MCAST_HASH_
;
1113 lan743x_dp_write(adapter
, DP_SEL_RFE_RAM
,
1114 DP_SEL_VHF_VLAN_LEN
,
1115 DP_SEL_VHF_HASH_LEN
, hash_table
);
1116 lan743x_csr_write(adapter
, RFE_CTL
, rfctl
);
1119 static int lan743x_dmac_init(struct lan743x_adapter
*adapter
)
1123 lan743x_csr_write(adapter
, DMAC_CMD
, DMAC_CMD_SWR_
);
1124 lan743x_csr_wait_for_bit(adapter
, DMAC_CMD
, DMAC_CMD_SWR_
,
1125 0, 1000, 20000, 100);
1126 switch (DEFAULT_DMA_DESCRIPTOR_SPACING
) {
1127 case DMA_DESCRIPTOR_SPACING_16
:
1128 data
= DMAC_CFG_MAX_DSPACE_16_
;
1130 case DMA_DESCRIPTOR_SPACING_32
:
1131 data
= DMAC_CFG_MAX_DSPACE_32_
;
1133 case DMA_DESCRIPTOR_SPACING_64
:
1134 data
= DMAC_CFG_MAX_DSPACE_64_
;
1136 case DMA_DESCRIPTOR_SPACING_128
:
1137 data
= DMAC_CFG_MAX_DSPACE_128_
;
1142 if (!(adapter
->csr
.flags
& LAN743X_CSR_FLAG_IS_A0
))
1143 data
|= DMAC_CFG_COAL_EN_
;
1144 data
|= DMAC_CFG_CH_ARB_SEL_RX_HIGH_
;
1145 data
|= DMAC_CFG_MAX_READ_REQ_SET_(6);
1146 lan743x_csr_write(adapter
, DMAC_CFG
, data
);
1147 data
= DMAC_COAL_CFG_TIMER_LIMIT_SET_(1);
1148 data
|= DMAC_COAL_CFG_TIMER_TX_START_
;
1149 data
|= DMAC_COAL_CFG_FLUSH_INTS_
;
1150 data
|= DMAC_COAL_CFG_INT_EXIT_COAL_
;
1151 data
|= DMAC_COAL_CFG_CSR_EXIT_COAL_
;
1152 data
|= DMAC_COAL_CFG_TX_THRES_SET_(0x0A);
1153 data
|= DMAC_COAL_CFG_RX_THRES_SET_(0x0C);
1154 lan743x_csr_write(adapter
, DMAC_COAL_CFG
, data
);
1155 data
= DMAC_OBFF_TX_THRES_SET_(0x08);
1156 data
|= DMAC_OBFF_RX_THRES_SET_(0x0A);
1157 lan743x_csr_write(adapter
, DMAC_OBFF_CFG
, data
);
1161 static int lan743x_dmac_tx_get_state(struct lan743x_adapter
*adapter
,
1166 dmac_cmd
= lan743x_csr_read(adapter
, DMAC_CMD
);
1167 return DMAC_CHANNEL_STATE_SET((dmac_cmd
&
1168 DMAC_CMD_START_T_(tx_channel
)),
1170 DMAC_CMD_STOP_T_(tx_channel
)));
1173 static int lan743x_dmac_tx_wait_till_stopped(struct lan743x_adapter
*adapter
,
1180 ((result
= lan743x_dmac_tx_get_state(adapter
, tx_channel
)) ==
1181 DMAC_CHANNEL_STATE_STOP_PENDING
)) {
1182 usleep_range(1000, 20000);
1185 if (result
== DMAC_CHANNEL_STATE_STOP_PENDING
)
1190 static int lan743x_dmac_rx_get_state(struct lan743x_adapter
*adapter
,
1195 dmac_cmd
= lan743x_csr_read(adapter
, DMAC_CMD
);
1196 return DMAC_CHANNEL_STATE_SET((dmac_cmd
&
1197 DMAC_CMD_START_R_(rx_channel
)),
1199 DMAC_CMD_STOP_R_(rx_channel
)));
1202 static int lan743x_dmac_rx_wait_till_stopped(struct lan743x_adapter
*adapter
,
1209 ((result
= lan743x_dmac_rx_get_state(adapter
, rx_channel
)) ==
1210 DMAC_CHANNEL_STATE_STOP_PENDING
)) {
1211 usleep_range(1000, 20000);
1214 if (result
== DMAC_CHANNEL_STATE_STOP_PENDING
)
1219 static void lan743x_tx_release_desc(struct lan743x_tx
*tx
,
1220 int descriptor_index
, bool cleanup
)
1222 struct lan743x_tx_buffer_info
*buffer_info
= NULL
;
1223 struct lan743x_tx_descriptor
*descriptor
= NULL
;
1224 u32 descriptor_type
= 0;
1227 descriptor
= &tx
->ring_cpu_ptr
[descriptor_index
];
1228 buffer_info
= &tx
->buffer_info
[descriptor_index
];
1229 if (!(buffer_info
->flags
& TX_BUFFER_INFO_FLAG_ACTIVE
))
1232 descriptor_type
= (descriptor
->data0
) &
1233 TX_DESC_DATA0_DTYPE_MASK_
;
1234 if (descriptor_type
== TX_DESC_DATA0_DTYPE_DATA_
)
1235 goto clean_up_data_descriptor
;
1239 clean_up_data_descriptor
:
1240 if (buffer_info
->dma_ptr
) {
1241 if (buffer_info
->flags
&
1242 TX_BUFFER_INFO_FLAG_SKB_FRAGMENT
) {
1243 dma_unmap_page(&tx
->adapter
->pdev
->dev
,
1244 buffer_info
->dma_ptr
,
1245 buffer_info
->buffer_length
,
1248 dma_unmap_single(&tx
->adapter
->pdev
->dev
,
1249 buffer_info
->dma_ptr
,
1250 buffer_info
->buffer_length
,
1253 buffer_info
->dma_ptr
= 0;
1254 buffer_info
->buffer_length
= 0;
1256 if (!buffer_info
->skb
)
1259 if (!(buffer_info
->flags
& TX_BUFFER_INFO_FLAG_TIMESTAMP_REQUESTED
)) {
1260 dev_kfree_skb(buffer_info
->skb
);
1265 lan743x_ptp_unrequest_tx_timestamp(tx
->adapter
);
1266 dev_kfree_skb(buffer_info
->skb
);
1268 ignore_sync
= (buffer_info
->flags
&
1269 TX_BUFFER_INFO_FLAG_IGNORE_SYNC
) != 0;
1270 lan743x_ptp_tx_timestamp_skb(tx
->adapter
,
1271 buffer_info
->skb
, ignore_sync
);
1275 buffer_info
->skb
= NULL
;
1278 buffer_info
->flags
&= ~TX_BUFFER_INFO_FLAG_ACTIVE
;
1281 memset(buffer_info
, 0, sizeof(*buffer_info
));
1282 memset(descriptor
, 0, sizeof(*descriptor
));
1285 static int lan743x_tx_next_index(struct lan743x_tx
*tx
, int index
)
1287 return ((++index
) % tx
->ring_size
);
1290 static void lan743x_tx_release_completed_descriptors(struct lan743x_tx
*tx
)
1292 while ((*tx
->head_cpu_ptr
) != (tx
->last_head
)) {
1293 lan743x_tx_release_desc(tx
, tx
->last_head
, false);
1294 tx
->last_head
= lan743x_tx_next_index(tx
, tx
->last_head
);
1298 static void lan743x_tx_release_all_descriptors(struct lan743x_tx
*tx
)
1300 u32 original_head
= 0;
1302 original_head
= tx
->last_head
;
1304 lan743x_tx_release_desc(tx
, tx
->last_head
, true);
1305 tx
->last_head
= lan743x_tx_next_index(tx
, tx
->last_head
);
1306 } while (tx
->last_head
!= original_head
);
1307 memset(tx
->ring_cpu_ptr
, 0,
1308 sizeof(*tx
->ring_cpu_ptr
) * (tx
->ring_size
));
1309 memset(tx
->buffer_info
, 0,
1310 sizeof(*tx
->buffer_info
) * (tx
->ring_size
));
1313 static int lan743x_tx_get_desc_cnt(struct lan743x_tx
*tx
,
1314 struct sk_buff
*skb
)
1316 int result
= 1; /* 1 for the main skb buffer */
1319 if (skb_is_gso(skb
))
1320 result
++; /* requires an extension descriptor */
1321 nr_frags
= skb_shinfo(skb
)->nr_frags
;
1322 result
+= nr_frags
; /* 1 for each fragment buffer */
1326 static int lan743x_tx_get_avail_desc(struct lan743x_tx
*tx
)
1328 int last_head
= tx
->last_head
;
1329 int last_tail
= tx
->last_tail
;
1331 if (last_tail
>= last_head
)
1332 return tx
->ring_size
- last_tail
+ last_head
- 1;
1334 return last_head
- last_tail
- 1;
1337 void lan743x_tx_set_timestamping_mode(struct lan743x_tx
*tx
,
1338 bool enable_timestamping
,
1339 bool enable_onestep_sync
)
1341 if (enable_timestamping
)
1342 tx
->ts_flags
|= TX_TS_FLAG_TIMESTAMPING_ENABLED
;
1344 tx
->ts_flags
&= ~TX_TS_FLAG_TIMESTAMPING_ENABLED
;
1345 if (enable_onestep_sync
)
1346 tx
->ts_flags
|= TX_TS_FLAG_ONE_STEP_SYNC
;
1348 tx
->ts_flags
&= ~TX_TS_FLAG_ONE_STEP_SYNC
;
1351 static int lan743x_tx_frame_start(struct lan743x_tx
*tx
,
1352 unsigned char *first_buffer
,
1353 unsigned int first_buffer_length
,
1354 unsigned int frame_length
,
1358 /* called only from within lan743x_tx_xmit_frame.
1359 * assuming tx->ring_lock has already been acquired.
1361 struct lan743x_tx_descriptor
*tx_descriptor
= NULL
;
1362 struct lan743x_tx_buffer_info
*buffer_info
= NULL
;
1363 struct lan743x_adapter
*adapter
= tx
->adapter
;
1364 struct device
*dev
= &adapter
->pdev
->dev
;
1367 tx
->frame_flags
|= TX_FRAME_FLAG_IN_PROGRESS
;
1368 tx
->frame_first
= tx
->last_tail
;
1369 tx
->frame_tail
= tx
->frame_first
;
1371 tx_descriptor
= &tx
->ring_cpu_ptr
[tx
->frame_tail
];
1372 buffer_info
= &tx
->buffer_info
[tx
->frame_tail
];
1373 dma_ptr
= dma_map_single(dev
, first_buffer
, first_buffer_length
,
1375 if (dma_mapping_error(dev
, dma_ptr
))
1378 tx_descriptor
->data1
= DMA_ADDR_LOW32(dma_ptr
);
1379 tx_descriptor
->data2
= DMA_ADDR_HIGH32(dma_ptr
);
1380 tx_descriptor
->data3
= (frame_length
<< 16) &
1381 TX_DESC_DATA3_FRAME_LENGTH_MSS_MASK_
;
1383 buffer_info
->skb
= NULL
;
1384 buffer_info
->dma_ptr
= dma_ptr
;
1385 buffer_info
->buffer_length
= first_buffer_length
;
1386 buffer_info
->flags
|= TX_BUFFER_INFO_FLAG_ACTIVE
;
1388 tx
->frame_data0
= (first_buffer_length
&
1389 TX_DESC_DATA0_BUF_LENGTH_MASK_
) |
1390 TX_DESC_DATA0_DTYPE_DATA_
|
1394 tx
->frame_data0
|= TX_DESC_DATA0_TSE_
;
1397 tx
->frame_data0
|= TX_DESC_DATA0_ICE_
|
1398 TX_DESC_DATA0_IPE_
|
1401 /* data0 will be programmed in one of other frame assembler functions */
1405 static void lan743x_tx_frame_add_lso(struct lan743x_tx
*tx
,
1406 unsigned int frame_length
)
1408 /* called only from within lan743x_tx_xmit_frame.
1409 * assuming tx->ring_lock has already been acquired.
1411 struct lan743x_tx_descriptor
*tx_descriptor
= NULL
;
1412 struct lan743x_tx_buffer_info
*buffer_info
= NULL
;
1414 /* wrap up previous descriptor */
1415 tx
->frame_data0
|= TX_DESC_DATA0_EXT_
;
1416 tx_descriptor
= &tx
->ring_cpu_ptr
[tx
->frame_tail
];
1417 tx_descriptor
->data0
= tx
->frame_data0
;
1419 /* move to next descriptor */
1420 tx
->frame_tail
= lan743x_tx_next_index(tx
, tx
->frame_tail
);
1421 tx_descriptor
= &tx
->ring_cpu_ptr
[tx
->frame_tail
];
1422 buffer_info
= &tx
->buffer_info
[tx
->frame_tail
];
1424 /* add extension descriptor */
1425 tx_descriptor
->data1
= 0;
1426 tx_descriptor
->data2
= 0;
1427 tx_descriptor
->data3
= 0;
1429 buffer_info
->skb
= NULL
;
1430 buffer_info
->dma_ptr
= 0;
1431 buffer_info
->buffer_length
= 0;
1432 buffer_info
->flags
|= TX_BUFFER_INFO_FLAG_ACTIVE
;
1434 tx
->frame_data0
= (frame_length
& TX_DESC_DATA0_EXT_PAY_LENGTH_MASK_
) |
1435 TX_DESC_DATA0_DTYPE_EXT_
|
1436 TX_DESC_DATA0_EXT_LSO_
;
1438 /* data0 will be programmed in one of other frame assembler functions */
1441 static int lan743x_tx_frame_add_fragment(struct lan743x_tx
*tx
,
1442 const struct skb_frag_struct
*fragment
,
1443 unsigned int frame_length
)
1445 /* called only from within lan743x_tx_xmit_frame
1446 * assuming tx->ring_lock has already been acquired
1448 struct lan743x_tx_descriptor
*tx_descriptor
= NULL
;
1449 struct lan743x_tx_buffer_info
*buffer_info
= NULL
;
1450 struct lan743x_adapter
*adapter
= tx
->adapter
;
1451 struct device
*dev
= &adapter
->pdev
->dev
;
1452 unsigned int fragment_length
= 0;
1455 fragment_length
= skb_frag_size(fragment
);
1456 if (!fragment_length
)
1459 /* wrap up previous descriptor */
1460 tx_descriptor
= &tx
->ring_cpu_ptr
[tx
->frame_tail
];
1461 tx_descriptor
->data0
= tx
->frame_data0
;
1463 /* move to next descriptor */
1464 tx
->frame_tail
= lan743x_tx_next_index(tx
, tx
->frame_tail
);
1465 tx_descriptor
= &tx
->ring_cpu_ptr
[tx
->frame_tail
];
1466 buffer_info
= &tx
->buffer_info
[tx
->frame_tail
];
1467 dma_ptr
= skb_frag_dma_map(dev
, fragment
,
1470 if (dma_mapping_error(dev
, dma_ptr
)) {
1473 /* cleanup all previously setup descriptors */
1474 desc_index
= tx
->frame_first
;
1475 while (desc_index
!= tx
->frame_tail
) {
1476 lan743x_tx_release_desc(tx
, desc_index
, true);
1477 desc_index
= lan743x_tx_next_index(tx
, desc_index
);
1480 tx
->frame_flags
&= ~TX_FRAME_FLAG_IN_PROGRESS
;
1481 tx
->frame_first
= 0;
1482 tx
->frame_data0
= 0;
1487 tx_descriptor
->data1
= DMA_ADDR_LOW32(dma_ptr
);
1488 tx_descriptor
->data2
= DMA_ADDR_HIGH32(dma_ptr
);
1489 tx_descriptor
->data3
= (frame_length
<< 16) &
1490 TX_DESC_DATA3_FRAME_LENGTH_MSS_MASK_
;
1492 buffer_info
->skb
= NULL
;
1493 buffer_info
->dma_ptr
= dma_ptr
;
1494 buffer_info
->buffer_length
= fragment_length
;
1495 buffer_info
->flags
|= TX_BUFFER_INFO_FLAG_ACTIVE
;
1496 buffer_info
->flags
|= TX_BUFFER_INFO_FLAG_SKB_FRAGMENT
;
1498 tx
->frame_data0
= (fragment_length
& TX_DESC_DATA0_BUF_LENGTH_MASK_
) |
1499 TX_DESC_DATA0_DTYPE_DATA_
|
1502 /* data0 will be programmed in one of other frame assembler functions */
1506 static void lan743x_tx_frame_end(struct lan743x_tx
*tx
,
1507 struct sk_buff
*skb
,
1511 /* called only from within lan743x_tx_xmit_frame
1512 * assuming tx->ring_lock has already been acquired
1514 struct lan743x_tx_descriptor
*tx_descriptor
= NULL
;
1515 struct lan743x_tx_buffer_info
*buffer_info
= NULL
;
1516 struct lan743x_adapter
*adapter
= tx
->adapter
;
1517 u32 tx_tail_flags
= 0;
1519 /* wrap up previous descriptor */
1520 tx
->frame_data0
|= TX_DESC_DATA0_LS_
;
1521 tx
->frame_data0
|= TX_DESC_DATA0_IOC_
;
1523 tx_descriptor
= &tx
->ring_cpu_ptr
[tx
->frame_tail
];
1524 buffer_info
= &tx
->buffer_info
[tx
->frame_tail
];
1525 buffer_info
->skb
= skb
;
1527 buffer_info
->flags
|= TX_BUFFER_INFO_FLAG_TIMESTAMP_REQUESTED
;
1529 buffer_info
->flags
|= TX_BUFFER_INFO_FLAG_IGNORE_SYNC
;
1531 tx_descriptor
->data0
= tx
->frame_data0
;
1532 tx
->frame_tail
= lan743x_tx_next_index(tx
, tx
->frame_tail
);
1533 tx
->last_tail
= tx
->frame_tail
;
1537 if (tx
->vector_flags
& LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET
)
1538 tx_tail_flags
|= TX_TAIL_SET_TOP_INT_VEC_EN_
;
1539 if (tx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET
)
1540 tx_tail_flags
|= TX_TAIL_SET_DMAC_INT_EN_
|
1541 TX_TAIL_SET_TOP_INT_EN_
;
1543 lan743x_csr_write(adapter
, TX_TAIL(tx
->channel_number
),
1544 tx_tail_flags
| tx
->frame_tail
);
1545 tx
->frame_flags
&= ~TX_FRAME_FLAG_IN_PROGRESS
;
1548 static netdev_tx_t
lan743x_tx_xmit_frame(struct lan743x_tx
*tx
,
1549 struct sk_buff
*skb
)
1551 int required_number_of_descriptors
= 0;
1552 unsigned int start_frame_length
= 0;
1553 unsigned int frame_length
= 0;
1554 unsigned int head_length
= 0;
1555 unsigned long irq_flags
= 0;
1556 bool do_timestamp
= false;
1557 bool ignore_sync
= false;
1562 required_number_of_descriptors
= lan743x_tx_get_desc_cnt(tx
, skb
);
1564 spin_lock_irqsave(&tx
->ring_lock
, irq_flags
);
1565 if (required_number_of_descriptors
>
1566 lan743x_tx_get_avail_desc(tx
)) {
1567 if (required_number_of_descriptors
> (tx
->ring_size
- 1)) {
1570 /* save to overflow buffer */
1571 tx
->overflow_skb
= skb
;
1572 netif_stop_queue(tx
->adapter
->netdev
);
1577 /* space available, transmit skb */
1578 if ((skb_shinfo(skb
)->tx_flags
& SKBTX_HW_TSTAMP
) &&
1579 (tx
->ts_flags
& TX_TS_FLAG_TIMESTAMPING_ENABLED
) &&
1580 (lan743x_ptp_request_tx_timestamp(tx
->adapter
))) {
1581 skb_shinfo(skb
)->tx_flags
|= SKBTX_IN_PROGRESS
;
1582 do_timestamp
= true;
1583 if (tx
->ts_flags
& TX_TS_FLAG_ONE_STEP_SYNC
)
1586 head_length
= skb_headlen(skb
);
1587 frame_length
= skb_pagelen(skb
);
1588 nr_frags
= skb_shinfo(skb
)->nr_frags
;
1589 start_frame_length
= frame_length
;
1590 gso
= skb_is_gso(skb
);
1592 start_frame_length
= max(skb_shinfo(skb
)->gso_size
,
1596 if (lan743x_tx_frame_start(tx
,
1597 skb
->data
, head_length
,
1600 skb
->ip_summed
== CHECKSUM_PARTIAL
)) {
1606 lan743x_tx_frame_add_lso(tx
, frame_length
);
1611 for (j
= 0; j
< nr_frags
; j
++) {
1612 const struct skb_frag_struct
*frag
;
1614 frag
= &(skb_shinfo(skb
)->frags
[j
]);
1615 if (lan743x_tx_frame_add_fragment(tx
, frag
, frame_length
)) {
1616 /* upon error no need to call
1617 * lan743x_tx_frame_end
1618 * frame assembler clean up was performed inside
1619 * lan743x_tx_frame_add_fragment
1627 lan743x_tx_frame_end(tx
, skb
, do_timestamp
, ignore_sync
);
1630 spin_unlock_irqrestore(&tx
->ring_lock
, irq_flags
);
1631 return NETDEV_TX_OK
;
1634 static int lan743x_tx_napi_poll(struct napi_struct
*napi
, int weight
)
1636 struct lan743x_tx
*tx
= container_of(napi
, struct lan743x_tx
, napi
);
1637 struct lan743x_adapter
*adapter
= tx
->adapter
;
1638 bool start_transmitter
= false;
1639 unsigned long irq_flags
= 0;
1643 ioc_bit
= DMAC_INT_BIT_TX_IOC_(tx
->channel_number
);
1644 int_sts
= lan743x_csr_read(adapter
, DMAC_INT_STS
);
1645 if (tx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C
)
1646 lan743x_csr_write(adapter
, DMAC_INT_STS
, ioc_bit
);
1647 spin_lock_irqsave(&tx
->ring_lock
, irq_flags
);
1649 /* clean up tx ring */
1650 lan743x_tx_release_completed_descriptors(tx
);
1651 if (netif_queue_stopped(adapter
->netdev
)) {
1652 if (tx
->overflow_skb
) {
1653 if (lan743x_tx_get_desc_cnt(tx
, tx
->overflow_skb
) <=
1654 lan743x_tx_get_avail_desc(tx
))
1655 start_transmitter
= true;
1657 netif_wake_queue(adapter
->netdev
);
1660 spin_unlock_irqrestore(&tx
->ring_lock
, irq_flags
);
1662 if (start_transmitter
) {
1663 /* space is now available, transmit overflow skb */
1664 lan743x_tx_xmit_frame(tx
, tx
->overflow_skb
);
1665 tx
->overflow_skb
= NULL
;
1666 netif_wake_queue(adapter
->netdev
);
1669 if (!napi_complete(napi
))
1673 lan743x_csr_write(adapter
, INT_EN_SET
,
1674 INT_BIT_DMA_TX_(tx
->channel_number
));
1675 lan743x_csr_read(adapter
, INT_STS
);
1681 static void lan743x_tx_ring_cleanup(struct lan743x_tx
*tx
)
1683 if (tx
->head_cpu_ptr
) {
1684 pci_free_consistent(tx
->adapter
->pdev
,
1685 sizeof(*tx
->head_cpu_ptr
),
1686 (void *)(tx
->head_cpu_ptr
),
1688 tx
->head_cpu_ptr
= NULL
;
1689 tx
->head_dma_ptr
= 0;
1691 kfree(tx
->buffer_info
);
1692 tx
->buffer_info
= NULL
;
1694 if (tx
->ring_cpu_ptr
) {
1695 pci_free_consistent(tx
->adapter
->pdev
,
1696 tx
->ring_allocation_size
,
1699 tx
->ring_allocation_size
= 0;
1700 tx
->ring_cpu_ptr
= NULL
;
1701 tx
->ring_dma_ptr
= 0;
1706 static int lan743x_tx_ring_init(struct lan743x_tx
*tx
)
1708 size_t ring_allocation_size
= 0;
1709 void *cpu_ptr
= NULL
;
1713 tx
->ring_size
= LAN743X_TX_RING_SIZE
;
1714 if (tx
->ring_size
& ~TX_CFG_B_TX_RING_LEN_MASK_
) {
1718 ring_allocation_size
= ALIGN(tx
->ring_size
*
1719 sizeof(struct lan743x_tx_descriptor
),
1722 cpu_ptr
= pci_zalloc_consistent(tx
->adapter
->pdev
,
1723 ring_allocation_size
, &dma_ptr
);
1729 tx
->ring_allocation_size
= ring_allocation_size
;
1730 tx
->ring_cpu_ptr
= (struct lan743x_tx_descriptor
*)cpu_ptr
;
1731 tx
->ring_dma_ptr
= dma_ptr
;
1733 cpu_ptr
= kcalloc(tx
->ring_size
, sizeof(*tx
->buffer_info
), GFP_KERNEL
);
1738 tx
->buffer_info
= (struct lan743x_tx_buffer_info
*)cpu_ptr
;
1740 cpu_ptr
= pci_zalloc_consistent(tx
->adapter
->pdev
,
1741 sizeof(*tx
->head_cpu_ptr
), &dma_ptr
);
1747 tx
->head_cpu_ptr
= cpu_ptr
;
1748 tx
->head_dma_ptr
= dma_ptr
;
1749 if (tx
->head_dma_ptr
& 0x3) {
1757 lan743x_tx_ring_cleanup(tx
);
1761 static void lan743x_tx_close(struct lan743x_tx
*tx
)
1763 struct lan743x_adapter
*adapter
= tx
->adapter
;
1765 lan743x_csr_write(adapter
,
1767 DMAC_CMD_STOP_T_(tx
->channel_number
));
1768 lan743x_dmac_tx_wait_till_stopped(adapter
, tx
->channel_number
);
1770 lan743x_csr_write(adapter
,
1772 DMAC_INT_BIT_TX_IOC_(tx
->channel_number
));
1773 lan743x_csr_write(adapter
, INT_EN_CLR
,
1774 INT_BIT_DMA_TX_(tx
->channel_number
));
1775 napi_disable(&tx
->napi
);
1776 netif_napi_del(&tx
->napi
);
1778 lan743x_csr_write(adapter
, FCT_TX_CTL
,
1779 FCT_TX_CTL_DIS_(tx
->channel_number
));
1780 lan743x_csr_wait_for_bit(adapter
, FCT_TX_CTL
,
1781 FCT_TX_CTL_EN_(tx
->channel_number
),
1782 0, 1000, 20000, 100);
1784 lan743x_tx_release_all_descriptors(tx
);
1786 if (tx
->overflow_skb
) {
1787 dev_kfree_skb(tx
->overflow_skb
);
1788 tx
->overflow_skb
= NULL
;
1791 lan743x_tx_ring_cleanup(tx
);
1794 static int lan743x_tx_open(struct lan743x_tx
*tx
)
1796 struct lan743x_adapter
*adapter
= NULL
;
1800 adapter
= tx
->adapter
;
1801 ret
= lan743x_tx_ring_init(tx
);
1805 /* initialize fifo */
1806 lan743x_csr_write(adapter
, FCT_TX_CTL
,
1807 FCT_TX_CTL_RESET_(tx
->channel_number
));
1808 lan743x_csr_wait_for_bit(adapter
, FCT_TX_CTL
,
1809 FCT_TX_CTL_RESET_(tx
->channel_number
),
1810 0, 1000, 20000, 100);
1813 lan743x_csr_write(adapter
, FCT_TX_CTL
,
1814 FCT_TX_CTL_EN_(tx
->channel_number
));
1816 /* reset tx channel */
1817 lan743x_csr_write(adapter
, DMAC_CMD
,
1818 DMAC_CMD_TX_SWR_(tx
->channel_number
));
1819 lan743x_csr_wait_for_bit(adapter
, DMAC_CMD
,
1820 DMAC_CMD_TX_SWR_(tx
->channel_number
),
1821 0, 1000, 20000, 100);
1823 /* Write TX_BASE_ADDR */
1824 lan743x_csr_write(adapter
,
1825 TX_BASE_ADDRH(tx
->channel_number
),
1826 DMA_ADDR_HIGH32(tx
->ring_dma_ptr
));
1827 lan743x_csr_write(adapter
,
1828 TX_BASE_ADDRL(tx
->channel_number
),
1829 DMA_ADDR_LOW32(tx
->ring_dma_ptr
));
1831 /* Write TX_CFG_B */
1832 data
= lan743x_csr_read(adapter
, TX_CFG_B(tx
->channel_number
));
1833 data
&= ~TX_CFG_B_TX_RING_LEN_MASK_
;
1834 data
|= ((tx
->ring_size
) & TX_CFG_B_TX_RING_LEN_MASK_
);
1835 if (!(adapter
->csr
.flags
& LAN743X_CSR_FLAG_IS_A0
))
1836 data
|= TX_CFG_B_TDMABL_512_
;
1837 lan743x_csr_write(adapter
, TX_CFG_B(tx
->channel_number
), data
);
1839 /* Write TX_CFG_A */
1840 data
= TX_CFG_A_TX_TMR_HPWB_SEL_IOC_
| TX_CFG_A_TX_HP_WB_EN_
;
1841 if (!(adapter
->csr
.flags
& LAN743X_CSR_FLAG_IS_A0
)) {
1842 data
|= TX_CFG_A_TX_HP_WB_ON_INT_TMR_
;
1843 data
|= TX_CFG_A_TX_PF_THRES_SET_(0x10);
1844 data
|= TX_CFG_A_TX_PF_PRI_THRES_SET_(0x04);
1845 data
|= TX_CFG_A_TX_HP_WB_THRES_SET_(0x07);
1847 lan743x_csr_write(adapter
, TX_CFG_A(tx
->channel_number
), data
);
1849 /* Write TX_HEAD_WRITEBACK_ADDR */
1850 lan743x_csr_write(adapter
,
1851 TX_HEAD_WRITEBACK_ADDRH(tx
->channel_number
),
1852 DMA_ADDR_HIGH32(tx
->head_dma_ptr
));
1853 lan743x_csr_write(adapter
,
1854 TX_HEAD_WRITEBACK_ADDRL(tx
->channel_number
),
1855 DMA_ADDR_LOW32(tx
->head_dma_ptr
));
1858 tx
->last_head
= lan743x_csr_read(adapter
, TX_HEAD(tx
->channel_number
));
1862 lan743x_csr_write(adapter
, TX_TAIL(tx
->channel_number
),
1863 (u32
)(tx
->last_tail
));
1864 tx
->vector_flags
= lan743x_intr_get_vector_flags(adapter
,
1866 (tx
->channel_number
));
1867 netif_tx_napi_add(adapter
->netdev
,
1868 &tx
->napi
, lan743x_tx_napi_poll
,
1870 napi_enable(&tx
->napi
);
1873 if (tx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR
)
1874 data
|= TX_CFG_C_TX_TOP_INT_EN_AUTO_CLR_
;
1875 if (tx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR
)
1876 data
|= TX_CFG_C_TX_DMA_INT_STS_AUTO_CLR_
;
1877 if (tx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C
)
1878 data
|= TX_CFG_C_TX_INT_STS_R2C_MODE_MASK_
;
1879 if (tx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C
)
1880 data
|= TX_CFG_C_TX_INT_EN_R2C_
;
1881 lan743x_csr_write(adapter
, TX_CFG_C(tx
->channel_number
), data
);
1883 if (!(tx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET
))
1884 lan743x_csr_write(adapter
, INT_EN_SET
,
1885 INT_BIT_DMA_TX_(tx
->channel_number
));
1886 lan743x_csr_write(adapter
, DMAC_INT_EN_SET
,
1887 DMAC_INT_BIT_TX_IOC_(tx
->channel_number
));
1889 /* start dmac channel */
1890 lan743x_csr_write(adapter
, DMAC_CMD
,
1891 DMAC_CMD_START_T_(tx
->channel_number
));
1895 static int lan743x_rx_next_index(struct lan743x_rx
*rx
, int index
)
1897 return ((++index
) % rx
->ring_size
);
1900 static int lan743x_rx_allocate_ring_element(struct lan743x_rx
*rx
, int index
)
1902 struct lan743x_rx_buffer_info
*buffer_info
;
1903 struct lan743x_rx_descriptor
*descriptor
;
1906 length
= (LAN743X_MAX_FRAME_SIZE
+ ETH_HLEN
+ 4 + RX_HEAD_PADDING
);
1907 descriptor
= &rx
->ring_cpu_ptr
[index
];
1908 buffer_info
= &rx
->buffer_info
[index
];
1909 buffer_info
->skb
= __netdev_alloc_skb(rx
->adapter
->netdev
,
1911 GFP_ATOMIC
| GFP_DMA
);
1912 if (!(buffer_info
->skb
))
1914 buffer_info
->dma_ptr
= dma_map_single(&rx
->adapter
->pdev
->dev
,
1915 buffer_info
->skb
->data
,
1918 if (dma_mapping_error(&rx
->adapter
->pdev
->dev
,
1919 buffer_info
->dma_ptr
)) {
1920 buffer_info
->dma_ptr
= 0;
1924 buffer_info
->buffer_length
= length
;
1925 descriptor
->data1
= DMA_ADDR_LOW32(buffer_info
->dma_ptr
);
1926 descriptor
->data2
= DMA_ADDR_HIGH32(buffer_info
->dma_ptr
);
1927 descriptor
->data3
= 0;
1928 descriptor
->data0
= (RX_DESC_DATA0_OWN_
|
1929 (length
& RX_DESC_DATA0_BUF_LENGTH_MASK_
));
1930 skb_reserve(buffer_info
->skb
, RX_HEAD_PADDING
);
1935 static void lan743x_rx_reuse_ring_element(struct lan743x_rx
*rx
, int index
)
1937 struct lan743x_rx_buffer_info
*buffer_info
;
1938 struct lan743x_rx_descriptor
*descriptor
;
1940 descriptor
= &rx
->ring_cpu_ptr
[index
];
1941 buffer_info
= &rx
->buffer_info
[index
];
1943 descriptor
->data1
= DMA_ADDR_LOW32(buffer_info
->dma_ptr
);
1944 descriptor
->data2
= DMA_ADDR_HIGH32(buffer_info
->dma_ptr
);
1945 descriptor
->data3
= 0;
1946 descriptor
->data0
= (RX_DESC_DATA0_OWN_
|
1947 ((buffer_info
->buffer_length
) &
1948 RX_DESC_DATA0_BUF_LENGTH_MASK_
));
1951 static void lan743x_rx_release_ring_element(struct lan743x_rx
*rx
, int index
)
1953 struct lan743x_rx_buffer_info
*buffer_info
;
1954 struct lan743x_rx_descriptor
*descriptor
;
1956 descriptor
= &rx
->ring_cpu_ptr
[index
];
1957 buffer_info
= &rx
->buffer_info
[index
];
1959 memset(descriptor
, 0, sizeof(*descriptor
));
1961 if (buffer_info
->dma_ptr
) {
1962 dma_unmap_single(&rx
->adapter
->pdev
->dev
,
1963 buffer_info
->dma_ptr
,
1964 buffer_info
->buffer_length
,
1966 buffer_info
->dma_ptr
= 0;
1969 if (buffer_info
->skb
) {
1970 dev_kfree_skb(buffer_info
->skb
);
1971 buffer_info
->skb
= NULL
;
1974 memset(buffer_info
, 0, sizeof(*buffer_info
));
1977 static int lan743x_rx_process_packet(struct lan743x_rx
*rx
)
1979 struct skb_shared_hwtstamps
*hwtstamps
= NULL
;
1980 int result
= RX_PROCESS_RESULT_NOTHING_TO_DO
;
1981 struct lan743x_rx_buffer_info
*buffer_info
;
1982 struct lan743x_rx_descriptor
*descriptor
;
1983 int current_head_index
= -1;
1984 int extension_index
= -1;
1985 int first_index
= -1;
1986 int last_index
= -1;
1988 current_head_index
= *rx
->head_cpu_ptr
;
1989 if (current_head_index
< 0 || current_head_index
>= rx
->ring_size
)
1992 if (rx
->last_head
< 0 || rx
->last_head
>= rx
->ring_size
)
1995 if (rx
->last_head
!= current_head_index
) {
1996 descriptor
= &rx
->ring_cpu_ptr
[rx
->last_head
];
1997 if (descriptor
->data0
& RX_DESC_DATA0_OWN_
)
2000 if (!(descriptor
->data0
& RX_DESC_DATA0_FS_
))
2003 first_index
= rx
->last_head
;
2004 if (descriptor
->data0
& RX_DESC_DATA0_LS_
) {
2005 last_index
= rx
->last_head
;
2009 index
= lan743x_rx_next_index(rx
, first_index
);
2010 while (index
!= current_head_index
) {
2011 descriptor
= &rx
->ring_cpu_ptr
[index
];
2012 if (descriptor
->data0
& RX_DESC_DATA0_OWN_
)
2015 if (descriptor
->data0
& RX_DESC_DATA0_LS_
) {
2019 index
= lan743x_rx_next_index(rx
, index
);
2022 if (last_index
>= 0) {
2023 descriptor
= &rx
->ring_cpu_ptr
[last_index
];
2024 if (descriptor
->data0
& RX_DESC_DATA0_EXT_
) {
2025 /* extension is expected to follow */
2026 int index
= lan743x_rx_next_index(rx
,
2028 if (index
!= current_head_index
) {
2029 descriptor
= &rx
->ring_cpu_ptr
[index
];
2030 if (descriptor
->data0
&
2031 RX_DESC_DATA0_OWN_
) {
2034 if (descriptor
->data0
&
2035 RX_DESC_DATA0_EXT_
) {
2036 extension_index
= index
;
2041 /* extension is not yet available */
2042 /* prevent processing of this packet */
2049 if (first_index
>= 0 && last_index
>= 0) {
2050 int real_last_index
= last_index
;
2051 struct sk_buff
*skb
= NULL
;
2055 /* packet is available */
2056 if (first_index
== last_index
) {
2057 /* single buffer packet */
2060 buffer_info
= &rx
->buffer_info
[first_index
];
2061 skb
= buffer_info
->skb
;
2062 descriptor
= &rx
->ring_cpu_ptr
[first_index
];
2064 /* unmap from dma */
2065 if (buffer_info
->dma_ptr
) {
2066 dma_unmap_single(&rx
->adapter
->pdev
->dev
,
2067 buffer_info
->dma_ptr
,
2068 buffer_info
->buffer_length
,
2070 buffer_info
->dma_ptr
= 0;
2071 buffer_info
->buffer_length
= 0;
2073 buffer_info
->skb
= NULL
;
2074 packet_length
= RX_DESC_DATA0_FRAME_LENGTH_GET_
2075 (descriptor
->data0
);
2076 skb_put(skb
, packet_length
- 4);
2077 skb
->protocol
= eth_type_trans(skb
,
2078 rx
->adapter
->netdev
);
2079 lan743x_rx_allocate_ring_element(rx
, first_index
);
2081 int index
= first_index
;
2083 /* multi buffer packet not supported */
2084 /* this should not happen since
2085 * buffers are allocated to be at least jumbo size
2088 /* clean up buffers */
2089 if (first_index
<= last_index
) {
2090 while ((index
>= first_index
) &&
2091 (index
<= last_index
)) {
2092 lan743x_rx_release_ring_element(rx
,
2094 lan743x_rx_allocate_ring_element(rx
,
2096 index
= lan743x_rx_next_index(rx
,
2100 while ((index
>= first_index
) ||
2101 (index
<= last_index
)) {
2102 lan743x_rx_release_ring_element(rx
,
2104 lan743x_rx_allocate_ring_element(rx
,
2106 index
= lan743x_rx_next_index(rx
,
2112 if (extension_index
>= 0) {
2113 descriptor
= &rx
->ring_cpu_ptr
[extension_index
];
2114 buffer_info
= &rx
->buffer_info
[extension_index
];
2116 ts_sec
= descriptor
->data1
;
2117 ts_nsec
= (descriptor
->data2
&
2118 RX_DESC_DATA2_TS_NS_MASK_
);
2119 lan743x_rx_reuse_ring_element(rx
, extension_index
);
2120 real_last_index
= extension_index
;
2124 result
= RX_PROCESS_RESULT_PACKET_DROPPED
;
2128 if (extension_index
< 0)
2129 goto pass_packet_to_os
;
2130 hwtstamps
= skb_hwtstamps(skb
);
2132 hwtstamps
->hwtstamp
= ktime_set(ts_sec
, ts_nsec
);
2135 /* pass packet to OS */
2136 napi_gro_receive(&rx
->napi
, skb
);
2137 result
= RX_PROCESS_RESULT_PACKET_RECEIVED
;
2140 /* push tail and head forward */
2141 rx
->last_tail
= real_last_index
;
2142 rx
->last_head
= lan743x_rx_next_index(rx
, real_last_index
);
2148 static int lan743x_rx_napi_poll(struct napi_struct
*napi
, int weight
)
2150 struct lan743x_rx
*rx
= container_of(napi
, struct lan743x_rx
, napi
);
2151 struct lan743x_adapter
*adapter
= rx
->adapter
;
2152 u32 rx_tail_flags
= 0;
2155 if (rx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C
) {
2156 /* clear int status bit before reading packet */
2157 lan743x_csr_write(adapter
, DMAC_INT_STS
,
2158 DMAC_INT_BIT_RXFRM_(rx
->channel_number
));
2161 while (count
< weight
) {
2162 int rx_process_result
= -1;
2164 rx_process_result
= lan743x_rx_process_packet(rx
);
2165 if (rx_process_result
== RX_PROCESS_RESULT_PACKET_RECEIVED
) {
2167 } else if (rx_process_result
==
2168 RX_PROCESS_RESULT_NOTHING_TO_DO
) {
2170 } else if (rx_process_result
==
2171 RX_PROCESS_RESULT_PACKET_DROPPED
) {
2175 rx
->frame_count
+= count
;
2176 if (count
== weight
)
2179 if (!napi_complete_done(napi
, count
))
2182 if (rx
->vector_flags
& LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET
)
2183 rx_tail_flags
|= RX_TAIL_SET_TOP_INT_VEC_EN_
;
2184 if (rx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET
) {
2185 rx_tail_flags
|= RX_TAIL_SET_TOP_INT_EN_
;
2187 lan743x_csr_write(adapter
, INT_EN_SET
,
2188 INT_BIT_DMA_RX_(rx
->channel_number
));
2191 /* update RX_TAIL */
2192 lan743x_csr_write(adapter
, RX_TAIL(rx
->channel_number
),
2193 rx_tail_flags
| rx
->last_tail
);
2198 static void lan743x_rx_ring_cleanup(struct lan743x_rx
*rx
)
2200 if (rx
->buffer_info
&& rx
->ring_cpu_ptr
) {
2203 for (index
= 0; index
< rx
->ring_size
; index
++)
2204 lan743x_rx_release_ring_element(rx
, index
);
2207 if (rx
->head_cpu_ptr
) {
2208 pci_free_consistent(rx
->adapter
->pdev
,
2209 sizeof(*rx
->head_cpu_ptr
),
2212 rx
->head_cpu_ptr
= NULL
;
2213 rx
->head_dma_ptr
= 0;
2216 kfree(rx
->buffer_info
);
2217 rx
->buffer_info
= NULL
;
2219 if (rx
->ring_cpu_ptr
) {
2220 pci_free_consistent(rx
->adapter
->pdev
,
2221 rx
->ring_allocation_size
,
2224 rx
->ring_allocation_size
= 0;
2225 rx
->ring_cpu_ptr
= NULL
;
2226 rx
->ring_dma_ptr
= 0;
2233 static int lan743x_rx_ring_init(struct lan743x_rx
*rx
)
2235 size_t ring_allocation_size
= 0;
2236 dma_addr_t dma_ptr
= 0;
2237 void *cpu_ptr
= NULL
;
2241 rx
->ring_size
= LAN743X_RX_RING_SIZE
;
2242 if (rx
->ring_size
<= 1) {
2246 if (rx
->ring_size
& ~RX_CFG_B_RX_RING_LEN_MASK_
) {
2250 ring_allocation_size
= ALIGN(rx
->ring_size
*
2251 sizeof(struct lan743x_rx_descriptor
),
2254 cpu_ptr
= pci_zalloc_consistent(rx
->adapter
->pdev
,
2255 ring_allocation_size
, &dma_ptr
);
2260 rx
->ring_allocation_size
= ring_allocation_size
;
2261 rx
->ring_cpu_ptr
= (struct lan743x_rx_descriptor
*)cpu_ptr
;
2262 rx
->ring_dma_ptr
= dma_ptr
;
2264 cpu_ptr
= kcalloc(rx
->ring_size
, sizeof(*rx
->buffer_info
),
2270 rx
->buffer_info
= (struct lan743x_rx_buffer_info
*)cpu_ptr
;
2272 cpu_ptr
= pci_zalloc_consistent(rx
->adapter
->pdev
,
2273 sizeof(*rx
->head_cpu_ptr
), &dma_ptr
);
2279 rx
->head_cpu_ptr
= cpu_ptr
;
2280 rx
->head_dma_ptr
= dma_ptr
;
2281 if (rx
->head_dma_ptr
& 0x3) {
2287 for (index
= 0; index
< rx
->ring_size
; index
++) {
2288 ret
= lan743x_rx_allocate_ring_element(rx
, index
);
2295 lan743x_rx_ring_cleanup(rx
);
2299 static void lan743x_rx_close(struct lan743x_rx
*rx
)
2301 struct lan743x_adapter
*adapter
= rx
->adapter
;
2303 lan743x_csr_write(adapter
, FCT_RX_CTL
,
2304 FCT_RX_CTL_DIS_(rx
->channel_number
));
2305 lan743x_csr_wait_for_bit(adapter
, FCT_RX_CTL
,
2306 FCT_RX_CTL_EN_(rx
->channel_number
),
2307 0, 1000, 20000, 100);
2309 lan743x_csr_write(adapter
, DMAC_CMD
,
2310 DMAC_CMD_STOP_R_(rx
->channel_number
));
2311 lan743x_dmac_rx_wait_till_stopped(adapter
, rx
->channel_number
);
2313 lan743x_csr_write(adapter
, DMAC_INT_EN_CLR
,
2314 DMAC_INT_BIT_RXFRM_(rx
->channel_number
));
2315 lan743x_csr_write(adapter
, INT_EN_CLR
,
2316 INT_BIT_DMA_RX_(rx
->channel_number
));
2317 napi_disable(&rx
->napi
);
2319 netif_napi_del(&rx
->napi
);
2321 lan743x_rx_ring_cleanup(rx
);
2324 static int lan743x_rx_open(struct lan743x_rx
*rx
)
2326 struct lan743x_adapter
*adapter
= rx
->adapter
;
2330 rx
->frame_count
= 0;
2331 ret
= lan743x_rx_ring_init(rx
);
2335 netif_napi_add(adapter
->netdev
,
2336 &rx
->napi
, lan743x_rx_napi_poll
,
2339 lan743x_csr_write(adapter
, DMAC_CMD
,
2340 DMAC_CMD_RX_SWR_(rx
->channel_number
));
2341 lan743x_csr_wait_for_bit(adapter
, DMAC_CMD
,
2342 DMAC_CMD_RX_SWR_(rx
->channel_number
),
2343 0, 1000, 20000, 100);
2345 /* set ring base address */
2346 lan743x_csr_write(adapter
,
2347 RX_BASE_ADDRH(rx
->channel_number
),
2348 DMA_ADDR_HIGH32(rx
->ring_dma_ptr
));
2349 lan743x_csr_write(adapter
,
2350 RX_BASE_ADDRL(rx
->channel_number
),
2351 DMA_ADDR_LOW32(rx
->ring_dma_ptr
));
2353 /* set rx write back address */
2354 lan743x_csr_write(adapter
,
2355 RX_HEAD_WRITEBACK_ADDRH(rx
->channel_number
),
2356 DMA_ADDR_HIGH32(rx
->head_dma_ptr
));
2357 lan743x_csr_write(adapter
,
2358 RX_HEAD_WRITEBACK_ADDRL(rx
->channel_number
),
2359 DMA_ADDR_LOW32(rx
->head_dma_ptr
));
2360 data
= RX_CFG_A_RX_HP_WB_EN_
;
2361 if (!(adapter
->csr
.flags
& LAN743X_CSR_FLAG_IS_A0
)) {
2362 data
|= (RX_CFG_A_RX_WB_ON_INT_TMR_
|
2363 RX_CFG_A_RX_WB_THRES_SET_(0x7) |
2364 RX_CFG_A_RX_PF_THRES_SET_(16) |
2365 RX_CFG_A_RX_PF_PRI_THRES_SET_(4));
2369 lan743x_csr_write(adapter
,
2370 RX_CFG_A(rx
->channel_number
), data
);
2373 data
= lan743x_csr_read(adapter
, RX_CFG_B(rx
->channel_number
));
2374 data
&= ~RX_CFG_B_RX_PAD_MASK_
;
2375 if (!RX_HEAD_PADDING
)
2376 data
|= RX_CFG_B_RX_PAD_0_
;
2378 data
|= RX_CFG_B_RX_PAD_2_
;
2379 data
&= ~RX_CFG_B_RX_RING_LEN_MASK_
;
2380 data
|= ((rx
->ring_size
) & RX_CFG_B_RX_RING_LEN_MASK_
);
2381 data
|= RX_CFG_B_TS_ALL_RX_
;
2382 if (!(adapter
->csr
.flags
& LAN743X_CSR_FLAG_IS_A0
))
2383 data
|= RX_CFG_B_RDMABL_512_
;
2385 lan743x_csr_write(adapter
, RX_CFG_B(rx
->channel_number
), data
);
2386 rx
->vector_flags
= lan743x_intr_get_vector_flags(adapter
,
2388 (rx
->channel_number
));
2392 if (rx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR
)
2393 data
|= RX_CFG_C_RX_TOP_INT_EN_AUTO_CLR_
;
2394 if (rx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR
)
2395 data
|= RX_CFG_C_RX_DMA_INT_STS_AUTO_CLR_
;
2396 if (rx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C
)
2397 data
|= RX_CFG_C_RX_INT_STS_R2C_MODE_MASK_
;
2398 if (rx
->vector_flags
& LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C
)
2399 data
|= RX_CFG_C_RX_INT_EN_R2C_
;
2400 lan743x_csr_write(adapter
, RX_CFG_C(rx
->channel_number
), data
);
2402 rx
->last_tail
= ((u32
)(rx
->ring_size
- 1));
2403 lan743x_csr_write(adapter
, RX_TAIL(rx
->channel_number
),
2405 rx
->last_head
= lan743x_csr_read(adapter
, RX_HEAD(rx
->channel_number
));
2406 if (rx
->last_head
) {
2411 napi_enable(&rx
->napi
);
2413 lan743x_csr_write(adapter
, INT_EN_SET
,
2414 INT_BIT_DMA_RX_(rx
->channel_number
));
2415 lan743x_csr_write(adapter
, DMAC_INT_STS
,
2416 DMAC_INT_BIT_RXFRM_(rx
->channel_number
));
2417 lan743x_csr_write(adapter
, DMAC_INT_EN_SET
,
2418 DMAC_INT_BIT_RXFRM_(rx
->channel_number
));
2419 lan743x_csr_write(adapter
, DMAC_CMD
,
2420 DMAC_CMD_START_R_(rx
->channel_number
));
2422 /* initialize fifo */
2423 lan743x_csr_write(adapter
, FCT_RX_CTL
,
2424 FCT_RX_CTL_RESET_(rx
->channel_number
));
2425 lan743x_csr_wait_for_bit(adapter
, FCT_RX_CTL
,
2426 FCT_RX_CTL_RESET_(rx
->channel_number
),
2427 0, 1000, 20000, 100);
2428 lan743x_csr_write(adapter
, FCT_FLOW(rx
->channel_number
),
2429 FCT_FLOW_CTL_REQ_EN_
|
2430 FCT_FLOW_CTL_ON_THRESHOLD_SET_(0x2A) |
2431 FCT_FLOW_CTL_OFF_THRESHOLD_SET_(0xA));
2434 lan743x_csr_write(adapter
, FCT_RX_CTL
,
2435 FCT_RX_CTL_EN_(rx
->channel_number
));
2439 netif_napi_del(&rx
->napi
);
2440 lan743x_rx_ring_cleanup(rx
);
2446 static int lan743x_netdev_close(struct net_device
*netdev
)
2448 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2451 lan743x_tx_close(&adapter
->tx
[0]);
2453 for (index
= 0; index
< LAN743X_USED_RX_CHANNELS
; index
++)
2454 lan743x_rx_close(&adapter
->rx
[index
]);
2456 lan743x_ptp_close(adapter
);
2458 lan743x_phy_close(adapter
);
2460 lan743x_mac_close(adapter
);
2462 lan743x_intr_close(adapter
);
2467 static int lan743x_netdev_open(struct net_device
*netdev
)
2469 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2473 ret
= lan743x_intr_open(adapter
);
2477 ret
= lan743x_mac_open(adapter
);
2481 ret
= lan743x_phy_open(adapter
);
2485 ret
= lan743x_ptp_open(adapter
);
2489 lan743x_rfe_open(adapter
);
2491 for (index
= 0; index
< LAN743X_USED_RX_CHANNELS
; index
++) {
2492 ret
= lan743x_rx_open(&adapter
->rx
[index
]);
2497 ret
= lan743x_tx_open(&adapter
->tx
[0]);
2504 for (index
= 0; index
< LAN743X_USED_RX_CHANNELS
; index
++) {
2505 if (adapter
->rx
[index
].ring_cpu_ptr
)
2506 lan743x_rx_close(&adapter
->rx
[index
]);
2508 lan743x_ptp_close(adapter
);
2511 lan743x_phy_close(adapter
);
2514 lan743x_mac_close(adapter
);
2517 lan743x_intr_close(adapter
);
2520 netif_warn(adapter
, ifup
, adapter
->netdev
,
2521 "Error opening LAN743x\n");
2525 static netdev_tx_t
lan743x_netdev_xmit_frame(struct sk_buff
*skb
,
2526 struct net_device
*netdev
)
2528 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2530 return lan743x_tx_xmit_frame(&adapter
->tx
[0], skb
);
2533 static int lan743x_netdev_ioctl(struct net_device
*netdev
,
2534 struct ifreq
*ifr
, int cmd
)
2536 if (!netif_running(netdev
))
2538 if (cmd
== SIOCSHWTSTAMP
)
2539 return lan743x_ptp_ioctl(netdev
, ifr
, cmd
);
2540 return phy_mii_ioctl(netdev
->phydev
, ifr
, cmd
);
2543 static void lan743x_netdev_set_multicast(struct net_device
*netdev
)
2545 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2547 lan743x_rfe_set_multicast(adapter
);
2550 static int lan743x_netdev_change_mtu(struct net_device
*netdev
, int new_mtu
)
2552 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2555 ret
= lan743x_mac_set_mtu(adapter
, new_mtu
);
2557 netdev
->mtu
= new_mtu
;
2561 static void lan743x_netdev_get_stats64(struct net_device
*netdev
,
2562 struct rtnl_link_stats64
*stats
)
2564 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2566 stats
->rx_packets
= lan743x_csr_read(adapter
, STAT_RX_TOTAL_FRAMES
);
2567 stats
->tx_packets
= lan743x_csr_read(adapter
, STAT_TX_TOTAL_FRAMES
);
2568 stats
->rx_bytes
= lan743x_csr_read(adapter
,
2569 STAT_RX_UNICAST_BYTE_COUNT
) +
2570 lan743x_csr_read(adapter
,
2571 STAT_RX_BROADCAST_BYTE_COUNT
) +
2572 lan743x_csr_read(adapter
,
2573 STAT_RX_MULTICAST_BYTE_COUNT
);
2574 stats
->tx_bytes
= lan743x_csr_read(adapter
,
2575 STAT_TX_UNICAST_BYTE_COUNT
) +
2576 lan743x_csr_read(adapter
,
2577 STAT_TX_BROADCAST_BYTE_COUNT
) +
2578 lan743x_csr_read(adapter
,
2579 STAT_TX_MULTICAST_BYTE_COUNT
);
2580 stats
->rx_errors
= lan743x_csr_read(adapter
, STAT_RX_FCS_ERRORS
) +
2581 lan743x_csr_read(adapter
,
2582 STAT_RX_ALIGNMENT_ERRORS
) +
2583 lan743x_csr_read(adapter
, STAT_RX_JABBER_ERRORS
) +
2584 lan743x_csr_read(adapter
,
2585 STAT_RX_UNDERSIZE_FRAME_ERRORS
) +
2586 lan743x_csr_read(adapter
,
2587 STAT_RX_OVERSIZE_FRAME_ERRORS
);
2588 stats
->tx_errors
= lan743x_csr_read(adapter
, STAT_TX_FCS_ERRORS
) +
2589 lan743x_csr_read(adapter
,
2590 STAT_TX_EXCESS_DEFERRAL_ERRORS
) +
2591 lan743x_csr_read(adapter
, STAT_TX_CARRIER_ERRORS
);
2592 stats
->rx_dropped
= lan743x_csr_read(adapter
,
2593 STAT_RX_DROPPED_FRAMES
);
2594 stats
->tx_dropped
= lan743x_csr_read(adapter
,
2595 STAT_TX_EXCESSIVE_COLLISION
);
2596 stats
->multicast
= lan743x_csr_read(adapter
,
2597 STAT_RX_MULTICAST_FRAMES
) +
2598 lan743x_csr_read(adapter
,
2599 STAT_TX_MULTICAST_FRAMES
);
2600 stats
->collisions
= lan743x_csr_read(adapter
,
2601 STAT_TX_SINGLE_COLLISIONS
) +
2602 lan743x_csr_read(adapter
,
2603 STAT_TX_MULTIPLE_COLLISIONS
) +
2604 lan743x_csr_read(adapter
,
2605 STAT_TX_LATE_COLLISIONS
);
2608 static int lan743x_netdev_set_mac_address(struct net_device
*netdev
,
2611 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2612 struct sockaddr
*sock_addr
= addr
;
2615 ret
= eth_prepare_mac_addr_change(netdev
, sock_addr
);
2618 ether_addr_copy(netdev
->dev_addr
, sock_addr
->sa_data
);
2619 lan743x_mac_set_address(adapter
, sock_addr
->sa_data
);
2620 lan743x_rfe_update_mac_address(adapter
);
2624 static const struct net_device_ops lan743x_netdev_ops
= {
2625 .ndo_open
= lan743x_netdev_open
,
2626 .ndo_stop
= lan743x_netdev_close
,
2627 .ndo_start_xmit
= lan743x_netdev_xmit_frame
,
2628 .ndo_do_ioctl
= lan743x_netdev_ioctl
,
2629 .ndo_set_rx_mode
= lan743x_netdev_set_multicast
,
2630 .ndo_change_mtu
= lan743x_netdev_change_mtu
,
2631 .ndo_get_stats64
= lan743x_netdev_get_stats64
,
2632 .ndo_set_mac_address
= lan743x_netdev_set_mac_address
,
2635 static void lan743x_hardware_cleanup(struct lan743x_adapter
*adapter
)
2637 lan743x_csr_write(adapter
, INT_EN_CLR
, 0xFFFFFFFF);
2640 static void lan743x_mdiobus_cleanup(struct lan743x_adapter
*adapter
)
2642 mdiobus_unregister(adapter
->mdiobus
);
2645 static void lan743x_full_cleanup(struct lan743x_adapter
*adapter
)
2647 unregister_netdev(adapter
->netdev
);
2649 lan743x_mdiobus_cleanup(adapter
);
2650 lan743x_hardware_cleanup(adapter
);
2651 lan743x_pci_cleanup(adapter
);
2654 static int lan743x_hardware_init(struct lan743x_adapter
*adapter
,
2655 struct pci_dev
*pdev
)
2657 struct lan743x_tx
*tx
;
2661 adapter
->intr
.irq
= adapter
->pdev
->irq
;
2662 lan743x_csr_write(adapter
, INT_EN_CLR
, 0xFFFFFFFF);
2663 mutex_init(&adapter
->dp_lock
);
2665 ret
= lan743x_gpio_init(adapter
);
2669 ret
= lan743x_mac_init(adapter
);
2673 ret
= lan743x_phy_init(adapter
);
2677 ret
= lan743x_ptp_init(adapter
);
2681 lan743x_rfe_update_mac_address(adapter
);
2683 ret
= lan743x_dmac_init(adapter
);
2687 for (index
= 0; index
< LAN743X_USED_RX_CHANNELS
; index
++) {
2688 adapter
->rx
[index
].adapter
= adapter
;
2689 adapter
->rx
[index
].channel_number
= index
;
2692 tx
= &adapter
->tx
[0];
2693 tx
->adapter
= adapter
;
2694 tx
->channel_number
= 0;
2695 spin_lock_init(&tx
->ring_lock
);
2699 static int lan743x_mdiobus_init(struct lan743x_adapter
*adapter
)
2703 adapter
->mdiobus
= devm_mdiobus_alloc(&adapter
->pdev
->dev
);
2704 if (!(adapter
->mdiobus
)) {
2709 adapter
->mdiobus
->priv
= (void *)adapter
;
2710 adapter
->mdiobus
->read
= lan743x_mdiobus_read
;
2711 adapter
->mdiobus
->write
= lan743x_mdiobus_write
;
2712 adapter
->mdiobus
->name
= "lan743x-mdiobus";
2713 snprintf(adapter
->mdiobus
->id
, MII_BUS_ID_SIZE
,
2714 "pci-%s", pci_name(adapter
->pdev
));
2716 if ((adapter
->csr
.id_rev
& ID_REV_ID_MASK_
) == ID_REV_ID_LAN7430_
)
2717 /* LAN7430 uses internal phy at address 1 */
2718 adapter
->mdiobus
->phy_mask
= ~(u32
)BIT(1);
2720 /* register mdiobus */
2721 ret
= mdiobus_register(adapter
->mdiobus
);
2730 /* lan743x_pcidev_probe - Device Initialization Routine
2731 * @pdev: PCI device information struct
2732 * @id: entry in lan743x_pci_tbl
2734 * Returns 0 on success, negative on failure
2736 * initializes an adapter identified by a pci_dev structure.
2737 * The OS initialization, configuring of the adapter private structure,
2738 * and a hardware reset occur.
2740 static int lan743x_pcidev_probe(struct pci_dev
*pdev
,
2741 const struct pci_device_id
*id
)
2743 struct lan743x_adapter
*adapter
= NULL
;
2744 struct net_device
*netdev
= NULL
;
2747 netdev
= devm_alloc_etherdev(&pdev
->dev
,
2748 sizeof(struct lan743x_adapter
));
2752 SET_NETDEV_DEV(netdev
, &pdev
->dev
);
2753 pci_set_drvdata(pdev
, netdev
);
2754 adapter
= netdev_priv(netdev
);
2755 adapter
->netdev
= netdev
;
2756 adapter
->msg_enable
= NETIF_MSG_DRV
| NETIF_MSG_PROBE
|
2757 NETIF_MSG_LINK
| NETIF_MSG_IFUP
|
2758 NETIF_MSG_IFDOWN
| NETIF_MSG_TX_QUEUED
;
2759 netdev
->max_mtu
= LAN743X_MAX_FRAME_SIZE
;
2761 ret
= lan743x_pci_init(adapter
, pdev
);
2765 ret
= lan743x_csr_init(adapter
);
2769 ret
= lan743x_hardware_init(adapter
, pdev
);
2773 ret
= lan743x_mdiobus_init(adapter
);
2775 goto cleanup_hardware
;
2777 adapter
->netdev
->netdev_ops
= &lan743x_netdev_ops
;
2778 adapter
->netdev
->ethtool_ops
= &lan743x_ethtool_ops
;
2779 adapter
->netdev
->features
= NETIF_F_SG
| NETIF_F_TSO
| NETIF_F_HW_CSUM
;
2780 adapter
->netdev
->hw_features
= adapter
->netdev
->features
;
2782 /* carrier off reporting is important to ethtool even BEFORE open */
2783 netif_carrier_off(netdev
);
2785 ret
= register_netdev(adapter
->netdev
);
2787 goto cleanup_mdiobus
;
2791 lan743x_mdiobus_cleanup(adapter
);
2794 lan743x_hardware_cleanup(adapter
);
2797 lan743x_pci_cleanup(adapter
);
2800 pr_warn("Initialization failed\n");
2805 * lan743x_pcidev_remove - Device Removal Routine
2806 * @pdev: PCI device information struct
2808 * this is called by the PCI subsystem to alert the driver
2809 * that it should release a PCI device. This could be caused by a
2810 * Hot-Plug event, or because the driver is going to be removed from
2813 static void lan743x_pcidev_remove(struct pci_dev
*pdev
)
2815 struct net_device
*netdev
= pci_get_drvdata(pdev
);
2816 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2818 lan743x_full_cleanup(adapter
);
2821 static void lan743x_pcidev_shutdown(struct pci_dev
*pdev
)
2823 struct net_device
*netdev
= pci_get_drvdata(pdev
);
2824 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2827 netif_device_detach(netdev
);
2829 /* close netdev when netdev is at running state.
2830 * For instance, it is true when system goes to sleep by pm-suspend
2831 * However, it is false when system goes to sleep by suspend GUI menu
2833 if (netif_running(netdev
))
2834 lan743x_netdev_close(netdev
);
2838 pci_save_state(pdev
);
2841 /* clean up lan743x portion */
2842 lan743x_hardware_cleanup(adapter
);
2845 #ifdef CONFIG_PM_SLEEP
2846 static u16
lan743x_pm_wakeframe_crc16(const u8
*buf
, int len
)
2848 return bitrev16(crc16(0xFFFF, buf
, len
));
2851 static void lan743x_pm_set_wol(struct lan743x_adapter
*adapter
)
2853 const u8 ipv4_multicast
[3] = { 0x01, 0x00, 0x5E };
2854 const u8 ipv6_multicast
[3] = { 0x33, 0x33 };
2855 const u8 arp_type
[2] = { 0x08, 0x06 };
2862 for (mask_index
= 0; mask_index
< MAC_NUM_OF_WUF_CFG
; mask_index
++)
2863 lan743x_csr_write(adapter
, MAC_WUF_CFG(mask_index
), 0);
2865 /* clear wake settings */
2866 pmtctl
= lan743x_csr_read(adapter
, PMT_CTL
);
2867 pmtctl
|= PMT_CTL_WUPS_MASK_
;
2868 pmtctl
&= ~(PMT_CTL_GPIO_WAKEUP_EN_
| PMT_CTL_EEE_WAKEUP_EN_
|
2869 PMT_CTL_WOL_EN_
| PMT_CTL_MAC_D3_RX_CLK_OVR_
|
2870 PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_
| PMT_CTL_ETH_PHY_WAKE_EN_
);
2872 macrx
= lan743x_csr_read(adapter
, MAC_RX
);
2877 pmtctl
|= PMT_CTL_ETH_PHY_D3_COLD_OVR_
| PMT_CTL_ETH_PHY_D3_OVR_
;
2879 if (adapter
->wolopts
& WAKE_PHY
) {
2880 pmtctl
|= PMT_CTL_ETH_PHY_EDPD_PLL_CTL_
;
2881 pmtctl
|= PMT_CTL_ETH_PHY_WAKE_EN_
;
2883 if (adapter
->wolopts
& WAKE_MAGIC
) {
2884 wucsr
|= MAC_WUCSR_MPEN_
;
2885 macrx
|= MAC_RX_RXEN_
;
2886 pmtctl
|= PMT_CTL_WOL_EN_
| PMT_CTL_MAC_D3_RX_CLK_OVR_
;
2888 if (adapter
->wolopts
& WAKE_UCAST
) {
2889 wucsr
|= MAC_WUCSR_RFE_WAKE_EN_
| MAC_WUCSR_PFDA_EN_
;
2890 macrx
|= MAC_RX_RXEN_
;
2891 pmtctl
|= PMT_CTL_WOL_EN_
| PMT_CTL_MAC_D3_RX_CLK_OVR_
;
2892 pmtctl
|= PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_
;
2894 if (adapter
->wolopts
& WAKE_BCAST
) {
2895 wucsr
|= MAC_WUCSR_RFE_WAKE_EN_
| MAC_WUCSR_BCST_EN_
;
2896 macrx
|= MAC_RX_RXEN_
;
2897 pmtctl
|= PMT_CTL_WOL_EN_
| PMT_CTL_MAC_D3_RX_CLK_OVR_
;
2898 pmtctl
|= PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_
;
2900 if (adapter
->wolopts
& WAKE_MCAST
) {
2901 /* IPv4 multicast */
2902 crc
= lan743x_pm_wakeframe_crc16(ipv4_multicast
, 3);
2903 lan743x_csr_write(adapter
, MAC_WUF_CFG(mask_index
),
2904 MAC_WUF_CFG_EN_
| MAC_WUF_CFG_TYPE_MCAST_
|
2905 (0 << MAC_WUF_CFG_OFFSET_SHIFT_
) |
2906 (crc
& MAC_WUF_CFG_CRC16_MASK_
));
2907 lan743x_csr_write(adapter
, MAC_WUF_MASK0(mask_index
), 7);
2908 lan743x_csr_write(adapter
, MAC_WUF_MASK1(mask_index
), 0);
2909 lan743x_csr_write(adapter
, MAC_WUF_MASK2(mask_index
), 0);
2910 lan743x_csr_write(adapter
, MAC_WUF_MASK3(mask_index
), 0);
2913 /* IPv6 multicast */
2914 crc
= lan743x_pm_wakeframe_crc16(ipv6_multicast
, 2);
2915 lan743x_csr_write(adapter
, MAC_WUF_CFG(mask_index
),
2916 MAC_WUF_CFG_EN_
| MAC_WUF_CFG_TYPE_MCAST_
|
2917 (0 << MAC_WUF_CFG_OFFSET_SHIFT_
) |
2918 (crc
& MAC_WUF_CFG_CRC16_MASK_
));
2919 lan743x_csr_write(adapter
, MAC_WUF_MASK0(mask_index
), 3);
2920 lan743x_csr_write(adapter
, MAC_WUF_MASK1(mask_index
), 0);
2921 lan743x_csr_write(adapter
, MAC_WUF_MASK2(mask_index
), 0);
2922 lan743x_csr_write(adapter
, MAC_WUF_MASK3(mask_index
), 0);
2925 wucsr
|= MAC_WUCSR_RFE_WAKE_EN_
| MAC_WUCSR_WAKE_EN_
;
2926 macrx
|= MAC_RX_RXEN_
;
2927 pmtctl
|= PMT_CTL_WOL_EN_
| PMT_CTL_MAC_D3_RX_CLK_OVR_
;
2928 pmtctl
|= PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_
;
2930 if (adapter
->wolopts
& WAKE_ARP
) {
2931 /* set MAC_WUF_CFG & WUF_MASK
2932 * for packettype (offset 12,13) = ARP (0x0806)
2934 crc
= lan743x_pm_wakeframe_crc16(arp_type
, 2);
2935 lan743x_csr_write(adapter
, MAC_WUF_CFG(mask_index
),
2936 MAC_WUF_CFG_EN_
| MAC_WUF_CFG_TYPE_ALL_
|
2937 (0 << MAC_WUF_CFG_OFFSET_SHIFT_
) |
2938 (crc
& MAC_WUF_CFG_CRC16_MASK_
));
2939 lan743x_csr_write(adapter
, MAC_WUF_MASK0(mask_index
), 0x3000);
2940 lan743x_csr_write(adapter
, MAC_WUF_MASK1(mask_index
), 0);
2941 lan743x_csr_write(adapter
, MAC_WUF_MASK2(mask_index
), 0);
2942 lan743x_csr_write(adapter
, MAC_WUF_MASK3(mask_index
), 0);
2945 wucsr
|= MAC_WUCSR_RFE_WAKE_EN_
| MAC_WUCSR_WAKE_EN_
;
2946 macrx
|= MAC_RX_RXEN_
;
2947 pmtctl
|= PMT_CTL_WOL_EN_
| PMT_CTL_MAC_D3_RX_CLK_OVR_
;
2948 pmtctl
|= PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_
;
2951 lan743x_csr_write(adapter
, MAC_WUCSR
, wucsr
);
2952 lan743x_csr_write(adapter
, PMT_CTL
, pmtctl
);
2953 lan743x_csr_write(adapter
, MAC_RX
, macrx
);
2956 static int lan743x_pm_suspend(struct device
*dev
)
2958 struct pci_dev
*pdev
= to_pci_dev(dev
);
2959 struct net_device
*netdev
= pci_get_drvdata(pdev
);
2960 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2963 lan743x_pcidev_shutdown(pdev
);
2965 /* clear all wakes */
2966 lan743x_csr_write(adapter
, MAC_WUCSR
, 0);
2967 lan743x_csr_write(adapter
, MAC_WUCSR2
, 0);
2968 lan743x_csr_write(adapter
, MAC_WK_SRC
, 0xFFFFFFFF);
2970 if (adapter
->wolopts
)
2971 lan743x_pm_set_wol(adapter
);
2973 /* Host sets PME_En, put D3hot */
2974 ret
= pci_prepare_to_sleep(pdev
);
2979 static int lan743x_pm_resume(struct device
*dev
)
2981 struct pci_dev
*pdev
= to_pci_dev(dev
);
2982 struct net_device
*netdev
= pci_get_drvdata(pdev
);
2983 struct lan743x_adapter
*adapter
= netdev_priv(netdev
);
2986 pci_set_power_state(pdev
, PCI_D0
);
2987 pci_restore_state(pdev
);
2988 pci_save_state(pdev
);
2990 ret
= lan743x_hardware_init(adapter
, pdev
);
2992 netif_err(adapter
, probe
, adapter
->netdev
,
2993 "lan743x_hardware_init returned %d\n", ret
);
2996 /* open netdev when netdev is at running state while resume.
2997 * For instance, it is true when system wakesup after pm-suspend
2998 * However, it is false when system wakes up after suspend GUI menu
3000 if (netif_running(netdev
))
3001 lan743x_netdev_open(netdev
);
3003 netif_device_attach(netdev
);
3008 static const struct dev_pm_ops lan743x_pm_ops
= {
3009 SET_SYSTEM_SLEEP_PM_OPS(lan743x_pm_suspend
, lan743x_pm_resume
)
3011 #endif /* CONFIG_PM_SLEEP */
3013 static const struct pci_device_id lan743x_pcidev_tbl
[] = {
3014 { PCI_DEVICE(PCI_VENDOR_ID_SMSC
, PCI_DEVICE_ID_SMSC_LAN7430
) },
3015 { PCI_DEVICE(PCI_VENDOR_ID_SMSC
, PCI_DEVICE_ID_SMSC_LAN7431
) },
3019 static struct pci_driver lan743x_pcidev_driver
= {
3020 .name
= DRIVER_NAME
,
3021 .id_table
= lan743x_pcidev_tbl
,
3022 .probe
= lan743x_pcidev_probe
,
3023 .remove
= lan743x_pcidev_remove
,
3024 #ifdef CONFIG_PM_SLEEP
3025 .driver
.pm
= &lan743x_pm_ops
,
3027 .shutdown
= lan743x_pcidev_shutdown
,
3030 module_pci_driver(lan743x_pcidev_driver
);
3032 MODULE_AUTHOR(DRIVER_AUTHOR
);
3033 MODULE_DESCRIPTION(DRIVER_DESC
);
3034 MODULE_LICENSE("GPL");