6 * Converted to DMA API, added zero-copy buffer handling, and
7 * (from the mac68k project) introduced dhd's support for 16-bit cards.
9 * (C) 1996,1998 by Thomas Bogendoerfer (tsbogend@alpha.franken.de)
11 * This driver is based on work from Andreas Busse, but most of
12 * the code is rewritten.
14 * (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
16 * Core code included by system sonic drivers
18 * And... partially rewritten again by David Huggins-Daines in order
19 * to cope with screwed up Macintosh NICs that may or may not use
22 * (C) 1999 David Huggins-Daines <dhd@debian.org>
27 * Sources: Olivetti M700-10 Risc Personal Computer hardware handbook,
28 * National Semiconductors data sheet for the DP83932B Sonic Ethernet
29 * controller, and the files "8390.c" and "skeleton.c" in this directory.
31 * Additional sources: Nat Semi data sheet for the DP83932C and Nat Semi
32 * Application Note AN-746, the files "lance.c" and "ibmlana.c". See also
33 * the NetBSD file "sys/arch/mac68k/dev/if_sn.c".
39 * Open/initialize the SONIC controller.
41 * This routine should set everything up anew at each open, even
42 * registers that "should" only need to be set once at boot, so that
43 * there is non-reboot way to recover if something goes wrong.
45 static int sonic_open(struct net_device
*dev
)
47 struct sonic_local
*lp
= netdev_priv(dev
);
51 printk("sonic_open: initializing sonic driver.\n");
54 * We don't need to deal with auto-irq stuff since we
55 * hardwire the sonic interrupt.
58 * XXX Horrible work around: We install sonic_interrupt as fast interrupt.
59 * This means that during execution of the handler interrupt are disabled
60 * covering another bug otherwise corrupting data. This doesn't mean
61 * this glue works ok under all situations.
63 * Note (dhd): this also appears to prevent lockups on the Macintrash
64 * when more than one Ethernet card is installed (knock on wood)
66 * Note (fthain): whether the above is still true is anyones guess. Certainly
67 * the buffer handling algorithms will not tolerate re-entrance without some
68 * mutual exclusion added. Anyway, the memcpy has now been eliminated from the
69 * rx code to make this a faster "fast interrupt".
71 if (request_irq(dev
->irq
, &sonic_interrupt
, SONIC_IRQ_FLAG
, "sonic", dev
)) {
72 printk(KERN_ERR
"\n%s: unable to get IRQ %d .\n", dev
->name
, dev
->irq
);
76 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
77 struct sk_buff
*skb
= dev_alloc_skb(SONIC_RBSIZE
+ 2);
79 while(i
> 0) { /* free any that were allocated successfully */
81 dev_kfree_skb(lp
->rx_skb
[i
]);
84 printk(KERN_ERR
"%s: couldn't allocate receive buffers\n",
88 /* align IP header unless DMA requires otherwise */
89 if (SONIC_BUS_SCALE(lp
->dma_bitmode
) == 2)
94 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
95 dma_addr_t laddr
= dma_map_single(lp
->device
, skb_put(lp
->rx_skb
[i
], SONIC_RBSIZE
),
96 SONIC_RBSIZE
, DMA_FROM_DEVICE
);
98 while(i
> 0) { /* free any that were mapped successfully */
100 dma_unmap_single(lp
->device
, lp
->rx_laddr
[i
], SONIC_RBSIZE
, DMA_FROM_DEVICE
);
101 lp
->rx_laddr
[i
] = (dma_addr_t
)0;
103 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
104 dev_kfree_skb(lp
->rx_skb
[i
]);
105 lp
->rx_skb
[i
] = NULL
;
107 printk(KERN_ERR
"%s: couldn't map rx DMA buffers\n",
111 lp
->rx_laddr
[i
] = laddr
;
115 * Initialize the SONIC
119 netif_start_queue(dev
);
122 printk("sonic_open: Initialization done.\n");
129 * Close the SONIC device
131 static int sonic_close(struct net_device
*dev
)
133 struct sonic_local
*lp
= netdev_priv(dev
);
137 printk("sonic_close\n");
139 netif_stop_queue(dev
);
142 * stop the SONIC, disable interrupts
144 SONIC_WRITE(SONIC_IMR
, 0);
145 SONIC_WRITE(SONIC_ISR
, 0x7fff);
146 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
148 /* unmap and free skbs that haven't been transmitted */
149 for (i
= 0; i
< SONIC_NUM_TDS
; i
++) {
150 if(lp
->tx_laddr
[i
]) {
151 dma_unmap_single(lp
->device
, lp
->tx_laddr
[i
], lp
->tx_len
[i
], DMA_TO_DEVICE
);
152 lp
->tx_laddr
[i
] = (dma_addr_t
)0;
155 dev_kfree_skb(lp
->tx_skb
[i
]);
156 lp
->tx_skb
[i
] = NULL
;
160 /* unmap and free the receive buffers */
161 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
162 if(lp
->rx_laddr
[i
]) {
163 dma_unmap_single(lp
->device
, lp
->rx_laddr
[i
], SONIC_RBSIZE
, DMA_FROM_DEVICE
);
164 lp
->rx_laddr
[i
] = (dma_addr_t
)0;
167 dev_kfree_skb(lp
->rx_skb
[i
]);
168 lp
->rx_skb
[i
] = NULL
;
172 free_irq(dev
->irq
, dev
); /* release the IRQ */
177 static void sonic_tx_timeout(struct net_device
*dev
)
179 struct sonic_local
*lp
= netdev_priv(dev
);
181 /* Stop the interrupts for this */
182 SONIC_WRITE(SONIC_IMR
, 0);
183 /* We could resend the original skbs. Easier to re-initialise. */
184 for (i
= 0; i
< SONIC_NUM_TDS
; i
++) {
185 if(lp
->tx_laddr
[i
]) {
186 dma_unmap_single(lp
->device
, lp
->tx_laddr
[i
], lp
->tx_len
[i
], DMA_TO_DEVICE
);
187 lp
->tx_laddr
[i
] = (dma_addr_t
)0;
190 dev_kfree_skb(lp
->tx_skb
[i
]);
191 lp
->tx_skb
[i
] = NULL
;
194 /* Try to restart the adaptor. */
196 lp
->stats
.tx_errors
++;
197 dev
->trans_start
= jiffies
;
198 netif_wake_queue(dev
);
204 * Appends new TD during transmission thus avoiding any TX interrupts
205 * until we run out of TDs.
206 * This routine interacts closely with the ISR in that it may,
208 * reset the status flags of the new TD
209 * set and reset EOL flags
211 * The ISR interacts with this routine in various ways. It may,
213 * test the EOL and status flags of the TDs
215 * Concurrently with all of this, the SONIC is potentially writing to
216 * the status flags of the TDs.
217 * Until some mutual exclusion is added, this code will not work with SMP. However,
218 * MIPS Jazz machines and m68k Macs were all uni-processor machines.
221 static int sonic_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
223 struct sonic_local
*lp
= netdev_priv(dev
);
226 int entry
= lp
->next_tx
;
229 printk("sonic_send_packet: skb=%p, dev=%p\n", skb
, dev
);
232 if (length
< ETH_ZLEN
) {
233 if (skb_padto(skb
, ETH_ZLEN
))
239 * Map the packet data into the logical DMA address space
242 laddr
= dma_map_single(lp
->device
, skb
->data
, length
, DMA_TO_DEVICE
);
244 printk(KERN_ERR
"%s: failed to map tx DMA buffer.\n", dev
->name
);
249 sonic_tda_put(dev
, entry
, SONIC_TD_STATUS
, 0); /* clear status */
250 sonic_tda_put(dev
, entry
, SONIC_TD_FRAG_COUNT
, 1); /* single fragment */
251 sonic_tda_put(dev
, entry
, SONIC_TD_PKTSIZE
, length
); /* length of packet */
252 sonic_tda_put(dev
, entry
, SONIC_TD_FRAG_PTR_L
, laddr
& 0xffff);
253 sonic_tda_put(dev
, entry
, SONIC_TD_FRAG_PTR_H
, laddr
>> 16);
254 sonic_tda_put(dev
, entry
, SONIC_TD_FRAG_SIZE
, length
);
255 sonic_tda_put(dev
, entry
, SONIC_TD_LINK
,
256 sonic_tda_get(dev
, entry
, SONIC_TD_LINK
) | SONIC_EOL
);
259 * Must set tx_skb[entry] only after clearing status, and
260 * before clearing EOL and before stopping queue
263 lp
->tx_len
[entry
] = length
;
264 lp
->tx_laddr
[entry
] = laddr
;
265 lp
->tx_skb
[entry
] = skb
;
268 sonic_tda_put(dev
, lp
->eol_tx
, SONIC_TD_LINK
,
269 sonic_tda_get(dev
, lp
->eol_tx
, SONIC_TD_LINK
) & ~SONIC_EOL
);
272 lp
->next_tx
= (entry
+ 1) & SONIC_TDS_MASK
;
273 if (lp
->tx_skb
[lp
->next_tx
] != NULL
) {
274 /* The ring is full, the ISR has yet to process the next TD. */
276 printk("%s: stopping queue\n", dev
->name
);
277 netif_stop_queue(dev
);
278 /* after this packet, wait for ISR to free up some TDAs */
279 } else netif_start_queue(dev
);
282 printk("sonic_send_packet: issuing Tx command\n");
284 SONIC_WRITE(SONIC_CMD
, SONIC_CR_TXP
);
286 dev
->trans_start
= jiffies
;
292 * The typical workload of the driver:
293 * Handle the network interface interrupts.
295 static irqreturn_t
sonic_interrupt(int irq
, void *dev_id
)
297 struct net_device
*dev
= dev_id
;
298 struct sonic_local
*lp
= netdev_priv(dev
);
301 if (!(status
= SONIC_READ(SONIC_ISR
) & SONIC_IMR_DEFAULT
))
305 if (status
& SONIC_INT_PKTRX
) {
307 printk("%s: packet rx\n", dev
->name
);
308 sonic_rx(dev
); /* got packet(s) */
309 SONIC_WRITE(SONIC_ISR
, SONIC_INT_PKTRX
); /* clear the interrupt */
312 if (status
& SONIC_INT_TXDN
) {
313 int entry
= lp
->cur_tx
;
317 /* At this point, cur_tx is the index of a TD that is one of:
318 * unallocated/freed (status set & tx_skb[entry] clear)
319 * allocated and sent (status set & tx_skb[entry] set )
320 * allocated and not yet sent (status clear & tx_skb[entry] set )
321 * still being allocated by sonic_send_packet (status clear & tx_skb[entry] clear)
325 printk("%s: tx done\n", dev
->name
);
327 while (lp
->tx_skb
[entry
] != NULL
) {
328 if ((td_status
= sonic_tda_get(dev
, entry
, SONIC_TD_STATUS
)) == 0)
331 if (td_status
& 0x0001) {
332 lp
->stats
.tx_packets
++;
333 lp
->stats
.tx_bytes
+= sonic_tda_get(dev
, entry
, SONIC_TD_PKTSIZE
);
335 lp
->stats
.tx_errors
++;
336 if (td_status
& 0x0642)
337 lp
->stats
.tx_aborted_errors
++;
338 if (td_status
& 0x0180)
339 lp
->stats
.tx_carrier_errors
++;
340 if (td_status
& 0x0020)
341 lp
->stats
.tx_window_errors
++;
342 if (td_status
& 0x0004)
343 lp
->stats
.tx_fifo_errors
++;
346 /* We must free the original skb */
347 dev_kfree_skb_irq(lp
->tx_skb
[entry
]);
348 lp
->tx_skb
[entry
] = NULL
;
349 /* and unmap DMA buffer */
350 dma_unmap_single(lp
->device
, lp
->tx_laddr
[entry
], lp
->tx_len
[entry
], DMA_TO_DEVICE
);
351 lp
->tx_laddr
[entry
] = (dma_addr_t
)0;
354 if (sonic_tda_get(dev
, entry
, SONIC_TD_LINK
) & SONIC_EOL
) {
355 entry
= (entry
+ 1) & SONIC_TDS_MASK
;
358 entry
= (entry
+ 1) & SONIC_TDS_MASK
;
361 if (freed_some
|| lp
->tx_skb
[entry
] == NULL
)
362 netif_wake_queue(dev
); /* The ring is no longer full */
364 SONIC_WRITE(SONIC_ISR
, SONIC_INT_TXDN
); /* clear the interrupt */
368 * check error conditions
370 if (status
& SONIC_INT_RFO
) {
372 printk("%s: rx fifo overrun\n", dev
->name
);
373 lp
->stats
.rx_fifo_errors
++;
374 SONIC_WRITE(SONIC_ISR
, SONIC_INT_RFO
); /* clear the interrupt */
376 if (status
& SONIC_INT_RDE
) {
378 printk("%s: rx descriptors exhausted\n", dev
->name
);
379 lp
->stats
.rx_dropped
++;
380 SONIC_WRITE(SONIC_ISR
, SONIC_INT_RDE
); /* clear the interrupt */
382 if (status
& SONIC_INT_RBAE
) {
384 printk("%s: rx buffer area exceeded\n", dev
->name
);
385 lp
->stats
.rx_dropped
++;
386 SONIC_WRITE(SONIC_ISR
, SONIC_INT_RBAE
); /* clear the interrupt */
389 /* counter overruns; all counters are 16bit wide */
390 if (status
& SONIC_INT_FAE
) {
391 lp
->stats
.rx_frame_errors
+= 65536;
392 SONIC_WRITE(SONIC_ISR
, SONIC_INT_FAE
); /* clear the interrupt */
394 if (status
& SONIC_INT_CRC
) {
395 lp
->stats
.rx_crc_errors
+= 65536;
396 SONIC_WRITE(SONIC_ISR
, SONIC_INT_CRC
); /* clear the interrupt */
398 if (status
& SONIC_INT_MP
) {
399 lp
->stats
.rx_missed_errors
+= 65536;
400 SONIC_WRITE(SONIC_ISR
, SONIC_INT_MP
); /* clear the interrupt */
404 if (status
& SONIC_INT_TXER
) {
405 if ((SONIC_READ(SONIC_TCR
) & SONIC_TCR_FU
) && (sonic_debug
> 2))
406 printk(KERN_ERR
"%s: tx fifo underrun\n", dev
->name
);
407 SONIC_WRITE(SONIC_ISR
, SONIC_INT_TXER
); /* clear the interrupt */
411 if (status
& SONIC_INT_BR
) {
412 printk(KERN_ERR
"%s: Bus retry occurred! Device interrupt disabled.\n",
414 /* ... to help debug DMA problems causing endless interrupts. */
415 /* Bounce the eth interface to turn on the interrupt again. */
416 SONIC_WRITE(SONIC_IMR
, 0);
417 SONIC_WRITE(SONIC_ISR
, SONIC_INT_BR
); /* clear the interrupt */
421 if (status
& SONIC_INT_LCD
)
422 SONIC_WRITE(SONIC_ISR
, SONIC_INT_LCD
); /* clear the interrupt */
423 } while((status
= SONIC_READ(SONIC_ISR
) & SONIC_IMR_DEFAULT
));
428 * We have a good packet(s), pass it/them up the network stack.
430 static void sonic_rx(struct net_device
*dev
)
432 struct sonic_local
*lp
= netdev_priv(dev
);
434 int entry
= lp
->cur_rx
;
436 while (sonic_rda_get(dev
, entry
, SONIC_RD_IN_USE
) == 0) {
437 struct sk_buff
*used_skb
;
438 struct sk_buff
*new_skb
;
439 dma_addr_t new_laddr
;
444 status
= sonic_rda_get(dev
, entry
, SONIC_RD_STATUS
);
445 if (status
& SONIC_RCR_PRX
) {
446 /* Malloc up new buffer. */
447 new_skb
= dev_alloc_skb(SONIC_RBSIZE
+ 2);
448 if (new_skb
== NULL
) {
449 printk(KERN_ERR
"%s: Memory squeeze, dropping packet.\n", dev
->name
);
450 lp
->stats
.rx_dropped
++;
453 /* provide 16 byte IP header alignment unless DMA requires otherwise */
454 if(SONIC_BUS_SCALE(lp
->dma_bitmode
) == 2)
455 skb_reserve(new_skb
, 2);
457 new_laddr
= dma_map_single(lp
->device
, skb_put(new_skb
, SONIC_RBSIZE
),
458 SONIC_RBSIZE
, DMA_FROM_DEVICE
);
460 dev_kfree_skb(new_skb
);
461 printk(KERN_ERR
"%s: Failed to map rx buffer, dropping packet.\n", dev
->name
);
462 lp
->stats
.rx_dropped
++;
466 /* now we have a new skb to replace it, pass the used one up the stack */
467 dma_unmap_single(lp
->device
, lp
->rx_laddr
[entry
], SONIC_RBSIZE
, DMA_FROM_DEVICE
);
468 used_skb
= lp
->rx_skb
[entry
];
469 pkt_len
= sonic_rda_get(dev
, entry
, SONIC_RD_PKTLEN
);
470 skb_trim(used_skb
, pkt_len
);
471 used_skb
->protocol
= eth_type_trans(used_skb
, dev
);
473 dev
->last_rx
= jiffies
;
474 lp
->stats
.rx_packets
++;
475 lp
->stats
.rx_bytes
+= pkt_len
;
477 /* and insert the new skb */
478 lp
->rx_laddr
[entry
] = new_laddr
;
479 lp
->rx_skb
[entry
] = new_skb
;
481 bufadr_l
= (unsigned long)new_laddr
& 0xffff;
482 bufadr_h
= (unsigned long)new_laddr
>> 16;
483 sonic_rra_put(dev
, entry
, SONIC_RR_BUFADR_L
, bufadr_l
);
484 sonic_rra_put(dev
, entry
, SONIC_RR_BUFADR_H
, bufadr_h
);
486 /* This should only happen, if we enable accepting broken packets. */
487 lp
->stats
.rx_errors
++;
488 if (status
& SONIC_RCR_FAER
)
489 lp
->stats
.rx_frame_errors
++;
490 if (status
& SONIC_RCR_CRCR
)
491 lp
->stats
.rx_crc_errors
++;
493 if (status
& SONIC_RCR_LPKT
) {
495 * this was the last packet out of the current receive buffer
496 * give the buffer back to the SONIC
498 lp
->cur_rwp
+= SIZEOF_SONIC_RR
* SONIC_BUS_SCALE(lp
->dma_bitmode
);
499 if (lp
->cur_rwp
>= lp
->rra_end
) lp
->cur_rwp
= lp
->rra_laddr
& 0xffff;
500 SONIC_WRITE(SONIC_RWP
, lp
->cur_rwp
);
501 if (SONIC_READ(SONIC_ISR
) & SONIC_INT_RBE
) {
503 printk("%s: rx buffer exhausted\n", dev
->name
);
504 SONIC_WRITE(SONIC_ISR
, SONIC_INT_RBE
); /* clear the flag */
507 printk(KERN_ERR
"%s: rx desc without RCR_LPKT. Shouldn't happen !?\n",
510 * give back the descriptor
512 sonic_rda_put(dev
, entry
, SONIC_RD_LINK
,
513 sonic_rda_get(dev
, entry
, SONIC_RD_LINK
) | SONIC_EOL
);
514 sonic_rda_put(dev
, entry
, SONIC_RD_IN_USE
, 1);
515 sonic_rda_put(dev
, lp
->eol_rx
, SONIC_RD_LINK
,
516 sonic_rda_get(dev
, lp
->eol_rx
, SONIC_RD_LINK
) & ~SONIC_EOL
);
518 lp
->cur_rx
= entry
= (entry
+ 1) & SONIC_RDS_MASK
;
521 * If any worth-while packets have been received, netif_rx()
522 * has done a mark_bh(NET_BH) for us and will work on them
523 * when we get to the bottom-half routine.
529 * Get the current statistics.
530 * This may be called with the device open or closed.
532 static struct net_device_stats
*sonic_get_stats(struct net_device
*dev
)
534 struct sonic_local
*lp
= netdev_priv(dev
);
536 /* read the tally counter from the SONIC and reset them */
537 lp
->stats
.rx_crc_errors
+= SONIC_READ(SONIC_CRCT
);
538 SONIC_WRITE(SONIC_CRCT
, 0xffff);
539 lp
->stats
.rx_frame_errors
+= SONIC_READ(SONIC_FAET
);
540 SONIC_WRITE(SONIC_FAET
, 0xffff);
541 lp
->stats
.rx_missed_errors
+= SONIC_READ(SONIC_MPT
);
542 SONIC_WRITE(SONIC_MPT
, 0xffff);
549 * Set or clear the multicast filter for this adaptor.
551 static void sonic_multicast_list(struct net_device
*dev
)
553 struct sonic_local
*lp
= netdev_priv(dev
);
555 struct dev_mc_list
*dmi
= dev
->mc_list
;
559 rcr
= SONIC_READ(SONIC_RCR
) & ~(SONIC_RCR_PRO
| SONIC_RCR_AMC
);
560 rcr
|= SONIC_RCR_BRD
; /* accept broadcast packets */
562 if (dev
->flags
& IFF_PROMISC
) { /* set promiscuous mode */
563 rcr
|= SONIC_RCR_PRO
;
565 if ((dev
->flags
& IFF_ALLMULTI
) || (dev
->mc_count
> 15)) {
566 rcr
|= SONIC_RCR_AMC
;
569 printk("sonic_multicast_list: mc_count %d\n", dev
->mc_count
);
570 sonic_set_cam_enable(dev
, 1); /* always enable our own address */
571 for (i
= 1; i
<= dev
->mc_count
; i
++) {
572 addr
= dmi
->dmi_addr
;
574 sonic_cda_put(dev
, i
, SONIC_CD_CAP0
, addr
[1] << 8 | addr
[0]);
575 sonic_cda_put(dev
, i
, SONIC_CD_CAP1
, addr
[3] << 8 | addr
[2]);
576 sonic_cda_put(dev
, i
, SONIC_CD_CAP2
, addr
[5] << 8 | addr
[4]);
577 sonic_set_cam_enable(dev
, sonic_get_cam_enable(dev
) | (1 << i
));
579 SONIC_WRITE(SONIC_CDC
, 16);
580 /* issue Load CAM command */
581 SONIC_WRITE(SONIC_CDP
, lp
->cda_laddr
& 0xffff);
582 SONIC_WRITE(SONIC_CMD
, SONIC_CR_LCAM
);
587 printk("sonic_multicast_list: setting RCR=%x\n", rcr
);
589 SONIC_WRITE(SONIC_RCR
, rcr
);
594 * Initialize the SONIC ethernet controller.
596 static int sonic_init(struct net_device
*dev
)
599 struct sonic_local
*lp
= netdev_priv(dev
);
603 * put the Sonic into software-reset mode and
604 * disable all interrupts
606 SONIC_WRITE(SONIC_IMR
, 0);
607 SONIC_WRITE(SONIC_ISR
, 0x7fff);
608 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
611 * clear software reset flag, disable receiver, clear and
612 * enable interrupts, then completely initialize the SONIC
614 SONIC_WRITE(SONIC_CMD
, 0);
615 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RXDIS
);
618 * initialize the receive resource area
621 printk("sonic_init: initialize receive resource area\n");
623 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
624 u16 bufadr_l
= (unsigned long)lp
->rx_laddr
[i
] & 0xffff;
625 u16 bufadr_h
= (unsigned long)lp
->rx_laddr
[i
] >> 16;
626 sonic_rra_put(dev
, i
, SONIC_RR_BUFADR_L
, bufadr_l
);
627 sonic_rra_put(dev
, i
, SONIC_RR_BUFADR_H
, bufadr_h
);
628 sonic_rra_put(dev
, i
, SONIC_RR_BUFSIZE_L
, SONIC_RBSIZE
>> 1);
629 sonic_rra_put(dev
, i
, SONIC_RR_BUFSIZE_H
, 0);
632 /* initialize all RRA registers */
633 lp
->rra_end
= (lp
->rra_laddr
+ SONIC_NUM_RRS
* SIZEOF_SONIC_RR
*
634 SONIC_BUS_SCALE(lp
->dma_bitmode
)) & 0xffff;
635 lp
->cur_rwp
= (lp
->rra_laddr
+ (SONIC_NUM_RRS
- 1) * SIZEOF_SONIC_RR
*
636 SONIC_BUS_SCALE(lp
->dma_bitmode
)) & 0xffff;
638 SONIC_WRITE(SONIC_RSA
, lp
->rra_laddr
& 0xffff);
639 SONIC_WRITE(SONIC_REA
, lp
->rra_end
);
640 SONIC_WRITE(SONIC_RRP
, lp
->rra_laddr
& 0xffff);
641 SONIC_WRITE(SONIC_RWP
, lp
->cur_rwp
);
642 SONIC_WRITE(SONIC_URRA
, lp
->rra_laddr
>> 16);
643 SONIC_WRITE(SONIC_EOBC
, (SONIC_RBSIZE
>> 1) - (lp
->dma_bitmode
? 2 : 1));
645 /* load the resource pointers */
647 printk("sonic_init: issuing RRRA command\n");
649 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RRRA
);
652 if (SONIC_READ(SONIC_CMD
) & SONIC_CR_RRRA
)
657 printk("sonic_init: status=%x i=%d\n", SONIC_READ(SONIC_CMD
), i
);
660 * Initialize the receive descriptors so that they
661 * become a circular linked list, ie. let the last
662 * descriptor point to the first again.
665 printk("sonic_init: initialize receive descriptors\n");
666 for (i
=0; i
<SONIC_NUM_RDS
; i
++) {
667 sonic_rda_put(dev
, i
, SONIC_RD_STATUS
, 0);
668 sonic_rda_put(dev
, i
, SONIC_RD_PKTLEN
, 0);
669 sonic_rda_put(dev
, i
, SONIC_RD_PKTPTR_L
, 0);
670 sonic_rda_put(dev
, i
, SONIC_RD_PKTPTR_H
, 0);
671 sonic_rda_put(dev
, i
, SONIC_RD_SEQNO
, 0);
672 sonic_rda_put(dev
, i
, SONIC_RD_IN_USE
, 1);
673 sonic_rda_put(dev
, i
, SONIC_RD_LINK
,
675 ((i
+1) * SIZEOF_SONIC_RD
* SONIC_BUS_SCALE(lp
->dma_bitmode
)));
677 /* fix last descriptor */
678 sonic_rda_put(dev
, SONIC_NUM_RDS
- 1, SONIC_RD_LINK
,
679 (lp
->rda_laddr
& 0xffff) | SONIC_EOL
);
680 lp
->eol_rx
= SONIC_NUM_RDS
- 1;
682 SONIC_WRITE(SONIC_URDA
, lp
->rda_laddr
>> 16);
683 SONIC_WRITE(SONIC_CRDA
, lp
->rda_laddr
& 0xffff);
686 * initialize transmit descriptors
689 printk("sonic_init: initialize transmit descriptors\n");
690 for (i
= 0; i
< SONIC_NUM_TDS
; i
++) {
691 sonic_tda_put(dev
, i
, SONIC_TD_STATUS
, 0);
692 sonic_tda_put(dev
, i
, SONIC_TD_CONFIG
, 0);
693 sonic_tda_put(dev
, i
, SONIC_TD_PKTSIZE
, 0);
694 sonic_tda_put(dev
, i
, SONIC_TD_FRAG_COUNT
, 0);
695 sonic_tda_put(dev
, i
, SONIC_TD_LINK
,
696 (lp
->tda_laddr
& 0xffff) +
697 (i
+ 1) * SIZEOF_SONIC_TD
* SONIC_BUS_SCALE(lp
->dma_bitmode
));
698 lp
->tx_skb
[i
] = NULL
;
700 /* fix last descriptor */
701 sonic_tda_put(dev
, SONIC_NUM_TDS
- 1, SONIC_TD_LINK
,
702 (lp
->tda_laddr
& 0xffff));
704 SONIC_WRITE(SONIC_UTDA
, lp
->tda_laddr
>> 16);
705 SONIC_WRITE(SONIC_CTDA
, lp
->tda_laddr
& 0xffff);
706 lp
->cur_tx
= lp
->next_tx
= 0;
707 lp
->eol_tx
= SONIC_NUM_TDS
- 1;
710 * put our own address to CAM desc[0]
712 sonic_cda_put(dev
, 0, SONIC_CD_CAP0
, dev
->dev_addr
[1] << 8 | dev
->dev_addr
[0]);
713 sonic_cda_put(dev
, 0, SONIC_CD_CAP1
, dev
->dev_addr
[3] << 8 | dev
->dev_addr
[2]);
714 sonic_cda_put(dev
, 0, SONIC_CD_CAP2
, dev
->dev_addr
[5] << 8 | dev
->dev_addr
[4]);
715 sonic_set_cam_enable(dev
, 1);
717 for (i
= 0; i
< 16; i
++)
718 sonic_cda_put(dev
, i
, SONIC_CD_ENTRY_POINTER
, i
);
721 * initialize CAM registers
723 SONIC_WRITE(SONIC_CDP
, lp
->cda_laddr
& 0xffff);
724 SONIC_WRITE(SONIC_CDC
, 16);
729 SONIC_WRITE(SONIC_CMD
, SONIC_CR_LCAM
);
733 if (SONIC_READ(SONIC_ISR
) & SONIC_INT_LCD
)
736 if (sonic_debug
> 2) {
737 printk("sonic_init: CMD=%x, ISR=%x\n, i=%d",
738 SONIC_READ(SONIC_CMD
), SONIC_READ(SONIC_ISR
), i
);
742 * enable receiver, disable loopback
743 * and enable all interrupts
745 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RXEN
| SONIC_CR_STP
);
746 SONIC_WRITE(SONIC_RCR
, SONIC_RCR_DEFAULT
);
747 SONIC_WRITE(SONIC_TCR
, SONIC_TCR_DEFAULT
);
748 SONIC_WRITE(SONIC_ISR
, 0x7fff);
749 SONIC_WRITE(SONIC_IMR
, SONIC_IMR_DEFAULT
);
751 cmd
= SONIC_READ(SONIC_CMD
);
752 if ((cmd
& SONIC_CR_RXEN
) == 0 || (cmd
& SONIC_CR_STP
) == 0)
753 printk(KERN_ERR
"sonic_init: failed, status=%x\n", cmd
);
756 printk("sonic_init: new status=%x\n",
757 SONIC_READ(SONIC_CMD
));
762 MODULE_LICENSE("GPL");