sungem.c (43577B)
1 /* 2 * QEMU model of SUN GEM ethernet controller 3 * 4 * As found in Apple ASICs among others 5 * 6 * Copyright 2016 Ben Herrenschmidt 7 * Copyright 2017 Mark Cave-Ayland 8 */ 9 10 #include "qemu/osdep.h" 11 #include "hw/pci/pci.h" 12 #include "hw/qdev-properties.h" 13 #include "migration/vmstate.h" 14 #include "qemu/log.h" 15 #include "qemu/module.h" 16 #include "net/net.h" 17 #include "net/eth.h" 18 #include "net/checksum.h" 19 #include "hw/net/mii.h" 20 #include "sysemu/sysemu.h" 21 #include "trace.h" 22 #include "qom/object.h" 23 24 #define TYPE_SUNGEM "sungem" 25 26 OBJECT_DECLARE_SIMPLE_TYPE(SunGEMState, SUNGEM) 27 28 #define MAX_PACKET_SIZE 9016 29 30 #define SUNGEM_MMIO_SIZE 0x200000 31 32 /* Global registers */ 33 #define SUNGEM_MMIO_GREG_SIZE 0x2000 34 35 #define GREG_SEBSTATE 0x0000UL /* SEB State Register */ 36 37 #define GREG_STAT 0x000CUL /* Status Register */ 38 #define GREG_STAT_TXINTME 0x00000001 /* TX INTME frame transferred */ 39 #define GREG_STAT_TXALL 0x00000002 /* All TX frames transferred */ 40 #define GREG_STAT_TXDONE 0x00000004 /* One TX frame transferred */ 41 #define GREG_STAT_RXDONE 0x00000010 /* One RX frame arrived */ 42 #define GREG_STAT_RXNOBUF 0x00000020 /* No free RX buffers available */ 43 #define GREG_STAT_RXTAGERR 0x00000040 /* RX tag framing is corrupt */ 44 #define GREG_STAT_TXMAC 0x00004000 /* TX MAC signalled interrupt */ 45 #define GREG_STAT_RXMAC 0x00008000 /* RX MAC signalled interrupt */ 46 #define GREG_STAT_MAC 0x00010000 /* MAC Control signalled irq */ 47 #define GREG_STAT_TXNR 0xfff80000 /* == TXDMA_TXDONE reg val */ 48 #define GREG_STAT_TXNR_SHIFT 19 49 50 /* These interrupts are edge latches in the status register, 51 * reading it (or writing the corresponding bit in IACK) will 52 * clear them 53 */ 54 #define GREG_STAT_LATCH (GREG_STAT_TXALL | GREG_STAT_TXINTME | \ 55 GREG_STAT_RXDONE | GREG_STAT_RXDONE | \ 56 GREG_STAT_RXNOBUF | GREG_STAT_RXTAGERR) 57 58 #define GREG_IMASK 0x0010UL /* Interrupt Mask Register */ 59 #define GREG_IACK 0x0014UL /* Interrupt ACK Register */ 60 #define GREG_STAT2 0x001CUL /* Alias of GREG_STAT */ 61 #define GREG_PCIESTAT 0x1000UL /* PCI Error Status Register */ 62 #define GREG_PCIEMASK 0x1004UL /* PCI Error Mask Register */ 63 64 #define GREG_SWRST 0x1010UL /* Software Reset Register */ 65 #define GREG_SWRST_TXRST 0x00000001 /* TX Software Reset */ 66 #define GREG_SWRST_RXRST 0x00000002 /* RX Software Reset */ 67 #define GREG_SWRST_RSTOUT 0x00000004 /* Force RST# pin active */ 68 69 /* TX DMA Registers */ 70 #define SUNGEM_MMIO_TXDMA_SIZE 0x1000 71 72 #define TXDMA_KICK 0x0000UL /* TX Kick Register */ 73 74 #define TXDMA_CFG 0x0004UL /* TX Configuration Register */ 75 #define TXDMA_CFG_ENABLE 0x00000001 /* Enable TX DMA channel */ 76 #define TXDMA_CFG_RINGSZ 0x0000001e /* TX descriptor ring size */ 77 78 #define TXDMA_DBLOW 0x0008UL /* TX Desc. Base Low */ 79 #define TXDMA_DBHI 0x000CUL /* TX Desc. Base High */ 80 #define TXDMA_PCNT 0x0024UL /* TX FIFO Packet Counter */ 81 #define TXDMA_SMACHINE 0x0028UL /* TX State Machine Register */ 82 #define TXDMA_DPLOW 0x0030UL /* TX Data Pointer Low */ 83 #define TXDMA_DPHI 0x0034UL /* TX Data Pointer High */ 84 #define TXDMA_TXDONE 0x0100UL /* TX Completion Register */ 85 #define TXDMA_FTAG 0x0108UL /* TX FIFO Tag */ 86 #define TXDMA_FSZ 0x0118UL /* TX FIFO Size */ 87 88 /* Receive DMA Registers */ 89 #define SUNGEM_MMIO_RXDMA_SIZE 0x2000 90 91 #define RXDMA_CFG 0x0000UL /* RX Configuration Register */ 92 #define RXDMA_CFG_ENABLE 0x00000001 /* Enable RX DMA channel */ 93 #define RXDMA_CFG_RINGSZ 0x0000001e /* RX descriptor ring size */ 94 #define RXDMA_CFG_FBOFF 0x00001c00 /* Offset of first data byte */ 95 #define RXDMA_CFG_CSUMOFF 0x000fe000 /* Skip bytes before csum calc */ 96 97 #define RXDMA_DBLOW 0x0004UL /* RX Descriptor Base Low */ 98 #define RXDMA_DBHI 0x0008UL /* RX Descriptor Base High */ 99 #define RXDMA_PCNT 0x0018UL /* RX FIFO Packet Counter */ 100 #define RXDMA_SMACHINE 0x001CUL /* RX State Machine Register */ 101 #define RXDMA_PTHRESH 0x0020UL /* Pause Thresholds */ 102 #define RXDMA_DPLOW 0x0024UL /* RX Data Pointer Low */ 103 #define RXDMA_DPHI 0x0028UL /* RX Data Pointer High */ 104 #define RXDMA_KICK 0x0100UL /* RX Kick Register */ 105 #define RXDMA_DONE 0x0104UL /* RX Completion Register */ 106 #define RXDMA_BLANK 0x0108UL /* RX Blanking Register */ 107 #define RXDMA_FTAG 0x0110UL /* RX FIFO Tag */ 108 #define RXDMA_FSZ 0x0120UL /* RX FIFO Size */ 109 110 /* MAC Registers */ 111 #define SUNGEM_MMIO_MAC_SIZE 0x200 112 113 #define MAC_TXRST 0x0000UL /* TX MAC Software Reset Command */ 114 #define MAC_RXRST 0x0004UL /* RX MAC Software Reset Command */ 115 #define MAC_TXSTAT 0x0010UL /* TX MAC Status Register */ 116 #define MAC_RXSTAT 0x0014UL /* RX MAC Status Register */ 117 118 #define MAC_CSTAT 0x0018UL /* MAC Control Status Register */ 119 #define MAC_CSTAT_PTR 0xffff0000 /* Pause Time Received */ 120 121 #define MAC_TXMASK 0x0020UL /* TX MAC Mask Register */ 122 #define MAC_RXMASK 0x0024UL /* RX MAC Mask Register */ 123 #define MAC_MCMASK 0x0028UL /* MAC Control Mask Register */ 124 125 #define MAC_TXCFG 0x0030UL /* TX MAC Configuration Register */ 126 #define MAC_TXCFG_ENAB 0x00000001 /* TX MAC Enable */ 127 128 #define MAC_RXCFG 0x0034UL /* RX MAC Configuration Register */ 129 #define MAC_RXCFG_ENAB 0x00000001 /* RX MAC Enable */ 130 #define MAC_RXCFG_SFCS 0x00000004 /* Strip FCS */ 131 #define MAC_RXCFG_PROM 0x00000008 /* Promiscuous Mode */ 132 #define MAC_RXCFG_PGRP 0x00000010 /* Promiscuous Group */ 133 #define MAC_RXCFG_HFE 0x00000020 /* Hash Filter Enable */ 134 135 #define MAC_XIFCFG 0x003CUL /* XIF Configuration Register */ 136 #define MAC_XIFCFG_LBCK 0x00000002 /* Loopback TX to RX */ 137 138 #define MAC_MINFSZ 0x0050UL /* MinFrameSize Register */ 139 #define MAC_MAXFSZ 0x0054UL /* MaxFrameSize Register */ 140 #define MAC_ADDR0 0x0080UL /* MAC Address 0 Register */ 141 #define MAC_ADDR1 0x0084UL /* MAC Address 1 Register */ 142 #define MAC_ADDR2 0x0088UL /* MAC Address 2 Register */ 143 #define MAC_ADDR3 0x008CUL /* MAC Address 3 Register */ 144 #define MAC_ADDR4 0x0090UL /* MAC Address 4 Register */ 145 #define MAC_ADDR5 0x0094UL /* MAC Address 5 Register */ 146 #define MAC_HASH0 0x00C0UL /* Hash Table 0 Register */ 147 #define MAC_PATMPS 0x0114UL /* Peak Attempts Register */ 148 #define MAC_SMACHINE 0x0134UL /* State Machine Register */ 149 150 /* MIF Registers */ 151 #define SUNGEM_MMIO_MIF_SIZE 0x20 152 153 #define MIF_FRAME 0x000CUL /* MIF Frame/Output Register */ 154 #define MIF_FRAME_OP 0x30000000 /* OPcode */ 155 #define MIF_FRAME_PHYAD 0x0f800000 /* PHY ADdress */ 156 #define MIF_FRAME_REGAD 0x007c0000 /* REGister ADdress */ 157 #define MIF_FRAME_TALSB 0x00010000 /* Turn Around LSB */ 158 #define MIF_FRAME_DATA 0x0000ffff /* Instruction Payload */ 159 160 #define MIF_CFG 0x0010UL /* MIF Configuration Register */ 161 #define MIF_CFG_MDI0 0x00000100 /* MDIO_0 present or read-bit */ 162 #define MIF_CFG_MDI1 0x00000200 /* MDIO_1 present or read-bit */ 163 164 #define MIF_STATUS 0x0018UL /* MIF Status Register */ 165 #define MIF_SMACHINE 0x001CUL /* MIF State Machine Register */ 166 167 /* PCS/Serialink Registers */ 168 #define SUNGEM_MMIO_PCS_SIZE 0x60 169 #define PCS_MIISTAT 0x0004UL /* PCS MII Status Register */ 170 #define PCS_ISTAT 0x0018UL /* PCS Interrupt Status Reg */ 171 #define PCS_SSTATE 0x005CUL /* Serialink State Register */ 172 173 /* Descriptors */ 174 struct gem_txd { 175 uint64_t control_word; 176 uint64_t buffer; 177 }; 178 179 #define TXDCTRL_BUFSZ 0x0000000000007fffULL /* Buffer Size */ 180 #define TXDCTRL_CSTART 0x00000000001f8000ULL /* CSUM Start Offset */ 181 #define TXDCTRL_COFF 0x000000001fe00000ULL /* CSUM Stuff Offset */ 182 #define TXDCTRL_CENAB 0x0000000020000000ULL /* CSUM Enable */ 183 #define TXDCTRL_EOF 0x0000000040000000ULL /* End of Frame */ 184 #define TXDCTRL_SOF 0x0000000080000000ULL /* Start of Frame */ 185 #define TXDCTRL_INTME 0x0000000100000000ULL /* "Interrupt Me" */ 186 187 struct gem_rxd { 188 uint64_t status_word; 189 uint64_t buffer; 190 }; 191 192 #define RXDCTRL_HPASS 0x1000000000000000ULL /* Passed Hash Filter */ 193 #define RXDCTRL_ALTMAC 0x2000000000000000ULL /* Matched ALT MAC */ 194 195 196 struct SunGEMState { 197 PCIDevice pdev; 198 199 MemoryRegion sungem; 200 MemoryRegion greg; 201 MemoryRegion txdma; 202 MemoryRegion rxdma; 203 MemoryRegion mac; 204 MemoryRegion mif; 205 MemoryRegion pcs; 206 NICState *nic; 207 NICConf conf; 208 uint32_t phy_addr; 209 210 uint32_t gregs[SUNGEM_MMIO_GREG_SIZE >> 2]; 211 uint32_t txdmaregs[SUNGEM_MMIO_TXDMA_SIZE >> 2]; 212 uint32_t rxdmaregs[SUNGEM_MMIO_RXDMA_SIZE >> 2]; 213 uint32_t macregs[SUNGEM_MMIO_MAC_SIZE >> 2]; 214 uint32_t mifregs[SUNGEM_MMIO_MIF_SIZE >> 2]; 215 uint32_t pcsregs[SUNGEM_MMIO_PCS_SIZE >> 2]; 216 217 /* Cache some useful things */ 218 uint32_t rx_mask; 219 uint32_t tx_mask; 220 221 /* Current tx packet */ 222 uint8_t tx_data[MAX_PACKET_SIZE]; 223 uint32_t tx_size; 224 uint64_t tx_first_ctl; 225 }; 226 227 228 static void sungem_eval_irq(SunGEMState *s) 229 { 230 uint32_t stat, mask; 231 232 mask = s->gregs[GREG_IMASK >> 2]; 233 stat = s->gregs[GREG_STAT >> 2] & ~GREG_STAT_TXNR; 234 if (stat & ~mask) { 235 pci_set_irq(PCI_DEVICE(s), 1); 236 } else { 237 pci_set_irq(PCI_DEVICE(s), 0); 238 } 239 } 240 241 static void sungem_update_status(SunGEMState *s, uint32_t bits, bool val) 242 { 243 uint32_t stat; 244 245 stat = s->gregs[GREG_STAT >> 2]; 246 if (val) { 247 stat |= bits; 248 } else { 249 stat &= ~bits; 250 } 251 s->gregs[GREG_STAT >> 2] = stat; 252 sungem_eval_irq(s); 253 } 254 255 static void sungem_eval_cascade_irq(SunGEMState *s) 256 { 257 uint32_t stat, mask; 258 259 mask = s->macregs[MAC_TXSTAT >> 2]; 260 stat = s->macregs[MAC_TXMASK >> 2]; 261 if (stat & ~mask) { 262 sungem_update_status(s, GREG_STAT_TXMAC, true); 263 } else { 264 sungem_update_status(s, GREG_STAT_TXMAC, false); 265 } 266 267 mask = s->macregs[MAC_RXSTAT >> 2]; 268 stat = s->macregs[MAC_RXMASK >> 2]; 269 if (stat & ~mask) { 270 sungem_update_status(s, GREG_STAT_RXMAC, true); 271 } else { 272 sungem_update_status(s, GREG_STAT_RXMAC, false); 273 } 274 275 mask = s->macregs[MAC_CSTAT >> 2]; 276 stat = s->macregs[MAC_MCMASK >> 2] & ~MAC_CSTAT_PTR; 277 if (stat & ~mask) { 278 sungem_update_status(s, GREG_STAT_MAC, true); 279 } else { 280 sungem_update_status(s, GREG_STAT_MAC, false); 281 } 282 } 283 284 static void sungem_do_tx_csum(SunGEMState *s) 285 { 286 uint16_t start, off; 287 uint32_t csum; 288 289 start = (s->tx_first_ctl & TXDCTRL_CSTART) >> 15; 290 off = (s->tx_first_ctl & TXDCTRL_COFF) >> 21; 291 292 trace_sungem_tx_checksum(start, off); 293 294 if (start > (s->tx_size - 2) || off > (s->tx_size - 2)) { 295 trace_sungem_tx_checksum_oob(); 296 return; 297 } 298 299 csum = net_raw_checksum(s->tx_data + start, s->tx_size - start); 300 stw_be_p(s->tx_data + off, csum); 301 } 302 303 static void sungem_send_packet(SunGEMState *s, const uint8_t *buf, 304 int size) 305 { 306 NetClientState *nc = qemu_get_queue(s->nic); 307 308 if (s->macregs[MAC_XIFCFG >> 2] & MAC_XIFCFG_LBCK) { 309 qemu_receive_packet(nc, buf, size); 310 } else { 311 qemu_send_packet(nc, buf, size); 312 } 313 } 314 315 static void sungem_process_tx_desc(SunGEMState *s, struct gem_txd *desc) 316 { 317 PCIDevice *d = PCI_DEVICE(s); 318 uint32_t len; 319 320 /* If it's a start of frame, discard anything we had in the 321 * buffer and start again. This should be an error condition 322 * if we had something ... for now we ignore it 323 */ 324 if (desc->control_word & TXDCTRL_SOF) { 325 if (s->tx_first_ctl) { 326 trace_sungem_tx_unfinished(); 327 } 328 s->tx_size = 0; 329 s->tx_first_ctl = desc->control_word; 330 } 331 332 /* Grab data size */ 333 len = desc->control_word & TXDCTRL_BUFSZ; 334 335 /* Clamp it to our max size */ 336 if ((s->tx_size + len) > MAX_PACKET_SIZE) { 337 trace_sungem_tx_overflow(); 338 len = MAX_PACKET_SIZE - s->tx_size; 339 } 340 341 /* Read the data */ 342 pci_dma_read(d, desc->buffer, &s->tx_data[s->tx_size], len); 343 s->tx_size += len; 344 345 /* If end of frame, send packet */ 346 if (desc->control_word & TXDCTRL_EOF) { 347 trace_sungem_tx_finished(s->tx_size); 348 349 /* Handle csum */ 350 if (s->tx_first_ctl & TXDCTRL_CENAB) { 351 sungem_do_tx_csum(s); 352 } 353 354 /* Send it */ 355 sungem_send_packet(s, s->tx_data, s->tx_size); 356 357 /* No more pending packet */ 358 s->tx_size = 0; 359 s->tx_first_ctl = 0; 360 } 361 } 362 363 static void sungem_tx_kick(SunGEMState *s) 364 { 365 PCIDevice *d = PCI_DEVICE(s); 366 uint32_t comp, kick; 367 uint32_t txdma_cfg, txmac_cfg, ints; 368 uint64_t dbase; 369 370 trace_sungem_tx_kick(); 371 372 /* Check that both TX MAC and TX DMA are enabled. We don't 373 * handle DMA-less direct FIFO operations (we don't emulate 374 * the FIFO at all). 375 * 376 * A write to TXDMA_KICK while DMA isn't enabled can happen 377 * when the driver is resetting the pointer. 378 */ 379 txdma_cfg = s->txdmaregs[TXDMA_CFG >> 2]; 380 txmac_cfg = s->macregs[MAC_TXCFG >> 2]; 381 if (!(txdma_cfg & TXDMA_CFG_ENABLE) || 382 !(txmac_cfg & MAC_TXCFG_ENAB)) { 383 trace_sungem_tx_disabled(); 384 return; 385 } 386 387 /* XXX Test min frame size register ? */ 388 /* XXX Test max frame size register ? */ 389 390 dbase = s->txdmaregs[TXDMA_DBHI >> 2]; 391 dbase = (dbase << 32) | s->txdmaregs[TXDMA_DBLOW >> 2]; 392 393 comp = s->txdmaregs[TXDMA_TXDONE >> 2] & s->tx_mask; 394 kick = s->txdmaregs[TXDMA_KICK >> 2] & s->tx_mask; 395 396 trace_sungem_tx_process(comp, kick, s->tx_mask + 1); 397 398 /* This is rather primitive for now, we just send everything we 399 * can in one go, like e1000. Ideally we should do the sending 400 * from some kind of background task 401 */ 402 while (comp != kick) { 403 struct gem_txd desc; 404 405 /* Read the next descriptor */ 406 pci_dma_read(d, dbase + comp * sizeof(desc), &desc, sizeof(desc)); 407 408 /* Byteswap descriptor */ 409 desc.control_word = le64_to_cpu(desc.control_word); 410 desc.buffer = le64_to_cpu(desc.buffer); 411 trace_sungem_tx_desc(comp, desc.control_word, desc.buffer); 412 413 /* Send it for processing */ 414 sungem_process_tx_desc(s, &desc); 415 416 /* Interrupt */ 417 ints = GREG_STAT_TXDONE; 418 if (desc.control_word & TXDCTRL_INTME) { 419 ints |= GREG_STAT_TXINTME; 420 } 421 sungem_update_status(s, ints, true); 422 423 /* Next ! */ 424 comp = (comp + 1) & s->tx_mask; 425 s->txdmaregs[TXDMA_TXDONE >> 2] = comp; 426 } 427 428 /* We sent everything, set status/irq bit */ 429 sungem_update_status(s, GREG_STAT_TXALL, true); 430 } 431 432 static bool sungem_rx_full(SunGEMState *s, uint32_t kick, uint32_t done) 433 { 434 return kick == ((done + 1) & s->rx_mask); 435 } 436 437 static bool sungem_can_receive(NetClientState *nc) 438 { 439 SunGEMState *s = qemu_get_nic_opaque(nc); 440 uint32_t kick, done, rxdma_cfg, rxmac_cfg; 441 bool full; 442 443 rxmac_cfg = s->macregs[MAC_RXCFG >> 2]; 444 rxdma_cfg = s->rxdmaregs[RXDMA_CFG >> 2]; 445 446 /* If MAC disabled, can't receive */ 447 if ((rxmac_cfg & MAC_RXCFG_ENAB) == 0) { 448 trace_sungem_rx_mac_disabled(); 449 return false; 450 } 451 if ((rxdma_cfg & RXDMA_CFG_ENABLE) == 0) { 452 trace_sungem_rx_txdma_disabled(); 453 return false; 454 } 455 456 /* Check RX availability */ 457 kick = s->rxdmaregs[RXDMA_KICK >> 2]; 458 done = s->rxdmaregs[RXDMA_DONE >> 2]; 459 full = sungem_rx_full(s, kick, done); 460 461 trace_sungem_rx_check(!full, kick, done); 462 463 return !full; 464 } 465 466 enum { 467 rx_no_match, 468 rx_match_promisc, 469 rx_match_bcast, 470 rx_match_allmcast, 471 rx_match_mcast, 472 rx_match_mac, 473 rx_match_altmac, 474 }; 475 476 static int sungem_check_rx_mac(SunGEMState *s, const uint8_t *mac, uint32_t crc) 477 { 478 uint32_t rxcfg = s->macregs[MAC_RXCFG >> 2]; 479 uint32_t mac0, mac1, mac2; 480 481 /* Promisc enabled ? */ 482 if (rxcfg & MAC_RXCFG_PROM) { 483 return rx_match_promisc; 484 } 485 486 /* Format MAC address into dwords */ 487 mac0 = (mac[4] << 8) | mac[5]; 488 mac1 = (mac[2] << 8) | mac[3]; 489 mac2 = (mac[0] << 8) | mac[1]; 490 491 trace_sungem_rx_mac_check(mac0, mac1, mac2); 492 493 /* Is this a broadcast frame ? */ 494 if (mac0 == 0xffff && mac1 == 0xffff && mac2 == 0xffff) { 495 return rx_match_bcast; 496 } 497 498 /* TODO: Implement address filter registers (or we don't care ?) */ 499 500 /* Is this a multicast frame ? */ 501 if (mac[0] & 1) { 502 trace_sungem_rx_mac_multicast(); 503 504 /* Promisc group enabled ? */ 505 if (rxcfg & MAC_RXCFG_PGRP) { 506 return rx_match_allmcast; 507 } 508 509 /* TODO: Check MAC control frames (or we don't care) ? */ 510 511 /* Check hash filter (somebody check that's correct ?) */ 512 if (rxcfg & MAC_RXCFG_HFE) { 513 uint32_t hash, idx; 514 515 crc >>= 24; 516 idx = (crc >> 2) & 0x3c; 517 hash = s->macregs[(MAC_HASH0 + idx) >> 2]; 518 if (hash & (1 << (15 - (crc & 0xf)))) { 519 return rx_match_mcast; 520 } 521 } 522 return rx_no_match; 523 } 524 525 /* Main MAC check */ 526 trace_sungem_rx_mac_compare(s->macregs[MAC_ADDR0 >> 2], 527 s->macregs[MAC_ADDR1 >> 2], 528 s->macregs[MAC_ADDR2 >> 2]); 529 530 if (mac0 == s->macregs[MAC_ADDR0 >> 2] && 531 mac1 == s->macregs[MAC_ADDR1 >> 2] && 532 mac2 == s->macregs[MAC_ADDR2 >> 2]) { 533 return rx_match_mac; 534 } 535 536 /* Alt MAC check */ 537 if (mac0 == s->macregs[MAC_ADDR3 >> 2] && 538 mac1 == s->macregs[MAC_ADDR4 >> 2] && 539 mac2 == s->macregs[MAC_ADDR5 >> 2]) { 540 return rx_match_altmac; 541 } 542 543 return rx_no_match; 544 } 545 546 static ssize_t sungem_receive(NetClientState *nc, const uint8_t *buf, 547 size_t size) 548 { 549 SunGEMState *s = qemu_get_nic_opaque(nc); 550 PCIDevice *d = PCI_DEVICE(s); 551 uint32_t mac_crc, done, kick, max_fsize; 552 uint32_t fcs_size, ints, rxdma_cfg, rxmac_cfg, csum, coff; 553 uint8_t smallbuf[60]; 554 struct gem_rxd desc; 555 uint64_t dbase, baddr; 556 unsigned int rx_cond; 557 558 trace_sungem_rx_packet(size); 559 560 rxmac_cfg = s->macregs[MAC_RXCFG >> 2]; 561 rxdma_cfg = s->rxdmaregs[RXDMA_CFG >> 2]; 562 max_fsize = s->macregs[MAC_MAXFSZ >> 2] & 0x7fff; 563 564 /* If MAC or DMA disabled, can't receive */ 565 if (!(rxdma_cfg & RXDMA_CFG_ENABLE) || 566 !(rxmac_cfg & MAC_RXCFG_ENAB)) { 567 trace_sungem_rx_disabled(); 568 return 0; 569 } 570 571 /* Size adjustment for FCS */ 572 if (rxmac_cfg & MAC_RXCFG_SFCS) { 573 fcs_size = 0; 574 } else { 575 fcs_size = 4; 576 } 577 578 /* Discard frame smaller than a MAC or larger than max frame size 579 * (when accounting for FCS) 580 */ 581 if (size < 6 || (size + 4) > max_fsize) { 582 trace_sungem_rx_bad_frame_size(size); 583 /* XXX Increment error statistics ? */ 584 return size; 585 } 586 587 /* We don't drop too small frames since we get them in qemu, we pad 588 * them instead. We should probably use the min frame size register 589 * but I don't want to use a variable size staging buffer and I 590 * know both MacOS and Linux use the default 64 anyway. We use 60 591 * here to account for the non-existent FCS. 592 */ 593 if (size < 60) { 594 memcpy(smallbuf, buf, size); 595 memset(&smallbuf[size], 0, 60 - size); 596 buf = smallbuf; 597 size = 60; 598 } 599 600 /* Get MAC crc */ 601 mac_crc = net_crc32_le(buf, ETH_ALEN); 602 603 /* Packet isn't for me ? */ 604 rx_cond = sungem_check_rx_mac(s, buf, mac_crc); 605 if (rx_cond == rx_no_match) { 606 /* Just drop it */ 607 trace_sungem_rx_unmatched(); 608 return size; 609 } 610 611 /* Get ring pointers */ 612 kick = s->rxdmaregs[RXDMA_KICK >> 2] & s->rx_mask; 613 done = s->rxdmaregs[RXDMA_DONE >> 2] & s->rx_mask; 614 615 trace_sungem_rx_process(done, kick, s->rx_mask + 1); 616 617 /* Ring full ? Can't receive */ 618 if (sungem_rx_full(s, kick, done)) { 619 trace_sungem_rx_ringfull(); 620 return 0; 621 } 622 623 /* Note: The real GEM will fetch descriptors in blocks of 4, 624 * for now we handle them one at a time, I think the driver will 625 * cope 626 */ 627 628 dbase = s->rxdmaregs[RXDMA_DBHI >> 2]; 629 dbase = (dbase << 32) | s->rxdmaregs[RXDMA_DBLOW >> 2]; 630 631 /* Read the next descriptor */ 632 pci_dma_read(d, dbase + done * sizeof(desc), &desc, sizeof(desc)); 633 634 trace_sungem_rx_desc(le64_to_cpu(desc.status_word), 635 le64_to_cpu(desc.buffer)); 636 637 /* Effective buffer address */ 638 baddr = le64_to_cpu(desc.buffer) & ~7ull; 639 baddr |= (rxdma_cfg & RXDMA_CFG_FBOFF) >> 10; 640 641 /* Write buffer out */ 642 pci_dma_write(d, baddr, buf, size); 643 644 if (fcs_size) { 645 /* Should we add an FCS ? Linux doesn't ask us to strip it, 646 * however I believe nothing checks it... For now we just 647 * do nothing. It's faster this way. 648 */ 649 } 650 651 /* Calculate the checksum */ 652 coff = (rxdma_cfg & RXDMA_CFG_CSUMOFF) >> 13; 653 csum = net_raw_checksum((uint8_t *)buf + coff, size - coff); 654 655 /* Build the updated descriptor */ 656 desc.status_word = (size + fcs_size) << 16; 657 desc.status_word |= ((uint64_t)(mac_crc >> 16)) << 44; 658 desc.status_word |= csum; 659 if (rx_cond == rx_match_mcast) { 660 desc.status_word |= RXDCTRL_HPASS; 661 } 662 if (rx_cond == rx_match_altmac) { 663 desc.status_word |= RXDCTRL_ALTMAC; 664 } 665 desc.status_word = cpu_to_le64(desc.status_word); 666 667 pci_dma_write(d, dbase + done * sizeof(desc), &desc, sizeof(desc)); 668 669 done = (done + 1) & s->rx_mask; 670 s->rxdmaregs[RXDMA_DONE >> 2] = done; 671 672 /* XXX Unconditionally set RX interrupt for now. The interrupt 673 * mitigation timer might well end up adding more overhead than 674 * helping here... 675 */ 676 ints = GREG_STAT_RXDONE; 677 if (sungem_rx_full(s, kick, done)) { 678 ints |= GREG_STAT_RXNOBUF; 679 } 680 sungem_update_status(s, ints, true); 681 682 return size; 683 } 684 685 static void sungem_set_link_status(NetClientState *nc) 686 { 687 /* We don't do anything for now as I believe none of the OSes 688 * drivers use the MIF autopoll feature nor the PHY interrupt 689 */ 690 } 691 692 static void sungem_update_masks(SunGEMState *s) 693 { 694 uint32_t sz; 695 696 sz = 1 << (((s->rxdmaregs[RXDMA_CFG >> 2] & RXDMA_CFG_RINGSZ) >> 1) + 5); 697 s->rx_mask = sz - 1; 698 699 sz = 1 << (((s->txdmaregs[TXDMA_CFG >> 2] & TXDMA_CFG_RINGSZ) >> 1) + 5); 700 s->tx_mask = sz - 1; 701 } 702 703 static void sungem_reset_rx(SunGEMState *s) 704 { 705 trace_sungem_rx_reset(); 706 707 /* XXX Do RXCFG */ 708 /* XXX Check value */ 709 s->rxdmaregs[RXDMA_FSZ >> 2] = 0x140; 710 s->rxdmaregs[RXDMA_DONE >> 2] = 0; 711 s->rxdmaregs[RXDMA_KICK >> 2] = 0; 712 s->rxdmaregs[RXDMA_CFG >> 2] = 0x1000010; 713 s->rxdmaregs[RXDMA_PTHRESH >> 2] = 0xf8; 714 s->rxdmaregs[RXDMA_BLANK >> 2] = 0; 715 716 sungem_update_masks(s); 717 } 718 719 static void sungem_reset_tx(SunGEMState *s) 720 { 721 trace_sungem_tx_reset(); 722 723 /* XXX Do TXCFG */ 724 /* XXX Check value */ 725 s->txdmaregs[TXDMA_FSZ >> 2] = 0x90; 726 s->txdmaregs[TXDMA_TXDONE >> 2] = 0; 727 s->txdmaregs[TXDMA_KICK >> 2] = 0; 728 s->txdmaregs[TXDMA_CFG >> 2] = 0x118010; 729 730 sungem_update_masks(s); 731 732 s->tx_size = 0; 733 s->tx_first_ctl = 0; 734 } 735 736 static void sungem_reset_all(SunGEMState *s, bool pci_reset) 737 { 738 trace_sungem_reset(pci_reset); 739 740 sungem_reset_rx(s); 741 sungem_reset_tx(s); 742 743 s->gregs[GREG_IMASK >> 2] = 0xFFFFFFF; 744 s->gregs[GREG_STAT >> 2] = 0; 745 if (pci_reset) { 746 uint8_t *ma = s->conf.macaddr.a; 747 748 s->gregs[GREG_SWRST >> 2] = 0; 749 s->macregs[MAC_ADDR0 >> 2] = (ma[4] << 8) | ma[5]; 750 s->macregs[MAC_ADDR1 >> 2] = (ma[2] << 8) | ma[3]; 751 s->macregs[MAC_ADDR2 >> 2] = (ma[0] << 8) | ma[1]; 752 } else { 753 s->gregs[GREG_SWRST >> 2] &= GREG_SWRST_RSTOUT; 754 } 755 s->mifregs[MIF_CFG >> 2] = MIF_CFG_MDI0; 756 } 757 758 static void sungem_mii_write(SunGEMState *s, uint8_t phy_addr, 759 uint8_t reg_addr, uint16_t val) 760 { 761 trace_sungem_mii_write(phy_addr, reg_addr, val); 762 763 /* XXX TODO */ 764 } 765 766 static uint16_t __sungem_mii_read(SunGEMState *s, uint8_t phy_addr, 767 uint8_t reg_addr) 768 { 769 if (phy_addr != s->phy_addr) { 770 return 0xffff; 771 } 772 /* Primitive emulation of a BCM5201 to please the driver, 773 * ID is 0x00406210. TODO: Do a gigabit PHY like BCM5400 774 */ 775 switch (reg_addr) { 776 case MII_BMCR: 777 return 0; 778 case MII_PHYID1: 779 return 0x0040; 780 case MII_PHYID2: 781 return 0x6210; 782 case MII_BMSR: 783 if (qemu_get_queue(s->nic)->link_down) { 784 return MII_BMSR_100TX_FD | MII_BMSR_AUTONEG; 785 } else { 786 return MII_BMSR_100TX_FD | MII_BMSR_AN_COMP | 787 MII_BMSR_AUTONEG | MII_BMSR_LINK_ST; 788 } 789 case MII_ANLPAR: 790 case MII_ANAR: 791 return MII_ANLPAR_TXFD; 792 case 0x18: /* 5201 AUX status */ 793 return 3; /* 100FD */ 794 default: 795 return 0; 796 }; 797 } 798 static uint16_t sungem_mii_read(SunGEMState *s, uint8_t phy_addr, 799 uint8_t reg_addr) 800 { 801 uint16_t val; 802 803 val = __sungem_mii_read(s, phy_addr, reg_addr); 804 805 trace_sungem_mii_read(phy_addr, reg_addr, val); 806 807 return val; 808 } 809 810 static uint32_t sungem_mii_op(SunGEMState *s, uint32_t val) 811 { 812 uint8_t phy_addr, reg_addr, op; 813 814 /* Ignore not start of frame */ 815 if ((val >> 30) != 1) { 816 trace_sungem_mii_invalid_sof(val >> 30); 817 return 0xffff; 818 } 819 phy_addr = (val & MIF_FRAME_PHYAD) >> 23; 820 reg_addr = (val & MIF_FRAME_REGAD) >> 18; 821 op = (val & MIF_FRAME_OP) >> 28; 822 switch (op) { 823 case 1: 824 sungem_mii_write(s, phy_addr, reg_addr, val & MIF_FRAME_DATA); 825 return val | MIF_FRAME_TALSB; 826 case 2: 827 return sungem_mii_read(s, phy_addr, reg_addr) | MIF_FRAME_TALSB; 828 default: 829 trace_sungem_mii_invalid_op(op); 830 } 831 return 0xffff | MIF_FRAME_TALSB; 832 } 833 834 static void sungem_mmio_greg_write(void *opaque, hwaddr addr, uint64_t val, 835 unsigned size) 836 { 837 SunGEMState *s = opaque; 838 839 if (!(addr < 0x20) && !(addr >= 0x1000 && addr <= 0x1010)) { 840 qemu_log_mask(LOG_GUEST_ERROR, 841 "Write to unknown GREG register 0x%"HWADDR_PRIx"\n", 842 addr); 843 return; 844 } 845 846 trace_sungem_mmio_greg_write(addr, val); 847 848 /* Pre-write filter */ 849 switch (addr) { 850 /* Read only registers */ 851 case GREG_SEBSTATE: 852 case GREG_STAT: 853 case GREG_STAT2: 854 case GREG_PCIESTAT: 855 return; /* No actual write */ 856 case GREG_IACK: 857 val &= GREG_STAT_LATCH; 858 s->gregs[GREG_STAT >> 2] &= ~val; 859 sungem_eval_irq(s); 860 return; /* No actual write */ 861 case GREG_PCIEMASK: 862 val &= 0x7; 863 break; 864 } 865 866 s->gregs[addr >> 2] = val; 867 868 /* Post write action */ 869 switch (addr) { 870 case GREG_IMASK: 871 /* Re-evaluate interrupt */ 872 sungem_eval_irq(s); 873 break; 874 case GREG_SWRST: 875 switch (val & (GREG_SWRST_TXRST | GREG_SWRST_RXRST)) { 876 case GREG_SWRST_RXRST: 877 sungem_reset_rx(s); 878 break; 879 case GREG_SWRST_TXRST: 880 sungem_reset_tx(s); 881 break; 882 case GREG_SWRST_RXRST | GREG_SWRST_TXRST: 883 sungem_reset_all(s, false); 884 } 885 break; 886 } 887 } 888 889 static uint64_t sungem_mmio_greg_read(void *opaque, hwaddr addr, unsigned size) 890 { 891 SunGEMState *s = opaque; 892 uint32_t val; 893 894 if (!(addr < 0x20) && !(addr >= 0x1000 && addr <= 0x1010)) { 895 qemu_log_mask(LOG_GUEST_ERROR, 896 "Read from unknown GREG register 0x%"HWADDR_PRIx"\n", 897 addr); 898 return 0; 899 } 900 901 val = s->gregs[addr >> 2]; 902 903 trace_sungem_mmio_greg_read(addr, val); 904 905 switch (addr) { 906 case GREG_STAT: 907 /* Side effect, clear bottom 7 bits */ 908 s->gregs[GREG_STAT >> 2] &= ~GREG_STAT_LATCH; 909 sungem_eval_irq(s); 910 911 /* Inject TX completion in returned value */ 912 val = (val & ~GREG_STAT_TXNR) | 913 (s->txdmaregs[TXDMA_TXDONE >> 2] << GREG_STAT_TXNR_SHIFT); 914 break; 915 case GREG_STAT2: 916 /* Return the status reg without side effect 917 * (and inject TX completion in returned value) 918 */ 919 val = (s->gregs[GREG_STAT >> 2] & ~GREG_STAT_TXNR) | 920 (s->txdmaregs[TXDMA_TXDONE >> 2] << GREG_STAT_TXNR_SHIFT); 921 break; 922 } 923 924 return val; 925 } 926 927 static const MemoryRegionOps sungem_mmio_greg_ops = { 928 .read = sungem_mmio_greg_read, 929 .write = sungem_mmio_greg_write, 930 .endianness = DEVICE_LITTLE_ENDIAN, 931 .impl = { 932 .min_access_size = 4, 933 .max_access_size = 4, 934 }, 935 }; 936 937 static void sungem_mmio_txdma_write(void *opaque, hwaddr addr, uint64_t val, 938 unsigned size) 939 { 940 SunGEMState *s = opaque; 941 942 if (!(addr < 0x38) && !(addr >= 0x100 && addr <= 0x118)) { 943 qemu_log_mask(LOG_GUEST_ERROR, 944 "Write to unknown TXDMA register 0x%"HWADDR_PRIx"\n", 945 addr); 946 return; 947 } 948 949 trace_sungem_mmio_txdma_write(addr, val); 950 951 /* Pre-write filter */ 952 switch (addr) { 953 /* Read only registers */ 954 case TXDMA_TXDONE: 955 case TXDMA_PCNT: 956 case TXDMA_SMACHINE: 957 case TXDMA_DPLOW: 958 case TXDMA_DPHI: 959 case TXDMA_FSZ: 960 case TXDMA_FTAG: 961 return; /* No actual write */ 962 } 963 964 s->txdmaregs[addr >> 2] = val; 965 966 /* Post write action */ 967 switch (addr) { 968 case TXDMA_KICK: 969 sungem_tx_kick(s); 970 break; 971 case TXDMA_CFG: 972 sungem_update_masks(s); 973 break; 974 } 975 } 976 977 static uint64_t sungem_mmio_txdma_read(void *opaque, hwaddr addr, unsigned size) 978 { 979 SunGEMState *s = opaque; 980 uint32_t val; 981 982 if (!(addr < 0x38) && !(addr >= 0x100 && addr <= 0x118)) { 983 qemu_log_mask(LOG_GUEST_ERROR, 984 "Read from unknown TXDMA register 0x%"HWADDR_PRIx"\n", 985 addr); 986 return 0; 987 } 988 989 val = s->txdmaregs[addr >> 2]; 990 991 trace_sungem_mmio_txdma_read(addr, val); 992 993 return val; 994 } 995 996 static const MemoryRegionOps sungem_mmio_txdma_ops = { 997 .read = sungem_mmio_txdma_read, 998 .write = sungem_mmio_txdma_write, 999 .endianness = DEVICE_LITTLE_ENDIAN, 1000 .impl = { 1001 .min_access_size = 4, 1002 .max_access_size = 4, 1003 }, 1004 }; 1005 1006 static void sungem_mmio_rxdma_write(void *opaque, hwaddr addr, uint64_t val, 1007 unsigned size) 1008 { 1009 SunGEMState *s = opaque; 1010 1011 if (!(addr <= 0x28) && !(addr >= 0x100 && addr <= 0x120)) { 1012 qemu_log_mask(LOG_GUEST_ERROR, 1013 "Write to unknown RXDMA register 0x%"HWADDR_PRIx"\n", 1014 addr); 1015 return; 1016 } 1017 1018 trace_sungem_mmio_rxdma_write(addr, val); 1019 1020 /* Pre-write filter */ 1021 switch (addr) { 1022 /* Read only registers */ 1023 case RXDMA_DONE: 1024 case RXDMA_PCNT: 1025 case RXDMA_SMACHINE: 1026 case RXDMA_DPLOW: 1027 case RXDMA_DPHI: 1028 case RXDMA_FSZ: 1029 case RXDMA_FTAG: 1030 return; /* No actual write */ 1031 } 1032 1033 s->rxdmaregs[addr >> 2] = val; 1034 1035 /* Post write action */ 1036 switch (addr) { 1037 case RXDMA_KICK: 1038 trace_sungem_rx_kick(val); 1039 break; 1040 case RXDMA_CFG: 1041 sungem_update_masks(s); 1042 if ((s->macregs[MAC_RXCFG >> 2] & MAC_RXCFG_ENAB) != 0 && 1043 (s->rxdmaregs[RXDMA_CFG >> 2] & RXDMA_CFG_ENABLE) != 0) { 1044 qemu_flush_queued_packets(qemu_get_queue(s->nic)); 1045 } 1046 break; 1047 } 1048 } 1049 1050 static uint64_t sungem_mmio_rxdma_read(void *opaque, hwaddr addr, unsigned size) 1051 { 1052 SunGEMState *s = opaque; 1053 uint32_t val; 1054 1055 if (!(addr <= 0x28) && !(addr >= 0x100 && addr <= 0x120)) { 1056 qemu_log_mask(LOG_GUEST_ERROR, 1057 "Read from unknown RXDMA register 0x%"HWADDR_PRIx"\n", 1058 addr); 1059 return 0; 1060 } 1061 1062 val = s->rxdmaregs[addr >> 2]; 1063 1064 trace_sungem_mmio_rxdma_read(addr, val); 1065 1066 return val; 1067 } 1068 1069 static const MemoryRegionOps sungem_mmio_rxdma_ops = { 1070 .read = sungem_mmio_rxdma_read, 1071 .write = sungem_mmio_rxdma_write, 1072 .endianness = DEVICE_LITTLE_ENDIAN, 1073 .impl = { 1074 .min_access_size = 4, 1075 .max_access_size = 4, 1076 }, 1077 }; 1078 1079 static void sungem_mmio_mac_write(void *opaque, hwaddr addr, uint64_t val, 1080 unsigned size) 1081 { 1082 SunGEMState *s = opaque; 1083 1084 if (!(addr <= 0x134)) { 1085 qemu_log_mask(LOG_GUEST_ERROR, 1086 "Write to unknown MAC register 0x%"HWADDR_PRIx"\n", 1087 addr); 1088 return; 1089 } 1090 1091 trace_sungem_mmio_mac_write(addr, val); 1092 1093 /* Pre-write filter */ 1094 switch (addr) { 1095 /* Read only registers */ 1096 case MAC_TXRST: /* Not technically read-only but will do for now */ 1097 case MAC_RXRST: /* Not technically read-only but will do for now */ 1098 case MAC_TXSTAT: 1099 case MAC_RXSTAT: 1100 case MAC_CSTAT: 1101 case MAC_PATMPS: 1102 case MAC_SMACHINE: 1103 return; /* No actual write */ 1104 case MAC_MINFSZ: 1105 /* 10-bits implemented */ 1106 val &= 0x3ff; 1107 break; 1108 } 1109 1110 s->macregs[addr >> 2] = val; 1111 1112 /* Post write action */ 1113 switch (addr) { 1114 case MAC_TXMASK: 1115 case MAC_RXMASK: 1116 case MAC_MCMASK: 1117 sungem_eval_cascade_irq(s); 1118 break; 1119 case MAC_RXCFG: 1120 sungem_update_masks(s); 1121 if ((s->macregs[MAC_RXCFG >> 2] & MAC_RXCFG_ENAB) != 0 && 1122 (s->rxdmaregs[RXDMA_CFG >> 2] & RXDMA_CFG_ENABLE) != 0) { 1123 qemu_flush_queued_packets(qemu_get_queue(s->nic)); 1124 } 1125 break; 1126 } 1127 } 1128 1129 static uint64_t sungem_mmio_mac_read(void *opaque, hwaddr addr, unsigned size) 1130 { 1131 SunGEMState *s = opaque; 1132 uint32_t val; 1133 1134 if (!(addr <= 0x134)) { 1135 qemu_log_mask(LOG_GUEST_ERROR, 1136 "Read from unknown MAC register 0x%"HWADDR_PRIx"\n", 1137 addr); 1138 return 0; 1139 } 1140 1141 val = s->macregs[addr >> 2]; 1142 1143 trace_sungem_mmio_mac_read(addr, val); 1144 1145 switch (addr) { 1146 case MAC_TXSTAT: 1147 /* Side effect, clear all */ 1148 s->macregs[addr >> 2] = 0; 1149 sungem_update_status(s, GREG_STAT_TXMAC, false); 1150 break; 1151 case MAC_RXSTAT: 1152 /* Side effect, clear all */ 1153 s->macregs[addr >> 2] = 0; 1154 sungem_update_status(s, GREG_STAT_RXMAC, false); 1155 break; 1156 case MAC_CSTAT: 1157 /* Side effect, interrupt bits */ 1158 s->macregs[addr >> 2] &= MAC_CSTAT_PTR; 1159 sungem_update_status(s, GREG_STAT_MAC, false); 1160 break; 1161 } 1162 1163 return val; 1164 } 1165 1166 static const MemoryRegionOps sungem_mmio_mac_ops = { 1167 .read = sungem_mmio_mac_read, 1168 .write = sungem_mmio_mac_write, 1169 .endianness = DEVICE_LITTLE_ENDIAN, 1170 .impl = { 1171 .min_access_size = 4, 1172 .max_access_size = 4, 1173 }, 1174 }; 1175 1176 static void sungem_mmio_mif_write(void *opaque, hwaddr addr, uint64_t val, 1177 unsigned size) 1178 { 1179 SunGEMState *s = opaque; 1180 1181 if (!(addr <= 0x1c)) { 1182 qemu_log_mask(LOG_GUEST_ERROR, 1183 "Write to unknown MIF register 0x%"HWADDR_PRIx"\n", 1184 addr); 1185 return; 1186 } 1187 1188 trace_sungem_mmio_mif_write(addr, val); 1189 1190 /* Pre-write filter */ 1191 switch (addr) { 1192 /* Read only registers */ 1193 case MIF_STATUS: 1194 case MIF_SMACHINE: 1195 return; /* No actual write */ 1196 case MIF_CFG: 1197 /* Maintain the RO MDI bits to advertize an MDIO PHY on MDI0 */ 1198 val &= ~MIF_CFG_MDI1; 1199 val |= MIF_CFG_MDI0; 1200 break; 1201 } 1202 1203 s->mifregs[addr >> 2] = val; 1204 1205 /* Post write action */ 1206 switch (addr) { 1207 case MIF_FRAME: 1208 s->mifregs[addr >> 2] = sungem_mii_op(s, val); 1209 break; 1210 } 1211 } 1212 1213 static uint64_t sungem_mmio_mif_read(void *opaque, hwaddr addr, unsigned size) 1214 { 1215 SunGEMState *s = opaque; 1216 uint32_t val; 1217 1218 if (!(addr <= 0x1c)) { 1219 qemu_log_mask(LOG_GUEST_ERROR, 1220 "Read from unknown MIF register 0x%"HWADDR_PRIx"\n", 1221 addr); 1222 return 0; 1223 } 1224 1225 val = s->mifregs[addr >> 2]; 1226 1227 trace_sungem_mmio_mif_read(addr, val); 1228 1229 return val; 1230 } 1231 1232 static const MemoryRegionOps sungem_mmio_mif_ops = { 1233 .read = sungem_mmio_mif_read, 1234 .write = sungem_mmio_mif_write, 1235 .endianness = DEVICE_LITTLE_ENDIAN, 1236 .impl = { 1237 .min_access_size = 4, 1238 .max_access_size = 4, 1239 }, 1240 }; 1241 1242 static void sungem_mmio_pcs_write(void *opaque, hwaddr addr, uint64_t val, 1243 unsigned size) 1244 { 1245 SunGEMState *s = opaque; 1246 1247 if (!(addr <= 0x18) && !(addr >= 0x50 && addr <= 0x5c)) { 1248 qemu_log_mask(LOG_GUEST_ERROR, 1249 "Write to unknown PCS register 0x%"HWADDR_PRIx"\n", 1250 addr); 1251 return; 1252 } 1253 1254 trace_sungem_mmio_pcs_write(addr, val); 1255 1256 /* Pre-write filter */ 1257 switch (addr) { 1258 /* Read only registers */ 1259 case PCS_MIISTAT: 1260 case PCS_ISTAT: 1261 case PCS_SSTATE: 1262 return; /* No actual write */ 1263 } 1264 1265 s->pcsregs[addr >> 2] = val; 1266 } 1267 1268 static uint64_t sungem_mmio_pcs_read(void *opaque, hwaddr addr, unsigned size) 1269 { 1270 SunGEMState *s = opaque; 1271 uint32_t val; 1272 1273 if (!(addr <= 0x18) && !(addr >= 0x50 && addr <= 0x5c)) { 1274 qemu_log_mask(LOG_GUEST_ERROR, 1275 "Read from unknown PCS register 0x%"HWADDR_PRIx"\n", 1276 addr); 1277 return 0; 1278 } 1279 1280 val = s->pcsregs[addr >> 2]; 1281 1282 trace_sungem_mmio_pcs_read(addr, val); 1283 1284 return val; 1285 } 1286 1287 static const MemoryRegionOps sungem_mmio_pcs_ops = { 1288 .read = sungem_mmio_pcs_read, 1289 .write = sungem_mmio_pcs_write, 1290 .endianness = DEVICE_LITTLE_ENDIAN, 1291 .impl = { 1292 .min_access_size = 4, 1293 .max_access_size = 4, 1294 }, 1295 }; 1296 1297 static void sungem_uninit(PCIDevice *dev) 1298 { 1299 SunGEMState *s = SUNGEM(dev); 1300 1301 qemu_del_nic(s->nic); 1302 } 1303 1304 static NetClientInfo net_sungem_info = { 1305 .type = NET_CLIENT_DRIVER_NIC, 1306 .size = sizeof(NICState), 1307 .can_receive = sungem_can_receive, 1308 .receive = sungem_receive, 1309 .link_status_changed = sungem_set_link_status, 1310 }; 1311 1312 static void sungem_realize(PCIDevice *pci_dev, Error **errp) 1313 { 1314 DeviceState *dev = DEVICE(pci_dev); 1315 SunGEMState *s = SUNGEM(pci_dev); 1316 uint8_t *pci_conf; 1317 1318 pci_conf = pci_dev->config; 1319 1320 pci_set_word(pci_conf + PCI_STATUS, 1321 PCI_STATUS_FAST_BACK | 1322 PCI_STATUS_DEVSEL_MEDIUM | 1323 PCI_STATUS_66MHZ); 1324 1325 pci_set_word(pci_conf + PCI_SUBSYSTEM_VENDOR_ID, 0x0); 1326 pci_set_word(pci_conf + PCI_SUBSYSTEM_ID, 0x0); 1327 1328 pci_conf[PCI_INTERRUPT_PIN] = 1; /* interrupt pin A */ 1329 pci_conf[PCI_MIN_GNT] = 0x40; 1330 pci_conf[PCI_MAX_LAT] = 0x40; 1331 1332 sungem_reset_all(s, true); 1333 memory_region_init(&s->sungem, OBJECT(s), "sungem", SUNGEM_MMIO_SIZE); 1334 1335 memory_region_init_io(&s->greg, OBJECT(s), &sungem_mmio_greg_ops, s, 1336 "sungem.greg", SUNGEM_MMIO_GREG_SIZE); 1337 memory_region_add_subregion(&s->sungem, 0, &s->greg); 1338 1339 memory_region_init_io(&s->txdma, OBJECT(s), &sungem_mmio_txdma_ops, s, 1340 "sungem.txdma", SUNGEM_MMIO_TXDMA_SIZE); 1341 memory_region_add_subregion(&s->sungem, 0x2000, &s->txdma); 1342 1343 memory_region_init_io(&s->rxdma, OBJECT(s), &sungem_mmio_rxdma_ops, s, 1344 "sungem.rxdma", SUNGEM_MMIO_RXDMA_SIZE); 1345 memory_region_add_subregion(&s->sungem, 0x4000, &s->rxdma); 1346 1347 memory_region_init_io(&s->mac, OBJECT(s), &sungem_mmio_mac_ops, s, 1348 "sungem.mac", SUNGEM_MMIO_MAC_SIZE); 1349 memory_region_add_subregion(&s->sungem, 0x6000, &s->mac); 1350 1351 memory_region_init_io(&s->mif, OBJECT(s), &sungem_mmio_mif_ops, s, 1352 "sungem.mif", SUNGEM_MMIO_MIF_SIZE); 1353 memory_region_add_subregion(&s->sungem, 0x6200, &s->mif); 1354 1355 memory_region_init_io(&s->pcs, OBJECT(s), &sungem_mmio_pcs_ops, s, 1356 "sungem.pcs", SUNGEM_MMIO_PCS_SIZE); 1357 memory_region_add_subregion(&s->sungem, 0x9000, &s->pcs); 1358 1359 pci_register_bar(pci_dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->sungem); 1360 1361 qemu_macaddr_default_if_unset(&s->conf.macaddr); 1362 s->nic = qemu_new_nic(&net_sungem_info, &s->conf, 1363 object_get_typename(OBJECT(dev)), 1364 dev->id, s); 1365 qemu_format_nic_info_str(qemu_get_queue(s->nic), 1366 s->conf.macaddr.a); 1367 } 1368 1369 static void sungem_reset(DeviceState *dev) 1370 { 1371 SunGEMState *s = SUNGEM(dev); 1372 1373 sungem_reset_all(s, true); 1374 } 1375 1376 static void sungem_instance_init(Object *obj) 1377 { 1378 SunGEMState *s = SUNGEM(obj); 1379 1380 device_add_bootindex_property(obj, &s->conf.bootindex, 1381 "bootindex", "/ethernet-phy@0", 1382 DEVICE(obj)); 1383 } 1384 1385 static Property sungem_properties[] = { 1386 DEFINE_NIC_PROPERTIES(SunGEMState, conf), 1387 /* Phy address should be 0 for most Apple machines except 1388 * for K2 in which case it's 1. Will be set by a machine 1389 * override. 1390 */ 1391 DEFINE_PROP_UINT32("phy_addr", SunGEMState, phy_addr, 0), 1392 DEFINE_PROP_END_OF_LIST(), 1393 }; 1394 1395 static const VMStateDescription vmstate_sungem = { 1396 .name = "sungem", 1397 .version_id = 0, 1398 .minimum_version_id = 0, 1399 .fields = (VMStateField[]) { 1400 VMSTATE_PCI_DEVICE(pdev, SunGEMState), 1401 VMSTATE_MACADDR(conf.macaddr, SunGEMState), 1402 VMSTATE_UINT32(phy_addr, SunGEMState), 1403 VMSTATE_UINT32_ARRAY(gregs, SunGEMState, (SUNGEM_MMIO_GREG_SIZE >> 2)), 1404 VMSTATE_UINT32_ARRAY(txdmaregs, SunGEMState, 1405 (SUNGEM_MMIO_TXDMA_SIZE >> 2)), 1406 VMSTATE_UINT32_ARRAY(rxdmaregs, SunGEMState, 1407 (SUNGEM_MMIO_RXDMA_SIZE >> 2)), 1408 VMSTATE_UINT32_ARRAY(macregs, SunGEMState, (SUNGEM_MMIO_MAC_SIZE >> 2)), 1409 VMSTATE_UINT32_ARRAY(mifregs, SunGEMState, (SUNGEM_MMIO_MIF_SIZE >> 2)), 1410 VMSTATE_UINT32_ARRAY(pcsregs, SunGEMState, (SUNGEM_MMIO_PCS_SIZE >> 2)), 1411 VMSTATE_UINT32(rx_mask, SunGEMState), 1412 VMSTATE_UINT32(tx_mask, SunGEMState), 1413 VMSTATE_UINT8_ARRAY(tx_data, SunGEMState, MAX_PACKET_SIZE), 1414 VMSTATE_UINT32(tx_size, SunGEMState), 1415 VMSTATE_UINT64(tx_first_ctl, SunGEMState), 1416 VMSTATE_END_OF_LIST() 1417 } 1418 }; 1419 1420 static void sungem_class_init(ObjectClass *klass, void *data) 1421 { 1422 DeviceClass *dc = DEVICE_CLASS(klass); 1423 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); 1424 1425 k->realize = sungem_realize; 1426 k->exit = sungem_uninit; 1427 k->vendor_id = PCI_VENDOR_ID_APPLE; 1428 k->device_id = PCI_DEVICE_ID_APPLE_UNI_N_GMAC; 1429 k->revision = 0x01; 1430 k->class_id = PCI_CLASS_NETWORK_ETHERNET; 1431 dc->vmsd = &vmstate_sungem; 1432 dc->reset = sungem_reset; 1433 device_class_set_props(dc, sungem_properties); 1434 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories); 1435 } 1436 1437 static const TypeInfo sungem_info = { 1438 .name = TYPE_SUNGEM, 1439 .parent = TYPE_PCI_DEVICE, 1440 .instance_size = sizeof(SunGEMState), 1441 .class_init = sungem_class_init, 1442 .instance_init = sungem_instance_init, 1443 .interfaces = (InterfaceInfo[]) { 1444 { INTERFACE_CONVENTIONAL_PCI_DEVICE }, 1445 { } 1446 } 1447 }; 1448 1449 static void sungem_register_types(void) 1450 { 1451 type_register_static(&sungem_info); 1452 } 1453 1454 type_init(sungem_register_types)