drivers/net/arm/p2001_eth.c

   1 /*
   2  *  linux/drivers/char/p2001_eth.c
   3  *
   4  *  Driver for P2001 ethernet unit
   5  *
   6  *  Copyright (C) 2004 Tobias Lorenz
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 /*
  24  * Version 1.0: First working version
  25  * Version 1.1: mdio ioctl calls
  26  * Version 1.2: statistics counter
  27  * Version 1.3: skbuff direct instead of buffer-copy for sending
  28  * Version 1.4: ethtool calls
  29  * Version 1.5: interrupt driven transmit with transmit buffer ring
  30  * Version 1.6: support for all interfaces with phy connected
  31  * Version 1.7: generic mii infrastructure
  32  * Version 1.8: automatic MDIO CLK calculation
  33  * Version 1.9: added request_mem_region
  34  * Version 1.10: bug fix for main isp
  35  * Version 1.11: removed all READ_REG/WRITE_REG
  36  * Version 1.12: transmit timeout, no boot via eth1
  37  * Version 1.13: initialisation fix, which results in transmission errors,
  38  *               some pings are 10 times longer than the regular ones (glitches)
  39  */
  40
  41 #include <linux/module.h>
  42 #include <linux/kernel.h>
  43 #include <linux/string.h>
  44 #include <linux/timer.h>
  45 #include <linux/errno.h>
  46 #include <linux/ioport.h>
  47 #include <linux/slab.h>
  48 #include <linux/interrupt.h>
  49 #include <linux/netdevice.h>
  50 #include <linux/init.h>
  51 #include <linux/mii.h>
  52 #include <linux/etherdevice.h>
  53 #include <linux/skbuff.h>
  54 #include <linux/delay.h>
  55 #include <linux/ethtool.h>
  56 #include <linux/crc32.h>
  57
  58 #include <asm/processor.h>      /* Processor type for cache alignment. */
  59 #include <asm/bitops.h>
  60 #include <asm/io.h>
  61 #include <asm/uaccess.h>        /* User space memory access functions */
  62
  63
  64
  65 /**************************************************************************
  66  * Definitions
  67  **************************************************************************/
  68 static const char *version =
  69         "p2001_eth.c:v1.13 10/13/2004 Tobias Lorenz (tobias.lorenz@gmx.net)\n";
  70
  71 static const char p2001_eth_name[] = "P2001 eth";
  72
  73 /* Hardware lookup table */
  74 struct {
  75         unsigned int nr;                /* ethernet unit number / dma channel number */
  76         unsigned int base_addr;         /* device I/O address */
  77         unsigned int irq;               /* device data IRQ number (error IRQ +1) */
  78         unsigned int phy_id;            /* assigned phy address */
  79         unsigned char mac_hw_addr[6];   /* fixed MAC address */
  80 } p2001_eth_dev_list[4] = {
  81         { 0, (unsigned int)P2001_EU0, IRQ_EU0_DATA, 0, {0x00,0x09,0x4F,0x00,0x00,0x02} },
  82         { 1, (unsigned int)P2001_EU1, IRQ_EU1_DATA, 1, {0x00,0x09,0x4F,0x00,0x00,0x03} },
  83         { 2, (unsigned int)P2001_EU2, IRQ_EU2_DATA, 2, {0x00,0x09,0x4F,0x00,0x00,0x04} },
  84         { 3, (unsigned int)P2001_EU3, IRQ_EU3_DATA, 3, {0x00,0x09,0x4F,0x00,0x00,0x05} },
  85 };
  86
  87 /* DMA descriptions and buffers */
  88 #define NUM_RX_DESC     16              /* Number of RX descriptor registers. */
  89 #define NUM_TX_DESC     16              /* Number of TX descriptor registers. */
  90 #define DMA_BUF_SIZE    2048            /* Buffer size */
  91
  92 /* Drivers private structure */
  93 struct p2001_eth_private {
  94         struct net_device_stats stats;
  95
  96         /* DMA descriptors and buffers */
  97         DMA_DSC rxd[NUM_RX_DESC] __attribute__ ((aligned(16)));
  98         DMA_DSC txd[NUM_TX_DESC] __attribute__ ((aligned(16)));
  99         char rxb[NUM_RX_DESC * DMA_BUF_SIZE] __attribute__ ((aligned(16)));
 100         struct sk_buff *txb[NUM_TX_DESC];
 101         /* producer/comsumer pointers for Tx/Rx ring */
 102         int cur_tx, dirty_tx;
 103         int cur_rx, dirty_rx;
 104
 105         /* Device selectors */
 106         unsigned int nr;        /* NR/DMA channel: 0..3  */
 107         char adapter_name[11];  /* P2001 ethx\0 */
 108
 109         spinlock_t lock;
 110
 111         /* The Tx queue is full. */
 112         unsigned int tx_full;
 113
 114         /* MII interface info */
 115         struct mii_if_info mii;
 116 };
 117
 118 /* mdio handling */
 119 static void mdio_hard_reset(void);
 120 static int mdio_read(struct net_device *dev, int phy_id, int location);
 121 static void mdio_write(struct net_device *dev, int phy_id, int location, int val);
 122
 123 /* net_device functions */
 124 static struct net_device_stats * p2001_eth_get_stats(struct net_device *dev);
 125 static int p2001_eth_open(struct net_device *dev);
 126 static int p2001_eth_stop(struct net_device *dev);
 127 static int p2001_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *dev);
 128 static void p2001_eth_tx_timeout(struct net_device *dev);
 129 static int p2001_eth_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 130
 131 /* interrupt routines */
 132 static irqreturn_t p2001_eth_data_interrupt(int irq, struct net_device *dev, struct pt_regs *regs);
 133 static irqreturn_t p2001_eth_error_interrupt(int irq, struct net_device *dev, struct pt_regs *regs);
 134
 135 /* ethtool ops */
 136 static struct ethtool_ops p2001_eth_ethtool_ops;
 137
 138 /* driver functions (pci_driver, isa_driver) */
 139 struct net_device * __init p2001_eth_probe(int unit);
 140 static void __devexit p2001_eth_remove(struct net_device *dev);
 141
 142
 143
 144 /**************************************************************************
 145  * PHY MANAGEMENT UNIT - Read/write
 146  **************************************************************************/
 147
 148 /**
 149  *      mdio_hard_reset - hardware reset all MII PHYs and set MDIO CLK
 150  */
 151 static void mdio_hard_reset()
 152 {
 153         /* GPIO24/25: TX_ER2/TX_ER0 */
 154         /* GPIO26/27: PHY_RESET/TX_ER1 */
 155         P2001_GPIO->PIN_MUX |= 0x0018;
 156         // 31-16: 0000 1111 0000 0000
 157         P2001_GPIO->GPIO2_En |= 0x0400;
 158
 159         P2001_GPIO->GPIO2_Out |= 0x04000000;
 160         P2001_GPIO->GPIO2_Out &= ~0x0400;
 161         mdelay(500);
 162         P2001_GPIO->GPIO2_Out |= 0x0400;
 163
 164         /* set management unit clock divisor */
 165         // max. MDIO CLK = 2.048 MHz (EU.doc)
 166         // max. MDIO CLK = 8.000 MHz (LXT971A)
 167         // sysclk/(2*(n+1)) = MDIO CLK <= 2.048 MHz
 168         // n >= sysclk/4.096 MHz - 1
 169         P2001_MU->MU_DIV = (CONFIG_SYSCLK/4096000)-1;   // 2.048 MHz
 170         //asm("nop \n nop");
 171 }
 172
 173
 174 /**
 175  *      mdio_read - read MII PHY register
 176  *      @dev: the net device to read
 177  *      @regadr: the phy register id to read
 178  *
 179  *      Read MII registers through MDIO and MDC
 180  *      using MDIO management frame structure and protocol(defined by ISO/IEC).
 181  */
 182 static int mdio_read(struct net_device *dev, int phy_id, int location)
 183 {
 184         do {
 185                 /* Warten bis Hardware inaktiv (MIU = "0") */
 186                 while (P2001_MU->MU_CNTL & 0x8000)
 187                         barrier();
 188
 189                 /* Schreiben MU_CNTL */
 190                 P2001_MU->MU_CNTL = location + (phy_id<<5) + (2<<10);
 191
 192                 /* Warten bis Hardware aktiv (MIU = "1") */
 193                 while ((P2001_MU->MU_CNTL & 0x8000) == 0)
 194                         barrier();
 195                 //asm("nop \r\n nop");
 196
 197                 /* Warten bis Hardware inaktiv (MIU = "0") */
 198                 while (P2001_MU->MU_CNTL & 0x8000)
 199                         barrier();
 200
 201                 /* Fehler, wenn MDIO Read Error (MRE = "1") */
 202         } while (P2001_MU->MU_CNTL & 0x4000);
 203
 204         /* Lesen MU_DATA */
 205         return P2001_MU->MU_DATA;
 206 }
 207
 208
 209 /**
 210  *      mdio_write - write MII PHY register
 211  *      @dev: the net device to write
 212  *      @regadr: the phy regiester id to write
 213  *      @value: the register value to write with
 214  *
 215  *      Write MII registers with @value through MDIO and MDC
 216  *      using MDIO management frame structure and protocol(defined by ISO/IEC)
 217  */
 218 static void mdio_write(struct net_device *dev, int phy_id, int location, int val)
 219 {
 220         /* Warten bis Hardware inaktiv (MIU = "0") */
 221         while (P2001_MU->MU_CNTL & 0x8000)
 222                 barrier();
 223
 224         /* Schreiben MU_DATA */
 225         P2001_MU->MU_DATA = val;
 226
 227         /* Schreiben MU_CNTL */
 228         P2001_MU->MU_CNTL = location + (phy_id<<5) + (1<<10);
 229
 230         /* Warten bis Hardware aktiv (MIU = "1") */
 231         while ((P2001_MU->MU_CNTL & 0x8000) == 0)
 232                 barrier();
 233         //asm("nop \r\n nop");
 234
 235         /* Warten bis Hardware inaktiv (MIU = "0") */
 236         while (P2001_MU->MU_CNTL & 0x8000)
 237                 barrier();
 238 }
 239
 240
 241 //      mdio_write(dev, priv->mii.phy_id, MII_BMCR, BMCR_RESET);
 242
 243
 244
 245 /**************************************************************************
 246  * GET_STATS - Get read/write statistics
 247  **************************************************************************/
 248
 249 /**
 250  *      p2001_eth_get_stats - Get p2001 read/write statistics
 251  *      @dev: the net device to get statistics for
 252  *
 253  *      get tx/rx statistics for p2001
 254  */
 255 static struct net_device_stats * p2001_eth_get_stats(struct net_device *dev)
 256 {
 257         struct p2001_eth_private *priv = dev->priv;
 258
 259         return &priv->stats;
 260 }
 261
 262
 263
 264 /**************************************************************************
 265  * OPEN - Open network device
 266  **************************************************************************/
 267
 268 /**
 269  *      p2001_eth_open - open p2001 ethernet device
 270  *      @dev: the net device to open
 271  *
 272  *      Do some initialization and start net interface.
 273  *      enable interrupts and set timer.
 274  */
 275 static int p2001_eth_open(struct net_device *dev)
 276 {
 277         struct p2001_eth_private *priv = dev->priv;
 278         P2001_ETH_regs_ptr EU = (P2001_ETH_regs_ptr) dev->base_addr;
 279         int i, ret;
 280
 281 //      printk("%s: p2001_eth_open\n", dev->name);
 282
 283         /* request data and error interrupts */
 284         ret = request_irq(dev->irq, (void *) &p2001_eth_data_interrupt, 0, dev->name, dev);
 285         if (ret)
 286                 return ret;
 287         ret = request_irq(dev->irq+1, (void *) &p2001_eth_error_interrupt, 0, dev->name, dev);
 288         if (ret)
 289                 return ret;
 290
 291         /* set rx filter (physical mac address) */
 292         EU->RMAC_PHYU =
 293                 (dev->dev_addr[0]<< 8) +
 294                 (dev->dev_addr[1]<< 0);
 295         EU->RMAC_PHYL =
 296                 (dev->dev_addr[2]<<24) +
 297                 (dev->dev_addr[3]<<16) +
 298                 (dev->dev_addr[4]<<8 ) +
 299                 (dev->dev_addr[5]<<0 );
 300
 301         /* initialize the tx descriptor ring */
 302         priv->tx_full = 0;
 303         priv->cur_tx = 0;
 304         priv->dirty_tx = 0;
 305         for (i = 0; i < NUM_TX_DESC; i++) {
 306                 priv->txd[i].stat = 0;                                  // DSC0
 307                 priv->txd[i].cntl = 0;                                  // DSC1
 308                 priv->txd[i].buf = 0;                                   // DSC2 BUFFER (EU-TX data)
 309                 priv->txd[i].next = &priv->txd[(i+1) % NUM_TX_DESC];    // DSC3 NEXTDSC @next/@first
 310         }
 311         EU->TMAC_DMA_DESC = &priv->txd[0];
 312
 313         /* initialize the rx descriptor ring */
 314         priv->cur_rx = 0;
 315         priv->dirty_rx = 0;
 316         for (i = 0; i < NUM_RX_DESC; i++) {
 317                 priv->rxd[i].stat = (1<<31) | (1<<30) | (1<<29);        // DSC0 OWN|START|END
 318                 priv->rxd[i].cntl = (1<<30) | (1<<23);                  // DSC1 INT|RECEIVE
 319                 priv->rxd[i].cntl |= priv->nr << 16;                    // DSC1 CHANNEL
 320                 priv->rxd[i].cntl |= DMA_BUF_SIZE;                      // DSC1 LEN
 321                 priv->rxd[i].buf = &priv->rxb[i*DMA_BUF_SIZE];          // DSC2 BUFFER (EU-RX data)
 322                 priv->rxd[i].next = &priv->rxd[(i+1) % NUM_RX_DESC];    // DSC3 NEXTDSC @next/@first
 323         }
 324         EU->RMAC_DMA_DESC = &priv->rxd[0];
 325
 326         /* set transmitter mode */
 327         EU->TMAC_CNTL = (1<<4) |        /* COI: Collision ignore */
 328                         //(1<<3) |      /* CSI: Carrier Sense ignore */
 329                         (1<<2);         /* ATP: Automatic Transmit Padding */
 330
 331         /* set receive mode */
 332         EU->RMAC_CNTL = (1<<3) |        /* BROAD: Broadcast packets */
 333                         (1<<1);         /* PHY  : Packets to out MAC address */
 334
 335         /* enable receiver */
 336         EU->RMAC_DMA_EN = 1;
 337
 338         netif_start_queue(dev);
 339
 340         return 0;
 341 }
 342
 343
 344
 345 /**************************************************************************
 346  * STOP - Close network device
 347  **************************************************************************/
 348
 349 /**
 350  *      p2001_eth_stop - close p2001 ethernet device
 351  *      @dev: the net device to be closed
 352  *
 353  *      Disable interrupts, stop the Tx and Rx Status Machine
 354  *      free Tx and RX socket buffer
 355  */
 356 static int p2001_eth_stop(struct net_device *dev)
 357 {
 358         struct p2001_eth_private *priv = dev->priv;
 359         P2001_ETH_regs_ptr EU = (P2001_ETH_regs_ptr) dev->base_addr;
 360         struct sk_buff *skb;
 361         unsigned int i;
 362
 363 //      printk("%s: p2001_eth_stop\n", dev->name);
 364
 365         netif_stop_queue(dev);
 366
 367         /* Stop the chip's Tx and Rx Status Machine */
 368         EU->TMAC_DMA_EN = 0;
 369         EU->RMAC_DMA_EN = 0;
 370
 371         free_irq(dev->irq, dev);
 372         free_irq(dev->irq+1, dev);
 373
 374         /* Free Tx skbuff */
 375         for (i = 0; i < NUM_TX_DESC; i++) {
 376                 skb = priv->txb[i];
 377                 if (skb) {
 378                         dev_kfree_skb(skb);
 379                         priv->txb[i] = 0;
 380                 }
 381         }
 382
 383
 384         /* Green! Put the chip in low-power mode. */
 385
 386         return 0;
 387 }
 388
 389
 390
 391 /**************************************************************************
 392  * HARD START XMIT - Force start sending packets
 393  **************************************************************************/
 394
 395 /**
 396  *      p2001_eth_hard_start_xmit - start transmit routine
 397  *      @skb: socket buffer pointer to put the data being transmitted
 398  *      @dev: the net device to transmit with
 399  *
 400  *      Set the transmit buffer descriptor,
 401  *      and write TxENA to enable transmit state machine.
 402  *      tell upper layer if the buffer is full
 403  */
 404 static int p2001_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 405 {
 406         struct p2001_eth_private *priv = dev->priv;
 407         P2001_ETH_regs_ptr EU = (P2001_ETH_regs_ptr) dev->base_addr;
 408         unsigned int entry;
 409         unsigned long flags;
 410         unsigned int index_cur_tx, index_dirty_tx;
 411         unsigned int count_dirty_tx;
 412
 413         spin_lock_irqsave(&priv->lock, flags);
 414         EU->TMAC_DMA_EN   = 0;          /* clear run bit */
 415
 416 //      printk("%s: p2001_eth_hard_start_xmit: size=%d\n", dev->name, skb->len);
 417
 418         /* Calculate the next Tx descriptor entry. */
 419         entry = priv->cur_tx % NUM_TX_DESC;
 420         priv->txb[entry] = skb;
 421
 422         /* set the transmit buffer descriptor and enable Transmit State Machine */
 423         priv->txd[entry].stat = (1<<31) | (1<<30) | (1<<29);    // DSC0 OWN|START|END
 424         priv->txd[entry].cntl = priv->nr << 16;                 // DSC1 CHANNEL
 425         priv->txd[entry].cntl |= (1<<30);                       // DSC1 INT
 426         priv->txd[entry].cntl |= skb->len;                      // DSC1 LEN
 427         priv->txd[entry].buf = skb->data;                       // DSC2 BUFFER (EU-TX data)
 428
 429         priv->cur_tx++;
 430         index_cur_tx = priv->cur_tx;
 431         index_dirty_tx = priv->dirty_tx;
 432
 433         for (count_dirty_tx = 0; index_cur_tx != index_dirty_tx; index_dirty_tx++)
 434                 count_dirty_tx++;
 435
 436 //      printk("%s: entry=%d, cur_tx=%d, dirty_tx=%d, count_dirty_tx=%d\n", dev->name,
 437 //              entry, priv->cur_tx % NUM_TX_DESC, priv->dirty_tx % NUM_TX_DESC, count_dirty_tx);
 438
 439         EU->TMAC_DMA_DESC = &priv->txd[priv->dirty_tx % NUM_TX_DESC];
 440
 441         EU->TMAC_DMA_EN   = 1;          /* set run bit */
 442         spin_unlock_irqrestore(&priv->lock, flags);
 443
 444         dev->trans_start = jiffies;
 445
 446 //      printk(KERN_INFO "%s: Queued Tx packet at %p size %d to slot %d.\n",
 447 //              dev->name, skb->data, (int)skb->len, entry);
 448
 449         return 0;
 450 }
 451
 452
 453
 454 /**************************************************************************
 455  * DO_IOCTL - Process MII i/o control command
 456  **************************************************************************/
 457
 458 /**
 459  *      p2001_eth_do_ioctl - process MII i/o control command
 460  *      @dev: the net device to command for
 461  *      @rq: parameter for command
 462  *      @cmd: the i/o command
 463  *
 464  *      Process MII command like read/write MII register
 465  */
 466 static int p2001_eth_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 467 {
 468         struct p2001_eth_private *priv = dev->priv;
 469         struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;
 470
 471         return generic_mii_ioctl(&priv->mii, data, cmd, NULL);
 472 }
 473
 474
 475
 476 /**************************************************************************
 477  * TX_TIMEOUT - Transmit timeout routine
 478  **************************************************************************/
 479
 480 /**
 481  *      p2001_eth_tx_timeout - transmit timeout routine
 482  *      @dev: the net device to command for
 483  *
 484  *      print transmit timeout status
 485  *      disable interrupts and do some tasks
 486  */
 487 static void p2001_eth_tx_timeout(struct net_device *dev)
 488 {
 489 //      struct p2001_eth_private *priv = dev->priv;
 490
 491         printk(KERN_INFO "%s: Transmit timeout\n", dev->name);
 492 }
 493
 494
 495
 496 /**************************************************************************
 497  * TX - interrupt transmit routine
 498  **************************************************************************/
 499
 500 /**
 501  *      p2001_eth_tx - finish up transmission of packets
 502  *      @net_dev: the net device to be transmitted on
 503  *
 504  *      Check for error condition and free socket buffer etc
 505  *      schedule for more transmission as needed
 506  *      Note: This fucntion is called by interrupt handler,
 507  *      don't do "too much" work here
 508  */
 509
 510 static void p2001_eth_tx(struct net_device *dev)
 511 {
 512         struct p2001_eth_private *priv = dev->priv;
 513         P2001_ETH_regs_ptr EU = (P2001_ETH_regs_ptr) dev->base_addr;
 514         unsigned int index_cur_tx, index_dirty_tx;
 515         unsigned int count_dirty_tx;
 516
 517 //      printk("%s: p2001_eth_tx\n", dev->name);
 518         for (; priv->dirty_tx != priv->cur_tx; priv->dirty_tx++) {
 519                 struct sk_buff *skb;
 520                 unsigned int entry;
 521                 unsigned int status;
 522
 523                 entry = priv->dirty_tx % NUM_TX_DESC;
 524                 status = priv->txd[entry].stat;
 525
 526                 if (status & (1<<31)) { // OWN
 527                         /* The packet is not transmitted yet (owned by hardware) !
 528                            Note: the interrupt is generated only when Tx Machine
 529                            is idle, so this is an almost impossible case */
 530 //                      printk("%s: p2001_eth_tx: nothing more to do\n", dev->name);
 531                         break;
 532                 }
 533
 534 //              if (status & 0x0000000f) {      // CRS|ED|OWC|EC
 535                 if (status & 0x00000007) {      // ED|OWC|EC
 536                         /* packet unsuccessfully transmitted */
 537                         printk("%s: Transmit error, Tx status %8.8x.\n", dev->name, status);
 538                         priv->stats.tx_errors++;
 539 //                      if (status & (1<<3))    // CRS
 540 //                              priv->stats.tx_carrier_errors++;
 541                         if (status & (1<<1))    // OWC
 542                                 priv->stats.tx_window_errors++;
 543                 } else {
 544                         /* packet successfully transmitted */
 545 //                      printk("%s: p2001_eth_tx: success\n", dev->name);
 546                         priv->stats.collisions += (status & 0x00000f00) >> 8;
 547                         priv->stats.tx_bytes += priv->txd[entry].cntl & 0xffff;
 548                         priv->stats.tx_packets++;
 549                 }
 550                 /* Free the original skb. */
 551                 skb = priv->txb[entry];
 552                 dev_kfree_skb_irq(skb);
 553                 priv->txb[entry] = 0;
 554                 priv->txd[entry].stat = 0;      // DSC0
 555                 priv->txd[entry].cntl = 0;      // DSC1
 556                 priv->txd[entry].buf = 0;       // DSC2 BUFFER (EU-TX data)
 557         }
 558
 559         if (priv->tx_full && netif_queue_stopped(dev)) {
 560                 index_cur_tx = priv->cur_tx;
 561                 index_dirty_tx = priv->dirty_tx;
 562
 563                 for (count_dirty_tx = 0; index_cur_tx != index_dirty_tx; index_dirty_tx++)
 564                         count_dirty_tx++;
 565
 566                 if (count_dirty_tx < NUM_TX_DESC - 4) {
 567                         /* The ring is no longer full, clear tx_full and
 568                            schedule more transmissions by netif_wake_queue(dev) */
 569                         priv->tx_full = 0;
 570                         netif_wake_queue(dev);
 571                 }
 572         }
 573
 574         EU->TMAC_DMA_STAT |= (1<<8);
 575 }
 576
 577
 578
 579 /**************************************************************************
 580  * RX - interrupt receive routine
 581  **************************************************************************/
 582
 583 /**
 584  *      p2001_eth_rx - p2001_eth receive routine
 585  *      @dev: the net device which receives data
 586  *
 587  *      Process receive interrupt events,
 588  *      put buffer to higher layer and refill buffer pool
 589  *      Note: This fucntion is called by interrupt handler,
 590  *      don't do "too much" work here
 591  */
 592 static void p2001_eth_rx(struct net_device *dev)
 593 {
 594         struct p2001_eth_private *priv = dev->priv;
 595         P2001_ETH_regs_ptr EU = (P2001_ETH_regs_ptr) dev->base_addr;
 596         unsigned int entry;
 597         unsigned int status;
 598         struct sk_buff *skb;
 599         unsigned int pkt_len;
 600
 601 //      printk("%s: p2001_eth_rx\n", dev->name);
 602         while(1) {
 603                 entry = priv->cur_rx % NUM_RX_DESC;
 604                 status = priv->rxd[entry].stat;
 605                 if (status & (1<<31))
 606                         break;
 607
 608                 if (status & 0x07c00000) {      // NOBYTE|CRCERR|COL|ISE|ILEN
 609                         /* corrupted packet received */
 610                         printk(KERN_INFO "%s: Corrupted packet "
 611                                "received, buffer status = 0x%8.8x.\n",
 612                                dev->name, status);
 613                         priv->stats.rx_errors++;
 614                 } else {
 615                         /* give the socket buffer to the upper layers */
 616                         pkt_len = priv->rxd[entry].cntl & 0xffff;
 617                         skb = dev_alloc_skb(pkt_len);
 618                         if (skb == NULL) {
 619                                 printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
 620                                 break;
 621                         }
 622
 623                         skb->dev = dev;
 624                         skb_reserve(skb, 2);    /* 16 byte align the IP fields. */
 625
 626                         eth_copy_and_sum(skb, priv->rxd[entry].buf, pkt_len, 0);
 627                         skb_put(skb, pkt_len);
 628
 629                         skb->protocol = eth_type_trans(skb, dev);
 630                         netif_rx(skb);
 631
 632                         /* some network statistics */
 633                         dev->last_rx = jiffies;
 634                         priv->stats.rx_bytes += pkt_len;
 635                         priv->stats.rx_packets++;
 636                 }
 637
 638                 /* disable receiver */
 639                 // FIXME: is that ok? it can produce grave errors.
 640                 EU->RMAC_DMA_EN = 0;                    /* clear run bit */
 641                 EU->RMAC_DMA_STAT = EU->RMAC_DMA_STAT;
 642
 643                 /* return the descriptor and buffer to receive ring */
 644                 priv->rxd[entry].stat = (1<<31) | (1<<30) | (1<<29);    // DSC0 OWN|START|END
 645                 priv->rxd[entry].cntl = (1<<30) | (1<<23);              // DSC1 INT|RECEIVE
 646                 priv->rxd[entry].cntl |= priv->nr << 16;                // DSC1 CHANNEL
 647                 priv->rxd[entry].cntl |= DMA_BUF_SIZE;                  // DSC1 LEN
 648
 649                 /* enable receiver */
 650                 EU->RMAC_DMA_EN = 0x01;                 /* set run bit */
 651
 652                 priv->cur_rx++;
 653         }
 654 }
 655
 656
 657
 658 /**************************************************************************
 659  * INTERRUPT - Interrupt routines
 660  **************************************************************************/
 661
 662 /**
 663  *      p2001_eth_data_interrupt - p2001_eth data interrupt handler
 664  *      @irq: the irq number
 665  *      @dev: the client data object
 666  *      @regs: snapshot of processor context
 667  *
 668  *      The interrupt handler does all of the Rx thread work,
 669  *      and cleans up after the Tx thread
 670  */
 671 static irqreturn_t p2001_eth_data_interrupt(int irq, struct net_device *dev, struct pt_regs *regs)
 672 {
 673         struct p2001_eth_private *priv = dev->priv;
 674         P2001_ETH_regs_ptr EU = (P2001_ETH_regs_ptr) dev->base_addr;
 675         int boguscnt = 10;      // max_interrupt_work
 676         unsigned int handled = 0;
 677         unsigned int rx_status;
 678         unsigned int tx_status;
 679
 680 //      printk("%s: p2001_eth_data_interrupt: start\n", dev->name);
 681
 682         spin_lock(&priv->lock);
 683
 684         do {
 685                 /* Rx interrupt */
 686                 rx_status = EU->RMAC_DMA_STAT;
 687                 if (rx_status & (1<<8)) {
 688                         // usally there is only one interrupt for multiple receives
 689                         p2001_eth_rx(dev);
 690                         handled = 1;
 691                 }
 692
 693                 /* Tx interrupt */
 694                 tx_status = EU->TMAC_DMA_STAT;
 695                 if (tx_status & (1<<8)) {
 696                         // usally there is only one interrupt for multiple transmits
 697                         p2001_eth_tx(dev);
 698                         handled = 1;
 699                 }
 700         } while (--boguscnt && ((rx_status & (1<<8)) | (tx_status & (1<<8))));
 701
 702         if (!handled) {
 703                 printk(KERN_INFO "%s: p2001_eth_data_interrupt: interrupt not handled\n",
 704                         dev->name);
 705                 printk(KERN_INFO "%s: p2001_eth_data_interrupt: (rx=%#8.8x tx=%#8.8x)\n",
 706                         dev->name, rx_status, tx_status);
 707                 handled = 1;
 708         }
 709
 710         spin_unlock(&priv->lock);
 711         return IRQ_RETVAL(handled);
 712 }
 713
 714
 715 /**
 716  *      p2001_eth_error_interrupt - p2001_eth error interrupt handler
 717  *      @irq: the irq number
 718  *      @dev: the client data object
 719  *      @regs: snapshot of processor context
 720  *
 721  *      The interrupt handler does all error tasks
 722  */
 723 static irqreturn_t p2001_eth_error_interrupt(int irq, struct net_device *dev, struct pt_regs *regs)
 724 {
 725         struct p2001_eth_private *priv = dev->priv;
 726         P2001_ETH_regs_ptr EU = (P2001_ETH_regs_ptr) dev->base_addr;
 727         unsigned int handled = 1;
 728
 729         spin_lock(&priv->lock);
 730         if (EU->RMAC_DMA_STAT) {
 731                 printk("%s: p2001_eth_error_interrupt: rmac_dma_stat=%#8.8x\n", dev->name, EU->RMAC_DMA_STAT);
 732                 EU->RMAC_DMA_STAT |= (1<<7);
 733         }
 734         if (EU->TMAC_DMA_STAT) {
 735                 printk("%s: p2001_eth_error_interrupt: tmac_dma_stat=%#8.8x\n", dev->name, EU->TMAC_DMA_STAT);
 736                 EU->TMAC_DMA_STAT |= (1<<7);
 737         }
 738         spin_unlock(&priv->lock);
 739         return IRQ_RETVAL(handled);
 740 }
 741
 742
 743
 744 /**************************************************************************
 745  * PROBE - Look for an adapter, this routine's visible to the outside
 746  **************************************************************************/
 747
 748 /**
 749  *      p2001_eth_probe - Probe for p2001 ethernet device
 750  *      @unit: the p2001 ethernet unit number
 751  *
 752  *      Check and probe for p2001 net device.
 753  *      Get mac address and assign p2001-specific entries in the device structure.
 754  */
 755 struct net_device * __init p2001_eth_probe(int unit)
 756 {
 757         struct net_device *dev;
 758         struct p2001_eth_private *priv;
 759         int i, err;
 760
 761         dev = alloc_etherdev(sizeof(struct p2001_eth_private));
 762         if (!dev)
 763                 return ERR_PTR(-ENOMEM);
 764         SET_MODULE_OWNER(dev);
 765
 766         /* Configure unit specific variables */
 767         priv = dev->priv;
 768         dev->base_addr = p2001_eth_dev_list[unit].base_addr;
 769         dev->irq       = p2001_eth_dev_list[unit].irq;
 770         priv->nr       = p2001_eth_dev_list[unit].nr;
 771         sprintf(priv->adapter_name, "%s%i", p2001_eth_name, unit);
 772         request_mem_region(dev->base_addr, 0x1000, priv->adapter_name);
 773         spin_lock_init(&priv->lock);
 774
 775         /* The p2001_eth-specific entries in the device structure. */
 776         // init
 777         dev->get_stats          = &p2001_eth_get_stats;
 778         // get_wireless_stats
 779         dev->ethtool_ops        = &p2001_eth_ethtool_ops;
 780         // uninit
 781         // destructor
 782         dev->open               = &p2001_eth_open;
 783         dev->stop               = &p2001_eth_stop;
 784         dev->hard_start_xmit    = &p2001_eth_hard_start_xmit;
 785         // poll
 786         // hard_header
 787         // rebuild_header
 788         // set_multicast_list
 789         // set_mac_address
 790         dev->do_ioctl           = &p2001_eth_do_ioctl;
 791         // set_config
 792         // hard_header_cache
 793         // header_cache_update
 794         // change_mtu
 795         dev->tx_timeout         = &p2001_eth_tx_timeout;
 796         // vlan_rx_register
 797         // vlan_rx_add_vid
 798         // vlan_rx_kill_vid
 799         // hard_header_parse
 800         // neigh_setup
 801         // accept_fastpath
 802         // poll_controller
 803         // last_stats
 804         ether_setup(dev);
 805
 806         err = register_netdev(dev);
 807         if (err)
 808                 goto err_out;
 809 //      printk("%s: p2001_eth_probe\n", dev->name);
 810
 811         /* Set MAC filter */
 812         memcpy(dev->dev_addr, p2001_eth_dev_list[unit].mac_hw_addr, ETH_ALEN);
 813         //random_ether_addr(dev->dev_addr);
 814
 815         /* MII setup */
 816         priv->mii.phy_id = p2001_eth_dev_list[unit].phy_id;
 817         priv->mii.phy_id_mask = 0x1F;
 818         priv->mii.reg_num_mask = 0x1F;
 819         priv->mii.dev = dev;
 820         priv->mii.mdio_read = mdio_read;
 821         priv->mii.mdio_write = mdio_write;
 822
 823         /* print some information about our NIC */
 824         printk(KERN_INFO "%s: ADDR %#lx, IRQ %d/%d, MAC ", dev->name, dev->base_addr, dev->irq, dev->irq+1);
 825         for (i = 0; i < 5; i++)
 826                 printk("%2.2x:", (u8)dev->dev_addr[i]);
 827         printk("%2.2x.\n", dev->dev_addr[i]);
 828
 829         printk(KERN_INFO "%s: phy_addr = %d\n", dev->name, priv->mii.phy_id);
 830         printk(KERN_INFO "%s: phy ID = 0x%08x\n", dev->name,
 831                 (mdio_read(dev, priv->mii.phy_id, MII_PHYSID2) << 16) |
 832                  mdio_read(dev, priv->mii.phy_id, MII_PHYSID1));
 833
 834         netif_carrier_on(dev);
 835
 836         return dev;
 837
 838 //err_out_unregister:
 839 //      unregister_netdev(dev);
 840 err_out:
 841         release_mem_region(dev->base_addr, 0x1000);
 842         free_netdev(dev);
 843         return ERR_PTR(err);
 844 }
 845
 846
 847
 848 /**************************************************************************
 849  * REMOVE - Remove an adapter, this routine's visible to the outside
 850  **************************************************************************/
 851
 852 static void __devexit p2001_eth_remove(struct net_device *dev)
 853 {
 854 //      printk("%s: p2001_eth_remove\n", dev->name);
 855 }
 856
 857
 858
 859 /**************************************************************************
 860  * GET_DRVINFO - Return information about driver
 861  **************************************************************************/
 862
 863 /**
 864  *      p2001_eth_get_drvinfo - Return information about driver
 865  *      @dev: the net device to probe
 866  *      @info: container for info returned
 867  *
 868  *      Process ethtool command such as "ethtool -i" to show information
 869  */
 870 static void p2001_eth_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 871 {
 872         strcpy(info->driver, p2001_eth_name);
 873         strcpy(info->version, version);
 874         sprintf(info->bus_info, "ADDR 0x%lx", dev->base_addr);
 875 }
 876
 877 static struct ethtool_ops p2001_eth_ethtool_ops = {
 878         .get_drvinfo =          p2001_eth_get_drvinfo,
 879 };
 880
 881
 882
 883 /**************************************************************************
 884  * Module functions
 885  **************************************************************************/
 886 static struct net_device *p2001_eth_dev[4];
 887
 888 /**
 889  * init_module:
 890  *
 891  * When the driver is loaded as a module this function is called. We fake up
 892  * a device structure with the base I/O and interrupt set as if it were being
 893  * called from Space.c. This minimises the extra code that would otherwise
 894  * be required.
 895  *
 896  * Returns 0 for success or -EIO if a card is not found. Returning an error
 897  * here also causes the module to be unloaded
 898  */
 899 static int __init p2001_eth_init_module(void)
 900 {
 901         int i;
 902
 903 //      printk("p2001_eth_init_module\n");
 904         printk(version);
 905         mdio_hard_reset();
 906
 907 //      for (i = 0; i < 4; i++) {
 908         for (i = 0; i < 2; i++) {
 909                 p2001_eth_dev[i] = p2001_eth_probe(i);
 910                 if (!p2001_eth_dev[i])
 911                         return (unsigned int)p2001_eth_dev[i];
 912         }
 913
 914         return 0;
 915 }
 916
 917
 918 /**
 919  * cleanup_module:
 920  *
 921  * The module is being unloaded. We unhook our network device from the system
 922  * and then free up the resources we took when the card was found.
 923  */
 924 static void __exit p2001_eth_cleanup_module(void)
 925 {
 926 //      printk("p2001_eth_cleanup_module\n");
 927 }
 928
 929 module_init(p2001_eth_init_module);
 930 module_exit(p2001_eth_cleanup_module);
 931
 932 MODULE_AUTHOR("Tobias Lorenz");
 933 MODULE_DESCRIPTION("P2001 ethernet unit driver");
 934 MODULE_LICENSE("GPL");