1 /* SPDX-License-Identifier: GPL-2.0+ */
2 /* Copyright (C) 2018 Microchip Technology Inc. */
3
4 #include <linux/module.h>
5 #include <linux/pci.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/of_mdio.h>
12 #include <linux/of_net.h>
13 #include <linux/phy.h>
14 #include <linux/phy_fixed.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/iopoll.h>
17 #include <linux/crc16.h>
18 #include "lan743x_main.h"
19 #include "lan743x_ethtool.h"
20
lan743x_pci_cleanup(struct lan743x_adapter * adapter)21 static void lan743x_pci_cleanup(struct lan743x_adapter *adapter)
22 {
23 pci_release_selected_regions(adapter->pdev,
24 pci_select_bars(adapter->pdev,
25 IORESOURCE_MEM));
26 pci_disable_device(adapter->pdev);
27 }
28
lan743x_pci_init(struct lan743x_adapter * adapter,struct pci_dev * pdev)29 static int lan743x_pci_init(struct lan743x_adapter *adapter,
30 struct pci_dev *pdev)
31 {
32 unsigned long bars = 0;
33 int ret;
34
35 adapter->pdev = pdev;
36 ret = pci_enable_device_mem(pdev);
37 if (ret)
38 goto return_error;
39
40 netif_info(adapter, probe, adapter->netdev,
41 "PCI: Vendor ID = 0x%04X, Device ID = 0x%04X\n",
42 pdev->vendor, pdev->device);
43 bars = pci_select_bars(pdev, IORESOURCE_MEM);
44 if (!test_bit(0, &bars))
45 goto disable_device;
46
47 ret = pci_request_selected_regions(pdev, bars, DRIVER_NAME);
48 if (ret)
49 goto disable_device;
50
51 pci_set_master(pdev);
52 return 0;
53
54 disable_device:
55 pci_disable_device(adapter->pdev);
56
57 return_error:
58 return ret;
59 }
60
lan743x_csr_read(struct lan743x_adapter * adapter,int offset)61 u32 lan743x_csr_read(struct lan743x_adapter *adapter, int offset)
62 {
63 return ioread32(&adapter->csr.csr_address[offset]);
64 }
65
lan743x_csr_write(struct lan743x_adapter * adapter,int offset,u32 data)66 void lan743x_csr_write(struct lan743x_adapter *adapter, int offset,
67 u32 data)
68 {
69 iowrite32(data, &adapter->csr.csr_address[offset]);
70 }
71
72 #define LAN743X_CSR_READ_OP(offset) lan743x_csr_read(adapter, offset)
73
lan743x_csr_light_reset(struct lan743x_adapter * adapter)74 static int lan743x_csr_light_reset(struct lan743x_adapter *adapter)
75 {
76 u32 data;
77
78 data = lan743x_csr_read(adapter, HW_CFG);
79 data |= HW_CFG_LRST_;
80 lan743x_csr_write(adapter, HW_CFG, data);
81
82 return readx_poll_timeout(LAN743X_CSR_READ_OP, HW_CFG, data,
83 !(data & HW_CFG_LRST_), 100000, 10000000);
84 }
85
lan743x_csr_wait_for_bit_atomic(struct lan743x_adapter * adapter,int offset,u32 bit_mask,int target_value,int udelay_min,int udelay_max,int count)86 static int lan743x_csr_wait_for_bit_atomic(struct lan743x_adapter *adapter,
87 int offset, u32 bit_mask,
88 int target_value, int udelay_min,
89 int udelay_max, int count)
90 {
91 u32 data;
92
93 return readx_poll_timeout_atomic(LAN743X_CSR_READ_OP, offset, data,
94 target_value == !!(data & bit_mask),
95 udelay_max, udelay_min * count);
96 }
97
lan743x_csr_wait_for_bit(struct lan743x_adapter * adapter,int offset,u32 bit_mask,int target_value,int usleep_min,int usleep_max,int count)98 static int lan743x_csr_wait_for_bit(struct lan743x_adapter *adapter,
99 int offset, u32 bit_mask,
100 int target_value, int usleep_min,
101 int usleep_max, int count)
102 {
103 u32 data;
104
105 return readx_poll_timeout(LAN743X_CSR_READ_OP, offset, data,
106 target_value == ((data & bit_mask) ? 1 : 0),
107 usleep_max, usleep_min * count);
108 }
109
lan743x_csr_init(struct lan743x_adapter * adapter)110 static int lan743x_csr_init(struct lan743x_adapter *adapter)
111 {
112 struct lan743x_csr *csr = &adapter->csr;
113 resource_size_t bar_start, bar_length;
114 int result;
115
116 bar_start = pci_resource_start(adapter->pdev, 0);
117 bar_length = pci_resource_len(adapter->pdev, 0);
118 csr->csr_address = devm_ioremap(&adapter->pdev->dev,
119 bar_start, bar_length);
120 if (!csr->csr_address) {
121 result = -ENOMEM;
122 goto clean_up;
123 }
124
125 csr->id_rev = lan743x_csr_read(adapter, ID_REV);
126 csr->fpga_rev = lan743x_csr_read(adapter, FPGA_REV);
127 netif_info(adapter, probe, adapter->netdev,
128 "ID_REV = 0x%08X, FPGA_REV = %d.%d\n",
129 csr->id_rev, FPGA_REV_GET_MAJOR_(csr->fpga_rev),
130 FPGA_REV_GET_MINOR_(csr->fpga_rev));
131 if (!ID_REV_IS_VALID_CHIP_ID_(csr->id_rev)) {
132 result = -ENODEV;
133 goto clean_up;
134 }
135
136 csr->flags = LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR;
137 switch (csr->id_rev & ID_REV_CHIP_REV_MASK_) {
138 case ID_REV_CHIP_REV_A0_:
139 csr->flags |= LAN743X_CSR_FLAG_IS_A0;
140 csr->flags &= ~LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR;
141 break;
142 case ID_REV_CHIP_REV_B0_:
143 csr->flags |= LAN743X_CSR_FLAG_IS_B0;
144 break;
145 }
146
147 result = lan743x_csr_light_reset(adapter);
148 if (result)
149 goto clean_up;
150 return 0;
151 clean_up:
152 return result;
153 }
154
lan743x_intr_software_isr(struct lan743x_adapter * adapter)155 static void lan743x_intr_software_isr(struct lan743x_adapter *adapter)
156 {
157 struct lan743x_intr *intr = &adapter->intr;
158
159 /* disable the interrupt to prevent repeated re-triggering */
160 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_SW_GP_);
161 intr->software_isr_flag = true;
162 wake_up(&intr->software_isr_wq);
163 }
164
lan743x_tx_isr(void * context,u32 int_sts,u32 flags)165 static void lan743x_tx_isr(void *context, u32 int_sts, u32 flags)
166 {
167 struct lan743x_tx *tx = context;
168 struct lan743x_adapter *adapter = tx->adapter;
169 bool enable_flag = true;
170
171 lan743x_csr_read(adapter, INT_EN_SET);
172 if (flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR) {
173 lan743x_csr_write(adapter, INT_EN_CLR,
174 INT_BIT_DMA_TX_(tx->channel_number));
175 }
176
177 if (int_sts & INT_BIT_DMA_TX_(tx->channel_number)) {
178 u32 ioc_bit = DMAC_INT_BIT_TX_IOC_(tx->channel_number);
179 u32 dmac_int_sts;
180 u32 dmac_int_en;
181
182 if (flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ)
183 dmac_int_sts = lan743x_csr_read(adapter, DMAC_INT_STS);
184 else
185 dmac_int_sts = ioc_bit;
186 if (flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK)
187 dmac_int_en = lan743x_csr_read(adapter,
188 DMAC_INT_EN_SET);
189 else
190 dmac_int_en = ioc_bit;
191
192 dmac_int_en &= ioc_bit;
193 dmac_int_sts &= dmac_int_en;
194 if (dmac_int_sts & ioc_bit) {
195 napi_schedule(&tx->napi);
196 enable_flag = false;/* poll func will enable later */
197 }
198 }
199
200 if (enable_flag)
201 /* enable isr */
202 lan743x_csr_write(adapter, INT_EN_SET,
203 INT_BIT_DMA_TX_(tx->channel_number));
204 }
205
lan743x_rx_isr(void * context,u32 int_sts,u32 flags)206 static void lan743x_rx_isr(void *context, u32 int_sts, u32 flags)
207 {
208 struct lan743x_rx *rx = context;
209 struct lan743x_adapter *adapter = rx->adapter;
210 bool enable_flag = true;
211
212 if (flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR) {
213 lan743x_csr_write(adapter, INT_EN_CLR,
214 INT_BIT_DMA_RX_(rx->channel_number));
215 }
216
217 if (int_sts & INT_BIT_DMA_RX_(rx->channel_number)) {
218 u32 rx_frame_bit = DMAC_INT_BIT_RXFRM_(rx->channel_number);
219 u32 dmac_int_sts;
220 u32 dmac_int_en;
221
222 if (flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ)
223 dmac_int_sts = lan743x_csr_read(adapter, DMAC_INT_STS);
224 else
225 dmac_int_sts = rx_frame_bit;
226 if (flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK)
227 dmac_int_en = lan743x_csr_read(adapter,
228 DMAC_INT_EN_SET);
229 else
230 dmac_int_en = rx_frame_bit;
231
232 dmac_int_en &= rx_frame_bit;
233 dmac_int_sts &= dmac_int_en;
234 if (dmac_int_sts & rx_frame_bit) {
235 napi_schedule(&rx->napi);
236 enable_flag = false;/* poll funct will enable later */
237 }
238 }
239
240 if (enable_flag) {
241 /* enable isr */
242 lan743x_csr_write(adapter, INT_EN_SET,
243 INT_BIT_DMA_RX_(rx->channel_number));
244 }
245 }
246
lan743x_intr_shared_isr(void * context,u32 int_sts,u32 flags)247 static void lan743x_intr_shared_isr(void *context, u32 int_sts, u32 flags)
248 {
249 struct lan743x_adapter *adapter = context;
250 unsigned int channel;
251
252 if (int_sts & INT_BIT_ALL_RX_) {
253 for (channel = 0; channel < LAN743X_USED_RX_CHANNELS;
254 channel++) {
255 u32 int_bit = INT_BIT_DMA_RX_(channel);
256
257 if (int_sts & int_bit) {
258 lan743x_rx_isr(&adapter->rx[channel],
259 int_bit, flags);
260 int_sts &= ~int_bit;
261 }
262 }
263 }
264 if (int_sts & INT_BIT_ALL_TX_) {
265 for (channel = 0; channel < LAN743X_USED_TX_CHANNELS;
266 channel++) {
267 u32 int_bit = INT_BIT_DMA_TX_(channel);
268
269 if (int_sts & int_bit) {
270 lan743x_tx_isr(&adapter->tx[channel],
271 int_bit, flags);
272 int_sts &= ~int_bit;
273 }
274 }
275 }
276 if (int_sts & INT_BIT_ALL_OTHER_) {
277 if (int_sts & INT_BIT_SW_GP_) {
278 lan743x_intr_software_isr(adapter);
279 int_sts &= ~INT_BIT_SW_GP_;
280 }
281 if (int_sts & INT_BIT_1588_) {
282 lan743x_ptp_isr(adapter);
283 int_sts &= ~INT_BIT_1588_;
284 }
285 }
286 if (int_sts)
287 lan743x_csr_write(adapter, INT_EN_CLR, int_sts);
288 }
289
lan743x_intr_entry_isr(int irq,void * ptr)290 static irqreturn_t lan743x_intr_entry_isr(int irq, void *ptr)
291 {
292 struct lan743x_vector *vector = ptr;
293 struct lan743x_adapter *adapter = vector->adapter;
294 irqreturn_t result = IRQ_NONE;
295 u32 int_enables;
296 u32 int_sts;
297
298 if (vector->flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ) {
299 int_sts = lan743x_csr_read(adapter, INT_STS);
300 } else if (vector->flags &
301 (LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C |
302 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C)) {
303 int_sts = lan743x_csr_read(adapter, INT_STS_R2C);
304 } else {
305 /* use mask as implied status */
306 int_sts = vector->int_mask | INT_BIT_MAS_;
307 }
308
309 if (!(int_sts & INT_BIT_MAS_))
310 goto irq_done;
311
312 if (vector->flags & LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR)
313 /* disable vector interrupt */
314 lan743x_csr_write(adapter,
315 INT_VEC_EN_CLR,
316 INT_VEC_EN_(vector->vector_index));
317
318 if (vector->flags & LAN743X_VECTOR_FLAG_MASTER_ENABLE_CLEAR)
319 /* disable master interrupt */
320 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_MAS_);
321
322 if (vector->flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK) {
323 int_enables = lan743x_csr_read(adapter, INT_EN_SET);
324 } else {
325 /* use vector mask as implied enable mask */
326 int_enables = vector->int_mask;
327 }
328
329 int_sts &= int_enables;
330 int_sts &= vector->int_mask;
331 if (int_sts) {
332 if (vector->handler) {
333 vector->handler(vector->context,
334 int_sts, vector->flags);
335 } else {
336 /* disable interrupts on this vector */
337 lan743x_csr_write(adapter, INT_EN_CLR,
338 vector->int_mask);
339 }
340 result = IRQ_HANDLED;
341 }
342
343 if (vector->flags & LAN743X_VECTOR_FLAG_MASTER_ENABLE_SET)
344 /* enable master interrupt */
345 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_MAS_);
346
347 if (vector->flags & LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET)
348 /* enable vector interrupt */
349 lan743x_csr_write(adapter,
350 INT_VEC_EN_SET,
351 INT_VEC_EN_(vector->vector_index));
352 irq_done:
353 return result;
354 }
355
lan743x_intr_test_isr(struct lan743x_adapter * adapter)356 static int lan743x_intr_test_isr(struct lan743x_adapter *adapter)
357 {
358 struct lan743x_intr *intr = &adapter->intr;
359 int ret;
360
361 intr->software_isr_flag = false;
362
363 /* enable and activate test interrupt */
364 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_SW_GP_);
365 lan743x_csr_write(adapter, INT_SET, INT_BIT_SW_GP_);
366
367 ret = wait_event_timeout(intr->software_isr_wq,
368 intr->software_isr_flag,
369 msecs_to_jiffies(200));
370
371 /* disable test interrupt */
372 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_SW_GP_);
373
374 return ret > 0 ? 0 : -ENODEV;
375 }
376
lan743x_intr_register_isr(struct lan743x_adapter * adapter,int vector_index,u32 flags,u32 int_mask,lan743x_vector_handler handler,void * context)377 static int lan743x_intr_register_isr(struct lan743x_adapter *adapter,
378 int vector_index, u32 flags,
379 u32 int_mask,
380 lan743x_vector_handler handler,
381 void *context)
382 {
383 struct lan743x_vector *vector = &adapter->intr.vector_list
384 [vector_index];
385 int ret;
386
387 vector->adapter = adapter;
388 vector->flags = flags;
389 vector->vector_index = vector_index;
390 vector->int_mask = int_mask;
391 vector->handler = handler;
392 vector->context = context;
393
394 ret = request_irq(vector->irq,
395 lan743x_intr_entry_isr,
396 (flags & LAN743X_VECTOR_FLAG_IRQ_SHARED) ?
397 IRQF_SHARED : 0, DRIVER_NAME, vector);
398 if (ret) {
399 vector->handler = NULL;
400 vector->context = NULL;
401 vector->int_mask = 0;
402 vector->flags = 0;
403 }
404 return ret;
405 }
406
lan743x_intr_unregister_isr(struct lan743x_adapter * adapter,int vector_index)407 static void lan743x_intr_unregister_isr(struct lan743x_adapter *adapter,
408 int vector_index)
409 {
410 struct lan743x_vector *vector = &adapter->intr.vector_list
411 [vector_index];
412
413 free_irq(vector->irq, vector);
414 vector->handler = NULL;
415 vector->context = NULL;
416 vector->int_mask = 0;
417 vector->flags = 0;
418 }
419
lan743x_intr_get_vector_flags(struct lan743x_adapter * adapter,u32 int_mask)420 static u32 lan743x_intr_get_vector_flags(struct lan743x_adapter *adapter,
421 u32 int_mask)
422 {
423 int index;
424
425 for (index = 0; index < LAN743X_MAX_VECTOR_COUNT; index++) {
426 if (adapter->intr.vector_list[index].int_mask & int_mask)
427 return adapter->intr.vector_list[index].flags;
428 }
429 return 0;
430 }
431
lan743x_intr_close(struct lan743x_adapter * adapter)432 static void lan743x_intr_close(struct lan743x_adapter *adapter)
433 {
434 struct lan743x_intr *intr = &adapter->intr;
435 int index = 0;
436
437 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_MAS_);
438 lan743x_csr_write(adapter, INT_VEC_EN_CLR, 0x000000FF);
439
440 for (index = 0; index < LAN743X_MAX_VECTOR_COUNT; index++) {
441 if (intr->flags & INTR_FLAG_IRQ_REQUESTED(index)) {
442 lan743x_intr_unregister_isr(adapter, index);
443 intr->flags &= ~INTR_FLAG_IRQ_REQUESTED(index);
444 }
445 }
446
447 if (intr->flags & INTR_FLAG_MSI_ENABLED) {
448 pci_disable_msi(adapter->pdev);
449 intr->flags &= ~INTR_FLAG_MSI_ENABLED;
450 }
451
452 if (intr->flags & INTR_FLAG_MSIX_ENABLED) {
453 pci_disable_msix(adapter->pdev);
454 intr->flags &= ~INTR_FLAG_MSIX_ENABLED;
455 }
456 }
457
lan743x_intr_open(struct lan743x_adapter * adapter)458 static int lan743x_intr_open(struct lan743x_adapter *adapter)
459 {
460 struct msix_entry msix_entries[LAN743X_MAX_VECTOR_COUNT];
461 struct lan743x_intr *intr = &adapter->intr;
462 u32 int_vec_en_auto_clr = 0;
463 u32 int_vec_map0 = 0;
464 u32 int_vec_map1 = 0;
465 int ret = -ENODEV;
466 int index = 0;
467 u32 flags = 0;
468
469 intr->number_of_vectors = 0;
470
471 /* Try to set up MSIX interrupts */
472 memset(&msix_entries[0], 0,
473 sizeof(struct msix_entry) * LAN743X_MAX_VECTOR_COUNT);
474 for (index = 0; index < LAN743X_MAX_VECTOR_COUNT; index++)
475 msix_entries[index].entry = index;
476 ret = pci_enable_msix_range(adapter->pdev,
477 msix_entries, 1,
478 1 + LAN743X_USED_TX_CHANNELS +
479 LAN743X_USED_RX_CHANNELS);
480
481 if (ret > 0) {
482 intr->flags |= INTR_FLAG_MSIX_ENABLED;
483 intr->number_of_vectors = ret;
484 intr->using_vectors = true;
485 for (index = 0; index < intr->number_of_vectors; index++)
486 intr->vector_list[index].irq = msix_entries
487 [index].vector;
488 netif_info(adapter, ifup, adapter->netdev,
489 "using MSIX interrupts, number of vectors = %d\n",
490 intr->number_of_vectors);
491 }
492
493 /* If MSIX failed try to setup using MSI interrupts */
494 if (!intr->number_of_vectors) {
495 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0)) {
496 if (!pci_enable_msi(adapter->pdev)) {
497 intr->flags |= INTR_FLAG_MSI_ENABLED;
498 intr->number_of_vectors = 1;
499 intr->using_vectors = true;
500 intr->vector_list[0].irq =
501 adapter->pdev->irq;
502 netif_info(adapter, ifup, adapter->netdev,
503 "using MSI interrupts, number of vectors = %d\n",
504 intr->number_of_vectors);
505 }
506 }
507 }
508
509 /* If MSIX, and MSI failed, setup using legacy interrupt */
510 if (!intr->number_of_vectors) {
511 intr->number_of_vectors = 1;
512 intr->using_vectors = false;
513 intr->vector_list[0].irq = intr->irq;
514 netif_info(adapter, ifup, adapter->netdev,
515 "using legacy interrupts\n");
516 }
517
518 /* At this point we must have at least one irq */
519 lan743x_csr_write(adapter, INT_VEC_EN_CLR, 0xFFFFFFFF);
520
521 /* map all interrupts to vector 0 */
522 lan743x_csr_write(adapter, INT_VEC_MAP0, 0x00000000);
523 lan743x_csr_write(adapter, INT_VEC_MAP1, 0x00000000);
524 lan743x_csr_write(adapter, INT_VEC_MAP2, 0x00000000);
525 flags = LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ |
526 LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C |
527 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK |
528 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR;
529
530 if (intr->using_vectors) {
531 flags |= LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR |
532 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET;
533 } else {
534 flags |= LAN743X_VECTOR_FLAG_MASTER_ENABLE_CLEAR |
535 LAN743X_VECTOR_FLAG_MASTER_ENABLE_SET |
536 LAN743X_VECTOR_FLAG_IRQ_SHARED;
537 }
538
539 if (adapter->csr.flags & LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR) {
540 flags &= ~LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ;
541 flags &= ~LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C;
542 flags &= ~LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR;
543 flags &= ~LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK;
544 flags |= LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C;
545 flags |= LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C;
546 }
547
548 init_waitqueue_head(&intr->software_isr_wq);
549
550 ret = lan743x_intr_register_isr(adapter, 0, flags,
551 INT_BIT_ALL_RX_ | INT_BIT_ALL_TX_ |
552 INT_BIT_ALL_OTHER_,
553 lan743x_intr_shared_isr, adapter);
554 if (ret)
555 goto clean_up;
556 intr->flags |= INTR_FLAG_IRQ_REQUESTED(0);
557
558 if (intr->using_vectors)
559 lan743x_csr_write(adapter, INT_VEC_EN_SET,
560 INT_VEC_EN_(0));
561
562 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0)) {
563 lan743x_csr_write(adapter, INT_MOD_CFG0, LAN743X_INT_MOD);
564 lan743x_csr_write(adapter, INT_MOD_CFG1, LAN743X_INT_MOD);
565 lan743x_csr_write(adapter, INT_MOD_CFG2, LAN743X_INT_MOD);
566 lan743x_csr_write(adapter, INT_MOD_CFG3, LAN743X_INT_MOD);
567 lan743x_csr_write(adapter, INT_MOD_CFG4, LAN743X_INT_MOD);
568 lan743x_csr_write(adapter, INT_MOD_CFG5, LAN743X_INT_MOD);
569 lan743x_csr_write(adapter, INT_MOD_CFG6, LAN743X_INT_MOD);
570 lan743x_csr_write(adapter, INT_MOD_CFG7, LAN743X_INT_MOD);
571 lan743x_csr_write(adapter, INT_MOD_MAP0, 0x00005432);
572 lan743x_csr_write(adapter, INT_MOD_MAP1, 0x00000001);
573 lan743x_csr_write(adapter, INT_MOD_MAP2, 0x00FFFFFF);
574 }
575
576 /* enable interrupts */
577 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_MAS_);
578 ret = lan743x_intr_test_isr(adapter);
579 if (ret)
580 goto clean_up;
581
582 if (intr->number_of_vectors > 1) {
583 int number_of_tx_vectors = intr->number_of_vectors - 1;
584
585 if (number_of_tx_vectors > LAN743X_USED_TX_CHANNELS)
586 number_of_tx_vectors = LAN743X_USED_TX_CHANNELS;
587 flags = LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ |
588 LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C |
589 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK |
590 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR |
591 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR |
592 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET;
593
594 if (adapter->csr.flags &
595 LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR) {
596 flags = LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET |
597 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET |
598 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR |
599 LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR;
600 }
601
602 for (index = 0; index < number_of_tx_vectors; index++) {
603 u32 int_bit = INT_BIT_DMA_TX_(index);
604 int vector = index + 1;
605
606 /* map TX interrupt to vector */
607 int_vec_map1 |= INT_VEC_MAP1_TX_VEC_(index, vector);
608 lan743x_csr_write(adapter, INT_VEC_MAP1, int_vec_map1);
609
610 /* Remove TX interrupt from shared mask */
611 intr->vector_list[0].int_mask &= ~int_bit;
612 ret = lan743x_intr_register_isr(adapter, vector, flags,
613 int_bit, lan743x_tx_isr,
614 &adapter->tx[index]);
615 if (ret)
616 goto clean_up;
617 intr->flags |= INTR_FLAG_IRQ_REQUESTED(vector);
618 if (!(flags &
619 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET))
620 lan743x_csr_write(adapter, INT_VEC_EN_SET,
621 INT_VEC_EN_(vector));
622 }
623 }
624 if ((intr->number_of_vectors - LAN743X_USED_TX_CHANNELS) > 1) {
625 int number_of_rx_vectors = intr->number_of_vectors -
626 LAN743X_USED_TX_CHANNELS - 1;
627
628 if (number_of_rx_vectors > LAN743X_USED_RX_CHANNELS)
629 number_of_rx_vectors = LAN743X_USED_RX_CHANNELS;
630
631 flags = LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ |
632 LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C |
633 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK |
634 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR |
635 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR |
636 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET;
637
638 if (adapter->csr.flags &
639 LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR) {
640 flags = LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_CLEAR |
641 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET |
642 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET |
643 LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR |
644 LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR;
645 }
646 for (index = 0; index < number_of_rx_vectors; index++) {
647 int vector = index + 1 + LAN743X_USED_TX_CHANNELS;
648 u32 int_bit = INT_BIT_DMA_RX_(index);
649
650 /* map RX interrupt to vector */
651 int_vec_map0 |= INT_VEC_MAP0_RX_VEC_(index, vector);
652 lan743x_csr_write(adapter, INT_VEC_MAP0, int_vec_map0);
653 if (flags &
654 LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_CLEAR) {
655 int_vec_en_auto_clr |= INT_VEC_EN_(vector);
656 lan743x_csr_write(adapter, INT_VEC_EN_AUTO_CLR,
657 int_vec_en_auto_clr);
658 }
659
660 /* Remove RX interrupt from shared mask */
661 intr->vector_list[0].int_mask &= ~int_bit;
662 ret = lan743x_intr_register_isr(adapter, vector, flags,
663 int_bit, lan743x_rx_isr,
664 &adapter->rx[index]);
665 if (ret)
666 goto clean_up;
667 intr->flags |= INTR_FLAG_IRQ_REQUESTED(vector);
668
669 lan743x_csr_write(adapter, INT_VEC_EN_SET,
670 INT_VEC_EN_(vector));
671 }
672 }
673 return 0;
674
675 clean_up:
676 lan743x_intr_close(adapter);
677 return ret;
678 }
679
lan743x_dp_write(struct lan743x_adapter * adapter,u32 select,u32 addr,u32 length,u32 * buf)680 static int lan743x_dp_write(struct lan743x_adapter *adapter,
681 u32 select, u32 addr, u32 length, u32 *buf)
682 {
683 u32 dp_sel;
684 int i;
685
686 if (lan743x_csr_wait_for_bit_atomic(adapter, DP_SEL, DP_SEL_DPRDY_,
687 1, 40, 100, 100))
688 return -EIO;
689 dp_sel = lan743x_csr_read(adapter, DP_SEL);
690 dp_sel &= ~DP_SEL_MASK_;
691 dp_sel |= select;
692 lan743x_csr_write(adapter, DP_SEL, dp_sel);
693
694 for (i = 0; i < length; i++) {
695 lan743x_csr_write(adapter, DP_ADDR, addr + i);
696 lan743x_csr_write(adapter, DP_DATA_0, buf[i]);
697 lan743x_csr_write(adapter, DP_CMD, DP_CMD_WRITE_);
698 if (lan743x_csr_wait_for_bit_atomic(adapter, DP_SEL,
699 DP_SEL_DPRDY_,
700 1, 40, 100, 100))
701 return -EIO;
702 }
703
704 return 0;
705 }
706
lan743x_mac_mii_access(u16 id,u16 index,int read)707 static u32 lan743x_mac_mii_access(u16 id, u16 index, int read)
708 {
709 u32 ret;
710
711 ret = (id << MAC_MII_ACC_PHY_ADDR_SHIFT_) &
712 MAC_MII_ACC_PHY_ADDR_MASK_;
713 ret |= (index << MAC_MII_ACC_MIIRINDA_SHIFT_) &
714 MAC_MII_ACC_MIIRINDA_MASK_;
715
716 if (read)
717 ret |= MAC_MII_ACC_MII_READ_;
718 else
719 ret |= MAC_MII_ACC_MII_WRITE_;
720 ret |= MAC_MII_ACC_MII_BUSY_;
721
722 return ret;
723 }
724
lan743x_mac_mii_wait_till_not_busy(struct lan743x_adapter * adapter)725 static int lan743x_mac_mii_wait_till_not_busy(struct lan743x_adapter *adapter)
726 {
727 u32 data;
728
729 return readx_poll_timeout(LAN743X_CSR_READ_OP, MAC_MII_ACC, data,
730 !(data & MAC_MII_ACC_MII_BUSY_), 0, 1000000);
731 }
732
lan743x_mdiobus_read(struct mii_bus * bus,int phy_id,int index)733 static int lan743x_mdiobus_read(struct mii_bus *bus, int phy_id, int index)
734 {
735 struct lan743x_adapter *adapter = bus->priv;
736 u32 val, mii_access;
737 int ret;
738
739 /* comfirm MII not busy */
740 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
741 if (ret < 0)
742 return ret;
743
744 /* set the address, index & direction (read from PHY) */
745 mii_access = lan743x_mac_mii_access(phy_id, index, MAC_MII_READ);
746 lan743x_csr_write(adapter, MAC_MII_ACC, mii_access);
747 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
748 if (ret < 0)
749 return ret;
750
751 val = lan743x_csr_read(adapter, MAC_MII_DATA);
752 return (int)(val & 0xFFFF);
753 }
754
lan743x_mdiobus_write(struct mii_bus * bus,int phy_id,int index,u16 regval)755 static int lan743x_mdiobus_write(struct mii_bus *bus,
756 int phy_id, int index, u16 regval)
757 {
758 struct lan743x_adapter *adapter = bus->priv;
759 u32 val, mii_access;
760 int ret;
761
762 /* confirm MII not busy */
763 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
764 if (ret < 0)
765 return ret;
766 val = (u32)regval;
767 lan743x_csr_write(adapter, MAC_MII_DATA, val);
768
769 /* set the address, index & direction (write to PHY) */
770 mii_access = lan743x_mac_mii_access(phy_id, index, MAC_MII_WRITE);
771 lan743x_csr_write(adapter, MAC_MII_ACC, mii_access);
772 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
773 return ret;
774 }
775
lan743x_mac_set_address(struct lan743x_adapter * adapter,u8 * addr)776 static void lan743x_mac_set_address(struct lan743x_adapter *adapter,
777 u8 *addr)
778 {
779 u32 addr_lo, addr_hi;
780
781 addr_lo = addr[0] |
782 addr[1] << 8 |
783 addr[2] << 16 |
784 addr[3] << 24;
785 addr_hi = addr[4] |
786 addr[5] << 8;
787 lan743x_csr_write(adapter, MAC_RX_ADDRL, addr_lo);
788 lan743x_csr_write(adapter, MAC_RX_ADDRH, addr_hi);
789
790 ether_addr_copy(adapter->mac_address, addr);
791 netif_info(adapter, drv, adapter->netdev,
792 "MAC address set to %pM\n", addr);
793 }
794
lan743x_mac_init(struct lan743x_adapter * adapter)795 static int lan743x_mac_init(struct lan743x_adapter *adapter)
796 {
797 bool mac_address_valid = true;
798 struct net_device *netdev;
799 u32 mac_addr_hi = 0;
800 u32 mac_addr_lo = 0;
801 u32 data;
802
803 netdev = adapter->netdev;
804
805 /* disable auto duplex, and speed detection. Phylib does that */
806 data = lan743x_csr_read(adapter, MAC_CR);
807 data &= ~(MAC_CR_ADD_ | MAC_CR_ASD_);
808 data |= MAC_CR_CNTR_RST_;
809 lan743x_csr_write(adapter, MAC_CR, data);
810
811 if (!is_valid_ether_addr(adapter->mac_address)) {
812 mac_addr_hi = lan743x_csr_read(adapter, MAC_RX_ADDRH);
813 mac_addr_lo = lan743x_csr_read(adapter, MAC_RX_ADDRL);
814 adapter->mac_address[0] = mac_addr_lo & 0xFF;
815 adapter->mac_address[1] = (mac_addr_lo >> 8) & 0xFF;
816 adapter->mac_address[2] = (mac_addr_lo >> 16) & 0xFF;
817 adapter->mac_address[3] = (mac_addr_lo >> 24) & 0xFF;
818 adapter->mac_address[4] = mac_addr_hi & 0xFF;
819 adapter->mac_address[5] = (mac_addr_hi >> 8) & 0xFF;
820
821 if (((mac_addr_hi & 0x0000FFFF) == 0x0000FFFF) &&
822 mac_addr_lo == 0xFFFFFFFF) {
823 mac_address_valid = false;
824 } else if (!is_valid_ether_addr(adapter->mac_address)) {
825 mac_address_valid = false;
826 }
827
828 if (!mac_address_valid)
829 eth_random_addr(adapter->mac_address);
830 }
831 lan743x_mac_set_address(adapter, adapter->mac_address);
832 eth_hw_addr_set(netdev, adapter->mac_address);
833
834 return 0;
835 }
836
lan743x_mac_open(struct lan743x_adapter * adapter)837 static int lan743x_mac_open(struct lan743x_adapter *adapter)
838 {
839 u32 temp;
840
841 temp = lan743x_csr_read(adapter, MAC_RX);
842 lan743x_csr_write(adapter, MAC_RX, temp | MAC_RX_RXEN_);
843 temp = lan743x_csr_read(adapter, MAC_TX);
844 lan743x_csr_write(adapter, MAC_TX, temp | MAC_TX_TXEN_);
845 return 0;
846 }
847
lan743x_mac_close(struct lan743x_adapter * adapter)848 static void lan743x_mac_close(struct lan743x_adapter *adapter)
849 {
850 u32 temp;
851
852 temp = lan743x_csr_read(adapter, MAC_TX);
853 temp &= ~MAC_TX_TXEN_;
854 lan743x_csr_write(adapter, MAC_TX, temp);
855 lan743x_csr_wait_for_bit(adapter, MAC_TX, MAC_TX_TXD_,
856 1, 1000, 20000, 100);
857
858 temp = lan743x_csr_read(adapter, MAC_RX);
859 temp &= ~MAC_RX_RXEN_;
860 lan743x_csr_write(adapter, MAC_RX, temp);
861 lan743x_csr_wait_for_bit(adapter, MAC_RX, MAC_RX_RXD_,
862 1, 1000, 20000, 100);
863 }
864
lan743x_mac_flow_ctrl_set_enables(struct lan743x_adapter * adapter,bool tx_enable,bool rx_enable)865 static void lan743x_mac_flow_ctrl_set_enables(struct lan743x_adapter *adapter,
866 bool tx_enable, bool rx_enable)
867 {
868 u32 flow_setting = 0;
869
870 /* set maximum pause time because when fifo space frees
871 * up a zero value pause frame will be sent to release the pause
872 */
873 flow_setting = MAC_FLOW_CR_FCPT_MASK_;
874 if (tx_enable)
875 flow_setting |= MAC_FLOW_CR_TX_FCEN_;
876 if (rx_enable)
877 flow_setting |= MAC_FLOW_CR_RX_FCEN_;
878 lan743x_csr_write(adapter, MAC_FLOW, flow_setting);
879 }
880
lan743x_mac_set_mtu(struct lan743x_adapter * adapter,int new_mtu)881 static int lan743x_mac_set_mtu(struct lan743x_adapter *adapter, int new_mtu)
882 {
883 int enabled = 0;
884 u32 mac_rx = 0;
885
886 mac_rx = lan743x_csr_read(adapter, MAC_RX);
887 if (mac_rx & MAC_RX_RXEN_) {
888 enabled = 1;
889 if (mac_rx & MAC_RX_RXD_) {
890 lan743x_csr_write(adapter, MAC_RX, mac_rx);
891 mac_rx &= ~MAC_RX_RXD_;
892 }
893 mac_rx &= ~MAC_RX_RXEN_;
894 lan743x_csr_write(adapter, MAC_RX, mac_rx);
895 lan743x_csr_wait_for_bit(adapter, MAC_RX, MAC_RX_RXD_,
896 1, 1000, 20000, 100);
897 lan743x_csr_write(adapter, MAC_RX, mac_rx | MAC_RX_RXD_);
898 }
899
900 mac_rx &= ~(MAC_RX_MAX_SIZE_MASK_);
901 mac_rx |= (((new_mtu + ETH_HLEN + ETH_FCS_LEN)
902 << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
903 lan743x_csr_write(adapter, MAC_RX, mac_rx);
904
905 if (enabled) {
906 mac_rx |= MAC_RX_RXEN_;
907 lan743x_csr_write(adapter, MAC_RX, mac_rx);
908 }
909 return 0;
910 }
911
912 /* PHY */
lan743x_phy_reset(struct lan743x_adapter * adapter)913 static int lan743x_phy_reset(struct lan743x_adapter *adapter)
914 {
915 u32 data;
916
917 /* Only called with in probe, and before mdiobus_register */
918
919 data = lan743x_csr_read(adapter, PMT_CTL);
920 data |= PMT_CTL_ETH_PHY_RST_;
921 lan743x_csr_write(adapter, PMT_CTL, data);
922
923 return readx_poll_timeout(LAN743X_CSR_READ_OP, PMT_CTL, data,
924 (!(data & PMT_CTL_ETH_PHY_RST_) &&
925 (data & PMT_CTL_READY_)),
926 50000, 1000000);
927 }
928
lan743x_phy_update_flowcontrol(struct lan743x_adapter * adapter,u16 local_adv,u16 remote_adv)929 static void lan743x_phy_update_flowcontrol(struct lan743x_adapter *adapter,
930 u16 local_adv, u16 remote_adv)
931 {
932 struct lan743x_phy *phy = &adapter->phy;
933 u8 cap;
934
935 if (phy->fc_autoneg)
936 cap = mii_resolve_flowctrl_fdx(local_adv, remote_adv);
937 else
938 cap = phy->fc_request_control;
939
940 lan743x_mac_flow_ctrl_set_enables(adapter,
941 cap & FLOW_CTRL_TX,
942 cap & FLOW_CTRL_RX);
943 }
944
lan743x_phy_init(struct lan743x_adapter * adapter)945 static int lan743x_phy_init(struct lan743x_adapter *adapter)
946 {
947 return lan743x_phy_reset(adapter);
948 }
949
lan743x_phy_link_status_change(struct net_device * netdev)950 static void lan743x_phy_link_status_change(struct net_device *netdev)
951 {
952 struct lan743x_adapter *adapter = netdev_priv(netdev);
953 struct phy_device *phydev = netdev->phydev;
954 u32 data;
955
956 phy_print_status(phydev);
957 if (phydev->state == PHY_RUNNING) {
958 int remote_advertisement = 0;
959 int local_advertisement = 0;
960
961 data = lan743x_csr_read(adapter, MAC_CR);
962
963 /* set interface mode */
964 if (phy_interface_is_rgmii(phydev))
965 /* RGMII */
966 data &= ~MAC_CR_MII_EN_;
967 else
968 /* GMII */
969 data |= MAC_CR_MII_EN_;
970
971 /* set duplex mode */
972 if (phydev->duplex)
973 data |= MAC_CR_DPX_;
974 else
975 data &= ~MAC_CR_DPX_;
976
977 /* set bus speed */
978 switch (phydev->speed) {
979 case SPEED_10:
980 data &= ~MAC_CR_CFG_H_;
981 data &= ~MAC_CR_CFG_L_;
982 break;
983 case SPEED_100:
984 data &= ~MAC_CR_CFG_H_;
985 data |= MAC_CR_CFG_L_;
986 break;
987 case SPEED_1000:
988 data |= MAC_CR_CFG_H_;
989 data &= ~MAC_CR_CFG_L_;
990 break;
991 }
992 lan743x_csr_write(adapter, MAC_CR, data);
993
994 local_advertisement =
995 linkmode_adv_to_mii_adv_t(phydev->advertising);
996 remote_advertisement =
997 linkmode_adv_to_mii_adv_t(phydev->lp_advertising);
998
999 lan743x_phy_update_flowcontrol(adapter, local_advertisement,
1000 remote_advertisement);
1001 lan743x_ptp_update_latency(adapter, phydev->speed);
1002 }
1003 }
1004
lan743x_phy_close(struct lan743x_adapter * adapter)1005 static void lan743x_phy_close(struct lan743x_adapter *adapter)
1006 {
1007 struct net_device *netdev = adapter->netdev;
1008
1009 phy_stop(netdev->phydev);
1010 phy_disconnect(netdev->phydev);
1011 netdev->phydev = NULL;
1012 }
1013
lan743x_phy_open(struct lan743x_adapter * adapter)1014 static int lan743x_phy_open(struct lan743x_adapter *adapter)
1015 {
1016 struct net_device *netdev = adapter->netdev;
1017 struct lan743x_phy *phy = &adapter->phy;
1018 struct phy_device *phydev;
1019 int ret = -EIO;
1020
1021 /* try devicetree phy, or fixed link */
1022 phydev = of_phy_get_and_connect(netdev, adapter->pdev->dev.of_node,
1023 lan743x_phy_link_status_change);
1024
1025 if (!phydev) {
1026 /* try internal phy */
1027 phydev = phy_find_first(adapter->mdiobus);
1028 if (!phydev)
1029 goto return_error;
1030
1031 ret = phy_connect_direct(netdev, phydev,
1032 lan743x_phy_link_status_change,
1033 PHY_INTERFACE_MODE_GMII);
1034 if (ret)
1035 goto return_error;
1036 }
1037
1038 /* MAC doesn't support 1000T Half */
1039 phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
1040
1041 /* support both flow controls */
1042 phy_support_asym_pause(phydev);
1043 phy->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
1044 phy->fc_autoneg = phydev->autoneg;
1045
1046 phy_start(phydev);
1047 phy_start_aneg(phydev);
1048 phy_attached_info(phydev);
1049 return 0;
1050
1051 return_error:
1052 return ret;
1053 }
1054
lan743x_rfe_open(struct lan743x_adapter * adapter)1055 static void lan743x_rfe_open(struct lan743x_adapter *adapter)
1056 {
1057 lan743x_csr_write(adapter, RFE_RSS_CFG,
1058 RFE_RSS_CFG_UDP_IPV6_EX_ |
1059 RFE_RSS_CFG_TCP_IPV6_EX_ |
1060 RFE_RSS_CFG_IPV6_EX_ |
1061 RFE_RSS_CFG_UDP_IPV6_ |
1062 RFE_RSS_CFG_TCP_IPV6_ |
1063 RFE_RSS_CFG_IPV6_ |
1064 RFE_RSS_CFG_UDP_IPV4_ |
1065 RFE_RSS_CFG_TCP_IPV4_ |
1066 RFE_RSS_CFG_IPV4_ |
1067 RFE_RSS_CFG_VALID_HASH_BITS_ |
1068 RFE_RSS_CFG_RSS_QUEUE_ENABLE_ |
1069 RFE_RSS_CFG_RSS_HASH_STORE_ |
1070 RFE_RSS_CFG_RSS_ENABLE_);
1071 }
1072
lan743x_rfe_update_mac_address(struct lan743x_adapter * adapter)1073 static void lan743x_rfe_update_mac_address(struct lan743x_adapter *adapter)
1074 {
1075 u8 *mac_addr;
1076 u32 mac_addr_hi = 0;
1077 u32 mac_addr_lo = 0;
1078
1079 /* Add mac address to perfect Filter */
1080 mac_addr = adapter->mac_address;
1081 mac_addr_lo = ((((u32)(mac_addr[0])) << 0) |
1082 (((u32)(mac_addr[1])) << 8) |
1083 (((u32)(mac_addr[2])) << 16) |
1084 (((u32)(mac_addr[3])) << 24));
1085 mac_addr_hi = ((((u32)(mac_addr[4])) << 0) |
1086 (((u32)(mac_addr[5])) << 8));
1087
1088 lan743x_csr_write(adapter, RFE_ADDR_FILT_LO(0), mac_addr_lo);
1089 lan743x_csr_write(adapter, RFE_ADDR_FILT_HI(0),
1090 mac_addr_hi | RFE_ADDR_FILT_HI_VALID_);
1091 }
1092
lan743x_rfe_set_multicast(struct lan743x_adapter * adapter)1093 static void lan743x_rfe_set_multicast(struct lan743x_adapter *adapter)
1094 {
1095 struct net_device *netdev = adapter->netdev;
1096 u32 hash_table[DP_SEL_VHF_HASH_LEN];
1097 u32 rfctl;
1098 u32 data;
1099
1100 rfctl = lan743x_csr_read(adapter, RFE_CTL);
1101 rfctl &= ~(RFE_CTL_AU_ | RFE_CTL_AM_ |
1102 RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1103 rfctl |= RFE_CTL_AB_;
1104 if (netdev->flags & IFF_PROMISC) {
1105 rfctl |= RFE_CTL_AM_ | RFE_CTL_AU_;
1106 } else {
1107 if (netdev->flags & IFF_ALLMULTI)
1108 rfctl |= RFE_CTL_AM_;
1109 }
1110
1111 memset(hash_table, 0, DP_SEL_VHF_HASH_LEN * sizeof(u32));
1112 if (netdev_mc_count(netdev)) {
1113 struct netdev_hw_addr *ha;
1114 int i;
1115
1116 rfctl |= RFE_CTL_DA_PERFECT_;
1117 i = 1;
1118 netdev_for_each_mc_addr(ha, netdev) {
1119 /* set first 32 into Perfect Filter */
1120 if (i < 33) {
1121 lan743x_csr_write(adapter,
1122 RFE_ADDR_FILT_HI(i), 0);
1123 data = ha->addr[3];
1124 data = ha->addr[2] | (data << 8);
1125 data = ha->addr[1] | (data << 8);
1126 data = ha->addr[0] | (data << 8);
1127 lan743x_csr_write(adapter,
1128 RFE_ADDR_FILT_LO(i), data);
1129 data = ha->addr[5];
1130 data = ha->addr[4] | (data << 8);
1131 data |= RFE_ADDR_FILT_HI_VALID_;
1132 lan743x_csr_write(adapter,
1133 RFE_ADDR_FILT_HI(i), data);
1134 } else {
1135 u32 bitnum = (ether_crc(ETH_ALEN, ha->addr) >>
1136 23) & 0x1FF;
1137 hash_table[bitnum / 32] |= (1 << (bitnum % 32));
1138 rfctl |= RFE_CTL_MCAST_HASH_;
1139 }
1140 i++;
1141 }
1142 }
1143
1144 lan743x_dp_write(adapter, DP_SEL_RFE_RAM,
1145 DP_SEL_VHF_VLAN_LEN,
1146 DP_SEL_VHF_HASH_LEN, hash_table);
1147 lan743x_csr_write(adapter, RFE_CTL, rfctl);
1148 }
1149
lan743x_dmac_init(struct lan743x_adapter * adapter)1150 static int lan743x_dmac_init(struct lan743x_adapter *adapter)
1151 {
1152 u32 data = 0;
1153
1154 lan743x_csr_write(adapter, DMAC_CMD, DMAC_CMD_SWR_);
1155 lan743x_csr_wait_for_bit(adapter, DMAC_CMD, DMAC_CMD_SWR_,
1156 0, 1000, 20000, 100);
1157 switch (DEFAULT_DMA_DESCRIPTOR_SPACING) {
1158 case DMA_DESCRIPTOR_SPACING_16:
1159 data = DMAC_CFG_MAX_DSPACE_16_;
1160 break;
1161 case DMA_DESCRIPTOR_SPACING_32:
1162 data = DMAC_CFG_MAX_DSPACE_32_;
1163 break;
1164 case DMA_DESCRIPTOR_SPACING_64:
1165 data = DMAC_CFG_MAX_DSPACE_64_;
1166 break;
1167 case DMA_DESCRIPTOR_SPACING_128:
1168 data = DMAC_CFG_MAX_DSPACE_128_;
1169 break;
1170 default:
1171 return -EPERM;
1172 }
1173 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0))
1174 data |= DMAC_CFG_COAL_EN_;
1175 data |= DMAC_CFG_CH_ARB_SEL_RX_HIGH_;
1176 data |= DMAC_CFG_MAX_READ_REQ_SET_(6);
1177 lan743x_csr_write(adapter, DMAC_CFG, data);
1178 data = DMAC_COAL_CFG_TIMER_LIMIT_SET_(1);
1179 data |= DMAC_COAL_CFG_TIMER_TX_START_;
1180 data |= DMAC_COAL_CFG_FLUSH_INTS_;
1181 data |= DMAC_COAL_CFG_INT_EXIT_COAL_;
1182 data |= DMAC_COAL_CFG_CSR_EXIT_COAL_;
1183 data |= DMAC_COAL_CFG_TX_THRES_SET_(0x0A);
1184 data |= DMAC_COAL_CFG_RX_THRES_SET_(0x0C);
1185 lan743x_csr_write(adapter, DMAC_COAL_CFG, data);
1186 data = DMAC_OBFF_TX_THRES_SET_(0x08);
1187 data |= DMAC_OBFF_RX_THRES_SET_(0x0A);
1188 lan743x_csr_write(adapter, DMAC_OBFF_CFG, data);
1189 return 0;
1190 }
1191
lan743x_dmac_tx_get_state(struct lan743x_adapter * adapter,int tx_channel)1192 static int lan743x_dmac_tx_get_state(struct lan743x_adapter *adapter,
1193 int tx_channel)
1194 {
1195 u32 dmac_cmd = 0;
1196
1197 dmac_cmd = lan743x_csr_read(adapter, DMAC_CMD);
1198 return DMAC_CHANNEL_STATE_SET((dmac_cmd &
1199 DMAC_CMD_START_T_(tx_channel)),
1200 (dmac_cmd &
1201 DMAC_CMD_STOP_T_(tx_channel)));
1202 }
1203
lan743x_dmac_tx_wait_till_stopped(struct lan743x_adapter * adapter,int tx_channel)1204 static int lan743x_dmac_tx_wait_till_stopped(struct lan743x_adapter *adapter,
1205 int tx_channel)
1206 {
1207 int timeout = 100;
1208 int result = 0;
1209
1210 while (timeout &&
1211 ((result = lan743x_dmac_tx_get_state(adapter, tx_channel)) ==
1212 DMAC_CHANNEL_STATE_STOP_PENDING)) {
1213 usleep_range(1000, 20000);
1214 timeout--;
1215 }
1216 if (result == DMAC_CHANNEL_STATE_STOP_PENDING)
1217 result = -ENODEV;
1218 return result;
1219 }
1220
lan743x_dmac_rx_get_state(struct lan743x_adapter * adapter,int rx_channel)1221 static int lan743x_dmac_rx_get_state(struct lan743x_adapter *adapter,
1222 int rx_channel)
1223 {
1224 u32 dmac_cmd = 0;
1225
1226 dmac_cmd = lan743x_csr_read(adapter, DMAC_CMD);
1227 return DMAC_CHANNEL_STATE_SET((dmac_cmd &
1228 DMAC_CMD_START_R_(rx_channel)),
1229 (dmac_cmd &
1230 DMAC_CMD_STOP_R_(rx_channel)));
1231 }
1232
lan743x_dmac_rx_wait_till_stopped(struct lan743x_adapter * adapter,int rx_channel)1233 static int lan743x_dmac_rx_wait_till_stopped(struct lan743x_adapter *adapter,
1234 int rx_channel)
1235 {
1236 int timeout = 100;
1237 int result = 0;
1238
1239 while (timeout &&
1240 ((result = lan743x_dmac_rx_get_state(adapter, rx_channel)) ==
1241 DMAC_CHANNEL_STATE_STOP_PENDING)) {
1242 usleep_range(1000, 20000);
1243 timeout--;
1244 }
1245 if (result == DMAC_CHANNEL_STATE_STOP_PENDING)
1246 result = -ENODEV;
1247 return result;
1248 }
1249
lan743x_tx_release_desc(struct lan743x_tx * tx,int descriptor_index,bool cleanup)1250 static void lan743x_tx_release_desc(struct lan743x_tx *tx,
1251 int descriptor_index, bool cleanup)
1252 {
1253 struct lan743x_tx_buffer_info *buffer_info = NULL;
1254 struct lan743x_tx_descriptor *descriptor = NULL;
1255 u32 descriptor_type = 0;
1256 bool ignore_sync;
1257
1258 descriptor = &tx->ring_cpu_ptr[descriptor_index];
1259 buffer_info = &tx->buffer_info[descriptor_index];
1260 if (!(buffer_info->flags & TX_BUFFER_INFO_FLAG_ACTIVE))
1261 goto done;
1262
1263 descriptor_type = le32_to_cpu(descriptor->data0) &
1264 TX_DESC_DATA0_DTYPE_MASK_;
1265 if (descriptor_type == TX_DESC_DATA0_DTYPE_DATA_)
1266 goto clean_up_data_descriptor;
1267 else
1268 goto clear_active;
1269
1270 clean_up_data_descriptor:
1271 if (buffer_info->dma_ptr) {
1272 if (buffer_info->flags &
1273 TX_BUFFER_INFO_FLAG_SKB_FRAGMENT) {
1274 dma_unmap_page(&tx->adapter->pdev->dev,
1275 buffer_info->dma_ptr,
1276 buffer_info->buffer_length,
1277 DMA_TO_DEVICE);
1278 } else {
1279 dma_unmap_single(&tx->adapter->pdev->dev,
1280 buffer_info->dma_ptr,
1281 buffer_info->buffer_length,
1282 DMA_TO_DEVICE);
1283 }
1284 buffer_info->dma_ptr = 0;
1285 buffer_info->buffer_length = 0;
1286 }
1287 if (!buffer_info->skb)
1288 goto clear_active;
1289
1290 if (!(buffer_info->flags & TX_BUFFER_INFO_FLAG_TIMESTAMP_REQUESTED)) {
1291 dev_kfree_skb_any(buffer_info->skb);
1292 goto clear_skb;
1293 }
1294
1295 if (cleanup) {
1296 lan743x_ptp_unrequest_tx_timestamp(tx->adapter);
1297 dev_kfree_skb_any(buffer_info->skb);
1298 } else {
1299 ignore_sync = (buffer_info->flags &
1300 TX_BUFFER_INFO_FLAG_IGNORE_SYNC) != 0;
1301 lan743x_ptp_tx_timestamp_skb(tx->adapter,
1302 buffer_info->skb, ignore_sync);
1303 }
1304
1305 clear_skb:
1306 buffer_info->skb = NULL;
1307
1308 clear_active:
1309 buffer_info->flags &= ~TX_BUFFER_INFO_FLAG_ACTIVE;
1310
1311 done:
1312 memset(buffer_info, 0, sizeof(*buffer_info));
1313 memset(descriptor, 0, sizeof(*descriptor));
1314 }
1315
lan743x_tx_next_index(struct lan743x_tx * tx,int index)1316 static int lan743x_tx_next_index(struct lan743x_tx *tx, int index)
1317 {
1318 return ((++index) % tx->ring_size);
1319 }
1320
lan743x_tx_release_completed_descriptors(struct lan743x_tx * tx)1321 static void lan743x_tx_release_completed_descriptors(struct lan743x_tx *tx)
1322 {
1323 while (le32_to_cpu(*tx->head_cpu_ptr) != (tx->last_head)) {
1324 lan743x_tx_release_desc(tx, tx->last_head, false);
1325 tx->last_head = lan743x_tx_next_index(tx, tx->last_head);
1326 }
1327 }
1328
lan743x_tx_release_all_descriptors(struct lan743x_tx * tx)1329 static void lan743x_tx_release_all_descriptors(struct lan743x_tx *tx)
1330 {
1331 u32 original_head = 0;
1332
1333 original_head = tx->last_head;
1334 do {
1335 lan743x_tx_release_desc(tx, tx->last_head, true);
1336 tx->last_head = lan743x_tx_next_index(tx, tx->last_head);
1337 } while (tx->last_head != original_head);
1338 memset(tx->ring_cpu_ptr, 0,
1339 sizeof(*tx->ring_cpu_ptr) * (tx->ring_size));
1340 memset(tx->buffer_info, 0,
1341 sizeof(*tx->buffer_info) * (tx->ring_size));
1342 }
1343
lan743x_tx_get_desc_cnt(struct lan743x_tx * tx,struct sk_buff * skb)1344 static int lan743x_tx_get_desc_cnt(struct lan743x_tx *tx,
1345 struct sk_buff *skb)
1346 {
1347 int result = 1; /* 1 for the main skb buffer */
1348 int nr_frags = 0;
1349
1350 if (skb_is_gso(skb))
1351 result++; /* requires an extension descriptor */
1352 nr_frags = skb_shinfo(skb)->nr_frags;
1353 result += nr_frags; /* 1 for each fragment buffer */
1354 return result;
1355 }
1356
lan743x_tx_get_avail_desc(struct lan743x_tx * tx)1357 static int lan743x_tx_get_avail_desc(struct lan743x_tx *tx)
1358 {
1359 int last_head = tx->last_head;
1360 int last_tail = tx->last_tail;
1361
1362 if (last_tail >= last_head)
1363 return tx->ring_size - last_tail + last_head - 1;
1364 else
1365 return last_head - last_tail - 1;
1366 }
1367
lan743x_tx_set_timestamping_mode(struct lan743x_tx * tx,bool enable_timestamping,bool enable_onestep_sync)1368 void lan743x_tx_set_timestamping_mode(struct lan743x_tx *tx,
1369 bool enable_timestamping,
1370 bool enable_onestep_sync)
1371 {
1372 if (enable_timestamping)
1373 tx->ts_flags |= TX_TS_FLAG_TIMESTAMPING_ENABLED;
1374 else
1375 tx->ts_flags &= ~TX_TS_FLAG_TIMESTAMPING_ENABLED;
1376 if (enable_onestep_sync)
1377 tx->ts_flags |= TX_TS_FLAG_ONE_STEP_SYNC;
1378 else
1379 tx->ts_flags &= ~TX_TS_FLAG_ONE_STEP_SYNC;
1380 }
1381
lan743x_tx_frame_start(struct lan743x_tx * tx,unsigned char * first_buffer,unsigned int first_buffer_length,unsigned int frame_length,bool time_stamp,bool check_sum)1382 static int lan743x_tx_frame_start(struct lan743x_tx *tx,
1383 unsigned char *first_buffer,
1384 unsigned int first_buffer_length,
1385 unsigned int frame_length,
1386 bool time_stamp,
1387 bool check_sum)
1388 {
1389 /* called only from within lan743x_tx_xmit_frame.
1390 * assuming tx->ring_lock has already been acquired.
1391 */
1392 struct lan743x_tx_descriptor *tx_descriptor = NULL;
1393 struct lan743x_tx_buffer_info *buffer_info = NULL;
1394 struct lan743x_adapter *adapter = tx->adapter;
1395 struct device *dev = &adapter->pdev->dev;
1396 dma_addr_t dma_ptr;
1397
1398 tx->frame_flags |= TX_FRAME_FLAG_IN_PROGRESS;
1399 tx->frame_first = tx->last_tail;
1400 tx->frame_tail = tx->frame_first;
1401
1402 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
1403 buffer_info = &tx->buffer_info[tx->frame_tail];
1404 dma_ptr = dma_map_single(dev, first_buffer, first_buffer_length,
1405 DMA_TO_DEVICE);
1406 if (dma_mapping_error(dev, dma_ptr))
1407 return -ENOMEM;
1408
1409 tx_descriptor->data1 = cpu_to_le32(DMA_ADDR_LOW32(dma_ptr));
1410 tx_descriptor->data2 = cpu_to_le32(DMA_ADDR_HIGH32(dma_ptr));
1411 tx_descriptor->data3 = cpu_to_le32((frame_length << 16) &
1412 TX_DESC_DATA3_FRAME_LENGTH_MSS_MASK_);
1413
1414 buffer_info->skb = NULL;
1415 buffer_info->dma_ptr = dma_ptr;
1416 buffer_info->buffer_length = first_buffer_length;
1417 buffer_info->flags |= TX_BUFFER_INFO_FLAG_ACTIVE;
1418
1419 tx->frame_data0 = (first_buffer_length &
1420 TX_DESC_DATA0_BUF_LENGTH_MASK_) |
1421 TX_DESC_DATA0_DTYPE_DATA_ |
1422 TX_DESC_DATA0_FS_ |
1423 TX_DESC_DATA0_FCS_;
1424 if (time_stamp)
1425 tx->frame_data0 |= TX_DESC_DATA0_TSE_;
1426
1427 if (check_sum)
1428 tx->frame_data0 |= TX_DESC_DATA0_ICE_ |
1429 TX_DESC_DATA0_IPE_ |
1430 TX_DESC_DATA0_TPE_;
1431
1432 /* data0 will be programmed in one of other frame assembler functions */
1433 return 0;
1434 }
1435
lan743x_tx_frame_add_lso(struct lan743x_tx * tx,unsigned int frame_length,int nr_frags)1436 static void lan743x_tx_frame_add_lso(struct lan743x_tx *tx,
1437 unsigned int frame_length,
1438 int nr_frags)
1439 {
1440 /* called only from within lan743x_tx_xmit_frame.
1441 * assuming tx->ring_lock has already been acquired.
1442 */
1443 struct lan743x_tx_descriptor *tx_descriptor = NULL;
1444 struct lan743x_tx_buffer_info *buffer_info = NULL;
1445
1446 /* wrap up previous descriptor */
1447 tx->frame_data0 |= TX_DESC_DATA0_EXT_;
1448 if (nr_frags <= 0) {
1449 tx->frame_data0 |= TX_DESC_DATA0_LS_;
1450 tx->frame_data0 |= TX_DESC_DATA0_IOC_;
1451 }
1452 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
1453 tx_descriptor->data0 = cpu_to_le32(tx->frame_data0);
1454
1455 /* move to next descriptor */
1456 tx->frame_tail = lan743x_tx_next_index(tx, tx->frame_tail);
1457 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
1458 buffer_info = &tx->buffer_info[tx->frame_tail];
1459
1460 /* add extension descriptor */
1461 tx_descriptor->data1 = 0;
1462 tx_descriptor->data2 = 0;
1463 tx_descriptor->data3 = 0;
1464
1465 buffer_info->skb = NULL;
1466 buffer_info->dma_ptr = 0;
1467 buffer_info->buffer_length = 0;
1468 buffer_info->flags |= TX_BUFFER_INFO_FLAG_ACTIVE;
1469
1470 tx->frame_data0 = (frame_length & TX_DESC_DATA0_EXT_PAY_LENGTH_MASK_) |
1471 TX_DESC_DATA0_DTYPE_EXT_ |
1472 TX_DESC_DATA0_EXT_LSO_;
1473
1474 /* data0 will be programmed in one of other frame assembler functions */
1475 }
1476
lan743x_tx_frame_add_fragment(struct lan743x_tx * tx,const skb_frag_t * fragment,unsigned int frame_length)1477 static int lan743x_tx_frame_add_fragment(struct lan743x_tx *tx,
1478 const skb_frag_t *fragment,
1479 unsigned int frame_length)
1480 {
1481 /* called only from within lan743x_tx_xmit_frame
1482 * assuming tx->ring_lock has already been acquired
1483 */
1484 struct lan743x_tx_descriptor *tx_descriptor = NULL;
1485 struct lan743x_tx_buffer_info *buffer_info = NULL;
1486 struct lan743x_adapter *adapter = tx->adapter;
1487 struct device *dev = &adapter->pdev->dev;
1488 unsigned int fragment_length = 0;
1489 dma_addr_t dma_ptr;
1490
1491 fragment_length = skb_frag_size(fragment);
1492 if (!fragment_length)
1493 return 0;
1494
1495 /* wrap up previous descriptor */
1496 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
1497 tx_descriptor->data0 = cpu_to_le32(tx->frame_data0);
1498
1499 /* move to next descriptor */
1500 tx->frame_tail = lan743x_tx_next_index(tx, tx->frame_tail);
1501 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
1502 buffer_info = &tx->buffer_info[tx->frame_tail];
1503 dma_ptr = skb_frag_dma_map(dev, fragment,
1504 0, fragment_length,
1505 DMA_TO_DEVICE);
1506 if (dma_mapping_error(dev, dma_ptr)) {
1507 int desc_index;
1508
1509 /* cleanup all previously setup descriptors */
1510 desc_index = tx->frame_first;
1511 while (desc_index != tx->frame_tail) {
1512 lan743x_tx_release_desc(tx, desc_index, true);
1513 desc_index = lan743x_tx_next_index(tx, desc_index);
1514 }
1515 dma_wmb();
1516 tx->frame_flags &= ~TX_FRAME_FLAG_IN_PROGRESS;
1517 tx->frame_first = 0;
1518 tx->frame_data0 = 0;
1519 tx->frame_tail = 0;
1520 return -ENOMEM;
1521 }
1522
1523 tx_descriptor->data1 = cpu_to_le32(DMA_ADDR_LOW32(dma_ptr));
1524 tx_descriptor->data2 = cpu_to_le32(DMA_ADDR_HIGH32(dma_ptr));
1525 tx_descriptor->data3 = cpu_to_le32((frame_length << 16) &
1526 TX_DESC_DATA3_FRAME_LENGTH_MSS_MASK_);
1527
1528 buffer_info->skb = NULL;
1529 buffer_info->dma_ptr = dma_ptr;
1530 buffer_info->buffer_length = fragment_length;
1531 buffer_info->flags |= TX_BUFFER_INFO_FLAG_ACTIVE;
1532 buffer_info->flags |= TX_BUFFER_INFO_FLAG_SKB_FRAGMENT;
1533
1534 tx->frame_data0 = (fragment_length & TX_DESC_DATA0_BUF_LENGTH_MASK_) |
1535 TX_DESC_DATA0_DTYPE_DATA_ |
1536 TX_DESC_DATA0_FCS_;
1537
1538 /* data0 will be programmed in one of other frame assembler functions */
1539 return 0;
1540 }
1541
lan743x_tx_frame_end(struct lan743x_tx * tx,struct sk_buff * skb,bool time_stamp,bool ignore_sync)1542 static void lan743x_tx_frame_end(struct lan743x_tx *tx,
1543 struct sk_buff *skb,
1544 bool time_stamp,
1545 bool ignore_sync)
1546 {
1547 /* called only from within lan743x_tx_xmit_frame
1548 * assuming tx->ring_lock has already been acquired
1549 */
1550 struct lan743x_tx_descriptor *tx_descriptor = NULL;
1551 struct lan743x_tx_buffer_info *buffer_info = NULL;
1552 struct lan743x_adapter *adapter = tx->adapter;
1553 u32 tx_tail_flags = 0;
1554
1555 /* wrap up previous descriptor */
1556 if ((tx->frame_data0 & TX_DESC_DATA0_DTYPE_MASK_) ==
1557 TX_DESC_DATA0_DTYPE_DATA_) {
1558 tx->frame_data0 |= TX_DESC_DATA0_LS_;
1559 tx->frame_data0 |= TX_DESC_DATA0_IOC_;
1560 }
1561
1562 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
1563 buffer_info = &tx->buffer_info[tx->frame_tail];
1564 buffer_info->skb = skb;
1565 if (time_stamp)
1566 buffer_info->flags |= TX_BUFFER_INFO_FLAG_TIMESTAMP_REQUESTED;
1567 if (ignore_sync)
1568 buffer_info->flags |= TX_BUFFER_INFO_FLAG_IGNORE_SYNC;
1569
1570 tx_descriptor->data0 = cpu_to_le32(tx->frame_data0);
1571 tx->frame_tail = lan743x_tx_next_index(tx, tx->frame_tail);
1572 tx->last_tail = tx->frame_tail;
1573
1574 dma_wmb();
1575
1576 if (tx->vector_flags & LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET)
1577 tx_tail_flags |= TX_TAIL_SET_TOP_INT_VEC_EN_;
1578 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET)
1579 tx_tail_flags |= TX_TAIL_SET_DMAC_INT_EN_ |
1580 TX_TAIL_SET_TOP_INT_EN_;
1581
1582 lan743x_csr_write(adapter, TX_TAIL(tx->channel_number),
1583 tx_tail_flags | tx->frame_tail);
1584 tx->frame_flags &= ~TX_FRAME_FLAG_IN_PROGRESS;
1585 }
1586
lan743x_tx_xmit_frame(struct lan743x_tx * tx,struct sk_buff * skb)1587 static netdev_tx_t lan743x_tx_xmit_frame(struct lan743x_tx *tx,
1588 struct sk_buff *skb)
1589 {
1590 int required_number_of_descriptors = 0;
1591 unsigned int start_frame_length = 0;
1592 unsigned int frame_length = 0;
1593 unsigned int head_length = 0;
1594 unsigned long irq_flags = 0;
1595 bool do_timestamp = false;
1596 bool ignore_sync = false;
1597 int nr_frags = 0;
1598 bool gso = false;
1599 int j;
1600
1601 required_number_of_descriptors = lan743x_tx_get_desc_cnt(tx, skb);
1602
1603 spin_lock_irqsave(&tx->ring_lock, irq_flags);
1604 if (required_number_of_descriptors >
1605 lan743x_tx_get_avail_desc(tx)) {
1606 if (required_number_of_descriptors > (tx->ring_size - 1)) {
1607 dev_kfree_skb_irq(skb);
1608 } else {
1609 /* save to overflow buffer */
1610 tx->overflow_skb = skb;
1611 netif_stop_queue(tx->adapter->netdev);
1612 }
1613 goto unlock;
1614 }
1615
1616 /* space available, transmit skb */
1617 if ((skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
1618 (tx->ts_flags & TX_TS_FLAG_TIMESTAMPING_ENABLED) &&
1619 (lan743x_ptp_request_tx_timestamp(tx->adapter))) {
1620 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
1621 do_timestamp = true;
1622 if (tx->ts_flags & TX_TS_FLAG_ONE_STEP_SYNC)
1623 ignore_sync = true;
1624 }
1625 head_length = skb_headlen(skb);
1626 frame_length = skb_pagelen(skb);
1627 nr_frags = skb_shinfo(skb)->nr_frags;
1628 start_frame_length = frame_length;
1629 gso = skb_is_gso(skb);
1630 if (gso) {
1631 start_frame_length = max(skb_shinfo(skb)->gso_size,
1632 (unsigned short)8);
1633 }
1634
1635 if (lan743x_tx_frame_start(tx,
1636 skb->data, head_length,
1637 start_frame_length,
1638 do_timestamp,
1639 skb->ip_summed == CHECKSUM_PARTIAL)) {
1640 dev_kfree_skb_irq(skb);
1641 goto unlock;
1642 }
1643
1644 if (gso)
1645 lan743x_tx_frame_add_lso(tx, frame_length, nr_frags);
1646
1647 if (nr_frags <= 0)
1648 goto finish;
1649
1650 for (j = 0; j < nr_frags; j++) {
1651 const skb_frag_t *frag = &(skb_shinfo(skb)->frags[j]);
1652
1653 if (lan743x_tx_frame_add_fragment(tx, frag, frame_length)) {
1654 /* upon error no need to call
1655 * lan743x_tx_frame_end
1656 * frame assembler clean up was performed inside
1657 * lan743x_tx_frame_add_fragment
1658 */
1659 dev_kfree_skb_irq(skb);
1660 goto unlock;
1661 }
1662 }
1663
1664 finish:
1665 lan743x_tx_frame_end(tx, skb, do_timestamp, ignore_sync);
1666
1667 unlock:
1668 spin_unlock_irqrestore(&tx->ring_lock, irq_flags);
1669 return NETDEV_TX_OK;
1670 }
1671
lan743x_tx_napi_poll(struct napi_struct * napi,int weight)1672 static int lan743x_tx_napi_poll(struct napi_struct *napi, int weight)
1673 {
1674 struct lan743x_tx *tx = container_of(napi, struct lan743x_tx, napi);
1675 struct lan743x_adapter *adapter = tx->adapter;
1676 bool start_transmitter = false;
1677 unsigned long irq_flags = 0;
1678 u32 ioc_bit = 0;
1679
1680 ioc_bit = DMAC_INT_BIT_TX_IOC_(tx->channel_number);
1681 lan743x_csr_read(adapter, DMAC_INT_STS);
1682 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C)
1683 lan743x_csr_write(adapter, DMAC_INT_STS, ioc_bit);
1684 spin_lock_irqsave(&tx->ring_lock, irq_flags);
1685
1686 /* clean up tx ring */
1687 lan743x_tx_release_completed_descriptors(tx);
1688 if (netif_queue_stopped(adapter->netdev)) {
1689 if (tx->overflow_skb) {
1690 if (lan743x_tx_get_desc_cnt(tx, tx->overflow_skb) <=
1691 lan743x_tx_get_avail_desc(tx))
1692 start_transmitter = true;
1693 } else {
1694 netif_wake_queue(adapter->netdev);
1695 }
1696 }
1697 spin_unlock_irqrestore(&tx->ring_lock, irq_flags);
1698
1699 if (start_transmitter) {
1700 /* space is now available, transmit overflow skb */
1701 lan743x_tx_xmit_frame(tx, tx->overflow_skb);
1702 tx->overflow_skb = NULL;
1703 netif_wake_queue(adapter->netdev);
1704 }
1705
1706 if (!napi_complete(napi))
1707 goto done;
1708
1709 /* enable isr */
1710 lan743x_csr_write(adapter, INT_EN_SET,
1711 INT_BIT_DMA_TX_(tx->channel_number));
1712 lan743x_csr_read(adapter, INT_STS);
1713
1714 done:
1715 return 0;
1716 }
1717
lan743x_tx_ring_cleanup(struct lan743x_tx * tx)1718 static void lan743x_tx_ring_cleanup(struct lan743x_tx *tx)
1719 {
1720 if (tx->head_cpu_ptr) {
1721 dma_free_coherent(&tx->adapter->pdev->dev,
1722 sizeof(*tx->head_cpu_ptr), tx->head_cpu_ptr,
1723 tx->head_dma_ptr);
1724 tx->head_cpu_ptr = NULL;
1725 tx->head_dma_ptr = 0;
1726 }
1727 kfree(tx->buffer_info);
1728 tx->buffer_info = NULL;
1729
1730 if (tx->ring_cpu_ptr) {
1731 dma_free_coherent(&tx->adapter->pdev->dev,
1732 tx->ring_allocation_size, tx->ring_cpu_ptr,
1733 tx->ring_dma_ptr);
1734 tx->ring_allocation_size = 0;
1735 tx->ring_cpu_ptr = NULL;
1736 tx->ring_dma_ptr = 0;
1737 }
1738 tx->ring_size = 0;
1739 }
1740
lan743x_tx_ring_init(struct lan743x_tx * tx)1741 static int lan743x_tx_ring_init(struct lan743x_tx *tx)
1742 {
1743 size_t ring_allocation_size = 0;
1744 void *cpu_ptr = NULL;
1745 dma_addr_t dma_ptr;
1746 int ret = -ENOMEM;
1747
1748 tx->ring_size = LAN743X_TX_RING_SIZE;
1749 if (tx->ring_size & ~TX_CFG_B_TX_RING_LEN_MASK_) {
1750 ret = -EINVAL;
1751 goto cleanup;
1752 }
1753 if (dma_set_mask_and_coherent(&tx->adapter->pdev->dev,
1754 DMA_BIT_MASK(64))) {
1755 if (dma_set_mask_and_coherent(&tx->adapter->pdev->dev,
1756 DMA_BIT_MASK(32))) {
1757 dev_warn(&tx->adapter->pdev->dev,
1758 "lan743x_: No suitable DMA available\n");
1759 ret = -ENOMEM;
1760 goto cleanup;
1761 }
1762 }
1763 ring_allocation_size = ALIGN(tx->ring_size *
1764 sizeof(struct lan743x_tx_descriptor),
1765 PAGE_SIZE);
1766 dma_ptr = 0;
1767 cpu_ptr = dma_alloc_coherent(&tx->adapter->pdev->dev,
1768 ring_allocation_size, &dma_ptr, GFP_KERNEL);
1769 if (!cpu_ptr) {
1770 ret = -ENOMEM;
1771 goto cleanup;
1772 }
1773
1774 tx->ring_allocation_size = ring_allocation_size;
1775 tx->ring_cpu_ptr = (struct lan743x_tx_descriptor *)cpu_ptr;
1776 tx->ring_dma_ptr = dma_ptr;
1777
1778 cpu_ptr = kcalloc(tx->ring_size, sizeof(*tx->buffer_info), GFP_KERNEL);
1779 if (!cpu_ptr) {
1780 ret = -ENOMEM;
1781 goto cleanup;
1782 }
1783 tx->buffer_info = (struct lan743x_tx_buffer_info *)cpu_ptr;
1784 dma_ptr = 0;
1785 cpu_ptr = dma_alloc_coherent(&tx->adapter->pdev->dev,
1786 sizeof(*tx->head_cpu_ptr), &dma_ptr,
1787 GFP_KERNEL);
1788 if (!cpu_ptr) {
1789 ret = -ENOMEM;
1790 goto cleanup;
1791 }
1792
1793 tx->head_cpu_ptr = cpu_ptr;
1794 tx->head_dma_ptr = dma_ptr;
1795 if (tx->head_dma_ptr & 0x3) {
1796 ret = -ENOMEM;
1797 goto cleanup;
1798 }
1799
1800 return 0;
1801
1802 cleanup:
1803 lan743x_tx_ring_cleanup(tx);
1804 return ret;
1805 }
1806
lan743x_tx_close(struct lan743x_tx * tx)1807 static void lan743x_tx_close(struct lan743x_tx *tx)
1808 {
1809 struct lan743x_adapter *adapter = tx->adapter;
1810
1811 lan743x_csr_write(adapter,
1812 DMAC_CMD,
1813 DMAC_CMD_STOP_T_(tx->channel_number));
1814 lan743x_dmac_tx_wait_till_stopped(adapter, tx->channel_number);
1815
1816 lan743x_csr_write(adapter,
1817 DMAC_INT_EN_CLR,
1818 DMAC_INT_BIT_TX_IOC_(tx->channel_number));
1819 lan743x_csr_write(adapter, INT_EN_CLR,
1820 INT_BIT_DMA_TX_(tx->channel_number));
1821 napi_disable(&tx->napi);
1822 netif_napi_del(&tx->napi);
1823
1824 lan743x_csr_write(adapter, FCT_TX_CTL,
1825 FCT_TX_CTL_DIS_(tx->channel_number));
1826 lan743x_csr_wait_for_bit(adapter, FCT_TX_CTL,
1827 FCT_TX_CTL_EN_(tx->channel_number),
1828 0, 1000, 20000, 100);
1829
1830 lan743x_tx_release_all_descriptors(tx);
1831
1832 if (tx->overflow_skb) {
1833 dev_kfree_skb(tx->overflow_skb);
1834 tx->overflow_skb = NULL;
1835 }
1836
1837 lan743x_tx_ring_cleanup(tx);
1838 }
1839
lan743x_tx_open(struct lan743x_tx * tx)1840 static int lan743x_tx_open(struct lan743x_tx *tx)
1841 {
1842 struct lan743x_adapter *adapter = NULL;
1843 u32 data = 0;
1844 int ret;
1845
1846 adapter = tx->adapter;
1847 ret = lan743x_tx_ring_init(tx);
1848 if (ret)
1849 return ret;
1850
1851 /* initialize fifo */
1852 lan743x_csr_write(adapter, FCT_TX_CTL,
1853 FCT_TX_CTL_RESET_(tx->channel_number));
1854 lan743x_csr_wait_for_bit(adapter, FCT_TX_CTL,
1855 FCT_TX_CTL_RESET_(tx->channel_number),
1856 0, 1000, 20000, 100);
1857
1858 /* enable fifo */
1859 lan743x_csr_write(adapter, FCT_TX_CTL,
1860 FCT_TX_CTL_EN_(tx->channel_number));
1861
1862 /* reset tx channel */
1863 lan743x_csr_write(adapter, DMAC_CMD,
1864 DMAC_CMD_TX_SWR_(tx->channel_number));
1865 lan743x_csr_wait_for_bit(adapter, DMAC_CMD,
1866 DMAC_CMD_TX_SWR_(tx->channel_number),
1867 0, 1000, 20000, 100);
1868
1869 /* Write TX_BASE_ADDR */
1870 lan743x_csr_write(adapter,
1871 TX_BASE_ADDRH(tx->channel_number),
1872 DMA_ADDR_HIGH32(tx->ring_dma_ptr));
1873 lan743x_csr_write(adapter,
1874 TX_BASE_ADDRL(tx->channel_number),
1875 DMA_ADDR_LOW32(tx->ring_dma_ptr));
1876
1877 /* Write TX_CFG_B */
1878 data = lan743x_csr_read(adapter, TX_CFG_B(tx->channel_number));
1879 data &= ~TX_CFG_B_TX_RING_LEN_MASK_;
1880 data |= ((tx->ring_size) & TX_CFG_B_TX_RING_LEN_MASK_);
1881 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0))
1882 data |= TX_CFG_B_TDMABL_512_;
1883 lan743x_csr_write(adapter, TX_CFG_B(tx->channel_number), data);
1884
1885 /* Write TX_CFG_A */
1886 data = TX_CFG_A_TX_TMR_HPWB_SEL_IOC_ | TX_CFG_A_TX_HP_WB_EN_;
1887 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0)) {
1888 data |= TX_CFG_A_TX_HP_WB_ON_INT_TMR_;
1889 data |= TX_CFG_A_TX_PF_THRES_SET_(0x10);
1890 data |= TX_CFG_A_TX_PF_PRI_THRES_SET_(0x04);
1891 data |= TX_CFG_A_TX_HP_WB_THRES_SET_(0x07);
1892 }
1893 lan743x_csr_write(adapter, TX_CFG_A(tx->channel_number), data);
1894
1895 /* Write TX_HEAD_WRITEBACK_ADDR */
1896 lan743x_csr_write(adapter,
1897 TX_HEAD_WRITEBACK_ADDRH(tx->channel_number),
1898 DMA_ADDR_HIGH32(tx->head_dma_ptr));
1899 lan743x_csr_write(adapter,
1900 TX_HEAD_WRITEBACK_ADDRL(tx->channel_number),
1901 DMA_ADDR_LOW32(tx->head_dma_ptr));
1902
1903 /* set last head */
1904 tx->last_head = lan743x_csr_read(adapter, TX_HEAD(tx->channel_number));
1905
1906 /* write TX_TAIL */
1907 tx->last_tail = 0;
1908 lan743x_csr_write(adapter, TX_TAIL(tx->channel_number),
1909 (u32)(tx->last_tail));
1910 tx->vector_flags = lan743x_intr_get_vector_flags(adapter,
1911 INT_BIT_DMA_TX_
1912 (tx->channel_number));
1913 netif_tx_napi_add(adapter->netdev,
1914 &tx->napi, lan743x_tx_napi_poll,
1915 tx->ring_size - 1);
1916 napi_enable(&tx->napi);
1917
1918 data = 0;
1919 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR)
1920 data |= TX_CFG_C_TX_TOP_INT_EN_AUTO_CLR_;
1921 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR)
1922 data |= TX_CFG_C_TX_DMA_INT_STS_AUTO_CLR_;
1923 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C)
1924 data |= TX_CFG_C_TX_INT_STS_R2C_MODE_MASK_;
1925 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C)
1926 data |= TX_CFG_C_TX_INT_EN_R2C_;
1927 lan743x_csr_write(adapter, TX_CFG_C(tx->channel_number), data);
1928
1929 if (!(tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET))
1930 lan743x_csr_write(adapter, INT_EN_SET,
1931 INT_BIT_DMA_TX_(tx->channel_number));
1932 lan743x_csr_write(adapter, DMAC_INT_EN_SET,
1933 DMAC_INT_BIT_TX_IOC_(tx->channel_number));
1934
1935 /* start dmac channel */
1936 lan743x_csr_write(adapter, DMAC_CMD,
1937 DMAC_CMD_START_T_(tx->channel_number));
1938 return 0;
1939 }
1940
lan743x_rx_next_index(struct lan743x_rx * rx,int index)1941 static int lan743x_rx_next_index(struct lan743x_rx *rx, int index)
1942 {
1943 return ((++index) % rx->ring_size);
1944 }
1945
lan743x_rx_update_tail(struct lan743x_rx * rx,int index)1946 static void lan743x_rx_update_tail(struct lan743x_rx *rx, int index)
1947 {
1948 /* update the tail once per 8 descriptors */
1949 if ((index & 7) == 7)
1950 lan743x_csr_write(rx->adapter, RX_TAIL(rx->channel_number),
1951 index);
1952 }
1953
lan743x_rx_init_ring_element(struct lan743x_rx * rx,int index,gfp_t gfp)1954 static int lan743x_rx_init_ring_element(struct lan743x_rx *rx, int index,
1955 gfp_t gfp)
1956 {
1957 struct net_device *netdev = rx->adapter->netdev;
1958 struct device *dev = &rx->adapter->pdev->dev;
1959 struct lan743x_rx_buffer_info *buffer_info;
1960 unsigned int buffer_length, used_length;
1961 struct lan743x_rx_descriptor *descriptor;
1962 struct sk_buff *skb;
1963 dma_addr_t dma_ptr;
1964
1965 buffer_length = netdev->mtu + ETH_HLEN + ETH_FCS_LEN + RX_HEAD_PADDING;
1966
1967 descriptor = &rx->ring_cpu_ptr[index];
1968 buffer_info = &rx->buffer_info[index];
1969 skb = __netdev_alloc_skb(netdev, buffer_length, gfp);
1970 if (!skb)
1971 return -ENOMEM;
1972 dma_ptr = dma_map_single(dev, skb->data, buffer_length, DMA_FROM_DEVICE);
1973 if (dma_mapping_error(dev, dma_ptr)) {
1974 dev_kfree_skb_any(skb);
1975 return -ENOMEM;
1976 }
1977 if (buffer_info->dma_ptr) {
1978 /* sync used area of buffer only */
1979 if (le32_to_cpu(descriptor->data0) & RX_DESC_DATA0_LS_)
1980 /* frame length is valid only if LS bit is set.
1981 * it's a safe upper bound for the used area in this
1982 * buffer.
1983 */
1984 used_length = min(RX_DESC_DATA0_FRAME_LENGTH_GET_
1985 (le32_to_cpu(descriptor->data0)),
1986 buffer_info->buffer_length);
1987 else
1988 used_length = buffer_info->buffer_length;
1989 dma_sync_single_for_cpu(dev, buffer_info->dma_ptr,
1990 used_length,
1991 DMA_FROM_DEVICE);
1992 dma_unmap_single_attrs(dev, buffer_info->dma_ptr,
1993 buffer_info->buffer_length,
1994 DMA_FROM_DEVICE,
1995 DMA_ATTR_SKIP_CPU_SYNC);
1996 }
1997
1998 buffer_info->skb = skb;
1999 buffer_info->dma_ptr = dma_ptr;
2000 buffer_info->buffer_length = buffer_length;
2001 descriptor->data1 = cpu_to_le32(DMA_ADDR_LOW32(buffer_info->dma_ptr));
2002 descriptor->data2 = cpu_to_le32(DMA_ADDR_HIGH32(buffer_info->dma_ptr));
2003 descriptor->data3 = 0;
2004 descriptor->data0 = cpu_to_le32((RX_DESC_DATA0_OWN_ |
2005 (buffer_length & RX_DESC_DATA0_BUF_LENGTH_MASK_)));
2006 lan743x_rx_update_tail(rx, index);
2007
2008 return 0;
2009 }
2010
lan743x_rx_reuse_ring_element(struct lan743x_rx * rx,int index)2011 static void lan743x_rx_reuse_ring_element(struct lan743x_rx *rx, int index)
2012 {
2013 struct lan743x_rx_buffer_info *buffer_info;
2014 struct lan743x_rx_descriptor *descriptor;
2015
2016 descriptor = &rx->ring_cpu_ptr[index];
2017 buffer_info = &rx->buffer_info[index];
2018
2019 descriptor->data1 = cpu_to_le32(DMA_ADDR_LOW32(buffer_info->dma_ptr));
2020 descriptor->data2 = cpu_to_le32(DMA_ADDR_HIGH32(buffer_info->dma_ptr));
2021 descriptor->data3 = 0;
2022 descriptor->data0 = cpu_to_le32((RX_DESC_DATA0_OWN_ |
2023 ((buffer_info->buffer_length) &
2024 RX_DESC_DATA0_BUF_LENGTH_MASK_)));
2025 lan743x_rx_update_tail(rx, index);
2026 }
2027
lan743x_rx_release_ring_element(struct lan743x_rx * rx,int index)2028 static void lan743x_rx_release_ring_element(struct lan743x_rx *rx, int index)
2029 {
2030 struct lan743x_rx_buffer_info *buffer_info;
2031 struct lan743x_rx_descriptor *descriptor;
2032
2033 descriptor = &rx->ring_cpu_ptr[index];
2034 buffer_info = &rx->buffer_info[index];
2035
2036 memset(descriptor, 0, sizeof(*descriptor));
2037
2038 if (buffer_info->dma_ptr) {
2039 dma_unmap_single(&rx->adapter->pdev->dev,
2040 buffer_info->dma_ptr,
2041 buffer_info->buffer_length,
2042 DMA_FROM_DEVICE);
2043 buffer_info->dma_ptr = 0;
2044 }
2045
2046 if (buffer_info->skb) {
2047 dev_kfree_skb(buffer_info->skb);
2048 buffer_info->skb = NULL;
2049 }
2050
2051 memset(buffer_info, 0, sizeof(*buffer_info));
2052 }
2053
2054 static struct sk_buff *
lan743x_rx_trim_skb(struct sk_buff * skb,int frame_length)2055 lan743x_rx_trim_skb(struct sk_buff *skb, int frame_length)
2056 {
2057 if (skb_linearize(skb)) {
2058 dev_kfree_skb_irq(skb);
2059 return NULL;
2060 }
2061 frame_length = max_t(int, 0, frame_length - ETH_FCS_LEN);
2062 if (skb->len > frame_length) {
2063 skb->tail -= skb->len - frame_length;
2064 skb->len = frame_length;
2065 }
2066 return skb;
2067 }
2068
lan743x_rx_process_buffer(struct lan743x_rx * rx)2069 static int lan743x_rx_process_buffer(struct lan743x_rx *rx)
2070 {
2071 int current_head_index = le32_to_cpu(*rx->head_cpu_ptr);
2072 struct lan743x_rx_descriptor *descriptor, *desc_ext;
2073 struct net_device *netdev = rx->adapter->netdev;
2074 int result = RX_PROCESS_RESULT_NOTHING_TO_DO;
2075 struct lan743x_rx_buffer_info *buffer_info;
2076 int frame_length, buffer_length;
2077 int extension_index = -1;
2078 bool is_last, is_first;
2079 struct sk_buff *skb;
2080
2081 if (current_head_index < 0 || current_head_index >= rx->ring_size)
2082 goto done;
2083
2084 if (rx->last_head < 0 || rx->last_head >= rx->ring_size)
2085 goto done;
2086
2087 if (rx->last_head == current_head_index)
2088 goto done;
2089
2090 descriptor = &rx->ring_cpu_ptr[rx->last_head];
2091 if (le32_to_cpu(descriptor->data0) & RX_DESC_DATA0_OWN_)
2092 goto done;
2093 buffer_info = &rx->buffer_info[rx->last_head];
2094
2095 is_last = le32_to_cpu(descriptor->data0) & RX_DESC_DATA0_LS_;
2096 is_first = le32_to_cpu(descriptor->data0) & RX_DESC_DATA0_FS_;
2097
2098 if (is_last && le32_to_cpu(descriptor->data0) & RX_DESC_DATA0_EXT_) {
2099 /* extension is expected to follow */
2100 int index = lan743x_rx_next_index(rx, rx->last_head);
2101
2102 if (index == current_head_index)
2103 /* extension not yet available */
2104 goto done;
2105 desc_ext = &rx->ring_cpu_ptr[index];
2106 if (le32_to_cpu(desc_ext->data0) & RX_DESC_DATA0_OWN_)
2107 /* extension not yet available */
2108 goto done;
2109 if (!(le32_to_cpu(desc_ext->data0) & RX_DESC_DATA0_EXT_))
2110 goto move_forward;
2111 extension_index = index;
2112 }
2113
2114 /* Only the last buffer in a multi-buffer frame contains the total frame
2115 * length. The chip occasionally sends more buffers than strictly
2116 * required to reach the total frame length.
2117 * Handle this by adding all buffers to the skb in their entirety.
2118 * Once the real frame length is known, trim the skb.
2119 */
2120 frame_length =
2121 RX_DESC_DATA0_FRAME_LENGTH_GET_(le32_to_cpu(descriptor->data0));
2122 buffer_length = buffer_info->buffer_length;
2123
2124 netdev_dbg(netdev, "%s%schunk: %d/%d",
2125 is_first ? "first " : " ",
2126 is_last ? "last " : " ",
2127 frame_length, buffer_length);
2128
2129 /* save existing skb, allocate new skb and map to dma */
2130 skb = buffer_info->skb;
2131 if (lan743x_rx_init_ring_element(rx, rx->last_head,
2132 GFP_ATOMIC | GFP_DMA)) {
2133 /* failed to allocate next skb.
2134 * Memory is very low.
2135 * Drop this packet and reuse buffer.
2136 */
2137 lan743x_rx_reuse_ring_element(rx, rx->last_head);
2138 /* drop packet that was being assembled */
2139 dev_kfree_skb_irq(rx->skb_head);
2140 rx->skb_head = NULL;
2141 goto process_extension;
2142 }
2143
2144 /* add buffers to skb via skb->frag_list */
2145 if (is_first) {
2146 skb_reserve(skb, RX_HEAD_PADDING);
2147 skb_put(skb, buffer_length - RX_HEAD_PADDING);
2148 if (rx->skb_head)
2149 dev_kfree_skb_irq(rx->skb_head);
2150 rx->skb_head = skb;
2151 } else if (rx->skb_head) {
2152 skb_put(skb, buffer_length);
2153 if (skb_shinfo(rx->skb_head)->frag_list)
2154 rx->skb_tail->next = skb;
2155 else
2156 skb_shinfo(rx->skb_head)->frag_list = skb;
2157 rx->skb_tail = skb;
2158 rx->skb_head->len += skb->len;
2159 rx->skb_head->data_len += skb->len;
2160 rx->skb_head->truesize += skb->truesize;
2161 } else {
2162 /* packet to assemble has already been dropped because one or
2163 * more of its buffers could not be allocated
2164 */
2165 netdev_dbg(netdev, "drop buffer intended for dropped packet");
2166 dev_kfree_skb_irq(skb);
2167 }
2168
2169 process_extension:
2170 if (extension_index >= 0) {
2171 u32 ts_sec;
2172 u32 ts_nsec;
2173
2174 ts_sec = le32_to_cpu(desc_ext->data1);
2175 ts_nsec = (le32_to_cpu(desc_ext->data2) &
2176 RX_DESC_DATA2_TS_NS_MASK_);
2177 if (rx->skb_head)
2178 skb_hwtstamps(rx->skb_head)->hwtstamp =
2179 ktime_set(ts_sec, ts_nsec);
2180 lan743x_rx_reuse_ring_element(rx, extension_index);
2181 rx->last_head = extension_index;
2182 netdev_dbg(netdev, "process extension");
2183 }
2184
2185 if (is_last && rx->skb_head)
2186 rx->skb_head = lan743x_rx_trim_skb(rx->skb_head, frame_length);
2187
2188 if (is_last && rx->skb_head) {
2189 rx->skb_head->protocol = eth_type_trans(rx->skb_head,
2190 rx->adapter->netdev);
2191 netdev_dbg(netdev, "sending %d byte frame to OS",
2192 rx->skb_head->len);
2193 napi_gro_receive(&rx->napi, rx->skb_head);
2194 rx->skb_head = NULL;
2195 }
2196
2197 move_forward:
2198 /* push tail and head forward */
2199 rx->last_tail = rx->last_head;
2200 rx->last_head = lan743x_rx_next_index(rx, rx->last_head);
2201 result = RX_PROCESS_RESULT_BUFFER_RECEIVED;
2202 done:
2203 return result;
2204 }
2205
lan743x_rx_napi_poll(struct napi_struct * napi,int weight)2206 static int lan743x_rx_napi_poll(struct napi_struct *napi, int weight)
2207 {
2208 struct lan743x_rx *rx = container_of(napi, struct lan743x_rx, napi);
2209 struct lan743x_adapter *adapter = rx->adapter;
2210 int result = RX_PROCESS_RESULT_NOTHING_TO_DO;
2211 u32 rx_tail_flags = 0;
2212 int count;
2213
2214 if (rx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C) {
2215 /* clear int status bit before reading packet */
2216 lan743x_csr_write(adapter, DMAC_INT_STS,
2217 DMAC_INT_BIT_RXFRM_(rx->channel_number));
2218 }
2219 for (count = 0; count < weight; count++) {
2220 result = lan743x_rx_process_buffer(rx);
2221 if (result == RX_PROCESS_RESULT_NOTHING_TO_DO)
2222 break;
2223 }
2224 rx->frame_count += count;
2225 if (count == weight || result == RX_PROCESS_RESULT_BUFFER_RECEIVED)
2226 return weight;
2227
2228 if (!napi_complete_done(napi, count))
2229 return count;
2230
2231 /* re-arm interrupts, must write to rx tail on some chip variants */
2232 if (rx->vector_flags & LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET)
2233 rx_tail_flags |= RX_TAIL_SET_TOP_INT_VEC_EN_;
2234 if (rx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET) {
2235 rx_tail_flags |= RX_TAIL_SET_TOP_INT_EN_;
2236 } else {
2237 lan743x_csr_write(adapter, INT_EN_SET,
2238 INT_BIT_DMA_RX_(rx->channel_number));
2239 }
2240
2241 if (rx_tail_flags)
2242 lan743x_csr_write(adapter, RX_TAIL(rx->channel_number),
2243 rx_tail_flags | rx->last_tail);
2244
2245 return count;
2246 }
2247
lan743x_rx_ring_cleanup(struct lan743x_rx * rx)2248 static void lan743x_rx_ring_cleanup(struct lan743x_rx *rx)
2249 {
2250 if (rx->buffer_info && rx->ring_cpu_ptr) {
2251 int index;
2252
2253 for (index = 0; index < rx->ring_size; index++)
2254 lan743x_rx_release_ring_element(rx, index);
2255 }
2256
2257 if (rx->head_cpu_ptr) {
2258 dma_free_coherent(&rx->adapter->pdev->dev,
2259 sizeof(*rx->head_cpu_ptr), rx->head_cpu_ptr,
2260 rx->head_dma_ptr);
2261 rx->head_cpu_ptr = NULL;
2262 rx->head_dma_ptr = 0;
2263 }
2264
2265 kfree(rx->buffer_info);
2266 rx->buffer_info = NULL;
2267
2268 if (rx->ring_cpu_ptr) {
2269 dma_free_coherent(&rx->adapter->pdev->dev,
2270 rx->ring_allocation_size, rx->ring_cpu_ptr,
2271 rx->ring_dma_ptr);
2272 rx->ring_allocation_size = 0;
2273 rx->ring_cpu_ptr = NULL;
2274 rx->ring_dma_ptr = 0;
2275 }
2276
2277 rx->ring_size = 0;
2278 rx->last_head = 0;
2279 }
2280
lan743x_rx_ring_init(struct lan743x_rx * rx)2281 static int lan743x_rx_ring_init(struct lan743x_rx *rx)
2282 {
2283 size_t ring_allocation_size = 0;
2284 dma_addr_t dma_ptr = 0;
2285 void *cpu_ptr = NULL;
2286 int ret = -ENOMEM;
2287 int index = 0;
2288
2289 rx->ring_size = LAN743X_RX_RING_SIZE;
2290 if (rx->ring_size <= 1) {
2291 ret = -EINVAL;
2292 goto cleanup;
2293 }
2294 if (rx->ring_size & ~RX_CFG_B_RX_RING_LEN_MASK_) {
2295 ret = -EINVAL;
2296 goto cleanup;
2297 }
2298 if (dma_set_mask_and_coherent(&rx->adapter->pdev->dev,
2299 DMA_BIT_MASK(64))) {
2300 if (dma_set_mask_and_coherent(&rx->adapter->pdev->dev,
2301 DMA_BIT_MASK(32))) {
2302 dev_warn(&rx->adapter->pdev->dev,
2303 "lan743x_: No suitable DMA available\n");
2304 ret = -ENOMEM;
2305 goto cleanup;
2306 }
2307 }
2308 ring_allocation_size = ALIGN(rx->ring_size *
2309 sizeof(struct lan743x_rx_descriptor),
2310 PAGE_SIZE);
2311 dma_ptr = 0;
2312 cpu_ptr = dma_alloc_coherent(&rx->adapter->pdev->dev,
2313 ring_allocation_size, &dma_ptr, GFP_KERNEL);
2314 if (!cpu_ptr) {
2315 ret = -ENOMEM;
2316 goto cleanup;
2317 }
2318 rx->ring_allocation_size = ring_allocation_size;
2319 rx->ring_cpu_ptr = (struct lan743x_rx_descriptor *)cpu_ptr;
2320 rx->ring_dma_ptr = dma_ptr;
2321
2322 cpu_ptr = kcalloc(rx->ring_size, sizeof(*rx->buffer_info),
2323 GFP_KERNEL);
2324 if (!cpu_ptr) {
2325 ret = -ENOMEM;
2326 goto cleanup;
2327 }
2328 rx->buffer_info = (struct lan743x_rx_buffer_info *)cpu_ptr;
2329 dma_ptr = 0;
2330 cpu_ptr = dma_alloc_coherent(&rx->adapter->pdev->dev,
2331 sizeof(*rx->head_cpu_ptr), &dma_ptr,
2332 GFP_KERNEL);
2333 if (!cpu_ptr) {
2334 ret = -ENOMEM;
2335 goto cleanup;
2336 }
2337
2338 rx->head_cpu_ptr = cpu_ptr;
2339 rx->head_dma_ptr = dma_ptr;
2340 if (rx->head_dma_ptr & 0x3) {
2341 ret = -ENOMEM;
2342 goto cleanup;
2343 }
2344
2345 rx->last_head = 0;
2346 for (index = 0; index < rx->ring_size; index++) {
2347 ret = lan743x_rx_init_ring_element(rx, index, GFP_KERNEL);
2348 if (ret)
2349 goto cleanup;
2350 }
2351 return 0;
2352
2353 cleanup:
2354 netif_warn(rx->adapter, ifup, rx->adapter->netdev,
2355 "Error allocating memory for LAN743x\n");
2356
2357 lan743x_rx_ring_cleanup(rx);
2358 return ret;
2359 }
2360
lan743x_rx_close(struct lan743x_rx * rx)2361 static void lan743x_rx_close(struct lan743x_rx *rx)
2362 {
2363 struct lan743x_adapter *adapter = rx->adapter;
2364
2365 lan743x_csr_write(adapter, FCT_RX_CTL,
2366 FCT_RX_CTL_DIS_(rx->channel_number));
2367 lan743x_csr_wait_for_bit(adapter, FCT_RX_CTL,
2368 FCT_RX_CTL_EN_(rx->channel_number),
2369 0, 1000, 20000, 100);
2370
2371 lan743x_csr_write(adapter, DMAC_CMD,
2372 DMAC_CMD_STOP_R_(rx->channel_number));
2373 lan743x_dmac_rx_wait_till_stopped(adapter, rx->channel_number);
2374
2375 lan743x_csr_write(adapter, DMAC_INT_EN_CLR,
2376 DMAC_INT_BIT_RXFRM_(rx->channel_number));
2377 lan743x_csr_write(adapter, INT_EN_CLR,
2378 INT_BIT_DMA_RX_(rx->channel_number));
2379 napi_disable(&rx->napi);
2380
2381 netif_napi_del(&rx->napi);
2382
2383 lan743x_rx_ring_cleanup(rx);
2384 }
2385
lan743x_rx_open(struct lan743x_rx * rx)2386 static int lan743x_rx_open(struct lan743x_rx *rx)
2387 {
2388 struct lan743x_adapter *adapter = rx->adapter;
2389 u32 data = 0;
2390 int ret;
2391
2392 rx->frame_count = 0;
2393 ret = lan743x_rx_ring_init(rx);
2394 if (ret)
2395 goto return_error;
2396
2397 netif_napi_add(adapter->netdev,
2398 &rx->napi, lan743x_rx_napi_poll,
2399 NAPI_POLL_WEIGHT);
2400
2401 lan743x_csr_write(adapter, DMAC_CMD,
2402 DMAC_CMD_RX_SWR_(rx->channel_number));
2403 lan743x_csr_wait_for_bit(adapter, DMAC_CMD,
2404 DMAC_CMD_RX_SWR_(rx->channel_number),
2405 0, 1000, 20000, 100);
2406
2407 /* set ring base address */
2408 lan743x_csr_write(adapter,
2409 RX_BASE_ADDRH(rx->channel_number),
2410 DMA_ADDR_HIGH32(rx->ring_dma_ptr));
2411 lan743x_csr_write(adapter,
2412 RX_BASE_ADDRL(rx->channel_number),
2413 DMA_ADDR_LOW32(rx->ring_dma_ptr));
2414
2415 /* set rx write back address */
2416 lan743x_csr_write(adapter,
2417 RX_HEAD_WRITEBACK_ADDRH(rx->channel_number),
2418 DMA_ADDR_HIGH32(rx->head_dma_ptr));
2419 lan743x_csr_write(adapter,
2420 RX_HEAD_WRITEBACK_ADDRL(rx->channel_number),
2421 DMA_ADDR_LOW32(rx->head_dma_ptr));
2422 data = RX_CFG_A_RX_HP_WB_EN_;
2423 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0)) {
2424 data |= (RX_CFG_A_RX_WB_ON_INT_TMR_ |
2425 RX_CFG_A_RX_WB_THRES_SET_(0x7) |
2426 RX_CFG_A_RX_PF_THRES_SET_(16) |
2427 RX_CFG_A_RX_PF_PRI_THRES_SET_(4));
2428 }
2429
2430 /* set RX_CFG_A */
2431 lan743x_csr_write(adapter,
2432 RX_CFG_A(rx->channel_number), data);
2433
2434 /* set RX_CFG_B */
2435 data = lan743x_csr_read(adapter, RX_CFG_B(rx->channel_number));
2436 data &= ~RX_CFG_B_RX_PAD_MASK_;
2437 if (!RX_HEAD_PADDING)
2438 data |= RX_CFG_B_RX_PAD_0_;
2439 else
2440 data |= RX_CFG_B_RX_PAD_2_;
2441 data &= ~RX_CFG_B_RX_RING_LEN_MASK_;
2442 data |= ((rx->ring_size) & RX_CFG_B_RX_RING_LEN_MASK_);
2443 data |= RX_CFG_B_TS_ALL_RX_;
2444 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0))
2445 data |= RX_CFG_B_RDMABL_512_;
2446
2447 lan743x_csr_write(adapter, RX_CFG_B(rx->channel_number), data);
2448 rx->vector_flags = lan743x_intr_get_vector_flags(adapter,
2449 INT_BIT_DMA_RX_
2450 (rx->channel_number));
2451
2452 /* set RX_CFG_C */
2453 data = 0;
2454 if (rx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR)
2455 data |= RX_CFG_C_RX_TOP_INT_EN_AUTO_CLR_;
2456 if (rx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR)
2457 data |= RX_CFG_C_RX_DMA_INT_STS_AUTO_CLR_;
2458 if (rx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C)
2459 data |= RX_CFG_C_RX_INT_STS_R2C_MODE_MASK_;
2460 if (rx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C)
2461 data |= RX_CFG_C_RX_INT_EN_R2C_;
2462 lan743x_csr_write(adapter, RX_CFG_C(rx->channel_number), data);
2463
2464 rx->last_tail = ((u32)(rx->ring_size - 1));
2465 lan743x_csr_write(adapter, RX_TAIL(rx->channel_number),
2466 rx->last_tail);
2467 rx->last_head = lan743x_csr_read(adapter, RX_HEAD(rx->channel_number));
2468 if (rx->last_head) {
2469 ret = -EIO;
2470 goto napi_delete;
2471 }
2472
2473 napi_enable(&rx->napi);
2474
2475 lan743x_csr_write(adapter, INT_EN_SET,
2476 INT_BIT_DMA_RX_(rx->channel_number));
2477 lan743x_csr_write(adapter, DMAC_INT_STS,
2478 DMAC_INT_BIT_RXFRM_(rx->channel_number));
2479 lan743x_csr_write(adapter, DMAC_INT_EN_SET,
2480 DMAC_INT_BIT_RXFRM_(rx->channel_number));
2481 lan743x_csr_write(adapter, DMAC_CMD,
2482 DMAC_CMD_START_R_(rx->channel_number));
2483
2484 /* initialize fifo */
2485 lan743x_csr_write(adapter, FCT_RX_CTL,
2486 FCT_RX_CTL_RESET_(rx->channel_number));
2487 lan743x_csr_wait_for_bit(adapter, FCT_RX_CTL,
2488 FCT_RX_CTL_RESET_(rx->channel_number),
2489 0, 1000, 20000, 100);
2490 lan743x_csr_write(adapter, FCT_FLOW(rx->channel_number),
2491 FCT_FLOW_CTL_REQ_EN_ |
2492 FCT_FLOW_CTL_ON_THRESHOLD_SET_(0x2A) |
2493 FCT_FLOW_CTL_OFF_THRESHOLD_SET_(0xA));
2494
2495 /* enable fifo */
2496 lan743x_csr_write(adapter, FCT_RX_CTL,
2497 FCT_RX_CTL_EN_(rx->channel_number));
2498 return 0;
2499
2500 napi_delete:
2501 netif_napi_del(&rx->napi);
2502 lan743x_rx_ring_cleanup(rx);
2503
2504 return_error:
2505 return ret;
2506 }
2507
lan743x_netdev_close(struct net_device * netdev)2508 static int lan743x_netdev_close(struct net_device *netdev)
2509 {
2510 struct lan743x_adapter *adapter = netdev_priv(netdev);
2511 int index;
2512
2513 lan743x_tx_close(&adapter->tx[0]);
2514
2515 for (index = 0; index < LAN743X_USED_RX_CHANNELS; index++)
2516 lan743x_rx_close(&adapter->rx[index]);
2517
2518 lan743x_ptp_close(adapter);
2519
2520 lan743x_phy_close(adapter);
2521
2522 lan743x_mac_close(adapter);
2523
2524 lan743x_intr_close(adapter);
2525
2526 return 0;
2527 }
2528
lan743x_netdev_open(struct net_device * netdev)2529 static int lan743x_netdev_open(struct net_device *netdev)
2530 {
2531 struct lan743x_adapter *adapter = netdev_priv(netdev);
2532 int index;
2533 int ret;
2534
2535 ret = lan743x_intr_open(adapter);
2536 if (ret)
2537 goto return_error;
2538
2539 ret = lan743x_mac_open(adapter);
2540 if (ret)
2541 goto close_intr;
2542
2543 ret = lan743x_phy_open(adapter);
2544 if (ret)
2545 goto close_mac;
2546
2547 ret = lan743x_ptp_open(adapter);
2548 if (ret)
2549 goto close_phy;
2550
2551 lan743x_rfe_open(adapter);
2552
2553 for (index = 0; index < LAN743X_USED_RX_CHANNELS; index++) {
2554 ret = lan743x_rx_open(&adapter->rx[index]);
2555 if (ret)
2556 goto close_rx;
2557 }
2558
2559 ret = lan743x_tx_open(&adapter->tx[0]);
2560 if (ret)
2561 goto close_rx;
2562
2563 return 0;
2564
2565 close_rx:
2566 for (index = 0; index < LAN743X_USED_RX_CHANNELS; index++) {
2567 if (adapter->rx[index].ring_cpu_ptr)
2568 lan743x_rx_close(&adapter->rx[index]);
2569 }
2570 lan743x_ptp_close(adapter);
2571
2572 close_phy:
2573 lan743x_phy_close(adapter);
2574
2575 close_mac:
2576 lan743x_mac_close(adapter);
2577
2578 close_intr:
2579 lan743x_intr_close(adapter);
2580
2581 return_error:
2582 netif_warn(adapter, ifup, adapter->netdev,
2583 "Error opening LAN743x\n");
2584 return ret;
2585 }
2586
lan743x_netdev_xmit_frame(struct sk_buff * skb,struct net_device * netdev)2587 static netdev_tx_t lan743x_netdev_xmit_frame(struct sk_buff *skb,
2588 struct net_device *netdev)
2589 {
2590 struct lan743x_adapter *adapter = netdev_priv(netdev);
2591
2592 return lan743x_tx_xmit_frame(&adapter->tx[0], skb);
2593 }
2594
lan743x_netdev_ioctl(struct net_device * netdev,struct ifreq * ifr,int cmd)2595 static int lan743x_netdev_ioctl(struct net_device *netdev,
2596 struct ifreq *ifr, int cmd)
2597 {
2598 if (!netif_running(netdev))
2599 return -EINVAL;
2600 if (cmd == SIOCSHWTSTAMP)
2601 return lan743x_ptp_ioctl(netdev, ifr, cmd);
2602 return phy_mii_ioctl(netdev->phydev, ifr, cmd);
2603 }
2604
lan743x_netdev_set_multicast(struct net_device * netdev)2605 static void lan743x_netdev_set_multicast(struct net_device *netdev)
2606 {
2607 struct lan743x_adapter *adapter = netdev_priv(netdev);
2608
2609 lan743x_rfe_set_multicast(adapter);
2610 }
2611
lan743x_netdev_change_mtu(struct net_device * netdev,int new_mtu)2612 static int lan743x_netdev_change_mtu(struct net_device *netdev, int new_mtu)
2613 {
2614 struct lan743x_adapter *adapter = netdev_priv(netdev);
2615 int ret = 0;
2616
2617 ret = lan743x_mac_set_mtu(adapter, new_mtu);
2618 if (!ret)
2619 netdev->mtu = new_mtu;
2620 return ret;
2621 }
2622
lan743x_netdev_get_stats64(struct net_device * netdev,struct rtnl_link_stats64 * stats)2623 static void lan743x_netdev_get_stats64(struct net_device *netdev,
2624 struct rtnl_link_stats64 *stats)
2625 {
2626 struct lan743x_adapter *adapter = netdev_priv(netdev);
2627
2628 stats->rx_packets = lan743x_csr_read(adapter, STAT_RX_TOTAL_FRAMES);
2629 stats->tx_packets = lan743x_csr_read(adapter, STAT_TX_TOTAL_FRAMES);
2630 stats->rx_bytes = lan743x_csr_read(adapter,
2631 STAT_RX_UNICAST_BYTE_COUNT) +
2632 lan743x_csr_read(adapter,
2633 STAT_RX_BROADCAST_BYTE_COUNT) +
2634 lan743x_csr_read(adapter,
2635 STAT_RX_MULTICAST_BYTE_COUNT);
2636 stats->tx_bytes = lan743x_csr_read(adapter,
2637 STAT_TX_UNICAST_BYTE_COUNT) +
2638 lan743x_csr_read(adapter,
2639 STAT_TX_BROADCAST_BYTE_COUNT) +
2640 lan743x_csr_read(adapter,
2641 STAT_TX_MULTICAST_BYTE_COUNT);
2642 stats->rx_errors = lan743x_csr_read(adapter, STAT_RX_FCS_ERRORS) +
2643 lan743x_csr_read(adapter,
2644 STAT_RX_ALIGNMENT_ERRORS) +
2645 lan743x_csr_read(adapter, STAT_RX_JABBER_ERRORS) +
2646 lan743x_csr_read(adapter,
2647 STAT_RX_UNDERSIZE_FRAME_ERRORS) +
2648 lan743x_csr_read(adapter,
2649 STAT_RX_OVERSIZE_FRAME_ERRORS);
2650 stats->tx_errors = lan743x_csr_read(adapter, STAT_TX_FCS_ERRORS) +
2651 lan743x_csr_read(adapter,
2652 STAT_TX_EXCESS_DEFERRAL_ERRORS) +
2653 lan743x_csr_read(adapter, STAT_TX_CARRIER_ERRORS);
2654 stats->rx_dropped = lan743x_csr_read(adapter,
2655 STAT_RX_DROPPED_FRAMES);
2656 stats->tx_dropped = lan743x_csr_read(adapter,
2657 STAT_TX_EXCESSIVE_COLLISION);
2658 stats->multicast = lan743x_csr_read(adapter,
2659 STAT_RX_MULTICAST_FRAMES) +
2660 lan743x_csr_read(adapter,
2661 STAT_TX_MULTICAST_FRAMES);
2662 stats->collisions = lan743x_csr_read(adapter,
2663 STAT_TX_SINGLE_COLLISIONS) +
2664 lan743x_csr_read(adapter,
2665 STAT_TX_MULTIPLE_COLLISIONS) +
2666 lan743x_csr_read(adapter,
2667 STAT_TX_LATE_COLLISIONS);
2668 }
2669
lan743x_netdev_set_mac_address(struct net_device * netdev,void * addr)2670 static int lan743x_netdev_set_mac_address(struct net_device *netdev,
2671 void *addr)
2672 {
2673 struct lan743x_adapter *adapter = netdev_priv(netdev);
2674 struct sockaddr *sock_addr = addr;
2675 int ret;
2676
2677 ret = eth_prepare_mac_addr_change(netdev, sock_addr);
2678 if (ret)
2679 return ret;
2680 eth_hw_addr_set(netdev, sock_addr->sa_data);
2681 lan743x_mac_set_address(adapter, sock_addr->sa_data);
2682 lan743x_rfe_update_mac_address(adapter);
2683 return 0;
2684 }
2685
2686 static const struct net_device_ops lan743x_netdev_ops = {
2687 .ndo_open = lan743x_netdev_open,
2688 .ndo_stop = lan743x_netdev_close,
2689 .ndo_start_xmit = lan743x_netdev_xmit_frame,
2690 .ndo_eth_ioctl = lan743x_netdev_ioctl,
2691 .ndo_set_rx_mode = lan743x_netdev_set_multicast,
2692 .ndo_change_mtu = lan743x_netdev_change_mtu,
2693 .ndo_get_stats64 = lan743x_netdev_get_stats64,
2694 .ndo_set_mac_address = lan743x_netdev_set_mac_address,
2695 };
2696
lan743x_hardware_cleanup(struct lan743x_adapter * adapter)2697 static void lan743x_hardware_cleanup(struct lan743x_adapter *adapter)
2698 {
2699 lan743x_csr_write(adapter, INT_EN_CLR, 0xFFFFFFFF);
2700 }
2701
lan743x_mdiobus_cleanup(struct lan743x_adapter * adapter)2702 static void lan743x_mdiobus_cleanup(struct lan743x_adapter *adapter)
2703 {
2704 mdiobus_unregister(adapter->mdiobus);
2705 }
2706
lan743x_full_cleanup(struct lan743x_adapter * adapter)2707 static void lan743x_full_cleanup(struct lan743x_adapter *adapter)
2708 {
2709 unregister_netdev(adapter->netdev);
2710
2711 lan743x_mdiobus_cleanup(adapter);
2712 lan743x_hardware_cleanup(adapter);
2713 lan743x_pci_cleanup(adapter);
2714 }
2715
lan743x_hardware_init(struct lan743x_adapter * adapter,struct pci_dev * pdev)2716 static int lan743x_hardware_init(struct lan743x_adapter *adapter,
2717 struct pci_dev *pdev)
2718 {
2719 struct lan743x_tx *tx;
2720 int index;
2721 int ret;
2722
2723 adapter->intr.irq = adapter->pdev->irq;
2724 lan743x_csr_write(adapter, INT_EN_CLR, 0xFFFFFFFF);
2725
2726 ret = lan743x_gpio_init(adapter);
2727 if (ret)
2728 return ret;
2729
2730 ret = lan743x_mac_init(adapter);
2731 if (ret)
2732 return ret;
2733
2734 ret = lan743x_phy_init(adapter);
2735 if (ret)
2736 return ret;
2737
2738 ret = lan743x_ptp_init(adapter);
2739 if (ret)
2740 return ret;
2741
2742 lan743x_rfe_update_mac_address(adapter);
2743
2744 ret = lan743x_dmac_init(adapter);
2745 if (ret)
2746 return ret;
2747
2748 for (index = 0; index < LAN743X_USED_RX_CHANNELS; index++) {
2749 adapter->rx[index].adapter = adapter;
2750 adapter->rx[index].channel_number = index;
2751 }
2752
2753 tx = &adapter->tx[0];
2754 tx->adapter = adapter;
2755 tx->channel_number = 0;
2756 spin_lock_init(&tx->ring_lock);
2757 return 0;
2758 }
2759
lan743x_mdiobus_init(struct lan743x_adapter * adapter)2760 static int lan743x_mdiobus_init(struct lan743x_adapter *adapter)
2761 {
2762 int ret;
2763
2764 adapter->mdiobus = devm_mdiobus_alloc(&adapter->pdev->dev);
2765 if (!(adapter->mdiobus)) {
2766 ret = -ENOMEM;
2767 goto return_error;
2768 }
2769
2770 adapter->mdiobus->priv = (void *)adapter;
2771 adapter->mdiobus->read = lan743x_mdiobus_read;
2772 adapter->mdiobus->write = lan743x_mdiobus_write;
2773 adapter->mdiobus->name = "lan743x-mdiobus";
2774 snprintf(adapter->mdiobus->id, MII_BUS_ID_SIZE,
2775 "pci-%s", pci_name(adapter->pdev));
2776
2777 if ((adapter->csr.id_rev & ID_REV_ID_MASK_) == ID_REV_ID_LAN7430_)
2778 /* LAN7430 uses internal phy at address 1 */
2779 adapter->mdiobus->phy_mask = ~(u32)BIT(1);
2780
2781 /* register mdiobus */
2782 ret = mdiobus_register(adapter->mdiobus);
2783 if (ret < 0)
2784 goto return_error;
2785 return 0;
2786
2787 return_error:
2788 return ret;
2789 }
2790
2791 /* lan743x_pcidev_probe - Device Initialization Routine
2792 * @pdev: PCI device information struct
2793 * @id: entry in lan743x_pci_tbl
2794 *
2795 * Returns 0 on success, negative on failure
2796 *
2797 * initializes an adapter identified by a pci_dev structure.
2798 * The OS initialization, configuring of the adapter private structure,
2799 * and a hardware reset occur.
2800 **/
lan743x_pcidev_probe(struct pci_dev * pdev,const struct pci_device_id * id)2801 static int lan743x_pcidev_probe(struct pci_dev *pdev,
2802 const struct pci_device_id *id)
2803 {
2804 struct lan743x_adapter *adapter = NULL;
2805 struct net_device *netdev = NULL;
2806 int ret = -ENODEV;
2807
2808 netdev = devm_alloc_etherdev(&pdev->dev,
2809 sizeof(struct lan743x_adapter));
2810 if (!netdev)
2811 goto return_error;
2812
2813 SET_NETDEV_DEV(netdev, &pdev->dev);
2814 pci_set_drvdata(pdev, netdev);
2815 adapter = netdev_priv(netdev);
2816 adapter->netdev = netdev;
2817 adapter->msg_enable = NETIF_MSG_DRV | NETIF_MSG_PROBE |
2818 NETIF_MSG_LINK | NETIF_MSG_IFUP |
2819 NETIF_MSG_IFDOWN | NETIF_MSG_TX_QUEUED;
2820 netdev->max_mtu = LAN743X_MAX_FRAME_SIZE;
2821
2822 of_get_mac_address(pdev->dev.of_node, adapter->mac_address);
2823
2824 ret = lan743x_pci_init(adapter, pdev);
2825 if (ret)
2826 goto return_error;
2827
2828 ret = lan743x_csr_init(adapter);
2829 if (ret)
2830 goto cleanup_pci;
2831
2832 ret = lan743x_hardware_init(adapter, pdev);
2833 if (ret)
2834 goto cleanup_pci;
2835
2836 ret = lan743x_mdiobus_init(adapter);
2837 if (ret)
2838 goto cleanup_hardware;
2839
2840 adapter->netdev->netdev_ops = &lan743x_netdev_ops;
2841 adapter->netdev->ethtool_ops = &lan743x_ethtool_ops;
2842 adapter->netdev->features = NETIF_F_SG | NETIF_F_TSO | NETIF_F_HW_CSUM;
2843 adapter->netdev->hw_features = adapter->netdev->features;
2844
2845 /* carrier off reporting is important to ethtool even BEFORE open */
2846 netif_carrier_off(netdev);
2847
2848 ret = register_netdev(adapter->netdev);
2849 if (ret < 0)
2850 goto cleanup_mdiobus;
2851 return 0;
2852
2853 cleanup_mdiobus:
2854 lan743x_mdiobus_cleanup(adapter);
2855
2856 cleanup_hardware:
2857 lan743x_hardware_cleanup(adapter);
2858
2859 cleanup_pci:
2860 lan743x_pci_cleanup(adapter);
2861
2862 return_error:
2863 pr_warn("Initialization failed\n");
2864 return ret;
2865 }
2866
2867 /**
2868 * lan743x_pcidev_remove - Device Removal Routine
2869 * @pdev: PCI device information struct
2870 *
2871 * this is called by the PCI subsystem to alert the driver
2872 * that it should release a PCI device. This could be caused by a
2873 * Hot-Plug event, or because the driver is going to be removed from
2874 * memory.
2875 **/
lan743x_pcidev_remove(struct pci_dev * pdev)2876 static void lan743x_pcidev_remove(struct pci_dev *pdev)
2877 {
2878 struct net_device *netdev = pci_get_drvdata(pdev);
2879 struct lan743x_adapter *adapter = netdev_priv(netdev);
2880
2881 lan743x_full_cleanup(adapter);
2882 }
2883
lan743x_pcidev_shutdown(struct pci_dev * pdev)2884 static void lan743x_pcidev_shutdown(struct pci_dev *pdev)
2885 {
2886 struct net_device *netdev = pci_get_drvdata(pdev);
2887 struct lan743x_adapter *adapter = netdev_priv(netdev);
2888
2889 rtnl_lock();
2890 netif_device_detach(netdev);
2891
2892 /* close netdev when netdev is at running state.
2893 * For instance, it is true when system goes to sleep by pm-suspend
2894 * However, it is false when system goes to sleep by suspend GUI menu
2895 */
2896 if (netif_running(netdev))
2897 lan743x_netdev_close(netdev);
2898 rtnl_unlock();
2899
2900 #ifdef CONFIG_PM
2901 pci_save_state(pdev);
2902 #endif
2903
2904 /* clean up lan743x portion */
2905 lan743x_hardware_cleanup(adapter);
2906 }
2907
2908 #ifdef CONFIG_PM_SLEEP
lan743x_pm_wakeframe_crc16(const u8 * buf,int len)2909 static u16 lan743x_pm_wakeframe_crc16(const u8 *buf, int len)
2910 {
2911 return bitrev16(crc16(0xFFFF, buf, len));
2912 }
2913
lan743x_pm_set_wol(struct lan743x_adapter * adapter)2914 static void lan743x_pm_set_wol(struct lan743x_adapter *adapter)
2915 {
2916 const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
2917 const u8 ipv6_multicast[3] = { 0x33, 0x33 };
2918 const u8 arp_type[2] = { 0x08, 0x06 };
2919 int mask_index;
2920 u32 pmtctl;
2921 u32 wucsr;
2922 u32 macrx;
2923 u16 crc;
2924
2925 for (mask_index = 0; mask_index < MAC_NUM_OF_WUF_CFG; mask_index++)
2926 lan743x_csr_write(adapter, MAC_WUF_CFG(mask_index), 0);
2927
2928 /* clear wake settings */
2929 pmtctl = lan743x_csr_read(adapter, PMT_CTL);
2930 pmtctl |= PMT_CTL_WUPS_MASK_;
2931 pmtctl &= ~(PMT_CTL_GPIO_WAKEUP_EN_ | PMT_CTL_EEE_WAKEUP_EN_ |
2932 PMT_CTL_WOL_EN_ | PMT_CTL_MAC_D3_RX_CLK_OVR_ |
2933 PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_ | PMT_CTL_ETH_PHY_WAKE_EN_);
2934
2935 macrx = lan743x_csr_read(adapter, MAC_RX);
2936
2937 wucsr = 0;
2938 mask_index = 0;
2939
2940 pmtctl |= PMT_CTL_ETH_PHY_D3_COLD_OVR_ | PMT_CTL_ETH_PHY_D3_OVR_;
2941
2942 if (adapter->wolopts & WAKE_PHY) {
2943 pmtctl |= PMT_CTL_ETH_PHY_EDPD_PLL_CTL_;
2944 pmtctl |= PMT_CTL_ETH_PHY_WAKE_EN_;
2945 }
2946 if (adapter->wolopts & WAKE_MAGIC) {
2947 wucsr |= MAC_WUCSR_MPEN_;
2948 macrx |= MAC_RX_RXEN_;
2949 pmtctl |= PMT_CTL_WOL_EN_ | PMT_CTL_MAC_D3_RX_CLK_OVR_;
2950 }
2951 if (adapter->wolopts & WAKE_UCAST) {
2952 wucsr |= MAC_WUCSR_RFE_WAKE_EN_ | MAC_WUCSR_PFDA_EN_;
2953 macrx |= MAC_RX_RXEN_;
2954 pmtctl |= PMT_CTL_WOL_EN_ | PMT_CTL_MAC_D3_RX_CLK_OVR_;
2955 pmtctl |= PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_;
2956 }
2957 if (adapter->wolopts & WAKE_BCAST) {
2958 wucsr |= MAC_WUCSR_RFE_WAKE_EN_ | MAC_WUCSR_BCST_EN_;
2959 macrx |= MAC_RX_RXEN_;
2960 pmtctl |= PMT_CTL_WOL_EN_ | PMT_CTL_MAC_D3_RX_CLK_OVR_;
2961 pmtctl |= PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_;
2962 }
2963 if (adapter->wolopts & WAKE_MCAST) {
2964 /* IPv4 multicast */
2965 crc = lan743x_pm_wakeframe_crc16(ipv4_multicast, 3);
2966 lan743x_csr_write(adapter, MAC_WUF_CFG(mask_index),
2967 MAC_WUF_CFG_EN_ | MAC_WUF_CFG_TYPE_MCAST_ |
2968 (0 << MAC_WUF_CFG_OFFSET_SHIFT_) |
2969 (crc & MAC_WUF_CFG_CRC16_MASK_));
2970 lan743x_csr_write(adapter, MAC_WUF_MASK0(mask_index), 7);
2971 lan743x_csr_write(adapter, MAC_WUF_MASK1(mask_index), 0);
2972 lan743x_csr_write(adapter, MAC_WUF_MASK2(mask_index), 0);
2973 lan743x_csr_write(adapter, MAC_WUF_MASK3(mask_index), 0);
2974 mask_index++;
2975
2976 /* IPv6 multicast */
2977 crc = lan743x_pm_wakeframe_crc16(ipv6_multicast, 2);
2978 lan743x_csr_write(adapter, MAC_WUF_CFG(mask_index),
2979 MAC_WUF_CFG_EN_ | MAC_WUF_CFG_TYPE_MCAST_ |
2980 (0 << MAC_WUF_CFG_OFFSET_SHIFT_) |
2981 (crc & MAC_WUF_CFG_CRC16_MASK_));
2982 lan743x_csr_write(adapter, MAC_WUF_MASK0(mask_index), 3);
2983 lan743x_csr_write(adapter, MAC_WUF_MASK1(mask_index), 0);
2984 lan743x_csr_write(adapter, MAC_WUF_MASK2(mask_index), 0);
2985 lan743x_csr_write(adapter, MAC_WUF_MASK3(mask_index), 0);
2986 mask_index++;
2987
2988 wucsr |= MAC_WUCSR_RFE_WAKE_EN_ | MAC_WUCSR_WAKE_EN_;
2989 macrx |= MAC_RX_RXEN_;
2990 pmtctl |= PMT_CTL_WOL_EN_ | PMT_CTL_MAC_D3_RX_CLK_OVR_;
2991 pmtctl |= PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_;
2992 }
2993 if (adapter->wolopts & WAKE_ARP) {
2994 /* set MAC_WUF_CFG & WUF_MASK
2995 * for packettype (offset 12,13) = ARP (0x0806)
2996 */
2997 crc = lan743x_pm_wakeframe_crc16(arp_type, 2);
2998 lan743x_csr_write(adapter, MAC_WUF_CFG(mask_index),
2999 MAC_WUF_CFG_EN_ | MAC_WUF_CFG_TYPE_ALL_ |
3000 (0 << MAC_WUF_CFG_OFFSET_SHIFT_) |
3001 (crc & MAC_WUF_CFG_CRC16_MASK_));
3002 lan743x_csr_write(adapter, MAC_WUF_MASK0(mask_index), 0x3000);
3003 lan743x_csr_write(adapter, MAC_WUF_MASK1(mask_index), 0);
3004 lan743x_csr_write(adapter, MAC_WUF_MASK2(mask_index), 0);
3005 lan743x_csr_write(adapter, MAC_WUF_MASK3(mask_index), 0);
3006 mask_index++;
3007
3008 wucsr |= MAC_WUCSR_RFE_WAKE_EN_ | MAC_WUCSR_WAKE_EN_;
3009 macrx |= MAC_RX_RXEN_;
3010 pmtctl |= PMT_CTL_WOL_EN_ | PMT_CTL_MAC_D3_RX_CLK_OVR_;
3011 pmtctl |= PMT_CTL_RX_FCT_RFE_D3_CLK_OVR_;
3012 }
3013
3014 lan743x_csr_write(adapter, MAC_WUCSR, wucsr);
3015 lan743x_csr_write(adapter, PMT_CTL, pmtctl);
3016 lan743x_csr_write(adapter, MAC_RX, macrx);
3017 }
3018
lan743x_pm_suspend(struct device * dev)3019 static int lan743x_pm_suspend(struct device *dev)
3020 {
3021 struct pci_dev *pdev = to_pci_dev(dev);
3022 struct net_device *netdev = pci_get_drvdata(pdev);
3023 struct lan743x_adapter *adapter = netdev_priv(netdev);
3024
3025 lan743x_pcidev_shutdown(pdev);
3026
3027 /* clear all wakes */
3028 lan743x_csr_write(adapter, MAC_WUCSR, 0);
3029 lan743x_csr_write(adapter, MAC_WUCSR2, 0);
3030 lan743x_csr_write(adapter, MAC_WK_SRC, 0xFFFFFFFF);
3031
3032 if (adapter->wolopts)
3033 lan743x_pm_set_wol(adapter);
3034
3035 /* Host sets PME_En, put D3hot */
3036 return pci_prepare_to_sleep(pdev);
3037 }
3038
lan743x_pm_resume(struct device * dev)3039 static int lan743x_pm_resume(struct device *dev)
3040 {
3041 struct pci_dev *pdev = to_pci_dev(dev);
3042 struct net_device *netdev = pci_get_drvdata(pdev);
3043 struct lan743x_adapter *adapter = netdev_priv(netdev);
3044 int ret;
3045
3046 pci_set_power_state(pdev, PCI_D0);
3047 pci_restore_state(pdev);
3048 pci_save_state(pdev);
3049
3050 ret = lan743x_hardware_init(adapter, pdev);
3051 if (ret) {
3052 netif_err(adapter, probe, adapter->netdev,
3053 "lan743x_hardware_init returned %d\n", ret);
3054 lan743x_pci_cleanup(adapter);
3055 return ret;
3056 }
3057
3058 /* open netdev when netdev is at running state while resume.
3059 * For instance, it is true when system wakesup after pm-suspend
3060 * However, it is false when system wakes up after suspend GUI menu
3061 */
3062 if (netif_running(netdev))
3063 lan743x_netdev_open(netdev);
3064
3065 netif_device_attach(netdev);
3066
3067 return 0;
3068 }
3069
3070 static const struct dev_pm_ops lan743x_pm_ops = {
3071 SET_SYSTEM_SLEEP_PM_OPS(lan743x_pm_suspend, lan743x_pm_resume)
3072 };
3073 #endif /* CONFIG_PM_SLEEP */
3074
3075 static const struct pci_device_id lan743x_pcidev_tbl[] = {
3076 { PCI_DEVICE(PCI_VENDOR_ID_SMSC, PCI_DEVICE_ID_SMSC_LAN7430) },
3077 { PCI_DEVICE(PCI_VENDOR_ID_SMSC, PCI_DEVICE_ID_SMSC_LAN7431) },
3078 { 0, }
3079 };
3080
3081 MODULE_DEVICE_TABLE(pci, lan743x_pcidev_tbl);
3082
3083 static struct pci_driver lan743x_pcidev_driver = {
3084 .name = DRIVER_NAME,
3085 .id_table = lan743x_pcidev_tbl,
3086 .probe = lan743x_pcidev_probe,
3087 .remove = lan743x_pcidev_remove,
3088 #ifdef CONFIG_PM_SLEEP
3089 .driver.pm = &lan743x_pm_ops,
3090 #endif
3091 .shutdown = lan743x_pcidev_shutdown,
3092 };
3093
3094 module_pci_driver(lan743x_pcidev_driver);
3095
3096 MODULE_AUTHOR(DRIVER_AUTHOR);
3097 MODULE_DESCRIPTION(DRIVER_DESC);
3098 MODULE_LICENSE("GPL");
3099