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