drivers/net/saa9730.c

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