]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/net/sonic.c
4 * (C) 1996,1998 by Thomas Bogendoerfer (tsbogend@alpha.franken.de)
6 * This driver is based on work from Andreas Busse, but most of
7 * the code is rewritten.
9 * (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
11 * Core code included by system sonic drivers
15 * Sources: Olivetti M700-10 Risc Personal Computer hardware handbook,
16 * National Semiconductors data sheet for the DP83932B Sonic Ethernet
17 * controller, and the files "8390.c" and "skeleton.c" in this directory.
23 * Open/initialize the SONIC controller.
25 * This routine should set everything up anew at each open, even
26 * registers that "should" only need to be set once at boot, so that
27 * there is non-reboot way to recover if something goes wrong.
29 static int sonic_open(struct net_device
*dev
)
32 printk("sonic_open: initializing sonic driver.\n");
35 * We don't need to deal with auto-irq stuff since we
36 * hardwire the sonic interrupt.
39 * XXX Horrible work around: We install sonic_interrupt as fast interrupt.
40 * This means that during execution of the handler interrupt are disabled
41 * covering another bug otherwise corrupting data. This doesn't mean
42 * this glue works ok under all situations.
44 // if (sonic_request_irq(dev->irq, &sonic_interrupt, 0, "sonic", dev)) {
45 if (sonic_request_irq(dev
->irq
, &sonic_interrupt
, SA_INTERRUPT
,
47 printk("\n%s: unable to get IRQ %d .\n", dev
->name
, dev
->irq
);
52 * Initialize the SONIC
56 netif_start_queue(dev
);
59 printk("sonic_open: Initialization done.\n");
66 * Close the SONIC device
68 static int sonic_close(struct net_device
*dev
)
70 unsigned int base_addr
= dev
->base_addr
;
73 printk("sonic_close\n");
75 netif_stop_queue(dev
);
78 * stop the SONIC, disable interrupts
80 SONIC_WRITE(SONIC_ISR
, 0x7fff);
81 SONIC_WRITE(SONIC_IMR
, 0);
82 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
84 sonic_free_irq(dev
->irq
, dev
); /* release the IRQ */
89 static void sonic_tx_timeout(struct net_device
*dev
)
91 struct sonic_local
*lp
= (struct sonic_local
*) dev
->priv
;
92 printk("%s: transmit timed out.\n", dev
->name
);
94 /* Try to restart the adaptor. */
96 lp
->stats
.tx_errors
++;
97 dev
->trans_start
= jiffies
;
98 netif_wake_queue(dev
);
104 static int sonic_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
106 struct sonic_local
*lp
= (struct sonic_local
*) dev
->priv
;
107 unsigned int base_addr
= dev
->base_addr
;
111 netif_stop_queue(dev
);
114 printk("sonic_send_packet: skb=%p, dev=%p\n", skb
, dev
);
117 * Map the packet data into the logical DMA address space
119 if ((laddr
= vdma_alloc(CPHYSADDR(skb
->data
), skb
->len
)) == ~0UL) {
120 printk("%s: no VDMA entry for transmit available.\n",
123 netif_start_queue(dev
);
126 entry
= lp
->cur_tx
& SONIC_TDS_MASK
;
127 lp
->tx_laddr
[entry
] = laddr
;
128 lp
->tx_skb
[entry
] = skb
;
130 length
= (skb
->len
< ETH_ZLEN
) ? ETH_ZLEN
: skb
->len
;
134 * Setup the transmit descriptor and issue the transmit command.
136 lp
->tda
[entry
].tx_status
= 0; /* clear status */
137 lp
->tda
[entry
].tx_frag_count
= 1; /* single fragment */
138 lp
->tda
[entry
].tx_pktsize
= length
; /* length of packet */
139 lp
->tda
[entry
].tx_frag_ptr_l
= laddr
& 0xffff;
140 lp
->tda
[entry
].tx_frag_ptr_h
= laddr
>> 16;
141 lp
->tda
[entry
].tx_frag_size
= length
;
143 lp
->stats
.tx_bytes
+= length
;
146 printk("sonic_send_packet: issueing Tx command\n");
148 SONIC_WRITE(SONIC_CMD
, SONIC_CR_TXP
);
150 dev
->trans_start
= jiffies
;
152 if (lp
->cur_tx
< lp
->dirty_tx
+ SONIC_NUM_TDS
)
153 netif_start_queue(dev
);
161 * The typical workload of the driver:
162 * Handle the network interface interrupts.
164 static irqreturn_t
sonic_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
166 struct net_device
*dev
= (struct net_device
*) dev_id
;
167 unsigned int base_addr
= dev
->base_addr
;
168 struct sonic_local
*lp
;
172 printk("sonic_interrupt: irq %d for unknown device.\n", irq
);
176 lp
= (struct sonic_local
*) dev
->priv
;
178 status
= SONIC_READ(SONIC_ISR
);
179 SONIC_WRITE(SONIC_ISR
, 0x7fff); /* clear all bits */
182 printk("sonic_interrupt: ISR=%x\n", status
);
184 if (status
& SONIC_INT_PKTRX
) {
185 sonic_rx(dev
); /* got packet(s) */
188 if (status
& SONIC_INT_TXDN
) {
189 int dirty_tx
= lp
->dirty_tx
;
191 while (dirty_tx
< lp
->cur_tx
) {
192 int entry
= dirty_tx
& SONIC_TDS_MASK
;
193 int status
= lp
->tda
[entry
].tx_status
;
197 ("sonic_interrupt: status %d, cur_tx %d, dirty_tx %d\n",
198 status
, lp
->cur_tx
, lp
->dirty_tx
);
201 /* It still hasn't been Txed, kick the sonic again */
202 SONIC_WRITE(SONIC_CMD
, SONIC_CR_TXP
);
206 /* put back EOL and free descriptor */
207 lp
->tda
[entry
].tx_frag_count
= 0;
208 lp
->tda
[entry
].tx_status
= 0;
211 lp
->stats
.tx_packets
++;
213 lp
->stats
.tx_errors
++;
215 lp
->stats
.tx_aborted_errors
++;
217 lp
->stats
.tx_carrier_errors
++;
219 lp
->stats
.tx_window_errors
++;
221 lp
->stats
.tx_fifo_errors
++;
224 /* We must free the original skb */
225 if (lp
->tx_skb
[entry
]) {
226 dev_kfree_skb_irq(lp
->tx_skb
[entry
]);
227 lp
->tx_skb
[entry
] = 0;
229 /* and the VDMA address */
230 vdma_free(lp
->tx_laddr
[entry
]);
235 && dirty_tx
+ SONIC_NUM_TDS
> lp
->cur_tx
+ 2) {
236 /* The ring is no longer full, clear tbusy. */
238 netif_wake_queue(dev
);
241 lp
->dirty_tx
= dirty_tx
;
245 * check error conditions
247 if (status
& SONIC_INT_RFO
) {
248 printk("%s: receive fifo underrun\n", dev
->name
);
249 lp
->stats
.rx_fifo_errors
++;
251 if (status
& SONIC_INT_RDE
) {
252 printk("%s: receive descriptors exhausted\n", dev
->name
);
253 lp
->stats
.rx_dropped
++;
255 if (status
& SONIC_INT_RBE
) {
256 printk("%s: receive buffer exhausted\n", dev
->name
);
257 lp
->stats
.rx_dropped
++;
259 if (status
& SONIC_INT_RBAE
) {
260 printk("%s: receive buffer area exhausted\n", dev
->name
);
261 lp
->stats
.rx_dropped
++;
264 /* counter overruns; all counters are 16bit wide */
265 if (status
& SONIC_INT_FAE
)
266 lp
->stats
.rx_frame_errors
+= 65536;
267 if (status
& SONIC_INT_CRC
)
268 lp
->stats
.rx_crc_errors
+= 65536;
269 if (status
& SONIC_INT_MP
)
270 lp
->stats
.rx_missed_errors
+= 65536;
273 if (status
& SONIC_INT_TXER
)
274 lp
->stats
.tx_errors
++;
277 * clear interrupt bits and return
279 SONIC_WRITE(SONIC_ISR
, status
);
284 * We have a good packet(s), get it/them out of the buffers.
286 static void sonic_rx(struct net_device
*dev
)
288 unsigned int base_addr
= dev
->base_addr
;
289 struct sonic_local
*lp
= (struct sonic_local
*) dev
->priv
;
290 sonic_rd_t
*rd
= &lp
->rda
[lp
->cur_rx
& SONIC_RDS_MASK
];
293 while (rd
->in_use
== 0) {
296 unsigned char *pkt_ptr
;
298 status
= rd
->rx_status
;
300 printk("status %x, cur_rx %d, cur_rra %x\n",
301 status
, lp
->cur_rx
, lp
->cur_rra
);
302 if (status
& SONIC_RCR_PRX
) {
303 pkt_len
= rd
->rx_pktlen
;
306 sonic_chiptomem((rd
->rx_pktptr_h
<< 16) +
311 ("pktptr %p (rba %p) h:%x l:%x, bsize h:%x l:%x\n",
312 pkt_ptr
, lp
->rba
, rd
->rx_pktptr_h
,
314 SONIC_READ(SONIC_RBWC1
),
315 SONIC_READ(SONIC_RBWC0
));
317 /* Malloc up new buffer. */
318 skb
= dev_alloc_skb(pkt_len
+ 2);
321 ("%s: Memory squeeze, dropping packet.\n",
323 lp
->stats
.rx_dropped
++;
327 skb_reserve(skb
, 2); /* 16 byte align */
328 skb_put(skb
, pkt_len
); /* Make room */
329 eth_copy_and_sum(skb
, pkt_ptr
, pkt_len
, 0);
330 skb
->protocol
= eth_type_trans(skb
, dev
);
331 netif_rx(skb
); /* pass the packet to upper layers */
332 dev
->last_rx
= jiffies
;
333 lp
->stats
.rx_packets
++;
334 lp
->stats
.rx_bytes
+= pkt_len
;
337 /* This should only happen, if we enable accepting broken packets. */
338 lp
->stats
.rx_errors
++;
339 if (status
& SONIC_RCR_FAER
)
340 lp
->stats
.rx_frame_errors
++;
341 if (status
& SONIC_RCR_CRCR
)
342 lp
->stats
.rx_crc_errors
++;
346 rd
= &lp
->rda
[(++lp
->cur_rx
) & SONIC_RDS_MASK
];
347 /* now give back the buffer to the receive buffer area */
348 if (status
& SONIC_RCR_LPKT
) {
350 * this was the last packet out of the current receice buffer
351 * give the buffer back to the SONIC
353 lp
->cur_rra
+= sizeof(sonic_rr_t
);
357 1) * sizeof(sonic_rr_t
))) lp
->cur_rra
=
359 SONIC_WRITE(SONIC_RWP
, lp
->cur_rra
& 0xffff);
362 ("%s: rx desc without RCR_LPKT. Shouldn't happen !?\n",
366 * If any worth-while packets have been received, dev_rint()
367 * has done a mark_bh(NET_BH) for us and will work on them
368 * when we get to the bottom-half routine.
374 * Get the current statistics.
375 * This may be called with the device open or closed.
377 static struct net_device_stats
*sonic_get_stats(struct net_device
*dev
)
379 struct sonic_local
*lp
= (struct sonic_local
*) dev
->priv
;
380 unsigned int base_addr
= dev
->base_addr
;
382 /* read the tally counter from the SONIC and reset them */
383 lp
->stats
.rx_crc_errors
+= SONIC_READ(SONIC_CRCT
);
384 SONIC_WRITE(SONIC_CRCT
, 0xffff);
385 lp
->stats
.rx_frame_errors
+= SONIC_READ(SONIC_FAET
);
386 SONIC_WRITE(SONIC_FAET
, 0xffff);
387 lp
->stats
.rx_missed_errors
+= SONIC_READ(SONIC_MPT
);
388 SONIC_WRITE(SONIC_MPT
, 0xffff);
395 * Set or clear the multicast filter for this adaptor.
397 static void sonic_multicast_list(struct net_device
*dev
)
399 struct sonic_local
*lp
= (struct sonic_local
*) dev
->priv
;
400 unsigned int base_addr
= dev
->base_addr
;
402 struct dev_mc_list
*dmi
= dev
->mc_list
;
406 rcr
= SONIC_READ(SONIC_RCR
) & ~(SONIC_RCR_PRO
| SONIC_RCR_AMC
);
407 rcr
|= SONIC_RCR_BRD
; /* accept broadcast packets */
409 if (dev
->flags
& IFF_PROMISC
) { /* set promiscuous mode */
410 rcr
|= SONIC_RCR_PRO
;
412 if ((dev
->flags
& IFF_ALLMULTI
) || (dev
->mc_count
> 15)) {
413 rcr
|= SONIC_RCR_AMC
;
417 ("sonic_multicast_list: mc_count %d\n",
419 lp
->cda
.cam_enable
= 1; /* always enable our own address */
420 for (i
= 1; i
<= dev
->mc_count
; i
++) {
421 addr
= dmi
->dmi_addr
;
423 lp
->cda
.cam_desc
[i
].cam_cap0
=
424 addr
[1] << 8 | addr
[0];
425 lp
->cda
.cam_desc
[i
].cam_cap1
=
426 addr
[3] << 8 | addr
[2];
427 lp
->cda
.cam_desc
[i
].cam_cap2
=
428 addr
[5] << 8 | addr
[4];
429 lp
->cda
.cam_enable
|= (1 << i
);
431 SONIC_WRITE(SONIC_CDC
, 16);
432 /* issue Load CAM command */
433 SONIC_WRITE(SONIC_CDP
, lp
->cda_laddr
& 0xffff);
434 SONIC_WRITE(SONIC_CMD
, SONIC_CR_LCAM
);
439 printk("sonic_multicast_list: setting RCR=%x\n", rcr
);
441 SONIC_WRITE(SONIC_RCR
, rcr
);
446 * Initialize the SONIC ethernet controller.
448 static int sonic_init(struct net_device
*dev
)
450 unsigned int base_addr
= dev
->base_addr
;
452 struct sonic_local
*lp
= (struct sonic_local
*) dev
->priv
;
453 unsigned int rra_start
;
454 unsigned int rra_end
;
458 * put the Sonic into software-reset mode and
459 * disable all interrupts
461 SONIC_WRITE(SONIC_ISR
, 0x7fff);
462 SONIC_WRITE(SONIC_IMR
, 0);
463 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
466 * clear software reset flag, disable receiver, clear and
467 * enable interrupts, then completely initialize the SONIC
469 SONIC_WRITE(SONIC_CMD
, 0);
470 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RXDIS
);
473 * initialize the receive resource area
476 printk("sonic_init: initialize receive resource area\n");
478 rra_start
= lp
->rra_laddr
& 0xffff;
480 (rra_start
+ (SONIC_NUM_RRS
* sizeof(sonic_rr_t
))) & 0xffff;
482 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
483 lp
->rra
[i
].rx_bufadr_l
=
484 (lp
->rba_laddr
+ i
* SONIC_RBSIZE
) & 0xffff;
485 lp
->rra
[i
].rx_bufadr_h
=
486 (lp
->rba_laddr
+ i
* SONIC_RBSIZE
) >> 16;
487 lp
->rra
[i
].rx_bufsize_l
= SONIC_RBSIZE
>> 1;
488 lp
->rra
[i
].rx_bufsize_h
= 0;
491 /* initialize all RRA registers */
492 SONIC_WRITE(SONIC_RSA
, rra_start
);
493 SONIC_WRITE(SONIC_REA
, rra_end
);
494 SONIC_WRITE(SONIC_RRP
, rra_start
);
495 SONIC_WRITE(SONIC_RWP
, rra_end
);
496 SONIC_WRITE(SONIC_URRA
, lp
->rra_laddr
>> 16);
497 SONIC_WRITE(SONIC_EOBC
, (SONIC_RBSIZE
- 2) >> 1);
500 lp
->rra_laddr
+ (SONIC_NUM_RRS
- 1) * sizeof(sonic_rr_t
);
502 /* load the resource pointers */
504 printk("sonic_init: issueing RRRA command\n");
506 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RRRA
);
509 if (SONIC_READ(SONIC_CMD
) & SONIC_CR_RRRA
)
514 printk("sonic_init: status=%x\n", SONIC_READ(SONIC_CMD
));
517 * Initialize the receive descriptors so that they
518 * become a circular linked list, ie. let the last
519 * descriptor point to the first again.
522 printk("sonic_init: initialize receive descriptors\n");
523 for (i
= 0; i
< SONIC_NUM_RDS
; i
++) {
524 lp
->rda
[i
].rx_status
= 0;
525 lp
->rda
[i
].rx_pktlen
= 0;
526 lp
->rda
[i
].rx_pktptr_l
= 0;
527 lp
->rda
[i
].rx_pktptr_h
= 0;
528 lp
->rda
[i
].rx_seqno
= 0;
529 lp
->rda
[i
].in_use
= 1;
531 lp
->rda_laddr
+ (i
+ 1) * sizeof(sonic_rd_t
);
533 /* fix last descriptor */
534 lp
->rda
[SONIC_NUM_RDS
- 1].link
= lp
->rda_laddr
;
536 SONIC_WRITE(SONIC_URDA
, lp
->rda_laddr
>> 16);
537 SONIC_WRITE(SONIC_CRDA
, lp
->rda_laddr
& 0xffff);
540 * initialize transmit descriptors
543 printk("sonic_init: initialize transmit descriptors\n");
544 for (i
= 0; i
< SONIC_NUM_TDS
; i
++) {
545 lp
->tda
[i
].tx_status
= 0;
546 lp
->tda
[i
].tx_config
= 0;
547 lp
->tda
[i
].tx_pktsize
= 0;
548 lp
->tda
[i
].tx_frag_count
= 0;
551 (i
+ 1) * sizeof(sonic_td_t
)) | SONIC_END_OF_LINKS
;
553 lp
->tda
[SONIC_NUM_TDS
- 1].link
=
554 (lp
->tda_laddr
& 0xffff) | SONIC_END_OF_LINKS
;
556 SONIC_WRITE(SONIC_UTDA
, lp
->tda_laddr
>> 16);
557 SONIC_WRITE(SONIC_CTDA
, lp
->tda_laddr
& 0xffff);
558 lp
->cur_tx
= lp
->dirty_tx
= 0;
561 * put our own address to CAM desc[0]
563 lp
->cda
.cam_desc
[0].cam_cap0
=
564 dev
->dev_addr
[1] << 8 | dev
->dev_addr
[0];
565 lp
->cda
.cam_desc
[0].cam_cap1
=
566 dev
->dev_addr
[3] << 8 | dev
->dev_addr
[2];
567 lp
->cda
.cam_desc
[0].cam_cap2
=
568 dev
->dev_addr
[5] << 8 | dev
->dev_addr
[4];
569 lp
->cda
.cam_enable
= 1;
571 for (i
= 0; i
< 16; i
++)
572 lp
->cda
.cam_desc
[i
].cam_entry_pointer
= i
;
575 * initialize CAM registers
577 SONIC_WRITE(SONIC_CDP
, lp
->cda_laddr
& 0xffff);
578 SONIC_WRITE(SONIC_CDC
, 16);
583 SONIC_WRITE(SONIC_CMD
, SONIC_CR_LCAM
);
587 if (SONIC_READ(SONIC_ISR
) & SONIC_INT_LCD
)
590 if (sonic_debug
> 2) {
591 printk("sonic_init: CMD=%x, ISR=%x\n",
592 SONIC_READ(SONIC_CMD
), SONIC_READ(SONIC_ISR
));
596 * enable receiver, disable loopback
597 * and enable all interrupts
599 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RXEN
| SONIC_CR_STP
);
600 SONIC_WRITE(SONIC_RCR
, SONIC_RCR_DEFAULT
);
601 SONIC_WRITE(SONIC_TCR
, SONIC_TCR_DEFAULT
);
602 SONIC_WRITE(SONIC_ISR
, 0x7fff);
603 SONIC_WRITE(SONIC_IMR
, SONIC_IMR_DEFAULT
);
605 cmd
= SONIC_READ(SONIC_CMD
);
606 if ((cmd
& SONIC_CR_RXEN
) == 0 || (cmd
& SONIC_CR_STP
) == 0)
607 printk("sonic_init: failed, status=%x\n", cmd
);
610 printk("sonic_init: new status=%x\n",
611 SONIC_READ(SONIC_CMD
));
616 MODULE_LICENSE("GPL");