1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Micrel KS8695 (Centaur) Ethernet.
5 * Copyright 2008 Simtec Electronics
6 * Daniel Silverstone <dsilvers@simtec.co.uk>
7 * Vincent Sanders <vince@simtec.co.uk>
10 #include <linux/dma-mapping.h>
11 #include <linux/module.h>
12 #include <linux/ioport.h>
13 #include <linux/netdevice.h>
14 #include <linux/etherdevice.h>
15 #include <linux/interrupt.h>
16 #include <linux/skbuff.h>
17 #include <linux/spinlock.h>
18 #include <linux/crc32.h>
19 #include <linux/mii.h>
20 #include <linux/ethtool.h>
21 #include <linux/delay.h>
22 #include <linux/platform_device.h>
23 #include <linux/irq.h>
25 #include <linux/slab.h>
29 #include <mach/regs-switch.h>
30 #include <mach/regs-misc.h>
31 #include <asm/mach/irq.h>
32 #include <mach/regs-irq.h>
34 #include "ks8695net.h"
36 #define MODULENAME "ks8695_ether"
37 #define MODULEVERSION "1.02"
40 * Transmit and device reset timeout, default 5 seconds.
42 static int watchdog
= 5000;
44 /* Hardware structures */
47 * struct rx_ring_desc - Receive descriptor ring element
48 * @status: The status of the descriptor element (E.g. who owns it)
49 * @length: The number of bytes in the block pointed to by data_ptr
50 * @data_ptr: The physical address of the data block to receive into
51 * @next_desc: The physical address of the next descriptor element.
61 * struct tx_ring_desc - Transmit descriptor ring element
62 * @owner: Who owns the descriptor
63 * @status: The number of bytes in the block pointed to by data_ptr
64 * @data_ptr: The physical address of the data block to receive into
65 * @next_desc: The physical address of the next descriptor element.
75 * struct ks8695_skbuff - sk_buff wrapper for rx/tx rings.
76 * @skb: The buffer in the ring
77 * @dma_ptr: The mapped DMA pointer of the buffer
78 * @length: The number of bytes mapped to dma_ptr
80 struct ks8695_skbuff
{
86 /* Private device structure */
89 #define MAX_TX_DESC_MASK 0x7
90 #define MAX_RX_DESC 16
91 #define MAX_RX_DESC_MASK 0xf
93 /*napi_weight have better more than rx DMA buffers*/
94 #define NAPI_WEIGHT 64
96 #define MAX_RXBUF_SIZE 0x700
98 #define TX_RING_DMA_SIZE (sizeof(struct tx_ring_desc) * MAX_TX_DESC)
99 #define RX_RING_DMA_SIZE (sizeof(struct rx_ring_desc) * MAX_RX_DESC)
100 #define RING_DMA_SIZE (TX_RING_DMA_SIZE + RX_RING_DMA_SIZE)
103 * enum ks8695_dtype - Device type
104 * @KS8695_DTYPE_WAN: This device is a WAN interface
105 * @KS8695_DTYPE_LAN: This device is a LAN interface
106 * @KS8695_DTYPE_HPNA: This device is an HPNA interface
115 * struct ks8695_priv - Private data for the KS8695 Ethernet
116 * @in_suspend: Flag to indicate if we're suspending/resuming
117 * @ndev: The net_device for this interface
118 * @dev: The platform device object for this interface
119 * @dtype: The type of this device
120 * @io_regs: The ioremapped registers for this interface
121 * @napi : Add support NAPI for Rx
122 * @rx_irq_name: The textual name of the RX IRQ from the platform data
123 * @tx_irq_name: The textual name of the TX IRQ from the platform data
124 * @link_irq_name: The textual name of the link IRQ from the
125 * platform data if available
126 * @rx_irq: The IRQ number for the RX IRQ
127 * @tx_irq: The IRQ number for the TX IRQ
128 * @link_irq: The IRQ number for the link IRQ if available
129 * @regs_req: The resource request for the registers region
130 * @phyiface_req: The resource request for the phy/switch region
132 * @phyiface_regs: The ioremapped registers for the phy/switch if available
133 * @ring_base: The base pointer of the dma coherent memory for the rings
134 * @ring_base_dma: The DMA mapped equivalent of ring_base
135 * @tx_ring: The pointer in ring_base of the TX ring
136 * @tx_ring_used: The number of slots in the TX ring which are occupied
137 * @tx_ring_next_slot: The next slot to fill in the TX ring
138 * @tx_ring_dma: The DMA mapped equivalent of tx_ring
139 * @tx_buffers: The sk_buff mappings for the TX ring
140 * @txq_lock: A lock to protect the tx_buffers tx_ring_used etc variables
141 * @rx_ring: The pointer in ring_base of the RX ring
142 * @rx_ring_dma: The DMA mapped equivalent of rx_ring
143 * @rx_buffers: The sk_buff mappings for the RX ring
144 * @next_rx_desc_read: The next RX descriptor to read from on IRQ
145 * @rx_lock: A lock to protect Rx irq function
146 * @msg_enable: The flags for which messages to emit
150 struct net_device
*ndev
;
152 enum ks8695_dtype dtype
;
153 void __iomem
*io_regs
;
155 struct napi_struct napi
;
157 const char *rx_irq_name
, *tx_irq_name
, *link_irq_name
;
158 int rx_irq
, tx_irq
, link_irq
;
160 struct resource
*regs_req
, *phyiface_req
;
161 void __iomem
*phyiface_regs
;
164 dma_addr_t ring_base_dma
;
166 struct tx_ring_desc
*tx_ring
;
168 int tx_ring_next_slot
;
169 dma_addr_t tx_ring_dma
;
170 struct ks8695_skbuff tx_buffers
[MAX_TX_DESC
];
173 struct rx_ring_desc
*rx_ring
;
174 dma_addr_t rx_ring_dma
;
175 struct ks8695_skbuff rx_buffers
[MAX_RX_DESC
];
176 int next_rx_desc_read
;
182 /* Register access */
185 * ks8695_readreg - Read from a KS8695 ethernet register
186 * @ksp: The device to read from
187 * @reg: The register to read
190 ks8695_readreg(struct ks8695_priv
*ksp
, int reg
)
192 return readl(ksp
->io_regs
+ reg
);
196 * ks8695_writereg - Write to a KS8695 ethernet register
197 * @ksp: The device to write to
198 * @reg: The register to write
199 * @value: The value to write to the register
202 ks8695_writereg(struct ks8695_priv
*ksp
, int reg
, u32 value
)
204 writel(value
, ksp
->io_regs
+ reg
);
207 /* Utility functions */
210 * ks8695_port_type - Retrieve port-type as user-friendly string
211 * @ksp: The device to return the type for
213 * Returns a string indicating which of the WAN, LAN or HPNA
214 * ports this device is likely to represent.
217 ks8695_port_type(struct ks8695_priv
*ksp
)
219 switch (ksp
->dtype
) {
220 case KS8695_DTYPE_LAN
:
222 case KS8695_DTYPE_WAN
:
224 case KS8695_DTYPE_HPNA
:
232 * ks8695_update_mac - Update the MAC registers in the device
233 * @ksp: The device to update
235 * Updates the MAC registers in the KS8695 device from the address in the
236 * net_device structure associated with this interface.
239 ks8695_update_mac(struct ks8695_priv
*ksp
)
241 /* Update the HW with the MAC from the net_device */
242 struct net_device
*ndev
= ksp
->ndev
;
245 maclow
= ((ndev
->dev_addr
[2] << 24) | (ndev
->dev_addr
[3] << 16) |
246 (ndev
->dev_addr
[4] << 8) | (ndev
->dev_addr
[5] << 0));
247 machigh
= ((ndev
->dev_addr
[0] << 8) | (ndev
->dev_addr
[1] << 0));
249 ks8695_writereg(ksp
, KS8695_MAL
, maclow
);
250 ks8695_writereg(ksp
, KS8695_MAH
, machigh
);
255 * ks8695_refill_rxbuffers - Re-fill the RX buffer ring
256 * @ksp: The device to refill
258 * Iterates the RX ring of the device looking for empty slots.
259 * For each empty slot, we allocate and map a new SKB and give it
261 * This can be called from interrupt context safely.
264 ks8695_refill_rxbuffers(struct ks8695_priv
*ksp
)
266 /* Run around the RX ring, filling in any missing sk_buff's */
269 for (buff_n
= 0; buff_n
< MAX_RX_DESC
; ++buff_n
) {
270 if (!ksp
->rx_buffers
[buff_n
].skb
) {
271 struct sk_buff
*skb
=
272 netdev_alloc_skb(ksp
->ndev
, MAX_RXBUF_SIZE
);
275 ksp
->rx_buffers
[buff_n
].skb
= skb
;
277 /* Failed to allocate one, perhaps
278 * we'll try again later.
283 mapping
= dma_map_single(ksp
->dev
, skb
->data
,
286 if (unlikely(dma_mapping_error(ksp
->dev
, mapping
))) {
287 /* Failed to DMA map this SKB, try later */
288 dev_kfree_skb_irq(skb
);
289 ksp
->rx_buffers
[buff_n
].skb
= NULL
;
292 ksp
->rx_buffers
[buff_n
].dma_ptr
= mapping
;
293 ksp
->rx_buffers
[buff_n
].length
= MAX_RXBUF_SIZE
;
295 /* Record this into the DMA ring */
296 ksp
->rx_ring
[buff_n
].data_ptr
= cpu_to_le32(mapping
);
297 ksp
->rx_ring
[buff_n
].length
=
298 cpu_to_le32(MAX_RXBUF_SIZE
);
302 /* And give ownership over to the hardware */
303 ksp
->rx_ring
[buff_n
].status
= cpu_to_le32(RDES_OWN
);
308 /* Maximum number of multicast addresses which the KS8695 HW supports */
309 #define KS8695_NR_ADDRESSES 16
312 * ks8695_init_partial_multicast - Init the mcast addr registers
313 * @ksp: The device to initialise
314 * @addr: The multicast address list to use
315 * @nr_addr: The number of addresses in the list
317 * This routine is a helper for ks8695_set_multicast - it writes
318 * the additional-address registers in the KS8695 ethernet device
319 * and cleans up any others left behind.
322 ks8695_init_partial_multicast(struct ks8695_priv
*ksp
,
323 struct net_device
*ndev
)
327 struct netdev_hw_addr
*ha
;
330 netdev_for_each_mc_addr(ha
, ndev
) {
331 /* Ran out of space in chip? */
332 BUG_ON(i
== KS8695_NR_ADDRESSES
);
334 low
= (ha
->addr
[2] << 24) | (ha
->addr
[3] << 16) |
335 (ha
->addr
[4] << 8) | (ha
->addr
[5]);
336 high
= (ha
->addr
[0] << 8) | (ha
->addr
[1]);
338 ks8695_writereg(ksp
, KS8695_AAL_(i
), low
);
339 ks8695_writereg(ksp
, KS8695_AAH_(i
), AAH_E
| high
);
343 /* Clear the remaining Additional Station Addresses */
344 for (; i
< KS8695_NR_ADDRESSES
; i
++) {
345 ks8695_writereg(ksp
, KS8695_AAL_(i
), 0);
346 ks8695_writereg(ksp
, KS8695_AAH_(i
), 0);
350 /* Interrupt handling */
353 * ks8695_tx_irq - Transmit IRQ handler
354 * @irq: The IRQ which went off (ignored)
355 * @dev_id: The net_device for the interrupt
357 * Process the TX ring, clearing out any transmitted slots.
358 * Allows the net_device to pass us new packets once slots are
362 ks8695_tx_irq(int irq
, void *dev_id
)
364 struct net_device
*ndev
= (struct net_device
*)dev_id
;
365 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
368 for (buff_n
= 0; buff_n
< MAX_TX_DESC
; ++buff_n
) {
369 if (ksp
->tx_buffers
[buff_n
].skb
&&
370 !(ksp
->tx_ring
[buff_n
].owner
& cpu_to_le32(TDES_OWN
))) {
372 /* An SKB which is not owned by HW is present */
373 /* Update the stats for the net_device */
374 ndev
->stats
.tx_packets
++;
375 ndev
->stats
.tx_bytes
+= ksp
->tx_buffers
[buff_n
].length
;
377 /* Free the packet from the ring */
378 ksp
->tx_ring
[buff_n
].data_ptr
= 0;
380 /* Free the sk_buff */
381 dma_unmap_single(ksp
->dev
,
382 ksp
->tx_buffers
[buff_n
].dma_ptr
,
383 ksp
->tx_buffers
[buff_n
].length
,
385 dev_consume_skb_irq(ksp
->tx_buffers
[buff_n
].skb
);
386 ksp
->tx_buffers
[buff_n
].skb
= NULL
;
391 netif_wake_queue(ndev
);
397 * ks8695_get_rx_enable_bit - Get rx interrupt enable/status bit
398 * @ksp: Private data for the KS8695 Ethernet
400 * For KS8695 document:
401 * Interrupt Enable Register (offset 0xE204)
402 * Bit29 : WAN MAC Receive Interrupt Enable
403 * Bit16 : LAN MAC Receive Interrupt Enable
404 * Interrupt Status Register (Offset 0xF208)
405 * Bit29: WAN MAC Receive Status
406 * Bit16: LAN MAC Receive Status
407 * So, this Rx interrupt enable/status bit number is equal
410 static inline u32
ks8695_get_rx_enable_bit(struct ks8695_priv
*ksp
)
416 * ks8695_rx_irq - Receive IRQ handler
417 * @irq: The IRQ which went off (ignored)
418 * @dev_id: The net_device for the interrupt
420 * Inform NAPI that packet reception needs to be scheduled
424 ks8695_rx_irq(int irq
, void *dev_id
)
426 struct net_device
*ndev
= (struct net_device
*)dev_id
;
427 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
429 spin_lock(&ksp
->rx_lock
);
431 if (napi_schedule_prep(&ksp
->napi
)) {
432 unsigned long status
= readl(KS8695_IRQ_VA
+ KS8695_INTEN
);
433 unsigned long mask_bit
= 1 << ks8695_get_rx_enable_bit(ksp
);
434 /*disable rx interrupt*/
436 writel(status
, KS8695_IRQ_VA
+ KS8695_INTEN
);
437 __napi_schedule(&ksp
->napi
);
440 spin_unlock(&ksp
->rx_lock
);
445 * ks8695_rx - Receive packets called by NAPI poll method
446 * @ksp: Private data for the KS8695 Ethernet
447 * @budget: Number of packets allowed to process
449 static int ks8695_rx(struct ks8695_priv
*ksp
, int budget
)
451 struct net_device
*ndev
= ksp
->ndev
;
458 buff_n
= ksp
->next_rx_desc_read
;
459 while (received
< budget
460 && ksp
->rx_buffers
[buff_n
].skb
461 && (!(ksp
->rx_ring
[buff_n
].status
&
462 cpu_to_le32(RDES_OWN
)))) {
464 flags
= le32_to_cpu(ksp
->rx_ring
[buff_n
].status
);
466 /* Found an SKB which we own, this means we
469 if ((flags
& (RDES_FS
| RDES_LS
)) !=
470 (RDES_FS
| RDES_LS
)) {
471 /* This packet is not the first and
472 * the last segment. Therefore it is
473 * a "spanning" packet and we can't
479 if (flags
& (RDES_ES
| RDES_RE
)) {
480 /* It's an error packet */
481 ndev
->stats
.rx_errors
++;
483 ndev
->stats
.rx_length_errors
++;
485 ndev
->stats
.rx_length_errors
++;
487 ndev
->stats
.rx_crc_errors
++;
489 ndev
->stats
.rx_missed_errors
++;
494 pktlen
= flags
& RDES_FLEN
;
495 pktlen
-= 4; /* Drop the CRC */
497 /* Retrieve the sk_buff */
498 skb
= ksp
->rx_buffers
[buff_n
].skb
;
500 /* Clear it from the ring */
501 ksp
->rx_buffers
[buff_n
].skb
= NULL
;
502 ksp
->rx_ring
[buff_n
].data_ptr
= 0;
505 dma_unmap_single(ksp
->dev
,
506 ksp
->rx_buffers
[buff_n
].dma_ptr
,
507 ksp
->rx_buffers
[buff_n
].length
,
510 /* Relinquish the SKB to the network layer */
511 skb_put(skb
, pktlen
);
512 skb
->protocol
= eth_type_trans(skb
, ndev
);
513 napi_gro_receive(&ksp
->napi
, skb
);
516 ndev
->stats
.rx_packets
++;
517 ndev
->stats
.rx_bytes
+= pktlen
;
521 /* This ring entry is an error, but we can
524 /* Give the ring entry back to the hardware */
525 ksp
->rx_ring
[buff_n
].status
= cpu_to_le32(RDES_OWN
);
528 buff_n
= (buff_n
+ 1) & MAX_RX_DESC_MASK
;
531 /* And note which RX descriptor we last did */
532 ksp
->next_rx_desc_read
= buff_n
;
534 /* And refill the buffers */
535 ks8695_refill_rxbuffers(ksp
);
537 /* Kick the RX DMA engine, in case it became suspended */
538 ks8695_writereg(ksp
, KS8695_DRSC
, 0);
545 * ks8695_poll - Receive packet by NAPI poll method
546 * @ksp: Private data for the KS8695 Ethernet
547 * @budget: The remaining number packets for network subsystem
549 * Invoked by the network core when it requests for new
550 * packets from the driver
552 static int ks8695_poll(struct napi_struct
*napi
, int budget
)
554 struct ks8695_priv
*ksp
= container_of(napi
, struct ks8695_priv
, napi
);
555 unsigned long isr
= readl(KS8695_IRQ_VA
+ KS8695_INTEN
);
556 unsigned long mask_bit
= 1 << ks8695_get_rx_enable_bit(ksp
);
559 work_done
= ks8695_rx(ksp
, budget
);
561 if (work_done
< budget
&& napi_complete_done(napi
, work_done
)) {
564 spin_lock_irqsave(&ksp
->rx_lock
, flags
);
565 /* enable rx interrupt */
566 writel(isr
| mask_bit
, KS8695_IRQ_VA
+ KS8695_INTEN
);
567 spin_unlock_irqrestore(&ksp
->rx_lock
, flags
);
573 * ks8695_link_irq - Link change IRQ handler
574 * @irq: The IRQ which went off (ignored)
575 * @dev_id: The net_device for the interrupt
577 * The WAN interface can generate an IRQ when the link changes,
578 * report this to the net layer and the user.
581 ks8695_link_irq(int irq
, void *dev_id
)
583 struct net_device
*ndev
= (struct net_device
*)dev_id
;
584 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
587 ctrl
= readl(ksp
->phyiface_regs
+ KS8695_WMC
);
588 if (ctrl
& WMC_WLS
) {
589 netif_carrier_on(ndev
);
590 if (netif_msg_link(ksp
))
592 "%s: Link is now up (10%sMbps/%s-duplex)\n",
594 (ctrl
& WMC_WSS
) ? "0" : "",
595 (ctrl
& WMC_WDS
) ? "Full" : "Half");
597 netif_carrier_off(ndev
);
598 if (netif_msg_link(ksp
))
599 dev_info(ksp
->dev
, "%s: Link is now down.\n",
607 /* KS8695 Device functions */
610 * ks8695_reset - Reset a KS8695 ethernet interface
611 * @ksp: The interface to reset
613 * Perform an engine reset of the interface and re-program it
614 * with sensible defaults.
617 ks8695_reset(struct ks8695_priv
*ksp
)
619 int reset_timeout
= watchdog
;
620 /* Issue the reset via the TX DMA control register */
621 ks8695_writereg(ksp
, KS8695_DTXC
, DTXC_TRST
);
622 while (reset_timeout
--) {
623 if (!(ks8695_readreg(ksp
, KS8695_DTXC
) & DTXC_TRST
))
628 if (reset_timeout
< 0) {
630 "Timeout waiting for DMA engines to reset\n");
631 /* And blithely carry on */
634 /* Definitely wait long enough before attempting to program
639 /* RX: unicast and broadcast */
640 ks8695_writereg(ksp
, KS8695_DRXC
, DRXC_RU
| DRXC_RB
);
641 /* TX: pad and add CRC */
642 ks8695_writereg(ksp
, KS8695_DTXC
, DTXC_TEP
| DTXC_TAC
);
646 * ks8695_shutdown - Shut down a KS8695 ethernet interface
647 * @ksp: The interface to shut down
649 * This disables packet RX/TX, cleans up IRQs, drains the rings,
650 * and basically places the interface into a clean shutdown
654 ks8695_shutdown(struct ks8695_priv
*ksp
)
659 /* Disable packet transmission */
660 ctrl
= ks8695_readreg(ksp
, KS8695_DTXC
);
661 ks8695_writereg(ksp
, KS8695_DTXC
, ctrl
& ~DTXC_TE
);
663 /* Disable packet reception */
664 ctrl
= ks8695_readreg(ksp
, KS8695_DRXC
);
665 ks8695_writereg(ksp
, KS8695_DRXC
, ctrl
& ~DRXC_RE
);
667 /* Release the IRQs */
668 free_irq(ksp
->rx_irq
, ksp
->ndev
);
669 free_irq(ksp
->tx_irq
, ksp
->ndev
);
670 if (ksp
->link_irq
!= -1)
671 free_irq(ksp
->link_irq
, ksp
->ndev
);
673 /* Throw away any pending TX packets */
674 for (buff_n
= 0; buff_n
< MAX_TX_DESC
; ++buff_n
) {
675 if (ksp
->tx_buffers
[buff_n
].skb
) {
676 /* Remove this SKB from the TX ring */
677 ksp
->tx_ring
[buff_n
].owner
= 0;
678 ksp
->tx_ring
[buff_n
].status
= 0;
679 ksp
->tx_ring
[buff_n
].data_ptr
= 0;
681 /* Unmap and bin this SKB */
682 dma_unmap_single(ksp
->dev
,
683 ksp
->tx_buffers
[buff_n
].dma_ptr
,
684 ksp
->tx_buffers
[buff_n
].length
,
686 dev_kfree_skb_irq(ksp
->tx_buffers
[buff_n
].skb
);
687 ksp
->tx_buffers
[buff_n
].skb
= NULL
;
691 /* Purge the RX buffers */
692 for (buff_n
= 0; buff_n
< MAX_RX_DESC
; ++buff_n
) {
693 if (ksp
->rx_buffers
[buff_n
].skb
) {
694 /* Remove the SKB from the RX ring */
695 ksp
->rx_ring
[buff_n
].status
= 0;
696 ksp
->rx_ring
[buff_n
].data_ptr
= 0;
698 /* Unmap and bin the SKB */
699 dma_unmap_single(ksp
->dev
,
700 ksp
->rx_buffers
[buff_n
].dma_ptr
,
701 ksp
->rx_buffers
[buff_n
].length
,
703 dev_kfree_skb_irq(ksp
->rx_buffers
[buff_n
].skb
);
704 ksp
->rx_buffers
[buff_n
].skb
= NULL
;
711 * ks8695_setup_irq - IRQ setup helper function
712 * @irq: The IRQ number to claim
713 * @irq_name: The name to give the IRQ claimant
714 * @handler: The function to call to handle the IRQ
715 * @ndev: The net_device to pass in as the dev_id argument to the handler
717 * Return 0 on success.
720 ks8695_setup_irq(int irq
, const char *irq_name
,
721 irq_handler_t handler
, struct net_device
*ndev
)
725 ret
= request_irq(irq
, handler
, IRQF_SHARED
, irq_name
, ndev
);
728 dev_err(&ndev
->dev
, "failure to request IRQ %d\n", irq
);
736 * ks8695_init_net - Initialise a KS8695 ethernet interface
737 * @ksp: The interface to initialise
739 * This routine fills the RX ring, initialises the DMA engines,
740 * allocates the IRQs and then starts the packet TX and RX
744 ks8695_init_net(struct ks8695_priv
*ksp
)
749 ks8695_refill_rxbuffers(ksp
);
751 /* Initialise the DMA engines */
752 ks8695_writereg(ksp
, KS8695_RDLB
, (u32
) ksp
->rx_ring_dma
);
753 ks8695_writereg(ksp
, KS8695_TDLB
, (u32
) ksp
->tx_ring_dma
);
755 /* Request the IRQs */
756 ret
= ks8695_setup_irq(ksp
->rx_irq
, ksp
->rx_irq_name
,
757 ks8695_rx_irq
, ksp
->ndev
);
760 ret
= ks8695_setup_irq(ksp
->tx_irq
, ksp
->tx_irq_name
,
761 ks8695_tx_irq
, ksp
->ndev
);
764 if (ksp
->link_irq
!= -1) {
765 ret
= ks8695_setup_irq(ksp
->link_irq
, ksp
->link_irq_name
,
766 ks8695_link_irq
, ksp
->ndev
);
771 /* Set up the ring indices */
772 ksp
->next_rx_desc_read
= 0;
773 ksp
->tx_ring_next_slot
= 0;
774 ksp
->tx_ring_used
= 0;
776 /* Bring up transmission */
777 ctrl
= ks8695_readreg(ksp
, KS8695_DTXC
);
778 /* Enable packet transmission */
779 ks8695_writereg(ksp
, KS8695_DTXC
, ctrl
| DTXC_TE
);
781 /* Bring up the reception */
782 ctrl
= ks8695_readreg(ksp
, KS8695_DRXC
);
783 /* Enable packet reception */
784 ks8695_writereg(ksp
, KS8695_DRXC
, ctrl
| DRXC_RE
);
785 /* And start the DMA engine */
786 ks8695_writereg(ksp
, KS8695_DRSC
, 0);
793 * ks8695_release_device - HW resource release for KS8695 e-net
794 * @ksp: The device to be freed
796 * This unallocates io memory regions, dma-coherent regions etc
797 * which were allocated in ks8695_probe.
800 ks8695_release_device(struct ks8695_priv
*ksp
)
802 /* Unmap the registers */
803 iounmap(ksp
->io_regs
);
804 if (ksp
->phyiface_regs
)
805 iounmap(ksp
->phyiface_regs
);
807 /* And release the request */
808 release_resource(ksp
->regs_req
);
809 kfree(ksp
->regs_req
);
810 if (ksp
->phyiface_req
) {
811 release_resource(ksp
->phyiface_req
);
812 kfree(ksp
->phyiface_req
);
815 /* Free the ring buffers */
816 dma_free_coherent(ksp
->dev
, RING_DMA_SIZE
,
817 ksp
->ring_base
, ksp
->ring_base_dma
);
820 /* Ethtool support */
823 * ks8695_get_msglevel - Get the messages enabled for emission
824 * @ndev: The network device to read from
827 ks8695_get_msglevel(struct net_device
*ndev
)
829 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
831 return ksp
->msg_enable
;
835 * ks8695_set_msglevel - Set the messages enabled for emission
836 * @ndev: The network device to configure
837 * @value: The messages to set for emission
840 ks8695_set_msglevel(struct net_device
*ndev
, u32 value
)
842 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
844 ksp
->msg_enable
= value
;
848 * ks8695_wan_get_link_ksettings - Get device-specific settings.
849 * @ndev: The network device to read settings from
850 * @cmd: The ethtool structure to read into
853 ks8695_wan_get_link_ksettings(struct net_device
*ndev
,
854 struct ethtool_link_ksettings
*cmd
)
856 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
858 u32 supported
, advertising
;
860 /* All ports on the KS8695 support these... */
861 supported
= (SUPPORTED_10baseT_Half
| SUPPORTED_10baseT_Full
|
862 SUPPORTED_100baseT_Half
| SUPPORTED_100baseT_Full
|
863 SUPPORTED_TP
| SUPPORTED_MII
);
865 advertising
= ADVERTISED_TP
| ADVERTISED_MII
;
866 cmd
->base
.port
= PORT_MII
;
867 supported
|= (SUPPORTED_Autoneg
| SUPPORTED_Pause
);
868 cmd
->base
.phy_address
= 0;
870 ctrl
= readl(ksp
->phyiface_regs
+ KS8695_WMC
);
871 if ((ctrl
& WMC_WAND
) == 0) {
872 /* auto-negotiation is enabled */
873 advertising
|= ADVERTISED_Autoneg
;
874 if (ctrl
& WMC_WANA100F
)
875 advertising
|= ADVERTISED_100baseT_Full
;
876 if (ctrl
& WMC_WANA100H
)
877 advertising
|= ADVERTISED_100baseT_Half
;
878 if (ctrl
& WMC_WANA10F
)
879 advertising
|= ADVERTISED_10baseT_Full
;
880 if (ctrl
& WMC_WANA10H
)
881 advertising
|= ADVERTISED_10baseT_Half
;
882 if (ctrl
& WMC_WANAP
)
883 advertising
|= ADVERTISED_Pause
;
884 cmd
->base
.autoneg
= AUTONEG_ENABLE
;
886 cmd
->base
.speed
= (ctrl
& WMC_WSS
) ? SPEED_100
: SPEED_10
;
887 cmd
->base
.duplex
= (ctrl
& WMC_WDS
) ?
888 DUPLEX_FULL
: DUPLEX_HALF
;
890 /* auto-negotiation is disabled */
891 cmd
->base
.autoneg
= AUTONEG_DISABLE
;
893 cmd
->base
.speed
= (ctrl
& WMC_WANF100
) ?
894 SPEED_100
: SPEED_10
;
895 cmd
->base
.duplex
= (ctrl
& WMC_WANFF
) ?
896 DUPLEX_FULL
: DUPLEX_HALF
;
899 ethtool_convert_legacy_u32_to_link_mode(cmd
->link_modes
.supported
,
901 ethtool_convert_legacy_u32_to_link_mode(cmd
->link_modes
.advertising
,
908 * ks8695_wan_set_link_ksettings - Set device-specific settings.
909 * @ndev: The network device to configure
910 * @cmd: The settings to configure
913 ks8695_wan_set_link_ksettings(struct net_device
*ndev
,
914 const struct ethtool_link_ksettings
*cmd
)
916 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
920 ethtool_convert_link_mode_to_legacy_u32(&advertising
,
921 cmd
->link_modes
.advertising
);
923 if ((cmd
->base
.speed
!= SPEED_10
) && (cmd
->base
.speed
!= SPEED_100
))
925 if ((cmd
->base
.duplex
!= DUPLEX_HALF
) &&
926 (cmd
->base
.duplex
!= DUPLEX_FULL
))
928 if (cmd
->base
.port
!= PORT_MII
)
930 if ((cmd
->base
.autoneg
!= AUTONEG_DISABLE
) &&
931 (cmd
->base
.autoneg
!= AUTONEG_ENABLE
))
934 if (cmd
->base
.autoneg
== AUTONEG_ENABLE
) {
935 if ((advertising
& (ADVERTISED_10baseT_Half
|
936 ADVERTISED_10baseT_Full
|
937 ADVERTISED_100baseT_Half
|
938 ADVERTISED_100baseT_Full
)) == 0)
941 ctrl
= readl(ksp
->phyiface_regs
+ KS8695_WMC
);
943 ctrl
&= ~(WMC_WAND
| WMC_WANA100F
| WMC_WANA100H
|
944 WMC_WANA10F
| WMC_WANA10H
);
945 if (advertising
& ADVERTISED_100baseT_Full
)
946 ctrl
|= WMC_WANA100F
;
947 if (advertising
& ADVERTISED_100baseT_Half
)
948 ctrl
|= WMC_WANA100H
;
949 if (advertising
& ADVERTISED_10baseT_Full
)
951 if (advertising
& ADVERTISED_10baseT_Half
)
954 /* force a re-negotiation */
956 writel(ctrl
, ksp
->phyiface_regs
+ KS8695_WMC
);
958 ctrl
= readl(ksp
->phyiface_regs
+ KS8695_WMC
);
960 /* disable auto-negotiation */
962 ctrl
&= ~(WMC_WANF100
| WMC_WANFF
);
964 if (cmd
->base
.speed
== SPEED_100
)
966 if (cmd
->base
.duplex
== DUPLEX_FULL
)
969 writel(ctrl
, ksp
->phyiface_regs
+ KS8695_WMC
);
976 * ks8695_wan_nwayreset - Restart the autonegotiation on the port.
977 * @ndev: The network device to restart autoneotiation on
980 ks8695_wan_nwayreset(struct net_device
*ndev
)
982 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
985 ctrl
= readl(ksp
->phyiface_regs
+ KS8695_WMC
);
987 if ((ctrl
& WMC_WAND
) == 0)
988 writel(ctrl
| WMC_WANR
,
989 ksp
->phyiface_regs
+ KS8695_WMC
);
991 /* auto-negotiation not enabled */
998 * ks8695_wan_get_pause - Retrieve network pause/flow-control advertising
999 * @ndev: The device to retrieve settings from
1000 * @param: The structure to fill out with the information
1003 ks8695_wan_get_pause(struct net_device
*ndev
, struct ethtool_pauseparam
*param
)
1005 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
1008 ctrl
= readl(ksp
->phyiface_regs
+ KS8695_WMC
);
1010 /* advertise Pause */
1011 param
->autoneg
= (ctrl
& WMC_WANAP
);
1013 /* current Rx Flow-control */
1014 ctrl
= ks8695_readreg(ksp
, KS8695_DRXC
);
1015 param
->rx_pause
= (ctrl
& DRXC_RFCE
);
1017 /* current Tx Flow-control */
1018 ctrl
= ks8695_readreg(ksp
, KS8695_DTXC
);
1019 param
->tx_pause
= (ctrl
& DTXC_TFCE
);
1023 * ks8695_get_drvinfo - Retrieve driver information
1024 * @ndev: The network device to retrieve info about
1025 * @info: The info structure to fill out.
1028 ks8695_get_drvinfo(struct net_device
*ndev
, struct ethtool_drvinfo
*info
)
1030 strlcpy(info
->driver
, MODULENAME
, sizeof(info
->driver
));
1031 strlcpy(info
->version
, MODULEVERSION
, sizeof(info
->version
));
1032 strlcpy(info
->bus_info
, dev_name(ndev
->dev
.parent
),
1033 sizeof(info
->bus_info
));
1036 static const struct ethtool_ops ks8695_ethtool_ops
= {
1037 .get_msglevel
= ks8695_get_msglevel
,
1038 .set_msglevel
= ks8695_set_msglevel
,
1039 .get_drvinfo
= ks8695_get_drvinfo
,
1042 static const struct ethtool_ops ks8695_wan_ethtool_ops
= {
1043 .get_msglevel
= ks8695_get_msglevel
,
1044 .set_msglevel
= ks8695_set_msglevel
,
1045 .nway_reset
= ks8695_wan_nwayreset
,
1046 .get_link
= ethtool_op_get_link
,
1047 .get_pauseparam
= ks8695_wan_get_pause
,
1048 .get_drvinfo
= ks8695_get_drvinfo
,
1049 .get_link_ksettings
= ks8695_wan_get_link_ksettings
,
1050 .set_link_ksettings
= ks8695_wan_set_link_ksettings
,
1053 /* Network device interface functions */
1056 * ks8695_set_mac - Update MAC in net dev and HW
1057 * @ndev: The network device to update
1058 * @addr: The new MAC address to set
1061 ks8695_set_mac(struct net_device
*ndev
, void *addr
)
1063 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
1064 struct sockaddr
*address
= addr
;
1066 if (!is_valid_ether_addr(address
->sa_data
))
1067 return -EADDRNOTAVAIL
;
1069 memcpy(ndev
->dev_addr
, address
->sa_data
, ndev
->addr_len
);
1071 ks8695_update_mac(ksp
);
1073 dev_dbg(ksp
->dev
, "%s: Updated MAC address to %pM\n",
1074 ndev
->name
, ndev
->dev_addr
);
1080 * ks8695_set_multicast - Set up the multicast behaviour of the interface
1081 * @ndev: The net_device to configure
1083 * This routine, called by the net layer, configures promiscuity
1084 * and multicast reception behaviour for the interface.
1087 ks8695_set_multicast(struct net_device
*ndev
)
1089 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
1092 ctrl
= ks8695_readreg(ksp
, KS8695_DRXC
);
1094 if (ndev
->flags
& IFF_PROMISC
) {
1095 /* enable promiscuous mode */
1097 } else if (ndev
->flags
& ~IFF_PROMISC
) {
1098 /* disable promiscuous mode */
1102 if (ndev
->flags
& IFF_ALLMULTI
) {
1103 /* enable all multicast mode */
1105 } else if (netdev_mc_count(ndev
) > KS8695_NR_ADDRESSES
) {
1106 /* more specific multicast addresses than can be
1107 * handled in hardware
1111 /* enable specific multicasts */
1113 ks8695_init_partial_multicast(ksp
, ndev
);
1116 ks8695_writereg(ksp
, KS8695_DRXC
, ctrl
);
1120 * ks8695_timeout - Handle a network tx/rx timeout.
1121 * @ndev: The net_device which timed out.
1123 * A network transaction timed out, reset the device.
1126 ks8695_timeout(struct net_device
*ndev
)
1128 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
1130 netif_stop_queue(ndev
);
1131 ks8695_shutdown(ksp
);
1135 ks8695_update_mac(ksp
);
1137 /* We ignore the return from this since it managed to init
1138 * before it probably will be okay to init again.
1140 ks8695_init_net(ksp
);
1142 /* Reconfigure promiscuity etc */
1143 ks8695_set_multicast(ndev
);
1145 /* And start the TX queue once more */
1146 netif_start_queue(ndev
);
1150 * ks8695_start_xmit - Start a packet transmission
1151 * @skb: The packet to transmit
1152 * @ndev: The network device to send the packet on
1154 * This routine, called by the net layer, takes ownership of the
1155 * sk_buff and adds it to the TX ring. It then kicks the TX DMA
1156 * engine to ensure transmission begins.
1159 ks8695_start_xmit(struct sk_buff
*skb
, struct net_device
*ndev
)
1161 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
1165 spin_lock_irq(&ksp
->txq_lock
);
1167 if (ksp
->tx_ring_used
== MAX_TX_DESC
) {
1168 /* Somehow we got entered when we have no room */
1169 spin_unlock_irq(&ksp
->txq_lock
);
1170 return NETDEV_TX_BUSY
;
1173 buff_n
= ksp
->tx_ring_next_slot
;
1175 BUG_ON(ksp
->tx_buffers
[buff_n
].skb
);
1177 dmap
= dma_map_single(ksp
->dev
, skb
->data
, skb
->len
, DMA_TO_DEVICE
);
1178 if (unlikely(dma_mapping_error(ksp
->dev
, dmap
))) {
1179 /* Failed to DMA map this SKB, give it back for now */
1180 spin_unlock_irq(&ksp
->txq_lock
);
1181 dev_dbg(ksp
->dev
, "%s: Could not map DMA memory for "\
1182 "transmission, trying later\n", ndev
->name
);
1183 return NETDEV_TX_BUSY
;
1186 ksp
->tx_buffers
[buff_n
].dma_ptr
= dmap
;
1187 /* Mapped okay, store the buffer pointer and length for later */
1188 ksp
->tx_buffers
[buff_n
].skb
= skb
;
1189 ksp
->tx_buffers
[buff_n
].length
= skb
->len
;
1191 /* Fill out the TX descriptor */
1192 ksp
->tx_ring
[buff_n
].data_ptr
=
1193 cpu_to_le32(ksp
->tx_buffers
[buff_n
].dma_ptr
);
1194 ksp
->tx_ring
[buff_n
].status
=
1195 cpu_to_le32(TDES_IC
| TDES_FS
| TDES_LS
|
1196 (skb
->len
& TDES_TBS
));
1200 /* Hand it over to the hardware */
1201 ksp
->tx_ring
[buff_n
].owner
= cpu_to_le32(TDES_OWN
);
1203 if (++ksp
->tx_ring_used
== MAX_TX_DESC
)
1204 netif_stop_queue(ndev
);
1206 /* Kick the TX DMA in case it decided to go IDLE */
1207 ks8695_writereg(ksp
, KS8695_DTSC
, 0);
1209 /* And update the next ring slot */
1210 ksp
->tx_ring_next_slot
= (buff_n
+ 1) & MAX_TX_DESC_MASK
;
1212 spin_unlock_irq(&ksp
->txq_lock
);
1213 return NETDEV_TX_OK
;
1217 * ks8695_stop - Stop (shutdown) a KS8695 ethernet interface
1218 * @ndev: The net_device to stop
1220 * This disables the TX queue and cleans up a KS8695 ethernet
1224 ks8695_stop(struct net_device
*ndev
)
1226 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
1228 netif_stop_queue(ndev
);
1229 napi_disable(&ksp
->napi
);
1231 ks8695_shutdown(ksp
);
1237 * ks8695_open - Open (bring up) a KS8695 ethernet interface
1238 * @ndev: The net_device to open
1240 * This resets, configures the MAC, initialises the RX ring and
1241 * DMA engines and starts the TX queue for a KS8695 ethernet
1245 ks8695_open(struct net_device
*ndev
)
1247 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
1252 ks8695_update_mac(ksp
);
1254 ret
= ks8695_init_net(ksp
);
1256 ks8695_shutdown(ksp
);
1260 napi_enable(&ksp
->napi
);
1261 netif_start_queue(ndev
);
1266 /* Platform device driver */
1269 * ks8695_init_switch - Init LAN switch to known good defaults.
1270 * @ksp: The device to initialise
1272 * This initialises the LAN switch in the KS8695 to a known-good
1276 ks8695_init_switch(struct ks8695_priv
*ksp
)
1280 /* Default value for SEC0 according to datasheet */
1283 /* LED0 = Speed LED1 = Link/Activity */
1284 ctrl
&= ~(SEC0_LLED1S
| SEC0_LLED0S
);
1285 ctrl
|= (LLED0S_LINK
| LLED1S_LINK_ACTIVITY
);
1288 ctrl
|= SEC0_ENABLE
;
1290 writel(ctrl
, ksp
->phyiface_regs
+ KS8695_SEC0
);
1292 /* Defaults for SEC1 */
1293 writel(0x9400100, ksp
->phyiface_regs
+ KS8695_SEC1
);
1297 * ks8695_init_wan_phy - Initialise the WAN PHY to sensible defaults
1298 * @ksp: The device to initialise
1300 * This initialises a KS8695's WAN phy to sensible values for
1301 * autonegotiation etc.
1304 ks8695_init_wan_phy(struct ks8695_priv
*ksp
)
1308 /* Support auto-negotiation */
1309 ctrl
= (WMC_WANAP
| WMC_WANA100F
| WMC_WANA100H
|
1310 WMC_WANA10F
| WMC_WANA10H
);
1312 /* LED0 = Activity , LED1 = Link */
1313 ctrl
|= (WLED0S_ACTIVITY
| WLED1S_LINK
);
1315 /* Restart Auto-negotiation */
1318 writel(ctrl
, ksp
->phyiface_regs
+ KS8695_WMC
);
1320 writel(0, ksp
->phyiface_regs
+ KS8695_WPPM
);
1321 writel(0, ksp
->phyiface_regs
+ KS8695_PPS
);
1324 static const struct net_device_ops ks8695_netdev_ops
= {
1325 .ndo_open
= ks8695_open
,
1326 .ndo_stop
= ks8695_stop
,
1327 .ndo_start_xmit
= ks8695_start_xmit
,
1328 .ndo_tx_timeout
= ks8695_timeout
,
1329 .ndo_set_mac_address
= ks8695_set_mac
,
1330 .ndo_validate_addr
= eth_validate_addr
,
1331 .ndo_set_rx_mode
= ks8695_set_multicast
,
1335 * ks8695_probe - Probe and initialise a KS8695 ethernet interface
1336 * @pdev: The platform device to probe
1338 * Initialise a KS8695 ethernet device from platform data.
1340 * This driver requires at least one IORESOURCE_MEM for the
1341 * registers and two IORESOURCE_IRQ for the RX and TX IRQs
1342 * respectively. It can optionally take an additional
1343 * IORESOURCE_MEM for the switch or phy in the case of the lan or
1344 * wan ports, and an IORESOURCE_IRQ for the link IRQ for the wan
1348 ks8695_probe(struct platform_device
*pdev
)
1350 struct ks8695_priv
*ksp
;
1351 struct net_device
*ndev
;
1352 struct resource
*regs_res
, *phyiface_res
;
1353 struct resource
*rxirq_res
, *txirq_res
, *linkirq_res
;
1356 bool inv_mac_addr
= false;
1357 u32 machigh
, maclow
;
1359 /* Initialise a net_device */
1360 ndev
= alloc_etherdev(sizeof(struct ks8695_priv
));
1364 SET_NETDEV_DEV(ndev
, &pdev
->dev
);
1366 dev_dbg(&pdev
->dev
, "ks8695_probe() called\n");
1368 /* Configure our private structure a little */
1369 ksp
= netdev_priv(ndev
);
1371 ksp
->dev
= &pdev
->dev
;
1373 ksp
->msg_enable
= NETIF_MSG_LINK
;
1375 /* Retrieve resources */
1376 regs_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1377 phyiface_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 1);
1379 rxirq_res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
1380 txirq_res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 1);
1381 linkirq_res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 2);
1383 if (!(regs_res
&& rxirq_res
&& txirq_res
)) {
1384 dev_err(ksp
->dev
, "insufficient resources\n");
1389 ksp
->regs_req
= request_mem_region(regs_res
->start
,
1390 resource_size(regs_res
),
1393 if (!ksp
->regs_req
) {
1394 dev_err(ksp
->dev
, "cannot claim register space\n");
1399 ksp
->io_regs
= ioremap(regs_res
->start
, resource_size(regs_res
));
1401 if (!ksp
->io_regs
) {
1402 dev_err(ksp
->dev
, "failed to ioremap registers\n");
1409 request_mem_region(phyiface_res
->start
,
1410 resource_size(phyiface_res
),
1411 phyiface_res
->name
);
1413 if (!ksp
->phyiface_req
) {
1415 "cannot claim switch register space\n");
1420 ksp
->phyiface_regs
= ioremap(phyiface_res
->start
,
1421 resource_size(phyiface_res
));
1423 if (!ksp
->phyiface_regs
) {
1425 "failed to ioremap switch registers\n");
1431 ksp
->rx_irq
= rxirq_res
->start
;
1432 ksp
->rx_irq_name
= rxirq_res
->name
? rxirq_res
->name
: "Ethernet RX";
1433 ksp
->tx_irq
= txirq_res
->start
;
1434 ksp
->tx_irq_name
= txirq_res
->name
? txirq_res
->name
: "Ethernet TX";
1435 ksp
->link_irq
= (linkirq_res
? linkirq_res
->start
: -1);
1436 ksp
->link_irq_name
= (linkirq_res
&& linkirq_res
->name
) ?
1437 linkirq_res
->name
: "Ethernet Link";
1439 /* driver system setup */
1440 ndev
->netdev_ops
= &ks8695_netdev_ops
;
1441 ndev
->watchdog_timeo
= msecs_to_jiffies(watchdog
);
1443 netif_napi_add(ndev
, &ksp
->napi
, ks8695_poll
, NAPI_WEIGHT
);
1445 /* Retrieve the default MAC addr from the chip. */
1446 /* The bootloader should have left it in there for us. */
1448 machigh
= ks8695_readreg(ksp
, KS8695_MAH
);
1449 maclow
= ks8695_readreg(ksp
, KS8695_MAL
);
1451 ndev
->dev_addr
[0] = (machigh
>> 8) & 0xFF;
1452 ndev
->dev_addr
[1] = machigh
& 0xFF;
1453 ndev
->dev_addr
[2] = (maclow
>> 24) & 0xFF;
1454 ndev
->dev_addr
[3] = (maclow
>> 16) & 0xFF;
1455 ndev
->dev_addr
[4] = (maclow
>> 8) & 0xFF;
1456 ndev
->dev_addr
[5] = maclow
& 0xFF;
1458 if (!is_valid_ether_addr(ndev
->dev_addr
))
1459 inv_mac_addr
= true;
1461 /* In order to be efficient memory-wise, we allocate both
1464 ksp
->ring_base
= dma_alloc_coherent(&pdev
->dev
, RING_DMA_SIZE
,
1465 &ksp
->ring_base_dma
, GFP_KERNEL
);
1466 if (!ksp
->ring_base
) {
1471 /* Specify the TX DMA ring buffer */
1472 ksp
->tx_ring
= ksp
->ring_base
;
1473 ksp
->tx_ring_dma
= ksp
->ring_base_dma
;
1475 /* And initialise the queue's lock */
1476 spin_lock_init(&ksp
->txq_lock
);
1477 spin_lock_init(&ksp
->rx_lock
);
1479 /* Specify the RX DMA ring buffer */
1480 ksp
->rx_ring
= ksp
->ring_base
+ TX_RING_DMA_SIZE
;
1481 ksp
->rx_ring_dma
= ksp
->ring_base_dma
+ TX_RING_DMA_SIZE
;
1483 /* Zero the descriptor rings */
1484 memset(ksp
->tx_ring
, 0, TX_RING_DMA_SIZE
);
1485 memset(ksp
->rx_ring
, 0, RX_RING_DMA_SIZE
);
1487 /* Build the rings */
1488 for (buff_n
= 0; buff_n
< MAX_TX_DESC
; ++buff_n
) {
1489 ksp
->tx_ring
[buff_n
].next_desc
=
1490 cpu_to_le32(ksp
->tx_ring_dma
+
1491 (sizeof(struct tx_ring_desc
) *
1492 ((buff_n
+ 1) & MAX_TX_DESC_MASK
)));
1495 for (buff_n
= 0; buff_n
< MAX_RX_DESC
; ++buff_n
) {
1496 ksp
->rx_ring
[buff_n
].next_desc
=
1497 cpu_to_le32(ksp
->rx_ring_dma
+
1498 (sizeof(struct rx_ring_desc
) *
1499 ((buff_n
+ 1) & MAX_RX_DESC_MASK
)));
1502 /* Initialise the port (physically) */
1503 if (ksp
->phyiface_regs
&& ksp
->link_irq
== -1) {
1504 ks8695_init_switch(ksp
);
1505 ksp
->dtype
= KS8695_DTYPE_LAN
;
1506 ndev
->ethtool_ops
= &ks8695_ethtool_ops
;
1507 } else if (ksp
->phyiface_regs
&& ksp
->link_irq
!= -1) {
1508 ks8695_init_wan_phy(ksp
);
1509 ksp
->dtype
= KS8695_DTYPE_WAN
;
1510 ndev
->ethtool_ops
= &ks8695_wan_ethtool_ops
;
1512 /* No initialisation since HPNA does not have a PHY */
1513 ksp
->dtype
= KS8695_DTYPE_HPNA
;
1514 ndev
->ethtool_ops
= &ks8695_ethtool_ops
;
1517 /* And bring up the net_device with the net core */
1518 platform_set_drvdata(pdev
, ndev
);
1519 ret
= register_netdev(ndev
);
1523 dev_warn(ksp
->dev
, "%s: Invalid ethernet MAC address. Please set using ip\n",
1525 dev_info(ksp
->dev
, "ks8695 ethernet (%s) MAC: %pM\n",
1526 ks8695_port_type(ksp
), ndev
->dev_addr
);
1528 /* Report the failure to register the net_device */
1529 dev_err(ksp
->dev
, "ks8695net: failed to register netdev.\n");
1536 /* Error exit path */
1538 ks8695_release_device(ksp
);
1545 * ks8695_drv_suspend - Suspend a KS8695 ethernet platform device.
1546 * @pdev: The device to suspend
1547 * @state: The suspend state
1549 * This routine detaches and shuts down a KS8695 ethernet device.
1552 ks8695_drv_suspend(struct platform_device
*pdev
, pm_message_t state
)
1554 struct net_device
*ndev
= platform_get_drvdata(pdev
);
1555 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
1557 ksp
->in_suspend
= 1;
1559 if (netif_running(ndev
)) {
1560 netif_device_detach(ndev
);
1561 ks8695_shutdown(ksp
);
1568 * ks8695_drv_resume - Resume a KS8695 ethernet platform device.
1569 * @pdev: The device to resume
1571 * This routine re-initialises and re-attaches a KS8695 ethernet
1575 ks8695_drv_resume(struct platform_device
*pdev
)
1577 struct net_device
*ndev
= platform_get_drvdata(pdev
);
1578 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
1580 if (netif_running(ndev
)) {
1582 ks8695_init_net(ksp
);
1583 ks8695_set_multicast(ndev
);
1584 netif_device_attach(ndev
);
1587 ksp
->in_suspend
= 0;
1593 * ks8695_drv_remove - Remove a KS8695 net device on driver unload.
1594 * @pdev: The platform device to remove
1596 * This unregisters and releases a KS8695 ethernet device.
1599 ks8695_drv_remove(struct platform_device
*pdev
)
1601 struct net_device
*ndev
= platform_get_drvdata(pdev
);
1602 struct ks8695_priv
*ksp
= netdev_priv(ndev
);
1604 netif_napi_del(&ksp
->napi
);
1606 unregister_netdev(ndev
);
1607 ks8695_release_device(ksp
);
1610 dev_dbg(&pdev
->dev
, "released and freed device\n");
1614 static struct platform_driver ks8695_driver
= {
1618 .probe
= ks8695_probe
,
1619 .remove
= ks8695_drv_remove
,
1620 .suspend
= ks8695_drv_suspend
,
1621 .resume
= ks8695_drv_resume
,
1624 module_platform_driver(ks8695_driver
);
1626 MODULE_AUTHOR("Simtec Electronics");
1627 MODULE_DESCRIPTION("Micrel KS8695 (Centaur) Ethernet driver");
1628 MODULE_LICENSE("GPL");
1629 MODULE_ALIAS("platform:" MODULENAME
);
1631 module_param(watchdog
, int, 0400);
1632 MODULE_PARM_DESC(watchdog
, "transmit timeout in milliseconds");