hw/arm/bcm2836: Only provide "enabled-cpus" property to multicore SoCs
[qemu.git] / hw / net / allwinner_emac.c
1 /*
2 * Emulation of Allwinner EMAC Fast Ethernet controller and
3 * Realtek RTL8201CP PHY
4 *
5 * Copyright (C) 2014 Beniamino Galvani <b.galvani@gmail.com>
6 *
7 * This model is based on reverse-engineering of Linux kernel driver.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 */
19
20 #include "qemu/osdep.h"
21 #include "hw/sysbus.h"
22 #include "migration/vmstate.h"
23 #include "net/net.h"
24 #include "qemu/fifo8.h"
25 #include "hw/irq.h"
26 #include "hw/net/allwinner_emac.h"
27 #include "hw/qdev-properties.h"
28 #include "qemu/log.h"
29 #include "qemu/module.h"
30 #include <zlib.h>
31
32 static uint8_t padding[60];
33
34 static void mii_set_link(RTL8201CPState *mii, bool link_ok)
35 {
36 if (link_ok) {
37 mii->bmsr |= MII_BMSR_LINK_ST | MII_BMSR_AN_COMP;
38 mii->anlpar |= MII_ANAR_TXFD | MII_ANAR_10FD | MII_ANAR_10 |
39 MII_ANAR_CSMACD;
40 } else {
41 mii->bmsr &= ~(MII_BMSR_LINK_ST | MII_BMSR_AN_COMP);
42 mii->anlpar = MII_ANAR_TX;
43 }
44 }
45
46 static void mii_reset(RTL8201CPState *mii, bool link_ok)
47 {
48 mii->bmcr = MII_BMCR_FD | MII_BMCR_AUTOEN | MII_BMCR_SPEED;
49 mii->bmsr = MII_BMSR_100TX_FD | MII_BMSR_100TX_HD | MII_BMSR_10T_FD |
50 MII_BMSR_10T_HD | MII_BMSR_MFPS | MII_BMSR_AUTONEG;
51 mii->anar = MII_ANAR_TXFD | MII_ANAR_TX | MII_ANAR_10FD | MII_ANAR_10 |
52 MII_ANAR_CSMACD;
53 mii->anlpar = MII_ANAR_TX;
54
55 mii_set_link(mii, link_ok);
56 }
57
58 static uint16_t RTL8201CP_mdio_read(AwEmacState *s, uint8_t addr, uint8_t reg)
59 {
60 RTL8201CPState *mii = &s->mii;
61 uint16_t ret = 0xffff;
62
63 if (addr == s->phy_addr) {
64 switch (reg) {
65 case MII_BMCR:
66 return mii->bmcr;
67 case MII_BMSR:
68 return mii->bmsr;
69 case MII_PHYID1:
70 return RTL8201CP_PHYID1;
71 case MII_PHYID2:
72 return RTL8201CP_PHYID2;
73 case MII_ANAR:
74 return mii->anar;
75 case MII_ANLPAR:
76 return mii->anlpar;
77 case MII_ANER:
78 case MII_NSR:
79 case MII_LBREMR:
80 case MII_REC:
81 case MII_SNRDR:
82 case MII_TEST:
83 qemu_log_mask(LOG_UNIMP,
84 "allwinner_emac: read from unimpl. mii reg 0x%x\n",
85 reg);
86 return 0;
87 default:
88 qemu_log_mask(LOG_GUEST_ERROR,
89 "allwinner_emac: read from invalid mii reg 0x%x\n",
90 reg);
91 return 0;
92 }
93 }
94 return ret;
95 }
96
97 static void RTL8201CP_mdio_write(AwEmacState *s, uint8_t addr, uint8_t reg,
98 uint16_t value)
99 {
100 RTL8201CPState *mii = &s->mii;
101 NetClientState *nc;
102
103 if (addr == s->phy_addr) {
104 switch (reg) {
105 case MII_BMCR:
106 if (value & MII_BMCR_RESET) {
107 nc = qemu_get_queue(s->nic);
108 mii_reset(mii, !nc->link_down);
109 } else {
110 mii->bmcr = value;
111 }
112 break;
113 case MII_ANAR:
114 mii->anar = value;
115 break;
116 case MII_BMSR:
117 case MII_PHYID1:
118 case MII_PHYID2:
119 case MII_ANLPAR:
120 case MII_ANER:
121 qemu_log_mask(LOG_GUEST_ERROR,
122 "allwinner_emac: write to read-only mii reg 0x%x\n",
123 reg);
124 break;
125 case MII_NSR:
126 case MII_LBREMR:
127 case MII_REC:
128 case MII_SNRDR:
129 case MII_TEST:
130 qemu_log_mask(LOG_UNIMP,
131 "allwinner_emac: write to unimpl. mii reg 0x%x\n",
132 reg);
133 break;
134 default:
135 qemu_log_mask(LOG_GUEST_ERROR,
136 "allwinner_emac: write to invalid mii reg 0x%x\n",
137 reg);
138 }
139 }
140 }
141
142 static void aw_emac_update_irq(AwEmacState *s)
143 {
144 qemu_set_irq(s->irq, (s->int_sta & s->int_ctl) != 0);
145 }
146
147 static void aw_emac_tx_reset(AwEmacState *s, int chan)
148 {
149 fifo8_reset(&s->tx_fifo[chan]);
150 s->tx_length[chan] = 0;
151 }
152
153 static void aw_emac_rx_reset(AwEmacState *s)
154 {
155 fifo8_reset(&s->rx_fifo);
156 s->rx_num_packets = 0;
157 s->rx_packet_size = 0;
158 s->rx_packet_pos = 0;
159 }
160
161 static void fifo8_push_word(Fifo8 *fifo, uint32_t val)
162 {
163 fifo8_push(fifo, val);
164 fifo8_push(fifo, val >> 8);
165 fifo8_push(fifo, val >> 16);
166 fifo8_push(fifo, val >> 24);
167 }
168
169 static uint32_t fifo8_pop_word(Fifo8 *fifo)
170 {
171 uint32_t ret;
172
173 ret = fifo8_pop(fifo);
174 ret |= fifo8_pop(fifo) << 8;
175 ret |= fifo8_pop(fifo) << 16;
176 ret |= fifo8_pop(fifo) << 24;
177
178 return ret;
179 }
180
181 static bool aw_emac_can_receive(NetClientState *nc)
182 {
183 AwEmacState *s = qemu_get_nic_opaque(nc);
184
185 /*
186 * To avoid packet drops, allow reception only when there is space
187 * for a full frame: 1522 + 8 (rx headers) + 2 (padding).
188 */
189 return (s->ctl & EMAC_CTL_RX_EN) && (fifo8_num_free(&s->rx_fifo) >= 1532);
190 }
191
192 static ssize_t aw_emac_receive(NetClientState *nc, const uint8_t *buf,
193 size_t size)
194 {
195 AwEmacState *s = qemu_get_nic_opaque(nc);
196 Fifo8 *fifo = &s->rx_fifo;
197 size_t padded_size, total_size;
198 uint32_t crc;
199
200 padded_size = size > 60 ? size : 60;
201 total_size = QEMU_ALIGN_UP(RX_HDR_SIZE + padded_size + CRC_SIZE, 4);
202
203 if (!(s->ctl & EMAC_CTL_RX_EN) || (fifo8_num_free(fifo) < total_size)) {
204 return -1;
205 }
206
207 fifo8_push_word(fifo, EMAC_UNDOCUMENTED_MAGIC);
208 fifo8_push_word(fifo, EMAC_RX_HEADER(padded_size + CRC_SIZE,
209 EMAC_RX_IO_DATA_STATUS_OK));
210 fifo8_push_all(fifo, buf, size);
211 crc = crc32(~0, buf, size);
212
213 if (padded_size != size) {
214 fifo8_push_all(fifo, padding, padded_size - size);
215 crc = crc32(crc, padding, padded_size - size);
216 }
217
218 fifo8_push_word(fifo, crc);
219 fifo8_push_all(fifo, padding, QEMU_ALIGN_UP(padded_size, 4) - padded_size);
220 s->rx_num_packets++;
221
222 s->int_sta |= EMAC_INT_RX;
223 aw_emac_update_irq(s);
224
225 return size;
226 }
227
228 static void aw_emac_reset(DeviceState *dev)
229 {
230 AwEmacState *s = AW_EMAC(dev);
231 NetClientState *nc = qemu_get_queue(s->nic);
232
233 s->ctl = 0;
234 s->tx_mode = 0;
235 s->int_ctl = 0;
236 s->int_sta = 0;
237 s->tx_channel = 0;
238 s->phy_target = 0;
239
240 aw_emac_tx_reset(s, 0);
241 aw_emac_tx_reset(s, 1);
242 aw_emac_rx_reset(s);
243
244 mii_reset(&s->mii, !nc->link_down);
245 }
246
247 static uint64_t aw_emac_read(void *opaque, hwaddr offset, unsigned size)
248 {
249 AwEmacState *s = opaque;
250 Fifo8 *fifo = &s->rx_fifo;
251 NetClientState *nc;
252 uint64_t ret;
253
254 switch (offset) {
255 case EMAC_CTL_REG:
256 return s->ctl;
257 case EMAC_TX_MODE_REG:
258 return s->tx_mode;
259 case EMAC_TX_INS_REG:
260 return s->tx_channel;
261 case EMAC_RX_CTL_REG:
262 return s->rx_ctl;
263 case EMAC_RX_IO_DATA_REG:
264 if (!s->rx_num_packets) {
265 qemu_log_mask(LOG_GUEST_ERROR,
266 "Read IO data register when no packet available");
267 return 0;
268 }
269
270 ret = fifo8_pop_word(fifo);
271
272 switch (s->rx_packet_pos) {
273 case 0: /* Word is magic header */
274 s->rx_packet_pos += 4;
275 break;
276 case 4: /* Word is rx info header */
277 s->rx_packet_pos += 4;
278 s->rx_packet_size = QEMU_ALIGN_UP(extract32(ret, 0, 16), 4);
279 break;
280 default: /* Word is packet data */
281 s->rx_packet_pos += 4;
282 s->rx_packet_size -= 4;
283
284 if (!s->rx_packet_size) {
285 s->rx_packet_pos = 0;
286 s->rx_num_packets--;
287 nc = qemu_get_queue(s->nic);
288 if (aw_emac_can_receive(nc)) {
289 qemu_flush_queued_packets(nc);
290 }
291 }
292 }
293 return ret;
294 case EMAC_RX_FBC_REG:
295 return s->rx_num_packets;
296 case EMAC_INT_CTL_REG:
297 return s->int_ctl;
298 case EMAC_INT_STA_REG:
299 return s->int_sta;
300 case EMAC_MAC_MRDD_REG:
301 return RTL8201CP_mdio_read(s,
302 extract32(s->phy_target, PHY_ADDR_SHIFT, 8),
303 extract32(s->phy_target, PHY_REG_SHIFT, 8));
304 default:
305 qemu_log_mask(LOG_UNIMP,
306 "allwinner_emac: read access to unknown register 0x"
307 TARGET_FMT_plx "\n", offset);
308 ret = 0;
309 }
310
311 return ret;
312 }
313
314 static void aw_emac_write(void *opaque, hwaddr offset, uint64_t value,
315 unsigned size)
316 {
317 AwEmacState *s = opaque;
318 Fifo8 *fifo;
319 NetClientState *nc = qemu_get_queue(s->nic);
320 int chan;
321
322 switch (offset) {
323 case EMAC_CTL_REG:
324 if (value & EMAC_CTL_RESET) {
325 aw_emac_reset(DEVICE(s));
326 value &= ~EMAC_CTL_RESET;
327 }
328 s->ctl = value;
329 if (aw_emac_can_receive(nc)) {
330 qemu_flush_queued_packets(nc);
331 }
332 break;
333 case EMAC_TX_MODE_REG:
334 s->tx_mode = value;
335 break;
336 case EMAC_TX_CTL0_REG:
337 case EMAC_TX_CTL1_REG:
338 chan = (offset == EMAC_TX_CTL0_REG ? 0 : 1);
339 if ((value & 1) && (s->ctl & EMAC_CTL_TX_EN)) {
340 uint32_t len, ret;
341 const uint8_t *data;
342
343 fifo = &s->tx_fifo[chan];
344 len = s->tx_length[chan];
345
346 if (len > fifo8_num_used(fifo)) {
347 len = fifo8_num_used(fifo);
348 qemu_log_mask(LOG_GUEST_ERROR,
349 "allwinner_emac: TX length > fifo data length\n");
350 }
351 if (len > 0) {
352 data = fifo8_pop_buf(fifo, len, &ret);
353 qemu_send_packet(nc, data, ret);
354 aw_emac_tx_reset(s, chan);
355 /* Raise TX interrupt */
356 s->int_sta |= EMAC_INT_TX_CHAN(chan);
357 aw_emac_update_irq(s);
358 }
359 }
360 break;
361 case EMAC_TX_INS_REG:
362 s->tx_channel = value < NUM_TX_FIFOS ? value : 0;
363 break;
364 case EMAC_TX_PL0_REG:
365 case EMAC_TX_PL1_REG:
366 chan = (offset == EMAC_TX_PL0_REG ? 0 : 1);
367 if (value > TX_FIFO_SIZE) {
368 qemu_log_mask(LOG_GUEST_ERROR,
369 "allwinner_emac: invalid TX frame length %d\n",
370 (int)value);
371 value = TX_FIFO_SIZE;
372 }
373 s->tx_length[chan] = value;
374 break;
375 case EMAC_TX_IO_DATA_REG:
376 fifo = &s->tx_fifo[s->tx_channel];
377 if (fifo8_num_free(fifo) < 4) {
378 qemu_log_mask(LOG_GUEST_ERROR,
379 "allwinner_emac: TX data overruns fifo\n");
380 break;
381 }
382 fifo8_push_word(fifo, value);
383 break;
384 case EMAC_RX_CTL_REG:
385 s->rx_ctl = value;
386 break;
387 case EMAC_RX_FBC_REG:
388 if (value == 0) {
389 aw_emac_rx_reset(s);
390 }
391 break;
392 case EMAC_INT_CTL_REG:
393 s->int_ctl = value;
394 aw_emac_update_irq(s);
395 break;
396 case EMAC_INT_STA_REG:
397 s->int_sta &= ~value;
398 aw_emac_update_irq(s);
399 break;
400 case EMAC_MAC_MADR_REG:
401 s->phy_target = value;
402 break;
403 case EMAC_MAC_MWTD_REG:
404 RTL8201CP_mdio_write(s, extract32(s->phy_target, PHY_ADDR_SHIFT, 8),
405 extract32(s->phy_target, PHY_REG_SHIFT, 8), value);
406 break;
407 default:
408 qemu_log_mask(LOG_UNIMP,
409 "allwinner_emac: write access to unknown register 0x"
410 TARGET_FMT_plx "\n", offset);
411 }
412 }
413
414 static void aw_emac_set_link(NetClientState *nc)
415 {
416 AwEmacState *s = qemu_get_nic_opaque(nc);
417
418 mii_set_link(&s->mii, !nc->link_down);
419 }
420
421 static const MemoryRegionOps aw_emac_mem_ops = {
422 .read = aw_emac_read,
423 .write = aw_emac_write,
424 .endianness = DEVICE_NATIVE_ENDIAN,
425 .valid = {
426 .min_access_size = 4,
427 .max_access_size = 4,
428 },
429 };
430
431 static NetClientInfo net_aw_emac_info = {
432 .type = NET_CLIENT_DRIVER_NIC,
433 .size = sizeof(NICState),
434 .can_receive = aw_emac_can_receive,
435 .receive = aw_emac_receive,
436 .link_status_changed = aw_emac_set_link,
437 };
438
439 static void aw_emac_init(Object *obj)
440 {
441 SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
442 AwEmacState *s = AW_EMAC(obj);
443
444 memory_region_init_io(&s->iomem, OBJECT(s), &aw_emac_mem_ops, s,
445 "aw_emac", 0x1000);
446 sysbus_init_mmio(sbd, &s->iomem);
447 sysbus_init_irq(sbd, &s->irq);
448 }
449
450 static void aw_emac_realize(DeviceState *dev, Error **errp)
451 {
452 AwEmacState *s = AW_EMAC(dev);
453
454 qemu_macaddr_default_if_unset(&s->conf.macaddr);
455 s->nic = qemu_new_nic(&net_aw_emac_info, &s->conf,
456 object_get_typename(OBJECT(dev)), dev->id, s);
457 qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a);
458
459 fifo8_create(&s->rx_fifo, RX_FIFO_SIZE);
460 fifo8_create(&s->tx_fifo[0], TX_FIFO_SIZE);
461 fifo8_create(&s->tx_fifo[1], TX_FIFO_SIZE);
462 }
463
464 static Property aw_emac_properties[] = {
465 DEFINE_NIC_PROPERTIES(AwEmacState, conf),
466 DEFINE_PROP_UINT8("phy-addr", AwEmacState, phy_addr, 0),
467 DEFINE_PROP_END_OF_LIST(),
468 };
469
470 static const VMStateDescription vmstate_mii = {
471 .name = "rtl8201cp",
472 .version_id = 1,
473 .minimum_version_id = 1,
474 .fields = (VMStateField[]) {
475 VMSTATE_UINT16(bmcr, RTL8201CPState),
476 VMSTATE_UINT16(bmsr, RTL8201CPState),
477 VMSTATE_UINT16(anar, RTL8201CPState),
478 VMSTATE_UINT16(anlpar, RTL8201CPState),
479 VMSTATE_END_OF_LIST()
480 }
481 };
482
483 static int aw_emac_post_load(void *opaque, int version_id)
484 {
485 AwEmacState *s = opaque;
486
487 aw_emac_set_link(qemu_get_queue(s->nic));
488
489 return 0;
490 }
491
492 static const VMStateDescription vmstate_aw_emac = {
493 .name = "allwinner_emac",
494 .version_id = 1,
495 .minimum_version_id = 1,
496 .post_load = aw_emac_post_load,
497 .fields = (VMStateField[]) {
498 VMSTATE_STRUCT(mii, AwEmacState, 1, vmstate_mii, RTL8201CPState),
499 VMSTATE_UINT32(ctl, AwEmacState),
500 VMSTATE_UINT32(tx_mode, AwEmacState),
501 VMSTATE_UINT32(rx_ctl, AwEmacState),
502 VMSTATE_UINT32(int_ctl, AwEmacState),
503 VMSTATE_UINT32(int_sta, AwEmacState),
504 VMSTATE_UINT32(phy_target, AwEmacState),
505 VMSTATE_FIFO8(rx_fifo, AwEmacState),
506 VMSTATE_UINT32(rx_num_packets, AwEmacState),
507 VMSTATE_UINT32(rx_packet_size, AwEmacState),
508 VMSTATE_UINT32(rx_packet_pos, AwEmacState),
509 VMSTATE_STRUCT_ARRAY(tx_fifo, AwEmacState, NUM_TX_FIFOS, 1,
510 vmstate_fifo8, Fifo8),
511 VMSTATE_UINT32_ARRAY(tx_length, AwEmacState, NUM_TX_FIFOS),
512 VMSTATE_UINT32(tx_channel, AwEmacState),
513 VMSTATE_END_OF_LIST()
514 }
515 };
516
517 static void aw_emac_class_init(ObjectClass *klass, void *data)
518 {
519 DeviceClass *dc = DEVICE_CLASS(klass);
520
521 dc->realize = aw_emac_realize;
522 device_class_set_props(dc, aw_emac_properties);
523 dc->reset = aw_emac_reset;
524 dc->vmsd = &vmstate_aw_emac;
525 }
526
527 static const TypeInfo aw_emac_info = {
528 .name = TYPE_AW_EMAC,
529 .parent = TYPE_SYS_BUS_DEVICE,
530 .instance_size = sizeof(AwEmacState),
531 .instance_init = aw_emac_init,
532 .class_init = aw_emac_class_init,
533 };
534
535 static void aw_emac_register_types(void)
536 {
537 type_register_static(&aw_emac_info);
538 }
539
540 type_init(aw_emac_register_types)