?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / drivers / net / saa9730.c
blobfd0167077fbeacaa164b5aa8b71afa58c7ce7931
1 /*
2 * Carsten Langgaard, carstenl@mips.com
3 * Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved.
4 *
5 * ########################################################################
6 *
7 * This program is free software; you can distribute it and/or modify it
8 * under the terms of the GNU General Public License (Version 2) as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
19 *
20 * ########################################################################
21 *
22 * SAA9730 ethernet driver.
23 *
24 * Changes:
25 * Angelo Dell'Aera <buffer@antifork.org> : Conversion to the new PCI API (pci_driver).
26 * Conversion to spinlocks.
27 * Error handling fixes.
28 *
29 */
30
31 #include <linux/init.h>
32 #include <linux/netdevice.h>
33 #include <linux/delay.h>
34 #include <linux/etherdevice.h>
35 #include <linux/module.h>
36 #include <linux/skbuff.h>
37 #include <linux/pci.h>
38 #include <linux/spinlock.h>
39
40 #include <asm/addrspace.h>
41 #include <asm/mips-boards/prom.h>
42
43 #include "saa9730.h"
44
45 #ifdef LAN_SAA9730_DEBUG
46 int lan_saa9730_debug = LAN_SAA9730_DEBUG;
47 #else
48 int lan_saa9730_debug;
49 #endif
50
51 #define DRV_MODULE_NAME "saa9730"
52
53 static struct pci_device_id saa9730_pci_tbl[] = {
54 { PCI_VENDOR_ID_PHILIPS, PCI_DEVICE_ID_PHILIPS_SAA9370,
55 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
56 { 0, }
57 };
58
59 MODULE_DEVICE_TABLE(pci, saa9730_pci_tbl);
60
61 /* Non-zero only if the current card is a PCI with BIOS-set IRQ. */
62 static unsigned int pci_irq_line;
63
64 #define INL(a) inl((unsigned long)a)
65 #define OUTL(x,a) outl(x,(unsigned long)a)
66
67 static void evm_saa9730_enable_lan_int(struct lan_saa9730_private *lp)
68 {
69 OUTL(INL(&lp->evm_saa9730_regs->InterruptBlock1) | EVM_LAN_INT,
70 &lp->evm_saa9730_regs->InterruptBlock1);
71 OUTL(INL(&lp->evm_saa9730_regs->InterruptStatus1) | EVM_LAN_INT,
72 &lp->evm_saa9730_regs->InterruptStatus1);
73 OUTL(INL(&lp->evm_saa9730_regs->InterruptEnable1) | EVM_LAN_INT |
74 EVM_MASTER_EN, &lp->evm_saa9730_regs->InterruptEnable1);
75 }
76 static void evm_saa9730_disable_lan_int(struct lan_saa9730_private *lp)
77 {
78 OUTL(INL(&lp->evm_saa9730_regs->InterruptBlock1) & ~EVM_LAN_INT,
79 &lp->evm_saa9730_regs->InterruptBlock1);
80 OUTL(INL(&lp->evm_saa9730_regs->InterruptEnable1) & ~EVM_LAN_INT,
81 &lp->evm_saa9730_regs->InterruptEnable1);
82 }
83
84 static void evm_saa9730_clear_lan_int(struct lan_saa9730_private *lp)
85 {
86 OUTL(EVM_LAN_INT, &lp->evm_saa9730_regs->InterruptStatus1);
87 }
88
89 static void evm_saa9730_block_lan_int(struct lan_saa9730_private *lp)
90 {
91 OUTL(INL(&lp->evm_saa9730_regs->InterruptBlock1) & ~EVM_LAN_INT,
92 &lp->evm_saa9730_regs->InterruptBlock1);
93 }
94
95 static void evm_saa9730_unblock_lan_int(struct lan_saa9730_private *lp)
96 {
97 OUTL(INL(&lp->evm_saa9730_regs->InterruptBlock1) | EVM_LAN_INT,
98 &lp->evm_saa9730_regs->InterruptBlock1);
99 }
100
101 static void show_saa9730_regs(struct lan_saa9730_private *lp)
102 {
103 int i, j;
104 printk("TxmBufferA = %x\n", lp->TxmBuffer[0][0]);
105 printk("TxmBufferB = %x\n", lp->TxmBuffer[1][0]);
106 printk("RcvBufferA = %x\n", lp->RcvBuffer[0][0]);
107 printk("RcvBufferB = %x\n", lp->RcvBuffer[1][0]);
108 for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
109 for (j = 0; j < LAN_SAA9730_TXM_Q_SIZE; j++) {
110 printk("TxmBuffer[%d][%d] = %x\n", i, j,
111 le32_to_cpu(*(unsigned int *)
112 lp->TxmBuffer[i][j]));
113 }
114 }
115 for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
116 for (j = 0; j < LAN_SAA9730_RCV_Q_SIZE; j++) {
117 printk("RcvBuffer[%d][%d] = %x\n", i, j,
118 le32_to_cpu(*(unsigned int *)
119 lp->RcvBuffer[i][j]));
120 }
121 }
122 printk("lp->evm_saa9730_regs->InterruptBlock1 = %x\n",
123 INL(&lp->evm_saa9730_regs->InterruptBlock1));
124 printk("lp->evm_saa9730_regs->InterruptStatus1 = %x\n",
125 INL(&lp->evm_saa9730_regs->InterruptStatus1));
126 printk("lp->evm_saa9730_regs->InterruptEnable1 = %x\n",
127 INL(&lp->evm_saa9730_regs->InterruptEnable1));
128 printk("lp->lan_saa9730_regs->Ok2Use = %x\n",
129 INL(&lp->lan_saa9730_regs->Ok2Use));
130 printk("lp->NextTxmBufferIndex = %x\n", lp->NextTxmBufferIndex);
131 printk("lp->NextTxmPacketIndex = %x\n", lp->NextTxmPacketIndex);
132 printk("lp->PendingTxmBufferIndex = %x\n",
133 lp->PendingTxmBufferIndex);
134 printk("lp->PendingTxmPacketIndex = %x\n",
135 lp->PendingTxmPacketIndex);
136 printk("lp->lan_saa9730_regs->LanDmaCtl = %x\n",
137 INL(&lp->lan_saa9730_regs->LanDmaCtl));
138 printk("lp->lan_saa9730_regs->DmaStatus = %x\n",
139 INL(&lp->lan_saa9730_regs->DmaStatus));
140 printk("lp->lan_saa9730_regs->CamCtl = %x\n",
141 INL(&lp->lan_saa9730_regs->CamCtl));
142 printk("lp->lan_saa9730_regs->TxCtl = %x\n",
143 INL(&lp->lan_saa9730_regs->TxCtl));
144 printk("lp->lan_saa9730_regs->TxStatus = %x\n",
145 INL(&lp->lan_saa9730_regs->TxStatus));
146 printk("lp->lan_saa9730_regs->RxCtl = %x\n",
147 INL(&lp->lan_saa9730_regs->RxCtl));
148 printk("lp->lan_saa9730_regs->RxStatus = %x\n",
149 INL(&lp->lan_saa9730_regs->RxStatus));
150 for (i = 0; i < LAN_SAA9730_CAM_DWORDS; i++) {
151 OUTL(i, &lp->lan_saa9730_regs->CamAddress);
152 printk("lp->lan_saa9730_regs->CamData = %x\n",
153 INL(&lp->lan_saa9730_regs->CamData));
154 }
155 printk("lp->stats.tx_packets = %lx\n", lp->stats.tx_packets);
156 printk("lp->stats.tx_errors = %lx\n", lp->stats.tx_errors);
157 printk("lp->stats.tx_aborted_errors = %lx\n",
158 lp->stats.tx_aborted_errors);
159 printk("lp->stats.tx_window_errors = %lx\n",
160 lp->stats.tx_window_errors);
161 printk("lp->stats.tx_carrier_errors = %lx\n",
162 lp->stats.tx_carrier_errors);
163 printk("lp->stats.tx_fifo_errors = %lx\n",
164 lp->stats.tx_fifo_errors);
165 printk("lp->stats.tx_heartbeat_errors = %lx\n",
166 lp->stats.tx_heartbeat_errors);
167 printk("lp->stats.collisions = %lx\n", lp->stats.collisions);
168
169 printk("lp->stats.rx_packets = %lx\n", lp->stats.rx_packets);
170 printk("lp->stats.rx_errors = %lx\n", lp->stats.rx_errors);
171 printk("lp->stats.rx_dropped = %lx\n", lp->stats.rx_dropped);
172 printk("lp->stats.rx_crc_errors = %lx\n", lp->stats.rx_crc_errors);
173 printk("lp->stats.rx_frame_errors = %lx\n",
174 lp->stats.rx_frame_errors);
175 printk("lp->stats.rx_fifo_errors = %lx\n",
176 lp->stats.rx_fifo_errors);
177 printk("lp->stats.rx_length_errors = %lx\n",
178 lp->stats.rx_length_errors);
179
180 printk("lp->lan_saa9730_regs->DebugPCIMasterAddr = %x\n",
181 INL(&lp->lan_saa9730_regs->DebugPCIMasterAddr));
182 printk("lp->lan_saa9730_regs->DebugLanTxStateMachine = %x\n",
183 INL(&lp->lan_saa9730_regs->DebugLanTxStateMachine));
184 printk("lp->lan_saa9730_regs->DebugLanRxStateMachine = %x\n",
185 INL(&lp->lan_saa9730_regs->DebugLanRxStateMachine));
186 printk("lp->lan_saa9730_regs->DebugLanTxFifoPointers = %x\n",
187 INL(&lp->lan_saa9730_regs->DebugLanTxFifoPointers));
188 printk("lp->lan_saa9730_regs->DebugLanRxFifoPointers = %x\n",
189 INL(&lp->lan_saa9730_regs->DebugLanRxFifoPointers));
190 printk("lp->lan_saa9730_regs->DebugLanCtlStateMachine = %x\n",
191 INL(&lp->lan_saa9730_regs->DebugLanCtlStateMachine));
192 }
193
194 static void lan_saa9730_buffer_init(struct lan_saa9730_private *lp)
195 {
196 int i, j;
197
198 /* Init RX buffers */
199 for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
200 for (j = 0; j < LAN_SAA9730_RCV_Q_SIZE; j++) {
201 *(unsigned int *) lp->RcvBuffer[i][j] =
202 cpu_to_le32(RXSF_READY <<
203 RX_STAT_CTL_OWNER_SHF);
204 }
205 }
206
207 /* Init TX buffers */
208 for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
209 for (j = 0; j < LAN_SAA9730_TXM_Q_SIZE; j++) {
210 *(unsigned int *) lp->TxmBuffer[i][j] =
211 cpu_to_le32(TXSF_EMPTY <<
212 TX_STAT_CTL_OWNER_SHF);
213 }
214 }
215 }
216
217 static int lan_saa9730_allocate_buffers(struct lan_saa9730_private *lp)
218 {
219 unsigned int mem_size;
220 void *Pa;
221 unsigned int i, j, RcvBufferSize, TxmBufferSize;
222 unsigned int buffer_start;
223
224 /*
225 * Allocate all RX and TX packets in one chunk.
226 * The Rx and Tx packets must be PACKET_SIZE aligned.
227 */
228 mem_size = ((LAN_SAA9730_RCV_Q_SIZE + LAN_SAA9730_TXM_Q_SIZE) *
229 LAN_SAA9730_PACKET_SIZE * LAN_SAA9730_BUFFERS) +
230 LAN_SAA9730_PACKET_SIZE;
231 buffer_start =
232 (unsigned int) kmalloc(mem_size, GFP_DMA | GFP_KERNEL);
233
234 if (!buffer_start)
235 return -ENOMEM;
236
237 /*
238 * Set DMA buffer to kseg1 (uncached).
239 * Make sure to flush before using it uncached.
240 */
241 Pa = (void *) KSEG1ADDR((buffer_start + LAN_SAA9730_PACKET_SIZE) &
242 ~(LAN_SAA9730_PACKET_SIZE - 1));
243 dma_cache_wback_inv((unsigned long) Pa, mem_size);
244
245 /* Initialize buffer space */
246 RcvBufferSize = LAN_SAA9730_PACKET_SIZE;
247 TxmBufferSize = LAN_SAA9730_PACKET_SIZE;
248 lp->DmaRcvPackets = LAN_SAA9730_RCV_Q_SIZE;
249 lp->DmaTxmPackets = LAN_SAA9730_TXM_Q_SIZE;
250
251 /* Init RX buffers */
252 for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
253 for (j = 0; j < LAN_SAA9730_RCV_Q_SIZE; j++) {
254 *(unsigned int *) Pa =
255 cpu_to_le32(RXSF_READY <<
256 RX_STAT_CTL_OWNER_SHF);
257 lp->RcvBuffer[i][j] = (unsigned int) Pa;
258 Pa += RcvBufferSize;
259 }
260 }
261
262 /* Init TX buffers */
263 for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
264 for (j = 0; j < LAN_SAA9730_TXM_Q_SIZE; j++) {
265 *(unsigned int *) Pa =
266 cpu_to_le32(TXSF_EMPTY <<
267 TX_STAT_CTL_OWNER_SHF);
268 lp->TxmBuffer[i][j] = (unsigned int) Pa;
269 Pa += TxmBufferSize;
270 }
271 }
272
273 /*
274 * Set rx buffer A and rx buffer B to point to the first two buffer
275 * spaces.
276 */
277 OUTL(PHYSADDR(lp->RcvBuffer[0][0]),
278 &lp->lan_saa9730_regs->RxBuffA);
279 OUTL(PHYSADDR(lp->RcvBuffer[1][0]),
280 &lp->lan_saa9730_regs->RxBuffB);
281
282 /* Initialize Buffer Index */
283 lp->NextRcvPacketIndex = 0;
284 lp->NextRcvToUseIsA = 1;
285
286 /* Set current buffer index & next availble packet index */
287 lp->NextTxmPacketIndex = 0;
288 lp->NextTxmBufferIndex = 0;
289 lp->PendingTxmPacketIndex = 0;
290 lp->PendingTxmBufferIndex = 0;
291
292 /*
293 * Set txm_buf_a and txm_buf_b to point to the first two buffer
294 * space
295 */
296 OUTL(PHYSADDR(lp->TxmBuffer[0][0]),
297 &lp->lan_saa9730_regs->TxBuffA);
298 OUTL(PHYSADDR(lp->TxmBuffer[1][0]),
299 &lp->lan_saa9730_regs->TxBuffB);
300
301 /* Set packet number */
302 OUTL((lp->DmaRcvPackets << PK_COUNT_RX_A_SHF) |
303 (lp->DmaRcvPackets << PK_COUNT_RX_B_SHF) |
304 (lp->DmaTxmPackets << PK_COUNT_TX_A_SHF) |
305 (lp->DmaTxmPackets << PK_COUNT_TX_B_SHF),
306 &lp->lan_saa9730_regs->PacketCount);
307
308 return 0;
309 }
310
311 static int lan_saa9730_cam_load(struct lan_saa9730_private *lp)
312 {
313 unsigned int i;
314 unsigned char *NetworkAddress;
315
316 NetworkAddress = (unsigned char *) &lp->PhysicalAddress[0][0];
317
318 for (i = 0; i < LAN_SAA9730_CAM_DWORDS; i++) {
319 /* First set address to where data is written */
320 OUTL(i, &lp->lan_saa9730_regs->CamAddress);
321 OUTL((NetworkAddress[0] << 24) | (NetworkAddress[1] << 16)
322 | (NetworkAddress[2] << 8) | NetworkAddress[3],
323 &lp->lan_saa9730_regs->CamData);
324 NetworkAddress += 4;
325 }
326 return 0;
327 }
328
329 static int lan_saa9730_cam_init(struct net_device *dev)
330 {
331 struct lan_saa9730_private *lp =
332 (struct lan_saa9730_private *) dev->priv;
333 unsigned int i;
334
335 /* Copy MAC-address into all entries. */
336 for (i = 0; i < LAN_SAA9730_CAM_ENTRIES; i++) {
337 memcpy((unsigned char *) lp->PhysicalAddress[i],
338 (unsigned char *) dev->dev_addr, 6);
339 }
340
341 return 0;
342 }
343
344 static int lan_saa9730_mii_init(struct lan_saa9730_private *lp)
345 {
346 int i, l;
347
348 /* Check link status, spin here till station is not busy. */
349 i = 0;
350 while (INL(&lp->lan_saa9730_regs->StationMgmtCtl) & MD_CA_BUSY) {
351 i++;
352 if (i > 100) {
353 printk("Error: lan_saa9730_mii_init: timeout\n");
354 return -1;
355 }
356 mdelay(1); /* wait 1 ms. */
357 }
358
359 /* Now set the control and address register. */
360 OUTL(MD_CA_BUSY | PHY_STATUS | PHY_ADDRESS << MD_CA_PHY_SHF,
361 &lp->lan_saa9730_regs->StationMgmtCtl);
362
363 /* check link status, spin here till station is not busy */
364 i = 0;
365 while (INL(&lp->lan_saa9730_regs->StationMgmtCtl) & MD_CA_BUSY) {
366 i++;
367 if (i > 100) {
368 printk("Error: lan_saa9730_mii_init: timeout\n");
369 return -1;
370 }
371 mdelay(1); /* wait 1 ms. */
372 }
373
374 /* Wait for 1 ms. */
375 mdelay(1);
376
377 /* Check the link status. */
378 if (INL(&lp->lan_saa9730_regs->StationMgmtData) &
379 PHY_STATUS_LINK_UP) {
380 /* Link is up. */
381 return 0;
382 } else {
383 /* Link is down, reset the PHY first. */
384
385 /* set PHY address = 'CONTROL' */
386 OUTL(PHY_ADDRESS << MD_CA_PHY_SHF | MD_CA_WR | PHY_CONTROL,
387 &lp->lan_saa9730_regs->StationMgmtCtl);
388
389 /* Wait for 1 ms. */
390 mdelay(1);
391
392 /* set 'CONTROL' = force reset and renegotiate */
393 OUTL(PHY_CONTROL_RESET | PHY_CONTROL_AUTO_NEG |
394 PHY_CONTROL_RESTART_AUTO_NEG,
395 &lp->lan_saa9730_regs->StationMgmtData);
396
397 /* Wait for 50 ms. */
398 mdelay(50);
399
400 /* set 'BUSY' to start operation */
401 OUTL(MD_CA_BUSY | PHY_ADDRESS << MD_CA_PHY_SHF | MD_CA_WR |
402 PHY_CONTROL, &lp->lan_saa9730_regs->StationMgmtCtl);
403
404 /* await completion */
405 i = 0;
406 while (INL(&lp->lan_saa9730_regs->StationMgmtCtl) &
407 MD_CA_BUSY) {
408 i++;
409 if (i > 100) {
410 printk
411 ("Error: lan_saa9730_mii_init: timeout\n");
412 return -1;
413 }
414 mdelay(1); /* wait 1 ms. */
415 }
416
417 /* Wait for 1 ms. */
418 mdelay(1);
419
420 for (l = 0; l < 2; l++) {
421 /* set PHY address = 'STATUS' */
422 OUTL(MD_CA_BUSY | PHY_ADDRESS << MD_CA_PHY_SHF |
423 PHY_STATUS,
424 &lp->lan_saa9730_regs->StationMgmtCtl);
425
426 /* await completion */
427 i = 0;
428 while (INL(&lp->lan_saa9730_regs->StationMgmtCtl) &
429 MD_CA_BUSY) {
430 i++;
431 if (i > 100) {
432 printk
433 ("Error: lan_saa9730_mii_init: timeout\n");
434 return -1;
435 }
436 mdelay(1); /* wait 1 ms. */
437 }
438
439 /* wait for 3 sec. */
440 mdelay(3000);
441
442 /* check the link status */
443 if (INL(&lp->lan_saa9730_regs->StationMgmtData) &
444 PHY_STATUS_LINK_UP) {
445 /* link is up */
446 break;
447 }
448 }
449 }
450
451 return 0;
452 }
453
454 static int lan_saa9730_control_init(struct lan_saa9730_private *lp)
455 {
456 /* Initialize DMA control register. */
457 OUTL((LANMB_ANY << DMA_CTL_MAX_XFER_SHF) |
458 (LANEND_LITTLE << DMA_CTL_ENDIAN_SHF) |
459 (LAN_SAA9730_RCV_Q_INT_THRESHOLD << DMA_CTL_RX_INT_COUNT_SHF)
460 | DMA_CTL_RX_INT_TO_EN | DMA_CTL_RX_INT_EN |
461 DMA_CTL_MAC_RX_INT_EN | DMA_CTL_MAC_TX_INT_EN,
462 &lp->lan_saa9730_regs->LanDmaCtl);
463
464 /* Initial MAC control register. */
465 OUTL((MACCM_MII << MAC_CONTROL_CONN_SHF) | MAC_CONTROL_FULL_DUP,
466 &lp->lan_saa9730_regs->MacCtl);
467
468 /* Initialize CAM control register. */
469 OUTL(CAM_CONTROL_COMP_EN | CAM_CONTROL_BROAD_ACC,
470 &lp->lan_saa9730_regs->CamCtl);
471
472 /*
473 * Initialize CAM enable register, only turn on first entry, should
474 * contain own addr.
475 */
476 OUTL(0x0001, &lp->lan_saa9730_regs->CamEnable);
477
478 /* Initialize Tx control register */
479 OUTL(TX_CTL_EN_COMP, &lp->lan_saa9730_regs->TxCtl);
480
481 /* Initialize Rcv control register */
482 OUTL(RX_CTL_STRIP_CRC, &lp->lan_saa9730_regs->RxCtl);
483
484 /* Reset DMA engine */
485 OUTL(DMA_TEST_SW_RESET, &lp->lan_saa9730_regs->DmaTest);
486
487 return 0;
488 }
489
490 static int lan_saa9730_stop(struct lan_saa9730_private *lp)
491 {
492 int i;
493
494 /* Stop DMA first */
495 OUTL(INL(&lp->lan_saa9730_regs->LanDmaCtl) &
496 ~(DMA_CTL_EN_TX_DMA | DMA_CTL_EN_RX_DMA),
497 &lp->lan_saa9730_regs->LanDmaCtl);
498
499 /* Set the SW Reset bits in DMA and MAC control registers */
500 OUTL(DMA_TEST_SW_RESET, &lp->lan_saa9730_regs->DmaTest);
501 OUTL(INL(&lp->lan_saa9730_regs->MacCtl) | MAC_CONTROL_RESET,
502 &lp->lan_saa9730_regs->MacCtl);
503
504 /*
505 * Wait for MAC reset to have finished. The reset bit is auto cleared
506 * when the reset is done.
507 */
508 i = 0;
509 while (INL(&lp->lan_saa9730_regs->MacCtl) & MAC_CONTROL_RESET) {
510 i++;
511 if (i > 100) {
512 printk
513 ("Error: lan_sa9730_stop: MAC reset timeout\n");
514 return -1;
515 }
516 mdelay(1); /* wait 1 ms. */
517 }
518
519 return 0;
520 }
521
522 static int lan_saa9730_dma_init(struct lan_saa9730_private *lp)
523 {
524 /* Stop lan controller. */
525 lan_saa9730_stop(lp);
526
527 OUTL(LAN_SAA9730_DEFAULT_TIME_OUT_CNT,
528 &lp->lan_saa9730_regs->Timeout);
529
530 return 0;
531 }
532
533 static int lan_saa9730_start(struct lan_saa9730_private *lp)
534 {
535 lan_saa9730_buffer_init(lp);
536
537 /* Initialize Rx Buffer Index */
538 lp->NextRcvPacketIndex = 0;
539 lp->NextRcvToUseIsA = 1;
540
541 /* Set current buffer index & next availble packet index */
542 lp->NextTxmPacketIndex = 0;
543 lp->NextTxmBufferIndex = 0;
544 lp->PendingTxmPacketIndex = 0;
545 lp->PendingTxmBufferIndex = 0;
546
547 OUTL(INL(&lp->lan_saa9730_regs->LanDmaCtl) | DMA_CTL_EN_TX_DMA |
548 DMA_CTL_EN_RX_DMA, &lp->lan_saa9730_regs->LanDmaCtl);
549
550 /* For Tx, turn on MAC then DMA */
551 OUTL(INL(&lp->lan_saa9730_regs->TxCtl) | TX_CTL_TX_EN,
552 &lp->lan_saa9730_regs->TxCtl);
553
554 /* For Rx, turn on DMA then MAC */
555 OUTL(INL(&lp->lan_saa9730_regs->RxCtl) | RX_CTL_RX_EN,
556 &lp->lan_saa9730_regs->RxCtl);
557
558 /* Set Ok2Use to let hardware owns the buffers */
559 OUTL(OK2USE_RX_A | OK2USE_RX_B | OK2USE_TX_A | OK2USE_TX_B,
560 &lp->lan_saa9730_regs->Ok2Use);
561
562 return 0;
563 }
564
565 static int lan_saa9730_restart(struct lan_saa9730_private *lp)
566 {
567 lan_saa9730_stop(lp);
568 lan_saa9730_start(lp);
569
570 return 0;
571 }
572
573 static int lan_saa9730_tx(struct net_device *dev)
574 {
575 struct lan_saa9730_private *lp =
576 (struct lan_saa9730_private *) dev->priv;
577 unsigned int *pPacket;
578 unsigned int tx_status;
579
580 if (lan_saa9730_debug > 5)
581 printk("lan_saa9730_tx interrupt\n");
582
583 /* Clear interrupt. */
584 OUTL(DMA_STATUS_MAC_TX_INT, &lp->lan_saa9730_regs->DmaStatus);
585
586 while (1) {
587 pPacket =
588 (unsigned int *) lp->TxmBuffer[lp->
589 PendingTxmBufferIndex]
590 [lp->PendingTxmPacketIndex];
591
592 /* Get status of first packet transmitted. */
593 tx_status = le32_to_cpu(*pPacket);
594
595 /* Check ownership. */
596 if ((tx_status & TX_STAT_CTL_OWNER_MSK) !=
597 (TXSF_HWDONE << TX_STAT_CTL_OWNER_SHF)) break;
598
599 /* Check for error. */
600 if (tx_status & TX_STAT_CTL_ERROR_MSK) {
601 if (lan_saa9730_debug > 1)
602 printk("lan_saa9730_tx: tx error = %x\n",
603 tx_status);
604
605 lp->stats.tx_errors++;
606 if (tx_status &
607 (TX_STATUS_EX_COLL << TX_STAT_CTL_STATUS_SHF))
608 lp->stats.tx_aborted_errors++;
609 if (tx_status &
610 (TX_STATUS_LATE_COLL <<
611 TX_STAT_CTL_STATUS_SHF)) lp->stats.
612 tx_window_errors++;
613 if (tx_status &
614 (TX_STATUS_L_CARR << TX_STAT_CTL_STATUS_SHF))
615 lp->stats.tx_carrier_errors++;
616 if (tx_status &
617 (TX_STATUS_UNDER << TX_STAT_CTL_STATUS_SHF))
618 lp->stats.tx_fifo_errors++;
619 if (tx_status &
620 (TX_STATUS_SQ_ERR << TX_STAT_CTL_STATUS_SHF))
621 lp->stats.tx_heartbeat_errors++;
622
623 lp->stats.collisions +=
624 tx_status & TX_STATUS_TX_COLL_MSK;
625 }
626
627 /* Free buffer. */
628 *pPacket =
629 cpu_to_le32(TXSF_EMPTY << TX_STAT_CTL_OWNER_SHF);
630
631 /* Update pending index pointer. */
632 lp->PendingTxmPacketIndex++;
633 if (lp->PendingTxmPacketIndex >= LAN_SAA9730_TXM_Q_SIZE) {
634 lp->PendingTxmPacketIndex = 0;
635 lp->PendingTxmBufferIndex ^= 1;
636 }
637 }
638
639 /* Make sure A and B are available to hardware. */
640 OUTL(OK2USE_TX_A | OK2USE_TX_B, &lp->lan_saa9730_regs->Ok2Use);
641
642 if (netif_queue_stopped(dev)) {
643 /* The tx buffer is no longer full. */
644 netif_wake_queue(dev);
645 }
646
647 return 0;
648 }
649
650 static int lan_saa9730_rx(struct net_device *dev)
651 {
652 struct lan_saa9730_private *lp =
653 (struct lan_saa9730_private *) dev->priv;
654 int len = 0;
655 struct sk_buff *skb = 0;
656 unsigned int rx_status;
657 int BufferIndex;
658 int PacketIndex;
659 unsigned int *pPacket;
660 unsigned char *pData;
661
662 if (lan_saa9730_debug > 5)
663 printk("lan_saa9730_rx interrupt\n");
664
665 /* Clear receive interrupts. */
666 OUTL(DMA_STATUS_MAC_RX_INT | DMA_STATUS_RX_INT |
667 DMA_STATUS_RX_TO_INT, &lp->lan_saa9730_regs->DmaStatus);
668
669 /* Address next packet */
670 if (lp->NextRcvToUseIsA)
671 BufferIndex = 0;
672 else
673 BufferIndex = 1;
674 PacketIndex = lp->NextRcvPacketIndex;
675 pPacket = (unsigned int *) lp->RcvBuffer[BufferIndex][PacketIndex];
676 rx_status = le32_to_cpu(*pPacket);
677
678 /* Process each packet. */
679 while ((rx_status & RX_STAT_CTL_OWNER_MSK) ==
680 (RXSF_HWDONE << RX_STAT_CTL_OWNER_SHF)) {
681 /* Check the rx status. */
682 if (rx_status & (RX_STATUS_GOOD << RX_STAT_CTL_STATUS_SHF)) {
683 /* Received packet is good. */
684 len = (rx_status & RX_STAT_CTL_LENGTH_MSK) >>
685 RX_STAT_CTL_LENGTH_SHF;
686
687 pData = (unsigned char *) pPacket;
688 pData += 4;
689 skb = dev_alloc_skb(len + 2);
690 if (skb == 0) {
691 printk
692 ("%s: Memory squeeze, deferring packet.\n",
693 dev->name);
694 lp->stats.rx_dropped++;
695 } else {
696 lp->stats.rx_bytes += len;
697 lp->stats.rx_packets++;
698 skb->dev = dev;
699 skb_reserve(skb, 2); /* 16 byte align */
700 skb_put(skb, len); /* make room */
701 eth_copy_and_sum(skb,
702 (unsigned char *) pData,
703 len, 0);
704 skb->protocol = eth_type_trans(skb, dev);
705 netif_rx(skb);
706 dev->last_rx = jiffies;
707 }
708 } else {
709 /* We got an error packet. */
710 if (lan_saa9730_debug > 2)
711 printk
712 ("lan_saa9730_rx: We got an error packet = %x\n",
713 rx_status);
714
715 lp->stats.rx_errors++;
716 if (rx_status &
717 (RX_STATUS_CRC_ERR << RX_STAT_CTL_STATUS_SHF))
718 lp->stats.rx_crc_errors++;
719 if (rx_status &
720 (RX_STATUS_ALIGN_ERR <<
721 RX_STAT_CTL_STATUS_SHF)) lp->stats.
722 rx_frame_errors++;
723 if (rx_status &
724 (RX_STATUS_OVERFLOW << RX_STAT_CTL_STATUS_SHF))
725 lp->stats.rx_fifo_errors++;
726 if (rx_status &
727 (RX_STATUS_LONG_ERR << RX_STAT_CTL_STATUS_SHF))
728 lp->stats.rx_length_errors++;
729 }
730
731 /* Indicate we have processed the buffer. */
732 *pPacket =
733 cpu_to_le32(RXSF_READY << RX_STAT_CTL_OWNER_SHF);
734
735 /* Go to next packet in sequence. */
736 lp->NextRcvPacketIndex++;
737 if (lp->NextRcvPacketIndex >= LAN_SAA9730_RCV_Q_SIZE) {
738 lp->NextRcvPacketIndex = 0;
739 if (BufferIndex) {
740 lp->NextRcvToUseIsA = 1;
741 } else {
742 lp->NextRcvToUseIsA = 0;
743 }
744 }
745 OUTL(OK2USE_RX_A | OK2USE_RX_B,
746 &lp->lan_saa9730_regs->Ok2Use);
747
748 /* Address next packet */
749 if (lp->NextRcvToUseIsA)
750 BufferIndex = 0;
751 else
752 BufferIndex = 1;
753 PacketIndex = lp->NextRcvPacketIndex;
754 pPacket =
755 (unsigned int *) lp->
756 RcvBuffer[BufferIndex][PacketIndex];
757 rx_status = le32_to_cpu(*pPacket);
758 }
759
760 /* Make sure A and B are available to hardware. */
761 OUTL(OK2USE_RX_A | OK2USE_RX_B, &lp->lan_saa9730_regs->Ok2Use);
762
763 return 0;
764 }
765
766 static irqreturn_t lan_saa9730_interrupt(const int irq, void *dev_id,
767 struct pt_regs *regs)
768 {
769 struct net_device *dev = (struct net_device *) dev_id;
770 struct lan_saa9730_private *lp =
771 (struct lan_saa9730_private *) dev->priv;
772
773 if (lan_saa9730_debug > 5)
774 printk("lan_saa9730_interrupt\n");
775
776 /* Disable the EVM LAN interrupt. */
777 evm_saa9730_block_lan_int(lp);
778
779 /* Clear the EVM LAN interrupt. */
780 evm_saa9730_clear_lan_int(lp);
781
782 /* Service pending transmit interrupts. */
783 if (INL(&lp->lan_saa9730_regs->DmaStatus) & DMA_STATUS_MAC_TX_INT)
784 lan_saa9730_tx(dev);
785
786 /* Service pending receive interrupts. */
787 if (INL(&lp->lan_saa9730_regs->DmaStatus) &
788 (DMA_STATUS_MAC_RX_INT | DMA_STATUS_RX_INT |
789 DMA_STATUS_RX_TO_INT)) lan_saa9730_rx(dev);
790
791 /* Enable the EVM LAN interrupt. */
792 evm_saa9730_unblock_lan_int(lp);
793
794 return IRQ_HANDLED;
795 }
796
797 static int lan_saa9730_open_fail(struct net_device *dev)
798 {
799 return -ENODEV;
800 }
801
802 static int lan_saa9730_open(struct net_device *dev)
803 {
804 struct lan_saa9730_private *lp =
805 (struct lan_saa9730_private *) dev->priv;
806
807 /* Associate IRQ with lan_saa9730_interrupt */
808 if (request_irq(dev->irq, &lan_saa9730_interrupt, 0, "SAA9730 Eth",
809 dev)) {
810 printk("lan_saa9730_open: Can't get irq %d\n", dev->irq);
811 return -EAGAIN;
812 }
813
814 /* Enable the Lan interrupt in the event manager. */
815 evm_saa9730_enable_lan_int(lp);
816
817 /* Start the LAN controller */
818 if (lan_saa9730_start(lp))
819 return -1;
820
821 netif_start_queue(dev);
822
823 return 0;
824 }
825
826 static int lan_saa9730_write(struct lan_saa9730_private *lp,
827 struct sk_buff *skb, int skblen)
828 {
829 unsigned char *pbData = skb->data;
830 unsigned int len = skblen;
831 unsigned char *pbPacketData;
832 unsigned int tx_status;
833 int BufferIndex;
834 int PacketIndex;
835
836 if (lan_saa9730_debug > 5)
837 printk("lan_saa9730_write: skb=%08x\n",
838 (unsigned int) skb);
839
840 BufferIndex = lp->NextTxmBufferIndex;
841 PacketIndex = lp->NextTxmPacketIndex;
842
843 tx_status =
844 le32_to_cpu(*(unsigned int *) lp->
845 TxmBuffer[BufferIndex][PacketIndex]);
846 if ((tx_status & TX_STAT_CTL_OWNER_MSK) !=
847 (TXSF_EMPTY << TX_STAT_CTL_OWNER_SHF)) {
848 if (lan_saa9730_debug > 4)
849 printk
850 ("lan_saa9730_write: Tx buffer not available: tx_status = %x\n",
851 tx_status);
852 return -1;
853 }
854
855 lp->NextTxmPacketIndex++;
856 if (lp->NextTxmPacketIndex >= LAN_SAA9730_TXM_Q_SIZE) {
857 lp->NextTxmPacketIndex = 0;
858 lp->NextTxmBufferIndex ^= 1;
859 }
860
861 pbPacketData =
862 (unsigned char *) lp->TxmBuffer[BufferIndex][PacketIndex];
863 pbPacketData += 4;
864
865 /* copy the bits */
866 memcpy(pbPacketData, pbData, len);
867
868 /* Set transmit status for hardware */
869 *(unsigned int *) lp->TxmBuffer[BufferIndex][PacketIndex] =
870 cpu_to_le32((TXSF_READY << TX_STAT_CTL_OWNER_SHF) |
871 (TX_STAT_CTL_INT_AFTER_TX << TX_STAT_CTL_FRAME_SHF)
872 | (len << TX_STAT_CTL_LENGTH_SHF));
873
874 /* Set hardware tx buffer. */
875 OUTL(OK2USE_TX_A | OK2USE_TX_B, &lp->lan_saa9730_regs->Ok2Use);
876
877 return 0;
878 }
879
880 static void lan_saa9730_tx_timeout(struct net_device *dev)
881 {
882 struct lan_saa9730_private *lp =
883 (struct lan_saa9730_private *) dev->priv;
884
885 /* Transmitter timeout, serious problems */
886 lp->stats.tx_errors++;
887 printk("%s: transmit timed out, reset\n", dev->name);
888 /*show_saa9730_regs(lp); */
889 lan_saa9730_restart(lp);
890
891 dev->trans_start = jiffies;
892 netif_start_queue(dev);
893 }
894
895 static int lan_saa9730_start_xmit(struct sk_buff *skb,
896 struct net_device *dev)
897 {
898 struct lan_saa9730_private *lp =
899 (struct lan_saa9730_private *) dev->priv;
900 unsigned long flags;
901 int skblen;
902 int len;
903
904 if (lan_saa9730_debug > 4)
905 printk("Send packet: skb=%08x\n", (unsigned int) skb);
906
907 skblen = skb->len;
908
909 spin_lock_irqsave(&lp->lock, flags);
910
911 len = (skblen <= ETH_ZLEN) ? ETH_ZLEN : skblen;
912
913 if (lan_saa9730_write(lp, skb, skblen)) {
914 spin_unlock_irqrestore(&lp->lock, flags);
915 printk("Error when writing packet to controller: skb=%08x\n",
916 (unsigned int) skb);
917 netif_stop_queue(dev);
918 return -1;
919 }
920
921 lp->stats.tx_bytes += len;
922 lp->stats.tx_packets++;
923
924 dev->trans_start = jiffies;
925 netif_start_queue(dev);
926 dev_kfree_skb(skb);
927
928 spin_unlock_irqrestore(&lp->lock, flags);
929
930 return 0;
931 }
932
933 static int lan_saa9730_close(struct net_device *dev)
934 {
935 struct lan_saa9730_private *lp =
936 (struct lan_saa9730_private *) dev->priv;
937
938 if (lan_saa9730_debug > 1)
939 printk("lan_saa9730_close:\n");
940
941 netif_stop_queue(dev);
942
943 /* Disable the Lan interrupt in the event manager. */
944 evm_saa9730_disable_lan_int(lp);
945
946 /* Stop the controller */
947 if (lan_saa9730_stop(lp))
948 return -1;
949
950 free_irq(dev->irq, (void *) dev);
951
952 return 0;
953 }
954
955 static struct net_device_stats *lan_saa9730_get_stats(struct net_device
956 *dev)
957 {
958 struct lan_saa9730_private *lp =
959 (struct lan_saa9730_private *) dev->priv;
960
961 return &lp->stats;
962 }
963
964 static void lan_saa9730_set_multicast(struct net_device *dev)
965 {
966 struct lan_saa9730_private *lp =
967 (struct lan_saa9730_private *) dev->priv;
968
969 /* Stop the controller */
970 lan_saa9730_stop(lp);
971
972 if (dev->flags & IFF_PROMISC) {
973 /* accept all packets */
974 OUTL(CAM_CONTROL_COMP_EN | CAM_CONTROL_STATION_ACC |
975 CAM_CONTROL_GROUP_ACC | CAM_CONTROL_BROAD_ACC,
976 &lp->lan_saa9730_regs->CamCtl);
977 } else {
978 if (dev->flags & IFF_ALLMULTI) {
979 /* accept all multicast packets */
980 OUTL(CAM_CONTROL_COMP_EN | CAM_CONTROL_GROUP_ACC |
981 CAM_CONTROL_BROAD_ACC,
982 &lp->lan_saa9730_regs->CamCtl);
983 } else {
984 /*
985 * Will handle the multicast stuff later. -carstenl
986 */
987 }
988 }
989
990 lan_saa9730_restart(lp);
991 }
992
993
994 static void __devexit saa9730_remove_one(struct pci_dev *pdev)
995 {
996 struct net_device *dev = pci_get_drvdata(pdev);
997
998 if (dev) {
999 unregister_netdev(dev);
1000
1001 if (dev->priv)
1002 kfree(dev->priv);
1003
1004 free_netdev(dev);
1005 pci_release_regions(pdev);
1006 pci_disable_device(pdev);
1007 pci_set_drvdata(pdev, NULL);
1008 }
1009 }
1010
1011
1012 static int lan_saa9730_init(struct net_device *dev, int ioaddr, int irq)
1013 {
1014 struct lan_saa9730_private *lp;
1015 unsigned char ethernet_addr[6];
1016 int ret = 0;
1017
1018 dev->open = lan_saa9730_open_fail;
1019
1020 if (get_ethernet_addr(ethernet_addr))
1021 return -ENODEV;
1022
1023 memcpy(dev->dev_addr, ethernet_addr, 6);
1024 dev->base_addr = ioaddr;
1025 dev->irq = irq;
1026
1027 /*
1028 * Make certain the data structures used by the controller are aligned
1029 * and DMAble.
1030 */
1031 /*
1032 * XXX: that is obviously broken - kfree() won't be happy with us.
1033 */
1034 lp = (struct lan_saa9730_private *) (((unsigned long)
1035 kmalloc(sizeof(*lp) + 7,
1036 GFP_DMA | GFP_KERNEL)
1037 + 7) & ~7);
1038
1039 if (!lp)
1040 return -ENOMEM;
1041
1042 dev->priv = lp;
1043 memset(lp, 0, sizeof(*lp));
1044
1045 /* Set SAA9730 LAN base address. */
1046 lp->lan_saa9730_regs = (t_lan_saa9730_regmap *) (ioaddr +
1047 SAA9730_LAN_REGS_ADDR);
1048
1049 /* Set SAA9730 EVM base address. */
1050 lp->evm_saa9730_regs = (t_evm_saa9730_regmap *) (ioaddr +
1051 SAA9730_EVM_REGS_ADDR);
1052
1053 /* Allocate LAN RX/TX frame buffer space. */
1054 /* FIXME: a leak */
1055 if ((ret = lan_saa9730_allocate_buffers(lp)))
1056 goto out;
1057
1058 /* Stop LAN controller. */
1059 if ((ret = lan_saa9730_stop(lp)))
1060 goto out;
1061
1062 /* Initialize CAM registers. */
1063 if ((ret = lan_saa9730_cam_init(dev)))
1064 goto out;
1065
1066 /* Initialize MII registers. */
1067 if ((ret = lan_saa9730_mii_init(lp)))
1068 goto out;
1069
1070 /* Initialize control registers. */
1071 if ((ret = lan_saa9730_control_init(lp)))
1072 goto out;
1073
1074 /* Load CAM registers. */
1075 if ((ret = lan_saa9730_cam_load(lp)))
1076 goto out;
1077
1078 /* Initialize DMA context registers. */
1079 if ((ret = lan_saa9730_dma_init(lp)))
1080 goto out;
1081
1082 spin_lock_init(&lp->lock);
1083
1084 dev->open = lan_saa9730_open;
1085 dev->hard_start_xmit = lan_saa9730_start_xmit;
1086 dev->stop = lan_saa9730_close;
1087 dev->get_stats = lan_saa9730_get_stats;
1088 dev->set_multicast_list = lan_saa9730_set_multicast;
1089 dev->tx_timeout = lan_saa9730_tx_timeout;
1090 dev->watchdog_timeo = (HZ >> 1);
1091 dev->dma = 0;
1092
1093 ret = register_netdev(dev);
1094 if (ret)
1095 goto out;
1096 return 0;
1097
1098 out:
1099 if (dev->priv)
1100 kfree(dev->priv);
1101 return ret;
1102 }
1103
1104
1105 static int __devinit saa9730_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
1106 {
1107 struct net_device *dev;
1108 unsigned int pci_ioaddr;
1109 int err;
1110
1111 if (lan_saa9730_debug > 1)
1112 printk("saa9730.c: PCI bios is present, checking for devices...\n");
1113
1114 err = -ENOMEM;
1115 dev = alloc_etherdev(0);
1116 if (!dev)
1117 goto out;
1118
1119 SET_MODULE_OWNER(dev);
1120
1121 err = pci_enable_device(pdev);
1122 if (err) {
1123 printk(KERN_ERR "Cannot enable PCI device, aborting.\n");
1124 goto out1;
1125 }
1126
1127 err = pci_request_regions(pdev, DRV_MODULE_NAME);
1128 if (err) {
1129 printk(KERN_ERR "Cannot obtain PCI resources, aborting.\n");
1130 goto out2;
1131 }
1132
1133 pci_irq_line = pdev->irq;
1134 /* LAN base address in located at BAR 1. */
1135
1136 pci_ioaddr = pci_resource_start(pdev, 1);
1137 pci_set_master(pdev);
1138
1139 printk("Found SAA9730 (PCI) at %#x, irq %d.\n",
1140 pci_ioaddr, pci_irq_line);
1141
1142 err = lan_saa9730_init(dev, pci_ioaddr, pci_irq_line);
1143 if (err) {
1144 printk("Lan init failed");
1145 goto out2;
1146 }
1147
1148 pci_set_drvdata(pdev, dev);
1149 SET_NETDEV_DEV(dev, &pdev->dev);
1150 return 0;
1151
1152 out2:
1153 pci_disable_device(pdev);
1154 out1:
1155 free_netdev(dev);
1156 out:
1157 return err;
1158 }
1159
1160
1161 static struct pci_driver saa9730_driver = {
1162 .name = DRV_MODULE_NAME,
1163 .id_table = saa9730_pci_tbl,
1164 .probe = saa9730_init_one,
1165 .remove = __devexit_p(saa9730_remove_one),
1166 };
1167
1168
1169 static int __init saa9730_init(void)
1170 {
1171 return pci_module_init(&saa9730_driver);
1172 }
1173
1174 static void __exit saa9730_cleanup(void)
1175 {
1176 pci_unregister_driver(&saa9730_driver);
1177 }
1178
1179 module_init(saa9730_init);
1180 module_exit(saa9730_cleanup);
1181
1182
1183
1184 MODULE_LICENSE("GPL");
Verdex Pro support