1 /* 2 * i.MX Fast Ethernet Controller emulation. 3 * 4 * Copyright (c) 2013 Jean-Christophe Dubois. <jcd@tribudubois.net> 5 * 6 * Based on Coldfire Fast Ethernet Controller emulation. 7 * 8 * Copyright (c) 2007 CodeSourcery. 9 * 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the 12 * Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, but WITHOUT 16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 18 * for more details. 19 * 20 * You should have received a copy of the GNU General Public License along 21 * with this program; if not, see <http://www.gnu.org/licenses/>. 22 */ 23 24 #include "qemu/osdep.h" 25 #include "hw/irq.h" 26 #include "hw/net/imx_fec.h" 27 #include "hw/qdev-properties.h" 28 #include "migration/vmstate.h" 29 #include "sysemu/dma.h" 30 #include "qemu/log.h" 31 #include "qemu/module.h" 32 #include "net/checksum.h" 33 #include "net/eth.h" 34 #include "trace.h" 35 36 #include <zlib.h> /* for crc32 */ 37 38 #define IMX_MAX_DESC 1024 39 40 static const char *imx_default_reg_name(IMXFECState *s, uint32_t index) 41 { 42 static char tmp[20]; 43 snprintf(tmp, sizeof(tmp), "index %d", index); 44 return tmp; 45 } 46 47 static const char *imx_fec_reg_name(IMXFECState *s, uint32_t index) 48 { 49 switch (index) { 50 case ENET_FRBR: 51 return "FRBR"; 52 case ENET_FRSR: 53 return "FRSR"; 54 case ENET_MIIGSK_CFGR: 55 return "MIIGSK_CFGR"; 56 case ENET_MIIGSK_ENR: 57 return "MIIGSK_ENR"; 58 default: 59 return imx_default_reg_name(s, index); 60 } 61 } 62 63 static const char *imx_enet_reg_name(IMXFECState *s, uint32_t index) 64 { 65 switch (index) { 66 case ENET_RSFL: 67 return "RSFL"; 68 case ENET_RSEM: 69 return "RSEM"; 70 case ENET_RAEM: 71 return "RAEM"; 72 case ENET_RAFL: 73 return "RAFL"; 74 case ENET_TSEM: 75 return "TSEM"; 76 case ENET_TAEM: 77 return "TAEM"; 78 case ENET_TAFL: 79 return "TAFL"; 80 case ENET_TIPG: 81 return "TIPG"; 82 case ENET_FTRL: 83 return "FTRL"; 84 case ENET_TACC: 85 return "TACC"; 86 case ENET_RACC: 87 return "RACC"; 88 case ENET_ATCR: 89 return "ATCR"; 90 case ENET_ATVR: 91 return "ATVR"; 92 case ENET_ATOFF: 93 return "ATOFF"; 94 case ENET_ATPER: 95 return "ATPER"; 96 case ENET_ATCOR: 97 return "ATCOR"; 98 case ENET_ATINC: 99 return "ATINC"; 100 case ENET_ATSTMP: 101 return "ATSTMP"; 102 case ENET_TGSR: 103 return "TGSR"; 104 case ENET_TCSR0: 105 return "TCSR0"; 106 case ENET_TCCR0: 107 return "TCCR0"; 108 case ENET_TCSR1: 109 return "TCSR1"; 110 case ENET_TCCR1: 111 return "TCCR1"; 112 case ENET_TCSR2: 113 return "TCSR2"; 114 case ENET_TCCR2: 115 return "TCCR2"; 116 case ENET_TCSR3: 117 return "TCSR3"; 118 case ENET_TCCR3: 119 return "TCCR3"; 120 default: 121 return imx_default_reg_name(s, index); 122 } 123 } 124 125 static const char *imx_eth_reg_name(IMXFECState *s, uint32_t index) 126 { 127 switch (index) { 128 case ENET_EIR: 129 return "EIR"; 130 case ENET_EIMR: 131 return "EIMR"; 132 case ENET_RDAR: 133 return "RDAR"; 134 case ENET_TDAR: 135 return "TDAR"; 136 case ENET_ECR: 137 return "ECR"; 138 case ENET_MMFR: 139 return "MMFR"; 140 case ENET_MSCR: 141 return "MSCR"; 142 case ENET_MIBC: 143 return "MIBC"; 144 case ENET_RCR: 145 return "RCR"; 146 case ENET_TCR: 147 return "TCR"; 148 case ENET_PALR: 149 return "PALR"; 150 case ENET_PAUR: 151 return "PAUR"; 152 case ENET_OPD: 153 return "OPD"; 154 case ENET_IAUR: 155 return "IAUR"; 156 case ENET_IALR: 157 return "IALR"; 158 case ENET_GAUR: 159 return "GAUR"; 160 case ENET_GALR: 161 return "GALR"; 162 case ENET_TFWR: 163 return "TFWR"; 164 case ENET_RDSR: 165 return "RDSR"; 166 case ENET_TDSR: 167 return "TDSR"; 168 case ENET_MRBR: 169 return "MRBR"; 170 default: 171 if (s->is_fec) { 172 return imx_fec_reg_name(s, index); 173 } else { 174 return imx_enet_reg_name(s, index); 175 } 176 } 177 } 178 179 /* 180 * Versions of this device with more than one TX descriptor save the 181 * 2nd and 3rd descriptors in a subsection, to maintain migration 182 * compatibility with previous versions of the device that only 183 * supported a single descriptor. 184 */ 185 static bool imx_eth_is_multi_tx_ring(void *opaque) 186 { 187 IMXFECState *s = IMX_FEC(opaque); 188 189 return s->tx_ring_num > 1; 190 } 191 192 static const VMStateDescription vmstate_imx_eth_txdescs = { 193 .name = "imx.fec/txdescs", 194 .version_id = 1, 195 .minimum_version_id = 1, 196 .needed = imx_eth_is_multi_tx_ring, 197 .fields = (const VMStateField[]) { 198 VMSTATE_UINT32(tx_descriptor[1], IMXFECState), 199 VMSTATE_UINT32(tx_descriptor[2], IMXFECState), 200 VMSTATE_END_OF_LIST() 201 } 202 }; 203 204 static const VMStateDescription vmstate_imx_eth = { 205 .name = TYPE_IMX_FEC, 206 .version_id = 2, 207 .minimum_version_id = 2, 208 .fields = (const VMStateField[]) { 209 VMSTATE_UINT32_ARRAY(regs, IMXFECState, ENET_MAX), 210 VMSTATE_UINT32(rx_descriptor, IMXFECState), 211 VMSTATE_UINT32(tx_descriptor[0], IMXFECState), 212 VMSTATE_UINT32(phy_status, IMXFECState), 213 VMSTATE_UINT32(phy_control, IMXFECState), 214 VMSTATE_UINT32(phy_advertise, IMXFECState), 215 VMSTATE_UINT32(phy_int, IMXFECState), 216 VMSTATE_UINT32(phy_int_mask, IMXFECState), 217 VMSTATE_END_OF_LIST() 218 }, 219 .subsections = (const VMStateDescription * const []) { 220 &vmstate_imx_eth_txdescs, 221 NULL 222 }, 223 }; 224 225 #define PHY_INT_ENERGYON (1 << 7) 226 #define PHY_INT_AUTONEG_COMPLETE (1 << 6) 227 #define PHY_INT_FAULT (1 << 5) 228 #define PHY_INT_DOWN (1 << 4) 229 #define PHY_INT_AUTONEG_LP (1 << 3) 230 #define PHY_INT_PARFAULT (1 << 2) 231 #define PHY_INT_AUTONEG_PAGE (1 << 1) 232 233 static void imx_eth_update(IMXFECState *s); 234 235 /* 236 * The MII phy could raise a GPIO to the processor which in turn 237 * could be handled as an interrpt by the OS. 238 * For now we don't handle any GPIO/interrupt line, so the OS will 239 * have to poll for the PHY status. 240 */ 241 static void imx_phy_update_irq(IMXFECState *s) 242 { 243 imx_eth_update(s); 244 } 245 246 static void imx_phy_update_link(IMXFECState *s) 247 { 248 /* Autonegotiation status mirrors link status. */ 249 if (qemu_get_queue(s->nic)->link_down) { 250 trace_imx_phy_update_link("down"); 251 s->phy_status &= ~0x0024; 252 s->phy_int |= PHY_INT_DOWN; 253 } else { 254 trace_imx_phy_update_link("up"); 255 s->phy_status |= 0x0024; 256 s->phy_int |= PHY_INT_ENERGYON; 257 s->phy_int |= PHY_INT_AUTONEG_COMPLETE; 258 } 259 imx_phy_update_irq(s); 260 } 261 262 static void imx_eth_set_link(NetClientState *nc) 263 { 264 imx_phy_update_link(IMX_FEC(qemu_get_nic_opaque(nc))); 265 } 266 267 static void imx_phy_reset(IMXFECState *s) 268 { 269 trace_imx_phy_reset(); 270 271 s->phy_status = 0x7809; 272 s->phy_control = 0x3000; 273 s->phy_advertise = 0x01e1; 274 s->phy_int_mask = 0; 275 s->phy_int = 0; 276 imx_phy_update_link(s); 277 } 278 279 static uint32_t imx_phy_read(IMXFECState *s, int reg) 280 { 281 uint32_t val; 282 uint32_t phy = reg / 32; 283 284 if (!s->phy_connected) { 285 return 0xffff; 286 } 287 288 if (phy != s->phy_num) { 289 if (s->phy_consumer && phy == s->phy_consumer->phy_num) { 290 s = s->phy_consumer; 291 } else { 292 trace_imx_phy_read_num(phy, s->phy_num); 293 return 0xffff; 294 } 295 } 296 297 reg %= 32; 298 299 switch (reg) { 300 case 0: /* Basic Control */ 301 val = s->phy_control; 302 break; 303 case 1: /* Basic Status */ 304 val = s->phy_status; 305 break; 306 case 2: /* ID1 */ 307 val = 0x0007; 308 break; 309 case 3: /* ID2 */ 310 val = 0xc0d1; 311 break; 312 case 4: /* Auto-neg advertisement */ 313 val = s->phy_advertise; 314 break; 315 case 5: /* Auto-neg Link Partner Ability */ 316 val = 0x0f71; 317 break; 318 case 6: /* Auto-neg Expansion */ 319 val = 1; 320 break; 321 case 29: /* Interrupt source. */ 322 val = s->phy_int; 323 s->phy_int = 0; 324 imx_phy_update_irq(s); 325 break; 326 case 30: /* Interrupt mask */ 327 val = s->phy_int_mask; 328 break; 329 case 17: 330 case 18: 331 case 27: 332 case 31: 333 qemu_log_mask(LOG_UNIMP, "[%s.phy]%s: reg %d not implemented\n", 334 TYPE_IMX_FEC, __func__, reg); 335 val = 0; 336 break; 337 default: 338 qemu_log_mask(LOG_GUEST_ERROR, "[%s.phy]%s: Bad address at offset %d\n", 339 TYPE_IMX_FEC, __func__, reg); 340 val = 0; 341 break; 342 } 343 344 trace_imx_phy_read(val, phy, reg); 345 346 return val; 347 } 348 349 static void imx_phy_write(IMXFECState *s, int reg, uint32_t val) 350 { 351 uint32_t phy = reg / 32; 352 353 if (!s->phy_connected) { 354 return; 355 } 356 357 if (phy != s->phy_num) { 358 if (s->phy_consumer && phy == s->phy_consumer->phy_num) { 359 s = s->phy_consumer; 360 } else { 361 trace_imx_phy_write_num(phy, s->phy_num); 362 return; 363 } 364 } 365 366 reg %= 32; 367 368 trace_imx_phy_write(val, phy, reg); 369 370 switch (reg) { 371 case 0: /* Basic Control */ 372 if (val & 0x8000) { 373 imx_phy_reset(s); 374 } else { 375 s->phy_control = val & 0x7980; 376 /* Complete autonegotiation immediately. */ 377 if (val & 0x1000) { 378 s->phy_status |= 0x0020; 379 } 380 } 381 break; 382 case 4: /* Auto-neg advertisement */ 383 s->phy_advertise = (val & 0x2d7f) | 0x80; 384 break; 385 case 30: /* Interrupt mask */ 386 s->phy_int_mask = val & 0xff; 387 imx_phy_update_irq(s); 388 break; 389 case 17: 390 case 18: 391 case 27: 392 case 31: 393 qemu_log_mask(LOG_UNIMP, "[%s.phy)%s: reg %d not implemented\n", 394 TYPE_IMX_FEC, __func__, reg); 395 break; 396 default: 397 qemu_log_mask(LOG_GUEST_ERROR, "[%s.phy]%s: Bad address at offset %d\n", 398 TYPE_IMX_FEC, __func__, reg); 399 break; 400 } 401 } 402 403 static void imx_fec_read_bd(IMXFECBufDesc *bd, dma_addr_t addr) 404 { 405 dma_memory_read(&address_space_memory, addr, bd, sizeof(*bd), 406 MEMTXATTRS_UNSPECIFIED); 407 408 trace_imx_fec_read_bd(addr, bd->flags, bd->length, bd->data); 409 } 410 411 static void imx_fec_write_bd(IMXFECBufDesc *bd, dma_addr_t addr) 412 { 413 dma_memory_write(&address_space_memory, addr, bd, sizeof(*bd), 414 MEMTXATTRS_UNSPECIFIED); 415 } 416 417 static void imx_enet_read_bd(IMXENETBufDesc *bd, dma_addr_t addr) 418 { 419 dma_memory_read(&address_space_memory, addr, bd, sizeof(*bd), 420 MEMTXATTRS_UNSPECIFIED); 421 422 trace_imx_enet_read_bd(addr, bd->flags, bd->length, bd->data, 423 bd->option, bd->status); 424 } 425 426 static void imx_enet_write_bd(IMXENETBufDesc *bd, dma_addr_t addr) 427 { 428 dma_memory_write(&address_space_memory, addr, bd, sizeof(*bd), 429 MEMTXATTRS_UNSPECIFIED); 430 } 431 432 static void imx_eth_update(IMXFECState *s) 433 { 434 /* 435 * Previous versions of qemu had the ENET_INT_MAC and ENET_INT_TS_TIMER 436 * interrupts swapped. This worked with older versions of Linux (4.14 437 * and older) since Linux associated both interrupt lines with Ethernet 438 * MAC interrupts. Specifically, 439 * - Linux 4.15 and later have separate interrupt handlers for the MAC and 440 * timer interrupts. Those versions of Linux fail with versions of QEMU 441 * with swapped interrupt assignments. 442 * - In linux 4.14, both interrupt lines were registered with the Ethernet 443 * MAC interrupt handler. As a result, all versions of qemu happen to 444 * work, though that is accidental. 445 * - In Linux 4.9 and older, the timer interrupt was registered directly 446 * with the Ethernet MAC interrupt handler. The MAC interrupt was 447 * redirected to a GPIO interrupt to work around erratum ERR006687. 448 * This was implemented using the SOC's IOMUX block. In qemu, this GPIO 449 * interrupt never fired since IOMUX is currently not supported in qemu. 450 * Linux instead received MAC interrupts on the timer interrupt. 451 * As a result, qemu versions with the swapped interrupt assignment work, 452 * albeit accidentally, but qemu versions with the correct interrupt 453 * assignment fail. 454 * 455 * To ensure that all versions of Linux work, generate ENET_INT_MAC 456 * interrupts on both interrupt lines. This should be changed if and when 457 * qemu supports IOMUX. 458 */ 459 if (s->regs[ENET_EIR] & s->regs[ENET_EIMR] & 460 (ENET_INT_MAC | ENET_INT_TS_TIMER)) { 461 qemu_set_irq(s->irq[1], 1); 462 } else { 463 qemu_set_irq(s->irq[1], 0); 464 } 465 466 if (s->regs[ENET_EIR] & s->regs[ENET_EIMR] & ENET_INT_MAC) { 467 qemu_set_irq(s->irq[0], 1); 468 } else { 469 qemu_set_irq(s->irq[0], 0); 470 } 471 } 472 473 static void imx_fec_do_tx(IMXFECState *s) 474 { 475 int frame_size = 0, descnt = 0; 476 uint8_t *ptr = s->frame; 477 uint32_t addr = s->tx_descriptor[0]; 478 479 while (descnt++ < IMX_MAX_DESC) { 480 IMXFECBufDesc bd; 481 int len; 482 483 imx_fec_read_bd(&bd, addr); 484 if ((bd.flags & ENET_BD_R) == 0) { 485 486 /* Run out of descriptors to transmit. */ 487 trace_imx_eth_tx_bd_busy(); 488 489 break; 490 } 491 len = bd.length; 492 if (frame_size + len > ENET_MAX_FRAME_SIZE) { 493 len = ENET_MAX_FRAME_SIZE - frame_size; 494 s->regs[ENET_EIR] |= ENET_INT_BABT; 495 } 496 dma_memory_read(&address_space_memory, bd.data, ptr, len, 497 MEMTXATTRS_UNSPECIFIED); 498 ptr += len; 499 frame_size += len; 500 if (bd.flags & ENET_BD_L) { 501 /* Last buffer in frame. */ 502 qemu_send_packet(qemu_get_queue(s->nic), s->frame, frame_size); 503 ptr = s->frame; 504 frame_size = 0; 505 s->regs[ENET_EIR] |= ENET_INT_TXF; 506 } 507 s->regs[ENET_EIR] |= ENET_INT_TXB; 508 bd.flags &= ~ENET_BD_R; 509 /* Write back the modified descriptor. */ 510 imx_fec_write_bd(&bd, addr); 511 /* Advance to the next descriptor. */ 512 if ((bd.flags & ENET_BD_W) != 0) { 513 addr = s->regs[ENET_TDSR]; 514 } else { 515 addr += sizeof(bd); 516 } 517 } 518 519 s->tx_descriptor[0] = addr; 520 521 imx_eth_update(s); 522 } 523 524 static void imx_enet_do_tx(IMXFECState *s, uint32_t index) 525 { 526 int frame_size = 0, descnt = 0; 527 528 uint8_t *ptr = s->frame; 529 uint32_t addr, int_txb, int_txf, tdsr; 530 size_t ring; 531 532 switch (index) { 533 case ENET_TDAR: 534 ring = 0; 535 int_txb = ENET_INT_TXB; 536 int_txf = ENET_INT_TXF; 537 tdsr = ENET_TDSR; 538 break; 539 case ENET_TDAR1: 540 ring = 1; 541 int_txb = ENET_INT_TXB1; 542 int_txf = ENET_INT_TXF1; 543 tdsr = ENET_TDSR1; 544 break; 545 case ENET_TDAR2: 546 ring = 2; 547 int_txb = ENET_INT_TXB2; 548 int_txf = ENET_INT_TXF2; 549 tdsr = ENET_TDSR2; 550 break; 551 default: 552 qemu_log_mask(LOG_GUEST_ERROR, 553 "%s: bogus value for index %x\n", 554 __func__, index); 555 abort(); 556 break; 557 } 558 559 addr = s->tx_descriptor[ring]; 560 561 while (descnt++ < IMX_MAX_DESC) { 562 IMXENETBufDesc bd; 563 int len; 564 565 imx_enet_read_bd(&bd, addr); 566 if ((bd.flags & ENET_BD_R) == 0) { 567 /* Run out of descriptors to transmit. */ 568 569 trace_imx_eth_tx_bd_busy(); 570 571 break; 572 } 573 len = bd.length; 574 if (frame_size + len > ENET_MAX_FRAME_SIZE) { 575 len = ENET_MAX_FRAME_SIZE - frame_size; 576 s->regs[ENET_EIR] |= ENET_INT_BABT; 577 } 578 dma_memory_read(&address_space_memory, bd.data, ptr, len, 579 MEMTXATTRS_UNSPECIFIED); 580 ptr += len; 581 frame_size += len; 582 if (bd.flags & ENET_BD_L) { 583 int csum = 0; 584 585 if (bd.option & ENET_BD_PINS) { 586 csum |= (CSUM_TCP | CSUM_UDP); 587 } 588 if (bd.option & ENET_BD_IINS) { 589 csum |= CSUM_IP; 590 } 591 if (csum) { 592 net_checksum_calculate(s->frame, frame_size, csum); 593 } 594 595 /* Last buffer in frame. */ 596 597 qemu_send_packet(qemu_get_queue(s->nic), s->frame, frame_size); 598 ptr = s->frame; 599 600 frame_size = 0; 601 if (bd.option & ENET_BD_TX_INT) { 602 s->regs[ENET_EIR] |= int_txf; 603 } 604 /* Indicate that we've updated the last buffer descriptor. */ 605 bd.last_buffer = ENET_BD_BDU; 606 } 607 if (bd.option & ENET_BD_TX_INT) { 608 s->regs[ENET_EIR] |= int_txb; 609 } 610 bd.flags &= ~ENET_BD_R; 611 /* Write back the modified descriptor. */ 612 imx_enet_write_bd(&bd, addr); 613 /* Advance to the next descriptor. */ 614 if ((bd.flags & ENET_BD_W) != 0) { 615 addr = s->regs[tdsr]; 616 } else { 617 addr += sizeof(bd); 618 } 619 } 620 621 s->tx_descriptor[ring] = addr; 622 623 imx_eth_update(s); 624 } 625 626 static void imx_eth_do_tx(IMXFECState *s, uint32_t index) 627 { 628 if (!s->is_fec && (s->regs[ENET_ECR] & ENET_ECR_EN1588)) { 629 imx_enet_do_tx(s, index); 630 } else { 631 imx_fec_do_tx(s); 632 } 633 } 634 635 static void imx_eth_enable_rx(IMXFECState *s, bool flush) 636 { 637 IMXFECBufDesc bd; 638 639 imx_fec_read_bd(&bd, s->rx_descriptor); 640 641 s->regs[ENET_RDAR] = (bd.flags & ENET_BD_E) ? ENET_RDAR_RDAR : 0; 642 643 if (!s->regs[ENET_RDAR]) { 644 trace_imx_eth_rx_bd_full(); 645 } else if (flush) { 646 qemu_flush_queued_packets(qemu_get_queue(s->nic)); 647 } 648 } 649 650 static void imx_eth_reset(DeviceState *d) 651 { 652 IMXFECState *s = IMX_FEC(d); 653 654 /* Reset the Device */ 655 memset(s->regs, 0, sizeof(s->regs)); 656 s->regs[ENET_ECR] = 0xf0000000; 657 s->regs[ENET_MIBC] = 0xc0000000; 658 s->regs[ENET_RCR] = 0x05ee0001; 659 s->regs[ENET_OPD] = 0x00010000; 660 661 s->regs[ENET_PALR] = (s->conf.macaddr.a[0] << 24) 662 | (s->conf.macaddr.a[1] << 16) 663 | (s->conf.macaddr.a[2] << 8) 664 | s->conf.macaddr.a[3]; 665 s->regs[ENET_PAUR] = (s->conf.macaddr.a[4] << 24) 666 | (s->conf.macaddr.a[5] << 16) 667 | 0x8808; 668 669 if (s->is_fec) { 670 s->regs[ENET_FRBR] = 0x00000600; 671 s->regs[ENET_FRSR] = 0x00000500; 672 s->regs[ENET_MIIGSK_ENR] = 0x00000006; 673 } else { 674 s->regs[ENET_RAEM] = 0x00000004; 675 s->regs[ENET_RAFL] = 0x00000004; 676 s->regs[ENET_TAEM] = 0x00000004; 677 s->regs[ENET_TAFL] = 0x00000008; 678 s->regs[ENET_TIPG] = 0x0000000c; 679 s->regs[ENET_FTRL] = 0x000007ff; 680 s->regs[ENET_ATPER] = 0x3b9aca00; 681 } 682 683 s->rx_descriptor = 0; 684 memset(s->tx_descriptor, 0, sizeof(s->tx_descriptor)); 685 686 /* We also reset the PHY */ 687 imx_phy_reset(s); 688 } 689 690 static uint32_t imx_default_read(IMXFECState *s, uint32_t index) 691 { 692 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Bad register at offset 0x%" 693 PRIx32 "\n", TYPE_IMX_FEC, __func__, index * 4); 694 return 0; 695 } 696 697 static uint32_t imx_fec_read(IMXFECState *s, uint32_t index) 698 { 699 switch (index) { 700 case ENET_FRBR: 701 case ENET_FRSR: 702 case ENET_MIIGSK_CFGR: 703 case ENET_MIIGSK_ENR: 704 return s->regs[index]; 705 default: 706 return imx_default_read(s, index); 707 } 708 } 709 710 static uint32_t imx_enet_read(IMXFECState *s, uint32_t index) 711 { 712 switch (index) { 713 case ENET_RSFL: 714 case ENET_RSEM: 715 case ENET_RAEM: 716 case ENET_RAFL: 717 case ENET_TSEM: 718 case ENET_TAEM: 719 case ENET_TAFL: 720 case ENET_TIPG: 721 case ENET_FTRL: 722 case ENET_TACC: 723 case ENET_RACC: 724 case ENET_ATCR: 725 case ENET_ATVR: 726 case ENET_ATOFF: 727 case ENET_ATPER: 728 case ENET_ATCOR: 729 case ENET_ATINC: 730 case ENET_ATSTMP: 731 case ENET_TGSR: 732 case ENET_TCSR0: 733 case ENET_TCCR0: 734 case ENET_TCSR1: 735 case ENET_TCCR1: 736 case ENET_TCSR2: 737 case ENET_TCCR2: 738 case ENET_TCSR3: 739 case ENET_TCCR3: 740 return s->regs[index]; 741 default: 742 return imx_default_read(s, index); 743 } 744 } 745 746 static uint64_t imx_eth_read(void *opaque, hwaddr offset, unsigned size) 747 { 748 uint32_t value = 0; 749 IMXFECState *s = IMX_FEC(opaque); 750 uint32_t index = offset >> 2; 751 752 switch (index) { 753 case ENET_EIR: 754 case ENET_EIMR: 755 case ENET_RDAR: 756 case ENET_TDAR: 757 case ENET_ECR: 758 case ENET_MMFR: 759 case ENET_MSCR: 760 case ENET_MIBC: 761 case ENET_RCR: 762 case ENET_TCR: 763 case ENET_PALR: 764 case ENET_PAUR: 765 case ENET_OPD: 766 case ENET_IAUR: 767 case ENET_IALR: 768 case ENET_GAUR: 769 case ENET_GALR: 770 case ENET_TFWR: 771 case ENET_RDSR: 772 case ENET_TDSR: 773 case ENET_MRBR: 774 value = s->regs[index]; 775 break; 776 default: 777 if (s->is_fec) { 778 value = imx_fec_read(s, index); 779 } else { 780 value = imx_enet_read(s, index); 781 } 782 break; 783 } 784 785 trace_imx_eth_read(index, imx_eth_reg_name(s, index), value); 786 787 return value; 788 } 789 790 static void imx_default_write(IMXFECState *s, uint32_t index, uint32_t value) 791 { 792 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Bad address at offset 0x%" 793 PRIx32 "\n", TYPE_IMX_FEC, __func__, index * 4); 794 return; 795 } 796 797 static void imx_fec_write(IMXFECState *s, uint32_t index, uint32_t value) 798 { 799 switch (index) { 800 case ENET_FRBR: 801 /* FRBR is read only */ 802 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Register FRBR is read only\n", 803 TYPE_IMX_FEC, __func__); 804 break; 805 case ENET_FRSR: 806 s->regs[index] = (value & 0x000003fc) | 0x00000400; 807 break; 808 case ENET_MIIGSK_CFGR: 809 s->regs[index] = value & 0x00000053; 810 break; 811 case ENET_MIIGSK_ENR: 812 s->regs[index] = (value & 0x00000002) ? 0x00000006 : 0; 813 break; 814 default: 815 imx_default_write(s, index, value); 816 break; 817 } 818 } 819 820 static void imx_enet_write(IMXFECState *s, uint32_t index, uint32_t value) 821 { 822 switch (index) { 823 case ENET_RSFL: 824 case ENET_RSEM: 825 case ENET_RAEM: 826 case ENET_RAFL: 827 case ENET_TSEM: 828 case ENET_TAEM: 829 case ENET_TAFL: 830 s->regs[index] = value & 0x000001ff; 831 break; 832 case ENET_TIPG: 833 s->regs[index] = value & 0x0000001f; 834 break; 835 case ENET_FTRL: 836 s->regs[index] = value & 0x00003fff; 837 break; 838 case ENET_TACC: 839 s->regs[index] = value & 0x00000019; 840 break; 841 case ENET_RACC: 842 s->regs[index] = value & 0x000000C7; 843 break; 844 case ENET_ATCR: 845 s->regs[index] = value & 0x00002a9d; 846 break; 847 case ENET_ATVR: 848 case ENET_ATOFF: 849 case ENET_ATPER: 850 s->regs[index] = value; 851 break; 852 case ENET_ATSTMP: 853 /* ATSTMP is read only */ 854 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Register ATSTMP is read only\n", 855 TYPE_IMX_FEC, __func__); 856 break; 857 case ENET_ATCOR: 858 s->regs[index] = value & 0x7fffffff; 859 break; 860 case ENET_ATINC: 861 s->regs[index] = value & 0x00007f7f; 862 break; 863 case ENET_TGSR: 864 /* implement clear timer flag */ 865 s->regs[index] &= ~(value & 0x0000000f); /* all bits W1C */ 866 break; 867 case ENET_TCSR0: 868 case ENET_TCSR1: 869 case ENET_TCSR2: 870 case ENET_TCSR3: 871 s->regs[index] &= ~(value & 0x00000080); /* W1C bits */ 872 s->regs[index] &= ~0x0000007d; /* writable fields */ 873 s->regs[index] |= (value & 0x0000007d); 874 break; 875 case ENET_TCCR0: 876 case ENET_TCCR1: 877 case ENET_TCCR2: 878 case ENET_TCCR3: 879 s->regs[index] = value; 880 break; 881 default: 882 imx_default_write(s, index, value); 883 break; 884 } 885 } 886 887 static void imx_eth_write(void *opaque, hwaddr offset, uint64_t value, 888 unsigned size) 889 { 890 IMXFECState *s = IMX_FEC(opaque); 891 const bool single_tx_ring = !imx_eth_is_multi_tx_ring(s); 892 uint32_t index = offset >> 2; 893 894 trace_imx_eth_write(index, imx_eth_reg_name(s, index), value); 895 896 switch (index) { 897 case ENET_EIR: 898 s->regs[index] &= ~value; 899 break; 900 case ENET_EIMR: 901 s->regs[index] = value; 902 break; 903 case ENET_RDAR: 904 if (s->regs[ENET_ECR] & ENET_ECR_ETHEREN) { 905 if (!s->regs[index]) { 906 imx_eth_enable_rx(s, true); 907 } 908 } else { 909 s->regs[index] = 0; 910 } 911 break; 912 case ENET_TDAR1: 913 case ENET_TDAR2: 914 if (unlikely(single_tx_ring)) { 915 qemu_log_mask(LOG_GUEST_ERROR, 916 "[%s]%s: trying to access TDAR2 or TDAR1\n", 917 TYPE_IMX_FEC, __func__); 918 return; 919 } 920 /* fall through */ 921 case ENET_TDAR: 922 if (s->regs[ENET_ECR] & ENET_ECR_ETHEREN) { 923 s->regs[index] = ENET_TDAR_TDAR; 924 imx_eth_do_tx(s, index); 925 } 926 s->regs[index] = 0; 927 break; 928 case ENET_ECR: 929 if (value & ENET_ECR_RESET) { 930 return imx_eth_reset(DEVICE(s)); 931 } 932 s->regs[index] = value; 933 if ((s->regs[index] & ENET_ECR_ETHEREN) == 0) { 934 s->regs[ENET_RDAR] = 0; 935 s->rx_descriptor = s->regs[ENET_RDSR]; 936 s->regs[ENET_TDAR] = 0; 937 s->regs[ENET_TDAR1] = 0; 938 s->regs[ENET_TDAR2] = 0; 939 s->tx_descriptor[0] = s->regs[ENET_TDSR]; 940 s->tx_descriptor[1] = s->regs[ENET_TDSR1]; 941 s->tx_descriptor[2] = s->regs[ENET_TDSR2]; 942 } 943 break; 944 case ENET_MMFR: 945 s->regs[index] = value; 946 if (extract32(value, 29, 1)) { 947 /* This is a read operation */ 948 s->regs[ENET_MMFR] = deposit32(s->regs[ENET_MMFR], 0, 16, 949 imx_phy_read(s, 950 extract32(value, 951 18, 10))); 952 } else { 953 /* This is a write operation */ 954 imx_phy_write(s, extract32(value, 18, 10), extract32(value, 0, 16)); 955 } 956 /* raise the interrupt as the PHY operation is done */ 957 s->regs[ENET_EIR] |= ENET_INT_MII; 958 break; 959 case ENET_MSCR: 960 s->regs[index] = value & 0xfe; 961 break; 962 case ENET_MIBC: 963 /* TODO: Implement MIB. */ 964 s->regs[index] = (value & 0x80000000) ? 0xc0000000 : 0; 965 break; 966 case ENET_RCR: 967 s->regs[index] = value & 0x07ff003f; 968 /* TODO: Implement LOOP mode. */ 969 break; 970 case ENET_TCR: 971 /* We transmit immediately, so raise GRA immediately. */ 972 s->regs[index] = value; 973 if (value & 1) { 974 s->regs[ENET_EIR] |= ENET_INT_GRA; 975 } 976 break; 977 case ENET_PALR: 978 s->regs[index] = value; 979 s->conf.macaddr.a[0] = value >> 24; 980 s->conf.macaddr.a[1] = value >> 16; 981 s->conf.macaddr.a[2] = value >> 8; 982 s->conf.macaddr.a[3] = value; 983 break; 984 case ENET_PAUR: 985 s->regs[index] = (value | 0x0000ffff) & 0xffff8808; 986 s->conf.macaddr.a[4] = value >> 24; 987 s->conf.macaddr.a[5] = value >> 16; 988 break; 989 case ENET_OPD: 990 s->regs[index] = (value & 0x0000ffff) | 0x00010000; 991 break; 992 case ENET_IAUR: 993 case ENET_IALR: 994 case ENET_GAUR: 995 case ENET_GALR: 996 /* TODO: implement MAC hash filtering. */ 997 break; 998 case ENET_TFWR: 999 if (s->is_fec) { 1000 s->regs[index] = value & 0x3; 1001 } else { 1002 s->regs[index] = value & 0x13f; 1003 } 1004 break; 1005 case ENET_RDSR: 1006 if (s->is_fec) { 1007 s->regs[index] = value & ~3; 1008 } else { 1009 s->regs[index] = value & ~7; 1010 } 1011 s->rx_descriptor = s->regs[index]; 1012 break; 1013 case ENET_TDSR: 1014 if (s->is_fec) { 1015 s->regs[index] = value & ~3; 1016 } else { 1017 s->regs[index] = value & ~7; 1018 } 1019 s->tx_descriptor[0] = s->regs[index]; 1020 break; 1021 case ENET_TDSR1: 1022 if (unlikely(single_tx_ring)) { 1023 qemu_log_mask(LOG_GUEST_ERROR, 1024 "[%s]%s: trying to access TDSR1\n", 1025 TYPE_IMX_FEC, __func__); 1026 return; 1027 } 1028 1029 s->regs[index] = value & ~7; 1030 s->tx_descriptor[1] = s->regs[index]; 1031 break; 1032 case ENET_TDSR2: 1033 if (unlikely(single_tx_ring)) { 1034 qemu_log_mask(LOG_GUEST_ERROR, 1035 "[%s]%s: trying to access TDSR2\n", 1036 TYPE_IMX_FEC, __func__); 1037 return; 1038 } 1039 1040 s->regs[index] = value & ~7; 1041 s->tx_descriptor[2] = s->regs[index]; 1042 break; 1043 case ENET_MRBR: 1044 s->regs[index] = value & 0x00003ff0; 1045 break; 1046 default: 1047 if (s->is_fec) { 1048 imx_fec_write(s, index, value); 1049 } else { 1050 imx_enet_write(s, index, value); 1051 } 1052 return; 1053 } 1054 1055 imx_eth_update(s); 1056 } 1057 1058 static bool imx_eth_can_receive(NetClientState *nc) 1059 { 1060 IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc)); 1061 1062 return !!s->regs[ENET_RDAR]; 1063 } 1064 1065 static ssize_t imx_fec_receive(NetClientState *nc, const uint8_t *buf, 1066 size_t len) 1067 { 1068 IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc)); 1069 IMXFECBufDesc bd; 1070 uint32_t flags = 0; 1071 uint32_t addr; 1072 uint32_t crc; 1073 uint32_t buf_addr; 1074 uint8_t *crc_ptr; 1075 unsigned int buf_len; 1076 size_t size = len; 1077 1078 trace_imx_fec_receive(size); 1079 1080 if (!s->regs[ENET_RDAR]) { 1081 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Unexpected packet\n", 1082 TYPE_IMX_FEC, __func__); 1083 return 0; 1084 } 1085 1086 crc = cpu_to_be32(crc32(~0, buf, size)); 1087 /* Increase size by 4, loop below reads the last 4 bytes from crc_ptr. */ 1088 size += 4; 1089 crc_ptr = (uint8_t *) &crc; 1090 1091 /* Huge frames are truncated. */ 1092 if (size > ENET_MAX_FRAME_SIZE) { 1093 size = ENET_MAX_FRAME_SIZE; 1094 flags |= ENET_BD_TR | ENET_BD_LG; 1095 } 1096 1097 /* Frames larger than the user limit just set error flags. */ 1098 if (size > (s->regs[ENET_RCR] >> 16)) { 1099 flags |= ENET_BD_LG; 1100 } 1101 1102 addr = s->rx_descriptor; 1103 while (size > 0) { 1104 imx_fec_read_bd(&bd, addr); 1105 if ((bd.flags & ENET_BD_E) == 0) { 1106 /* No descriptors available. Bail out. */ 1107 /* 1108 * FIXME: This is wrong. We should probably either 1109 * save the remainder for when more RX buffers are 1110 * available, or flag an error. 1111 */ 1112 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Lost end of frame\n", 1113 TYPE_IMX_FEC, __func__); 1114 break; 1115 } 1116 buf_len = (size <= s->regs[ENET_MRBR]) ? size : s->regs[ENET_MRBR]; 1117 bd.length = buf_len; 1118 size -= buf_len; 1119 1120 trace_imx_fec_receive_len(addr, bd.length); 1121 1122 /* The last 4 bytes are the CRC. */ 1123 if (size < 4) { 1124 buf_len += size - 4; 1125 } 1126 buf_addr = bd.data; 1127 dma_memory_write(&address_space_memory, buf_addr, buf, buf_len, 1128 MEMTXATTRS_UNSPECIFIED); 1129 buf += buf_len; 1130 if (size < 4) { 1131 dma_memory_write(&address_space_memory, buf_addr + buf_len, 1132 crc_ptr, 4 - size, MEMTXATTRS_UNSPECIFIED); 1133 crc_ptr += 4 - size; 1134 } 1135 bd.flags &= ~ENET_BD_E; 1136 if (size == 0) { 1137 /* Last buffer in frame. */ 1138 bd.flags |= flags | ENET_BD_L; 1139 1140 trace_imx_fec_receive_last(bd.flags); 1141 1142 s->regs[ENET_EIR] |= ENET_INT_RXF; 1143 } else { 1144 s->regs[ENET_EIR] |= ENET_INT_RXB; 1145 } 1146 imx_fec_write_bd(&bd, addr); 1147 /* Advance to the next descriptor. */ 1148 if ((bd.flags & ENET_BD_W) != 0) { 1149 addr = s->regs[ENET_RDSR]; 1150 } else { 1151 addr += sizeof(bd); 1152 } 1153 } 1154 s->rx_descriptor = addr; 1155 imx_eth_enable_rx(s, false); 1156 imx_eth_update(s); 1157 return len; 1158 } 1159 1160 static ssize_t imx_enet_receive(NetClientState *nc, const uint8_t *buf, 1161 size_t len) 1162 { 1163 IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc)); 1164 IMXENETBufDesc bd; 1165 uint32_t flags = 0; 1166 uint32_t addr; 1167 uint32_t crc; 1168 uint32_t buf_addr; 1169 uint8_t *crc_ptr; 1170 unsigned int buf_len; 1171 size_t size = len; 1172 bool shift16 = s->regs[ENET_RACC] & ENET_RACC_SHIFT16; 1173 1174 trace_imx_enet_receive(size); 1175 1176 if (!s->regs[ENET_RDAR]) { 1177 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Unexpected packet\n", 1178 TYPE_IMX_FEC, __func__); 1179 return 0; 1180 } 1181 1182 crc = cpu_to_be32(crc32(~0, buf, size)); 1183 /* Increase size by 4, loop below reads the last 4 bytes from crc_ptr. */ 1184 size += 4; 1185 crc_ptr = (uint8_t *) &crc; 1186 1187 if (shift16) { 1188 size += 2; 1189 } 1190 1191 /* Huge frames are truncated. */ 1192 if (size > s->regs[ENET_FTRL]) { 1193 size = s->regs[ENET_FTRL]; 1194 flags |= ENET_BD_TR | ENET_BD_LG; 1195 } 1196 1197 /* Frames larger than the user limit just set error flags. */ 1198 if (size > (s->regs[ENET_RCR] >> 16)) { 1199 flags |= ENET_BD_LG; 1200 } 1201 1202 addr = s->rx_descriptor; 1203 while (size > 0) { 1204 imx_enet_read_bd(&bd, addr); 1205 if ((bd.flags & ENET_BD_E) == 0) { 1206 /* No descriptors available. Bail out. */ 1207 /* 1208 * FIXME: This is wrong. We should probably either 1209 * save the remainder for when more RX buffers are 1210 * available, or flag an error. 1211 */ 1212 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Lost end of frame\n", 1213 TYPE_IMX_FEC, __func__); 1214 break; 1215 } 1216 buf_len = MIN(size, s->regs[ENET_MRBR]); 1217 bd.length = buf_len; 1218 size -= buf_len; 1219 1220 trace_imx_enet_receive_len(addr, bd.length); 1221 1222 /* The last 4 bytes are the CRC. */ 1223 if (size < 4) { 1224 buf_len += size - 4; 1225 } 1226 buf_addr = bd.data; 1227 1228 if (shift16) { 1229 /* 1230 * If SHIFT16 bit of ENETx_RACC register is set we need to 1231 * align the payload to 4-byte boundary. 1232 */ 1233 const uint8_t zeros[2] = { 0 }; 1234 1235 dma_memory_write(&address_space_memory, buf_addr, zeros, 1236 sizeof(zeros), MEMTXATTRS_UNSPECIFIED); 1237 1238 buf_addr += sizeof(zeros); 1239 buf_len -= sizeof(zeros); 1240 1241 /* We only do this once per Ethernet frame */ 1242 shift16 = false; 1243 } 1244 1245 dma_memory_write(&address_space_memory, buf_addr, buf, buf_len, 1246 MEMTXATTRS_UNSPECIFIED); 1247 buf += buf_len; 1248 if (size < 4) { 1249 dma_memory_write(&address_space_memory, buf_addr + buf_len, 1250 crc_ptr, 4 - size, MEMTXATTRS_UNSPECIFIED); 1251 crc_ptr += 4 - size; 1252 } 1253 bd.flags &= ~ENET_BD_E; 1254 if (size == 0) { 1255 /* Last buffer in frame. */ 1256 bd.flags |= flags | ENET_BD_L; 1257 1258 trace_imx_enet_receive_last(bd.flags); 1259 1260 /* Indicate that we've updated the last buffer descriptor. */ 1261 bd.last_buffer = ENET_BD_BDU; 1262 if (bd.option & ENET_BD_RX_INT) { 1263 s->regs[ENET_EIR] |= ENET_INT_RXF; 1264 } 1265 } else { 1266 if (bd.option & ENET_BD_RX_INT) { 1267 s->regs[ENET_EIR] |= ENET_INT_RXB; 1268 } 1269 } 1270 imx_enet_write_bd(&bd, addr); 1271 /* Advance to the next descriptor. */ 1272 if ((bd.flags & ENET_BD_W) != 0) { 1273 addr = s->regs[ENET_RDSR]; 1274 } else { 1275 addr += sizeof(bd); 1276 } 1277 } 1278 s->rx_descriptor = addr; 1279 imx_eth_enable_rx(s, false); 1280 imx_eth_update(s); 1281 return len; 1282 } 1283 1284 static ssize_t imx_eth_receive(NetClientState *nc, const uint8_t *buf, 1285 size_t len) 1286 { 1287 IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc)); 1288 1289 if (!s->is_fec && (s->regs[ENET_ECR] & ENET_ECR_EN1588)) { 1290 return imx_enet_receive(nc, buf, len); 1291 } else { 1292 return imx_fec_receive(nc, buf, len); 1293 } 1294 } 1295 1296 static const MemoryRegionOps imx_eth_ops = { 1297 .read = imx_eth_read, 1298 .write = imx_eth_write, 1299 .valid.min_access_size = 4, 1300 .valid.max_access_size = 4, 1301 .endianness = DEVICE_NATIVE_ENDIAN, 1302 }; 1303 1304 static void imx_eth_cleanup(NetClientState *nc) 1305 { 1306 IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc)); 1307 1308 s->nic = NULL; 1309 } 1310 1311 static NetClientInfo imx_eth_net_info = { 1312 .type = NET_CLIENT_DRIVER_NIC, 1313 .size = sizeof(NICState), 1314 .can_receive = imx_eth_can_receive, 1315 .receive = imx_eth_receive, 1316 .cleanup = imx_eth_cleanup, 1317 .link_status_changed = imx_eth_set_link, 1318 }; 1319 1320 1321 static void imx_eth_realize(DeviceState *dev, Error **errp) 1322 { 1323 IMXFECState *s = IMX_FEC(dev); 1324 SysBusDevice *sbd = SYS_BUS_DEVICE(dev); 1325 1326 memory_region_init_io(&s->iomem, OBJECT(dev), &imx_eth_ops, s, 1327 TYPE_IMX_FEC, FSL_IMX25_FEC_SIZE); 1328 sysbus_init_mmio(sbd, &s->iomem); 1329 sysbus_init_irq(sbd, &s->irq[0]); 1330 sysbus_init_irq(sbd, &s->irq[1]); 1331 1332 qemu_macaddr_default_if_unset(&s->conf.macaddr); 1333 1334 s->nic = qemu_new_nic(&imx_eth_net_info, &s->conf, 1335 object_get_typename(OBJECT(dev)), 1336 dev->id, &dev->mem_reentrancy_guard, s); 1337 1338 qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a); 1339 } 1340 1341 static Property imx_eth_properties[] = { 1342 DEFINE_NIC_PROPERTIES(IMXFECState, conf), 1343 DEFINE_PROP_UINT32("tx-ring-num", IMXFECState, tx_ring_num, 1), 1344 DEFINE_PROP_UINT32("phy-num", IMXFECState, phy_num, 0), 1345 DEFINE_PROP_BOOL("phy-connected", IMXFECState, phy_connected, true), 1346 DEFINE_PROP_LINK("phy-consumer", IMXFECState, phy_consumer, TYPE_IMX_FEC, 1347 IMXFECState *), 1348 DEFINE_PROP_END_OF_LIST(), 1349 }; 1350 1351 static void imx_eth_class_init(ObjectClass *klass, void *data) 1352 { 1353 DeviceClass *dc = DEVICE_CLASS(klass); 1354 1355 dc->vmsd = &vmstate_imx_eth; 1356 device_class_set_legacy_reset(dc, imx_eth_reset); 1357 device_class_set_props(dc, imx_eth_properties); 1358 dc->realize = imx_eth_realize; 1359 dc->desc = "i.MX FEC/ENET Ethernet Controller"; 1360 } 1361 1362 static void imx_fec_init(Object *obj) 1363 { 1364 IMXFECState *s = IMX_FEC(obj); 1365 1366 s->is_fec = true; 1367 } 1368 1369 static void imx_enet_init(Object *obj) 1370 { 1371 IMXFECState *s = IMX_FEC(obj); 1372 1373 s->is_fec = false; 1374 } 1375 1376 static const TypeInfo imx_fec_info = { 1377 .name = TYPE_IMX_FEC, 1378 .parent = TYPE_SYS_BUS_DEVICE, 1379 .instance_size = sizeof(IMXFECState), 1380 .instance_init = imx_fec_init, 1381 .class_init = imx_eth_class_init, 1382 }; 1383 1384 static const TypeInfo imx_enet_info = { 1385 .name = TYPE_IMX_ENET, 1386 .parent = TYPE_IMX_FEC, 1387 .instance_init = imx_enet_init, 1388 }; 1389 1390 static void imx_eth_register_types(void) 1391 { 1392 type_register_static(&imx_fec_info); 1393 type_register_static(&imx_enet_info); 1394 } 1395 1396 type_init(imx_eth_register_types) 1397