palacios/src/devices/ne2k.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2009, Lei Xia <lxia@northwestern.edu>
  11  * Copyright (c) 2009, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Lei Xia <lxia@northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20 /*
  21 * Virtual NE2K Network Card
  22 */
  23
  24 #include <devices/pci.h>
  25 #include <devices/ne2k.h>
  26 #include <palacios/vmm.h>
  27 #include <palacios/vmm_types.h>
  28 #include <palacios/vmm_io.h>
  29 #include <palacios/vmm_debug.h>
  30 #include <palacios/vmm_string.h>
  31
  32 #ifndef DEBUG_NE2K
  33 #undef PrintDebug
  34 #define PrintDebug(fmts, args...)
  35 #endif
  36
  37
  38
  39
  40 #define NE2K_DEFAULT_IRQ        11
  41
  42 #define MAX_ETH_FRAME_SIZE      1514
  43
  44
  45 // What the hell is this crap?
  46 #define NE2K_PMEM_SIZE          (32 * 1024)
  47 #define NE2K_PMEM_START         (16 * 1024)
  48 #define NE2K_PMEM_END           (NE2K_PMEM_SIZE + NE2K_PMEM_START)
  49 #define NE2K_MEM_SIZE           NE2K_PMEM_END
  50
  51 #define NIC_REG_BASE_PORT       0xc100          //Command register (for all pages)
  52 #define NIC_DATA_PORT           0xc110          //Data read/write port
  53 #define NIC_RESET_PORT          0xc11f          //Data read/write port
  54
  55 // Page 0 registers
  56 #define EN0_CLDALO              0x01    //Low byte of current local dma addr  RD
  57 #define EN0_STARTPG             0x01    //Starting page of ring bfr WR
  58 #define EN0_CLDAHI              0x02    //High byte of current local dma addr  RD
  59 #define EN0_STOPPG              0x02    //Ending page +1 of ring bfr WR
  60 #define EN0_BOUNDARY            0x03    //Boundary page of ring bfr RD WR
  61 #define EN0_TSR                 0x04    //Transmit status reg RD
  62 #define EN0_TPSR                0x04    //Transmit starting page WR
  63 #define EN0_NCR                 0x05    //Number of collision reg RD
  64 #define EN0_TCNTLO              0x05    //Low  byte of tx byte count WR
  65 #define EN0_FIFO                0x06    //FIFO RD
  66 #define EN0_TCNTHI              0x06    //High byte of tx byte count WR
  67 #define EN0_ISR                 0x07    //Interrupt status reg RD WR
  68 #define EN0_CRDALO              0x08    //low byte of current remote dma address RD
  69 #define EN0_RSARLO              0x08    //Remote start address reg 0
  70 #define EN0_CRDAHI              0x09    //high byte, current remote dma address RD
  71 #define EN0_RSARHI              0x09    //Remote start address reg 1
  72 #define EN0_RCNTLO              0x0a    //Remote byte count reg WR
  73 #define EN0_RTL8029ID0          0x0a    //Realtek ID byte #1 RD
  74 #define EN0_RCNTHI              0x0b    //Remote byte count reg WR
  75 #define EN0_RTL8029ID1          0x0b    //Realtek ID byte #2 RD
  76 #define EN0_RSR                 0x0c    //rx status reg RD
  77 #define EN0_RXCR                0x0c    //RX configuration reg WR
  78 #define EN0_TXCR                0x0d    //TX configuration reg WR
  79 #define EN0_COUNTER0            0x0d    //Rcv alignment error counter RD
  80 #define EN0_DCFG                0x0e    //Data configuration reg WR
  81 #define EN0_COUNTER1            0x0e    //Rcv CRC error counter RD
  82 #define EN0_IMR                 0x0f    //Interrupt mask reg WR
  83 #define EN0_COUNTER2            0x0f    //Rcv missed frame error counter RD
  84
  85 //Page 1 registers
  86 #define EN1_PHYS                0x01
  87 #define EN1_CURPAG              0x07
  88 #define EN1_MULT                0x08
  89
  90 //Page 2 registers
  91 #define EN2_STARTPG             0x01    //Starting page of ring bfr RD
  92 #define EN2_STOPPG              0x02    //Ending page +1 of ring bfr RD
  93 #define EN2_LDMA0               0x01    //Current Local DMA Address 0 WR
  94 #define EN2_LDMA1               0x02    //Current Local DMA Address 1 WR
  95 #define EN2_RNPR                0x03    //Remote Next Packet Pointer RD WR
  96 #define EN2_TPSR                0x04            //Transmit Page Start Address RD
  97 #define EN2_LNRP                0x05    //Local Next Packet Pointer RD WR
  98 #define EN2_ACNT0               0x06    //Address Counter Upper WR
  99 #define EN2_ACNT1               0x07    //Address Counter Lower WR
 100 #define EN2_RCR                 0x0c    //Receive Configuration Register RD
 101 #define EN2_TCR                 0x0d    //Transmit Configuration Register RD
 102 #define EN2_DCR                 0x0e    //Data Configuration Register RD
 103 #define EN2_IMR                 0x0f    //Interrupt Mask Register RD
 104
 105 //Page 3 registers
 106 #define EN3_CONFIG0             0x03
 107 #define EN3_CONFIG1             0x04
 108 #define EN3_CONFIG2             0x05
 109 #define EN3_CONFIG3             0x06
 110
 111
 112
 113 typedef enum {NIC_READY, NIC_REG_POSTED} nic_state_t;
 114
 115 struct cmd_reg {
 116     union {
 117         uint8_t val;
 118         struct {
 119             uint8_t stop        : 1;
 120             uint8_t start       : 1;
 121             uint8_t tx_pkt      : 1;
 122             uint8_t rem_dma_cmd : 3; // 0=Not allowed, 1=Read, 2=Write, 3=Send Pkt, 4=Abort/Complete DMA
 123             uint8_t pg_sel      : 2;
 124         } __attribute__((packed));
 125     } __attribute__((packed));
 126 } __attribute__((packed));
 127
 128
 129 struct intr_status_reg {
 130     union {
 131         uint8_t val;
 132         struct {
 133             uint8_t pkt_rx          : 1;
 134             uint8_t pkt_tx          : 1;
 135             uint8_t rx_err          : 1;
 136             uint8_t tx_err          : 1;
 137             uint8_t overwrite_warn  : 1;
 138             uint8_t cnt_overflow    : 1;
 139             uint8_t rem_dma_done    : 1;
 140             uint8_t reset_status    : 1;
 141         } __attribute__((packed));
 142     } __attribute__((packed));
 143 } __attribute__((packed));
 144
 145
 146 struct intr_mask_reg {
 147     union {
 148         uint8_t val;
 149         struct {
 150             uint8_t pkt_rx          : 1;
 151             uint8_t pkt_tx          : 1;
 152             uint8_t rx_err          : 1;
 153             uint8_t tx_err          : 1;
 154             uint8_t overwrite_warn  : 1;
 155             uint8_t cnt_overflow    : 1;
 156             uint8_t rem_dma_done    : 1;
 157             uint8_t rsvd            : 1;
 158         } __attribute__((packed));
 159     } __attribute__((packed));
 160 } __attribute__((packed));
 161
 162
 163 struct data_cfg_reg {
 164     union {
 165         uint8_t val;
 166         struct {
 167             uint8_t word_trans_sel   : 1;
 168             uint8_t byte_order_sel   : 1;
 169             uint8_t long_addr_sel    : 1;
 170             uint8_t loopback_sel     : 1;
 171             uint8_t auto_init_rem    : 1;
 172             uint8_t fifo_thresh_sel  : 2;
 173             uint8_t rsvd             : 1;
 174         } __attribute__((packed));
 175     } __attribute__((packed));
 176 } __attribute__((packed));
 177
 178
 179 struct tx_cfg_reg {
 180     union {
 181         uint8_t val;
 182         struct {
 183             uint8_t inhibit_crc     : 1;
 184             uint8_t enc_loop_ctrl   : 2;
 185             uint8_t auto_tx_disable : 1;
 186             uint8_t coll_offset_en  : 1;
 187             uint8_t rsvd            : 3;
 188         } __attribute__((packed));
 189     } __attribute__((packed));
 190 } __attribute__((packed));
 191
 192 struct tx_status_reg {
 193     union {
 194         uint8_t val;
 195         struct {
 196             uint8_t pkt_tx_ok       : 1;
 197             uint8_t rsvd            : 1;
 198             uint8_t tx_collision    : 1;
 199             uint8_t tx_aborted      : 1;
 200             uint8_t carrier_lost    : 1;
 201             uint8_t fifo_underrun   : 1;
 202             uint8_t cd_heartbeat    : 1;
 203             uint8_t oow_collision   : 1;
 204         } __attribute__((packed));
 205     } __attribute__((packed));
 206 } __attribute__((packed));
 207
 208 struct rx_cfg_reg {
 209     union {
 210         uint8_t val;
 211         struct {
 212             uint8_t save_pkt_errs    : 1;
 213             uint8_t runt_pkt_ok      : 1;
 214             uint8_t bcast_ok         : 1;
 215             uint8_t mcast_ok         : 1;
 216             uint8_t prom_phys_enable : 1;
 217             uint8_t mon_mode         : 1;
 218             uint8_t rsvd             : 2;
 219         } __attribute__((packed));
 220     } __attribute__((packed));
 221 } __attribute__((packed));
 222
 223
 224 struct rx_status_reg {
 225     union {
 226         uint8_t val;
 227         struct {
 228             uint8_t pkt_rx_ok        : 1;
 229             uint8_t crc_err          : 1;
 230             uint8_t frame_align_err  : 1;
 231             uint8_t fifo_overrun     : 1;
 232             uint8_t missed_pkt       : 1;
 233             uint8_t phy_match        : 1;   // 0=Physical Addr Match, 1=MCAST/BCAST Addr Match
 234             uint8_t rx_disabled      : 1;
 235             uint8_t deferring        : 1;
 236         } __attribute__((packed));
 237     } __attribute__((packed));
 238 } __attribute__((packed));
 239
 240
 241 struct ne2k_context {
 242     struct guest_info * vm;
 243
 244     nic_state_t dev_state;
 245
 246     // Registers
 247     struct cmd_reg cmd;
 248     struct intr_status_reg isr;
 249     struct intr_mask_reg imr;
 250     struct data_cfg_reg dcr;
 251     struct tx_cfg_reg tcr;
 252     struct tx_status_reg tsr;
 253     struct rx_cfg_reg rcr;
 254     struct rx_status_reg rsr;
 255
 256     uint8_t      pgstart;      // page start reg
 257     uint8_t      pgstop;       // page stop reg
 258     uint8_t      boundary;     // boundary ptr
 259     uint8_t      tpsr;         // tx page start addr
 260     uint8_t      ncr;          // number of collisions
 261     uint8_t      fifo;         // FIFO...
 262
 263     uint8_t      curpag;       // current page
 264     uint8_t      rnpp;         // rem next pkt ptr
 265     uint8_t      lnpp;         // local next pkt ptr
 266
 267     uint8_t      cntr0;        // counter 0 (frame alignment errors)
 268     uint8_t      cntr1;        // counter 1 (CRC Errors)
 269     uint8_t      cntr2;        // counter 2 (missed pkt errors)
 270
 271     union {                    // current local DMA Addr
 272         uint16_t     clda;
 273         struct {
 274             uint8_t clda0;
 275             uint8_t clda1;
 276         } __attribute__((packed));
 277     } __attribute__((packed));
 278
 279
 280     union {                   // current remote DMA addr
 281         uint16_t     crda;
 282         struct {
 283             uint8_t crda0;
 284             uint8_t crda1;
 285         } __attribute__((packed));
 286     } __attribute__((packed));
 287
 288
 289     union {                   // Remote Start Addr Reg
 290         uint16_t     rsar;
 291         struct {
 292             uint8_t rsar0;
 293             uint8_t rsar1;
 294         } __attribute__((packed));
 295     } __attribute__((packed));
 296
 297
 298     union {                    // TX Byte count Reg
 299         uint16_t     tbcr;
 300         struct {
 301             uint8_t tbcr0;
 302             uint8_t tbcr1;
 303         } __attribute__((packed));
 304     } __attribute__((packed));
 305
 306     union {                    // Remote Byte count Reg
 307         uint16_t     rbcr;
 308         struct {
 309             uint8_t rbcr0;
 310             uint8_t rbcr1;
 311         } __attribute__((packed));
 312     } __attribute__((packed));
 313
 314
 315
 316     union {                    // Address counter?
 317         uint16_t     addcnt;
 318         struct {
 319             uint8_t addcnt0;
 320             uint8_t addcnt1;
 321         } __attribute__((packed));
 322     } __attribute__((packed));
 323
 324
 325     uint8_t      mcast_addr[8];  // multicast mask array
 326     uint8_t      mac_addr[6];    // MAC Addr
 327
 328     uint8_t mem[NE2K_MEM_SIZE];
 329
 330     struct pci_device * pci_dev;
 331     struct vm_device * pci_bus;
 332 };
 333
 334 #define compare_mac(src, dst) !memcmp(src, dst, 6)
 335
 336 #ifdef DEBUG_NE2K
 337 static void dump_state(struct vm_device * dev) {
 338     struct ne2k_context *nic_state = (struct ne2k_context *)dev->private_data;
 339     int i;
 340
 341
 342     PrintDebug("====NE2000: Dumping state Begin ==========\n");
 343     PrintDebug("Registers:\n");
 344
 345     // JRL: Dump Registers
 346
 347     PrintDebug("Memory:\n");
 348
 349     for(i = 0; i < 32; i++) {
 350         PrintDebug("0x%02x ", nic_state->mem[i]);
 351     }
 352
 353     PrintDebug("\n");
 354     PrintDebug("====NE2000: Dumping state End==========\n");
 355 }
 356 #endif
 357
 358
 359
 360 static int ne2k_update_irq(struct vm_device *dev) {
 361     struct ne2k_context * nic_state = (struct ne2k_context *)dev->private_data;
 362     struct pci_device * pci_dev = nic_state->pci_dev;
 363     int irq_line = 0;
 364
 365     if (pci_dev == NULL){
 366         PrintDebug("Ne2k: Device %p is not attached to any PCI Bus\n", nic_state);
 367         irq_line = NE2K_DEFAULT_IRQ;
 368     } else {
 369         irq_line = pdev->config_header.intr_line;
 370     }
 371
 372     if (irq_line == 0){
 373         PrintError("Ne2k: IRQ_LINE: %d\n", irq_line);
 374         return -1;
 375     }
 376
 377     PrintDebug("ne2k_update_irq: irq_line: %d\n", irq_line);
 378
 379
 380     // The top bit of the ISR/IMR is reserved and does not indicate and irq event
 381     // We mask the bit out of the irq pending check
 382     if ((nic_state->isr.val & nic_state->imr.val) & 0x7f) {
 383         v3_raise_irq(nic_state->vm, irq_line);
 384         PrintDebug("Ne2k: RaiseIrq: isr: 0x%02x imr: 0x%02x\n", nic_state->isr.val, nic_state->imr.val);
 385     }
 386
 387     return 0;
 388 }
 389
 390
 391
 392 static void ne2k_init_state(struct vm_device * dev) {
 393     struct ne2k_context * nic_state = (struct ne2k_context *)dev->private_data;
 394     int i;
 395     uchar_t mac[6] = {0x52, 0x54, 0x0, 0x12, 0x34, 0x60};
 396
 397     nic_state->vm = dev->vm;
 398
 399     nic_state->isr.reset = 1;
 400     nic_state->imr.val = 0x00;
 401     nic_state->cmd.val = 0x22;
 402
 403     for (i = 0; i < 5; i++) {
 404         nic_state->mac_addr[i] = mac[i];
 405     }
 406
 407     memset(nic_state->mcast_addr, 0xff, sizeof(nic_state->mcast_addr));
 408
 409     // Not sure what this is about....
 410     memset(nic_state->mem, 0xff, 32);
 411
 412     memcpy(nic_state->mem, nic_state->mac_addr, 6);
 413     nic_state->mem[14] = 0x57;
 414     nic_state->mem[15] = 0x57;
 415
 416 #ifdef DEBUG_NE2K
 417     dump_state(dev);
 418 #endif
 419
 420 }
 421
 422 static int ne2k_send_packet(struct vm_device *dev, uchar_t *pkt, int length) {
 423     int i;
 424
 425     PrintDebug("\nNe2k: Sending Packet\n");
 426
 427     for (i = 0; i < length; i++) {
 428         PrintDebug("%x ",pkt[i]);
 429     }
 430
 431     PrintDebug("\n");
 432
 433     PrintError("Implement Send Packet interface\n");
 434
 435     return -1;
 436 }
 437
 438 static int ne2k_rxbuf_full(struct vm_device *dev) {
 439     int empty;
 440     int index;
 441     int boundary;
 442     struct ne2k_context * nic_state = (struct ne2k_context *)dev->private_data;
 443
 444     index = nic_state->curpag << 8;
 445     boundary = nic_state->boundary << 8;
 446
 447     if (index < boundary) {
 448         empty = boundary - index;
 449     } else {
 450         empty = ((nic_state->pgstop - nic_state->pgstart) << 8) - (index - boundary);
 451     }
 452
 453     if (empty < (MAX_ETH_FRAME_SIZE + 4)) {
 454         return 1;
 455     }
 456
 457     return 0;
 458 }
 459
 460 #define MIN_BUF_SIZE 60
 461
 462
 463 // This needs to be completely redone...
 464 static void ne2k_receive(struct vm_device * dev, const uchar_t * pkt, int length) {
 465     struct ne2k_context * nic_state = (struct ne2k_context *)dev->private_data;
 466     uchar_t * p;
 467     uint32_t total_len;
 468     uint32_t next;
 469     uint32_t len;
 470     uint32_t index;
 471     uint32_t empty;
 472     uchar_t buf[60];
 473     uint32_t start;
 474     uint32_t stop;
 475
 476     start = nic_state->pgstart << 8;
 477     stop = nic_state->pgstop << 8;
 478
 479     if (nic_state->cmd.stop) {
 480         return;
 481     }
 482
 483     if (ne2k_rxbuf_full(dev)) {
 484         PrintError("Ne2k: received buffer overflow\n");
 485         return;
 486     }
 487
 488
 489     //packet too small, expand it
 490     if (length < MIN_BUF_SIZE) {
 491         memcpy(buf, pkt, length);
 492         memset(buf + length, 0, MIN_BUF_SIZE - length);
 493         pkt = buf;
 494         length = MIN_BUF_SIZE;
 495     }
 496
 497     index = nic_state->curpag << 8;
 498
 499     //header, 4 bytes
 500     total_len = length + 4;
 501
 502     //address for next packet (4 bytes for CRC)
 503     next = index + ((total_len + 4 + 255) & ~0xff);
 504
 505     if (next >= stop) {
 506         next -= (stop - start);
 507     }
 508
 509     p = nic_state->mem + index;
 510     nic_state->rsr.val = 0;
 511     nic_state->rsr.rx_pkt_ok = 1;
 512
 513     if (pkt[0] & 0x01) {
 514         nic_state->rsr.phy = 1;
 515     }
 516
 517     p[0] = nic_state->rsr.val;
 518     p[1] = next >> 8;
 519     p[2] = total_len;
 520     p[3] = total_len >> 8;
 521     index += 4;
 522
 523     while (length > 0) {
 524         if (index <= stop) {
 525             empty = stop - index;
 526         } else {
 527             empty = 0;
 528         }
 529
 530         len = length;
 531
 532         if (len > empty) {
 533             len = empty;
 534         }
 535
 536         memcpy(nic_state->mem + index, pkt, len);
 537         pkt += len;
 538         index += len;
 539
 540         if (index == stop) {
 541             index = start;
 542         }
 543
 544         length -= len;
 545     }
 546
 547     nic_state->curpag = next >> 8;
 548
 549     nic_state->isr.pkt_rx = 1;
 550     ne2k_update_irq(dev);
 551 }
 552
 553
 554
 555
 556 static int netif_input(uchar_t *pkt, uint_t size) {
 557     struct ne2k_context * nic_state;
 558     static const uchar_t brocast_mac[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 559     int i;
 560
 561 #ifdef DEBUG_NE2K
 562     PrintDebug("\nNe2k: Packet Received:\nSource:");
 563     for (i = 6; i < 12; i++) {
 564         PrintDebug("%x ", pkt[i]);
 565     }
 566
 567     PrintDebug("\n");
 568
 569     for(i = 0; i < size; i++) {
 570         PrintDebug("%x ", pkt[i]);
 571     }
 572     PrintDebug("\n");
 573 #endif
 574
 575
 576     if (nic_state->rcr.prom_phys_enable == 1) {
 577         //promiscuous mode
 578         ne2k_receive(ne2ks[i], pkt, size);
 579     } else if (compare_mac(pkt,  brocast_mac) && (nic_state->rcr.bcast_ok)) {
 580         //broadcast packet
 581         ne2k_receive(ne2ks[i], pkt, size);
 582     } else if ((pkt[0] & 0x01) && (nic_state->rcr.mcast_ok)) {
 583         //TODO: multicast packet
 584         ne2k_receive(ne2ks[i], pkt, size);
 585     } else if (compare_mac(pkt, nic_state->mac_addr)) {
 586         ne2k_receive(ne2ks[i], pkt, size);
 587     }
 588
 589     return 0;
 590 }
 591
 592
 593 static void ne2k_mem_writeb(struct ne2k_context * nic_state, uint32_t addr, uint32_t val) {
 594     uchar_t tmp;
 595
 596     tmp = (uchar_t) (val & 0x000000ff);
 597
 598     if ((addr < 32) || (addr >= NE2K_PMEM_START && addr < NE2K_MEM_SIZE)) {
 599         nic_state->mem[addr] = tmp;
 600     }
 601
 602     PrintDebug("wmem addr: %x val: %x\n", addr, val);
 603 }
 604
 605 static void ne2k_mem_writew(struct ne2k_context * nic_state,
 606                             uint32_t addr,
 607                             uint32_t val) {
 608     addr &= ~1; //XXX: check exact behaviour if not even
 609
 610     if ((addr < 32) || (addr >= NE2K_PMEM_START && addr < NE2K_MEM_SIZE)) {
 611         *(ushort_t *)(nic_state->mem + addr) = cpu2le16(val);
 612     }
 613
 614     PrintDebug("wmem addr: %x val: %x\n", addr, val);
 615 }
 616
 617 static void ne2k_mem_writel(struct ne2k_context *nic_state,
 618                             uint32_t addr,
 619                             uint32_t val) {
 620     addr &= ~1; // XXX: check exact behaviour if not even
 621
 622     if ((addr < 32) || (addr >= NE2K_PMEM_START && addr < NE2K_MEM_SIZE)) {
 623         *(uint32_t *)(nic_state->mem + addr) = cpu2le32(val);
 624     }
 625
 626     PrintDebug("wmem addr: %x val: %x\n", addr, val);
 627 }
 628
 629 static uchar_t  ne2k_mem_readb(struct ne2k_context *nic_state, uint32_t addr) {
 630     PrintDebug("rmem addr: %x\n", addr);
 631
 632     if ((addr < 32) || (addr >= NE2K_PMEM_START && addr < NE2K_MEM_SIZE)) {
 633         return nic_state->mem[addr];
 634     } else {
 635         return 0xff;
 636     }
 637 }
 638
 639 static ushort_t ne2k_mem_readw(struct ne2k_context *nic_state, uint32_t addr) {
 640     PrintDebug("rmem addr: %x\n", addr);
 641
 642     addr &= ~1; //XXX: check exact behaviour if not even
 643
 644     if ((addr < 32) || (addr >= NE2K_PMEM_START && addr < NE2K_MEM_SIZE)) {
 645         return (ushort_t)le16_to_cpu((ushort_t *)(nic_state->mem + addr));
 646     } else {
 647         return 0xffff;
 648     }
 649 }
 650
 651 static uint32_t ne2k_mem_readl(struct ne2k_context *nic_state, uint32_t addr) {
 652     PrintDebug("rmem addr: %x\n", addr);
 653
 654     addr &= ~1; //XXX: check exact behaviour if not even
 655
 656     if ((addr < 32) || (addr >= NE2K_PMEM_START && addr < NE2K_MEM_SIZE)) {
 657         return (uint32_t)le32_to_cpu((uint32_t *)(nic_state->mem + addr));
 658     } else {
 659         return 0xffffffff;
 660     }
 661 }
 662
 663
 664 static void ne2k_dma_update(struct vm_device *dev, int len) {
 665     struct ne2k_context * nic_state = (struct ne2k_context *)dev->private_data;
 666
 667     nic_state->rsar += len;
 668
 669     // wrap
 670     if (nic_state->rsar == nic_state->pgstop) {
 671         nic_state->rsar = nic_state->pgstart;
 672     }
 673
 674     if (nic_state->rbcr <= len) {
 675         nic_state->rbcr = 0;
 676         nic_state->isr.rem_dma_done = 1;
 677         ne2k_update_irq(dev);
 678     } else {
 679         nic_state->rbcr -= len;
 680     }
 681 }
 682
 683
 684 //for data port read/write
 685 static int ne2k_data_read(ushort_t port, void * dst, uint_t length, struct vm_device *dev) {
 686     uint32_t val;
 687     struct ne2k_context * nic_state = (struct ne2k_context *)dev->private_data;
 688
 689     // current dma address
 690     uint32_t addr = nic_state->rsar;
 691
 692     switch (length){
 693         case 1:
 694             val = ne2k_mem_readb(nic_state, addr);
 695             break;
 696         case 2:
 697             val = ne2k_mem_readw(nic_state, addr);
 698             break;
 699         case 4:
 700             val = ne2k_mem_readl(nic_state, addr);
 701             break;
 702         default:
 703             PrintError("ne2k_data_read error: invalid length %d\n", length);
 704             val = 0x0;
 705     }
 706
 707     ne2k_dma_update(dev, length);
 708
 709     memcpy(dst, &val, length);
 710
 711     PrintDebug("ne2k_read: port:0x%x (%u bytes): 0x%x", port & 0x1f, length, val);
 712
 713     return length;
 714 }
 715
 716 static int ne2k_data_write(ushort_t port, void * src, uint_t length, struct vm_device *dev) {
 717     uint32_t val;
 718     struct ne2k_context * nic_state = (struct ne2k_context *)dev->private_data;
 719     uint32_t addr = nic_state->rsar;
 720
 721     if (nic_state->rbcr == 0) {
 722         return length;
 723     }
 724
 725     memcpy(&val, src, length);
 726
 727     switch (length) {
 728         case 1:
 729             ne2k_mem_writeb(nic_state, addr, val);
 730             break;
 731         case 2:
 732             ne2k_mem_writew(nic_state, addr, val);
 733             break;
 734         case 4:
 735             ne2k_mem_writel(nic_state, addr, val);
 736             break;
 737         default:
 738             PrintError("nic_data_write error: invalid length %d\n", length);
 739     }
 740
 741     ne2k_dma_update(dev, length);
 742
 743     PrintDebug("ne2k_write: port:0x%x (%u bytes): 0x%x\n", port & 0x1f, length, val);
 744
 745     return length;
 746 }
 747
 748 static int ne2k_reset_device(struct vm_device * dev) {
 749     PrintDebug("vnic: reset device\n");
 750
 751     init_ne2k_context(dev);
 752
 753     return 0;
 754 }
 755
 756
 757 //for 0xc11f port
 758 static int ne2k_reset_port_read(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
 759     PrintDebug("ne2k_read: port:0x%x (%u bytes): 0x%x\n", port, length, val);
 760
 761     memset(dst, 0, length);
 762     ne2k_reset_device(dev);
 763
 764     return length;
 765 }
 766
 767 static int ne2k_reset_port_write(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
 768     PrintDebug("ne2k_write: port:0x%x (%u bytes): 0x%x\n", port, length, val);
 769     return length;
 770 }
 771
 772
 773
 774 static int ne2k_cmd_write(uint16_t port, void * src, uint_t length, struct vm_device * dev) {
 775     struct ne2k_context * nic_state = (struct ne2k_context *)dev->private_data;
 776
 777     if (length != 1) {
 778         PrintError("Invalid write length to ne2k Command register\n");
 779         return -1;
 780     }
 781
 782     nic_state->cmd.val = *(uint8_t *)src;
 783
 784     if (!(nic_state->cmd.stop)) {
 785         nic_state->isr.reset = 0;
 786
 787
 788         // if ((send pkt) && (dma byte count == 0))
 789         if ((nic_state.rem_dma_cmd & 0x3) && (nic_state->rbcr == 0)) {
 790             nic_state->isr.rem_dma_done = 1;
 791             ne2k_update_irq(dev);
 792         }
 793
 794         if (nic_state->cmd.tx_pkt) {
 795             int offset = (nic_state->tpsr << 8);
 796
 797             if (offset >= NE2K_PMEM_END) {
 798                 offset -= NE2K_PMEM_SIZE;
 799             }
 800
 801             if (offset + nic_state->tbcr <= NE2K_PMEM_END) {
 802                 ne2k_send_packet(dev, nic_state->mem + offset, nic_state->tbcr);
 803             }
 804
 805
 806             nic_state->tsr.val = 0;        // clear the tx status reg
 807             nic_state->tsr.pkt_tx_ok = 1;  // indicate successful tx
 808
 809             nic_state->isr.pkt_tx = 1;     // irq due to pkt tx
 810             nic_state->cmd.tx_pkt = 0;     // reset cmd bit
 811             ne2k_update_irq(dev);
 812         }
 813     } else {
 814         // stop the controller
 815     }
 816
 817     return length;
 818 }
 819
 820 static int ne2k_cmd_read(uint16_t port, void * src, uint_t length, struct vm_device * dev) {
 821     *(uint8_t *)dst = nic_state->cmd.val;
 822
 823     PrintDebug("ne2k_read: port:0x%x  val: 0x%x\n", port, *(uint8_t *)dst);
 824     return length;
 825 }
 826
 827 static int ne2k_std_write(uint16_t port, void * src, uint_t length, struct vm_device * dev) {
 828     struct ne2k_context * nic_state = (struct ne2k_context *)dev->private_data;
 829     int index = port & 0x1f;
 830     uint8_t page = nic_state->cmd.pg_sel;
 831
 832     if (length != 1
 833         PrintError("ne2k_write error: length %d\n", length);
 834         return -1;
 835     }
 836
 837     PrintDebug("ne2k_write: port:0x%x  val: 0x%x\n", port, (int)val);
 838
 839
 840     if (page == 0) {
 841         switch (port) {
 842             case EN0_STARTPG:
 843                 nic_state->pgstart = val;
 844                 break;
 845             case EN0_STOPPG:
 846                 nic_state->pgstop = val;
 847                 break;
 848             case EN0_BOUNDARY:
 849                 nic_state->boundary = val;
 850                 break;
 851             case EN0_TPSR:
 852                 nic_state->tpsr = val;
 853                 break;
 854             case EN0_TCNTLO:
 855                 nic_state->tbcr0 = val;
 856                 break;
 857             case EN0_TCNTHI:
 858                 nic_state->tbcr1 = val;
 859                 break;
 860             case EN0_ISR:
 861                 nic_state->isr.val &= ~(val & 0x7f);
 862                 ne2k_update_irq(dev);
 863                 break;
 864             case EN0_RSARLO:
 865                 nic_state->rsar0 = val;
 866                 break;
 867             case EN0_RSARHI:
 868                 nic_state->rsar1 = val;
 869                 break;
 870             case EN0_RCNTLO:
 871                 nic_state->rbcr0 = val;
 872                 break;
 873             case EN0_RCNTHI:
 874                 nic_state->rbcr1 = val;
 875                 break;
 876             case EN0_RXCR:
 877                 nic_state->rcr.val = val;
 878                 break;
 879             case EN0_TXCR:
 880                 nic_state->tcr.val = val;
 881                 break;
 882             case EN0_DCFG:
 883                 nic_state->dcr.val = val;
 884                 break;
 885             case EN0_IMR:
 886                 nic_state->imr.val = val;
 887                 //PrintError("ne2k_write error: write IMR:0x%x\n", (int)val);
 888                 ne2k_update_irq(dev);
 889                 break;
 890             default:
 891                 PrintError("ne2k_write error: invalid port:0x%x\n", port);
 892                 return -1;
 893         }
 894     } else if (page == 1) {
 895         switch (port) {
 896             case EN1_PHYS ... EN1_PHYS + 5:
 897                 nic_state->mac_addr[port - EN1_PHYS] = val;
 898                 break;
 899             case EN1_CURPAG:
 900                 nic_state->curpag = val;
 901                 break;
 902             case EN1_MULT ... EN1_MULT + 7:
 903                 // PrintError("ne2k_write error: write EN_MULT:0x%x\n", (int)val);
 904                 nic_state->mcast_addr[port - EN1_MULT] = val;
 905                 break;
 906             default:
 907                 PrintError("ne2k_write error: invalid port:0x%x\n", port);
 908                 return -1;
 909         }
 910     } else if (page == 2) {
 911         switch (port) {
 912             case EN2_LDMA0:
 913                 nic_state->clda0 = val;
 914                 break;
 915             case EN2_LDMA1:
 916                 nic_state->clda1 = val;
 917                 break;
 918             case EN2_RNPR:
 919                 nic_state->rnpp = val;
 920                 break;
 921             case EN2_LNRP:
 922                 nic_state->lnpp = val;
 923                 break;
 924             case EN2_ACNT0:
 925                 nic_state->addcnt0 = val;
 926                 break;
 927             case EN2_ACNT1:
 928                 nic_state->addcnt1 = val;
 929                 break;
 930             default:
 931                 PrintError("ne2k_write error: invalid port:0x%x\n", port);
 932                 return -1;
 933         }
 934     } else {
 935         PrintError("Invalid Register Page Value\n");
 936         return -1;
 937     }
 938
 939
 940     return length;
 941
 942 }
 943
 944 static int ne2k_std_read(uint16_t port, void * dst, uint_t length, struct vm_device *dev) {
 945     struct ne2k_context * nic_state = (struct ne2k_context *)(dev->private_data);
 946     uint16_t index = port & 0x1f;
 947     uint8_t page = nic_state->cmd.pg_sel;
 948
 949     if (length > 1) {
 950         PrintError("ne2k_read error: length %d\n", length);
 951         return length;
 952     }
 953
 954     if (page == 0) {
 955
 956         switch (index) {
 957             case EN0_CLDALO:
 958                 *(uint8_t *)dst = nic_state->clda0;
 959                 break;
 960             case EN0_CLDAHI:
 961                 *(uint8_t *)dst = nic_state->clda1;
 962                 break;
 963             case EN0_BOUNDARY:
 964                 *(uint8_t *)dst = nic_state->boundary;
 965                 break;
 966             case EN0_TSR:
 967                 *(uint8_t *)dst = nic_state->tsr.val;
 968                 break;
 969             case EN0_NCR:
 970                 *(uint8_t *)dst = nic_state->ncr;
 971                 break;
 972             case EN0_FIFO:
 973                 *(uint8_t *)dst = nic_state->fifo;
 974                 break;
 975             case EN0_ISR:
 976                 *(uint8_t *)dst = nic_state->isr.val;
 977                 ne2k_update_irq(dev);
 978                 break;
 979             case EN0_CRDALO:
 980                 *(uint8_t *)dst = nic_state->crda0;
 981                 break;
 982             case EN0_CRDAHI:
 983                 *(uint8_t *)dst = nic_state->crda1;
 984                 break;
 985             case EN0_RSR:
 986                 *(uint8_t *)dst = nic_state->rsr.val;
 987                 break;
 988             case EN0_COUNTER0:
 989                 *(uint8_t *)dst = nic_state->cntr0;
 990                 break;
 991             case EN0_COUNTER1:
 992                 *(uint8_t *)dst = nic_state->cntr1;
 993                 break;
 994             case EN0_COUNTER2:
 995                 *(uint8_t *)dst = nic_state->cntr2;
 996                 break;
 997             default:
 998                 PrintError("ne2k_read error: invalid port:0x%x\n", port);
 999                 return -1;
1000         }
1001
1002     } else if (page == 1) {
1003
1004         switch (index) {
1005             case EN1_PHYS ... EN1_PHYS + 5:
1006                 *(uint8_t *)dst = nic_state->mac_addr[index - EN1_PHYS];
1007                 break;
1008             case EN1_CURPAG:
1009                 *(uint8_t *)dst = nic_state->curpag;
1010                 break;
1011             case EN1_MULT ... EN1_MULT + 7:
1012                 *(uint8_t *)dst = nic_state->mcast_addr[index - EN1_MULT];
1013                 break;
1014             default:
1015                 PrintError("ne2k_read error: invalid port:0x%x\n", port);
1016                 return -1;
1017         }
1018
1019     } else if (page == 2) {
1020
1021         switch (index) {
1022             case EN2_STARTPG:
1023                 *(uint8_t *)dst = nic_state->pgstart;
1024                 break;
1025             case EN2_STOPPG:
1026                 *(uint8_t *)dst = nic_state->pgstop;
1027                 break;
1028             case EN2_RNPR:
1029                 *(uint8_t *)dst = nic_state->rnpp;
1030                 break;
1031             case EN2_LNRP:
1032                 *(uint8_t *)dst = nic_state->lnpp;
1033                 break;
1034             case EN2_TPSR:
1035                 *(uint8_t *)dst = nic_state->tpsr;
1036                 break;
1037             case EN2_ACNT0:
1038                 *(uint8_t *)dst = nic_state->addcnt0;
1039                 break;
1040             case EN2_ACNT1:
1041                 *(uint8_t *)dst = nic_state->addcnt1;
1042                 break;
1043             case EN2_RCR:
1044                 *(uint8_t *)dst = nic_state->rcr.val;
1045                 break;
1046             case EN2_TCR:
1047                 *(uint8_t *)dst = nic_state->tcr.val;
1048                 break;
1049             case EN2_DCR:
1050                 *(uint8_t *)dst = nic_state->dcr.val;
1051                 break;
1052             case EN2_IMR:
1053                 *(uint8_t *)dst = nic_state->imr.val;
1054                 break;
1055             default:
1056                 PrintError("ne2k_read error: invalid port:0x%x\n", port);
1057                 return -1;
1058         }
1059     } else {
1060         PrintError("Invalid Register Page Value\n");
1061         return -1;
1062     }
1063
1064
1065     PrintDebug("ne2k_read: port:0x%x  val: 0x%x\n", port, *(uint8_t *)dst);
1066
1067     return length;
1068 }
1069
1070
1071 static int ne2k_start_device(struct vm_device * dev) {
1072     PrintDebug("vnic: start device\n");
1073
1074     return 0;
1075 }
1076
1077
1078 static int ne2k_stop_device(struct vm_device * dev) {
1079     PrintDebug("vnic: stop device\n");
1080
1081     return 0;
1082 }
1083
1084
1085
1086
1087 static int ne2k_init_device(struct vm_device * dev) {
1088     struct ne2k_context * nic_state = (struct ne2k_context *)(dev->private_data);
1089
1090     PrintDebug("Initializing NE2K\n");
1091
1092     init_ne2k_context(dev);
1093
1094     if (nic_state->pci_bus == NULL) {
1095         PrintDebug("NE2k: Not attached to pci\n");
1096
1097         v3_dev_hook_io(dev, NIC_REG_BASE_PORT , &ne2k_cmd_read, &ne2k_cmd_write);
1098
1099         for (i = 1; i < 16; i++){
1100             v3_dev_hook_io(dev, NIC_REG_BASE_PORT + i, &ne2k_std_read, &ne2k_std_write);
1101         }
1102
1103         v3_dev_hook_io(dev, NIC_DATA_PORT, &ne2k_data_read, &ne2k_data_write);
1104         v3_dev_hook_io(dev, NIC_RESET_PORT, &ne2k_reset_read, &ne2k_reset_write);
1105
1106     } else {
1107
1108         struct v3_pci_bar bars[6];
1109         struct pci_device * pci_dev = NULL;
1110         int i;
1111
1112         PrintDebug("NE2k: PCI Enabled\n");
1113
1114         for (i = 0; i < 6; i++) {
1115             bars[i].type = PCI_BAR_NONE;
1116         }
1117
1118         bars[0].type = PCI_BAR_IO;
1119         bars[0].default_base_port = NIC_REG_BASE_PORT;
1120         bars[0].num_ports = 256;
1121
1122         bars[0].io_read = ne2k_pci_read;
1123         bars[0].io_write = ne2k_pci_write;
1124
1125         pci_dev = v3_pci_register_device(nic_state->pci_bus, PCI_STD_DEVICE, 0, -1, 0,
1126                                          "NE2000", bars,
1127                                          pci_config_update, NULL, NULL, dev);
1128
1129         if (pci_dev == NULL) {
1130             PrintError("Failed to register NE2K with PCI\n");
1131             return -1;
1132         }
1133
1134         pci_dev->config_header.vendor_id = 0x10ec;
1135         pci_dev->config_header.device_id = 0x8029;
1136         pci_dev->config_header.revision = 0x00;
1137
1138         pci_dev->config_header.subclass = 0x00;
1139         pci_dev->config_header.class = 0x02;
1140         pci_dev->config_header.header_type = 0x00;
1141
1142         pci_dev->config_header.intr_line = 11;
1143         pci_dev->config_header.intr_pin = 1;
1144
1145         nic_state->pci_dev = pci_dev;
1146     }
1147
1148
1149 #ifdef DEBUG_NE2K
1150     dump_state(dev);
1151 #endif
1152
1153     return 0;
1154 }
1155
1156
1157
1158 static int ne2k_deinit_device(struct vm_device *dev) {
1159     int i;
1160
1161     for (i = 0; i < 16; i++){
1162         v3_dev_unhook_io(dev, NIC_REG_BASE_PORT + i);
1163     }
1164
1165     v3_dev_unhook_io(dev, NIC_DATA_PORT);
1166     v3_dev_unhook_io(dev, NIC_RESET_PORT);
1167
1168     return 0;
1169 }
1170
1171
1172 static struct vm_device_ops dev_ops = {
1173     .init = ne2k_init_device,
1174     .deinit = ne2k_deinit_device,
1175     .reset = ne2k_reset_device,
1176     .start = ne2k_start_device,
1177     .stop = ne2k_stop_device,
1178 };
1179
1180
1181 struct vm_device * v3_create_ne2k(struct vm_device * pci) {
1182     struct ne2k_context * nic_state = V3_Malloc(sizeof(struct ne2k_context));
1183
1184     memset(nic_state, 0, sizeof(struct ne2k_context));
1185
1186     nic_state->pci_bus = pci;
1187
1188     struct vm_device * device = v3_create_device("NE2K", &dev_ops, nic_state);
1189
1190     return device;
1191 }
1192