Loading...
Note: File does not exist in v3.1.
1/*
2 * Micrel KS8695 (Centaur) Ethernet.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * Copyright 2008 Simtec Electronics
15 * Daniel Silverstone <dsilvers@simtec.co.uk>
16 * Vincent Sanders <vince@simtec.co.uk>
17 */
18
19#include <linux/dma-mapping.h>
20#include <linux/module.h>
21#include <linux/ioport.h>
22#include <linux/netdevice.h>
23#include <linux/etherdevice.h>
24#include <linux/interrupt.h>
25#include <linux/skbuff.h>
26#include <linux/spinlock.h>
27#include <linux/crc32.h>
28#include <linux/mii.h>
29#include <linux/ethtool.h>
30#include <linux/delay.h>
31#include <linux/platform_device.h>
32#include <linux/irq.h>
33#include <linux/io.h>
34#include <linux/slab.h>
35
36#include <asm/irq.h>
37
38#include <mach/regs-switch.h>
39#include <mach/regs-misc.h>
40#include <asm/mach/irq.h>
41#include <mach/regs-irq.h>
42
43#include "ks8695net.h"
44
45#define MODULENAME "ks8695_ether"
46#define MODULEVERSION "1.02"
47
48/*
49 * Transmit and device reset timeout, default 5 seconds.
50 */
51static int watchdog = 5000;
52
53/* Hardware structures */
54
55/**
56 * struct rx_ring_desc - Receive descriptor ring element
57 * @status: The status of the descriptor element (E.g. who owns it)
58 * @length: The number of bytes in the block pointed to by data_ptr
59 * @data_ptr: The physical address of the data block to receive into
60 * @next_desc: The physical address of the next descriptor element.
61 */
62struct rx_ring_desc {
63 __le32 status;
64 __le32 length;
65 __le32 data_ptr;
66 __le32 next_desc;
67};
68
69/**
70 * struct tx_ring_desc - Transmit descriptor ring element
71 * @owner: Who owns the descriptor
72 * @status: The number of bytes in the block pointed to by data_ptr
73 * @data_ptr: The physical address of the data block to receive into
74 * @next_desc: The physical address of the next descriptor element.
75 */
76struct tx_ring_desc {
77 __le32 owner;
78 __le32 status;
79 __le32 data_ptr;
80 __le32 next_desc;
81};
82
83/**
84 * struct ks8695_skbuff - sk_buff wrapper for rx/tx rings.
85 * @skb: The buffer in the ring
86 * @dma_ptr: The mapped DMA pointer of the buffer
87 * @length: The number of bytes mapped to dma_ptr
88 */
89struct ks8695_skbuff {
90 struct sk_buff *skb;
91 dma_addr_t dma_ptr;
92 u32 length;
93};
94
95/* Private device structure */
96
97#define MAX_TX_DESC 8
98#define MAX_TX_DESC_MASK 0x7
99#define MAX_RX_DESC 16
100#define MAX_RX_DESC_MASK 0xf
101
102/*napi_weight have better more than rx DMA buffers*/
103#define NAPI_WEIGHT 64
104
105#define MAX_RXBUF_SIZE 0x700
106
107#define TX_RING_DMA_SIZE (sizeof(struct tx_ring_desc) * MAX_TX_DESC)
108#define RX_RING_DMA_SIZE (sizeof(struct rx_ring_desc) * MAX_RX_DESC)
109#define RING_DMA_SIZE (TX_RING_DMA_SIZE + RX_RING_DMA_SIZE)
110
111/**
112 * enum ks8695_dtype - Device type
113 * @KS8695_DTYPE_WAN: This device is a WAN interface
114 * @KS8695_DTYPE_LAN: This device is a LAN interface
115 * @KS8695_DTYPE_HPNA: This device is an HPNA interface
116 */
117enum ks8695_dtype {
118 KS8695_DTYPE_WAN,
119 KS8695_DTYPE_LAN,
120 KS8695_DTYPE_HPNA,
121};
122
123/**
124 * struct ks8695_priv - Private data for the KS8695 Ethernet
125 * @in_suspend: Flag to indicate if we're suspending/resuming
126 * @ndev: The net_device for this interface
127 * @dev: The platform device object for this interface
128 * @dtype: The type of this device
129 * @io_regs: The ioremapped registers for this interface
130 * @napi : Add support NAPI for Rx
131 * @rx_irq_name: The textual name of the RX IRQ from the platform data
132 * @tx_irq_name: The textual name of the TX IRQ from the platform data
133 * @link_irq_name: The textual name of the link IRQ from the
134 * platform data if available
135 * @rx_irq: The IRQ number for the RX IRQ
136 * @tx_irq: The IRQ number for the TX IRQ
137 * @link_irq: The IRQ number for the link IRQ if available
138 * @regs_req: The resource request for the registers region
139 * @phyiface_req: The resource request for the phy/switch region
140 * if available
141 * @phyiface_regs: The ioremapped registers for the phy/switch if available
142 * @ring_base: The base pointer of the dma coherent memory for the rings
143 * @ring_base_dma: The DMA mapped equivalent of ring_base
144 * @tx_ring: The pointer in ring_base of the TX ring
145 * @tx_ring_used: The number of slots in the TX ring which are occupied
146 * @tx_ring_next_slot: The next slot to fill in the TX ring
147 * @tx_ring_dma: The DMA mapped equivalent of tx_ring
148 * @tx_buffers: The sk_buff mappings for the TX ring
149 * @txq_lock: A lock to protect the tx_buffers tx_ring_used etc variables
150 * @rx_ring: The pointer in ring_base of the RX ring
151 * @rx_ring_dma: The DMA mapped equivalent of rx_ring
152 * @rx_buffers: The sk_buff mappings for the RX ring
153 * @next_rx_desc_read: The next RX descriptor to read from on IRQ
154 * @rx_lock: A lock to protect Rx irq function
155 * @msg_enable: The flags for which messages to emit
156 */
157struct ks8695_priv {
158 int in_suspend;
159 struct net_device *ndev;
160 struct device *dev;
161 enum ks8695_dtype dtype;
162 void __iomem *io_regs;
163
164 struct napi_struct napi;
165
166 const char *rx_irq_name, *tx_irq_name, *link_irq_name;
167 int rx_irq, tx_irq, link_irq;
168
169 struct resource *regs_req, *phyiface_req;
170 void __iomem *phyiface_regs;
171
172 void *ring_base;
173 dma_addr_t ring_base_dma;
174
175 struct tx_ring_desc *tx_ring;
176 int tx_ring_used;
177 int tx_ring_next_slot;
178 dma_addr_t tx_ring_dma;
179 struct ks8695_skbuff tx_buffers[MAX_TX_DESC];
180 spinlock_t txq_lock;
181
182 struct rx_ring_desc *rx_ring;
183 dma_addr_t rx_ring_dma;
184 struct ks8695_skbuff rx_buffers[MAX_RX_DESC];
185 int next_rx_desc_read;
186 spinlock_t rx_lock;
187
188 int msg_enable;
189};
190
191/* Register access */
192
193/**
194 * ks8695_readreg - Read from a KS8695 ethernet register
195 * @ksp: The device to read from
196 * @reg: The register to read
197 */
198static inline u32
199ks8695_readreg(struct ks8695_priv *ksp, int reg)
200{
201 return readl(ksp->io_regs + reg);
202}
203
204/**
205 * ks8695_writereg - Write to a KS8695 ethernet register
206 * @ksp: The device to write to
207 * @reg: The register to write
208 * @value: The value to write to the register
209 */
210static inline void
211ks8695_writereg(struct ks8695_priv *ksp, int reg, u32 value)
212{
213 writel(value, ksp->io_regs + reg);
214}
215
216/* Utility functions */
217
218/**
219 * ks8695_port_type - Retrieve port-type as user-friendly string
220 * @ksp: The device to return the type for
221 *
222 * Returns a string indicating which of the WAN, LAN or HPNA
223 * ports this device is likely to represent.
224 */
225static const char *
226ks8695_port_type(struct ks8695_priv *ksp)
227{
228 switch (ksp->dtype) {
229 case KS8695_DTYPE_LAN:
230 return "LAN";
231 case KS8695_DTYPE_WAN:
232 return "WAN";
233 case KS8695_DTYPE_HPNA:
234 return "HPNA";
235 }
236
237 return "UNKNOWN";
238}
239
240/**
241 * ks8695_update_mac - Update the MAC registers in the device
242 * @ksp: The device to update
243 *
244 * Updates the MAC registers in the KS8695 device from the address in the
245 * net_device structure associated with this interface.
246 */
247static void
248ks8695_update_mac(struct ks8695_priv *ksp)
249{
250 /* Update the HW with the MAC from the net_device */
251 struct net_device *ndev = ksp->ndev;
252 u32 machigh, maclow;
253
254 maclow = ((ndev->dev_addr[2] << 24) | (ndev->dev_addr[3] << 16) |
255 (ndev->dev_addr[4] << 8) | (ndev->dev_addr[5] << 0));
256 machigh = ((ndev->dev_addr[0] << 8) | (ndev->dev_addr[1] << 0));
257
258 ks8695_writereg(ksp, KS8695_MAL, maclow);
259 ks8695_writereg(ksp, KS8695_MAH, machigh);
260
261}
262
263/**
264 * ks8695_refill_rxbuffers - Re-fill the RX buffer ring
265 * @ksp: The device to refill
266 *
267 * Iterates the RX ring of the device looking for empty slots.
268 * For each empty slot, we allocate and map a new SKB and give it
269 * to the hardware.
270 * This can be called from interrupt context safely.
271 */
272static void
273ks8695_refill_rxbuffers(struct ks8695_priv *ksp)
274{
275 /* Run around the RX ring, filling in any missing sk_buff's */
276 int buff_n;
277
278 for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) {
279 if (!ksp->rx_buffers[buff_n].skb) {
280 struct sk_buff *skb =
281 netdev_alloc_skb(ksp->ndev, MAX_RXBUF_SIZE);
282 dma_addr_t mapping;
283
284 ksp->rx_buffers[buff_n].skb = skb;
285 if (skb == NULL) {
286 /* Failed to allocate one, perhaps
287 * we'll try again later.
288 */
289 break;
290 }
291
292 mapping = dma_map_single(ksp->dev, skb->data,
293 MAX_RXBUF_SIZE,
294 DMA_FROM_DEVICE);
295 if (unlikely(dma_mapping_error(ksp->dev, mapping))) {
296 /* Failed to DMA map this SKB, try later */
297 dev_kfree_skb_irq(skb);
298 ksp->rx_buffers[buff_n].skb = NULL;
299 break;
300 }
301 ksp->rx_buffers[buff_n].dma_ptr = mapping;
302 ksp->rx_buffers[buff_n].length = MAX_RXBUF_SIZE;
303
304 /* Record this into the DMA ring */
305 ksp->rx_ring[buff_n].data_ptr = cpu_to_le32(mapping);
306 ksp->rx_ring[buff_n].length =
307 cpu_to_le32(MAX_RXBUF_SIZE);
308
309 wmb();
310
311 /* And give ownership over to the hardware */
312 ksp->rx_ring[buff_n].status = cpu_to_le32(RDES_OWN);
313 }
314 }
315}
316
317/* Maximum number of multicast addresses which the KS8695 HW supports */
318#define KS8695_NR_ADDRESSES 16
319
320/**
321 * ks8695_init_partial_multicast - Init the mcast addr registers
322 * @ksp: The device to initialise
323 * @addr: The multicast address list to use
324 * @nr_addr: The number of addresses in the list
325 *
326 * This routine is a helper for ks8695_set_multicast - it writes
327 * the additional-address registers in the KS8695 ethernet device
328 * and cleans up any others left behind.
329 */
330static void
331ks8695_init_partial_multicast(struct ks8695_priv *ksp,
332 struct net_device *ndev)
333{
334 u32 low, high;
335 int i;
336 struct netdev_hw_addr *ha;
337
338 i = 0;
339 netdev_for_each_mc_addr(ha, ndev) {
340 /* Ran out of space in chip? */
341 BUG_ON(i == KS8695_NR_ADDRESSES);
342
343 low = (ha->addr[2] << 24) | (ha->addr[3] << 16) |
344 (ha->addr[4] << 8) | (ha->addr[5]);
345 high = (ha->addr[0] << 8) | (ha->addr[1]);
346
347 ks8695_writereg(ksp, KS8695_AAL_(i), low);
348 ks8695_writereg(ksp, KS8695_AAH_(i), AAH_E | high);
349 i++;
350 }
351
352 /* Clear the remaining Additional Station Addresses */
353 for (; i < KS8695_NR_ADDRESSES; i++) {
354 ks8695_writereg(ksp, KS8695_AAL_(i), 0);
355 ks8695_writereg(ksp, KS8695_AAH_(i), 0);
356 }
357}
358
359/* Interrupt handling */
360
361/**
362 * ks8695_tx_irq - Transmit IRQ handler
363 * @irq: The IRQ which went off (ignored)
364 * @dev_id: The net_device for the interrupt
365 *
366 * Process the TX ring, clearing out any transmitted slots.
367 * Allows the net_device to pass us new packets once slots are
368 * freed.
369 */
370static irqreturn_t
371ks8695_tx_irq(int irq, void *dev_id)
372{
373 struct net_device *ndev = (struct net_device *)dev_id;
374 struct ks8695_priv *ksp = netdev_priv(ndev);
375 int buff_n;
376
377 for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) {
378 if (ksp->tx_buffers[buff_n].skb &&
379 !(ksp->tx_ring[buff_n].owner & cpu_to_le32(TDES_OWN))) {
380 rmb();
381 /* An SKB which is not owned by HW is present */
382 /* Update the stats for the net_device */
383 ndev->stats.tx_packets++;
384 ndev->stats.tx_bytes += ksp->tx_buffers[buff_n].length;
385
386 /* Free the packet from the ring */
387 ksp->tx_ring[buff_n].data_ptr = 0;
388
389 /* Free the sk_buff */
390 dma_unmap_single(ksp->dev,
391 ksp->tx_buffers[buff_n].dma_ptr,
392 ksp->tx_buffers[buff_n].length,
393 DMA_TO_DEVICE);
394 dev_kfree_skb_irq(ksp->tx_buffers[buff_n].skb);
395 ksp->tx_buffers[buff_n].skb = NULL;
396 ksp->tx_ring_used--;
397 }
398 }
399
400 netif_wake_queue(ndev);
401
402 return IRQ_HANDLED;
403}
404
405/**
406 * ks8695_get_rx_enable_bit - Get rx interrupt enable/status bit
407 * @ksp: Private data for the KS8695 Ethernet
408 *
409 * For KS8695 document:
410 * Interrupt Enable Register (offset 0xE204)
411 * Bit29 : WAN MAC Receive Interrupt Enable
412 * Bit16 : LAN MAC Receive Interrupt Enable
413 * Interrupt Status Register (Offset 0xF208)
414 * Bit29: WAN MAC Receive Status
415 * Bit16: LAN MAC Receive Status
416 * So, this Rx interrupt enable/status bit number is equal
417 * as Rx IRQ number.
418 */
419static inline u32 ks8695_get_rx_enable_bit(struct ks8695_priv *ksp)
420{
421 return ksp->rx_irq;
422}
423
424/**
425 * ks8695_rx_irq - Receive IRQ handler
426 * @irq: The IRQ which went off (ignored)
427 * @dev_id: The net_device for the interrupt
428 *
429 * Inform NAPI that packet reception needs to be scheduled
430 */
431
432static irqreturn_t
433ks8695_rx_irq(int irq, void *dev_id)
434{
435 struct net_device *ndev = (struct net_device *)dev_id;
436 struct ks8695_priv *ksp = netdev_priv(ndev);
437
438 spin_lock(&ksp->rx_lock);
439
440 if (napi_schedule_prep(&ksp->napi)) {
441 unsigned long status = readl(KS8695_IRQ_VA + KS8695_INTEN);
442 unsigned long mask_bit = 1 << ks8695_get_rx_enable_bit(ksp);
443 /*disable rx interrupt*/
444 status &= ~mask_bit;
445 writel(status , KS8695_IRQ_VA + KS8695_INTEN);
446 __napi_schedule(&ksp->napi);
447 }
448
449 spin_unlock(&ksp->rx_lock);
450 return IRQ_HANDLED;
451}
452
453/**
454 * ks8695_rx - Receive packets called by NAPI poll method
455 * @ksp: Private data for the KS8695 Ethernet
456 * @budget: Number of packets allowed to process
457 */
458static int ks8695_rx(struct ks8695_priv *ksp, int budget)
459{
460 struct net_device *ndev = ksp->ndev;
461 struct sk_buff *skb;
462 int buff_n;
463 u32 flags;
464 int pktlen;
465 int received = 0;
466
467 buff_n = ksp->next_rx_desc_read;
468 while (received < budget
469 && ksp->rx_buffers[buff_n].skb
470 && (!(ksp->rx_ring[buff_n].status &
471 cpu_to_le32(RDES_OWN)))) {
472 rmb();
473 flags = le32_to_cpu(ksp->rx_ring[buff_n].status);
474
475 /* Found an SKB which we own, this means we
476 * received a packet
477 */
478 if ((flags & (RDES_FS | RDES_LS)) !=
479 (RDES_FS | RDES_LS)) {
480 /* This packet is not the first and
481 * the last segment. Therefore it is
482 * a "spanning" packet and we can't
483 * handle it
484 */
485 goto rx_failure;
486 }
487
488 if (flags & (RDES_ES | RDES_RE)) {
489 /* It's an error packet */
490 ndev->stats.rx_errors++;
491 if (flags & RDES_TL)
492 ndev->stats.rx_length_errors++;
493 if (flags & RDES_RF)
494 ndev->stats.rx_length_errors++;
495 if (flags & RDES_CE)
496 ndev->stats.rx_crc_errors++;
497 if (flags & RDES_RE)
498 ndev->stats.rx_missed_errors++;
499
500 goto rx_failure;
501 }
502
503 pktlen = flags & RDES_FLEN;
504 pktlen -= 4; /* Drop the CRC */
505
506 /* Retrieve the sk_buff */
507 skb = ksp->rx_buffers[buff_n].skb;
508
509 /* Clear it from the ring */
510 ksp->rx_buffers[buff_n].skb = NULL;
511 ksp->rx_ring[buff_n].data_ptr = 0;
512
513 /* Unmap the SKB */
514 dma_unmap_single(ksp->dev,
515 ksp->rx_buffers[buff_n].dma_ptr,
516 ksp->rx_buffers[buff_n].length,
517 DMA_FROM_DEVICE);
518
519 /* Relinquish the SKB to the network layer */
520 skb_put(skb, pktlen);
521 skb->protocol = eth_type_trans(skb, ndev);
522 netif_receive_skb(skb);
523
524 /* Record stats */
525 ndev->stats.rx_packets++;
526 ndev->stats.rx_bytes += pktlen;
527 goto rx_finished;
528
529rx_failure:
530 /* This ring entry is an error, but we can
531 * re-use the skb
532 */
533 /* Give the ring entry back to the hardware */
534 ksp->rx_ring[buff_n].status = cpu_to_le32(RDES_OWN);
535rx_finished:
536 received++;
537 buff_n = (buff_n + 1) & MAX_RX_DESC_MASK;
538 }
539
540 /* And note which RX descriptor we last did */
541 ksp->next_rx_desc_read = buff_n;
542
543 /* And refill the buffers */
544 ks8695_refill_rxbuffers(ksp);
545
546 /* Kick the RX DMA engine, in case it became suspended */
547 ks8695_writereg(ksp, KS8695_DRSC, 0);
548
549 return received;
550}
551
552
553/**
554 * ks8695_poll - Receive packet by NAPI poll method
555 * @ksp: Private data for the KS8695 Ethernet
556 * @budget: The remaining number packets for network subsystem
557 *
558 * Invoked by the network core when it requests for new
559 * packets from the driver
560 */
561static int ks8695_poll(struct napi_struct *napi, int budget)
562{
563 struct ks8695_priv *ksp = container_of(napi, struct ks8695_priv, napi);
564 unsigned long work_done;
565
566 unsigned long isr = readl(KS8695_IRQ_VA + KS8695_INTEN);
567 unsigned long mask_bit = 1 << ks8695_get_rx_enable_bit(ksp);
568
569 work_done = ks8695_rx(ksp, budget);
570
571 if (work_done < budget) {
572 unsigned long flags;
573 spin_lock_irqsave(&ksp->rx_lock, flags);
574 __napi_complete(napi);
575 /*enable rx interrupt*/
576 writel(isr | mask_bit, KS8695_IRQ_VA + KS8695_INTEN);
577 spin_unlock_irqrestore(&ksp->rx_lock, flags);
578 }
579 return work_done;
580}
581
582/**
583 * ks8695_link_irq - Link change IRQ handler
584 * @irq: The IRQ which went off (ignored)
585 * @dev_id: The net_device for the interrupt
586 *
587 * The WAN interface can generate an IRQ when the link changes,
588 * report this to the net layer and the user.
589 */
590static irqreturn_t
591ks8695_link_irq(int irq, void *dev_id)
592{
593 struct net_device *ndev = (struct net_device *)dev_id;
594 struct ks8695_priv *ksp = netdev_priv(ndev);
595 u32 ctrl;
596
597 ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
598 if (ctrl & WMC_WLS) {
599 netif_carrier_on(ndev);
600 if (netif_msg_link(ksp))
601 dev_info(ksp->dev,
602 "%s: Link is now up (10%sMbps/%s-duplex)\n",
603 ndev->name,
604 (ctrl & WMC_WSS) ? "0" : "",
605 (ctrl & WMC_WDS) ? "Full" : "Half");
606 } else {
607 netif_carrier_off(ndev);
608 if (netif_msg_link(ksp))
609 dev_info(ksp->dev, "%s: Link is now down.\n",
610 ndev->name);
611 }
612
613 return IRQ_HANDLED;
614}
615
616
617/* KS8695 Device functions */
618
619/**
620 * ks8695_reset - Reset a KS8695 ethernet interface
621 * @ksp: The interface to reset
622 *
623 * Perform an engine reset of the interface and re-program it
624 * with sensible defaults.
625 */
626static void
627ks8695_reset(struct ks8695_priv *ksp)
628{
629 int reset_timeout = watchdog;
630 /* Issue the reset via the TX DMA control register */
631 ks8695_writereg(ksp, KS8695_DTXC, DTXC_TRST);
632 while (reset_timeout--) {
633 if (!(ks8695_readreg(ksp, KS8695_DTXC) & DTXC_TRST))
634 break;
635 msleep(1);
636 }
637
638 if (reset_timeout < 0) {
639 dev_crit(ksp->dev,
640 "Timeout waiting for DMA engines to reset\n");
641 /* And blithely carry on */
642 }
643
644 /* Definitely wait long enough before attempting to program
645 * the engines
646 */
647 msleep(10);
648
649 /* RX: unicast and broadcast */
650 ks8695_writereg(ksp, KS8695_DRXC, DRXC_RU | DRXC_RB);
651 /* TX: pad and add CRC */
652 ks8695_writereg(ksp, KS8695_DTXC, DTXC_TEP | DTXC_TAC);
653}
654
655/**
656 * ks8695_shutdown - Shut down a KS8695 ethernet interface
657 * @ksp: The interface to shut down
658 *
659 * This disables packet RX/TX, cleans up IRQs, drains the rings,
660 * and basically places the interface into a clean shutdown
661 * state.
662 */
663static void
664ks8695_shutdown(struct ks8695_priv *ksp)
665{
666 u32 ctrl;
667 int buff_n;
668
669 /* Disable packet transmission */
670 ctrl = ks8695_readreg(ksp, KS8695_DTXC);
671 ks8695_writereg(ksp, KS8695_DTXC, ctrl & ~DTXC_TE);
672
673 /* Disable packet reception */
674 ctrl = ks8695_readreg(ksp, KS8695_DRXC);
675 ks8695_writereg(ksp, KS8695_DRXC, ctrl & ~DRXC_RE);
676
677 /* Release the IRQs */
678 free_irq(ksp->rx_irq, ksp->ndev);
679 free_irq(ksp->tx_irq, ksp->ndev);
680 if (ksp->link_irq != -1)
681 free_irq(ksp->link_irq, ksp->ndev);
682
683 /* Throw away any pending TX packets */
684 for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) {
685 if (ksp->tx_buffers[buff_n].skb) {
686 /* Remove this SKB from the TX ring */
687 ksp->tx_ring[buff_n].owner = 0;
688 ksp->tx_ring[buff_n].status = 0;
689 ksp->tx_ring[buff_n].data_ptr = 0;
690
691 /* Unmap and bin this SKB */
692 dma_unmap_single(ksp->dev,
693 ksp->tx_buffers[buff_n].dma_ptr,
694 ksp->tx_buffers[buff_n].length,
695 DMA_TO_DEVICE);
696 dev_kfree_skb_irq(ksp->tx_buffers[buff_n].skb);
697 ksp->tx_buffers[buff_n].skb = NULL;
698 }
699 }
700
701 /* Purge the RX buffers */
702 for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) {
703 if (ksp->rx_buffers[buff_n].skb) {
704 /* Remove the SKB from the RX ring */
705 ksp->rx_ring[buff_n].status = 0;
706 ksp->rx_ring[buff_n].data_ptr = 0;
707
708 /* Unmap and bin the SKB */
709 dma_unmap_single(ksp->dev,
710 ksp->rx_buffers[buff_n].dma_ptr,
711 ksp->rx_buffers[buff_n].length,
712 DMA_FROM_DEVICE);
713 dev_kfree_skb_irq(ksp->rx_buffers[buff_n].skb);
714 ksp->rx_buffers[buff_n].skb = NULL;
715 }
716 }
717}
718
719
720/**
721 * ks8695_setup_irq - IRQ setup helper function
722 * @irq: The IRQ number to claim
723 * @irq_name: The name to give the IRQ claimant
724 * @handler: The function to call to handle the IRQ
725 * @ndev: The net_device to pass in as the dev_id argument to the handler
726 *
727 * Return 0 on success.
728 */
729static int
730ks8695_setup_irq(int irq, const char *irq_name,
731 irq_handler_t handler, struct net_device *ndev)
732{
733 int ret;
734
735 ret = request_irq(irq, handler, IRQF_SHARED, irq_name, ndev);
736
737 if (ret) {
738 dev_err(&ndev->dev, "failure to request IRQ %d\n", irq);
739 return ret;
740 }
741
742 return 0;
743}
744
745/**
746 * ks8695_init_net - Initialise a KS8695 ethernet interface
747 * @ksp: The interface to initialise
748 *
749 * This routine fills the RX ring, initialises the DMA engines,
750 * allocates the IRQs and then starts the packet TX and RX
751 * engines.
752 */
753static int
754ks8695_init_net(struct ks8695_priv *ksp)
755{
756 int ret;
757 u32 ctrl;
758
759 ks8695_refill_rxbuffers(ksp);
760
761 /* Initialise the DMA engines */
762 ks8695_writereg(ksp, KS8695_RDLB, (u32) ksp->rx_ring_dma);
763 ks8695_writereg(ksp, KS8695_TDLB, (u32) ksp->tx_ring_dma);
764
765 /* Request the IRQs */
766 ret = ks8695_setup_irq(ksp->rx_irq, ksp->rx_irq_name,
767 ks8695_rx_irq, ksp->ndev);
768 if (ret)
769 return ret;
770 ret = ks8695_setup_irq(ksp->tx_irq, ksp->tx_irq_name,
771 ks8695_tx_irq, ksp->ndev);
772 if (ret)
773 return ret;
774 if (ksp->link_irq != -1) {
775 ret = ks8695_setup_irq(ksp->link_irq, ksp->link_irq_name,
776 ks8695_link_irq, ksp->ndev);
777 if (ret)
778 return ret;
779 }
780
781 /* Set up the ring indices */
782 ksp->next_rx_desc_read = 0;
783 ksp->tx_ring_next_slot = 0;
784 ksp->tx_ring_used = 0;
785
786 /* Bring up transmission */
787 ctrl = ks8695_readreg(ksp, KS8695_DTXC);
788 /* Enable packet transmission */
789 ks8695_writereg(ksp, KS8695_DTXC, ctrl | DTXC_TE);
790
791 /* Bring up the reception */
792 ctrl = ks8695_readreg(ksp, KS8695_DRXC);
793 /* Enable packet reception */
794 ks8695_writereg(ksp, KS8695_DRXC, ctrl | DRXC_RE);
795 /* And start the DMA engine */
796 ks8695_writereg(ksp, KS8695_DRSC, 0);
797
798 /* All done */
799 return 0;
800}
801
802/**
803 * ks8695_release_device - HW resource release for KS8695 e-net
804 * @ksp: The device to be freed
805 *
806 * This unallocates io memory regions, dma-coherent regions etc
807 * which were allocated in ks8695_probe.
808 */
809static void
810ks8695_release_device(struct ks8695_priv *ksp)
811{
812 /* Unmap the registers */
813 iounmap(ksp->io_regs);
814 if (ksp->phyiface_regs)
815 iounmap(ksp->phyiface_regs);
816
817 /* And release the request */
818 release_resource(ksp->regs_req);
819 kfree(ksp->regs_req);
820 if (ksp->phyiface_req) {
821 release_resource(ksp->phyiface_req);
822 kfree(ksp->phyiface_req);
823 }
824
825 /* Free the ring buffers */
826 dma_free_coherent(ksp->dev, RING_DMA_SIZE,
827 ksp->ring_base, ksp->ring_base_dma);
828}
829
830/* Ethtool support */
831
832/**
833 * ks8695_get_msglevel - Get the messages enabled for emission
834 * @ndev: The network device to read from
835 */
836static u32
837ks8695_get_msglevel(struct net_device *ndev)
838{
839 struct ks8695_priv *ksp = netdev_priv(ndev);
840
841 return ksp->msg_enable;
842}
843
844/**
845 * ks8695_set_msglevel - Set the messages enabled for emission
846 * @ndev: The network device to configure
847 * @value: The messages to set for emission
848 */
849static void
850ks8695_set_msglevel(struct net_device *ndev, u32 value)
851{
852 struct ks8695_priv *ksp = netdev_priv(ndev);
853
854 ksp->msg_enable = value;
855}
856
857/**
858 * ks8695_wan_get_settings - Get device-specific settings.
859 * @ndev: The network device to read settings from
860 * @cmd: The ethtool structure to read into
861 */
862static int
863ks8695_wan_get_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
864{
865 struct ks8695_priv *ksp = netdev_priv(ndev);
866 u32 ctrl;
867
868 /* All ports on the KS8695 support these... */
869 cmd->supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
870 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
871 SUPPORTED_TP | SUPPORTED_MII);
872 cmd->transceiver = XCVR_INTERNAL;
873
874 cmd->advertising = ADVERTISED_TP | ADVERTISED_MII;
875 cmd->port = PORT_MII;
876 cmd->supported |= (SUPPORTED_Autoneg | SUPPORTED_Pause);
877 cmd->phy_address = 0;
878
879 ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
880 if ((ctrl & WMC_WAND) == 0) {
881 /* auto-negotiation is enabled */
882 cmd->advertising |= ADVERTISED_Autoneg;
883 if (ctrl & WMC_WANA100F)
884 cmd->advertising |= ADVERTISED_100baseT_Full;
885 if (ctrl & WMC_WANA100H)
886 cmd->advertising |= ADVERTISED_100baseT_Half;
887 if (ctrl & WMC_WANA10F)
888 cmd->advertising |= ADVERTISED_10baseT_Full;
889 if (ctrl & WMC_WANA10H)
890 cmd->advertising |= ADVERTISED_10baseT_Half;
891 if (ctrl & WMC_WANAP)
892 cmd->advertising |= ADVERTISED_Pause;
893 cmd->autoneg = AUTONEG_ENABLE;
894
895 ethtool_cmd_speed_set(cmd,
896 (ctrl & WMC_WSS) ? SPEED_100 : SPEED_10);
897 cmd->duplex = (ctrl & WMC_WDS) ?
898 DUPLEX_FULL : DUPLEX_HALF;
899 } else {
900 /* auto-negotiation is disabled */
901 cmd->autoneg = AUTONEG_DISABLE;
902
903 ethtool_cmd_speed_set(cmd, ((ctrl & WMC_WANF100) ?
904 SPEED_100 : SPEED_10));
905 cmd->duplex = (ctrl & WMC_WANFF) ?
906 DUPLEX_FULL : DUPLEX_HALF;
907 }
908
909 return 0;
910}
911
912/**
913 * ks8695_wan_set_settings - Set device-specific settings.
914 * @ndev: The network device to configure
915 * @cmd: The settings to configure
916 */
917static int
918ks8695_wan_set_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
919{
920 struct ks8695_priv *ksp = netdev_priv(ndev);
921 u32 ctrl;
922
923 if ((cmd->speed != SPEED_10) && (cmd->speed != SPEED_100))
924 return -EINVAL;
925 if ((cmd->duplex != DUPLEX_HALF) && (cmd->duplex != DUPLEX_FULL))
926 return -EINVAL;
927 if (cmd->port != PORT_MII)
928 return -EINVAL;
929 if (cmd->transceiver != XCVR_INTERNAL)
930 return -EINVAL;
931 if ((cmd->autoneg != AUTONEG_DISABLE) &&
932 (cmd->autoneg != AUTONEG_ENABLE))
933 return -EINVAL;
934
935 if (cmd->autoneg == AUTONEG_ENABLE) {
936 if ((cmd->advertising & (ADVERTISED_10baseT_Half |
937 ADVERTISED_10baseT_Full |
938 ADVERTISED_100baseT_Half |
939 ADVERTISED_100baseT_Full)) == 0)
940 return -EINVAL;
941
942 ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
943
944 ctrl &= ~(WMC_WAND | WMC_WANA100F | WMC_WANA100H |
945 WMC_WANA10F | WMC_WANA10H);
946 if (cmd->advertising & ADVERTISED_100baseT_Full)
947 ctrl |= WMC_WANA100F;
948 if (cmd->advertising & ADVERTISED_100baseT_Half)
949 ctrl |= WMC_WANA100H;
950 if (cmd->advertising & ADVERTISED_10baseT_Full)
951 ctrl |= WMC_WANA10F;
952 if (cmd->advertising & ADVERTISED_10baseT_Half)
953 ctrl |= WMC_WANA10H;
954
955 /* force a re-negotiation */
956 ctrl |= WMC_WANR;
957 writel(ctrl, ksp->phyiface_regs + KS8695_WMC);
958 } else {
959 ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
960
961 /* disable auto-negotiation */
962 ctrl |= WMC_WAND;
963 ctrl &= ~(WMC_WANF100 | WMC_WANFF);
964
965 if (cmd->speed == SPEED_100)
966 ctrl |= WMC_WANF100;
967 if (cmd->duplex == DUPLEX_FULL)
968 ctrl |= WMC_WANFF;
969
970 writel(ctrl, ksp->phyiface_regs + KS8695_WMC);
971 }
972
973 return 0;
974}
975
976/**
977 * ks8695_wan_nwayreset - Restart the autonegotiation on the port.
978 * @ndev: The network device to restart autoneotiation on
979 */
980static int
981ks8695_wan_nwayreset(struct net_device *ndev)
982{
983 struct ks8695_priv *ksp = netdev_priv(ndev);
984 u32 ctrl;
985
986 ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
987
988 if ((ctrl & WMC_WAND) == 0)
989 writel(ctrl | WMC_WANR,
990 ksp->phyiface_regs + KS8695_WMC);
991 else
992 /* auto-negotiation not enabled */
993 return -EINVAL;
994
995 return 0;
996}
997
998/**
999 * ks8695_wan_get_pause - Retrieve network pause/flow-control advertising
1000 * @ndev: The device to retrieve settings from
1001 * @param: The structure to fill out with the information
1002 */
1003static void
1004ks8695_wan_get_pause(struct net_device *ndev, struct ethtool_pauseparam *param)
1005{
1006 struct ks8695_priv *ksp = netdev_priv(ndev);
1007 u32 ctrl;
1008
1009 ctrl = readl(ksp->phyiface_regs + KS8695_WMC);
1010
1011 /* advertise Pause */
1012 param->autoneg = (ctrl & WMC_WANAP);
1013
1014 /* current Rx Flow-control */
1015 ctrl = ks8695_readreg(ksp, KS8695_DRXC);
1016 param->rx_pause = (ctrl & DRXC_RFCE);
1017
1018 /* current Tx Flow-control */
1019 ctrl = ks8695_readreg(ksp, KS8695_DTXC);
1020 param->tx_pause = (ctrl & DTXC_TFCE);
1021}
1022
1023/**
1024 * ks8695_get_drvinfo - Retrieve driver information
1025 * @ndev: The network device to retrieve info about
1026 * @info: The info structure to fill out.
1027 */
1028static void
1029ks8695_get_drvinfo(struct net_device *ndev, struct ethtool_drvinfo *info)
1030{
1031 strlcpy(info->driver, MODULENAME, sizeof(info->driver));
1032 strlcpy(info->version, MODULEVERSION, sizeof(info->version));
1033 strlcpy(info->bus_info, dev_name(ndev->dev.parent),
1034 sizeof(info->bus_info));
1035}
1036
1037static const struct ethtool_ops ks8695_ethtool_ops = {
1038 .get_msglevel = ks8695_get_msglevel,
1039 .set_msglevel = ks8695_set_msglevel,
1040 .get_drvinfo = ks8695_get_drvinfo,
1041};
1042
1043static const struct ethtool_ops ks8695_wan_ethtool_ops = {
1044 .get_msglevel = ks8695_get_msglevel,
1045 .set_msglevel = ks8695_set_msglevel,
1046 .get_settings = ks8695_wan_get_settings,
1047 .set_settings = ks8695_wan_set_settings,
1048 .nway_reset = ks8695_wan_nwayreset,
1049 .get_link = ethtool_op_get_link,
1050 .get_pauseparam = ks8695_wan_get_pause,
1051 .get_drvinfo = ks8695_get_drvinfo,
1052};
1053
1054/* Network device interface functions */
1055
1056/**
1057 * ks8695_set_mac - Update MAC in net dev and HW
1058 * @ndev: The network device to update
1059 * @addr: The new MAC address to set
1060 */
1061static int
1062ks8695_set_mac(struct net_device *ndev, void *addr)
1063{
1064 struct ks8695_priv *ksp = netdev_priv(ndev);
1065 struct sockaddr *address = addr;
1066
1067 if (!is_valid_ether_addr(address->sa_data))
1068 return -EADDRNOTAVAIL;
1069
1070 memcpy(ndev->dev_addr, address->sa_data, ndev->addr_len);
1071
1072 ks8695_update_mac(ksp);
1073
1074 dev_dbg(ksp->dev, "%s: Updated MAC address to %pM\n",
1075 ndev->name, ndev->dev_addr);
1076
1077 return 0;
1078}
1079
1080/**
1081 * ks8695_set_multicast - Set up the multicast behaviour of the interface
1082 * @ndev: The net_device to configure
1083 *
1084 * This routine, called by the net layer, configures promiscuity
1085 * and multicast reception behaviour for the interface.
1086 */
1087static void
1088ks8695_set_multicast(struct net_device *ndev)
1089{
1090 struct ks8695_priv *ksp = netdev_priv(ndev);
1091 u32 ctrl;
1092
1093 ctrl = ks8695_readreg(ksp, KS8695_DRXC);
1094
1095 if (ndev->flags & IFF_PROMISC) {
1096 /* enable promiscuous mode */
1097 ctrl |= DRXC_RA;
1098 } else if (ndev->flags & ~IFF_PROMISC) {
1099 /* disable promiscuous mode */
1100 ctrl &= ~DRXC_RA;
1101 }
1102
1103 if (ndev->flags & IFF_ALLMULTI) {
1104 /* enable all multicast mode */
1105 ctrl |= DRXC_RM;
1106 } else if (netdev_mc_count(ndev) > KS8695_NR_ADDRESSES) {
1107 /* more specific multicast addresses than can be
1108 * handled in hardware
1109 */
1110 ctrl |= DRXC_RM;
1111 } else {
1112 /* enable specific multicasts */
1113 ctrl &= ~DRXC_RM;
1114 ks8695_init_partial_multicast(ksp, ndev);
1115 }
1116
1117 ks8695_writereg(ksp, KS8695_DRXC, ctrl);
1118}
1119
1120/**
1121 * ks8695_timeout - Handle a network tx/rx timeout.
1122 * @ndev: The net_device which timed out.
1123 *
1124 * A network transaction timed out, reset the device.
1125 */
1126static void
1127ks8695_timeout(struct net_device *ndev)
1128{
1129 struct ks8695_priv *ksp = netdev_priv(ndev);
1130
1131 netif_stop_queue(ndev);
1132 ks8695_shutdown(ksp);
1133
1134 ks8695_reset(ksp);
1135
1136 ks8695_update_mac(ksp);
1137
1138 /* We ignore the return from this since it managed to init
1139 * before it probably will be okay to init again.
1140 */
1141 ks8695_init_net(ksp);
1142
1143 /* Reconfigure promiscuity etc */
1144 ks8695_set_multicast(ndev);
1145
1146 /* And start the TX queue once more */
1147 netif_start_queue(ndev);
1148}
1149
1150/**
1151 * ks8695_start_xmit - Start a packet transmission
1152 * @skb: The packet to transmit
1153 * @ndev: The network device to send the packet on
1154 *
1155 * This routine, called by the net layer, takes ownership of the
1156 * sk_buff and adds it to the TX ring. It then kicks the TX DMA
1157 * engine to ensure transmission begins.
1158 */
1159static int
1160ks8695_start_xmit(struct sk_buff *skb, struct net_device *ndev)
1161{
1162 struct ks8695_priv *ksp = netdev_priv(ndev);
1163 int buff_n;
1164 dma_addr_t dmap;
1165
1166 spin_lock_irq(&ksp->txq_lock);
1167
1168 if (ksp->tx_ring_used == MAX_TX_DESC) {
1169 /* Somehow we got entered when we have no room */
1170 spin_unlock_irq(&ksp->txq_lock);
1171 return NETDEV_TX_BUSY;
1172 }
1173
1174 buff_n = ksp->tx_ring_next_slot;
1175
1176 BUG_ON(ksp->tx_buffers[buff_n].skb);
1177
1178 dmap = dma_map_single(ksp->dev, skb->data, skb->len, DMA_TO_DEVICE);
1179 if (unlikely(dma_mapping_error(ksp->dev, dmap))) {
1180 /* Failed to DMA map this SKB, give it back for now */
1181 spin_unlock_irq(&ksp->txq_lock);
1182 dev_dbg(ksp->dev, "%s: Could not map DMA memory for "\
1183 "transmission, trying later\n", ndev->name);
1184 return NETDEV_TX_BUSY;
1185 }
1186
1187 ksp->tx_buffers[buff_n].dma_ptr = dmap;
1188 /* Mapped okay, store the buffer pointer and length for later */
1189 ksp->tx_buffers[buff_n].skb = skb;
1190 ksp->tx_buffers[buff_n].length = skb->len;
1191
1192 /* Fill out the TX descriptor */
1193 ksp->tx_ring[buff_n].data_ptr =
1194 cpu_to_le32(ksp->tx_buffers[buff_n].dma_ptr);
1195 ksp->tx_ring[buff_n].status =
1196 cpu_to_le32(TDES_IC | TDES_FS | TDES_LS |
1197 (skb->len & TDES_TBS));
1198
1199 wmb();
1200
1201 /* Hand it over to the hardware */
1202 ksp->tx_ring[buff_n].owner = cpu_to_le32(TDES_OWN);
1203
1204 if (++ksp->tx_ring_used == MAX_TX_DESC)
1205 netif_stop_queue(ndev);
1206
1207 /* Kick the TX DMA in case it decided to go IDLE */
1208 ks8695_writereg(ksp, KS8695_DTSC, 0);
1209
1210 /* And update the next ring slot */
1211 ksp->tx_ring_next_slot = (buff_n + 1) & MAX_TX_DESC_MASK;
1212
1213 spin_unlock_irq(&ksp->txq_lock);
1214 return NETDEV_TX_OK;
1215}
1216
1217/**
1218 * ks8695_stop - Stop (shutdown) a KS8695 ethernet interface
1219 * @ndev: The net_device to stop
1220 *
1221 * This disables the TX queue and cleans up a KS8695 ethernet
1222 * device.
1223 */
1224static int
1225ks8695_stop(struct net_device *ndev)
1226{
1227 struct ks8695_priv *ksp = netdev_priv(ndev);
1228
1229 netif_stop_queue(ndev);
1230 napi_disable(&ksp->napi);
1231
1232 ks8695_shutdown(ksp);
1233
1234 return 0;
1235}
1236
1237/**
1238 * ks8695_open - Open (bring up) a KS8695 ethernet interface
1239 * @ndev: The net_device to open
1240 *
1241 * This resets, configures the MAC, initialises the RX ring and
1242 * DMA engines and starts the TX queue for a KS8695 ethernet
1243 * device.
1244 */
1245static int
1246ks8695_open(struct net_device *ndev)
1247{
1248 struct ks8695_priv *ksp = netdev_priv(ndev);
1249 int ret;
1250
1251 ks8695_reset(ksp);
1252
1253 ks8695_update_mac(ksp);
1254
1255 ret = ks8695_init_net(ksp);
1256 if (ret) {
1257 ks8695_shutdown(ksp);
1258 return ret;
1259 }
1260
1261 napi_enable(&ksp->napi);
1262 netif_start_queue(ndev);
1263
1264 return 0;
1265}
1266
1267/* Platform device driver */
1268
1269/**
1270 * ks8695_init_switch - Init LAN switch to known good defaults.
1271 * @ksp: The device to initialise
1272 *
1273 * This initialises the LAN switch in the KS8695 to a known-good
1274 * set of defaults.
1275 */
1276static void
1277ks8695_init_switch(struct ks8695_priv *ksp)
1278{
1279 u32 ctrl;
1280
1281 /* Default value for SEC0 according to datasheet */
1282 ctrl = 0x40819e00;
1283
1284 /* LED0 = Speed LED1 = Link/Activity */
1285 ctrl &= ~(SEC0_LLED1S | SEC0_LLED0S);
1286 ctrl |= (LLED0S_LINK | LLED1S_LINK_ACTIVITY);
1287
1288 /* Enable Switch */
1289 ctrl |= SEC0_ENABLE;
1290
1291 writel(ctrl, ksp->phyiface_regs + KS8695_SEC0);
1292
1293 /* Defaults for SEC1 */
1294 writel(0x9400100, ksp->phyiface_regs + KS8695_SEC1);
1295}
1296
1297/**
1298 * ks8695_init_wan_phy - Initialise the WAN PHY to sensible defaults
1299 * @ksp: The device to initialise
1300 *
1301 * This initialises a KS8695's WAN phy to sensible values for
1302 * autonegotiation etc.
1303 */
1304static void
1305ks8695_init_wan_phy(struct ks8695_priv *ksp)
1306{
1307 u32 ctrl;
1308
1309 /* Support auto-negotiation */
1310 ctrl = (WMC_WANAP | WMC_WANA100F | WMC_WANA100H |
1311 WMC_WANA10F | WMC_WANA10H);
1312
1313 /* LED0 = Activity , LED1 = Link */
1314 ctrl |= (WLED0S_ACTIVITY | WLED1S_LINK);
1315
1316 /* Restart Auto-negotiation */
1317 ctrl |= WMC_WANR;
1318
1319 writel(ctrl, ksp->phyiface_regs + KS8695_WMC);
1320
1321 writel(0, ksp->phyiface_regs + KS8695_WPPM);
1322 writel(0, ksp->phyiface_regs + KS8695_PPS);
1323}
1324
1325static const struct net_device_ops ks8695_netdev_ops = {
1326 .ndo_open = ks8695_open,
1327 .ndo_stop = ks8695_stop,
1328 .ndo_start_xmit = ks8695_start_xmit,
1329 .ndo_tx_timeout = ks8695_timeout,
1330 .ndo_set_mac_address = ks8695_set_mac,
1331 .ndo_validate_addr = eth_validate_addr,
1332 .ndo_set_rx_mode = ks8695_set_multicast,
1333};
1334
1335/**
1336 * ks8695_probe - Probe and initialise a KS8695 ethernet interface
1337 * @pdev: The platform device to probe
1338 *
1339 * Initialise a KS8695 ethernet device from platform data.
1340 *
1341 * This driver requires at least one IORESOURCE_MEM for the
1342 * registers and two IORESOURCE_IRQ for the RX and TX IRQs
1343 * respectively. It can optionally take an additional
1344 * IORESOURCE_MEM for the switch or phy in the case of the lan or
1345 * wan ports, and an IORESOURCE_IRQ for the link IRQ for the wan
1346 * port.
1347 */
1348static int
1349ks8695_probe(struct platform_device *pdev)
1350{
1351 struct ks8695_priv *ksp;
1352 struct net_device *ndev;
1353 struct resource *regs_res, *phyiface_res;
1354 struct resource *rxirq_res, *txirq_res, *linkirq_res;
1355 int ret = 0;
1356 int buff_n;
1357 bool inv_mac_addr = false;
1358 u32 machigh, maclow;
1359
1360 /* Initialise a net_device */
1361 ndev = alloc_etherdev(sizeof(struct ks8695_priv));
1362 if (!ndev)
1363 return -ENOMEM;
1364
1365 SET_NETDEV_DEV(ndev, &pdev->dev);
1366
1367 dev_dbg(&pdev->dev, "ks8695_probe() called\n");
1368
1369 /* Configure our private structure a little */
1370 ksp = netdev_priv(ndev);
1371
1372 ksp->dev = &pdev->dev;
1373 ksp->ndev = ndev;
1374 ksp->msg_enable = NETIF_MSG_LINK;
1375
1376 /* Retrieve resources */
1377 regs_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1378 phyiface_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1379
1380 rxirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1381 txirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
1382 linkirq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 2);
1383
1384 if (!(regs_res && rxirq_res && txirq_res)) {
1385 dev_err(ksp->dev, "insufficient resources\n");
1386 ret = -ENOENT;
1387 goto failure;
1388 }
1389
1390 ksp->regs_req = request_mem_region(regs_res->start,
1391 resource_size(regs_res),
1392 pdev->name);
1393
1394 if (!ksp->regs_req) {
1395 dev_err(ksp->dev, "cannot claim register space\n");
1396 ret = -EIO;
1397 goto failure;
1398 }
1399
1400 ksp->io_regs = ioremap(regs_res->start, resource_size(regs_res));
1401
1402 if (!ksp->io_regs) {
1403 dev_err(ksp->dev, "failed to ioremap registers\n");
1404 ret = -EINVAL;
1405 goto failure;
1406 }
1407
1408 if (phyiface_res) {
1409 ksp->phyiface_req =
1410 request_mem_region(phyiface_res->start,
1411 resource_size(phyiface_res),
1412 phyiface_res->name);
1413
1414 if (!ksp->phyiface_req) {
1415 dev_err(ksp->dev,
1416 "cannot claim switch register space\n");
1417 ret = -EIO;
1418 goto failure;
1419 }
1420
1421 ksp->phyiface_regs = ioremap(phyiface_res->start,
1422 resource_size(phyiface_res));
1423
1424 if (!ksp->phyiface_regs) {
1425 dev_err(ksp->dev,
1426 "failed to ioremap switch registers\n");
1427 ret = -EINVAL;
1428 goto failure;
1429 }
1430 }
1431
1432 ksp->rx_irq = rxirq_res->start;
1433 ksp->rx_irq_name = rxirq_res->name ? rxirq_res->name : "Ethernet RX";
1434 ksp->tx_irq = txirq_res->start;
1435 ksp->tx_irq_name = txirq_res->name ? txirq_res->name : "Ethernet TX";
1436 ksp->link_irq = (linkirq_res ? linkirq_res->start : -1);
1437 ksp->link_irq_name = (linkirq_res && linkirq_res->name) ?
1438 linkirq_res->name : "Ethernet Link";
1439
1440 /* driver system setup */
1441 ndev->netdev_ops = &ks8695_netdev_ops;
1442 ndev->watchdog_timeo = msecs_to_jiffies(watchdog);
1443
1444 netif_napi_add(ndev, &ksp->napi, ks8695_poll, NAPI_WEIGHT);
1445
1446 /* Retrieve the default MAC addr from the chip. */
1447 /* The bootloader should have left it in there for us. */
1448
1449 machigh = ks8695_readreg(ksp, KS8695_MAH);
1450 maclow = ks8695_readreg(ksp, KS8695_MAL);
1451
1452 ndev->dev_addr[0] = (machigh >> 8) & 0xFF;
1453 ndev->dev_addr[1] = machigh & 0xFF;
1454 ndev->dev_addr[2] = (maclow >> 24) & 0xFF;
1455 ndev->dev_addr[3] = (maclow >> 16) & 0xFF;
1456 ndev->dev_addr[4] = (maclow >> 8) & 0xFF;
1457 ndev->dev_addr[5] = maclow & 0xFF;
1458
1459 if (!is_valid_ether_addr(ndev->dev_addr))
1460 inv_mac_addr = true;
1461
1462 /* In order to be efficient memory-wise, we allocate both
1463 * rings in one go.
1464 */
1465 ksp->ring_base = dma_alloc_coherent(&pdev->dev, RING_DMA_SIZE,
1466 &ksp->ring_base_dma, GFP_KERNEL);
1467 if (!ksp->ring_base) {
1468 ret = -ENOMEM;
1469 goto failure;
1470 }
1471
1472 /* Specify the TX DMA ring buffer */
1473 ksp->tx_ring = ksp->ring_base;
1474 ksp->tx_ring_dma = ksp->ring_base_dma;
1475
1476 /* And initialise the queue's lock */
1477 spin_lock_init(&ksp->txq_lock);
1478 spin_lock_init(&ksp->rx_lock);
1479
1480 /* Specify the RX DMA ring buffer */
1481 ksp->rx_ring = ksp->ring_base + TX_RING_DMA_SIZE;
1482 ksp->rx_ring_dma = ksp->ring_base_dma + TX_RING_DMA_SIZE;
1483
1484 /* Zero the descriptor rings */
1485 memset(ksp->tx_ring, 0, TX_RING_DMA_SIZE);
1486 memset(ksp->rx_ring, 0, RX_RING_DMA_SIZE);
1487
1488 /* Build the rings */
1489 for (buff_n = 0; buff_n < MAX_TX_DESC; ++buff_n) {
1490 ksp->tx_ring[buff_n].next_desc =
1491 cpu_to_le32(ksp->tx_ring_dma +
1492 (sizeof(struct tx_ring_desc) *
1493 ((buff_n + 1) & MAX_TX_DESC_MASK)));
1494 }
1495
1496 for (buff_n = 0; buff_n < MAX_RX_DESC; ++buff_n) {
1497 ksp->rx_ring[buff_n].next_desc =
1498 cpu_to_le32(ksp->rx_ring_dma +
1499 (sizeof(struct rx_ring_desc) *
1500 ((buff_n + 1) & MAX_RX_DESC_MASK)));
1501 }
1502
1503 /* Initialise the port (physically) */
1504 if (ksp->phyiface_regs && ksp->link_irq == -1) {
1505 ks8695_init_switch(ksp);
1506 ksp->dtype = KS8695_DTYPE_LAN;
1507 ndev->ethtool_ops = &ks8695_ethtool_ops;
1508 } else if (ksp->phyiface_regs && ksp->link_irq != -1) {
1509 ks8695_init_wan_phy(ksp);
1510 ksp->dtype = KS8695_DTYPE_WAN;
1511 ndev->ethtool_ops = &ks8695_wan_ethtool_ops;
1512 } else {
1513 /* No initialisation since HPNA does not have a PHY */
1514 ksp->dtype = KS8695_DTYPE_HPNA;
1515 ndev->ethtool_ops = &ks8695_ethtool_ops;
1516 }
1517
1518 /* And bring up the net_device with the net core */
1519 platform_set_drvdata(pdev, ndev);
1520 ret = register_netdev(ndev);
1521
1522 if (ret == 0) {
1523 if (inv_mac_addr)
1524 dev_warn(ksp->dev, "%s: Invalid ethernet MAC address. Please set using ip\n",
1525 ndev->name);
1526 dev_info(ksp->dev, "ks8695 ethernet (%s) MAC: %pM\n",
1527 ks8695_port_type(ksp), ndev->dev_addr);
1528 } else {
1529 /* Report the failure to register the net_device */
1530 dev_err(ksp->dev, "ks8695net: failed to register netdev.\n");
1531 goto failure;
1532 }
1533
1534 /* All is well */
1535 return 0;
1536
1537 /* Error exit path */
1538failure:
1539 ks8695_release_device(ksp);
1540 free_netdev(ndev);
1541
1542 return ret;
1543}
1544
1545/**
1546 * ks8695_drv_suspend - Suspend a KS8695 ethernet platform device.
1547 * @pdev: The device to suspend
1548 * @state: The suspend state
1549 *
1550 * This routine detaches and shuts down a KS8695 ethernet device.
1551 */
1552static int
1553ks8695_drv_suspend(struct platform_device *pdev, pm_message_t state)
1554{
1555 struct net_device *ndev = platform_get_drvdata(pdev);
1556 struct ks8695_priv *ksp = netdev_priv(ndev);
1557
1558 ksp->in_suspend = 1;
1559
1560 if (netif_running(ndev)) {
1561 netif_device_detach(ndev);
1562 ks8695_shutdown(ksp);
1563 }
1564
1565 return 0;
1566}
1567
1568/**
1569 * ks8695_drv_resume - Resume a KS8695 ethernet platform device.
1570 * @pdev: The device to resume
1571 *
1572 * This routine re-initialises and re-attaches a KS8695 ethernet
1573 * device.
1574 */
1575static int
1576ks8695_drv_resume(struct platform_device *pdev)
1577{
1578 struct net_device *ndev = platform_get_drvdata(pdev);
1579 struct ks8695_priv *ksp = netdev_priv(ndev);
1580
1581 if (netif_running(ndev)) {
1582 ks8695_reset(ksp);
1583 ks8695_init_net(ksp);
1584 ks8695_set_multicast(ndev);
1585 netif_device_attach(ndev);
1586 }
1587
1588 ksp->in_suspend = 0;
1589
1590 return 0;
1591}
1592
1593/**
1594 * ks8695_drv_remove - Remove a KS8695 net device on driver unload.
1595 * @pdev: The platform device to remove
1596 *
1597 * This unregisters and releases a KS8695 ethernet device.
1598 */
1599static int
1600ks8695_drv_remove(struct platform_device *pdev)
1601{
1602 struct net_device *ndev = platform_get_drvdata(pdev);
1603 struct ks8695_priv *ksp = netdev_priv(ndev);
1604
1605 netif_napi_del(&ksp->napi);
1606
1607 unregister_netdev(ndev);
1608 ks8695_release_device(ksp);
1609 free_netdev(ndev);
1610
1611 dev_dbg(&pdev->dev, "released and freed device\n");
1612 return 0;
1613}
1614
1615static struct platform_driver ks8695_driver = {
1616 .driver = {
1617 .name = MODULENAME,
1618 },
1619 .probe = ks8695_probe,
1620 .remove = ks8695_drv_remove,
1621 .suspend = ks8695_drv_suspend,
1622 .resume = ks8695_drv_resume,
1623};
1624
1625module_platform_driver(ks8695_driver);
1626
1627MODULE_AUTHOR("Simtec Electronics");
1628MODULE_DESCRIPTION("Micrel KS8695 (Centaur) Ethernet driver");
1629MODULE_LICENSE("GPL");
1630MODULE_ALIAS("platform:" MODULENAME);
1631
1632module_param(watchdog, int, 0400);
1633MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");