2 * sgiseeq.c: Seeq8003 ethernet driver for SGI machines.
4 * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/errno.h>
12 #include <linux/init.h>
13 #include <linux/types.h>
14 #include <linux/interrupt.h>
15 #include <linux/ioport.h>
16 #include <linux/socket.h>
18 #include <linux/route.h>
19 #include <linux/slab.h>
20 #include <linux/string.h>
21 #include <linux/delay.h>
22 #include <linux/netdevice.h>
23 #include <linux/etherdevice.h>
24 #include <linux/skbuff.h>
25 #include <linux/bitops.h>
27 #include <asm/byteorder.h>
29 #include <asm/system.h>
31 #include <asm/pgtable.h>
32 #include <asm/sgi/hpc3.h>
33 #include <asm/sgi/ip22.h>
34 #include <asm/sgialib.h>
38 static char *sgiseeqstr
= "SGI Seeq8003";
41 * If you want speed, you do something silly, it always has worked for me. So,
42 * with that in mind, I've decided to make this driver look completely like a
43 * stupid Lance from a driver architecture perspective. Only difference is that
44 * here our "ring buffer" looks and acts like a real Lance one does but is
45 * layed out like how the HPC DMA and the Seeq want it to. You'd be surprised
46 * how a stupid idea like this can pay off in performance, not to mention
47 * making this driver 2,000 times easier to write. ;-)
50 /* Tune these if we tend to run out often etc. */
51 #define SEEQ_RX_BUFFERS 16
52 #define SEEQ_TX_BUFFERS 16
54 #define PKT_BUF_SZ 1584
56 #define NEXT_RX(i) (((i) + 1) & (SEEQ_RX_BUFFERS - 1))
57 #define NEXT_TX(i) (((i) + 1) & (SEEQ_TX_BUFFERS - 1))
58 #define PREV_RX(i) (((i) - 1) & (SEEQ_RX_BUFFERS - 1))
59 #define PREV_TX(i) (((i) - 1) & (SEEQ_TX_BUFFERS - 1))
61 #define TX_BUFFS_AVAIL(sp) ((sp->tx_old <= sp->tx_new) ? \
62 sp->tx_old + (SEEQ_TX_BUFFERS - 1) - sp->tx_new : \
63 sp->tx_old - sp->tx_new - 1)
65 struct sgiseeq_rx_desc
{
66 volatile struct hpc_dma_desc rdma
;
67 volatile signed int buf_vaddr
;
70 struct sgiseeq_tx_desc
{
71 volatile struct hpc_dma_desc tdma
;
72 volatile signed int buf_vaddr
;
76 * Warning: This structure is layed out in a certain way because HPC dma
77 * descriptors must be 8-byte aligned. So don't touch this without
80 struct sgiseeq_init_block
{ /* Note the name ;-) */
81 struct sgiseeq_rx_desc rxvector
[SEEQ_RX_BUFFERS
];
82 struct sgiseeq_tx_desc txvector
[SEEQ_TX_BUFFERS
];
85 struct sgiseeq_private
{
86 struct sgiseeq_init_block
*srings
;
88 /* Ptrs to the descriptors in uncached space. */
89 struct sgiseeq_rx_desc
*rx_desc
;
90 struct sgiseeq_tx_desc
*tx_desc
;
93 struct hpc3_ethregs
*hregs
;
94 struct sgiseeq_regs
*sregs
;
96 /* Ring entry counters. */
97 unsigned int rx_new
, tx_new
;
98 unsigned int rx_old
, tx_old
;
101 unsigned char control
;
104 struct net_device_stats stats
;
106 struct net_device
*next_module
;
110 /* A list of all installed seeq devices, for removing the driver module. */
111 static struct net_device
*root_sgiseeq_dev
;
113 static inline void hpc3_eth_reset(struct hpc3_ethregs
*hregs
)
115 hregs
->reset
= HPC3_ERST_CRESET
| HPC3_ERST_CLRIRQ
;
120 static inline void reset_hpc3_and_seeq(struct hpc3_ethregs
*hregs
,
121 struct sgiseeq_regs
*sregs
)
123 hregs
->rx_ctrl
= hregs
->tx_ctrl
= 0;
124 hpc3_eth_reset(hregs
);
127 #define RSTAT_GO_BITS (SEEQ_RCMD_IGOOD | SEEQ_RCMD_IEOF | SEEQ_RCMD_ISHORT | \
128 SEEQ_RCMD_IDRIB | SEEQ_RCMD_ICRC)
130 static inline void seeq_go(struct sgiseeq_private
*sp
,
131 struct hpc3_ethregs
*hregs
,
132 struct sgiseeq_regs
*sregs
)
134 sregs
->rstat
= sp
->mode
| RSTAT_GO_BITS
;
135 hregs
->rx_ctrl
= HPC3_ERXCTRL_ACTIVE
;
138 static inline void __sgiseeq_set_mac_address(struct net_device
*dev
)
140 struct sgiseeq_private
*sp
= netdev_priv(dev
);
141 struct sgiseeq_regs
*sregs
= sp
->sregs
;
144 sregs
->tstat
= SEEQ_TCMD_RB0
;
145 for (i
= 0; i
< 6; i
++)
146 sregs
->rw
.eth_addr
[i
] = dev
->dev_addr
[i
];
149 static int sgiseeq_set_mac_address(struct net_device
*dev
, void *addr
)
151 struct sgiseeq_private
*sp
= netdev_priv(dev
);
152 struct sockaddr
*sa
= addr
;
154 memcpy(dev
->dev_addr
, sa
->sa_data
, dev
->addr_len
);
156 spin_lock_irq(&sp
->tx_lock
);
157 __sgiseeq_set_mac_address(dev
);
158 spin_unlock_irq(&sp
->tx_lock
);
163 #define TCNTINFO_INIT (HPCDMA_EOX | HPCDMA_ETXD)
164 #define RCNTCFG_INIT (HPCDMA_OWN | HPCDMA_EORP | HPCDMA_XIE)
165 #define RCNTINFO_INIT (RCNTCFG_INIT | (PKT_BUF_SZ & HPCDMA_BCNT))
167 static int seeq_init_ring(struct net_device
*dev
)
169 struct sgiseeq_private
*sp
= netdev_priv(dev
);
172 netif_stop_queue(dev
);
173 sp
->rx_new
= sp
->tx_new
= 0;
174 sp
->rx_old
= sp
->tx_old
= 0;
176 __sgiseeq_set_mac_address(dev
);
179 for(i
= 0; i
< SEEQ_TX_BUFFERS
; i
++) {
180 if (!sp
->tx_desc
[i
].tdma
.pbuf
) {
181 unsigned long buffer
;
183 buffer
= (unsigned long) kmalloc(PKT_BUF_SZ
, GFP_KERNEL
);
186 sp
->tx_desc
[i
].buf_vaddr
= CKSEG1ADDR(buffer
);
187 sp
->tx_desc
[i
].tdma
.pbuf
= CPHYSADDR(buffer
);
189 sp
->tx_desc
[i
].tdma
.cntinfo
= TCNTINFO_INIT
;
192 /* And now the rx ring. */
193 for (i
= 0; i
< SEEQ_RX_BUFFERS
; i
++) {
194 if (!sp
->rx_desc
[i
].rdma
.pbuf
) {
195 unsigned long buffer
;
197 buffer
= (unsigned long) kmalloc(PKT_BUF_SZ
, GFP_KERNEL
);
200 sp
->rx_desc
[i
].buf_vaddr
= CKSEG1ADDR(buffer
);
201 sp
->rx_desc
[i
].rdma
.pbuf
= CPHYSADDR(buffer
);
203 sp
->rx_desc
[i
].rdma
.cntinfo
= RCNTINFO_INIT
;
205 sp
->rx_desc
[i
- 1].rdma
.cntinfo
|= HPCDMA_EOR
;
210 static struct sgiseeq_private
*gpriv
;
211 static struct net_device
*gdev
;
213 static void sgiseeq_dump_rings(void)
216 struct sgiseeq_rx_desc
*r
= gpriv
->rx_desc
;
217 struct sgiseeq_tx_desc
*t
= gpriv
->tx_desc
;
218 struct hpc3_ethregs
*hregs
= gpriv
->hregs
;
224 printk("RING DUMP:\n");
225 for (i
= 0; i
< SEEQ_RX_BUFFERS
; i
++) {
226 printk("RX [%d]: @(%p) [%08x,%08x,%08x] ",
227 i
, (&r
[i
]), r
[i
].rdma
.pbuf
, r
[i
].rdma
.cntinfo
,
230 printk("-- [%d]: @(%p) [%08x,%08x,%08x]\n",
231 i
, (&r
[i
]), r
[i
].rdma
.pbuf
, r
[i
].rdma
.cntinfo
,
234 for (i
= 0; i
< SEEQ_TX_BUFFERS
; i
++) {
235 printk("TX [%d]: @(%p) [%08x,%08x,%08x] ",
236 i
, (&t
[i
]), t
[i
].tdma
.pbuf
, t
[i
].tdma
.cntinfo
,
239 printk("-- [%d]: @(%p) [%08x,%08x,%08x]\n",
240 i
, (&t
[i
]), t
[i
].tdma
.pbuf
, t
[i
].tdma
.cntinfo
,
243 printk("INFO: [rx_new = %d rx_old=%d] [tx_new = %d tx_old = %d]\n",
244 gpriv
->rx_new
, gpriv
->rx_old
, gpriv
->tx_new
, gpriv
->tx_old
);
245 printk("RREGS: rx_cbptr[%08x] rx_ndptr[%08x] rx_ctrl[%08x]\n",
246 hregs
->rx_cbptr
, hregs
->rx_ndptr
, hregs
->rx_ctrl
);
247 printk("TREGS: tx_cbptr[%08x] tx_ndptr[%08x] tx_ctrl[%08x]\n",
248 hregs
->tx_cbptr
, hregs
->tx_ndptr
, hregs
->tx_ctrl
);
252 #define TSTAT_INIT_SEEQ (SEEQ_TCMD_IPT|SEEQ_TCMD_I16|SEEQ_TCMD_IC|SEEQ_TCMD_IUF)
253 #define TSTAT_INIT_EDLC ((TSTAT_INIT_SEEQ) | SEEQ_TCMD_RB2)
255 static int init_seeq(struct net_device
*dev
, struct sgiseeq_private
*sp
,
256 struct sgiseeq_regs
*sregs
)
258 struct hpc3_ethregs
*hregs
= sp
->hregs
;
261 reset_hpc3_and_seeq(hregs
, sregs
);
262 err
= seeq_init_ring(dev
);
266 /* Setup to field the proper interrupt types. */
268 sregs
->tstat
= TSTAT_INIT_EDLC
;
269 sregs
->rw
.wregs
.control
= sp
->control
;
270 sregs
->rw
.wregs
.frame_gap
= 0;
272 sregs
->tstat
= TSTAT_INIT_SEEQ
;
275 hregs
->rx_ndptr
= CPHYSADDR(sp
->rx_desc
);
276 hregs
->tx_ndptr
= CPHYSADDR(sp
->tx_desc
);
278 seeq_go(sp
, hregs
, sregs
);
282 static inline void record_rx_errors(struct sgiseeq_private
*sp
,
283 unsigned char status
)
285 if (status
& SEEQ_RSTAT_OVERF
||
286 status
& SEEQ_RSTAT_SFRAME
)
287 sp
->stats
.rx_over_errors
++;
288 if (status
& SEEQ_RSTAT_CERROR
)
289 sp
->stats
.rx_crc_errors
++;
290 if (status
& SEEQ_RSTAT_DERROR
)
291 sp
->stats
.rx_frame_errors
++;
292 if (status
& SEEQ_RSTAT_REOF
)
293 sp
->stats
.rx_errors
++;
296 static inline void rx_maybe_restart(struct sgiseeq_private
*sp
,
297 struct hpc3_ethregs
*hregs
,
298 struct sgiseeq_regs
*sregs
)
300 if (!(hregs
->rx_ctrl
& HPC3_ERXCTRL_ACTIVE
)) {
301 hregs
->rx_ndptr
= CPHYSADDR(sp
->rx_desc
+ sp
->rx_new
);
302 seeq_go(sp
, hregs
, sregs
);
306 #define for_each_rx(rd, sp) for((rd) = &(sp)->rx_desc[(sp)->rx_new]; \
307 !((rd)->rdma.cntinfo & HPCDMA_OWN); \
308 (rd) = &(sp)->rx_desc[(sp)->rx_new])
310 static inline void sgiseeq_rx(struct net_device
*dev
, struct sgiseeq_private
*sp
,
311 struct hpc3_ethregs
*hregs
,
312 struct sgiseeq_regs
*sregs
)
314 struct sgiseeq_rx_desc
*rd
;
315 struct sk_buff
*skb
= NULL
;
316 unsigned char pkt_status
;
317 unsigned char *pkt_pointer
= NULL
;
319 unsigned int orig_end
= PREV_RX(sp
->rx_new
);
321 /* Service every received packet. */
322 for_each_rx(rd
, sp
) {
323 len
= PKT_BUF_SZ
- (rd
->rdma
.cntinfo
& HPCDMA_BCNT
) - 3;
324 pkt_pointer
= (unsigned char *)(long)rd
->buf_vaddr
;
325 pkt_status
= pkt_pointer
[len
+ 2];
327 if (pkt_status
& SEEQ_RSTAT_FIG
) {
329 skb
= dev_alloc_skb(len
+ 2);
336 /* Copy out of kseg1 to avoid silly cache flush. */
337 eth_copy_and_sum(skb
, pkt_pointer
+ 2, len
, 0);
338 skb
->protocol
= eth_type_trans(skb
, dev
);
340 /* We don't want to receive our own packets */
341 if (memcmp(eth_hdr(skb
)->h_source
, dev
->dev_addr
, ETH_ALEN
)) {
343 dev
->last_rx
= jiffies
;
344 sp
->stats
.rx_packets
++;
345 sp
->stats
.rx_bytes
+= len
;
347 /* Silently drop my own packets */
348 dev_kfree_skb_irq(skb
);
351 printk (KERN_NOTICE
"%s: Memory squeeze, deferring packet.\n",
353 sp
->stats
.rx_dropped
++;
356 record_rx_errors(sp
, pkt_status
);
359 /* Return the entry to the ring pool. */
360 rd
->rdma
.cntinfo
= RCNTINFO_INIT
;
361 sp
->rx_new
= NEXT_RX(sp
->rx_new
);
363 sp
->rx_desc
[orig_end
].rdma
.cntinfo
&= ~(HPCDMA_EOR
);
364 sp
->rx_desc
[PREV_RX(sp
->rx_new
)].rdma
.cntinfo
|= HPCDMA_EOR
;
365 rx_maybe_restart(sp
, hregs
, sregs
);
368 static inline void tx_maybe_reset_collisions(struct sgiseeq_private
*sp
,
369 struct sgiseeq_regs
*sregs
)
372 sregs
->rw
.wregs
.control
= sp
->control
& ~(SEEQ_CTRL_XCNT
);
373 sregs
->rw
.wregs
.control
= sp
->control
;
377 static inline void kick_tx(struct sgiseeq_tx_desc
*td
,
378 struct hpc3_ethregs
*hregs
)
380 /* If the HPC aint doin nothin, and there are more packets
381 * with ETXD cleared and XIU set we must make very certain
382 * that we restart the HPC else we risk locking up the
383 * adapter. The following code is only safe iff the HPCDMA
386 while ((td
->tdma
.cntinfo
& (HPCDMA_XIU
| HPCDMA_ETXD
)) ==
387 (HPCDMA_XIU
| HPCDMA_ETXD
))
388 td
= (struct sgiseeq_tx_desc
*)(long) CKSEG1ADDR(td
->tdma
.pnext
);
389 if (td
->tdma
.cntinfo
& HPCDMA_XIU
) {
390 hregs
->tx_ndptr
= CPHYSADDR(td
);
391 hregs
->tx_ctrl
= HPC3_ETXCTRL_ACTIVE
;
395 static inline void sgiseeq_tx(struct net_device
*dev
, struct sgiseeq_private
*sp
,
396 struct hpc3_ethregs
*hregs
,
397 struct sgiseeq_regs
*sregs
)
399 struct sgiseeq_tx_desc
*td
;
400 unsigned long status
= hregs
->tx_ctrl
;
403 tx_maybe_reset_collisions(sp
, sregs
);
405 if (!(status
& (HPC3_ETXCTRL_ACTIVE
| SEEQ_TSTAT_PTRANS
))) {
406 /* Oops, HPC detected some sort of error. */
407 if (status
& SEEQ_TSTAT_R16
)
408 sp
->stats
.tx_aborted_errors
++;
409 if (status
& SEEQ_TSTAT_UFLOW
)
410 sp
->stats
.tx_fifo_errors
++;
411 if (status
& SEEQ_TSTAT_LCLS
)
412 sp
->stats
.collisions
++;
416 for (j
= sp
->tx_old
; j
!= sp
->tx_new
; j
= NEXT_TX(j
)) {
417 td
= &sp
->tx_desc
[j
];
419 if (!(td
->tdma
.cntinfo
& (HPCDMA_XIU
)))
421 if (!(td
->tdma
.cntinfo
& (HPCDMA_ETXD
))) {
422 if (!(status
& HPC3_ETXCTRL_ACTIVE
)) {
423 hregs
->tx_ndptr
= CPHYSADDR(td
);
424 hregs
->tx_ctrl
= HPC3_ETXCTRL_ACTIVE
;
428 sp
->stats
.tx_packets
++;
429 sp
->tx_old
= NEXT_TX(sp
->tx_old
);
430 td
->tdma
.cntinfo
&= ~(HPCDMA_XIU
| HPCDMA_XIE
);
431 td
->tdma
.cntinfo
|= HPCDMA_EOX
;
435 static irqreturn_t
sgiseeq_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
437 struct net_device
*dev
= (struct net_device
*) dev_id
;
438 struct sgiseeq_private
*sp
= netdev_priv(dev
);
439 struct hpc3_ethregs
*hregs
= sp
->hregs
;
440 struct sgiseeq_regs
*sregs
= sp
->sregs
;
442 spin_lock(&sp
->tx_lock
);
444 /* Ack the IRQ and set software state. */
445 hregs
->reset
= HPC3_ERST_CLRIRQ
;
447 /* Always check for received packets. */
448 sgiseeq_rx(dev
, sp
, hregs
, sregs
);
450 /* Only check for tx acks if we have something queued. */
451 if (sp
->tx_old
!= sp
->tx_new
)
452 sgiseeq_tx(dev
, sp
, hregs
, sregs
);
454 if ((TX_BUFFS_AVAIL(sp
) > 0) && netif_queue_stopped(dev
)) {
455 netif_wake_queue(dev
);
457 spin_unlock(&sp
->tx_lock
);
462 static int sgiseeq_open(struct net_device
*dev
)
464 struct sgiseeq_private
*sp
= netdev_priv(dev
);
465 struct sgiseeq_regs
*sregs
= sp
->sregs
;
466 unsigned int irq
= dev
->irq
;
469 if (request_irq(irq
, sgiseeq_interrupt
, 0, sgiseeqstr
, dev
)) {
470 printk(KERN_ERR
"Seeq8003: Can't get irq %d\n", dev
->irq
);
474 err
= init_seeq(dev
, sp
, sregs
);
478 netif_start_queue(dev
);
488 static int sgiseeq_close(struct net_device
*dev
)
490 struct sgiseeq_private
*sp
= netdev_priv(dev
);
491 struct sgiseeq_regs
*sregs
= sp
->sregs
;
492 unsigned int irq
= dev
->irq
;
494 netif_stop_queue(dev
);
496 /* Shutdown the Seeq. */
497 reset_hpc3_and_seeq(sp
->hregs
, sregs
);
503 static inline int sgiseeq_reset(struct net_device
*dev
)
505 struct sgiseeq_private
*sp
= netdev_priv(dev
);
506 struct sgiseeq_regs
*sregs
= sp
->sregs
;
509 err
= init_seeq(dev
, sp
, sregs
);
513 dev
->trans_start
= jiffies
;
514 netif_wake_queue(dev
);
519 static int sgiseeq_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
521 struct sgiseeq_private
*sp
= netdev_priv(dev
);
522 struct hpc3_ethregs
*hregs
= sp
->hregs
;
524 struct sgiseeq_tx_desc
*td
;
525 int skblen
, len
, entry
;
527 spin_lock_irqsave(&sp
->tx_lock
, flags
);
531 len
= (skblen
<= ETH_ZLEN
) ? ETH_ZLEN
: skblen
;
532 sp
->stats
.tx_bytes
+= len
;
534 td
= &sp
->tx_desc
[entry
];
536 /* Create entry. There are so many races with adding a new
537 * descriptor to the chain:
538 * 1) Assume that the HPC is off processing a DMA chain while
539 * we are changing all of the following.
540 * 2) Do no allow the HPC to look at a new descriptor until
541 * we have completely set up it's state. This means, do
542 * not clear HPCDMA_EOX in the current last descritptor
543 * until the one we are adding looks consistent and could
544 * be processes right now.
545 * 3) The tx interrupt code must notice when we've added a new
546 * entry and the HPC got to the end of the chain before we
547 * added this new entry and restarted it.
549 memcpy((char *)(long)td
->buf_vaddr
, skb
->data
, skblen
);
551 memset((char *)(long)td
->buf_vaddr
+ skb
->len
, 0, len
-skblen
);
552 td
->tdma
.cntinfo
= (len
& HPCDMA_BCNT
) |
553 HPCDMA_XIU
| HPCDMA_EOXP
| HPCDMA_XIE
| HPCDMA_EOX
;
554 if (sp
->tx_old
!= sp
->tx_new
) {
555 struct sgiseeq_tx_desc
*backend
;
557 backend
= &sp
->tx_desc
[PREV_TX(sp
->tx_new
)];
558 backend
->tdma
.cntinfo
&= ~HPCDMA_EOX
;
560 sp
->tx_new
= NEXT_TX(sp
->tx_new
); /* Advance. */
562 /* Maybe kick the HPC back into motion. */
563 if (!(hregs
->tx_ctrl
& HPC3_ETXCTRL_ACTIVE
))
564 kick_tx(&sp
->tx_desc
[sp
->tx_old
], hregs
);
566 dev
->trans_start
= jiffies
;
569 if (!TX_BUFFS_AVAIL(sp
))
570 netif_stop_queue(dev
);
571 spin_unlock_irqrestore(&sp
->tx_lock
, flags
);
576 static void timeout(struct net_device
*dev
)
578 printk(KERN_NOTICE
"%s: transmit timed out, resetting\n", dev
->name
);
581 dev
->trans_start
= jiffies
;
582 netif_wake_queue(dev
);
585 static struct net_device_stats
*sgiseeq_get_stats(struct net_device
*dev
)
587 struct sgiseeq_private
*sp
= netdev_priv(dev
);
592 static void sgiseeq_set_multicast(struct net_device
*dev
)
594 struct sgiseeq_private
*sp
= (struct sgiseeq_private
*) dev
->priv
;
595 unsigned char oldmode
= sp
->mode
;
597 if(dev
->flags
& IFF_PROMISC
)
598 sp
->mode
= SEEQ_RCMD_RANY
;
599 else if ((dev
->flags
& IFF_ALLMULTI
) || dev
->mc_count
)
600 sp
->mode
= SEEQ_RCMD_RBMCAST
;
602 sp
->mode
= SEEQ_RCMD_RBCAST
;
604 /* XXX I know this sucks, but is there a better way to reprogram
605 * XXX the receiver? At least, this shouldn't happen too often.
608 if (oldmode
!= sp
->mode
)
612 static inline void setup_tx_ring(struct sgiseeq_tx_desc
*buf
, int nbufs
)
616 while (i
< (nbufs
- 1)) {
617 buf
[i
].tdma
.pnext
= CPHYSADDR(buf
+ i
+ 1);
618 buf
[i
].tdma
.pbuf
= 0;
621 buf
[i
].tdma
.pnext
= CPHYSADDR(buf
);
624 static inline void setup_rx_ring(struct sgiseeq_rx_desc
*buf
, int nbufs
)
628 while (i
< (nbufs
- 1)) {
629 buf
[i
].rdma
.pnext
= CPHYSADDR(buf
+ i
+ 1);
630 buf
[i
].rdma
.pbuf
= 0;
633 buf
[i
].rdma
.pbuf
= 0;
634 buf
[i
].rdma
.pnext
= CPHYSADDR(buf
);
637 #define ALIGNED(x) ((((unsigned long)(x)) + 0xf) & ~(0xf))
639 static int sgiseeq_init(struct hpc3_regs
* hpcregs
, int irq
)
641 struct sgiseeq_init_block
*sr
;
642 struct sgiseeq_private
*sp
;
643 struct net_device
*dev
;
646 dev
= alloc_etherdev(sizeof (struct sgiseeq_private
));
648 printk(KERN_ERR
"Sgiseeq: Etherdev alloc failed, aborting.\n");
652 sp
= netdev_priv(dev
);
654 /* Make private data page aligned */
655 sr
= (struct sgiseeq_init_block
*) get_zeroed_page(GFP_KERNEL
);
657 printk(KERN_ERR
"Sgiseeq: Page alloc failed, aborting.\n");
659 goto err_out_free_dev
;
663 #define EADDR_NVOFS 250
664 for (i
= 0; i
< 3; i
++) {
665 unsigned short tmp
= ip22_nvram_read(EADDR_NVOFS
/ 2 + i
);
667 dev
->dev_addr
[2 * i
] = tmp
>> 8;
668 dev
->dev_addr
[2 * i
+ 1] = tmp
& 0xff;
675 sp
->sregs
= (struct sgiseeq_regs
*) &hpcregs
->eth_ext
[0];
676 sp
->hregs
= &hpcregs
->ethregs
;
677 sp
->name
= sgiseeqstr
;
678 sp
->mode
= SEEQ_RCMD_RBCAST
;
680 sp
->rx_desc
= (struct sgiseeq_rx_desc
*)
681 CKSEG1ADDR(ALIGNED(&sp
->srings
->rxvector
[0]));
682 dma_cache_wback_inv((unsigned long)&sp
->srings
->rxvector
,
683 sizeof(sp
->srings
->rxvector
));
684 sp
->tx_desc
= (struct sgiseeq_tx_desc
*)
685 CKSEG1ADDR(ALIGNED(&sp
->srings
->txvector
[0]));
686 dma_cache_wback_inv((unsigned long)&sp
->srings
->txvector
,
687 sizeof(sp
->srings
->txvector
));
689 /* A couple calculations now, saves many cycles later. */
690 setup_rx_ring(sp
->rx_desc
, SEEQ_RX_BUFFERS
);
691 setup_tx_ring(sp
->tx_desc
, SEEQ_TX_BUFFERS
);
693 /* Setup PIO and DMA transfer timing */
694 sp
->hregs
->pconfig
= 0x161;
695 sp
->hregs
->dconfig
= HPC3_EDCFG_FIRQ
| HPC3_EDCFG_FEOP
|
696 HPC3_EDCFG_FRXDC
| HPC3_EDCFG_PTO
| 0x026;
698 /* Reset the chip. */
699 hpc3_eth_reset(sp
->hregs
);
701 sp
->is_edlc
= !(sp
->sregs
->rw
.rregs
.collision_tx
[0] & 0xff);
703 sp
->control
= SEEQ_CTRL_XCNT
| SEEQ_CTRL_ACCNT
|
704 SEEQ_CTRL_SFLAG
| SEEQ_CTRL_ESHORT
|
707 dev
->open
= sgiseeq_open
;
708 dev
->stop
= sgiseeq_close
;
709 dev
->hard_start_xmit
= sgiseeq_start_xmit
;
710 dev
->tx_timeout
= timeout
;
711 dev
->watchdog_timeo
= (200 * HZ
) / 1000;
712 dev
->get_stats
= sgiseeq_get_stats
;
713 dev
->set_multicast_list
= sgiseeq_set_multicast
;
714 dev
->set_mac_address
= sgiseeq_set_mac_address
;
717 if (register_netdev(dev
)) {
718 printk(KERN_ERR
"Sgiseeq: Cannot register net device, "
721 goto err_out_free_page
;
724 printk(KERN_INFO
"%s: %s ", dev
->name
, sgiseeqstr
);
725 for (i
= 0; i
< 6; i
++)
726 printk("%2.2x%c", dev
->dev_addr
[i
], i
== 5 ? '\n' : ':');
728 sp
->next_module
= root_sgiseeq_dev
;
729 root_sgiseeq_dev
= dev
;
734 free_page((unsigned long) sp
->srings
);
742 static int __init
sgiseeq_probe(void)
744 /* On board adapter on 1st HPC is always present */
745 return sgiseeq_init(hpc3c0
, SGI_ENET_IRQ
);
748 static void __exit
sgiseeq_exit(void)
750 struct net_device
*next
, *dev
;
751 struct sgiseeq_private
*sp
;
753 for (dev
= root_sgiseeq_dev
; dev
; dev
= next
) {
754 sp
= (struct sgiseeq_private
*) netdev_priv(dev
);
755 next
= sp
->next_module
;
756 unregister_netdev(dev
);
757 free_page((unsigned long) sp
->srings
);
762 module_init(sgiseeq_probe
);
763 module_exit(sgiseeq_exit
);
765 MODULE_DESCRIPTION("SGI Seeq 8003 driver");
766 MODULE_AUTHOR("Linux/MIPS Mailing List <linux-mips@linux-mips.org>");
767 MODULE_LICENSE("GPL");
This page took 0.04624 seconds and 5 git commands to generate.