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