1
2
3
4
5
6
7
8
9
10
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14#include <linux/interrupt.h>
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/platform_device.h>
18#include <linux/netdevice.h>
19#include <linux/etherdevice.h>
20#include <linux/ethtool.h>
21#include <linux/ks8842.h>
22#include <linux/dmaengine.h>
23#include <linux/dma-mapping.h>
24#include <linux/scatterlist.h>
25
26#define DRV_NAME "ks8842"
27
28
29#define REG_TIMB_RST 0x1c
30#define REG_TIMB_FIFO 0x20
31#define REG_TIMB_ISR 0x24
32#define REG_TIMB_IER 0x28
33#define REG_TIMB_IAR 0x2C
34#define REQ_TIMB_DMA_RESUME 0x30
35
36
37
38#define REG_SELECT_BANK 0x0e
39
40
41#define REG_QRFCR 0x04
42
43
44#define REG_MARL 0x00
45#define REG_MARM 0x02
46#define REG_MARH 0x04
47
48
49#define REG_GRR 0x06
50
51
52#define REG_TXCR 0x00
53#define REG_TXSR 0x02
54#define REG_RXCR 0x04
55#define REG_TXMIR 0x08
56#define REG_RXMIR 0x0A
57
58
59#define REG_TXQCR 0x00
60#define REG_RXQCR 0x02
61#define REG_TXFDPR 0x04
62#define REG_RXFDPR 0x06
63#define REG_QMU_DATA_LO 0x08
64#define REG_QMU_DATA_HI 0x0A
65
66
67#define REG_IER 0x00
68#define IRQ_LINK_CHANGE 0x8000
69#define IRQ_TX 0x4000
70#define IRQ_RX 0x2000
71#define IRQ_RX_OVERRUN 0x0800
72#define IRQ_TX_STOPPED 0x0200
73#define IRQ_RX_STOPPED 0x0100
74#define IRQ_RX_ERROR 0x0080
75#define ENABLED_IRQS (IRQ_LINK_CHANGE | IRQ_TX | IRQ_RX | IRQ_RX_STOPPED | \
76 IRQ_TX_STOPPED | IRQ_RX_OVERRUN | IRQ_RX_ERROR)
77
78
79
80
81
82
83#define ENABLED_IRQS_DMA_IP (IRQ_LINK_CHANGE | IRQ_RX_STOPPED | \
84 IRQ_TX_STOPPED | IRQ_RX_OVERRUN | IRQ_RX_ERROR)
85#define ENABLED_IRQS_DMA (ENABLED_IRQS_DMA_IP | IRQ_RX)
86#define REG_ISR 0x02
87#define REG_RXSR 0x04
88#define RXSR_VALID 0x8000
89#define RXSR_BROADCAST 0x80
90#define RXSR_MULTICAST 0x40
91#define RXSR_UNICAST 0x20
92#define RXSR_FRAMETYPE 0x08
93#define RXSR_TOO_LONG 0x04
94#define RXSR_RUNT 0x02
95#define RXSR_CRC_ERROR 0x01
96#define RXSR_ERROR (RXSR_TOO_LONG | RXSR_RUNT | RXSR_CRC_ERROR)
97
98
99#define REG_SW_ID_AND_ENABLE 0x00
100#define REG_SGCR1 0x02
101#define REG_SGCR2 0x04
102#define REG_SGCR3 0x06
103
104
105#define REG_MACAR1 0x00
106#define REG_MACAR2 0x02
107#define REG_MACAR3 0x04
108
109
110#define REG_P1MBCR 0x00
111#define REG_P1MBSR 0x02
112
113
114#define REG_P2MBCR 0x00
115#define REG_P2MBSR 0x02
116
117
118#define REG_P1CR2 0x02
119
120
121#define REG_P1CR4 0x02
122#define REG_P1SR 0x04
123
124
125#define MICREL_KS884X 0x01
126#define KS884X_16BIT 0x02
127
128#define DMA_BUFFER_SIZE 2048
129
130struct ks8842_tx_dma_ctl {
131 struct dma_chan *chan;
132 struct dma_async_tx_descriptor *adesc;
133 void *buf;
134 struct scatterlist sg;
135 int channel;
136};
137
138struct ks8842_rx_dma_ctl {
139 struct dma_chan *chan;
140 struct dma_async_tx_descriptor *adesc;
141 struct sk_buff *skb;
142 struct scatterlist sg;
143 struct tasklet_struct tasklet;
144 int channel;
145};
146
147#define KS8842_USE_DMA(adapter) (((adapter)->dma_tx.channel != -1) && \
148 ((adapter)->dma_rx.channel != -1))
149
150struct ks8842_adapter {
151 void __iomem *hw_addr;
152 int irq;
153 unsigned long conf_flags;
154 struct tasklet_struct tasklet;
155 spinlock_t lock;
156 struct work_struct timeout_work;
157 struct net_device *netdev;
158 struct device *dev;
159 struct ks8842_tx_dma_ctl dma_tx;
160 struct ks8842_rx_dma_ctl dma_rx;
161};
162
163static void ks8842_dma_rx_cb(void *data);
164static void ks8842_dma_tx_cb(void *data);
165
166static inline void ks8842_resume_dma(struct ks8842_adapter *adapter)
167{
168 iowrite32(1, adapter->hw_addr + REQ_TIMB_DMA_RESUME);
169}
170
171static inline void ks8842_select_bank(struct ks8842_adapter *adapter, u16 bank)
172{
173 iowrite16(bank, adapter->hw_addr + REG_SELECT_BANK);
174}
175
176static inline void ks8842_write8(struct ks8842_adapter *adapter, u16 bank,
177 u8 value, int offset)
178{
179 ks8842_select_bank(adapter, bank);
180 iowrite8(value, adapter->hw_addr + offset);
181}
182
183static inline void ks8842_write16(struct ks8842_adapter *adapter, u16 bank,
184 u16 value, int offset)
185{
186 ks8842_select_bank(adapter, bank);
187 iowrite16(value, adapter->hw_addr + offset);
188}
189
190static inline void ks8842_enable_bits(struct ks8842_adapter *adapter, u16 bank,
191 u16 bits, int offset)
192{
193 u16 reg;
194 ks8842_select_bank(adapter, bank);
195 reg = ioread16(adapter->hw_addr + offset);
196 reg |= bits;
197 iowrite16(reg, adapter->hw_addr + offset);
198}
199
200static inline void ks8842_clear_bits(struct ks8842_adapter *adapter, u16 bank,
201 u16 bits, int offset)
202{
203 u16 reg;
204 ks8842_select_bank(adapter, bank);
205 reg = ioread16(adapter->hw_addr + offset);
206 reg &= ~bits;
207 iowrite16(reg, adapter->hw_addr + offset);
208}
209
210static inline void ks8842_write32(struct ks8842_adapter *adapter, u16 bank,
211 u32 value, int offset)
212{
213 ks8842_select_bank(adapter, bank);
214 iowrite32(value, adapter->hw_addr + offset);
215}
216
217static inline u8 ks8842_read8(struct ks8842_adapter *adapter, u16 bank,
218 int offset)
219{
220 ks8842_select_bank(adapter, bank);
221 return ioread8(adapter->hw_addr + offset);
222}
223
224static inline u16 ks8842_read16(struct ks8842_adapter *adapter, u16 bank,
225 int offset)
226{
227 ks8842_select_bank(adapter, bank);
228 return ioread16(adapter->hw_addr + offset);
229}
230
231static inline u32 ks8842_read32(struct ks8842_adapter *adapter, u16 bank,
232 int offset)
233{
234 ks8842_select_bank(adapter, bank);
235 return ioread32(adapter->hw_addr + offset);
236}
237
238static void ks8842_reset(struct ks8842_adapter *adapter)
239{
240 if (adapter->conf_flags & MICREL_KS884X) {
241 ks8842_write16(adapter, 3, 1, REG_GRR);
242 msleep(10);
243 iowrite16(0, adapter->hw_addr + REG_GRR);
244 } else {
245
246
247
248
249
250
251
252 iowrite32(0x1, adapter->hw_addr + REG_TIMB_RST);
253 msleep(20);
254 }
255}
256
257static void ks8842_update_link_status(struct net_device *netdev,
258 struct ks8842_adapter *adapter)
259{
260
261 if (ks8842_read16(adapter, 45, REG_P1MBSR) & 0x4) {
262 netif_carrier_on(netdev);
263 netif_wake_queue(netdev);
264 } else {
265 netif_stop_queue(netdev);
266 netif_carrier_off(netdev);
267 }
268}
269
270static void ks8842_enable_tx(struct ks8842_adapter *adapter)
271{
272 ks8842_enable_bits(adapter, 16, 0x01, REG_TXCR);
273}
274
275static void ks8842_disable_tx(struct ks8842_adapter *adapter)
276{
277 ks8842_clear_bits(adapter, 16, 0x01, REG_TXCR);
278}
279
280static void ks8842_enable_rx(struct ks8842_adapter *adapter)
281{
282 ks8842_enable_bits(adapter, 16, 0x01, REG_RXCR);
283}
284
285static void ks8842_disable_rx(struct ks8842_adapter *adapter)
286{
287 ks8842_clear_bits(adapter, 16, 0x01, REG_RXCR);
288}
289
290static void ks8842_reset_hw(struct ks8842_adapter *adapter)
291{
292
293 ks8842_reset(adapter);
294
295
296 ks8842_write16(adapter, 16, 0x000E, REG_TXCR);
297
298
299
300 ks8842_write16(adapter, 16, 0x8 | 0x20 | 0x40 | 0x80 | 0x400,
301 REG_RXCR);
302
303
304 ks8842_write16(adapter, 17, 0x4000, REG_TXFDPR);
305
306
307 ks8842_write16(adapter, 17, 0x4000, REG_RXFDPR);
308
309
310 ks8842_write16(adapter, 0, 0x1000, REG_QRFCR);
311
312
313 ks8842_enable_bits(adapter, 32, 1 << 8, REG_SGCR1);
314
315
316 ks8842_enable_bits(adapter, 32, 1 << 3, REG_SGCR2);
317
318
319 ks8842_write16(adapter, 48, 0x1E07, REG_P1CR2);
320
321
322 ks8842_enable_bits(adapter, 49, 1 << 13, REG_P1CR4);
323
324
325 ks8842_enable_tx(adapter);
326
327
328 ks8842_enable_rx(adapter);
329
330
331 ks8842_write16(adapter, 18, 0xffff, REG_ISR);
332
333
334 if (KS8842_USE_DMA(adapter)) {
335
336
337
338
339 iowrite16(ENABLED_IRQS_DMA_IP, adapter->hw_addr + REG_TIMB_IER);
340 ks8842_write16(adapter, 18, ENABLED_IRQS_DMA, REG_IER);
341 } else {
342 if (!(adapter->conf_flags & MICREL_KS884X))
343 iowrite16(ENABLED_IRQS,
344 adapter->hw_addr + REG_TIMB_IER);
345 ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
346 }
347
348 ks8842_write16(adapter, 32, 0x1, REG_SW_ID_AND_ENABLE);
349}
350
351static void ks8842_read_mac_addr(struct ks8842_adapter *adapter, u8 *dest)
352{
353 int i;
354 u16 mac;
355
356 for (i = 0; i < ETH_ALEN; i++)
357 dest[ETH_ALEN - i - 1] = ks8842_read8(adapter, 2, REG_MARL + i);
358
359 if (adapter->conf_flags & MICREL_KS884X) {
360
361
362
363
364
365 mac = ks8842_read16(adapter, 2, REG_MARL);
366 ks8842_write16(adapter, 39, mac, REG_MACAR3);
367 mac = ks8842_read16(adapter, 2, REG_MARM);
368 ks8842_write16(adapter, 39, mac, REG_MACAR2);
369 mac = ks8842_read16(adapter, 2, REG_MARH);
370 ks8842_write16(adapter, 39, mac, REG_MACAR1);
371 } else {
372
373
374 mac = ks8842_read16(adapter, 2, REG_MARL);
375 ks8842_write16(adapter, 39, mac, REG_MACAR1);
376 mac = ks8842_read16(adapter, 2, REG_MARM);
377 ks8842_write16(adapter, 39, mac, REG_MACAR2);
378 mac = ks8842_read16(adapter, 2, REG_MARH);
379 ks8842_write16(adapter, 39, mac, REG_MACAR3);
380 }
381}
382
383static void ks8842_write_mac_addr(struct ks8842_adapter *adapter, u8 *mac)
384{
385 unsigned long flags;
386 unsigned i;
387
388 spin_lock_irqsave(&adapter->lock, flags);
389 for (i = 0; i < ETH_ALEN; i++) {
390 ks8842_write8(adapter, 2, mac[ETH_ALEN - i - 1], REG_MARL + i);
391 if (!(adapter->conf_flags & MICREL_KS884X))
392 ks8842_write8(adapter, 39, mac[ETH_ALEN - i - 1],
393 REG_MACAR1 + i);
394 }
395
396 if (adapter->conf_flags & MICREL_KS884X) {
397
398
399
400
401
402 u16 mac;
403
404 mac = ks8842_read16(adapter, 2, REG_MARL);
405 ks8842_write16(adapter, 39, mac, REG_MACAR3);
406 mac = ks8842_read16(adapter, 2, REG_MARM);
407 ks8842_write16(adapter, 39, mac, REG_MACAR2);
408 mac = ks8842_read16(adapter, 2, REG_MARH);
409 ks8842_write16(adapter, 39, mac, REG_MACAR1);
410 }
411 spin_unlock_irqrestore(&adapter->lock, flags);
412}
413
414static inline u16 ks8842_tx_fifo_space(struct ks8842_adapter *adapter)
415{
416 return ks8842_read16(adapter, 16, REG_TXMIR) & 0x1fff;
417}
418
419static int ks8842_tx_frame_dma(struct sk_buff *skb, struct net_device *netdev)
420{
421 struct ks8842_adapter *adapter = netdev_priv(netdev);
422 struct ks8842_tx_dma_ctl *ctl = &adapter->dma_tx;
423 u8 *buf = ctl->buf;
424
425 if (ctl->adesc) {
426 netdev_dbg(netdev, "%s: TX ongoing\n", __func__);
427
428 return NETDEV_TX_BUSY;
429 }
430
431 sg_dma_len(&ctl->sg) = skb->len + sizeof(u32);
432
433
434
435 *buf++ = 0x00;
436 *buf++ = 0x01;
437 *buf++ = skb->len & 0xff;
438 *buf++ = (skb->len >> 8) & 0xff;
439 skb_copy_from_linear_data(skb, buf, skb->len);
440
441 dma_sync_single_range_for_device(adapter->dev,
442 sg_dma_address(&ctl->sg), 0, sg_dma_len(&ctl->sg),
443 DMA_TO_DEVICE);
444
445
446 if (sg_dma_len(&ctl->sg) % 4)
447 sg_dma_len(&ctl->sg) += 4 - sg_dma_len(&ctl->sg) % 4;
448
449 ctl->adesc = dmaengine_prep_slave_sg(ctl->chan,
450 &ctl->sg, 1, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT);
451 if (!ctl->adesc)
452 return NETDEV_TX_BUSY;
453
454 ctl->adesc->callback_param = netdev;
455 ctl->adesc->callback = ks8842_dma_tx_cb;
456 ctl->adesc->tx_submit(ctl->adesc);
457
458 netdev->stats.tx_bytes += skb->len;
459
460 dev_kfree_skb(skb);
461
462 return NETDEV_TX_OK;
463}
464
465static int ks8842_tx_frame(struct sk_buff *skb, struct net_device *netdev)
466{
467 struct ks8842_adapter *adapter = netdev_priv(netdev);
468 int len = skb->len;
469
470 netdev_dbg(netdev, "%s: len %u head %p data %p tail %p end %p\n",
471 __func__, skb->len, skb->head, skb->data,
472 skb_tail_pointer(skb), skb_end_pointer(skb));
473
474
475 if (ks8842_tx_fifo_space(adapter) < len + 8)
476 return NETDEV_TX_BUSY;
477
478 if (adapter->conf_flags & KS884X_16BIT) {
479 u16 *ptr16 = (u16 *)skb->data;
480 ks8842_write16(adapter, 17, 0x8000 | 0x100, REG_QMU_DATA_LO);
481 ks8842_write16(adapter, 17, (u16)len, REG_QMU_DATA_HI);
482 netdev->stats.tx_bytes += len;
483
484
485 while (len > 0) {
486 iowrite16(*ptr16++, adapter->hw_addr + REG_QMU_DATA_LO);
487 iowrite16(*ptr16++, adapter->hw_addr + REG_QMU_DATA_HI);
488 len -= sizeof(u32);
489 }
490 } else {
491
492 u32 *ptr = (u32 *)skb->data;
493 u32 ctrl;
494
495 ctrl = 0x8000 | 0x100 | (len << 16);
496 ks8842_write32(adapter, 17, ctrl, REG_QMU_DATA_LO);
497
498 netdev->stats.tx_bytes += len;
499
500
501 while (len > 0) {
502 iowrite32(*ptr, adapter->hw_addr + REG_QMU_DATA_LO);
503 len -= sizeof(u32);
504 ptr++;
505 }
506 }
507
508
509 ks8842_write16(adapter, 17, 1, REG_TXQCR);
510
511 dev_kfree_skb(skb);
512
513 return NETDEV_TX_OK;
514}
515
516static void ks8842_update_rx_err_counters(struct net_device *netdev, u32 status)
517{
518 netdev_dbg(netdev, "RX error, status: %x\n", status);
519
520 netdev->stats.rx_errors++;
521 if (status & RXSR_TOO_LONG)
522 netdev->stats.rx_length_errors++;
523 if (status & RXSR_CRC_ERROR)
524 netdev->stats.rx_crc_errors++;
525 if (status & RXSR_RUNT)
526 netdev->stats.rx_frame_errors++;
527}
528
529static void ks8842_update_rx_counters(struct net_device *netdev, u32 status,
530 int len)
531{
532 netdev_dbg(netdev, "RX packet, len: %d\n", len);
533
534 netdev->stats.rx_packets++;
535 netdev->stats.rx_bytes += len;
536 if (status & RXSR_MULTICAST)
537 netdev->stats.multicast++;
538}
539
540static int __ks8842_start_new_rx_dma(struct net_device *netdev)
541{
542 struct ks8842_adapter *adapter = netdev_priv(netdev);
543 struct ks8842_rx_dma_ctl *ctl = &adapter->dma_rx;
544 struct scatterlist *sg = &ctl->sg;
545 int err;
546
547 ctl->skb = netdev_alloc_skb(netdev, DMA_BUFFER_SIZE);
548 if (ctl->skb) {
549 sg_init_table(sg, 1);
550 sg_dma_address(sg) = dma_map_single(adapter->dev,
551 ctl->skb->data, DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
552 if (dma_mapping_error(adapter->dev, sg_dma_address(sg))) {
553 err = -ENOMEM;
554 sg_dma_address(sg) = 0;
555 goto out;
556 }
557
558 sg_dma_len(sg) = DMA_BUFFER_SIZE;
559
560 ctl->adesc = dmaengine_prep_slave_sg(ctl->chan,
561 sg, 1, DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT);
562
563 if (!ctl->adesc) {
564 err = -ENOMEM;
565 goto out;
566 }
567
568 ctl->adesc->callback_param = netdev;
569 ctl->adesc->callback = ks8842_dma_rx_cb;
570 ctl->adesc->tx_submit(ctl->adesc);
571 } else {
572 err = -ENOMEM;
573 sg_dma_address(sg) = 0;
574 goto out;
575 }
576
577 return 0;
578out:
579 if (sg_dma_address(sg))
580 dma_unmap_single(adapter->dev, sg_dma_address(sg),
581 DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
582 sg_dma_address(sg) = 0;
583 if (ctl->skb)
584 dev_kfree_skb(ctl->skb);
585
586 ctl->skb = NULL;
587
588 printk(KERN_ERR DRV_NAME": Failed to start RX DMA: %d\n", err);
589 return err;
590}
591
592static void ks8842_rx_frame_dma_tasklet(unsigned long arg)
593{
594 struct net_device *netdev = (struct net_device *)arg;
595 struct ks8842_adapter *adapter = netdev_priv(netdev);
596 struct ks8842_rx_dma_ctl *ctl = &adapter->dma_rx;
597 struct sk_buff *skb = ctl->skb;
598 dma_addr_t addr = sg_dma_address(&ctl->sg);
599 u32 status;
600
601 ctl->adesc = NULL;
602
603
604 __ks8842_start_new_rx_dma(netdev);
605
606
607 dma_unmap_single(adapter->dev, addr, DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
608
609 status = *((u32 *)skb->data);
610
611 netdev_dbg(netdev, "%s - rx_data: status: %x\n",
612 __func__, status & 0xffff);
613
614
615 if ((status & RXSR_VALID) && !(status & RXSR_ERROR)) {
616 int len = (status >> 16) & 0x7ff;
617
618 ks8842_update_rx_counters(netdev, status, len);
619
620
621 skb_reserve(skb, 4);
622 skb_put(skb, len);
623
624 skb->protocol = eth_type_trans(skb, netdev);
625 netif_rx(skb);
626 } else {
627 ks8842_update_rx_err_counters(netdev, status);
628 dev_kfree_skb(skb);
629 }
630}
631
632static void ks8842_rx_frame(struct net_device *netdev,
633 struct ks8842_adapter *adapter)
634{
635 u32 status;
636 int len;
637
638 if (adapter->conf_flags & KS884X_16BIT) {
639 status = ks8842_read16(adapter, 17, REG_QMU_DATA_LO);
640 len = ks8842_read16(adapter, 17, REG_QMU_DATA_HI);
641 netdev_dbg(netdev, "%s - rx_data: status: %x\n",
642 __func__, status);
643 } else {
644 status = ks8842_read32(adapter, 17, REG_QMU_DATA_LO);
645 len = (status >> 16) & 0x7ff;
646 status &= 0xffff;
647 netdev_dbg(netdev, "%s - rx_data: status: %x\n",
648 __func__, status);
649 }
650
651
652 if ((status & RXSR_VALID) && !(status & RXSR_ERROR)) {
653 struct sk_buff *skb = netdev_alloc_skb_ip_align(netdev, len + 3);
654
655 if (skb) {
656
657 ks8842_update_rx_counters(netdev, status, len);
658
659 if (adapter->conf_flags & KS884X_16BIT) {
660 u16 *data16 = skb_put(skb, len);
661 ks8842_select_bank(adapter, 17);
662 while (len > 0) {
663 *data16++ = ioread16(adapter->hw_addr +
664 REG_QMU_DATA_LO);
665 *data16++ = ioread16(adapter->hw_addr +
666 REG_QMU_DATA_HI);
667 len -= sizeof(u32);
668 }
669 } else {
670 u32 *data = skb_put(skb, len);
671
672 ks8842_select_bank(adapter, 17);
673 while (len > 0) {
674 *data++ = ioread32(adapter->hw_addr +
675 REG_QMU_DATA_LO);
676 len -= sizeof(u32);
677 }
678 }
679 skb->protocol = eth_type_trans(skb, netdev);
680 netif_rx(skb);
681 } else
682 netdev->stats.rx_dropped++;
683 } else
684 ks8842_update_rx_err_counters(netdev, status);
685
686
687 ks8842_clear_bits(adapter, 0, 1 << 12, REG_QRFCR);
688
689
690 ks8842_write16(adapter, 17, 0x01, REG_RXQCR);
691
692
693 ks8842_enable_bits(adapter, 0, 1 << 12, REG_QRFCR);
694}
695
696static void ks8842_handle_rx(struct net_device *netdev,
697 struct ks8842_adapter *adapter)
698{
699 u16 rx_data = ks8842_read16(adapter, 16, REG_RXMIR) & 0x1fff;
700 netdev_dbg(netdev, "%s Entry - rx_data: %d\n", __func__, rx_data);
701 while (rx_data) {
702 ks8842_rx_frame(netdev, adapter);
703 rx_data = ks8842_read16(adapter, 16, REG_RXMIR) & 0x1fff;
704 }
705}
706
707static void ks8842_handle_tx(struct net_device *netdev,
708 struct ks8842_adapter *adapter)
709{
710 u16 sr = ks8842_read16(adapter, 16, REG_TXSR);
711 netdev_dbg(netdev, "%s - entry, sr: %x\n", __func__, sr);
712 netdev->stats.tx_packets++;
713 if (netif_queue_stopped(netdev))
714 netif_wake_queue(netdev);
715}
716
717static void ks8842_handle_rx_overrun(struct net_device *netdev,
718 struct ks8842_adapter *adapter)
719{
720 netdev_dbg(netdev, "%s: entry\n", __func__);
721 netdev->stats.rx_errors++;
722 netdev->stats.rx_fifo_errors++;
723}
724
725static void ks8842_tasklet(unsigned long arg)
726{
727 struct net_device *netdev = (struct net_device *)arg;
728 struct ks8842_adapter *adapter = netdev_priv(netdev);
729 u16 isr;
730 unsigned long flags;
731 u16 entry_bank;
732
733
734 spin_lock_irqsave(&adapter->lock, flags);
735 entry_bank = ioread16(adapter->hw_addr + REG_SELECT_BANK);
736 spin_unlock_irqrestore(&adapter->lock, flags);
737
738 isr = ks8842_read16(adapter, 18, REG_ISR);
739 netdev_dbg(netdev, "%s - ISR: 0x%x\n", __func__, isr);
740
741
742
743
744 if (KS8842_USE_DMA(adapter))
745 isr &= ~IRQ_RX;
746
747
748 ks8842_write16(adapter, 18, isr, REG_ISR);
749
750 if (!(adapter->conf_flags & MICREL_KS884X))
751
752 iowrite32(0x1, adapter->hw_addr + REG_TIMB_IAR);
753
754 if (!netif_running(netdev))
755 return;
756
757 if (isr & IRQ_LINK_CHANGE)
758 ks8842_update_link_status(netdev, adapter);
759
760
761 if (isr & (IRQ_RX | IRQ_RX_ERROR) && !KS8842_USE_DMA(adapter))
762 ks8842_handle_rx(netdev, adapter);
763
764
765 if (isr & IRQ_TX)
766 ks8842_handle_tx(netdev, adapter);
767
768 if (isr & IRQ_RX_OVERRUN)
769 ks8842_handle_rx_overrun(netdev, adapter);
770
771 if (isr & IRQ_TX_STOPPED) {
772 ks8842_disable_tx(adapter);
773 ks8842_enable_tx(adapter);
774 }
775
776 if (isr & IRQ_RX_STOPPED) {
777 ks8842_disable_rx(adapter);
778 ks8842_enable_rx(adapter);
779 }
780
781
782 spin_lock_irqsave(&adapter->lock, flags);
783 if (KS8842_USE_DMA(adapter))
784 ks8842_write16(adapter, 18, ENABLED_IRQS_DMA, REG_IER);
785 else
786 ks8842_write16(adapter, 18, ENABLED_IRQS, REG_IER);
787 iowrite16(entry_bank, adapter->hw_addr + REG_SELECT_BANK);
788
789
790
791 if (KS8842_USE_DMA(adapter))
792 ks8842_resume_dma(adapter);
793
794 spin_unlock_irqrestore(&adapter->lock, flags);
795}
796
797static irqreturn_t ks8842_irq(int irq, void *devid)
798{
799 struct net_device *netdev = devid;
800 struct ks8842_adapter *adapter = netdev_priv(netdev);
801 u16 isr;
802 u16 entry_bank = ioread16(adapter->hw_addr + REG_SELECT_BANK);
803 irqreturn_t ret = IRQ_NONE;
804
805 isr = ks8842_read16(adapter, 18, REG_ISR);
806 netdev_dbg(netdev, "%s - ISR: 0x%x\n", __func__, isr);
807
808 if (isr) {
809 if (KS8842_USE_DMA(adapter))
810
811 ks8842_write16(adapter, 18, IRQ_RX, REG_IER);
812 else
813
814 ks8842_write16(adapter, 18, 0x00, REG_IER);
815
816
817 tasklet_schedule(&adapter->tasklet);
818
819 ret = IRQ_HANDLED;
820 }
821
822 iowrite16(entry_bank, adapter->hw_addr + REG_SELECT_BANK);
823
824
825
826
827 ks8842_resume_dma(adapter);
828
829 return ret;
830}
831
832static void ks8842_dma_rx_cb(void *data)
833{
834 struct net_device *netdev = data;
835 struct ks8842_adapter *adapter = netdev_priv(netdev);
836
837 netdev_dbg(netdev, "RX DMA finished\n");
838
839 if (adapter->dma_rx.adesc)
840 tasklet_schedule(&adapter->dma_rx.tasklet);
841}
842
843static void ks8842_dma_tx_cb(void *data)
844{
845 struct net_device *netdev = data;
846 struct ks8842_adapter *adapter = netdev_priv(netdev);
847 struct ks8842_tx_dma_ctl *ctl = &adapter->dma_tx;
848
849 netdev_dbg(netdev, "TX DMA finished\n");
850
851 if (!ctl->adesc)
852 return;
853
854 netdev->stats.tx_packets++;
855 ctl->adesc = NULL;
856
857 if (netif_queue_stopped(netdev))
858 netif_wake_queue(netdev);
859}
860
861static void ks8842_stop_dma(struct ks8842_adapter *adapter)
862{
863 struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
864 struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
865
866 tx_ctl->adesc = NULL;
867 if (tx_ctl->chan)
868 dmaengine_terminate_all(tx_ctl->chan);
869
870 rx_ctl->adesc = NULL;
871 if (rx_ctl->chan)
872 dmaengine_terminate_all(rx_ctl->chan);
873
874 if (sg_dma_address(&rx_ctl->sg))
875 dma_unmap_single(adapter->dev, sg_dma_address(&rx_ctl->sg),
876 DMA_BUFFER_SIZE, DMA_FROM_DEVICE);
877 sg_dma_address(&rx_ctl->sg) = 0;
878
879 dev_kfree_skb(rx_ctl->skb);
880 rx_ctl->skb = NULL;
881}
882
883static void ks8842_dealloc_dma_bufs(struct ks8842_adapter *adapter)
884{
885 struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
886 struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
887
888 ks8842_stop_dma(adapter);
889
890 if (tx_ctl->chan)
891 dma_release_channel(tx_ctl->chan);
892 tx_ctl->chan = NULL;
893
894 if (rx_ctl->chan)
895 dma_release_channel(rx_ctl->chan);
896 rx_ctl->chan = NULL;
897
898 tasklet_kill(&rx_ctl->tasklet);
899
900 if (sg_dma_address(&tx_ctl->sg))
901 dma_unmap_single(adapter->dev, sg_dma_address(&tx_ctl->sg),
902 DMA_BUFFER_SIZE, DMA_TO_DEVICE);
903 sg_dma_address(&tx_ctl->sg) = 0;
904
905 kfree(tx_ctl->buf);
906 tx_ctl->buf = NULL;
907}
908
909static bool ks8842_dma_filter_fn(struct dma_chan *chan, void *filter_param)
910{
911 return chan->chan_id == (long)filter_param;
912}
913
914static int ks8842_alloc_dma_bufs(struct net_device *netdev)
915{
916 struct ks8842_adapter *adapter = netdev_priv(netdev);
917 struct ks8842_tx_dma_ctl *tx_ctl = &adapter->dma_tx;
918 struct ks8842_rx_dma_ctl *rx_ctl = &adapter->dma_rx;
919 int err;
920
921 dma_cap_mask_t mask;
922
923 dma_cap_zero(mask);
924 dma_cap_set(DMA_SLAVE, mask);
925 dma_cap_set(DMA_PRIVATE, mask);
926
927 sg_init_table(&tx_ctl->sg, 1);
928
929 tx_ctl->chan = dma_request_channel(mask, ks8842_dma_filter_fn,
930 (void *)(long)tx_ctl->channel);
931 if (!tx_ctl->chan) {
932 err = -ENODEV;
933 goto err;
934 }
935
936
937 tx_ctl->buf = kmalloc(DMA_BUFFER_SIZE, GFP_KERNEL);
938 if (!tx_ctl->buf) {
939 err = -ENOMEM;
940 goto err;
941 }
942
943 sg_dma_address(&tx_ctl->sg) = dma_map_single(adapter->dev,
944 tx_ctl->buf, DMA_BUFFER_SIZE, DMA_TO_DEVICE);
945 if (dma_mapping_error(adapter->dev, sg_dma_address(&tx_ctl->sg))) {
946 err = -ENOMEM;
947 sg_dma_address(&tx_ctl->sg) = 0;
948 goto err;
949 }
950
951 rx_ctl->chan = dma_request_channel(mask, ks8842_dma_filter_fn,
952 (void *)(long)rx_ctl->channel);
953 if (!rx_ctl->chan) {
954 err = -ENODEV;
955 goto err;
956 }
957
958 tasklet_init(&rx_ctl->tasklet, ks8842_rx_frame_dma_tasklet,
959 (unsigned long)netdev);
960
961 return 0;
962err:
963 ks8842_dealloc_dma_bufs(adapter);
964 return err;
965}
966
967
968
969static int ks8842_open(struct net_device *netdev)
970{
971 struct ks8842_adapter *adapter = netdev_priv(netdev);
972 int err;
973
974 netdev_dbg(netdev, "%s - entry\n", __func__);
975
976 if (KS8842_USE_DMA(adapter)) {
977 err = ks8842_alloc_dma_bufs(netdev);
978
979 if (!err) {
980
981 err = __ks8842_start_new_rx_dma(netdev);
982 if (err)
983 ks8842_dealloc_dma_bufs(adapter);
984 }
985
986 if (err) {
987 printk(KERN_WARNING DRV_NAME
988 ": Failed to initiate DMA, running PIO\n");
989 ks8842_dealloc_dma_bufs(adapter);
990 adapter->dma_rx.channel = -1;
991 adapter->dma_tx.channel = -1;
992 }
993 }
994
995
996 ks8842_reset_hw(adapter);
997
998 ks8842_write_mac_addr(adapter, netdev->dev_addr);
999
1000 ks8842_update_link_status(netdev, adapter);
1001
1002 err = request_irq(adapter->irq, ks8842_irq, IRQF_SHARED, DRV_NAME,
1003 netdev);
1004 if (err) {
1005 pr_err("Failed to request IRQ: %d: %d\n", adapter->irq, err);
1006 return err;
1007 }
1008
1009 return 0;
1010}
1011
1012static int ks8842_close(struct net_device *netdev)
1013{
1014 struct ks8842_adapter *adapter = netdev_priv(netdev);
1015
1016 netdev_dbg(netdev, "%s - entry\n", __func__);
1017
1018 cancel_work_sync(&adapter->timeout_work);
1019
1020 if (KS8842_USE_DMA(adapter))
1021 ks8842_dealloc_dma_bufs(adapter);
1022
1023
1024 free_irq(adapter->irq, netdev);
1025
1026
1027 ks8842_write16(adapter, 32, 0x0, REG_SW_ID_AND_ENABLE);
1028
1029 return 0;
1030}
1031
1032static netdev_tx_t ks8842_xmit_frame(struct sk_buff *skb,
1033 struct net_device *netdev)
1034{
1035 int ret;
1036 struct ks8842_adapter *adapter = netdev_priv(netdev);
1037
1038 netdev_dbg(netdev, "%s: entry\n", __func__);
1039
1040 if (KS8842_USE_DMA(adapter)) {
1041 unsigned long flags;
1042 ret = ks8842_tx_frame_dma(skb, netdev);
1043
1044 spin_lock_irqsave(&adapter->lock, flags);
1045 if (adapter->dma_tx.adesc)
1046 netif_stop_queue(netdev);
1047 spin_unlock_irqrestore(&adapter->lock, flags);
1048 return ret;
1049 }
1050
1051 ret = ks8842_tx_frame(skb, netdev);
1052
1053 if (ks8842_tx_fifo_space(adapter) < netdev->mtu + 8)
1054 netif_stop_queue(netdev);
1055
1056 return ret;
1057}
1058
1059static int ks8842_set_mac(struct net_device *netdev, void *p)
1060{
1061 struct ks8842_adapter *adapter = netdev_priv(netdev);
1062 struct sockaddr *addr = p;
1063 char *mac = (u8 *)addr->sa_data;
1064
1065 netdev_dbg(netdev, "%s: entry\n", __func__);
1066
1067 if (!is_valid_ether_addr(addr->sa_data))
1068 return -EADDRNOTAVAIL;
1069
1070 memcpy(netdev->dev_addr, mac, netdev->addr_len);
1071
1072 ks8842_write_mac_addr(adapter, mac);
1073 return 0;
1074}
1075
1076static void ks8842_tx_timeout_work(struct work_struct *work)
1077{
1078 struct ks8842_adapter *adapter =
1079 container_of(work, struct ks8842_adapter, timeout_work);
1080 struct net_device *netdev = adapter->netdev;
1081 unsigned long flags;
1082
1083 netdev_dbg(netdev, "%s: entry\n", __func__);
1084
1085 spin_lock_irqsave(&adapter->lock, flags);
1086
1087 if (KS8842_USE_DMA(adapter))
1088 ks8842_stop_dma(adapter);
1089
1090
1091 ks8842_write16(adapter, 18, 0, REG_IER);
1092 ks8842_write16(adapter, 18, 0xFFFF, REG_ISR);
1093
1094 netif_stop_queue(netdev);
1095
1096 spin_unlock_irqrestore(&adapter->lock, flags);
1097
1098 ks8842_reset_hw(adapter);
1099
1100 ks8842_write_mac_addr(adapter, netdev->dev_addr);
1101
1102 ks8842_update_link_status(netdev, adapter);
1103
1104 if (KS8842_USE_DMA(adapter))
1105 __ks8842_start_new_rx_dma(netdev);
1106}
1107
1108static void ks8842_tx_timeout(struct net_device *netdev)
1109{
1110 struct ks8842_adapter *adapter = netdev_priv(netdev);
1111
1112 netdev_dbg(netdev, "%s: entry\n", __func__);
1113
1114 schedule_work(&adapter->timeout_work);
1115}
1116
1117static const struct net_device_ops ks8842_netdev_ops = {
1118 .ndo_open = ks8842_open,
1119 .ndo_stop = ks8842_close,
1120 .ndo_start_xmit = ks8842_xmit_frame,
1121 .ndo_set_mac_address = ks8842_set_mac,
1122 .ndo_tx_timeout = ks8842_tx_timeout,
1123 .ndo_validate_addr = eth_validate_addr
1124};
1125
1126static const struct ethtool_ops ks8842_ethtool_ops = {
1127 .get_link = ethtool_op_get_link,
1128};
1129
1130static int ks8842_probe(struct platform_device *pdev)
1131{
1132 int err = -ENOMEM;
1133 struct resource *iomem;
1134 struct net_device *netdev;
1135 struct ks8842_adapter *adapter;
1136 struct ks8842_platform_data *pdata = dev_get_platdata(&pdev->dev);
1137 u16 id;
1138 unsigned i;
1139
1140 iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1141 if (!request_mem_region(iomem->start, resource_size(iomem), DRV_NAME))
1142 goto err_mem_region;
1143
1144 netdev = alloc_etherdev(sizeof(struct ks8842_adapter));
1145 if (!netdev)
1146 goto err_alloc_etherdev;
1147
1148 SET_NETDEV_DEV(netdev, &pdev->dev);
1149
1150 adapter = netdev_priv(netdev);
1151 adapter->netdev = netdev;
1152 INIT_WORK(&adapter->timeout_work, ks8842_tx_timeout_work);
1153 adapter->hw_addr = ioremap(iomem->start, resource_size(iomem));
1154 adapter->conf_flags = iomem->flags;
1155
1156 if (!adapter->hw_addr)
1157 goto err_ioremap;
1158
1159 adapter->irq = platform_get_irq(pdev, 0);
1160 if (adapter->irq < 0) {
1161 err = adapter->irq;
1162 goto err_get_irq;
1163 }
1164
1165 adapter->dev = (pdev->dev.parent) ? pdev->dev.parent : &pdev->dev;
1166
1167
1168 if (!(adapter->conf_flags & MICREL_KS884X) && pdata &&
1169 (pdata->tx_dma_channel != -1) &&
1170 (pdata->rx_dma_channel != -1)) {
1171 adapter->dma_rx.channel = pdata->rx_dma_channel;
1172 adapter->dma_tx.channel = pdata->tx_dma_channel;
1173 } else {
1174 adapter->dma_rx.channel = -1;
1175 adapter->dma_tx.channel = -1;
1176 }
1177
1178 tasklet_init(&adapter->tasklet, ks8842_tasklet, (unsigned long)netdev);
1179 spin_lock_init(&adapter->lock);
1180
1181 netdev->netdev_ops = &ks8842_netdev_ops;
1182 netdev->ethtool_ops = &ks8842_ethtool_ops;
1183
1184
1185 i = netdev->addr_len;
1186 if (pdata) {
1187 for (i = 0; i < netdev->addr_len; i++)
1188 if (pdata->macaddr[i] != 0)
1189 break;
1190
1191 if (i < netdev->addr_len)
1192
1193 memcpy(netdev->dev_addr, pdata->macaddr,
1194 netdev->addr_len);
1195 }
1196
1197 if (i == netdev->addr_len) {
1198 ks8842_read_mac_addr(adapter, netdev->dev_addr);
1199
1200 if (!is_valid_ether_addr(netdev->dev_addr))
1201 eth_hw_addr_random(netdev);
1202 }
1203
1204 id = ks8842_read16(adapter, 32, REG_SW_ID_AND_ENABLE);
1205
1206 strcpy(netdev->name, "eth%d");
1207 err = register_netdev(netdev);
1208 if (err)
1209 goto err_register;
1210
1211 platform_set_drvdata(pdev, netdev);
1212
1213 pr_info("Found chip, family: 0x%x, id: 0x%x, rev: 0x%x\n",
1214 (id >> 8) & 0xff, (id >> 4) & 0xf, (id >> 1) & 0x7);
1215
1216 return 0;
1217
1218err_register:
1219err_get_irq:
1220 iounmap(adapter->hw_addr);
1221err_ioremap:
1222 free_netdev(netdev);
1223err_alloc_etherdev:
1224 release_mem_region(iomem->start, resource_size(iomem));
1225err_mem_region:
1226 return err;
1227}
1228
1229static int ks8842_remove(struct platform_device *pdev)
1230{
1231 struct net_device *netdev = platform_get_drvdata(pdev);
1232 struct ks8842_adapter *adapter = netdev_priv(netdev);
1233 struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1234
1235 unregister_netdev(netdev);
1236 tasklet_kill(&adapter->tasklet);
1237 iounmap(adapter->hw_addr);
1238 free_netdev(netdev);
1239 release_mem_region(iomem->start, resource_size(iomem));
1240 return 0;
1241}
1242
1243
1244static struct platform_driver ks8842_platform_driver = {
1245 .driver = {
1246 .name = DRV_NAME,
1247 },
1248 .probe = ks8842_probe,
1249 .remove = ks8842_remove,
1250};
1251
1252module_platform_driver(ks8842_platform_driver);
1253
1254MODULE_DESCRIPTION("Timberdale KS8842 ethernet driver");
1255MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
1256MODULE_LICENSE("GPL v2");
1257MODULE_ALIAS("platform:ks8842");
1258
1259