palacios/src/devices/rtl8139.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) 2011, Lei Xia <lxia@northwestern.edu>
  11  * Copyright (c) 2011, 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/ethernet.h>
  21 #include <devices/pci.h>
  22 #include <palacios/vmm.h>
  23 #include <palacios/vmm_types.h>
  24 #include <palacios/vmm_io.h>
  25 #include <palacios/vmm_debug.h>
  26 #include <palacios/vm_guest_mem.h>
  27
  28
  29 #ifndef CONFIG_DEBUG_RTL8139
  30 #undef PrintDebug
  31 #define PrintDebug(fmts, args...)
  32 #endif
  33
  34
  35
  36 #define NIC_BASE_ADDR   0xc100
  37 #define NIC_IRQ         11
  38
  39 #define RTL8139_IDR0    (0x00)          /* ID Registers */
  40 #define RTL8139_IDR1    (0x01)
  41 #define RTL8139_IDR2    (0x02)
  42 #define RTL8139_IDR3    (0x03)
  43 #define RTL8139_IDR4    (0x04)
  44 #define RTL8139_IDR5    (0x05)
  45
  46 #define RTL8139_MAR0    (0x08)  /* Mulicast Registers*/
  47 #define RTL8139_MAR1    (0x09)
  48 #define RTL8139_MAR2    (0x0a)
  49 #define RTL8139_MAR3    (0x0b)
  50 #define RTL8139_MAR4    (0x0c)
  51 #define RTL8139_MAR5    (0x0d)
  52 #define RTL8139_MAR6    (0x0e)
  53 #define RTL8139_MAR7    (0x0f)
  54
  55 #define RTL8139_TSD0    (0x10)  /* Tx Status of Descriptors */
  56 #define RTL8139_TSD1    (0x14)
  57 #define RTL8139_TSD2    (0x18)
  58 #define RTL8139_TSD3    (0x1c)
  59
  60 #define RTL8139_TSAD0   (0x20)  /* Tx Start Address of Descriptors */
  61 #define RTL8139_TSAD1   (0x24)
  62 #define RTL8139_TSAD2   (0x28)
  63 #define RTL8139_TSAD3   (0x2c)
  64
  65 #define RTL8139_RBSTART (0x30)  /* Rx Buffer Start Address */
  66 #define RTL8139_ERBCR   (0x34)  /* Early Rx Byte Count Register */
  67 #define RTL8139_ERSR    (0x36)  /* Early Rx Status Register */
  68 #define RTL8139_CR      (0x37)  /* Command Register */
  69 #define RTL8139_CAPR    (0x38)  /* Current Address of Pkt Read */
  70 #define RTL8139_CBR     (0x3a)  /* Current Buffer Address */
  71 #define RTL8139_IMR     (0x3c)  /* Intrpt Mask Reg */
  72 #define RTL8139_ISR     (0x3e)  /* Intrpt Status Reg */
  73 #define RTL8139_TCR     (0x40)  /* Tx Config Reg */
  74 #define RTL8139_RCR     (0x44)  /* Rx Config Reg */
  75 #define RTL8139_TCTR    (0x48)  /* Timer Count Reg */
  76 #define RTL8139_MPC     (0x4c)  /* Missed Pkt Counter */
  77 #define RTL8139_9346CR  (0x50)  /* 9346 Command Reg */
  78 #define RTL8139_CONFIG0 (0x51)  /* Config Reg */
  79 #define RTL8139_CONFIG1 (0x52)
  80 #define RTL8139_TimerInt    (0x54)      /* Timer Intrpt Reg */
  81 #define RTL8139_MSR     (0x58)  /* Media Status Reg */
  82 #define RTL8139_CONFIG3 (0x59)
  83 #define RTL8139_CONFIG4 (0x5a)
  84 #define RTL8139_MULINT  (0x5c)  /* Multiple Intrpt Select */
  85 #define RTL8139_RERID   (0x5e)
  86 #define RTL8139_TSAD    (0x60)  /* Tx Status of All Descriptors */
  87 #define RTL8139_BMCR    (0x62)  /* Basic Mode Control Register */
  88 #define RTL8139_BMSR    (0x64)  /* Basic Mode Status Register */
  89 #define RTL8139_ANAR    (0x66)  /* Auto-Negotiation Advertisement Register */
  90 #define RTL8139_ANLPAR  (0x68)  /* Auto-Negotiation Link Partner Register */
  91 #define RTL8139_ANER    (0x6a)  /* Auto-Negotiation Expansion Register */
  92 #define RTL8139_DIS     (0x6c)  /* Disconnect Counter */
  93 #define RTL8139_FCSC    (0x6e)  /* False Carrier Sense Counter */
  94 #define RTL8139_NWAYTR  (0x70)  /* N-way Test Register */
  95 #define RTL8139_REC     (0x72)  /* RX ER Counter */
  96 #define RTL8139_CSCR    (0x74)  /* CS Config Register */
  97 #define RTL8139_PHY1_PARM   (0x78)      /* PHY parameter */
  98 #define RTL8139_TW_PARM (0x7c)  /* Twister parameter */
  99 #define RTL8139_PHY2_PARM   (0x80)
 100
 101 #define RTL8139_CRC0    (0x84)  /* Power Management CRC Reg for wakeup frame */
 102 #define RTL8139_CRC1    (0x85)
 103 #define RTL8139_CRC2    (0x86)
 104 #define RTL8139_CRC3    (0x87)
 105 #define RTL8139_CRC4    (0x88)
 106 #define RTL8139_CRC5    (0x89)
 107 #define RTL8139_CRC6    (0x8a)
 108 #define RTL8139_CRC7    (0x8b)
 109
 110 #define RTL8139_Wakeup0 (0x8c)  /* Power Management wakeup frame */
 111 #define RTL8139_Wakeup1 (0x94)
 112 #define RTL8139_Wakeup2 (0x9c)
 113 #define RTL8139_Wakeup3 (0xa4)
 114 #define RTL8139_Wakeup4 (0xac)
 115 #define RTL8139_Wakeup5 (0xb4)
 116 #define RTL8139_Wakeup6 (0xbc)
 117 #define RTL8139_Wakeup7 (0xc4)
 118
 119 #define RTL8139_LSBCRO0 (0xcc)  /* LSB of the mask byte of wakeup frame */
 120 #define RTL8139_LSBCRO1 (0xcd)
 121 #define RTL8139_LSBCRO2 (0xce)
 122 #define RTL8139_LSBCRO3 (0xcf)
 123 #define RTL8139_LSBCRO4 (0xd0)
 124 #define RTL8139_LSBCRO5 (0xd1)
 125 #define RTL8139_LSBCRO6 (0xd2)
 126 #define RTL8139_LSBCRO7 (0xd3)
 127
 128 #define RTL8139_Config5 (0xd8)
 129
 130 /* Interrupts */
 131 #define PKT_RX      0x0001
 132 #define RX_ERR      0x0002
 133 #define TX_OK       0x0004
 134 #define TX_ERR      0x0008
 135 #define RX_BUFF_OF  0x0010
 136 #define RX_UNDERRUN 0x0020
 137 #define RX_FIFO_OF  0x0040
 138 #define CABLE_LEN_CHNG  0x2000
 139 #define TIME_OUT    0x4000
 140 #define SERR        0x8000
 141
 142 #define DESC_SIZE 2048
 143 #define TX_FIFO_SIZE (DESC_SIZE * 4)
 144 #define RX_FIFO_SIZE (DESC_SIZE * 4)
 145
 146 typedef enum {NIC_READY, NIC_REG_POSTED} nic_state_t;
 147
 148 enum TxStatusBits
 149 {
 150     TSD_Own = 0x2000,
 151     TSD_Tun = 0x4000,
 152     TSD_Tok = 0x8000,
 153     TSD_Cdh = 0x10000000,
 154     TSD_Owc = 0x20000000,
 155     TSD_Tabt = 0x40000000,
 156     TSD_Crs = 0x80000000,
 157 };
 158
 159 enum RxStatusBits {
 160     Rx_Multicast = 0x8000,
 161     Rx_Physical = 0x4000,
 162     Rx_Broadcast = 0x2000,
 163     Rx_BadSymbol = 0x0020,
 164     Rx_Runt = 0x0010,
 165     Rx_TooLong = 0x0008,
 166     Rx_CRCErr = 0x0004,
 167     Rx_BadAlign = 0x0002,
 168     Rx_StatusOK = 0x0001,
 169 };
 170
 171
 172 /* Transmit Status of All Descriptors (TSAD) Register */
 173 enum TSAD_bits {
 174  TSAD_TOK3 = 1<<15, // TOK bit of Descriptor 3
 175  TSAD_TOK2 = 1<<14, // TOK bit of Descriptor 2
 176  TSAD_TOK1 = 1<<13, // TOK bit of Descriptor 1
 177  TSAD_TOK0 = 1<<12, // TOK bit of Descriptor 0
 178  TSAD_TUN3 = 1<<11, // TUN bit of Descriptor 3
 179  TSAD_TUN2 = 1<<10, // TUN bit of Descriptor 2
 180  TSAD_TUN1 = 1<<9, // TUN bit of Descriptor 1
 181  TSAD_TUN0 = 1<<8, // TUN bit of Descriptor 0
 182  TSAD_TABT3 = 1<<07, // TABT bit of Descriptor 3
 183  TSAD_TABT2 = 1<<06, // TABT bit of Descriptor 2
 184  TSAD_TABT1 = 1<<05, // TABT bit of Descriptor 1
 185  TSAD_TABT0 = 1<<04, // TABT bit of Descriptor 0
 186  TSAD_OWN3 = 1<<03, // OWN bit of Descriptor 3
 187  TSAD_OWN2 = 1<<02, // OWN bit of Descriptor 2
 188  TSAD_OWN1 = 1<<01, // OWN bit of Descriptor 1
 189  TSAD_OWN0 = 1<<00, // OWN bit of Descriptor 0
 190 };
 191
 192 enum ISRBits
 193 {
 194     ISR_Rok = 0x1,
 195     ISR_Rer = 0x2,
 196     ISR_Tok = 0x4,
 197     ISR_Ter = 0x8,
 198     ISR_Rxovw = 0x10,
 199     ISR_Pun = 0x20,
 200     ISR_Fovw = 0x40,
 201     ISR_Lenchg = 0x2000,
 202     ISR_Timeout = 0x4000,
 203     ISR_Serr = 0x8000,
 204 };
 205
 206 enum CMDBits
 207 {
 208     CMD_Bufe = 0x1,
 209     CMD_Te = 0x4,
 210     CMD_Re = 0x8,
 211     CMD_Rst = 0x10,
 212 };
 213
 214 enum CMD9346Bits {
 215         CMD9346_Lock = 0x00,
 216         CMD9346_Unlock = 0xC0,
 217 };
 218
 219 // Bits in TxConfig.
 220 enum TXConfig_bits{
 221
 222         /* Interframe Gap Time. Only TxIFG96 doesn't violate IEEE 802.3 */
 223       TxIFGShift = 24,
 224       TxIFG84 = (0 << TxIFGShift),    /* 8.4us / 840ns (10 / 100Mbps) */
 225       TxIFG88 = (1 << TxIFGShift),    /* 8.8us / 880ns (10 / 100Mbps) */
 226       TxIFG92 = (2 << TxIFGShift),    /* 9.2us / 920ns (10 / 100Mbps) */
 227       TxIFG96 = (3 << TxIFGShift),    /* 9.6us / 960ns (10 / 100Mbps) */
 228
 229         TxLoopBack = (1 << 18) | (1 << 17), /* enable loopback test mode */
 230         TxCRC = (1 << 16),      /* DISABLE appending CRC to end of Tx packets */
 231         TxClearAbt = (1 << 0),  /* Clear abort (WO) */
 232         TxDMAShift = 8,         /* DMA burst value (0-7) is shifted this many bits */
 233         TxRetryShift = 4,       /* TXRR value (0-15) is shifted this many bits */
 234
 235         TxVersionMask = 0x7C800000, /* mask out version bits 30-26, 23 */
 236 };
 237
 238 enum CSCRBits {
 239     CSCR_Testfun = 1<<15, /* 1 = Auto-neg speeds up internal timer, WO, def 0 */
 240     CSCR_LD  = 1<<9,  /* Active low TPI link disable signal. When low, TPI still transmits link pulses and TPI stays in good link state. def 1*/
 241     CSCR_HEART_BIT = 1<<8,  /* 1 = HEART BEAT enable, 0 = HEART BEAT disable. HEART BEAT function is only valid in 10Mbps mode. def 1*/
 242     CSCR_JBEN = 1<<7,  /* 1 = enable jabber function. 0 = disable jabber function, def 1*/
 243     CSCR_F_LINK_100 = 1<<6, /* Used to login force good link in 100Mbps for diagnostic purposes. 1 = DISABLE, 0 = ENABLE. def 1*/
 244     CSCR_F_Connect  = 1<<5,  /* Assertion of this bit forces the disconnect function to be bypassed. def 0*/
 245     CSCR_Con_status = 1<<3, /* This bit indicates the status of the connection. 1 = valid connected link detected; 0 = disconnected link detected. RO def 0*/
 246     CSCR_Con_status_En = 1<<2, /* Assertion of this bit configures LED1 pin to indicate connection status. def 0*/
 247     CSCR_PASS_SCR = 1<<0, /* Bypass Scramble, def 0*/
 248 };
 249
 250 /* Bits in RxConfig. */
 251 enum rx_mode_bits {
 252         AcceptErr = 0x20,
 253         AcceptRunt = 0x10,
 254         AcceptBroadcast = 0x08,
 255         AcceptMulticast = 0x04,
 256         AcceptMyPhys = 0x02,
 257         AcceptAllPhys = 0x01,
 258 };
 259
 260 #define RTL8139_PCI_REVID_8139      0x10
 261
 262 #define SET_MASKED(input, mask, curr) \
 263     (((input) & ~(mask)) | ((curr) & (mask)))
 264
 265 /* arg % size for size which is a power of 2 */
 266 #define MOD2(input, size) \
 267     ((input) & (size - 1))
 268
 269
 270 /* Size is 64 * 16bit words */
 271 #define EEPROM_9346_ADDR_BITS 6
 272 #define EEPROM_9346_SIZE  (1 << EEPROM_9346_ADDR_BITS)
 273 #define EEPROM_9346_ADDR_MASK (EEPROM_9346_SIZE - 1)
 274
 275 enum Chip9346Operation
 276 {
 277     Chip9346_op_mask = 0xc0,          /* 10 zzzzzz */
 278     Chip9346_op_read = 0x80,          /* 10 AAAAAA */
 279     Chip9346_op_write = 0x40,         /* 01 AAAAAA D(15)..D(0) */
 280     Chip9346_op_ext_mask = 0xf0,      /* 11 zzzzzz */
 281     Chip9346_op_write_enable = 0x30,  /* 00 11zzzz */
 282     Chip9346_op_write_all = 0x10,     /* 00 01zzzz */
 283     Chip9346_op_write_disable = 0x00, /* 00 00zzzz */
 284 };
 285
 286 enum Chip9346Mode
 287 {
 288     Chip9346_none = 0,
 289     Chip9346_enter_command_mode,
 290     Chip9346_read_command,
 291     Chip9346_data_read,      /* from output register */
 292     Chip9346_data_write,     /* to input register, then to contents at specified address */
 293     Chip9346_data_write_all, /* to input register, then filling contents */
 294 };
 295
 296 struct EEprom9346
 297 {
 298     uint16_t contents[EEPROM_9346_SIZE];
 299     int      mode;
 300     uint32_t tick;
 301     uint8_t  address;
 302     uint16_t input;
 303     uint16_t output;
 304
 305     uint8_t eecs;
 306     uint8_t eesk;
 307     uint8_t eedi;
 308     uint8_t eedo;
 309 };
 310
 311 struct rtl8139_regs {
 312   union{
 313         uint8_t mem[256];
 314
 315         struct {
 316             uint8_t id[6];
 317             uint8_t reserved;
 318             uint8_t mult[8];
 319             uint32_t tsd[4];
 320             uint32_t tsad[4];
 321             uint32_t rbstart;
 322             uint16_t erbcr;
 323             uint8_t ersr;
 324             uint8_t cmd;
 325             uint16_t capr;
 326             uint16_t cbr;
 327             uint16_t imr;
 328             uint16_t isr;
 329             uint32_t tcr;
 330             uint32_t rcr;
 331             uint32_t tctr;
 332             uint16_t mpc;
 333             uint8_t cmd9346;
 334             uint8_t config[2];
 335             uint32_t timer_int;
 336             uint8_t msr;
 337             uint8_t config3[2];
 338             uint16_t mulint;
 339             uint16_t rerid;
 340             uint16_t txsad;
 341             uint16_t bmcr;
 342             uint16_t bmsr;
 343             uint16_t anar;
 344             uint16_t anlpar;
 345             uint16_t aner;
 346             uint16_t dis;
 347             uint16_t fcsc;
 348             uint16_t nwaytr;
 349             uint16_t rec;
 350             uint32_t cscr;
 351             uint32_t phy1_parm;
 352             uint16_t tw_parm;
 353             uint32_t  phy2_parm;
 354             uint8_t crc[8];
 355             uint32_t wakeup[16];
 356             uint8_t isbcr[8];
 357             uint8_t config5;
 358         }__attribute__((packed));
 359    }__attribute__((packed));
 360 };
 361
 362
 363
 364 struct rtl8139_state
 365 {
 366     nic_state_t dev_state;
 367
 368     struct v3_vm_info * vm;
 369     struct pci_device * pci_dev;
 370     struct vm_device * pci_bus;
 371     struct vm_device * dev;
 372
 373     struct nic_statistics statistic;
 374
 375     struct rtl8139_regs regs;
 376     struct EEprom9346 eeprom;
 377
 378     uint8_t tx_fifo[TX_FIFO_SIZE];
 379     uint8_t rx_fifo[RX_FIFO_SIZE];
 380     uint32_t rx_bufsize;
 381
 382     uint8_t mac[ETH_ALEN];
 383
 384     struct v3_dev_net_ops *net_ops;
 385     void * backend_data;
 386 };
 387
 388
 389 static void rtl8139_reset(struct vm_device *dev);
 390
 391 static void dump_state(struct vm_device *dev)
 392 {
 393     struct nic_context *nic_state = (struct nic_context *)dev->private_data;
 394     PrintDebug("====RTL8139: Dumping State Begin==========\n");
 395     PrintDebug("Registers\n");
 396     int i;
 397     uchar_t *reg;
 398         reg = (uchar_t *)&nic_state->regs;
 399
 400     for(i = 0; i < sizeof(struct nic_regs); i++)
 401     {
 402         PrintDebug("Register[%d] = 0x%2x\n", i, (int)reg[i]);
 403     }
 404
 405     PrintDebug("====RTL8139: Dumping State End==========\n");
 406 }
 407
 408 static void rtl8139_update_irq(struct rtl8139_state *nic_state)
 409 {
 410     struct pci_device *pdev = nic_state->pci_dev;
 411     int irq_line;
 412
 413     irq_line = pdev->configs[PCI_INTERRUPT_LINE];
 414     int isr = ((nic_state->regs.isr & nic_state->regs.imr) & 0xffff);
 415
 416     if(isr & 0xffff)
 417     {
 418         if (irq_line != 0){
 419                 v3_raise_irq(dev->vm, irq_line);
 420         PrintDebug("VNIC: RaiseIrq %d: isr: 0x%04x imr : 0x%04x\n", irq_line, nic_state->regs.isr, nic_state->regs.imr);
 421          } else {
 422               PrintError("RTL8139: IRQ_Line: %d\n", irq_line);
 423          }
 424     }
 425 }
 426
 427 #if 1
 428
 429 static void prom9346_decode_command(struct EEprom9346 *eeprom, uint8_t command)
 430 {
 431     PrintDebug("RTL8139: eeprom command 0x%02x\n", command);
 432
 433     switch (command & Chip9346_op_mask)
 434     {
 435         case Chip9346_op_read:
 436         {
 437             eeprom->address = command & EEPROM_9346_ADDR_MASK;
 438             eeprom->output = eeprom->contents[eeprom->address];
 439             eeprom->eedo = 0;
 440             eeprom->tick = 0;
 441             eeprom->mode = Chip9346_data_read;
 442             PrintDebug("RTL8139: eeprom read from address 0x%02x data=0x%04x\n",
 443                    eeprom->address, eeprom->output);
 444         }
 445         break;
 446
 447         case Chip9346_op_write:
 448         {
 449             eeprom->address = command & EEPROM_9346_ADDR_MASK;
 450             eeprom->input = 0;
 451             eeprom->tick = 0;
 452             eeprom->mode = Chip9346_none; /* Chip9346_data_write */
 453             PrintDebug("RTL8139: eeprom begin write to address 0x%02x\n",
 454                    eeprom->address);
 455         }
 456         break;
 457         default:
 458             eeprom->mode = Chip9346_none;
 459             switch (command & Chip9346_op_ext_mask)
 460             {
 461                 case Chip9346_op_write_enable:
 462                     PrintDebug("RTL8139: eeprom write enabled\n");
 463                     break;
 464                 case Chip9346_op_write_all:
 465                     PrintDebug("RTL8139: eeprom begin write all\n");
 466                     break;
 467                 case Chip9346_op_write_disable:
 468                     PrintDebug("RTL8139: eeprom write disabled\n");
 469                     break;
 470             }
 471             break;
 472     }
 473 }
 474
 475 static void prom9346_shift_clock(struct EEprom9346 *eeprom)
 476 {
 477     int bit = eeprom->eedi?1:0;
 478
 479     ++ eeprom->tick;
 480
 481     PrintDebug("eeprom: tick %d eedi=%d eedo=%d\n", eeprom->tick, eeprom->eedi, eeprom->eedo);
 482
 483     switch (eeprom->mode)
 484     {
 485         case Chip9346_enter_command_mode:
 486             if (bit)
 487             {
 488                 eeprom->mode = Chip9346_read_command;
 489                 eeprom->tick = 0;
 490                 eeprom->input = 0;
 491                 PrintDebug("eeprom: +++ synchronized, begin command read\n");
 492             }
 493             break;
 494
 495         case Chip9346_read_command:
 496             eeprom->input = (eeprom->input << 1) | (bit & 1);
 497             if (eeprom->tick == 8)
 498             {
 499                 prom9346_decode_command(eeprom, eeprom->input & 0xff);
 500             }
 501             break;
 502
 503         case Chip9346_data_read:
 504             eeprom->eedo = (eeprom->output & 0x8000)?1:0;
 505             eeprom->output <<= 1;
 506             if (eeprom->tick == 16)
 507             {
 508 #if 1
 509         // the FreeBSD drivers (rl and re) don't explicitly toggle
 510         // CS between reads (or does setting Cfg9346 to 0 count too?),
 511         // so we need to enter wait-for-command state here
 512                 eeprom->mode = Chip9346_enter_command_mode;
 513                 eeprom->input = 0;
 514                 eeprom->tick = 0;
 515
 516                 PrintDebug("eeprom: +++ end of read, awaiting next command\n");
 517 #else
 518         // original behaviour
 519                 ++eeprom->address;
 520                 eeprom->address &= EEPROM_9346_ADDR_MASK;
 521                 eeprom->output = eeprom->contents[eeprom->address];
 522                 eeprom->tick = 0;
 523
 524                 DEBUG_PRINT(("eeprom: +++ read next address 0x%02x data=0x%04x\n",
 525                        eeprom->address, eeprom->output));
 526 #endif
 527             }
 528             break;
 529
 530         case Chip9346_data_write:
 531             eeprom->input = (eeprom->input << 1) | (bit & 1);
 532             if (eeprom->tick == 16)
 533             {
 534                 PrintDebug("RTL8139: eeprom write to address 0x%02x data=0x%04x\n",
 535                        eeprom->address, eeprom->input);
 536
 537                 eeprom->contents[eeprom->address] = eeprom->input;
 538                 eeprom->mode = Chip9346_none; /* waiting for next command after CS cycle */
 539                 eeprom->tick = 0;
 540                 eeprom->input = 0;
 541             }
 542             break;
 543
 544         case Chip9346_data_write_all:
 545             eeprom->input = (eeprom->input << 1) | (bit & 1);
 546             if (eeprom->tick == 16)
 547             {
 548                 int i;
 549                 for (i = 0; i < EEPROM_9346_SIZE; i++)
 550                 {
 551                     eeprom->contents[i] = eeprom->input;
 552                 }
 553                 PrintDebug("RTL8139: eeprom filled with data=0x%04x\n",
 554                        eeprom->input);
 555
 556                 eeprom->mode = Chip9346_enter_command_mode;
 557                 eeprom->tick = 0;
 558                 eeprom->input = 0;
 559             }
 560             break;
 561
 562         default:
 563             break;
 564     }
 565 }
 566
 567 static int prom9346_get_wire(struct vm_device *dev)
 568 {
 569     struct nic_context *nic_state = (struct nic_context *)dev->private_data;
 570     struct EEprom9346 *eeprom = &(nic_state->eeprom);
 571
 572     if (!eeprom->eecs)
 573         return 0;
 574
 575     return eeprom->eedo;
 576 }
 577
 578 static void prom9346_set_wire(struct vm_device *dev, int eecs, int eesk, int eedi)
 579 {
 580     struct nic_context *nic_state = (struct nic_context *)dev->private_data;
 581     struct EEprom9346 *eeprom = &(nic_state->eeprom);
 582     uint8_t old_eecs = eeprom->eecs;
 583     uint8_t old_eesk = eeprom->eesk;
 584
 585     eeprom->eecs = eecs;
 586     eeprom->eesk = eesk;
 587     eeprom->eedi = eedi;
 588
 589     PrintDebug("eeprom: +++ wires CS=%d SK=%d DI=%d DO=%d\n",
 590                  eeprom->eecs, eeprom->eesk, eeprom->eedi, eeprom->eedo);
 591
 592     if (!old_eecs && eecs)
 593     {
 594         /* Synchronize start */
 595         eeprom->tick = 0;
 596         eeprom->input = 0;
 597         eeprom->output = 0;
 598         eeprom->mode = Chip9346_enter_command_mode;
 599
 600         PrintDebug("=== eeprom: begin access, enter command mode\n");
 601     }
 602
 603     if (!eecs)
 604     {
 605         PrintDebug("=== eeprom: end access\n");
 606         return;
 607     }
 608
 609     if (!old_eesk && eesk)
 610     {
 611         /* SK front rules */
 612         prom9346_shift_clock(eeprom);
 613     }
 614 }
 615
 616 static void rtl8139_9346cr_write(struct vm_device *dev, uint32_t val)
 617 {
 618     struct nic_context *nic_state = (struct nic_context *)dev->private_data;
 619
 620     val &= 0xff;
 621
 622     PrintDebug("RTL8139: 9346CR write val=0x%02x\n", val);
 623
 624     /* mask unwriteable bits */
 625     val = SET_MASKED(val, 0x31, nic_state->regs.cmd9346);
 626
 627     uint32_t opmode = val & 0xc0;
 628     uint32_t eeprom_val = val & 0xf;
 629
 630     if (opmode == 0x80) {
 631         /* eeprom access */
 632         int eecs = (eeprom_val & 0x08)?1:0;
 633         int eesk = (eeprom_val & 0x04)?1:0;
 634         int eedi = (eeprom_val & 0x02)?1:0;
 635         prom9346_set_wire(dev, eecs, eesk, eedi);
 636     } else if (opmode == 0x40) {
 637         /* Reset.  */
 638         val = 0;
 639         rtl8139_reset(dev);
 640     }
 641
 642     nic_state->regs.cmd9346 = val;
 643 }
 644
 645 static uint32_t rtl8139_9346cr_read(struct vm_device *dev)
 646 {
 647     struct nic_context *nic_state = (struct nic_context *)dev->private_data;
 648     uint32_t ret = nic_state->regs.cmd9346;
 649     uint32_t opmode = ret & 0xc0;
 650
 651     if (opmode == 0x80)
 652     {
 653         /* eeprom access */
 654         int eedo = prom9346_get_wire(dev);
 655         if (eedo)
 656         {
 657             ret |=  0x01;
 658         }
 659         else
 660         {
 661             ret &= ~0x01;
 662         }
 663     }
 664
 665     PrintDebug("RTL8139: 9346CR read val=0x%02x\n", ret);
 666
 667     return ret;
 668 }
 669
 670 #endif
 671
 672 static int rtl8139_receiver_enabled(struct vm_device *dev)
 673 {
 674     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
 675
 676     return nic_state->regs.cmd & CMD_Re;
 677 }
 678
 679 static int rtl8139_rxwrap(struct vm_device *dev)
 680 {
 681     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
 682
 683     // wrapping enabled; assume 1.5k more buffer space if size < 64K
 684     return (nic_state->regs.rcr & (1 << 7));
 685 }
 686
 687 static void rtl8139_rxbuf_write(struct vm_device *dev, const void *buf, int size)
 688 {
 689     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
 690     struct nic_regs *regs = &(nic_state->regs);
 691     int wrap;
 692     addr_t guestpa, host_rxbuf;
 693
 694     guestpa = (addr_t)regs->rbstart;
 695     guest_pa_to_host_va(dev->vm, guestpa, &host_rxbuf);
 696
 697     //wrap to the front of rx buffer
 698     if (regs->cbr + size > nic_state->rx_bufsize)
 699     {
 700         wrap = MOD2(regs->cbr + size, nic_state->rx_bufsize);
 701
 702         if (wrap && !(nic_state->rx_bufsize < 64*1024 && rtl8139_rxwrap(dev)))
 703         {
 704             PrintDebug("RTL8139: rx packet wrapped in buffer at %d\n", size-wrap);
 705
 706             if (size > wrap)
 707             {
 708                 memcpy((void *)(host_rxbuf + regs->cbr), buf, size-wrap);
 709             }
 710
 711             // reset buffer pointer
 712             regs->cbr = 0;
 713
 714             memcpy((void *)(host_rxbuf + regs->cbr), buf + (size-wrap), wrap);
 715
 716             regs->cbr = wrap;
 717
 718             return;
 719         }
 720     }
 721
 722     memcpy((void *)(host_rxbuf + regs->cbr), buf, size);
 723
 724     regs->cbr += size;
 725 }
 726
 727 #define POLYNOMIAL 0x04c11db6
 728
 729 /* From FreeBSD */
 730 static int compute_mcast_idx(const uint8_t *ep)
 731 {
 732     uint32_t crc;
 733     int carry, i, j;
 734     uint8_t b;
 735
 736     crc = 0xffffffff;
 737     for (i = 0; i < 6; i++) {
 738         b = *ep++;
 739         for (j = 0; j < 8; j++) {
 740             carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
 741             crc <<= 1;
 742             b >>= 1;
 743             if (carry)
 744                 crc = ((crc ^ POLYNOMIAL) | carry);
 745         }
 746     }
 747     return (crc >> 26);
 748 }
 749 static void vnic_receive(struct vm_device *dev, const uchar_t *pkt, uint_t length)
 750 {
 751     struct nic_context *nic_state = (struct nic_context *)dev->private_data;
 752     struct nic_regs *regs = &(nic_state->regs);
 753     uint_t rxbufsize = nic_state->rx_bufsize;
 754     uint32_t header, val;
 755     uint8_t bcast_addr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 756
 757     if (regs->rcr & AcceptAllPhys) {
 758         PrintDebug("RTL8139: packet received in promiscuous mode\n");
 759     } else {
 760         if (!memcmp(pkt,  bcast_addr, 6)) {
 761             if (!(regs->rcr & AcceptBroadcast))
 762             {
 763                 PrintDebug("RTL8139: broadcast packet rejected\n");
 764                 return;
 765             }
 766             header |= Rx_Broadcast;
 767             PrintDebug("RTL8139: broadcast packet received\n");
 768         } else if (pkt[0] & 0x01) {
 769             // multicast
 770             if (!(regs->rcr & AcceptMulticast))
 771             {
 772                 PrintDebug("RTL8139: multicast packet rejected\n");
 773                 return;
 774             }
 775
 776             int mcast_idx = compute_mcast_idx(pkt);
 777
 778             if (!(regs->mult[mcast_idx >> 3] & (1 << (mcast_idx & 7))))
 779             {
 780                 PrintDebug("RTL8139: multicast address mismatch\n");
 781                 return;
 782             }
 783             header |= Rx_Multicast;
 784             PrintDebug("RTL8139: multicast packet received\n");
 785         } else if (regs->id[0] == pkt[0] &&
 786                    regs->id[1] == pkt[1] &&
 787                    regs->id[2] == pkt[2] &&
 788                    regs->id[3] == pkt[3] &&
 789                    regs->id[4] == pkt[4] &&
 790                    regs->id[5] == pkt[5]) {
 791             if (!(regs->rcr & AcceptMyPhys))
 792             {
 793                 PrintDebug("RTL8139: rejecting physical address matching packet\n");
 794                 return;
 795             }
 796
 797             header |= Rx_Physical;
 798             PrintDebug("RTL8139: physical address matching packet received\n");
 799         } else {
 800             PrintDebug("RTL8139: unknown packet\n");
 801             return;
 802         }
 803     }
 804
 805     if(1){
 806         PrintDebug("RTL8139: in ring Rx mode\n");
 807
 808         int avail = MOD2(rxbufsize + regs->capr - regs->cbr, rxbufsize);
 809
 810         if (avail != 0 && length + 8 >= avail)
 811         {
 812             PrintError("rx overflow: rx buffer length %d head 0x%04x read 0x%04x === available 0x%04x need 0x%04x\n",
 813                    rxbufsize, regs->cbr, regs->capr, avail, length + 8);
 814
 815             regs->isr |= ISR_Rxovw;
 816             ++ regs->mpc;
 817             rtl8139_update_irq(dev);
 818             return;
 819         }
 820
 821         header |= Rx_StatusOK;
 822         header |= ((length << 16) & 0xffff0000);
 823
 824         rtl8139_rxbuf_write(dev, (uint8_t *)&header, 4);
 825
 826         rtl8139_rxbuf_write(dev, pkt, length);
 827
 828         val = V3_Crc32(0, (char *)pkt, length);
 829
 830         rtl8139_rxbuf_write(dev, (uint8_t *)&val, 4);
 831
 832         // correct buffer write pointer
 833         regs->cbr = MOD2((regs->cbr + 3) & ~0x3, rxbufsize);
 834
 835         PrintDebug("RTL8139: received: rx buffer length %d CBR: 0x%04x CAPR: 0x%04x\n",
 836                         rxbufsize, regs->cbr, regs->capr);
 837     }
 838
 839     regs->isr |= ISR_Rok;
 840
 841     nic_state->pkts_rcvd++;
 842
 843     rtl8139_update_irq(dev);
 844 }
 845
 846 static int netif_input(uchar_t *pkt, uint_t size)
 847 {
 848     PrintDebug("RTL8139: packet received!\n");
 849
 850     if (!rtl8139_receiver_enabled(current_vnic)){
 851                 PrintDebug("RTL8139: receiver disabled\n");
 852                 return 0;
 853     }
 854     vnic_receive(current_vnic, pkt, size);
 855
 856     return 0;
 857 }
 858
 859 static void rtl8139_reset_rxbuf(struct vm_device *dev, uint32_t bufsize)
 860 {
 861     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
 862     struct nic_regs *regs = &(nic_state->regs);
 863
 864     nic_state->rx_bufsize = bufsize;
 865     regs->capr  = 0;
 866     regs->cbr = 0;
 867 }
 868
 869 static void rtl8139_rcr_write(struct vm_device *dev, uint32_t val)
 870 {
 871     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
 872
 873     PrintDebug("RTL8139: RCR write val=0x%08x\n", val);
 874
 875     val = SET_MASKED(val, 0xf0fc0040, nic_state->regs.rcr);
 876
 877     nic_state->regs.rcr = val;
 878
 879 #if 0
 880     uchar_t rblen = (regs->rcr >> 11) & 0x3;
 881     switch(rblen)
 882     {
 883         case 0x0:
 884             rxbufsize = 1024 * 8 + 16;
 885             break;
 886         case 0x1:
 887             rxbufsize = 1024 * 16 + 16;
 888             break;
 889         case 0x2:
 890             rxbufsize = 1024 * 32 + 16;
 891             break;
 892         default:
 893             rxbufsize = 1024 * 64 + 16;
 894             break;
 895     }
 896 #endif
 897
 898     // reset buffer size and read/write pointers
 899     rtl8139_reset_rxbuf(dev, 8192 << ((nic_state->regs.rcr >> 11) & 0x3));
 900
 901     PrintDebug("RTL8139: RCR write reset buffer size to %d\n", nic_state->rx_bufsize);
 902 }
 903
 904 static void rtl8139_reset(struct rtl8139_state *nic_state)
 905 {
 906     struct rtl8139_regs *regs = &(nic_state->regs);
 907     int i;
 908
 909     PrintDebug("Rtl8139: Reset\n");
 910
 911     /* restore MAC address */
 912     memcpy(regs->id, nic_state->mac, ETH_ALEN);
 913     memset(regs->mult, 0xff, 8);
 914
 915     regs->isr = 0;
 916     regs->imr = 0;
 917
 918     rtl8139_update_irq(nic_state);
 919
 920     // prepare eeprom
 921     nic_state->eeprom.contents[0] = 0x8129;
 922
 923     // PCI vendor and device ID
 924     nic_state->eeprom.contents[1] = 0x10ec;
 925     nic_state->eeprom.contents[2] = 0x8139;
 926     //Mac address
 927     nic_state->eeprom.contents[7] = nic_state->mac[0] | nic_state->mac[1] << 8;
 928     nic_state->eeprom.contents[8] = nic_state->mac[2] | nic_state->mac[3] << 8;
 929     nic_state->eeprom.contents[9] = nic_state->mac[4] | nic_state->mac[5] << 8;
 930
 931     for (i = 0; i < 4; ++i)
 932     {
 933         regs->tsd[i] = TSD_Own;
 934     }
 935
 936     regs->rbstart = 0;
 937
 938     rtl8139_reset_rxbuf(nic_state, 1024*8);
 939
 940     /* ACK the reset */
 941     regs->tcr = 0;
 942
 943     regs->tcr |= ((0x1d << 26) | (0x1 << 22)); // RTL-8139D
 944     regs->rerid = RTL8139_PCI_REVID_8139;
 945
 946     regs->cmd = CMD_Rst; //RxBufEmpty bit is calculated on read from ChipCmd
 947
 948     regs->config[0] = 0x0 | (1 << 4); // No boot ROM
 949     regs->config[1] = 0xC; //IO mapped and MEM mapped registers available
 950     //regs->config[1] = 0x4; //Only IO mapped registers available
 951     regs->config3[0] = 0x1; // fast back-to-back compatible
 952     regs->config3[1] = 0x0;
 953     regs->config5 = 0x0;
 954
 955     regs->cscr = CSCR_F_LINK_100 | CSCR_HEART_BIT | CSCR_LD;
 956
 957     //0x3100 : 100Mbps, full duplex, autonegotiation.  0x2100 : 100Mbps, full duplex
 958     regs->bmcr = 0x1000; // autonegotiation
 959
 960     regs->bmsr  = 0x7809;
 961     regs->bmsr |= 0x0020; // autonegotiation completed
 962     regs->bmsr |= 0x0004; // link is up
 963
 964     regs->anar = 0x05e1;     // all modes, full duplex
 965     regs->anlpar = 0x05e1;   // all modes, full duplex
 966     regs->aner = 0x0001;     // autonegotiation supported
 967
 968     // reset timer and disable timer interrupt
 969     regs->tctr = 0;
 970     regs->timer_int = 0;
 971
 972     nic_state->pkts_rcvd = 0;
 973 }
 974
 975 static void init_rtl8139_regs(struct rtl8139_state *nic_state)
 976 {
 977     nic_state->regs.imr = 0x00;
 978     nic_state->regs.tsd[0] = nic_state->regs.tsd[1] = nic_state->regs.tsd[2] = nic_state->regs.tsd[3] = TSD_Own;
 979     nic_state->pkts_rcvd = 0;
 980
 981     int i;
 982     for(i = 0; i < 6; i++)
 983         nic_state->regs.id[i] = nic_state->mac_addr[i] = mac[i];
 984     for(i = 0; i < 8; i++)
 985         nic_state->regs.mult[i] = 0xff;
 986
 987     nic_state->regs.rerid = RTL8139_PCI_REVID_8139;
 988     nic_state->regs.tcr |= ((0x1d << 26) | (0x1 << 22));
 989
 990     rtl8139_reset(dev);
 991 }
 992
 993
 994 #if 0
 995
 996 static int rtl8139_config_writeable(struct vm_device *dev)
 997 {
 998     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
 999
1000     if (nic_state->regs.cmd9346 & CMD9346_Unlock)
1001     {
1002         return 1;
1003     }
1004
1005     PrintDebug("RTL8139: Configuration registers are unwriteable\n");
1006
1007     return 0;
1008 }
1009
1010 #endif
1011
1012 static int rtl8139_transmitter_enabled(struct vm_device *dev)
1013 {
1014     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1015
1016     return nic_state->regs.cmd & CMD_Te;
1017 }
1018
1019 static bool rtl8139_rxbufempty(struct vm_device *dev)
1020 {
1021     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1022     struct nic_regs *regs = &(nic_state->regs);
1023     int unread;
1024
1025     unread = MOD2(regs->cbr + nic_state->rx_bufsize - regs->capr, nic_state->rx_bufsize);
1026
1027     if (unread != 0)
1028     {
1029         PrintDebug("RTL8139: receiver buffer data available 0x%04x\n", unread);
1030         return false;
1031     }
1032
1033     PrintDebug("RTL8139: receiver buffer is empty\n");
1034
1035     return true;
1036 }
1037
1038 static uint32_t rtl8139_cmd_read(struct vm_device *dev)
1039 {
1040     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1041     uint32_t ret = nic_state->regs.cmd;
1042
1043     if (rtl8139_rxbufempty(dev))
1044         ret |= CMD_Bufe;
1045
1046     PrintDebug("RTL8139: Cmd read val=0x%04x\n", ret);
1047
1048     return ret;
1049 }
1050
1051 static void rtl8139_cmd_write(struct vm_device *dev, uint32_t val)
1052 {
1053     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1054
1055     val &= 0xff;
1056
1057     PrintDebug("RTL8139: Cmd write val=0x%08x\n", val);
1058
1059     if (val & CMD_Rst)
1060     {
1061         PrintDebug("RTL8139: Cmd reset\n");
1062         rtl8139_reset(dev);
1063     }
1064     if (val & CMD_Re)
1065     {
1066         PrintDebug("RTL8139: Cmd enable receiver\n");
1067
1068         //s->currCPlusRxDesc = 0;
1069     }
1070     if (val & CMD_Te)
1071     {
1072         PrintDebug("RTL8139: Cmd enable transmitter\n");
1073
1074         //s->currCPlusTxDesc = 0;
1075     }
1076
1077     val = SET_MASKED(val, 0xe3, nic_state->regs.cmd);
1078     val &= ~CMD_Rst;
1079
1080     nic_state->regs.cmd = val;
1081 }
1082
1083 static int rtl8139_send_packet(struct vm_device *dev, int descriptor)
1084 {
1085     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1086     struct nic_regs *regs = &(nic_state->regs);
1087     int txsize;
1088     uint8_t *pkt;
1089     addr_t pkt_gpa = 0, hostva = 0;
1090     int i;
1091
1092     if (!rtl8139_transmitter_enabled(dev))
1093     {
1094         PrintError("RTL8139: fail to send from descriptor %d: transmitter disabled\n", descriptor);
1095         return 0;
1096     }
1097
1098     if (regs->tsd[descriptor] & TSD_Own)
1099     {
1100         PrintError("RTL8139: fail to send from descriptor %d: owned by host\n", descriptor);
1101         return 0;
1102     }
1103
1104     txsize = regs->tsd[descriptor] & 0x1fff;
1105     pkt_gpa = (addr_t) regs->tsad[descriptor];
1106
1107     PrintDebug("RTL8139: sending %d bytes from guest memory at 0x%08x\n", txsize, regs->tsad[descriptor]);
1108
1109     guest_pa_to_host_va(dev->vm, (addr_t)pkt_gpa, &hostva);
1110     pkt = (uchar_t *)hostva;
1111
1112     for(i = 0; i < txsize; i++)
1113     {
1114         PrintDebug("%x ", pkt[i]);
1115     }
1116     PrintDebug("\n");
1117
1118     if (TxLoopBack == (regs->tcr & TxLoopBack)){ //loopback test
1119         PrintDebug(("RTL8139: transmit loopback mode\n"));
1120         vnic_receive(dev, pkt, txsize);
1121     } else{
1122             if (V3_SEND_PKT(pkt, txsize) == 0){
1123                  PrintDebug("RTL8139: Sent %d bytes from descriptor %d\n", txsize, descriptor);
1124             } else {
1125                 PrintError("Rtl8139: Sending packet error: 0x%p\n", pkt);
1126             }
1127     }
1128
1129     regs->tsd[descriptor] |= TSD_Tok;
1130     regs->tsd[descriptor] |= TSD_Own;
1131
1132     nic_state->regs.isr |= ISR_Tok;
1133     rtl8139_update_irq(dev);
1134
1135     return 0;
1136 }
1137
1138 //write to transmit status registers
1139 static void rtl8139_tsd_write(struct vm_device *dev, uint8_t descriptor, uint32_t val)
1140 {
1141     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1142
1143 #if 0
1144     if (rtl8139_transmitter_enabled(dev))
1145     {
1146         PrintDebug("RTL8139: TxStatus write val=0x%08x descriptor=%d\n", val, descriptor);
1147
1148         nic_state->regs.tsd[descriptor] = val;
1149
1150         return;
1151     }
1152 #endif
1153
1154     PrintDebug("RTL8139: TSD write val=0x%08x descriptor=%d\n", val, descriptor);
1155
1156     // mask read-only bits
1157     val &= ~0xff00c000;
1158     val = SET_MASKED(val, 0x00c00000,  nic_state->regs.tsd[descriptor]);
1159
1160     nic_state->regs.tsd[descriptor] = val;
1161
1162     rtl8139_send_packet(dev, descriptor);
1163 }
1164
1165 //transmit status of all descriptors
1166 static uint16_t rtl8139_tsad_read(struct vm_device *dev)
1167 {
1168     uint16_t ret = 0;
1169     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1170     struct nic_regs *regs = &(nic_state->regs);
1171
1172     ret = ((regs->tsd[3] & TSD_Tok)?TSD_Tok:0)
1173          |((regs->tsd[2] & TSD_Tok)?TSAD_TOK2:0)
1174          |((regs->tsd[1] & TSD_Tok)?TSAD_TOK1:0)
1175          |((regs->tsd[0] & TSD_Tok)?TSAD_TOK0:0)
1176
1177          |((regs->tsd[3] & TSD_Tun)?TSAD_TUN3:0)
1178          |((regs->tsd[2] & TSD_Tun)?TSAD_TUN2:0)
1179          |((regs->tsd[1] & TSD_Tun)?TSAD_TUN1:0)
1180          |((regs->tsd[0] & TSD_Tun)?TSAD_TUN0:0)
1181
1182          |((regs->tsd[3] & TSD_Tabt)?TSAD_TABT3:0)
1183          |((regs->tsd[2] & TSD_Tabt)?TSAD_TABT2:0)
1184          |((regs->tsd[1] & TSD_Tabt)?TSAD_TABT1:0)
1185          |((regs->tsd[0] & TSD_Tabt)?TSAD_TABT0:0)
1186
1187          |((regs->tsd[3] & TSD_Own)?TSAD_OWN3:0)
1188          |((regs->tsd[2] & TSD_Own)?TSAD_OWN2:0)
1189          |((regs->tsd[1] & TSD_Own)?TSAD_OWN1:0)
1190          |((regs->tsd[0] & TSD_Own)?TSAD_OWN0:0) ;
1191
1192
1193     PrintDebug("RTL8139: tsad read val=0x%04x\n", (int)ret);
1194
1195     return ret;
1196 }
1197
1198 //interrupt mask register
1199 static void rtl8139_imr_write(struct vm_device *dev, uint32_t val)
1200 {
1201     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1202
1203     PrintDebug("RTL8139: IMR write val=0x%04x\n", val);
1204
1205     /* mask unwriteable bits */
1206     val = SET_MASKED(val, 0x1e00, nic_state->regs.imr);
1207
1208     nic_state->regs.imr = val;
1209
1210     rtl8139_update_irq(dev);
1211 }
1212
1213 static void rtl8139_isr_write(struct vm_device *dev, uint32_t val)
1214 {
1215     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1216     struct nic_regs *regs = &(nic_state->regs);
1217
1218     PrintDebug("RTL8139: ISR write val=0x%04x\n", val);
1219
1220 #if 0
1221
1222     // writing to ISR has no effect
1223
1224     return;
1225
1226 #else
1227     uint16_t newisr = regs->isr & ~val;
1228
1229     /* mask unwriteable bits */
1230     newisr = SET_MASKED(newisr, 0x1e00, regs->isr);
1231
1232     /* writing 1 to interrupt status register bit clears it */
1233     regs->isr = 0;
1234     rtl8139_update_irq(dev);
1235
1236     regs->isr = newisr;
1237     rtl8139_update_irq(dev);
1238 #endif
1239 }
1240
1241 static uint32_t rtl8139_isr_read(struct vm_device *dev)
1242 {
1243     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1244     uint32_t ret = (uint32_t)nic_state->regs.isr;
1245
1246     PrintDebug("RTL8139: ISR read val=0x%04x\n", ret);
1247
1248 #if 0
1249     // reading ISR clears all interrupts
1250     nic_state->regs.isr = 0;
1251
1252     rtl8139_update_irq(dev);
1253
1254 #endif
1255
1256     return ret;
1257 }
1258
1259 static void rtl8139_capr_write(struct vm_device *dev, uint32_t val)
1260 {
1261     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1262
1263     PrintDebug("RTL8139: CAPR write val=0x%04x\n", val);
1264
1265     // this value is off by 16
1266     nic_state->regs.capr = MOD2(val + 0x10, nic_state->rx_bufsize);
1267
1268     PrintDebug("RTL 8139: CAPR write: rx buffer length %d head 0x%04x read 0x%04x\n",
1269            nic_state->rx_bufsize, nic_state->regs.cbr, nic_state->regs.capr);
1270 }
1271
1272 static uint32_t rtl8139_capr_read(struct vm_device *dev)
1273 {
1274     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1275
1276     /* this value is off by 16 */
1277     uint32_t ret = nic_state->regs.capr - 0x10;
1278
1279     PrintDebug("RTL8139: CAPR read val=0x%04x\n", ret);
1280
1281     return ret;
1282 }
1283
1284 typedef enum {read, write} opr_t;
1285 static bool need_hook(int port, opr_t op)
1286 {
1287         if (op == read){
1288                 switch (port) {
1289                         case RTL8139_IMR:
1290                         case RTL8139_ISR:
1291                                 return true;
1292                         default:
1293                                 break;
1294                 }
1295         }
1296         if (op == write){
1297                 switch (port) {
1298                         case RTL8139_TSD0:
1299                         case RTL8139_TSD1:
1300                         case RTL8139_TSD2:
1301                         case RTL8139_TSD3:
1302                         case RTL8139_CR:
1303                         case RTL8139_IMR:
1304                         case RTL8139_ISR:
1305                         case RTL8139_TCR:
1306                         case RTL8139_RCR:
1307                         case RTL8139_CSCR:
1308                         case RTL8139_Config5:
1309                                 return true;
1310                         default:
1311                                 break;
1312                 }
1313         }
1314
1315         return false;
1316 }
1317
1318 static int rtl8139_mmio_write(addr_t guest_addr, void * src, uint_t length, void * priv_data)
1319 {
1320     int port;
1321     uint32_t val;
1322     struct vm_device *dev = (struct vm_device *)priv_data;
1323     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1324
1325     port = guest_addr & 0xff;
1326
1327     memcpy(&val, src, length);
1328
1329     PrintDebug("rtl8139 mmio write: addr:0x%x (%u bytes): 0x%x\n", (int)guest_addr, length, val);
1330
1331     switch(port) {
1332             case RTL8139_IDR0:
1333                 nic_state->regs.id[0] = val & 0xff;
1334                 break;
1335             case RTL8139_IDR1:
1336                 nic_state->regs.id[1] = val & 0xff;
1337                 break;
1338             case RTL8139_IDR2:
1339                 nic_state->regs.id[2] = val & 0xff;
1340                 break;
1341             case RTL8139_IDR3:
1342                 nic_state->regs.id[3] = val & 0xff;
1343                 break;
1344             case RTL8139_IDR4:
1345                 nic_state->regs.id[4] = val & 0xff;
1346                 break;
1347             case RTL8139_IDR5:
1348                 nic_state->regs.id[5] = val & 0xff;
1349                 break;
1350             case RTL8139_MAR0:
1351                 nic_state->regs.mult[0] = val & 0xff;
1352                 break;
1353             case RTL8139_MAR1:
1354                 nic_state->regs.mult[1] = val & 0xff;
1355                 break;
1356             case RTL8139_MAR2:
1357                 nic_state->regs.mult[2] = val & 0xff;
1358                 break;
1359             case RTL8139_MAR3:
1360                 nic_state->regs.mult[3] = val & 0xff;
1361                 break;
1362             case RTL8139_MAR4:
1363                 nic_state->regs.mult[4] = val & 0xff;
1364                 break;
1365             case RTL8139_MAR5:
1366                 nic_state->regs.mult[5] = val & 0xff;
1367                 break;
1368             case RTL8139_MAR6:
1369                 nic_state->regs.mult[6] = val & 0xff;
1370                 break;
1371             case RTL8139_MAR7:
1372                 nic_state->regs.mult[7] = val & 0xff;
1373                 break;
1374             case RTL8139_TSD0:
1375             case RTL8139_TSD1:
1376             case RTL8139_TSD2:
1377             case RTL8139_TSD3:
1378                 rtl8139_tsd_write(dev, (port - RTL8139_TSD0)/4, val);
1379                 break;
1380             case RTL8139_TSAD0:
1381             case RTL8139_TSAD1:
1382             case RTL8139_TSAD2:
1383             case RTL8139_TSAD3:
1384                 nic_state->regs.tsad[(port - RTL8139_TSAD0)/4] = val;
1385                 break;
1386             case RTL8139_RBSTART:
1387                 nic_state->regs.rbstart = val;
1388                 break;
1389             case RTL8139_ERBCR:
1390                 nic_state->regs.erbcr = val & 0xffff;
1391                 break;
1392             case RTL8139_ERSR:
1393                 //nic_state->regs.ersr = val & 0xff;
1394                 nic_state->regs.ersr &= (~val) & 0x0c;
1395                 break;
1396             case RTL8139_CR:
1397                   rtl8139_cmd_write(dev, val);
1398                 break;
1399             case RTL8139_CAPR:
1400                 rtl8139_capr_write(dev, val & 0xffff);
1401                 break;
1402             case RTL8139_CBR: //this is read only =====
1403                 //nic_state->regs.cbr = val & 0xffff;
1404                 break;
1405             case RTL8139_IMR:
1406                   rtl8139_imr_write(dev, val);
1407                 break;
1408             case RTL8139_ISR:
1409                 rtl8139_isr_write(dev, val);
1410                 break;
1411             case RTL8139_TCR:
1412                 nic_state->regs.tcr = val;
1413                 break;
1414             case RTL8139_RCR:
1415                 rtl8139_rcr_write(dev, val);
1416                  break;
1417             case RTL8139_TCTR:
1418                 nic_state->regs.tctr = 0; //write clear current tick
1419                 break;
1420             case RTL8139_MPC:
1421                 nic_state->regs.mpc = 0; //clear on write
1422                 break;
1423             case RTL8139_9346CR:
1424                   rtl8139_9346cr_write(dev, val);
1425                 break;
1426             case RTL8139_CONFIG0:
1427                 nic_state->regs.config[0] = val & 0xff;
1428                 break;
1429             case RTL8139_CONFIG1:
1430                 nic_state->regs.config[1] = val & 0xff;
1431                 break;
1432             case RTL8139_TimerInt:
1433                 nic_state->regs.timer_int = val;
1434                 break;
1435             case RTL8139_MSR:
1436                 nic_state->regs.msr = val & 0xff;
1437                 break;
1438             case RTL8139_CONFIG3:
1439                 nic_state->regs.config3[0] = val & 0xff;
1440                 break;
1441             case RTL8139_CONFIG4:
1442                 nic_state->regs.config3[1] = val & 0xff;
1443                 break;
1444             case RTL8139_MULINT:
1445                 nic_state->regs.mulint = val & 0xffff;
1446                 break;
1447             case RTL8139_RERID:
1448                 nic_state->regs.rerid = val & 0xffff;
1449                 break;
1450             case RTL8139_TSAD:
1451                 nic_state->regs.txsad = val & 0xffff;
1452                 break;
1453             case RTL8139_BMCR:
1454                 nic_state->regs.bmcr = val & 0xffff;
1455                 break;
1456             case RTL8139_BMSR:
1457                 nic_state->regs.bmsr = val & 0xffff;
1458                 break;
1459             case RTL8139_ANAR:
1460                 nic_state->regs.anar = val & 0xffff;
1461                 break;
1462             case RTL8139_ANLPAR:
1463                 nic_state->regs.anlpar = val & 0xffff;
1464                 break;
1465             case RTL8139_ANER:
1466                 nic_state->regs.aner = val & 0xffff;
1467                 break;
1468             case RTL8139_DIS:
1469                 nic_state->regs.dis = val & 0xffff;
1470                 break;
1471             case RTL8139_FCSC:
1472                 nic_state->regs.fcsc = val & 0xffff;
1473                 break;
1474             case RTL8139_NWAYTR:
1475                 nic_state->regs.nwaytr = val & 0xffff;
1476                 break;
1477             case RTL8139_REC:
1478                 nic_state->regs.rec = val & 0xffff;
1479                 break;
1480             case RTL8139_CSCR:
1481                 nic_state->regs.cscr = val;
1482                 break;
1483             case RTL8139_PHY1_PARM:
1484                 nic_state->regs.phy1_parm = val;
1485                 break;
1486             case RTL8139_TW_PARM:
1487                 nic_state->regs.tw_parm = val & 0xffff;
1488                 break;
1489             case RTL8139_PHY2_PARM:
1490                 nic_state->regs.phy2_parm = val;
1491                 break;
1492             case RTL8139_CRC0:
1493                 nic_state->regs.crc[0] = val & 0xff;
1494                 break;
1495             case RTL8139_CRC1:
1496                 nic_state->regs.crc[1] = val & 0xff;
1497                 break;
1498             case RTL8139_CRC2:
1499                 nic_state->regs.crc[2] = val & 0xff;
1500                 break;
1501             case RTL8139_CRC3:
1502                 nic_state->regs.crc[3] = val & 0xff;
1503                 break;
1504             case RTL8139_CRC4:
1505                 nic_state->regs.crc[4] = val & 0xff;
1506                 break;
1507             case RTL8139_CRC5:
1508                 nic_state->regs.crc[5] = val & 0xff;
1509                 break;
1510             case RTL8139_CRC6:
1511                 nic_state->regs.crc[6] = val & 0xff;
1512                 break;
1513             case RTL8139_CRC7:
1514                 nic_state->regs.crc[7] = val & 0xff;
1515                 break;
1516             case RTL8139_Config5:
1517                 nic_state->regs.config5 = val & 0xff;
1518                 break;
1519             default:
1520                 PrintDebug("rtl8139 write error: invalid port: 0x%x\n", port);
1521         }
1522
1523
1524 #if TEST_PERFORMANCE
1525     if (need_hook(port, read))
1526                 io_hooked ++;
1527     if (( ++io_total) % 50 == 0)
1528          PrintError("RTL8139: Total IO: %d, Hooked: %d, INT: %d\n", io_total, io_hooked, int_total);
1529 #endif
1530
1531     return length;
1532 }
1533
1534 static int rtl8139_mmio_read(addr_t guest_addr, void * dst, uint_t length, void * priv_data)
1535 {
1536     ulong_t port;
1537     uint32_t val;
1538     struct vm_device *dev = (struct vm_device *)priv_data;
1539     struct nic_context *nic_state = (struct nic_context *)(dev->private_data);
1540
1541     port = guest_addr & 0xff;
1542
1543     switch(port) {
1544             case RTL8139_IDR0:
1545                 val = nic_state->regs.id[0];
1546                 break;
1547             case RTL8139_IDR1:
1548                 val = nic_state->regs.id[1];
1549                 break;
1550             case RTL8139_IDR2:
1551                 val = nic_state->regs.id[2];
1552                 break;
1553             case RTL8139_IDR3:
1554                 val = nic_state->regs.id[3];
1555                 break;
1556             case RTL8139_IDR4:
1557                 val = nic_state->regs.id[4];
1558                 break;
1559             case RTL8139_IDR5:
1560                 val = nic_state->regs.id[5];
1561                 break;
1562             case RTL8139_MAR0:
1563                 val = nic_state->regs.mult[0];
1564                 break;
1565             case RTL8139_MAR1:
1566                 val = nic_state->regs.mult[1];
1567                 break;
1568             case RTL8139_MAR2:
1569                 val = nic_state->regs.mult[2];
1570                 break;
1571             case RTL8139_MAR3:
1572                 val = nic_state->regs.mult[3];
1573                 break;
1574             case RTL8139_MAR4:
1575                 val = nic_state->regs.mult[4];
1576                 break;
1577             case RTL8139_MAR5:
1578                 val = nic_state->regs.mult[5];
1579                 break;
1580             case RTL8139_MAR6:
1581                 val = nic_state->regs.mult[6];
1582                 break;
1583             case RTL8139_MAR7:
1584                 val = nic_state->regs.mult[7];
1585                 break;
1586             case RTL8139_TSD0:
1587                 val = nic_state->regs.tsd[0];
1588                 break;
1589             case RTL8139_TSD1:
1590                 val = nic_state->regs.tsd[1];
1591                 break;
1592             case RTL8139_TSD2:
1593                 val = nic_state->regs.tsd[2];
1594                 break;
1595             case RTL8139_TSD3:
1596                 val = nic_state->regs.tsd[3];
1597                 break;
1598             case RTL8139_TSAD0:
1599                 val = nic_state->regs.tsad[0];
1600                 break;
1601             case RTL8139_TSAD1:
1602                 val = nic_state->regs.tsad[1];
1603                 break;
1604             case RTL8139_TSAD2:
1605                 val = nic_state->regs.tsad[2];
1606                 break;
1607             case RTL8139_TSAD3:
1608                 val = nic_state->regs.tsad[3];
1609                 break;
1610             case RTL8139_RBSTART:
1611                 val = nic_state->regs.rbstart;
1612                 break;
1613             case RTL8139_ERBCR:
1614                 val = nic_state->regs.erbcr;
1615                 break;
1616             case RTL8139_ERSR:
1617                 val = nic_state->regs.ersr;
1618                 break;
1619             case RTL8139_CR:
1620                 val = rtl8139_cmd_read(dev);
1621                 break;
1622             case RTL8139_CAPR:
1623                 val = rtl8139_capr_read(dev);
1624                 break;
1625             case RTL8139_CBR:
1626                 val = nic_state->regs.cbr;
1627                 break;
1628             case RTL8139_IMR:
1629                 val = nic_state->regs.imr;
1630                 break;
1631             case RTL8139_ISR:
1632                 val = rtl8139_isr_read(dev);
1633                 break;
1634             case RTL8139_TCR:
1635                 val = nic_state->regs.tcr;
1636                 break;
1637             case RTL8139_RCR:
1638                 val = nic_state->regs.rcr;
1639                 break;
1640             case RTL8139_TCTR:
1641                 val = nic_state->regs.tctr;
1642                 break;
1643             case RTL8139_MPC:
1644                 val = nic_state->regs.mpc;
1645                 break;
1646             case RTL8139_9346CR:
1647                 val = rtl8139_9346cr_read(dev);
1648                 break;
1649             case RTL8139_CONFIG0:
1650                 val = nic_state->regs.config[0];
1651                 break;
1652             case RTL8139_CONFIG1:
1653                 val = nic_state->regs.config[1];
1654                 break;
1655             case RTL8139_TimerInt:
1656                 val = nic_state->regs.timer_int;
1657                 break;
1658             case RTL8139_MSR:
1659                 val = nic_state->regs.msr;
1660                 break;
1661             case RTL8139_CONFIG3:
1662                 val = nic_state->regs.config3[0];
1663                 break;
1664             case RTL8139_CONFIG4:
1665                 val = nic_state->regs.config3[1];
1666                 break;
1667             case RTL8139_MULINT:
1668                 val = nic_state->regs.mulint;
1669                 break;
1670             case RTL8139_RERID:
1671                 val = nic_state->regs.rerid;
1672                 break;
1673             case RTL8139_TSAD:
1674                 val = rtl8139_tsad_read(dev);
1675                 break;
1676             case RTL8139_BMCR:
1677                 val = nic_state->regs.bmcr;
1678                 break;
1679             case RTL8139_BMSR:
1680                 val = nic_state->regs.bmsr;
1681                 break;
1682             case RTL8139_ANAR:
1683                 val = nic_state->regs.anar;
1684                 break;
1685             case RTL8139_ANLPAR:
1686                 val = nic_state->regs.anlpar;
1687                 break;
1688             case RTL8139_ANER:
1689                 val = nic_state->regs.aner;
1690                 break;
1691             case RTL8139_DIS:
1692                 val = nic_state->regs.dis;
1693                 break;
1694             case RTL8139_FCSC:
1695                 val = nic_state->regs.fcsc;
1696                 break;
1697             case RTL8139_NWAYTR:
1698                 val = nic_state->regs.nwaytr;
1699                 break;
1700             case RTL8139_REC:
1701                 val = nic_state->regs.rec;
1702                 break;
1703             case RTL8139_CSCR:
1704                 val = nic_state->regs.cscr;
1705                 break;
1706             case RTL8139_PHY1_PARM:
1707                 val = nic_state->regs.phy1_parm;
1708                 break;
1709             case RTL8139_TW_PARM:
1710                 val = nic_state->regs.tw_parm;
1711                 break;
1712             case RTL8139_PHY2_PARM:
1713                 val = nic_state->regs.phy2_parm;
1714                 break;
1715             case RTL8139_CRC0:
1716                 val = nic_state->regs.crc[0];
1717                 break;
1718             case RTL8139_CRC1:
1719                 val = nic_state->regs.crc[1];
1720                 break;
1721             case RTL8139_CRC2:
1722                 val = nic_state->regs.crc[2];
1723                 break;
1724             case RTL8139_CRC3:
1725                 val = nic_state->regs.crc[3];
1726                 break;
1727             case RTL8139_CRC4:
1728                 val = nic_state->regs.crc[4];
1729                 break;
1730             case RTL8139_CRC5:
1731                 val = nic_state->regs.crc[5];
1732                 break;
1733             case RTL8139_CRC6:
1734                 val = nic_state->regs.crc[6];
1735                 break;
1736             case RTL8139_CRC7:
1737                 val = nic_state->regs.crc[7];
1738                 break;
1739             case RTL8139_Config5:
1740                 val = nic_state->regs.config5;
1741                 break;
1742             default:
1743                  val = 0x0;
1744                  break;
1745     }
1746
1747     memcpy(dst, &val, length);
1748
1749     PrintDebug("rtl8139 mmio read: port:0x%x (%u bytes): 0x%x\n", (int)guest_addr, length, val);
1750
1751 #if TEST_PERFORMANCE
1752     if (need_hook(port, read))
1753                 io_hooked ++;
1754     if (( ++io_total) % 50 == 0)
1755          PrintError("RTL8139: Total IO: %d, Hooked: %d, INT: %d\n", io_total, io_hooked, int_total);
1756 #endif
1757
1758     return length;
1759 }
1760
1761
1762 static int rtl8139_ioport_write(struct guest_info * core, uint16_t port, void *src, uint_t length, void * private_data)
1763 {
1764     PrintDebug("rtl8139 pio write: port:0x%x (%u bytes)\n", port, length);
1765
1766     rtl8139_mmio_write((addr_t)port, src, length, private_data);
1767
1768     return length;
1769 }
1770
1771 static int rtl8139_ioport_read(uint16_t port, void *dst, uint_t length, struct vm_device *dev)
1772 {
1773     PrintDebug("rtl8139 pio read: port:0x%x (%u bytes)\n", port, length);
1774
1775     rtl8139_mmio_read((addr_t)port, dst, length, (void *)dev);
1776
1777     return length;
1778 }
1779
1780 static int rtl8139_reset_device(struct vm_device *dev)
1781 {
1782     struct nic_context *nic_state = (struct nic_context *)dev->private_data;
1783     struct nic_regs *regs = &(nic_state->regs);
1784     regs->cmd |= CMD_Rst;
1785     init_rtl8139(dev);
1786     regs->cmd &= ~CMD_Rst;
1787     return 0;
1788 }
1789
1790 static int rtl8139_start_device(struct vm_device *dev)
1791 {
1792     PrintDebug("rtl8139: start device\n");
1793     struct nic_context *nic_state = (struct nic_context *)dev->private_data;
1794     struct nic_regs *regs = &(nic_state->regs);
1795     regs->cmd |= CMD_Re | CMD_Te;
1796     return 0;
1797 }
1798
1799 static int rtl8139_stop_device(struct vm_device *dev)
1800 {
1801     PrintDebug("rtl8139: stop device\n");
1802     struct nic_context *nic_state = (struct nic_context *)dev->private_data;
1803     struct nic_regs *regs = &(nic_state->regs);
1804     regs->cmd &= ~(CMD_Re | CMD_Te);
1805     return 0;
1806 }
1807
1808 static void init_phy_network()
1809 {
1810     V3_REGISTER_PKT_DELIVERY(&netif_input);
1811 }
1812
1813 static int rtl8139_hook_iospace(struct vm_device *vmdev, addr_t base_addr, int size, int type, void *data)
1814 {
1815     int i;
1816
1817     if (base_addr <= 0)
1818     {
1819         PrintError("In RTL8139: Fail to Hook IO Space, base address 0x%x\n", (int) base_addr);
1820         return -1;
1821     }
1822
1823     if (type == PCI_ADDRESS_SPACE_IO){
1824         PrintDebug("In RTL8139: Hook IO ports starting from %x, size %d\n", (int) base_addr, size);
1825
1826         for (i = 0; i < 0xff; i++)
1827         {
1828             v3_dev_hook_io(vmdev, base_addr + i, &rtl8139_ioport_read, &rtl8139_ioport_write);
1829         }
1830     } else if (type == PCI_ADDRESS_SPACE_MEM) {
1831         PrintDebug("In RTL8139: Hook memory space starting from %x, size %d\n", (int) base_addr, size);
1832
1833         //hook memory mapped I/O
1834         v3_hook_full_mem(vmdev->vm, base_addr, base_addr + 0xff,
1835                                      &rtl8139_mmio_read, &rtl8139_mmio_write, vmdev);
1836     } else {
1837        PrintError("In RTL8139: unknown memory type: start %x, size %d\n", (int) base_addr, size);
1838     }
1839
1840     return 0;
1841 }
1842
1843 static int rtl8139_unhook_iospace()
1844 {
1845
1846     return 0;
1847 }
1848
1849
1850 static struct pci_device * rtl8139_pci_init(struct vm_device *vmdev, struct pci_bus *bus, int devfn)
1851 {
1852     uchar_t *pci_conf;
1853     struct pci_device *pdev;
1854
1855     pdev = v3_pci_register_device(vmdev, bus, "REALTEK8139", devfn, NULL, NULL);
1856
1857     if (pdev == NULL)
1858     {
1859         PrintError("NIC: Register to PCI bus failed\n");
1860          return NULL;
1861     }
1862
1863     pci_conf = pdev->configs;
1864
1865     pci_conf[0x00] = 0xec;
1866     pci_conf[0x01] = 0x10;
1867     pci_conf[0x02] = 0x39;
1868     pci_conf[0x03] = 0x81;
1869     pci_conf[0x04] = 0x05; /* command = I/O space, Bus Master */
1870     pci_conf[0x08] = RTL8139_PCI_REVID_8139; /* PCI revision ID; >=0x20 is for 8139C+ */
1871     pci_conf[0x0a] = 0x00; // ethernet network controller
1872     pci_conf[0x0b] = 0x02;
1873     pci_conf[0x0e] = 0x00; // header_type
1874     pci_conf[0x3d] = 1; // interrupt pin 0
1875     pci_conf[0x3c] = 12;
1876     pci_conf[0x34] = 0xdc;
1877
1878     pdev->vmdev = vmdev;
1879
1880     v3_pci_register_io_region(pdev, 0, 0x100, PCI_ADDRESS_SPACE_IO, &rtl8139_hook_iospace);
1881     v3_pci_register_io_region(pdev, 1, 0x100, PCI_ADDRESS_SPACE_MEM, &rtl8139_hook_iospace);
1882
1883     return pdev;
1884 }
1885
1886 static int rtl8139_init_state(struct rtl8139_state *nic_state)
1887 {
1888     PrintDebug("rtl8139: init_state\n");
1889
1890     init_phy_network();
1891     init_rtl8139(dev);
1892     current_vnic = dev;
1893     bus = v3_get_pcibus(dev->vm, 0);
1894
1895     if (bus != NULL)
1896     {
1897             PrintDebug("Find PCI bus in guest, attach nic to the bus %p\n", bus);
1898            pdev = rtl8139_pci_init(dev, bus, -1);
1899             if (pdev == NULL)
1900                     PrintError("Failure to attach nic to the bus %p\n", bus);
1901     }
1902
1903     nic_state->pci_dev = pdev;
1904
1905     //rtl8139_hook_iospace(dev, 0x2000, 0x100, 1, NULL);
1906
1907     return 0;
1908 }
1909
1910 static int rtl8139_deinit_device(struct vm_device *dev)
1911 {
1912
1913     rtl8139_unhook_iospace();
1914
1915     return 0;
1916 }
1917
1918 static struct vm_device_ops dev_ops =
1919 {
1920     .init = rtl8139_init_device,
1921     .deinit = rtl8139_deinit_device,
1922     .reset = rtl8139_reset_device,
1923     .start = rtl8139_start_device,
1924     .stop = rtl8139_stop_device,
1925 };
1926
1927 struct vm_device *v3_create_rtl8139()
1928 {
1929     struct nic_context *nic_state = V3_Malloc(sizeof(struct nic_context));
1930     PrintDebug("rtl8139 internal at %p\n", (void *)nic_state);
1931     struct vm_device *dev = v3_create_device("RTL8139", &dev_ops, nic_state);
1932     return dev;
1933 };
1934
1935
1936
1937 static int register_dev(struct ne2k_state * nic_state)
1938 {
1939     int i;
1940
1941     if (nic_state->pci_bus != NULL) {
1942         struct v3_pci_bar bars[6];
1943         struct pci_device * pci_dev = NULL;
1944
1945         PrintDebug("NE2000: PCI Enabled\n");
1946
1947         for (i = 0; i < 6; i++) {
1948             bars[i].type = PCI_BAR_NONE;
1949         }
1950
1951         bars[0].type = PCI_BAR_IO;
1952         bars[0].default_base_port = NIC_REG_BASE_PORT;
1953         bars[0].num_ports = 256;
1954
1955         bars[0].io_read = ne2k_pci_read;
1956         bars[0].io_write = ne2k_pci_write;
1957        bars[0].private_data = nic_state;
1958
1959         pci_dev = v3_pci_register_device(nic_state->pci_bus, PCI_STD_DEVICE, 0, -1, 0,
1960                                          "NE2000", bars,
1961                                          pci_config_update, NULL, NULL, nic_state);
1962
1963
1964         if (pci_dev == NULL) {
1965             PrintError("NE2000: Could not register PCI Device\n");
1966             return -1;
1967         }
1968
1969         pci_dev->config_header.vendor_id = 0x10ec;
1970         pci_dev->config_header.device_id = 0x8029;
1971         pci_dev->config_header.revision = 0x00;
1972
1973         pci_dev->config_header.subclass = 0x00;
1974         pci_dev->config_header.class = 0x02;
1975         pci_dev->config_header.header_type = 0x00;
1976
1977         pci_dev->config_header.intr_line = 11;
1978         pci_dev->config_header.intr_pin = 1;
1979
1980         nic_state->pci_dev = pci_dev;
1981     }else {
1982         PrintDebug("NE2000: Not attached to PCI\n");
1983
1984         v3_dev_hook_io(nic_state->dev, NIC_REG_BASE_PORT , &ne2k_cmd_read, &ne2k_cmd_write);
1985
1986         for (i = 1; i < 16; i++){
1987             v3_dev_hook_io(nic_state->dev, NIC_REG_BASE_PORT + i, &ne2k_std_read, &ne2k_std_write);
1988         }
1989
1990         v3_dev_hook_io(nic_state->dev, NIC_DATA_PORT, &ne2k_data_read, &ne2k_data_write);
1991         v3_dev_hook_io(nic_state->dev, NIC_RESET_PORT, &ne2k_reset_port_read, &ne2k_reset_port_write);
1992     }
1993
1994
1995     return 0;
1996 }
1997
1998 static int connect_fn(struct v3_vm_info * info,
1999                       void * frontend_data,
2000                       struct v3_dev_net_ops * ops,
2001                       v3_cfg_tree_t * cfg,
2002                       void * private_data) {
2003     struct ne2k_state * nic_state = (struct ne2k_state *)frontend_data;
2004
2005     rtl8139_init_state(nic_state);
2006     register_dev(nic_state);
2007
2008     nic_state->net_ops = ops;
2009     nic_state->backend_data = private_data;
2010
2011     ops->recv = ne2k_rx;
2012     ops->poll = NULL;
2013     ops->start_tx = NULL;
2014     ops->stop_tx = NULL;
2015     ops->frontend_data = nic_state;
2016     memcpy(ops->fnt_mac, nic_state->mac, ETH_ALEN);
2017
2018     return 0;
2019 }
2020
2021
2022 static int rtl8139_free(struct ne2k_state * nic_state) {
2023     int i;
2024
2025     /* dettached from backend */
2026
2027     if(nic_state->pci_bus == NULL){
2028         for (i = 0; i < 16; i++){
2029             v3_dev_unhook_io(nic_state->dev, NIC_REG_BASE_PORT + i);
2030         }
2031
2032        v3_dev_unhook_io(nic_state->dev, NIC_DATA_PORT);
2033        v3_dev_unhook_io(nic_state->dev, NIC_RESET_PORT);
2034     }else {
2035        /* unregistered from PCI? */
2036     }
2037
2038     return 0;
2039
2040     V3_Free(nic_state);
2041
2042     return 0;
2043 }
2044
2045
2046 static struct v3_device_ops dev_ops = {
2047     .free = (int (*)(void *))rtl8139_free,
2048 };
2049
2050
2051 static int rtl8139_init(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) {
2052     struct vm_device * pci_bus = v3_find_dev(vm, v3_cfg_val(cfg, "bus"));
2053     struct rtl8139_state * nic_state = NULL;
2054     char * dev_id = v3_cfg_val(cfg, "ID");
2055     char * macstr = v3_cfg_val(cfg, "mac");
2056
2057     nic_state  = (struct rtl8139_state *)V3_Malloc(sizeof(struct rtl8139_state));
2058     memset(nic_state, 0, sizeof(struct ne2k_state));
2059
2060     nic_state->pci_bus = pci_bus;
2061     nic_state->vm = vm;
2062
2063     if (macstr != NULL && !str2mac(macstr, nic_state->mac)) {
2064         PrintDebug("RTL8139: Mac specified %s\n", macstr);
2065     }else {
2066         PrintDebug("RTL8139: MAC not specified\n");
2067         random_ethaddr(nic_state->mac);
2068     }
2069
2070     struct vm_device * dev = v3_add_device(vm, dev_id, &dev_ops, nic_state);
2071
2072     if (dev == NULL) {
2073         PrintError("RTL8139: Could not attach device %s\n", dev_id);
2074         V3_Free(nic_state);
2075         return -1;
2076     }
2077
2078     nic_state->dev = dev;
2079
2080     if (v3_dev_add_net_frontend(vm, dev_id, connect_fn, (void *)nic_state) == -1) {
2081         PrintError("RTL8139: Could not register %s as net frontend\n", dev_id);
2082         v3_remove_device(dev);
2083         V3_Free(nic_state);
2084         return -1;
2085     }
2086
2087     return 0;
2088 }
2089
2090 device_register("RTL8139", rtl8139_init)