2 * meth.c -- O2 Builtin 10/100 Ethernet driver
4 * Copyright (C) 2001 Ilya Volynets
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
11 #include <linux/module.h>
12 #include <linux/init.h>
14 #include <linux/sched.h>
15 #include <linux/kernel.h> /* printk() */
16 #include <linux/delay.h>
17 #include <linux/slab.h>
18 #include <linux/errno.h> /* error codes */
19 #include <linux/types.h> /* size_t */
20 #include <linux/interrupt.h> /* mark_bh */
23 #include <linux/netdevice.h> /* struct device, and other headers */
24 #include <linux/etherdevice.h> /* eth_type_trans */
25 #include <linux/ip.h> /* struct iphdr */
26 #include <linux/tcp.h> /* struct tcphdr */
27 #include <linux/skbuff.h>
28 #include <linux/mii.h> /*MII definitions */
30 #include <asm/ip32/crime.h>
31 #include <asm/ip32/mace.h>
32 #include <asm/ip32/ip32_ints.h>
34 #include <linux/slab.h>
36 #include <asm/scatterlist.h>
37 #include <linux/device.h> /* struct device, et al */
38 #include <linux/dma-mapping.h>
42 #include <linux/in6.h>
43 #include <asm/checksum.h>
50 #define DPRINTK(str,args...) printk (KERN_DEBUG "meth(%ld): %s: " str, jiffies, __FUNCTION__ , ## args)
51 #define MFE_RX_DEBUG 2
53 #define DPRINTK(str,args...)
54 #define MFE_RX_DEBUG 0
58 static const char *meth_str
="SGI O2 Fast Ethernet";
59 MODULE_AUTHOR("Ilya Volynets <ilya@theIlya.com>");
60 MODULE_DESCRIPTION("SGI O2 Builtin Fast Ethernet driver");
62 #define HAVE_TX_TIMEOUT
63 /* The maximum time waited (in jiffies) before assuming a Tx failed. (400ms) */
64 #define TX_TIMEOUT (400*HZ/1000)
66 #ifdef HAVE_TX_TIMEOUT
67 static int timeout
= TX_TIMEOUT
;
68 MODULE_PARM(timeout
, "i");
72 * This structure is private to each device. It is used to pass
73 * packets in and out, so there is place for a packet
76 typedef struct meth_private
{
77 struct net_device_stats stats
;
78 volatile struct meth_regs
*regs
;
79 u64 mode
; /* in-memory copy of MAC control register */
80 int phy_addr
; /* address of phy, used by mdio_* functions, initialized in mdio_probe*/
82 dma_addr_t tx_ring_dma
;
84 struct sk_buff
*tx_skbs
[TX_RING_ENTRIES
];
85 dma_addr_t tx_skb_dmas
[TX_RING_ENTRIES
];
89 rx_packet
*rx_ring
[RX_RING_ENTRIES
];
90 dma_addr_t rx_ring_dmas
[RX_RING_ENTRIES
];
96 void meth_tx_timeout (struct net_device
*dev
);
97 irqreturn_t
meth_interrupt(int irq
, void *dev_id
, struct pt_regs
*pregs
);
99 /* global, initialized in ip32-setup.c */
100 char o2meth_eaddr
[8]={0,0,0,0,0,0,0,0};
102 static inline void load_eaddr(struct net_device
*dev
,
103 volatile struct meth_regs
*regs
)
106 DPRINTK("Loading MAC Address: %02x:%02x:%02x:%02x:%02x:%02x\n",
107 (int)o2meth_eaddr
[0]&0xFF,(int)o2meth_eaddr
[1]&0xFF,(int)o2meth_eaddr
[2]&0xFF,
108 (int)o2meth_eaddr
[3]&0xFF,(int)o2meth_eaddr
[4]&0xFF,(int)o2meth_eaddr
[5]&0xFF);
110 dev
->dev_addr
[i
]=o2meth_eaddr
[i
];
111 regs
->mac_addr
=(*(u64
*)o2meth_eaddr
)>>16;
115 *Waits for BUSY status of mdio bus to clear
117 #define WAIT_FOR_PHY(___regs, ___rval) \
118 while((___rval=___regs->phy_data)&MDIO_BUSY){ \
121 /*read phy register, return value read */
122 static int mdio_read(meth_private
*priv
,int phyreg
)
124 volatile meth_regs
* regs
=priv
->regs
;
126 WAIT_FOR_PHY(regs
,rval
);
127 regs
->phy_registers
=(priv
->phy_addr
<<5)|(phyreg
&0x1f);
129 regs
->phy_trans_go
=1;
131 WAIT_FOR_PHY(regs
,rval
);
132 return rval
&MDIO_DATA_MASK
;
135 static int mdio_probe(meth_private
*priv
)
138 DPRINTK("Detecting PHY kind\n");
139 /* check if phy is detected already */
140 if(priv
->phy_addr
>=0&&priv
->phy_addr
<32)
142 spin_lock(&priv
->meth_lock
);
144 priv
->phy_addr
=(char)i
;
145 p2
=mdio_read(priv
,2);
147 p3
=mdio_read(priv
,3);
148 switch ((p2
<<12)|(p3
>>4)){
150 DPRINTK("PHY is QS6612X\n");
153 DPRINTK("PHY is ICS1889\n");
156 DPRINTK("PHY is ICS1890\n");
159 DPRINTK("PHY is DP83840\n");
163 if(p2
!=0xffff&&p2
!=0x0000){
164 DPRINTK("PHY code: %x\n",(p2
<<12)|(p3
>>4));
168 spin_unlock(&priv
->meth_lock
);
169 if(priv
->phy_addr
<32) {
172 DPRINTK("Oopsie! PHY is not known!\n");
177 static void meth_check_link(struct net_device
*dev
)
179 struct meth_private
*priv
= (struct meth_private
*) dev
->priv
;
180 int mii_partner
= mdio_read(priv
, 5);
181 int mii_advertising
= mdio_read(priv
, 4);
182 int negotiated
= mii_advertising
& mii_partner
;
185 if (mii_partner
== 0xffff)
188 duplex
= ((negotiated
& 0x0100) || (negotiated
& 0x01C0) == 0x0040)?METH_PHY_FDX
:0;
189 speed
= (negotiated
& 0x0380)?METH_100MBIT
:0;
191 if ((priv
->mode
& METH_PHY_FDX
) ^ duplex
)
193 DPRINTK("Setting %s-duplex\n", duplex
? "full" : "half");
195 priv
->mode
|= METH_PHY_FDX
;
197 priv
->mode
&= ~METH_PHY_FDX
;
198 priv
->regs
->mac_ctrl
= priv
->mode
;
201 if ((priv
->mode
& METH_100MBIT
) ^ speed
)
203 DPRINTK("Setting %dMbs mode\n", speed
? 100 : 10);
205 priv
->mode
|= METH_100MBIT
;
207 priv
->mode
&= ~METH_100MBIT
;
208 priv
->regs
->mac_ctrl
= priv
->mode
;
213 static int meth_init_tx_ring(meth_private
*priv
)
216 DPRINTK("Initializing TX ring\n");
217 priv
->tx_ring
= dma_alloc_coherent(NULL
, TX_RING_BUFFER_SIZE
,
218 &priv
->tx_ring_dma
, GFP_ATOMIC
);
221 memset(priv
->tx_ring
, 0, TX_RING_BUFFER_SIZE
);
222 priv
->tx_count
= priv
->tx_read
= priv
->tx_write
= 0;
223 priv
->regs
->tx_ring_base
= priv
->tx_ring_dma
;
224 priv
->free_space
= TX_RING_ENTRIES
;
225 /* Now init skb save area */
226 memset(priv
->tx_skbs
,0,sizeof(priv
->tx_skbs
));
227 memset(priv
->tx_skb_dmas
,0,sizeof(priv
->tx_skb_dmas
));
228 DPRINTK("Done with TX ring init\n");
232 static int meth_init_rx_ring(meth_private
*priv
)
235 for(i
=0;i
<RX_RING_ENTRIES
;i
++){
236 priv
->rx_ring
[i
] = dma_alloc_coherent(NULL
, METH_RX_BUFF_SIZE
,
237 &priv
->rx_ring_dmas
[i
],0);
238 /* I'll need to re-sync it after each RX */
239 priv
->regs
->rx_fifo
=priv
->rx_ring_dmas
[i
];
242 DPRINTK("Done with RX ring\n");
245 static void meth_free_tx_ring(meth_private
*priv
)
249 /* Remove any pending skb */
250 for (i
= 0; i
< TX_RING_ENTRIES
; i
++) {
251 if (priv
->tx_skbs
[i
])
252 dev_kfree_skb(priv
->tx_skbs
[i
]);
253 priv
->tx_skbs
[i
] = NULL
;
255 dma_free_coherent(NULL
, TX_RING_BUFFER_SIZE
, priv
->tx_ring
,
258 static void meth_free_rx_ring(meth_private
*priv
)
262 for(i
=0;i
<RX_RING_ENTRIES
;i
++)
263 dma_free_coherent(NULL
, METH_RX_BUFF_SIZE
, priv
->rx_ring
[i
],
264 priv
->rx_ring_dmas
[i
]);
267 int meth_reset(struct net_device
*dev
)
269 struct meth_private
*priv
= (struct meth_private
*) dev
->priv
;
272 priv
->regs
->mac_ctrl
= SGI_MAC_RESET
;
273 priv
->regs
->mac_ctrl
= 0;
276 /* Load ethernet address */
277 load_eaddr(dev
, priv
->regs
);
278 /* Should load some "errata", but later */
280 /* Check for device */
281 if(mdio_probe(priv
) < 0) {
282 DPRINTK("Unable to find PHY\n");
286 /* Initial mode -- 10|Half-duplex|Accept normal packets */
287 priv
->mode
=METH_ACCEPT_MCAST
|METH_DEFAULT_IPG
;
288 if(dev
->flags
| IFF_PROMISC
)
289 priv
->mode
|= METH_PROMISC
;
290 priv
->regs
->mac_ctrl
= priv
->mode
;
292 /* Autonegociate speed and duplex mode */
293 meth_check_link(dev
);
295 /* Now set dma control, but don't enable DMA, yet */
296 priv
->regs
->dma_ctrl
= (4 << METH_RX_OFFSET_SHIFT
) |
297 (RX_RING_ENTRIES
<< METH_RX_DEPTH_SHIFT
);
302 /*============End Helper Routines=====================*/
308 int meth_open(struct net_device
*dev
)
310 meth_private
*priv
=dev
->priv
;
311 volatile meth_regs
*regs
=priv
->regs
;
314 /* Initialize the hardware */
315 if((ret
=meth_reset(dev
)) < 0)
318 /* Allocate the ring buffers */
319 if((ret
=meth_init_tx_ring(priv
))<0||(ret
=meth_init_rx_ring(priv
))<0){
320 meth_free_tx_ring(priv
);
321 meth_free_rx_ring(priv
);
325 DPRINTK("Will set dma_ctl now\n");
328 METH_DMA_TX_EN
|/*METH_DMA_TX_INT_EN|*/
329 METH_DMA_RX_EN
|METH_DMA_RX_INT_EN
;
331 if(request_irq(dev
->irq
,meth_interrupt
,SA_SHIRQ
,meth_str
,dev
)){
332 printk(KERN_ERR
"%s: Can't get irq %d\n", dev
->name
, dev
->irq
);
335 DPRINTK("About to start queue\n");
336 netif_start_queue(dev
);
337 DPRINTK("Opened... DMA control=0x%08lx\n", regs
->dma_ctrl
);
341 int meth_release(struct net_device
*dev
)
343 meth_private
*priv
=dev
->priv
;
344 netif_stop_queue(dev
); /* can't transmit any more */
346 ((meth_private
*)(dev
->priv
))->regs
->dma_ctrl
&=
347 ~(METH_DMA_TX_EN
|METH_DMA_TX_INT_EN
|
348 METH_DMA_RX_EN
|METH_DMA_RX_INT_EN
);
349 free_irq(dev
->irq
, dev
);
350 meth_free_tx_ring(priv
);
351 meth_free_rx_ring(priv
);
356 * Configuration changes (passed on by ifconfig)
358 int meth_config(struct net_device
*dev
, struct ifmap
*map
)
360 if (dev
->flags
& IFF_UP
) /* can't act on a running interface */
363 /* Don't allow changing the I/O address */
364 if (map
->base_addr
!= dev
->base_addr
) {
365 printk(KERN_WARNING
"meth: Can't change I/O address\n");
369 /* Don't allow changing the IRQ */
370 if (map
->irq
!= dev
->irq
) {
371 printk(KERN_WARNING
"meth: Can't change IRQ\n");
374 DPRINTK("Configured\n");
376 /* ignore other fields */
381 * Receive a packet: retrieve, encapsulate and pass over to upper levels
383 void meth_rx(struct net_device
* dev
)
386 struct meth_private
*priv
= (struct meth_private
*) dev
->priv
;
388 int twptr
=priv
->rx_write
;
390 spin_lock(&(priv
->meth_lock
));
391 while ((status
=(rxb
=priv
->rx_ring
[priv
->rx_write
])->status
.raw
)&0x8000000000000000)
393 int len
=(status
&0xFFFF) - 4; /* omit CRC */
394 /* length sanity check */
395 if(len
< 60 || len
> 1518) {
396 printk(KERN_DEBUG
"%s: bogus packet size: %d, status=%#2lx.\n",
397 dev
->name
, priv
->rx_write
, rxb
->status
.raw
);
398 priv
->stats
.rx_errors
++;
399 priv
->stats
.rx_length_errors
++;
401 if(!(status
&METH_RX_STATUS_ERRORS
)){
402 skb
=alloc_skb(len
+2,GFP_ATOMIC
);/* Should be atomic -- we are in interrupt */
404 /* Ouch! No memory! Drop packet on the floor */
405 priv
->stats
.rx_dropped
++;
407 skb_reserve(skb
, 2); /* align IP on 16B boundary */
408 memcpy(skb_put(skb
, len
), rxb
->buf
, len
);
409 /* Write metadata, and then pass to the receive level */
411 skb
->protocol
= eth_type_trans(skb
, dev
);
413 dev
->last_rx
= jiffies
;
414 priv
->stats
.rx_packets
++;
415 priv
->stats
.rx_bytes
+=len
;
419 printk(KERN_WARNING
"meth: RX error: status=0x%016lx\n",status
);
420 if(status
&METH_RX_ST_RCV_CODE_VIOLATION
)
421 printk(KERN_WARNING
"Receive Code Violation\n");
422 if(status
&METH_RX_ST_CRC_ERR
)
423 printk(KERN_WARNING
"CRC error\n");
424 if(status
&METH_RX_ST_INV_PREAMBLE_CTX
)
425 printk(KERN_WARNING
"Invalid Preamble Context\n");
426 if(status
&METH_RX_ST_LONG_EVT_SEEN
)
427 printk(KERN_WARNING
"Long Event Seen...\n");
428 if(status
&METH_RX_ST_BAD_PACKET
)
429 printk(KERN_WARNING
"Bad Packet\n");
430 if(status
&METH_RX_ST_CARRIER_EVT_SEEN
)
431 printk(KERN_WARNING
"Carrier Event Seen\n");
434 priv
->regs
->rx_fifo
=priv
->rx_ring_dmas
[priv
->rx_write
];
435 priv
->rx_write
=(priv
->rx_write
+1)&(RX_RING_ENTRIES
-1);
436 if(priv
->rx_write
==twptr
) {
437 DPRINTK("going rounds\n");
440 spin_unlock(&(priv
->meth_lock
));
443 static int meth_tx_full(struct net_device
*dev
)
445 struct meth_private
*priv
= (struct meth_private
*) dev
->priv
;
447 return(priv
->tx_count
>= TX_RING_ENTRIES
-1);
450 void meth_tx_cleanup(struct net_device
* dev
, int rptr
)
452 meth_private
*priv
=dev
->priv
;
456 spin_lock(&priv
->meth_lock
);
459 priv
->regs
->dma_ctrl
&= ~(METH_DMA_TX_INT_EN
);
461 while(priv
->tx_read
!= rptr
){
462 skb
= priv
->tx_skbs
[priv
->tx_read
];
463 status
= &priv
->tx_ring
[priv
->tx_read
];
464 if(!status
->header
.res
.sent
)
466 if(status
->header
.raw
& METH_TX_STATUS_DONE
) {
467 priv
->stats
.tx_packets
++;
468 priv
->stats
.tx_bytes
+= skb
->len
;
470 dev_kfree_skb_irq(skb
);
471 priv
->tx_skbs
[priv
->tx_read
] = NULL
;
472 status
->header
.raw
= 0;
473 priv
->tx_read
= (priv
->tx_read
+1)&(TX_RING_ENTRIES
-1);
477 /* wake up queue if it was stopped */
478 if (netif_queue_stopped(dev
) && ! meth_tx_full(dev
)) {
479 netif_wake_queue(dev
);
482 spin_unlock(priv
->meth_lock
);
486 * The typical interrupt entry point
488 irqreturn_t
meth_interrupt(int irq
, void *dev_id
, struct pt_regs
*pregs
)
490 struct meth_private
*priv
;
493 * As usual, check the "device" pointer for shared handlers.
494 * Then assign "struct device *dev"
496 struct net_device
*dev
= (struct net_device
*)dev_id
;
497 /* ... and check with hw if it's really ours */
499 if (!dev
/*paranoid*/ ) return IRQ_HANDLED
;
501 priv
= (struct meth_private
*) dev
->priv
;
503 status
= priv
->regs
->int_flags
;
505 if (status
& (METH_INT_RX_THRESHOLD
|METH_INT_RX_UNDERFLOW
)) {
506 /* send it to meth_rx for handling */
510 if (status
& (METH_INT_TX_EMPTY
|METH_INT_TX_PKT
)) {
511 /* a transmission is over: free the skb */
512 meth_tx_cleanup(dev
, (priv
->regs
->tx_info
&TX_INFO_RPTR
)>>16);
514 /* check for errors too... */
515 if (status
& (METH_INT_TX_LINK_FAIL
))
516 printk(KERN_WARNING
"meth: link failure\n");
517 if (status
& (METH_INT_MEM_ERROR
))
518 printk(KERN_WARNING
"meth: memory error\n");
519 if (status
& (METH_INT_TX_ABORT
))
520 printk(KERN_WARNING
"meth: aborted\n");
521 if (status
& (METH_INT_RX_OVERFLOW
))
522 printk(KERN_WARNING
"meth: RX overflow\n");
523 if (status
& (METH_INT_RX_UNDERFLOW
))
524 printk(KERN_WARNING
"meth: RX underflow\n");
526 #define METH_INT_ERROR (METH_INT_TX_LINK_FAIL| \
527 METH_INT_MEM_ERROR| \
529 METH_INT_RX_OVERFLOW| \
530 METH_INT_RX_UNDERFLOW)
531 if( status
& METH_INT_ERROR
) {
532 printk(KERN_WARNING
"meth: error status: 0x%08x\n",status
);
533 netif_wake_queue(dev
);
535 priv
->regs
->int_flags
=status
&0xff; /* clear interrupts */
540 * Transmits packets that fit into TX descriptor (are <=120B)
542 static void meth_tx_short_prepare(meth_private
* priv
, struct sk_buff
* skb
)
544 tx_packet
*desc
=&priv
->tx_ring
[priv
->tx_write
];
545 int len
= (skb
->len
<ETH_ZLEN
)?ETH_ZLEN
:skb
->len
;
547 /* maybe I should set whole thing to 0 first... */
548 memcpy(desc
->data
.dt
+(120-len
),skb
->data
,skb
->len
);
550 memset(desc
->data
.dt
+120-len
+skb
->len
,0,len
-skb
->len
);
551 desc
->header
.raw
=METH_TX_CMD_INT_EN
|(len
-1)|((128-len
)<<16);
553 #define TX_CATBUF1 BIT(25)
554 static void meth_tx_1page_prepare(meth_private
* priv
, struct sk_buff
* skb
)
556 tx_packet
*desc
=&priv
->tx_ring
[priv
->tx_write
];
557 void *buffer_data
= (void *)(((u64
)skb
->data
+ 7ULL) & (~7ULL));
558 int unaligned_len
= (int)((u64
)buffer_data
- (u64
)skb
->data
);
559 int buffer_len
= skb
->len
- unaligned_len
;
562 desc
->header
.raw
=METH_TX_CMD_INT_EN
|TX_CATBUF1
|(skb
->len
-1);
566 memcpy(desc
->data
.dt
+(120-unaligned_len
),
567 skb
->data
, unaligned_len
);
568 desc
->header
.raw
|= (128-unaligned_len
) << 16;
572 catbuf
= dma_map_single(NULL
, buffer_data
, buffer_len
,
574 desc
->data
.cat_buf
[0].form
.start_addr
= catbuf
>> 3;
575 desc
->data
.cat_buf
[0].form
.len
= buffer_len
-1;
577 #define TX_CATBUF2 BIT(26)
578 static void meth_tx_2page_prepare(meth_private
* priv
, struct sk_buff
* skb
)
580 tx_packet
*desc
=&priv
->tx_ring
[priv
->tx_write
];
581 void *buffer1_data
= (void *)(((u64
)skb
->data
+ 7ULL) & (~7ULL));
582 void *buffer2_data
= (void *)PAGE_ALIGN((u64
)skb
->data
);
583 int unaligned_len
= (int)((u64
)buffer1_data
- (u64
)skb
->data
);
584 int buffer1_len
= (int)((u64
)buffer2_data
- (u64
)buffer1_data
);
585 int buffer2_len
= skb
->len
- buffer1_len
- unaligned_len
;
586 dma_addr_t catbuf1
, catbuf2
;
588 desc
->header
.raw
=METH_TX_CMD_INT_EN
|TX_CATBUF1
|TX_CATBUF2
|(skb
->len
-1);
591 memcpy(desc
->data
.dt
+(120-unaligned_len
),
592 skb
->data
, unaligned_len
);
593 desc
->header
.raw
|= (128-unaligned_len
) << 16;
597 catbuf1
= dma_map_single(NULL
, buffer1_data
, buffer1_len
,
599 desc
->data
.cat_buf
[0].form
.start_addr
= catbuf1
>> 3;
600 desc
->data
.cat_buf
[0].form
.len
= buffer1_len
-1;
602 catbuf2
= dma_map_single(NULL
, buffer2_data
, buffer2_len
,
604 desc
->data
.cat_buf
[1].form
.start_addr
= catbuf2
>> 3;
605 desc
->data
.cat_buf
[1].form
.len
= buffer2_len
-1;
608 void meth_add_to_tx_ring(meth_private
*priv
, struct sk_buff
* skb
)
610 if(skb
->len
<= 120) {
611 /* Whole packet fits into descriptor */
612 meth_tx_short_prepare(priv
,skb
);
613 } else if(PAGE_ALIGN((u64
)skb
->data
) !=
614 PAGE_ALIGN((u64
)skb
->data
+skb
->len
-1)) {
615 /* Packet crosses page boundary */
616 meth_tx_2page_prepare(priv
,skb
);
618 /* Packet is in one page */
619 meth_tx_1page_prepare(priv
,skb
);
622 /* Remember the skb, so we can free it at interrupt time */
623 priv
->tx_skbs
[priv
->tx_write
] = skb
;
624 priv
->tx_write
= (priv
->tx_write
+1) & (TX_RING_ENTRIES
-1);
625 priv
->regs
->tx_info
= priv
->tx_write
;
627 /* Enable DMA transfer */
628 priv
->regs
->dma_ctrl
|= METH_DMA_TX_INT_EN
;
632 * Transmit a packet (called by the kernel)
634 int meth_tx(struct sk_buff
*skb
, struct net_device
*dev
)
636 struct meth_private
*priv
= (struct meth_private
*) dev
->priv
;
638 spin_lock(&priv
->meth_lock
);
640 meth_add_to_tx_ring(priv
, skb
);
641 dev
->trans_start
= jiffies
; /* save the timestamp */
643 /* If TX ring is full, tell the upper layer to stop sending packets */
644 if (meth_tx_full(dev
)) {
645 printk("TX full: stopping\n");
646 netif_stop_queue(dev
);
649 spin_unlock(&priv
->meth_lock
);
655 * Deal with a transmit timeout.
658 void meth_tx_timeout (struct net_device
*dev
)
660 struct meth_private
*priv
= (struct meth_private
*) dev
->priv
;
662 printk(KERN_WARNING
"%s: transmit timed out\n", dev
->name
);
664 /* Protect against concurrent rx interrupts */
665 spin_lock(&priv
->meth_lock
);
667 /* Try to reset the interface. */
670 priv
->stats
.tx_errors
++;
672 /* Clear all rings */
673 meth_free_tx_ring(priv
);
674 meth_free_rx_ring(priv
);
675 meth_init_tx_ring(priv
);
676 meth_init_rx_ring(priv
);
679 priv
->regs
->dma_ctrl
|=METH_DMA_TX_EN
|METH_DMA_RX_EN
|METH_DMA_RX_INT_EN
;
681 /* Enable interrupt */
682 spin_unlock(&priv
->meth_lock
);
684 dev
->trans_start
= jiffies
;
685 netif_wake_queue(dev
);
693 int meth_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
701 * Return statistics to the caller
703 struct net_device_stats
*meth_stats(struct net_device
*dev
)
705 struct meth_private
*priv
= (struct meth_private
*) dev
->priv
;
710 * The init function (sometimes called probe).
711 * It is invoked by register_netdev()
713 int meth_init(struct net_device
*dev
)
715 meth_private
*priv
=(meth_private
*)dev
->priv
;
717 * Then, assign other fields in dev, using ether_setup() and some
720 ether_setup(dev
); /* assign some of the fields */
722 dev
->open
= meth_open
;
723 dev
->stop
= meth_release
;
724 dev
->set_config
= meth_config
;
725 dev
->hard_start_xmit
= meth_tx
;
726 dev
->do_ioctl
= meth_ioctl
;
727 dev
->get_stats
= meth_stats
;
728 #ifdef HAVE_TX_TIMEOUT
729 dev
->tx_timeout
= meth_tx_timeout
;
730 dev
->watchdog_timeo
= timeout
;
732 dev
->irq
= MACE_ETHERNET_IRQ
;
733 SET_MODULE_OWNER(dev
);
735 spin_lock_init(&((struct meth_private
*) dev
->priv
)->meth_lock
);
737 * Make the usual checks: check_region(), probe irq, ... -ENODEV
738 * should be returned if no device found. No resource should be
739 * grabbed: this is done on open().
741 priv
->regs
=(meth_regs
*)SGI_MFE
;
742 dev
->base_addr
=SGI_MFE
;
743 priv
->phy_addr
= -1; /* No phy is known yet... */
745 printk("SGI O2 Fast Ethernet rev. %ld\n", priv
->regs
->mac_ctrl
>> 29);
754 struct net_device
*meth_dev
;
757 * Finally, the module stuff
760 int meth_init_module(void)
762 int result
, device_present
= 0;
764 meth_dev
=alloc_etherdev(sizeof(meth_private
));
767 if ( (result
= register_netdev(meth_dev
)) )
768 printk("meth: error %i registering device \"%s\"\n",
769 result
, meth_dev
->name
);
770 else device_present
++;
772 return device_present
? 0 : -ENODEV
;
775 void meth_cleanup(void)
777 unregister_netdev(meth_dev
);
782 module_init(meth_init_module
);
783 module_exit(meth_cleanup
);