hw/net/smc91c111.c

   1 /*
   2  * SMSC 91C111 Ethernet interface emulation
   3  *
   4  * Copyright (c) 2005 CodeSourcery, LLC.
   5  * Written by Paul Brook
   6  *
   7  * This code is licensed under the GPL
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "hw/sysbus.h"
  12 #include "net/net.h"
  13 #include "hw/devices.h"
  14 /* For crc32 */
  15 #include <zlib.h>
  16
  17 /* Number of 2k memory pages available.  */
  18 #define NUM_PACKETS 4
  19
  20 #define TYPE_SMC91C111 "smc91c111"
  21 #define SMC91C111(obj) OBJECT_CHECK(smc91c111_state, (obj), TYPE_SMC91C111)
  22
  23 typedef struct {
  24     SysBusDevice parent_obj;
  25
  26     NICState *nic;
  27     NICConf conf;
  28     uint16_t tcr;
  29     uint16_t rcr;
  30     uint16_t cr;
  31     uint16_t ctr;
  32     uint16_t gpr;
  33     uint16_t ptr;
  34     uint16_t ercv;
  35     qemu_irq irq;
  36     int bank;
  37     int packet_num;
  38     int tx_alloc;
  39     /* Bitmask of allocated packets.  */
  40     int allocated;
  41     int tx_fifo_len;
  42     int tx_fifo[NUM_PACKETS];
  43     int rx_fifo_len;
  44     int rx_fifo[NUM_PACKETS];
  45     int tx_fifo_done_len;
  46     int tx_fifo_done[NUM_PACKETS];
  47     /* Packet buffer memory.  */
  48     uint8_t data[NUM_PACKETS][2048];
  49     uint8_t int_level;
  50     uint8_t int_mask;
  51     MemoryRegion mmio;
  52 } smc91c111_state;
  53
  54 static const VMStateDescription vmstate_smc91c111 = {
  55     .name = "smc91c111",
  56     .version_id = 1,
  57     .minimum_version_id = 1,
  58     .fields = (VMStateField[]) {
  59         VMSTATE_UINT16(tcr, smc91c111_state),
  60         VMSTATE_UINT16(rcr, smc91c111_state),
  61         VMSTATE_UINT16(cr, smc91c111_state),
  62         VMSTATE_UINT16(ctr, smc91c111_state),
  63         VMSTATE_UINT16(gpr, smc91c111_state),
  64         VMSTATE_UINT16(ptr, smc91c111_state),
  65         VMSTATE_UINT16(ercv, smc91c111_state),
  66         VMSTATE_INT32(bank, smc91c111_state),
  67         VMSTATE_INT32(packet_num, smc91c111_state),
  68         VMSTATE_INT32(tx_alloc, smc91c111_state),
  69         VMSTATE_INT32(allocated, smc91c111_state),
  70         VMSTATE_INT32(tx_fifo_len, smc91c111_state),
  71         VMSTATE_INT32_ARRAY(tx_fifo, smc91c111_state, NUM_PACKETS),
  72         VMSTATE_INT32(rx_fifo_len, smc91c111_state),
  73         VMSTATE_INT32_ARRAY(rx_fifo, smc91c111_state, NUM_PACKETS),
  74         VMSTATE_INT32(tx_fifo_done_len, smc91c111_state),
  75         VMSTATE_INT32_ARRAY(tx_fifo_done, smc91c111_state, NUM_PACKETS),
  76         VMSTATE_BUFFER_UNSAFE(data, smc91c111_state, 0, NUM_PACKETS * 2048),
  77         VMSTATE_UINT8(int_level, smc91c111_state),
  78         VMSTATE_UINT8(int_mask, smc91c111_state),
  79         VMSTATE_END_OF_LIST()
  80     }
  81 };
  82
  83 #define RCR_SOFT_RST  0x8000
  84 #define RCR_STRIP_CRC 0x0200
  85 #define RCR_RXEN      0x0100
  86
  87 #define TCR_EPH_LOOP  0x2000
  88 #define TCR_NOCRC     0x0100
  89 #define TCR_PAD_EN    0x0080
  90 #define TCR_FORCOL    0x0004
  91 #define TCR_LOOP      0x0002
  92 #define TCR_TXEN      0x0001
  93
  94 #define INT_MD        0x80
  95 #define INT_ERCV      0x40
  96 #define INT_EPH       0x20
  97 #define INT_RX_OVRN   0x10
  98 #define INT_ALLOC     0x08
  99 #define INT_TX_EMPTY  0x04
 100 #define INT_TX        0x02
 101 #define INT_RCV       0x01
 102
 103 #define CTR_AUTO_RELEASE  0x0800
 104 #define CTR_RELOAD        0x0002
 105 #define CTR_STORE         0x0001
 106
 107 #define RS_ALGNERR      0x8000
 108 #define RS_BRODCAST     0x4000
 109 #define RS_BADCRC       0x2000
 110 #define RS_ODDFRAME     0x1000
 111 #define RS_TOOLONG      0x0800
 112 #define RS_TOOSHORT     0x0400
 113 #define RS_MULTICAST    0x0001
 114
 115 /* Update interrupt status.  */
 116 static void smc91c111_update(smc91c111_state *s)
 117 {
 118     int level;
 119
 120     if (s->tx_fifo_len == 0)
 121         s->int_level |= INT_TX_EMPTY;
 122     if (s->tx_fifo_done_len != 0)
 123         s->int_level |= INT_TX;
 124     level = (s->int_level & s->int_mask) != 0;
 125     qemu_set_irq(s->irq, level);
 126 }
 127
 128 static int smc91c111_can_receive(smc91c111_state *s)
 129 {
 130     if ((s->rcr & RCR_RXEN) == 0 || (s->rcr & RCR_SOFT_RST)) {
 131         return 1;
 132     }
 133     if (s->allocated == (1 << NUM_PACKETS) - 1 ||
 134         s->rx_fifo_len == NUM_PACKETS) {
 135         return 0;
 136     }
 137     return 1;
 138 }
 139
 140 static inline void smc91c111_flush_queued_packets(smc91c111_state *s)
 141 {
 142     if (smc91c111_can_receive(s)) {
 143         qemu_flush_queued_packets(qemu_get_queue(s->nic));
 144     }
 145 }
 146
 147 /* Try to allocate a packet.  Returns 0x80 on failure.  */
 148 static int smc91c111_allocate_packet(smc91c111_state *s)
 149 {
 150     int i;
 151     if (s->allocated == (1 << NUM_PACKETS) - 1) {
 152         return 0x80;
 153     }
 154
 155     for (i = 0; i < NUM_PACKETS; i++) {
 156         if ((s->allocated & (1 << i)) == 0)
 157             break;
 158     }
 159     s->allocated |= 1 << i;
 160     return i;
 161 }
 162
 163
 164 /* Process a pending TX allocate.  */
 165 static void smc91c111_tx_alloc(smc91c111_state *s)
 166 {
 167     s->tx_alloc = smc91c111_allocate_packet(s);
 168     if (s->tx_alloc == 0x80)
 169         return;
 170     s->int_level |= INT_ALLOC;
 171     smc91c111_update(s);
 172 }
 173
 174 /* Remove and item from the RX FIFO.  */
 175 static void smc91c111_pop_rx_fifo(smc91c111_state *s)
 176 {
 177     int i;
 178
 179     s->rx_fifo_len--;
 180     if (s->rx_fifo_len) {
 181         for (i = 0; i < s->rx_fifo_len; i++)
 182             s->rx_fifo[i] = s->rx_fifo[i + 1];
 183         s->int_level |= INT_RCV;
 184     } else {
 185         s->int_level &= ~INT_RCV;
 186     }
 187     smc91c111_flush_queued_packets(s);
 188     smc91c111_update(s);
 189 }
 190
 191 /* Remove an item from the TX completion FIFO.  */
 192 static void smc91c111_pop_tx_fifo_done(smc91c111_state *s)
 193 {
 194     int i;
 195
 196     if (s->tx_fifo_done_len == 0)
 197         return;
 198     s->tx_fifo_done_len--;
 199     for (i = 0; i < s->tx_fifo_done_len; i++)
 200         s->tx_fifo_done[i] = s->tx_fifo_done[i + 1];
 201 }
 202
 203 /* Release the memory allocated to a packet.  */
 204 static void smc91c111_release_packet(smc91c111_state *s, int packet)
 205 {
 206     s->allocated &= ~(1 << packet);
 207     if (s->tx_alloc == 0x80)
 208         smc91c111_tx_alloc(s);
 209     smc91c111_flush_queued_packets(s);
 210 }
 211
 212 /* Flush the TX FIFO.  */
 213 static void smc91c111_do_tx(smc91c111_state *s)
 214 {
 215     int i;
 216     int len;
 217     int control;
 218     int packetnum;
 219     uint8_t *p;
 220
 221     if ((s->tcr & TCR_TXEN) == 0)
 222         return;
 223     if (s->tx_fifo_len == 0)
 224         return;
 225     for (i = 0; i < s->tx_fifo_len; i++) {
 226         packetnum = s->tx_fifo[i];
 227         p = &s->data[packetnum][0];
 228         /* Set status word.  */
 229         *(p++) = 0x01;
 230         *(p++) = 0x40;
 231         len = *(p++);
 232         len |= ((int)*(p++)) << 8;
 233         len -= 6;
 234         control = p[len + 1];
 235         if (control & 0x20)
 236             len++;
 237         /* ??? This overwrites the data following the buffer.
 238            Don't know what real hardware does.  */
 239         if (len < 64 && (s->tcr & TCR_PAD_EN)) {
 240             memset(p + len, 0, 64 - len);
 241             len = 64;
 242         }
 243 #if 0
 244         {
 245             int add_crc;
 246
 247             /* The card is supposed to append the CRC to the frame.
 248                However none of the other network traffic has the CRC
 249                appended.  Suspect this is low level ethernet detail we
 250                don't need to worry about.  */
 251             add_crc = (control & 0x10) || (s->tcr & TCR_NOCRC) == 0;
 252             if (add_crc) {
 253                 uint32_t crc;
 254
 255                 crc = crc32(~0, p, len);
 256                 memcpy(p + len, &crc, 4);
 257                 len += 4;
 258             }
 259         }
 260 #endif
 261         if (s->ctr & CTR_AUTO_RELEASE)
 262             /* Race?  */
 263             smc91c111_release_packet(s, packetnum);
 264         else if (s->tx_fifo_done_len < NUM_PACKETS)
 265             s->tx_fifo_done[s->tx_fifo_done_len++] = packetnum;
 266         qemu_send_packet(qemu_get_queue(s->nic), p, len);
 267     }
 268     s->tx_fifo_len = 0;
 269     smc91c111_update(s);
 270 }
 271
 272 /* Add a packet to the TX FIFO.  */
 273 static void smc91c111_queue_tx(smc91c111_state *s, int packet)
 274 {
 275     if (s->tx_fifo_len == NUM_PACKETS)
 276         return;
 277     s->tx_fifo[s->tx_fifo_len++] = packet;
 278     smc91c111_do_tx(s);
 279 }
 280
 281 static void smc91c111_reset(DeviceState *dev)
 282 {
 283     smc91c111_state *s = SMC91C111(dev);
 284
 285     s->bank = 0;
 286     s->tx_fifo_len = 0;
 287     s->tx_fifo_done_len = 0;
 288     s->rx_fifo_len = 0;
 289     s->allocated = 0;
 290     s->packet_num = 0;
 291     s->tx_alloc = 0;
 292     s->tcr = 0;
 293     s->rcr = 0;
 294     s->cr = 0xa0b1;
 295     s->ctr = 0x1210;
 296     s->ptr = 0;
 297     s->ercv = 0x1f;
 298     s->int_level = INT_TX_EMPTY;
 299     s->int_mask = 0;
 300     smc91c111_update(s);
 301 }
 302
 303 #define SET_LOW(name, val) s->name = (s->name & 0xff00) | val
 304 #define SET_HIGH(name, val) s->name = (s->name & 0xff) | (val << 8)
 305
 306 static void smc91c111_writeb(void *opaque, hwaddr offset,
 307                              uint32_t value)
 308 {
 309     smc91c111_state *s = (smc91c111_state *)opaque;
 310
 311     offset = offset & 0xf;
 312     if (offset == 14) {
 313         s->bank = value;
 314         return;
 315     }
 316     if (offset == 15)
 317         return;
 318     switch (s->bank) {
 319     case 0:
 320         switch (offset) {
 321         case 0: /* TCR */
 322             SET_LOW(tcr, value);
 323             return;
 324         case 1:
 325             SET_HIGH(tcr, value);
 326             return;
 327         case 4: /* RCR */
 328             SET_LOW(rcr, value);
 329             return;
 330         case 5:
 331             SET_HIGH(rcr, value);
 332             if (s->rcr & RCR_SOFT_RST) {
 333                 smc91c111_reset(DEVICE(s));
 334             }
 335             smc91c111_flush_queued_packets(s);
 336             return;
 337         case 10: case 11: /* RPCR */
 338             /* Ignored */
 339             return;
 340         case 12: case 13: /* Reserved */
 341             return;
 342         }
 343         break;
 344
 345     case 1:
 346         switch (offset) {
 347         case 0: /* CONFIG */
 348             SET_LOW(cr, value);
 349             return;
 350         case 1:
 351             SET_HIGH(cr,value);
 352             return;
 353         case 2: case 3: /* BASE */
 354         case 4: case 5: case 6: case 7: case 8: case 9: /* IA */
 355             /* Not implemented.  */
 356             return;
 357         case 10: /* Genral Purpose */
 358             SET_LOW(gpr, value);
 359             return;
 360         case 11:
 361             SET_HIGH(gpr, value);
 362             return;
 363         case 12: /* Control */
 364             if (value & 1)
 365                 fprintf(stderr, "smc91c111:EEPROM store not implemented\n");
 366             if (value & 2)
 367                 fprintf(stderr, "smc91c111:EEPROM reload not implemented\n");
 368             value &= ~3;
 369             SET_LOW(ctr, value);
 370             return;
 371         case 13:
 372             SET_HIGH(ctr, value);
 373             return;
 374         }
 375         break;
 376
 377     case 2:
 378         switch (offset) {
 379         case 0: /* MMU Command */
 380             switch (value >> 5) {
 381             case 0: /* no-op */
 382                 break;
 383             case 1: /* Allocate for TX.  */
 384                 s->tx_alloc = 0x80;
 385                 s->int_level &= ~INT_ALLOC;
 386                 smc91c111_update(s);
 387                 smc91c111_tx_alloc(s);
 388                 break;
 389             case 2: /* Reset MMU.  */
 390                 s->allocated = 0;
 391                 s->tx_fifo_len = 0;
 392                 s->tx_fifo_done_len = 0;
 393                 s->rx_fifo_len = 0;
 394                 s->tx_alloc = 0;
 395                 break;
 396             case 3: /* Remove from RX FIFO.  */
 397                 smc91c111_pop_rx_fifo(s);
 398                 break;
 399             case 4: /* Remove from RX FIFO and release.  */
 400                 if (s->rx_fifo_len > 0) {
 401                     smc91c111_release_packet(s, s->rx_fifo[0]);
 402                 }
 403                 smc91c111_pop_rx_fifo(s);
 404                 break;
 405             case 5: /* Release.  */
 406                 smc91c111_release_packet(s, s->packet_num);
 407                 break;
 408             case 6: /* Add to TX FIFO.  */
 409                 smc91c111_queue_tx(s, s->packet_num);
 410                 break;
 411             case 7: /* Reset TX FIFO.  */
 412                 s->tx_fifo_len = 0;
 413                 s->tx_fifo_done_len = 0;
 414                 break;
 415             }
 416             return;
 417         case 1:
 418             /* Ignore.  */
 419             return;
 420         case 2: /* Packet Number Register */
 421             s->packet_num = value;
 422             return;
 423         case 3: case 4: case 5:
 424             /* Should be readonly, but linux writes to them anyway. Ignore.  */
 425             return;
 426         case 6: /* Pointer */
 427             SET_LOW(ptr, value);
 428             return;
 429         case 7:
 430             SET_HIGH(ptr, value);
 431             return;
 432         case 8: case 9: case 10: case 11: /* Data */
 433             {
 434                 int p;
 435                 int n;
 436
 437                 if (s->ptr & 0x8000)
 438                     n = s->rx_fifo[0];
 439                 else
 440                     n = s->packet_num;
 441                 p = s->ptr & 0x07ff;
 442                 if (s->ptr & 0x4000) {
 443                     s->ptr = (s->ptr & 0xf800) | ((s->ptr + 1) & 0x7ff);
 444                 } else {
 445                     p += (offset & 3);
 446                 }
 447                 s->data[n][p] = value;
 448             }
 449             return;
 450         case 12: /* Interrupt ACK.  */
 451             s->int_level &= ~(value & 0xd6);
 452             if (value & INT_TX)
 453                 smc91c111_pop_tx_fifo_done(s);
 454             smc91c111_update(s);
 455             return;
 456         case 13: /* Interrupt mask.  */
 457             s->int_mask = value;
 458             smc91c111_update(s);
 459             return;
 460         }
 461         break;
 462
 463     case 3:
 464         switch (offset) {
 465         case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
 466             /* Multicast table.  */
 467             /* Not implemented.  */
 468             return;
 469         case 8: case 9: /* Management Interface.  */
 470             /* Not implemented.  */
 471             return;
 472         case 12: /* Early receive.  */
 473             s->ercv = value & 0x1f;
 474             return;
 475         case 13:
 476             /* Ignore.  */
 477             return;
 478         }
 479         break;
 480     }
 481     hw_error("smc91c111_write: Bad reg %d:%x\n", s->bank, (int)offset);
 482 }
 483
 484 static uint32_t smc91c111_readb(void *opaque, hwaddr offset)
 485 {
 486     smc91c111_state *s = (smc91c111_state *)opaque;
 487
 488     offset = offset & 0xf;
 489     if (offset == 14) {
 490         return s->bank;
 491     }
 492     if (offset == 15)
 493         return 0x33;
 494     switch (s->bank) {
 495     case 0:
 496         switch (offset) {
 497         case 0: /* TCR */
 498             return s->tcr & 0xff;
 499         case 1:
 500             return s->tcr >> 8;
 501         case 2: /* EPH Status */
 502             return 0;
 503         case 3:
 504             return 0x40;
 505         case 4: /* RCR */
 506             return s->rcr & 0xff;
 507         case 5:
 508             return s->rcr >> 8;
 509         case 6: /* Counter */
 510         case 7:
 511             /* Not implemented.  */
 512             return 0;
 513         case 8: /* Memory size.  */
 514             return NUM_PACKETS;
 515         case 9: /* Free memory available.  */
 516             {
 517                 int i;
 518                 int n;
 519                 n = 0;
 520                 for (i = 0; i < NUM_PACKETS; i++) {
 521                     if (s->allocated & (1 << i))
 522                         n++;
 523                 }
 524                 return n;
 525             }
 526         case 10: case 11: /* RPCR */
 527             /* Not implemented.  */
 528             return 0;
 529         case 12: case 13: /* Reserved */
 530             return 0;
 531         }
 532         break;
 533
 534     case 1:
 535         switch (offset) {
 536         case 0: /* CONFIG */
 537             return s->cr & 0xff;
 538         case 1:
 539             return s->cr >> 8;
 540         case 2: case 3: /* BASE */
 541             /* Not implemented.  */
 542             return 0;
 543         case 4: case 5: case 6: case 7: case 8: case 9: /* IA */
 544             return s->conf.macaddr.a[offset - 4];
 545         case 10: /* General Purpose */
 546             return s->gpr & 0xff;
 547         case 11:
 548             return s->gpr >> 8;
 549         case 12: /* Control */
 550             return s->ctr & 0xff;
 551         case 13:
 552             return s->ctr >> 8;
 553         }
 554         break;
 555
 556     case 2:
 557         switch (offset) {
 558         case 0: case 1: /* MMUCR Busy bit.  */
 559             return 0;
 560         case 2: /* Packet Number.  */
 561             return s->packet_num;
 562         case 3: /* Allocation Result.  */
 563             return s->tx_alloc;
 564         case 4: /* TX FIFO */
 565             if (s->tx_fifo_done_len == 0)
 566                 return 0x80;
 567             else
 568                 return s->tx_fifo_done[0];
 569         case 5: /* RX FIFO */
 570             if (s->rx_fifo_len == 0)
 571                 return 0x80;
 572             else
 573                 return s->rx_fifo[0];
 574         case 6: /* Pointer */
 575             return s->ptr & 0xff;
 576         case 7:
 577             return (s->ptr >> 8) & 0xf7;
 578         case 8: case 9: case 10: case 11: /* Data */
 579             {
 580                 int p;
 581                 int n;
 582
 583                 if (s->ptr & 0x8000)
 584                     n = s->rx_fifo[0];
 585                 else
 586                     n = s->packet_num;
 587                 p = s->ptr & 0x07ff;
 588                 if (s->ptr & 0x4000) {
 589                     s->ptr = (s->ptr & 0xf800) | ((s->ptr + 1) & 0x07ff);
 590                 } else {
 591                     p += (offset & 3);
 592                 }
 593                 return s->data[n][p];
 594             }
 595         case 12: /* Interrupt status.  */
 596             return s->int_level;
 597         case 13: /* Interrupt mask.  */
 598             return s->int_mask;
 599         }
 600         break;
 601
 602     case 3:
 603         switch (offset) {
 604         case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
 605             /* Multicast table.  */
 606             /* Not implemented.  */
 607             return 0;
 608         case 8: /* Management Interface.  */
 609             /* Not implemented.  */
 610             return 0x30;
 611         case 9:
 612             return 0x33;
 613         case 10: /* Revision.  */
 614             return 0x91;
 615         case 11:
 616             return 0x33;
 617         case 12:
 618             return s->ercv;
 619         case 13:
 620             return 0;
 621         }
 622         break;
 623     }
 624     hw_error("smc91c111_read: Bad reg %d:%x\n", s->bank, (int)offset);
 625     return 0;
 626 }
 627
 628 static void smc91c111_writew(void *opaque, hwaddr offset,
 629                              uint32_t value)
 630 {
 631     smc91c111_writeb(opaque, offset, value & 0xff);
 632     smc91c111_writeb(opaque, offset + 1, value >> 8);
 633 }
 634
 635 static void smc91c111_writel(void *opaque, hwaddr offset,
 636                              uint32_t value)
 637 {
 638     /* 32-bit writes to offset 0xc only actually write to the bank select
 639        register (offset 0xe)  */
 640     if (offset != 0xc)
 641         smc91c111_writew(opaque, offset, value & 0xffff);
 642     smc91c111_writew(opaque, offset + 2, value >> 16);
 643 }
 644
 645 static uint32_t smc91c111_readw(void *opaque, hwaddr offset)
 646 {
 647     uint32_t val;
 648     val = smc91c111_readb(opaque, offset);
 649     val |= smc91c111_readb(opaque, offset + 1) << 8;
 650     return val;
 651 }
 652
 653 static uint32_t smc91c111_readl(void *opaque, hwaddr offset)
 654 {
 655     uint32_t val;
 656     val = smc91c111_readw(opaque, offset);
 657     val |= smc91c111_readw(opaque, offset + 2) << 16;
 658     return val;
 659 }
 660
 661 static int smc91c111_can_receive_nc(NetClientState *nc)
 662 {
 663     smc91c111_state *s = qemu_get_nic_opaque(nc);
 664
 665     return smc91c111_can_receive(s);
 666 }
 667
 668 static ssize_t smc91c111_receive(NetClientState *nc, const uint8_t *buf, size_t size)
 669 {
 670     smc91c111_state *s = qemu_get_nic_opaque(nc);
 671     int status;
 672     int packetsize;
 673     uint32_t crc;
 674     int packetnum;
 675     uint8_t *p;
 676
 677     if ((s->rcr & RCR_RXEN) == 0 || (s->rcr & RCR_SOFT_RST))
 678         return -1;
 679     /* Short packets are padded with zeros.  Receiving a packet
 680        < 64 bytes long is considered an error condition.  */
 681     if (size < 64)
 682         packetsize = 64;
 683     else
 684         packetsize = (size & ~1);
 685     packetsize += 6;
 686     crc = (s->rcr & RCR_STRIP_CRC) == 0;
 687     if (crc)
 688         packetsize += 4;
 689     /* TODO: Flag overrun and receive errors.  */
 690     if (packetsize > 2048)
 691         return -1;
 692     packetnum = smc91c111_allocate_packet(s);
 693     if (packetnum == 0x80)
 694         return -1;
 695     s->rx_fifo[s->rx_fifo_len++] = packetnum;
 696
 697     p = &s->data[packetnum][0];
 698     /* ??? Multicast packets?  */
 699     status = 0;
 700     if (size > 1518)
 701         status |= RS_TOOLONG;
 702     if (size & 1)
 703         status |= RS_ODDFRAME;
 704     *(p++) = status & 0xff;
 705     *(p++) = status >> 8;
 706     *(p++) = packetsize & 0xff;
 707     *(p++) = packetsize >> 8;
 708     memcpy(p, buf, size & ~1);
 709     p += (size & ~1);
 710     /* Pad short packets.  */
 711     if (size < 64) {
 712         int pad;
 713
 714         if (size & 1)
 715             *(p++) = buf[size - 1];
 716         pad = 64 - size;
 717         memset(p, 0, pad);
 718         p += pad;
 719         size = 64;
 720     }
 721     /* It's not clear if the CRC should go before or after the last byte in
 722        odd sized packets.  Linux disables the CRC, so that's no help.
 723        The pictures in the documentation show the CRC aligned on a 16-bit
 724        boundary before the last odd byte, so that's what we do.  */
 725     if (crc) {
 726         crc = crc32(~0, buf, size);
 727         *(p++) = crc & 0xff; crc >>= 8;
 728         *(p++) = crc & 0xff; crc >>= 8;
 729         *(p++) = crc & 0xff; crc >>= 8;
 730         *(p++) = crc & 0xff;
 731     }
 732     if (size & 1) {
 733         *(p++) = buf[size - 1];
 734         *p = 0x60;
 735     } else {
 736         *(p++) = 0;
 737         *p = 0x40;
 738     }
 739     /* TODO: Raise early RX interrupt?  */
 740     s->int_level |= INT_RCV;
 741     smc91c111_update(s);
 742
 743     return size;
 744 }
 745
 746 static const MemoryRegionOps smc91c111_mem_ops = {
 747     /* The special case for 32 bit writes to 0xc means we can't just
 748      * set .impl.min/max_access_size to 1, unfortunately
 749      */
 750     .old_mmio = {
 751         .read = { smc91c111_readb, smc91c111_readw, smc91c111_readl, },
 752         .write = { smc91c111_writeb, smc91c111_writew, smc91c111_writel, },
 753     },
 754     .endianness = DEVICE_NATIVE_ENDIAN,
 755 };
 756
 757 static NetClientInfo net_smc91c111_info = {
 758     .type = NET_CLIENT_OPTIONS_KIND_NIC,
 759     .size = sizeof(NICState),
 760     .can_receive = smc91c111_can_receive_nc,
 761     .receive = smc91c111_receive,
 762 };
 763
 764 static int smc91c111_init1(SysBusDevice *sbd)
 765 {
 766     DeviceState *dev = DEVICE(sbd);
 767     smc91c111_state *s = SMC91C111(dev);
 768
 769     memory_region_init_io(&s->mmio, OBJECT(s), &smc91c111_mem_ops, s,
 770                           "smc91c111-mmio", 16);
 771     sysbus_init_mmio(sbd, &s->mmio);
 772     sysbus_init_irq(sbd, &s->irq);
 773     qemu_macaddr_default_if_unset(&s->conf.macaddr);
 774     s->nic = qemu_new_nic(&net_smc91c111_info, &s->conf,
 775                           object_get_typename(OBJECT(dev)), dev->id, s);
 776     qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a);
 777     /* ??? Save/restore.  */
 778     return 0;
 779 }
 780
 781 static Property smc91c111_properties[] = {
 782     DEFINE_NIC_PROPERTIES(smc91c111_state, conf),
 783     DEFINE_PROP_END_OF_LIST(),
 784 };
 785
 786 static void smc91c111_class_init(ObjectClass *klass, void *data)
 787 {
 788     DeviceClass *dc = DEVICE_CLASS(klass);
 789     SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
 790
 791     k->init = smc91c111_init1;
 792     dc->reset = smc91c111_reset;
 793     dc->vmsd = &vmstate_smc91c111;
 794     dc->props = smc91c111_properties;
 795 }
 796
 797 static const TypeInfo smc91c111_info = {
 798     .name          = TYPE_SMC91C111,
 799     .parent        = TYPE_SYS_BUS_DEVICE,
 800     .instance_size = sizeof(smc91c111_state),
 801     .class_init    = smc91c111_class_init,
 802 };
 803
 804 static void smc91c111_register_types(void)
 805 {
 806     type_register_static(&smc91c111_info);
 807 }
 808
 809 /* Legacy helper function.  Should go away when machine config files are
 810    implemented.  */
 811 void smc91c111_init(NICInfo *nd, uint32_t base, qemu_irq irq)
 812 {
 813     DeviceState *dev;
 814     SysBusDevice *s;
 815
 816     qemu_check_nic_model(nd, "smc91c111");
 817     dev = qdev_create(NULL, TYPE_SMC91C111);
 818     qdev_set_nic_properties(dev, nd);
 819     qdev_init_nofail(dev);
 820     s = SYS_BUS_DEVICE(dev);
 821     sysbus_mmio_map(s, 0, base);
 822     sysbus_connect_irq(s, 0, irq);
 823 }
 824
 825 type_init(smc91c111_register_types)