]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/net/sonic.c
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");
53 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
54 struct sk_buff
*skb
= dev_alloc_skb(SONIC_RBSIZE
+ 2);
56 while(i
> 0) { /* free any that were allocated successfully */
58 dev_kfree_skb(lp
->rx_skb
[i
]);
61 printk(KERN_ERR
"%s: couldn't allocate receive buffers\n",
65 /* align IP header unless DMA requires otherwise */
66 if (SONIC_BUS_SCALE(lp
->dma_bitmode
) == 2)
71 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
72 dma_addr_t laddr
= dma_map_single(lp
->device
, skb_put(lp
->rx_skb
[i
], SONIC_RBSIZE
),
73 SONIC_RBSIZE
, DMA_FROM_DEVICE
);
75 while(i
> 0) { /* free any that were mapped successfully */
77 dma_unmap_single(lp
->device
, lp
->rx_laddr
[i
], SONIC_RBSIZE
, DMA_FROM_DEVICE
);
78 lp
->rx_laddr
[i
] = (dma_addr_t
)0;
80 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
81 dev_kfree_skb(lp
->rx_skb
[i
]);
84 printk(KERN_ERR
"%s: couldn't map rx DMA buffers\n",
88 lp
->rx_laddr
[i
] = laddr
;
92 * Initialize the SONIC
96 netif_start_queue(dev
);
99 printk("sonic_open: Initialization done.\n");
106 * Close the SONIC device
108 static int sonic_close(struct net_device
*dev
)
110 struct sonic_local
*lp
= netdev_priv(dev
);
114 printk("sonic_close\n");
116 netif_stop_queue(dev
);
119 * stop the SONIC, disable interrupts
121 SONIC_WRITE(SONIC_IMR
, 0);
122 SONIC_WRITE(SONIC_ISR
, 0x7fff);
123 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
125 /* unmap and free skbs that haven't been transmitted */
126 for (i
= 0; i
< SONIC_NUM_TDS
; i
++) {
127 if(lp
->tx_laddr
[i
]) {
128 dma_unmap_single(lp
->device
, lp
->tx_laddr
[i
], lp
->tx_len
[i
], DMA_TO_DEVICE
);
129 lp
->tx_laddr
[i
] = (dma_addr_t
)0;
132 dev_kfree_skb(lp
->tx_skb
[i
]);
133 lp
->tx_skb
[i
] = NULL
;
137 /* unmap and free the receive buffers */
138 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
139 if(lp
->rx_laddr
[i
]) {
140 dma_unmap_single(lp
->device
, lp
->rx_laddr
[i
], SONIC_RBSIZE
, DMA_FROM_DEVICE
);
141 lp
->rx_laddr
[i
] = (dma_addr_t
)0;
144 dev_kfree_skb(lp
->rx_skb
[i
]);
145 lp
->rx_skb
[i
] = NULL
;
152 static void sonic_tx_timeout(struct net_device
*dev
)
154 struct sonic_local
*lp
= netdev_priv(dev
);
157 * put the Sonic into software-reset mode and
158 * disable all interrupts before releasing DMA buffers
160 SONIC_WRITE(SONIC_IMR
, 0);
161 SONIC_WRITE(SONIC_ISR
, 0x7fff);
162 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
163 /* We could resend the original skbs. Easier to re-initialise. */
164 for (i
= 0; i
< SONIC_NUM_TDS
; i
++) {
165 if(lp
->tx_laddr
[i
]) {
166 dma_unmap_single(lp
->device
, lp
->tx_laddr
[i
], lp
->tx_len
[i
], DMA_TO_DEVICE
);
167 lp
->tx_laddr
[i
] = (dma_addr_t
)0;
170 dev_kfree_skb(lp
->tx_skb
[i
]);
171 lp
->tx_skb
[i
] = NULL
;
174 /* Try to restart the adaptor. */
176 lp
->stats
.tx_errors
++;
177 dev
->trans_start
= jiffies
;
178 netif_wake_queue(dev
);
184 * Appends new TD during transmission thus avoiding any TX interrupts
185 * until we run out of TDs.
186 * This routine interacts closely with the ISR in that it may,
188 * reset the status flags of the new TD
189 * set and reset EOL flags
191 * The ISR interacts with this routine in various ways. It may,
193 * test the EOL and status flags of the TDs
195 * Concurrently with all of this, the SONIC is potentially writing to
196 * the status flags of the TDs.
197 * Until some mutual exclusion is added, this code will not work with SMP. However,
198 * MIPS Jazz machines and m68k Macs were all uni-processor machines.
201 static int sonic_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
203 struct sonic_local
*lp
= netdev_priv(dev
);
206 int entry
= lp
->next_tx
;
209 printk("sonic_send_packet: skb=%p, dev=%p\n", skb
, dev
);
212 if (length
< ETH_ZLEN
) {
213 if (skb_padto(skb
, ETH_ZLEN
))
219 * Map the packet data into the logical DMA address space
222 laddr
= dma_map_single(lp
->device
, skb
->data
, length
, DMA_TO_DEVICE
);
224 printk(KERN_ERR
"%s: failed to map tx DMA buffer.\n", dev
->name
);
229 sonic_tda_put(dev
, entry
, SONIC_TD_STATUS
, 0); /* clear status */
230 sonic_tda_put(dev
, entry
, SONIC_TD_FRAG_COUNT
, 1); /* single fragment */
231 sonic_tda_put(dev
, entry
, SONIC_TD_PKTSIZE
, length
); /* length of packet */
232 sonic_tda_put(dev
, entry
, SONIC_TD_FRAG_PTR_L
, laddr
& 0xffff);
233 sonic_tda_put(dev
, entry
, SONIC_TD_FRAG_PTR_H
, laddr
>> 16);
234 sonic_tda_put(dev
, entry
, SONIC_TD_FRAG_SIZE
, length
);
235 sonic_tda_put(dev
, entry
, SONIC_TD_LINK
,
236 sonic_tda_get(dev
, entry
, SONIC_TD_LINK
) | SONIC_EOL
);
239 * Must set tx_skb[entry] only after clearing status, and
240 * before clearing EOL and before stopping queue
243 lp
->tx_len
[entry
] = length
;
244 lp
->tx_laddr
[entry
] = laddr
;
245 lp
->tx_skb
[entry
] = skb
;
248 sonic_tda_put(dev
, lp
->eol_tx
, SONIC_TD_LINK
,
249 sonic_tda_get(dev
, lp
->eol_tx
, SONIC_TD_LINK
) & ~SONIC_EOL
);
252 lp
->next_tx
= (entry
+ 1) & SONIC_TDS_MASK
;
253 if (lp
->tx_skb
[lp
->next_tx
] != NULL
) {
254 /* The ring is full, the ISR has yet to process the next TD. */
256 printk("%s: stopping queue\n", dev
->name
);
257 netif_stop_queue(dev
);
258 /* after this packet, wait for ISR to free up some TDAs */
259 } else netif_start_queue(dev
);
262 printk("sonic_send_packet: issuing Tx command\n");
264 SONIC_WRITE(SONIC_CMD
, SONIC_CR_TXP
);
266 dev
->trans_start
= jiffies
;
272 * The typical workload of the driver:
273 * Handle the network interface interrupts.
275 static irqreturn_t
sonic_interrupt(int irq
, void *dev_id
)
277 struct net_device
*dev
= dev_id
;
278 struct sonic_local
*lp
= netdev_priv(dev
);
281 if (!(status
= SONIC_READ(SONIC_ISR
) & SONIC_IMR_DEFAULT
))
285 if (status
& SONIC_INT_PKTRX
) {
287 printk("%s: packet rx\n", dev
->name
);
288 sonic_rx(dev
); /* got packet(s) */
289 SONIC_WRITE(SONIC_ISR
, SONIC_INT_PKTRX
); /* clear the interrupt */
292 if (status
& SONIC_INT_TXDN
) {
293 int entry
= lp
->cur_tx
;
297 /* At this point, cur_tx is the index of a TD that is one of:
298 * unallocated/freed (status set & tx_skb[entry] clear)
299 * allocated and sent (status set & tx_skb[entry] set )
300 * allocated and not yet sent (status clear & tx_skb[entry] set )
301 * still being allocated by sonic_send_packet (status clear & tx_skb[entry] clear)
305 printk("%s: tx done\n", dev
->name
);
307 while (lp
->tx_skb
[entry
] != NULL
) {
308 if ((td_status
= sonic_tda_get(dev
, entry
, SONIC_TD_STATUS
)) == 0)
311 if (td_status
& 0x0001) {
312 lp
->stats
.tx_packets
++;
313 lp
->stats
.tx_bytes
+= sonic_tda_get(dev
, entry
, SONIC_TD_PKTSIZE
);
315 lp
->stats
.tx_errors
++;
316 if (td_status
& 0x0642)
317 lp
->stats
.tx_aborted_errors
++;
318 if (td_status
& 0x0180)
319 lp
->stats
.tx_carrier_errors
++;
320 if (td_status
& 0x0020)
321 lp
->stats
.tx_window_errors
++;
322 if (td_status
& 0x0004)
323 lp
->stats
.tx_fifo_errors
++;
326 /* We must free the original skb */
327 dev_kfree_skb_irq(lp
->tx_skb
[entry
]);
328 lp
->tx_skb
[entry
] = NULL
;
329 /* and unmap DMA buffer */
330 dma_unmap_single(lp
->device
, lp
->tx_laddr
[entry
], lp
->tx_len
[entry
], DMA_TO_DEVICE
);
331 lp
->tx_laddr
[entry
] = (dma_addr_t
)0;
334 if (sonic_tda_get(dev
, entry
, SONIC_TD_LINK
) & SONIC_EOL
) {
335 entry
= (entry
+ 1) & SONIC_TDS_MASK
;
338 entry
= (entry
+ 1) & SONIC_TDS_MASK
;
341 if (freed_some
|| lp
->tx_skb
[entry
] == NULL
)
342 netif_wake_queue(dev
); /* The ring is no longer full */
344 SONIC_WRITE(SONIC_ISR
, SONIC_INT_TXDN
); /* clear the interrupt */
348 * check error conditions
350 if (status
& SONIC_INT_RFO
) {
352 printk("%s: rx fifo overrun\n", dev
->name
);
353 lp
->stats
.rx_fifo_errors
++;
354 SONIC_WRITE(SONIC_ISR
, SONIC_INT_RFO
); /* clear the interrupt */
356 if (status
& SONIC_INT_RDE
) {
358 printk("%s: rx descriptors exhausted\n", dev
->name
);
359 lp
->stats
.rx_dropped
++;
360 SONIC_WRITE(SONIC_ISR
, SONIC_INT_RDE
); /* clear the interrupt */
362 if (status
& SONIC_INT_RBAE
) {
364 printk("%s: rx buffer area exceeded\n", dev
->name
);
365 lp
->stats
.rx_dropped
++;
366 SONIC_WRITE(SONIC_ISR
, SONIC_INT_RBAE
); /* clear the interrupt */
369 /* counter overruns; all counters are 16bit wide */
370 if (status
& SONIC_INT_FAE
) {
371 lp
->stats
.rx_frame_errors
+= 65536;
372 SONIC_WRITE(SONIC_ISR
, SONIC_INT_FAE
); /* clear the interrupt */
374 if (status
& SONIC_INT_CRC
) {
375 lp
->stats
.rx_crc_errors
+= 65536;
376 SONIC_WRITE(SONIC_ISR
, SONIC_INT_CRC
); /* clear the interrupt */
378 if (status
& SONIC_INT_MP
) {
379 lp
->stats
.rx_missed_errors
+= 65536;
380 SONIC_WRITE(SONIC_ISR
, SONIC_INT_MP
); /* clear the interrupt */
384 if (status
& SONIC_INT_TXER
) {
385 if ((SONIC_READ(SONIC_TCR
) & SONIC_TCR_FU
) && (sonic_debug
> 2))
386 printk(KERN_ERR
"%s: tx fifo underrun\n", dev
->name
);
387 SONIC_WRITE(SONIC_ISR
, SONIC_INT_TXER
); /* clear the interrupt */
391 if (status
& SONIC_INT_BR
) {
392 printk(KERN_ERR
"%s: Bus retry occurred! Device interrupt disabled.\n",
394 /* ... to help debug DMA problems causing endless interrupts. */
395 /* Bounce the eth interface to turn on the interrupt again. */
396 SONIC_WRITE(SONIC_IMR
, 0);
397 SONIC_WRITE(SONIC_ISR
, SONIC_INT_BR
); /* clear the interrupt */
401 if (status
& SONIC_INT_LCD
)
402 SONIC_WRITE(SONIC_ISR
, SONIC_INT_LCD
); /* clear the interrupt */
403 } while((status
= SONIC_READ(SONIC_ISR
) & SONIC_IMR_DEFAULT
));
408 * We have a good packet(s), pass it/them up the network stack.
410 static void sonic_rx(struct net_device
*dev
)
412 struct sonic_local
*lp
= netdev_priv(dev
);
414 int entry
= lp
->cur_rx
;
416 while (sonic_rda_get(dev
, entry
, SONIC_RD_IN_USE
) == 0) {
417 struct sk_buff
*used_skb
;
418 struct sk_buff
*new_skb
;
419 dma_addr_t new_laddr
;
424 status
= sonic_rda_get(dev
, entry
, SONIC_RD_STATUS
);
425 if (status
& SONIC_RCR_PRX
) {
426 /* Malloc up new buffer. */
427 new_skb
= dev_alloc_skb(SONIC_RBSIZE
+ 2);
428 if (new_skb
== NULL
) {
429 printk(KERN_ERR
"%s: Memory squeeze, dropping packet.\n", dev
->name
);
430 lp
->stats
.rx_dropped
++;
433 /* provide 16 byte IP header alignment unless DMA requires otherwise */
434 if(SONIC_BUS_SCALE(lp
->dma_bitmode
) == 2)
435 skb_reserve(new_skb
, 2);
437 new_laddr
= dma_map_single(lp
->device
, skb_put(new_skb
, SONIC_RBSIZE
),
438 SONIC_RBSIZE
, DMA_FROM_DEVICE
);
440 dev_kfree_skb(new_skb
);
441 printk(KERN_ERR
"%s: Failed to map rx buffer, dropping packet.\n", dev
->name
);
442 lp
->stats
.rx_dropped
++;
446 /* now we have a new skb to replace it, pass the used one up the stack */
447 dma_unmap_single(lp
->device
, lp
->rx_laddr
[entry
], SONIC_RBSIZE
, DMA_FROM_DEVICE
);
448 used_skb
= lp
->rx_skb
[entry
];
449 pkt_len
= sonic_rda_get(dev
, entry
, SONIC_RD_PKTLEN
);
450 skb_trim(used_skb
, pkt_len
);
451 used_skb
->protocol
= eth_type_trans(used_skb
, dev
);
453 lp
->stats
.rx_packets
++;
454 lp
->stats
.rx_bytes
+= pkt_len
;
456 /* and insert the new skb */
457 lp
->rx_laddr
[entry
] = new_laddr
;
458 lp
->rx_skb
[entry
] = new_skb
;
460 bufadr_l
= (unsigned long)new_laddr
& 0xffff;
461 bufadr_h
= (unsigned long)new_laddr
>> 16;
462 sonic_rra_put(dev
, entry
, SONIC_RR_BUFADR_L
, bufadr_l
);
463 sonic_rra_put(dev
, entry
, SONIC_RR_BUFADR_H
, bufadr_h
);
465 /* This should only happen, if we enable accepting broken packets. */
466 lp
->stats
.rx_errors
++;
467 if (status
& SONIC_RCR_FAER
)
468 lp
->stats
.rx_frame_errors
++;
469 if (status
& SONIC_RCR_CRCR
)
470 lp
->stats
.rx_crc_errors
++;
472 if (status
& SONIC_RCR_LPKT
) {
474 * this was the last packet out of the current receive buffer
475 * give the buffer back to the SONIC
477 lp
->cur_rwp
+= SIZEOF_SONIC_RR
* SONIC_BUS_SCALE(lp
->dma_bitmode
);
478 if (lp
->cur_rwp
>= lp
->rra_end
) lp
->cur_rwp
= lp
->rra_laddr
& 0xffff;
479 SONIC_WRITE(SONIC_RWP
, lp
->cur_rwp
);
480 if (SONIC_READ(SONIC_ISR
) & SONIC_INT_RBE
) {
482 printk("%s: rx buffer exhausted\n", dev
->name
);
483 SONIC_WRITE(SONIC_ISR
, SONIC_INT_RBE
); /* clear the flag */
486 printk(KERN_ERR
"%s: rx desc without RCR_LPKT. Shouldn't happen !?\n",
489 * give back the descriptor
491 sonic_rda_put(dev
, entry
, SONIC_RD_LINK
,
492 sonic_rda_get(dev
, entry
, SONIC_RD_LINK
) | SONIC_EOL
);
493 sonic_rda_put(dev
, entry
, SONIC_RD_IN_USE
, 1);
494 sonic_rda_put(dev
, lp
->eol_rx
, SONIC_RD_LINK
,
495 sonic_rda_get(dev
, lp
->eol_rx
, SONIC_RD_LINK
) & ~SONIC_EOL
);
497 lp
->cur_rx
= entry
= (entry
+ 1) & SONIC_RDS_MASK
;
500 * If any worth-while packets have been received, netif_rx()
501 * has done a mark_bh(NET_BH) for us and will work on them
502 * when we get to the bottom-half routine.
508 * Get the current statistics.
509 * This may be called with the device open or closed.
511 static struct net_device_stats
*sonic_get_stats(struct net_device
*dev
)
513 struct sonic_local
*lp
= netdev_priv(dev
);
515 /* read the tally counter from the SONIC and reset them */
516 lp
->stats
.rx_crc_errors
+= SONIC_READ(SONIC_CRCT
);
517 SONIC_WRITE(SONIC_CRCT
, 0xffff);
518 lp
->stats
.rx_frame_errors
+= SONIC_READ(SONIC_FAET
);
519 SONIC_WRITE(SONIC_FAET
, 0xffff);
520 lp
->stats
.rx_missed_errors
+= SONIC_READ(SONIC_MPT
);
521 SONIC_WRITE(SONIC_MPT
, 0xffff);
528 * Set or clear the multicast filter for this adaptor.
530 static void sonic_multicast_list(struct net_device
*dev
)
532 struct sonic_local
*lp
= netdev_priv(dev
);
534 struct dev_mc_list
*dmi
= dev
->mc_list
;
538 rcr
= SONIC_READ(SONIC_RCR
) & ~(SONIC_RCR_PRO
| SONIC_RCR_AMC
);
539 rcr
|= SONIC_RCR_BRD
; /* accept broadcast packets */
541 if (dev
->flags
& IFF_PROMISC
) { /* set promiscuous mode */
542 rcr
|= SONIC_RCR_PRO
;
544 if ((dev
->flags
& IFF_ALLMULTI
) || (dev
->mc_count
> 15)) {
545 rcr
|= SONIC_RCR_AMC
;
548 printk("sonic_multicast_list: mc_count %d\n", dev
->mc_count
);
549 sonic_set_cam_enable(dev
, 1); /* always enable our own address */
550 for (i
= 1; i
<= dev
->mc_count
; i
++) {
551 addr
= dmi
->dmi_addr
;
553 sonic_cda_put(dev
, i
, SONIC_CD_CAP0
, addr
[1] << 8 | addr
[0]);
554 sonic_cda_put(dev
, i
, SONIC_CD_CAP1
, addr
[3] << 8 | addr
[2]);
555 sonic_cda_put(dev
, i
, SONIC_CD_CAP2
, addr
[5] << 8 | addr
[4]);
556 sonic_set_cam_enable(dev
, sonic_get_cam_enable(dev
) | (1 << i
));
558 SONIC_WRITE(SONIC_CDC
, 16);
559 /* issue Load CAM command */
560 SONIC_WRITE(SONIC_CDP
, lp
->cda_laddr
& 0xffff);
561 SONIC_WRITE(SONIC_CMD
, SONIC_CR_LCAM
);
566 printk("sonic_multicast_list: setting RCR=%x\n", rcr
);
568 SONIC_WRITE(SONIC_RCR
, rcr
);
573 * Initialize the SONIC ethernet controller.
575 static int sonic_init(struct net_device
*dev
)
578 struct sonic_local
*lp
= netdev_priv(dev
);
582 * put the Sonic into software-reset mode and
583 * disable all interrupts
585 SONIC_WRITE(SONIC_IMR
, 0);
586 SONIC_WRITE(SONIC_ISR
, 0x7fff);
587 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RST
);
590 * clear software reset flag, disable receiver, clear and
591 * enable interrupts, then completely initialize the SONIC
593 SONIC_WRITE(SONIC_CMD
, 0);
594 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RXDIS
);
597 * initialize the receive resource area
600 printk("sonic_init: initialize receive resource area\n");
602 for (i
= 0; i
< SONIC_NUM_RRS
; i
++) {
603 u16 bufadr_l
= (unsigned long)lp
->rx_laddr
[i
] & 0xffff;
604 u16 bufadr_h
= (unsigned long)lp
->rx_laddr
[i
] >> 16;
605 sonic_rra_put(dev
, i
, SONIC_RR_BUFADR_L
, bufadr_l
);
606 sonic_rra_put(dev
, i
, SONIC_RR_BUFADR_H
, bufadr_h
);
607 sonic_rra_put(dev
, i
, SONIC_RR_BUFSIZE_L
, SONIC_RBSIZE
>> 1);
608 sonic_rra_put(dev
, i
, SONIC_RR_BUFSIZE_H
, 0);
611 /* initialize all RRA registers */
612 lp
->rra_end
= (lp
->rra_laddr
+ SONIC_NUM_RRS
* SIZEOF_SONIC_RR
*
613 SONIC_BUS_SCALE(lp
->dma_bitmode
)) & 0xffff;
614 lp
->cur_rwp
= (lp
->rra_laddr
+ (SONIC_NUM_RRS
- 1) * SIZEOF_SONIC_RR
*
615 SONIC_BUS_SCALE(lp
->dma_bitmode
)) & 0xffff;
617 SONIC_WRITE(SONIC_RSA
, lp
->rra_laddr
& 0xffff);
618 SONIC_WRITE(SONIC_REA
, lp
->rra_end
);
619 SONIC_WRITE(SONIC_RRP
, lp
->rra_laddr
& 0xffff);
620 SONIC_WRITE(SONIC_RWP
, lp
->cur_rwp
);
621 SONIC_WRITE(SONIC_URRA
, lp
->rra_laddr
>> 16);
622 SONIC_WRITE(SONIC_EOBC
, (SONIC_RBSIZE
>> 1) - (lp
->dma_bitmode
? 2 : 1));
624 /* load the resource pointers */
626 printk("sonic_init: issuing RRRA command\n");
628 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RRRA
);
631 if (SONIC_READ(SONIC_CMD
) & SONIC_CR_RRRA
)
636 printk("sonic_init: status=%x i=%d\n", SONIC_READ(SONIC_CMD
), i
);
639 * Initialize the receive descriptors so that they
640 * become a circular linked list, ie. let the last
641 * descriptor point to the first again.
644 printk("sonic_init: initialize receive descriptors\n");
645 for (i
=0; i
<SONIC_NUM_RDS
; i
++) {
646 sonic_rda_put(dev
, i
, SONIC_RD_STATUS
, 0);
647 sonic_rda_put(dev
, i
, SONIC_RD_PKTLEN
, 0);
648 sonic_rda_put(dev
, i
, SONIC_RD_PKTPTR_L
, 0);
649 sonic_rda_put(dev
, i
, SONIC_RD_PKTPTR_H
, 0);
650 sonic_rda_put(dev
, i
, SONIC_RD_SEQNO
, 0);
651 sonic_rda_put(dev
, i
, SONIC_RD_IN_USE
, 1);
652 sonic_rda_put(dev
, i
, SONIC_RD_LINK
,
654 ((i
+1) * SIZEOF_SONIC_RD
* SONIC_BUS_SCALE(lp
->dma_bitmode
)));
656 /* fix last descriptor */
657 sonic_rda_put(dev
, SONIC_NUM_RDS
- 1, SONIC_RD_LINK
,
658 (lp
->rda_laddr
& 0xffff) | SONIC_EOL
);
659 lp
->eol_rx
= SONIC_NUM_RDS
- 1;
661 SONIC_WRITE(SONIC_URDA
, lp
->rda_laddr
>> 16);
662 SONIC_WRITE(SONIC_CRDA
, lp
->rda_laddr
& 0xffff);
665 * initialize transmit descriptors
668 printk("sonic_init: initialize transmit descriptors\n");
669 for (i
= 0; i
< SONIC_NUM_TDS
; i
++) {
670 sonic_tda_put(dev
, i
, SONIC_TD_STATUS
, 0);
671 sonic_tda_put(dev
, i
, SONIC_TD_CONFIG
, 0);
672 sonic_tda_put(dev
, i
, SONIC_TD_PKTSIZE
, 0);
673 sonic_tda_put(dev
, i
, SONIC_TD_FRAG_COUNT
, 0);
674 sonic_tda_put(dev
, i
, SONIC_TD_LINK
,
675 (lp
->tda_laddr
& 0xffff) +
676 (i
+ 1) * SIZEOF_SONIC_TD
* SONIC_BUS_SCALE(lp
->dma_bitmode
));
677 lp
->tx_skb
[i
] = NULL
;
679 /* fix last descriptor */
680 sonic_tda_put(dev
, SONIC_NUM_TDS
- 1, SONIC_TD_LINK
,
681 (lp
->tda_laddr
& 0xffff));
683 SONIC_WRITE(SONIC_UTDA
, lp
->tda_laddr
>> 16);
684 SONIC_WRITE(SONIC_CTDA
, lp
->tda_laddr
& 0xffff);
685 lp
->cur_tx
= lp
->next_tx
= 0;
686 lp
->eol_tx
= SONIC_NUM_TDS
- 1;
689 * put our own address to CAM desc[0]
691 sonic_cda_put(dev
, 0, SONIC_CD_CAP0
, dev
->dev_addr
[1] << 8 | dev
->dev_addr
[0]);
692 sonic_cda_put(dev
, 0, SONIC_CD_CAP1
, dev
->dev_addr
[3] << 8 | dev
->dev_addr
[2]);
693 sonic_cda_put(dev
, 0, SONIC_CD_CAP2
, dev
->dev_addr
[5] << 8 | dev
->dev_addr
[4]);
694 sonic_set_cam_enable(dev
, 1);
696 for (i
= 0; i
< 16; i
++)
697 sonic_cda_put(dev
, i
, SONIC_CD_ENTRY_POINTER
, i
);
700 * initialize CAM registers
702 SONIC_WRITE(SONIC_CDP
, lp
->cda_laddr
& 0xffff);
703 SONIC_WRITE(SONIC_CDC
, 16);
708 SONIC_WRITE(SONIC_CMD
, SONIC_CR_LCAM
);
712 if (SONIC_READ(SONIC_ISR
) & SONIC_INT_LCD
)
715 if (sonic_debug
> 2) {
716 printk("sonic_init: CMD=%x, ISR=%x\n, i=%d",
717 SONIC_READ(SONIC_CMD
), SONIC_READ(SONIC_ISR
), i
);
721 * enable receiver, disable loopback
722 * and enable all interrupts
724 SONIC_WRITE(SONIC_CMD
, SONIC_CR_RXEN
| SONIC_CR_STP
);
725 SONIC_WRITE(SONIC_RCR
, SONIC_RCR_DEFAULT
);
726 SONIC_WRITE(SONIC_TCR
, SONIC_TCR_DEFAULT
);
727 SONIC_WRITE(SONIC_ISR
, 0x7fff);
728 SONIC_WRITE(SONIC_IMR
, SONIC_IMR_DEFAULT
);
730 cmd
= SONIC_READ(SONIC_CMD
);
731 if ((cmd
& SONIC_CR_RXEN
) == 0 || (cmd
& SONIC_CR_STP
) == 0)
732 printk(KERN_ERR
"sonic_init: failed, status=%x\n", cmd
);
735 printk("sonic_init: new status=%x\n",
736 SONIC_READ(SONIC_CMD
));
741 MODULE_LICENSE("GPL");