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