]> git.proxmox.com Git - mirror_qemu.git/blob - hw/net/imx_fec.c
projects / mirror_qemu.git / blob
? search:


d91e029382b426b958a37490e3548f0c988928bc
[mirror_qemu.git] / hw / net / imx_fec.c
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/net/imx_fec.h"
26 #include "sysemu/dma.h"
27 #include "qemu/log.h"
28 #include "net/checksum.h"
29 #include "net/eth.h"
30
31 /* For crc32 */
32 #include <zlib.h>
33
34 #ifndef DEBUG_IMX_FEC
35 #define DEBUG_IMX_FEC 0
36 #endif
37
38 #define FEC_PRINTF(fmt, args...) \
39 do { \
40 if (DEBUG_IMX_FEC) { \
41 fprintf(stderr, "[%s]%s: " fmt , TYPE_IMX_FEC, \
42 __func__, ##args); \
43 } \
44 } while (0)
45
46 #ifndef DEBUG_IMX_PHY
47 #define DEBUG_IMX_PHY 0
48 #endif
49
50 #define PHY_PRINTF(fmt, args...) \
51 do { \
52 if (DEBUG_IMX_PHY) { \
53 fprintf(stderr, "[%s.phy]%s: " fmt , TYPE_IMX_FEC, \
54 __func__, ##args); \
55 } \
56 } while (0)
57
58 static const char *imx_default_reg_name(IMXFECState *s, uint32_t index)
59 {
60 static char tmp[20];
61 sprintf(tmp, "index %d", index);
62 return tmp;
63 }
64
65 static const char *imx_fec_reg_name(IMXFECState *s, uint32_t index)
66 {
67 switch (index) {
68 case ENET_FRBR:
69 return "FRBR";
70 case ENET_FRSR:
71 return "FRSR";
72 case ENET_MIIGSK_CFGR:
73 return "MIIGSK_CFGR";
74 case ENET_MIIGSK_ENR:
75 return "MIIGSK_ENR";
76 default:
77 return imx_default_reg_name(s, index);
78 }
79 }
80
81 static const char *imx_enet_reg_name(IMXFECState *s, uint32_t index)
82 {
83 switch (index) {
84 case ENET_RSFL:
85 return "RSFL";
86 case ENET_RSEM:
87 return "RSEM";
88 case ENET_RAEM:
89 return "RAEM";
90 case ENET_RAFL:
91 return "RAFL";
92 case ENET_TSEM:
93 return "TSEM";
94 case ENET_TAEM:
95 return "TAEM";
96 case ENET_TAFL:
97 return "TAFL";
98 case ENET_TIPG:
99 return "TIPG";
100 case ENET_FTRL:
101 return "FTRL";
102 case ENET_TACC:
103 return "TACC";
104 case ENET_RACC:
105 return "RACC";
106 case ENET_ATCR:
107 return "ATCR";
108 case ENET_ATVR:
109 return "ATVR";
110 case ENET_ATOFF:
111 return "ATOFF";
112 case ENET_ATPER:
113 return "ATPER";
114 case ENET_ATCOR:
115 return "ATCOR";
116 case ENET_ATINC:
117 return "ATINC";
118 case ENET_ATSTMP:
119 return "ATSTMP";
120 case ENET_TGSR:
121 return "TGSR";
122 case ENET_TCSR0:
123 return "TCSR0";
124 case ENET_TCCR0:
125 return "TCCR0";
126 case ENET_TCSR1:
127 return "TCSR1";
128 case ENET_TCCR1:
129 return "TCCR1";
130 case ENET_TCSR2:
131 return "TCSR2";
132 case ENET_TCCR2:
133 return "TCCR2";
134 case ENET_TCSR3:
135 return "TCSR3";
136 case ENET_TCCR3:
137 return "TCCR3";
138 default:
139 return imx_default_reg_name(s, index);
140 }
141 }
142
143 static const char *imx_eth_reg_name(IMXFECState *s, uint32_t index)
144 {
145 switch (index) {
146 case ENET_EIR:
147 return "EIR";
148 case ENET_EIMR:
149 return "EIMR";
150 case ENET_RDAR:
151 return "RDAR";
152 case ENET_TDAR:
153 return "TDAR";
154 case ENET_ECR:
155 return "ECR";
156 case ENET_MMFR:
157 return "MMFR";
158 case ENET_MSCR:
159 return "MSCR";
160 case ENET_MIBC:
161 return "MIBC";
162 case ENET_RCR:
163 return "RCR";
164 case ENET_TCR:
165 return "TCR";
166 case ENET_PALR:
167 return "PALR";
168 case ENET_PAUR:
169 return "PAUR";
170 case ENET_OPD:
171 return "OPD";
172 case ENET_IAUR:
173 return "IAUR";
174 case ENET_IALR:
175 return "IALR";
176 case ENET_GAUR:
177 return "GAUR";
178 case ENET_GALR:
179 return "GALR";
180 case ENET_TFWR:
181 return "TFWR";
182 case ENET_RDSR:
183 return "RDSR";
184 case ENET_TDSR:
185 return "TDSR";
186 case ENET_MRBR:
187 return "MRBR";
188 default:
189 if (s->is_fec) {
190 return imx_fec_reg_name(s, index);
191 } else {
192 return imx_enet_reg_name(s, index);
193 }
194 }
195 }
196
197 static const VMStateDescription vmstate_imx_eth = {
198 .name = TYPE_IMX_FEC,
199 .version_id = 2,
200 .minimum_version_id = 2,
201 .fields = (VMStateField[]) {
202 VMSTATE_UINT32_ARRAY(regs, IMXFECState, ENET_MAX),
203 VMSTATE_UINT32(rx_descriptor, IMXFECState),
204 VMSTATE_UINT32(tx_descriptor, IMXFECState),
205
206 VMSTATE_UINT32(phy_status, IMXFECState),
207 VMSTATE_UINT32(phy_control, IMXFECState),
208 VMSTATE_UINT32(phy_advertise, IMXFECState),
209 VMSTATE_UINT32(phy_int, IMXFECState),
210 VMSTATE_UINT32(phy_int_mask, IMXFECState),
211 VMSTATE_END_OF_LIST()
212 }
213 };
214
215 #define PHY_INT_ENERGYON (1 << 7)
216 #define PHY_INT_AUTONEG_COMPLETE (1 << 6)
217 #define PHY_INT_FAULT (1 << 5)
218 #define PHY_INT_DOWN (1 << 4)
219 #define PHY_INT_AUTONEG_LP (1 << 3)
220 #define PHY_INT_PARFAULT (1 << 2)
221 #define PHY_INT_AUTONEG_PAGE (1 << 1)
222
223 static void imx_eth_update(IMXFECState *s);
224
225 /*
226 * The MII phy could raise a GPIO to the processor which in turn
227 * could be handled as an interrpt by the OS.
228 * For now we don't handle any GPIO/interrupt line, so the OS will
229 * have to poll for the PHY status.
230 */
231 static void phy_update_irq(IMXFECState *s)
232 {
233 imx_eth_update(s);
234 }
235
236 static void phy_update_link(IMXFECState *s)
237 {
238 /* Autonegotiation status mirrors link status. */
239 if (qemu_get_queue(s->nic)->link_down) {
240 PHY_PRINTF("link is down\n");
241 s->phy_status &= ~0x0024;
242 s->phy_int |= PHY_INT_DOWN;
243 } else {
244 PHY_PRINTF("link is up\n");
245 s->phy_status |= 0x0024;
246 s->phy_int |= PHY_INT_ENERGYON;
247 s->phy_int |= PHY_INT_AUTONEG_COMPLETE;
248 }
249 phy_update_irq(s);
250 }
251
252 static void imx_eth_set_link(NetClientState *nc)
253 {
254 phy_update_link(IMX_FEC(qemu_get_nic_opaque(nc)));
255 }
256
257 static void phy_reset(IMXFECState *s)
258 {
259 s->phy_status = 0x7809;
260 s->phy_control = 0x3000;
261 s->phy_advertise = 0x01e1;
262 s->phy_int_mask = 0;
263 s->phy_int = 0;
264 phy_update_link(s);
265 }
266
267 static uint32_t do_phy_read(IMXFECState *s, int reg)
268 {
269 uint32_t val;
270
271 if (reg > 31) {
272 /* we only advertise one phy */
273 return 0;
274 }
275
276 switch (reg) {
277 case 0: /* Basic Control */
278 val = s->phy_control;
279 break;
280 case 1: /* Basic Status */
281 val = s->phy_status;
282 break;
283 case 2: /* ID1 */
284 val = 0x0007;
285 break;
286 case 3: /* ID2 */
287 val = 0xc0d1;
288 break;
289 case 4: /* Auto-neg advertisement */
290 val = s->phy_advertise;
291 break;
292 case 5: /* Auto-neg Link Partner Ability */
293 val = 0x0f71;
294 break;
295 case 6: /* Auto-neg Expansion */
296 val = 1;
297 break;
298 case 29: /* Interrupt source. */
299 val = s->phy_int;
300 s->phy_int = 0;
301 phy_update_irq(s);
302 break;
303 case 30: /* Interrupt mask */
304 val = s->phy_int_mask;
305 break;
306 case 17:
307 case 18:
308 case 27:
309 case 31:
310 qemu_log_mask(LOG_UNIMP, "[%s.phy]%s: reg %d not implemented\n",
311 TYPE_IMX_FEC, __func__, reg);
312 val = 0;
313 break;
314 default:
315 qemu_log_mask(LOG_GUEST_ERROR, "[%s.phy]%s: Bad address at offset %d\n",
316 TYPE_IMX_FEC, __func__, reg);
317 val = 0;
318 break;
319 }
320
321 PHY_PRINTF("read 0x%04x @ %d\n", val, reg);
322
323 return val;
324 }
325
326 static void do_phy_write(IMXFECState *s, int reg, uint32_t val)
327 {
328 PHY_PRINTF("write 0x%04x @ %d\n", val, reg);
329
330 if (reg > 31) {
331 /* we only advertise one phy */
332 return;
333 }
334
335 switch (reg) {
336 case 0: /* Basic Control */
337 if (val & 0x8000) {
338 phy_reset(s);
339 } else {
340 s->phy_control = val & 0x7980;
341 /* Complete autonegotiation immediately. */
342 if (val & 0x1000) {
343 s->phy_status |= 0x0020;
344 }
345 }
346 break;
347 case 4: /* Auto-neg advertisement */
348 s->phy_advertise = (val & 0x2d7f) | 0x80;
349 break;
350 case 30: /* Interrupt mask */
351 s->phy_int_mask = val & 0xff;
352 phy_update_irq(s);
353 break;
354 case 17:
355 case 18:
356 case 27:
357 case 31:
358 qemu_log_mask(LOG_UNIMP, "[%s.phy)%s: reg %d not implemented\n",
359 TYPE_IMX_FEC, __func__, reg);
360 break;
361 default:
362 qemu_log_mask(LOG_GUEST_ERROR, "[%s.phy]%s: Bad address at offset %d\n",
363 TYPE_IMX_FEC, __func__, reg);
364 break;
365 }
366 }
367
368 static void imx_fec_read_bd(IMXFECBufDesc *bd, dma_addr_t addr)
369 {
370 dma_memory_read(&address_space_memory, addr, bd, sizeof(*bd));
371 }
372
373 static void imx_fec_write_bd(IMXFECBufDesc *bd, dma_addr_t addr)
374 {
375 dma_memory_write(&address_space_memory, addr, bd, sizeof(*bd));
376 }
377
378 static void imx_enet_read_bd(IMXENETBufDesc *bd, dma_addr_t addr)
379 {
380 dma_memory_read(&address_space_memory, addr, bd, sizeof(*bd));
381 }
382
383 static void imx_enet_write_bd(IMXENETBufDesc *bd, dma_addr_t addr)
384 {
385 dma_memory_write(&address_space_memory, addr, bd, sizeof(*bd));
386 }
387
388 static void imx_eth_update(IMXFECState *s)
389 {
390 if (s->regs[ENET_EIR] & s->regs[ENET_EIMR] & ENET_INT_TS_TIMER) {
391 qemu_set_irq(s->irq[1], 1);
392 } else {
393 qemu_set_irq(s->irq[1], 0);
394 }
395
396 if (s->regs[ENET_EIR] & s->regs[ENET_EIMR] & ENET_INT_MAC) {
397 qemu_set_irq(s->irq[0], 1);
398 } else {
399 qemu_set_irq(s->irq[0], 0);
400 }
401 }
402
403 static void imx_fec_do_tx(IMXFECState *s)
404 {
405 int frame_size = 0;
406 uint8_t frame[ENET_MAX_FRAME_SIZE];
407 uint8_t *ptr = frame;
408 uint32_t addr = s->tx_descriptor;
409
410 while (1) {
411 IMXFECBufDesc bd;
412 int len;
413
414 imx_fec_read_bd(&bd, addr);
415 FEC_PRINTF("tx_bd %x flags %04x len %d data %08x\n",
416 addr, bd.flags, bd.length, bd.data);
417 if ((bd.flags & ENET_BD_R) == 0) {
418 /* Run out of descriptors to transmit. */
419 FEC_PRINTF("tx_bd ran out of descriptors to transmit\n");
420 break;
421 }
422 len = bd.length;
423 if (frame_size + len > ENET_MAX_FRAME_SIZE) {
424 len = ENET_MAX_FRAME_SIZE - frame_size;
425 s->regs[ENET_EIR] |= ENET_INT_BABT;
426 }
427 dma_memory_read(&address_space_memory, bd.data, ptr, len);
428 ptr += len;
429 frame_size += len;
430 if (bd.flags & ENET_BD_L) {
431 /* Last buffer in frame. */
432 qemu_send_packet(qemu_get_queue(s->nic), frame, len);
433 ptr = frame;
434 frame_size = 0;
435 s->regs[ENET_EIR] |= ENET_INT_TXF;
436 }
437 s->regs[ENET_EIR] |= ENET_INT_TXB;
438 bd.flags &= ~ENET_BD_R;
439 /* Write back the modified descriptor. */
440 imx_fec_write_bd(&bd, addr);
441 /* Advance to the next descriptor. */
442 if ((bd.flags & ENET_BD_W) != 0) {
443 addr = s->regs[ENET_TDSR];
444 } else {
445 addr += sizeof(bd);
446 }
447 }
448
449 s->tx_descriptor = addr;
450
451 imx_eth_update(s);
452 }
453
454 static void imx_enet_do_tx(IMXFECState *s)
455 {
456 int frame_size = 0;
457 uint8_t frame[ENET_MAX_FRAME_SIZE];
458 uint8_t *ptr = frame;
459 uint32_t addr = s->tx_descriptor;
460
461 while (1) {
462 IMXENETBufDesc bd;
463 int len;
464
465 imx_enet_read_bd(&bd, addr);
466 FEC_PRINTF("tx_bd %x flags %04x len %d data %08x option %04x "
467 "status %04x\n", addr, bd.flags, bd.length, bd.data,
468 bd.option, bd.status);
469 if ((bd.flags & ENET_BD_R) == 0) {
470 /* Run out of descriptors to transmit. */
471 break;
472 }
473 len = bd.length;
474 if (frame_size + len > ENET_MAX_FRAME_SIZE) {
475 len = ENET_MAX_FRAME_SIZE - frame_size;
476 s->regs[ENET_EIR] |= ENET_INT_BABT;
477 }
478 dma_memory_read(&address_space_memory, bd.data, ptr, len);
479 ptr += len;
480 frame_size += len;
481 if (bd.flags & ENET_BD_L) {
482 if (bd.option & ENET_BD_PINS) {
483 struct ip_header *ip_hd = PKT_GET_IP_HDR(frame);
484 if (IP_HEADER_VERSION(ip_hd) == 4) {
485 net_checksum_calculate(frame, frame_size);
486 }
487 }
488 if (bd.option & ENET_BD_IINS) {
489 struct ip_header *ip_hd = PKT_GET_IP_HDR(frame);
490 /* We compute checksum only for IPv4 frames */
491 if (IP_HEADER_VERSION(ip_hd) == 4) {
492 uint16_t csum;
493 ip_hd->ip_sum = 0;
494 csum = net_raw_checksum((uint8_t *)ip_hd, sizeof(*ip_hd));
495 ip_hd->ip_sum = cpu_to_be16(csum);
496 }
497 }
498 /* Last buffer in frame. */
499 qemu_send_packet(qemu_get_queue(s->nic), frame, len);
500 ptr = frame;
501 frame_size = 0;
502 if (bd.option & ENET_BD_TX_INT) {
503 s->regs[ENET_EIR] |= ENET_INT_TXF;
504 }
505 }
506 if (bd.option & ENET_BD_TX_INT) {
507 s->regs[ENET_EIR] |= ENET_INT_TXB;
508 }
509 bd.flags &= ~ENET_BD_R;
510 /* Write back the modified descriptor. */
511 imx_enet_write_bd(&bd, addr);
512 /* Advance to the next descriptor. */
513 if ((bd.flags & ENET_BD_W) != 0) {
514 addr = s->regs[ENET_TDSR];
515 } else {
516 addr += sizeof(bd);
517 }
518 }
519
520 s->tx_descriptor = addr;
521
522 imx_eth_update(s);
523 }
524
525 static void imx_eth_do_tx(IMXFECState *s)
526 {
527 if (!s->is_fec && (s->regs[ENET_ECR] & ENET_ECR_EN1588)) {
528 imx_enet_do_tx(s);
529 } else {
530 imx_fec_do_tx(s);
531 }
532 }
533
534 static void imx_eth_enable_rx(IMXFECState *s)
535 {
536 IMXFECBufDesc bd;
537 bool tmp;
538
539 imx_fec_read_bd(&bd, s->rx_descriptor);
540
541 tmp = ((bd.flags & ENET_BD_E) != 0);
542
543 if (!tmp) {
544 FEC_PRINTF("RX buffer full\n");
545 } else if (!s->regs[ENET_RDAR]) {
546 qemu_flush_queued_packets(qemu_get_queue(s->nic));
547 }
548
549 s->regs[ENET_RDAR] = tmp ? ENET_RDAR_RDAR : 0;
550 }
551
552 static void imx_eth_reset(DeviceState *d)
553 {
554 IMXFECState *s = IMX_FEC(d);
555
556 /* Reset the Device */
557 memset(s->regs, 0, sizeof(s->regs));
558 s->regs[ENET_ECR] = 0xf0000000;
559 s->regs[ENET_MIBC] = 0xc0000000;
560 s->regs[ENET_RCR] = 0x05ee0001;
561 s->regs[ENET_OPD] = 0x00010000;
562
563 s->regs[ENET_PALR] = (s->conf.macaddr.a[0] << 24)
564 | (s->conf.macaddr.a[1] << 16)
565 | (s->conf.macaddr.a[2] << 8)
566 | s->conf.macaddr.a[3];
567 s->regs[ENET_PAUR] = (s->conf.macaddr.a[4] << 24)
568 | (s->conf.macaddr.a[5] << 16)
569 | 0x8808;
570
571 if (s->is_fec) {
572 s->regs[ENET_FRBR] = 0x00000600;
573 s->regs[ENET_FRSR] = 0x00000500;
574 s->regs[ENET_MIIGSK_ENR] = 0x00000006;
575 } else {
576 s->regs[ENET_RAEM] = 0x00000004;
577 s->regs[ENET_RAFL] = 0x00000004;
578 s->regs[ENET_TAEM] = 0x00000004;
579 s->regs[ENET_TAFL] = 0x00000008;
580 s->regs[ENET_TIPG] = 0x0000000c;
581 s->regs[ENET_FTRL] = 0x000007ff;
582 s->regs[ENET_ATPER] = 0x3b9aca00;
583 }
584
585 s->rx_descriptor = 0;
586 s->tx_descriptor = 0;
587
588 /* We also reset the PHY */
589 phy_reset(s);
590 }
591
592 static uint32_t imx_default_read(IMXFECState *s, uint32_t index)
593 {
594 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Bad register at offset 0x%"
595 PRIx32 "\n", TYPE_IMX_FEC, __func__, index * 4);
596 return 0;
597 }
598
599 static uint32_t imx_fec_read(IMXFECState *s, uint32_t index)
600 {
601 switch (index) {
602 case ENET_FRBR:
603 case ENET_FRSR:
604 case ENET_MIIGSK_CFGR:
605 case ENET_MIIGSK_ENR:
606 return s->regs[index];
607 default:
608 return imx_default_read(s, index);
609 }
610 }
611
612 static uint32_t imx_enet_read(IMXFECState *s, uint32_t index)
613 {
614 switch (index) {
615 case ENET_RSFL:
616 case ENET_RSEM:
617 case ENET_RAEM:
618 case ENET_RAFL:
619 case ENET_TSEM:
620 case ENET_TAEM:
621 case ENET_TAFL:
622 case ENET_TIPG:
623 case ENET_FTRL:
624 case ENET_TACC:
625 case ENET_RACC:
626 case ENET_ATCR:
627 case ENET_ATVR:
628 case ENET_ATOFF:
629 case ENET_ATPER:
630 case ENET_ATCOR:
631 case ENET_ATINC:
632 case ENET_ATSTMP:
633 case ENET_TGSR:
634 case ENET_TCSR0:
635 case ENET_TCCR0:
636 case ENET_TCSR1:
637 case ENET_TCCR1:
638 case ENET_TCSR2:
639 case ENET_TCCR2:
640 case ENET_TCSR3:
641 case ENET_TCCR3:
642 return s->regs[index];
643 default:
644 return imx_default_read(s, index);
645 }
646 }
647
648 static uint64_t imx_eth_read(void *opaque, hwaddr offset, unsigned size)
649 {
650 uint32_t value = 0;
651 IMXFECState *s = IMX_FEC(opaque);
652 uint32_t index = offset >> 2;
653
654 switch (index) {
655 case ENET_EIR:
656 case ENET_EIMR:
657 case ENET_RDAR:
658 case ENET_TDAR:
659 case ENET_ECR:
660 case ENET_MMFR:
661 case ENET_MSCR:
662 case ENET_MIBC:
663 case ENET_RCR:
664 case ENET_TCR:
665 case ENET_PALR:
666 case ENET_PAUR:
667 case ENET_OPD:
668 case ENET_IAUR:
669 case ENET_IALR:
670 case ENET_GAUR:
671 case ENET_GALR:
672 case ENET_TFWR:
673 case ENET_RDSR:
674 case ENET_TDSR:
675 case ENET_MRBR:
676 value = s->regs[index];
677 break;
678 default:
679 if (s->is_fec) {
680 value = imx_fec_read(s, index);
681 } else {
682 value = imx_enet_read(s, index);
683 }
684 break;
685 }
686
687 FEC_PRINTF("reg[%s] => 0x%" PRIx32 "\n", imx_eth_reg_name(s, index),
688 value);
689
690 return value;
691 }
692
693 static void imx_default_write(IMXFECState *s, uint32_t index, uint32_t value)
694 {
695 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Bad address at offset 0x%"
696 PRIx32 "\n", TYPE_IMX_FEC, __func__, index * 4);
697 return;
698 }
699
700 static void imx_fec_write(IMXFECState *s, uint32_t index, uint32_t value)
701 {
702 switch (index) {
703 case ENET_FRBR:
704 /* FRBR is read only */
705 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Register FRBR is read only\n",
706 TYPE_IMX_FEC, __func__);
707 break;
708 case ENET_FRSR:
709 s->regs[index] = (value & 0x000003fc) | 0x00000400;
710 break;
711 case ENET_MIIGSK_CFGR:
712 s->regs[index] = value & 0x00000053;
713 break;
714 case ENET_MIIGSK_ENR:
715 s->regs[index] = (value & 0x00000002) ? 0x00000006 : 0;
716 break;
717 default:
718 imx_default_write(s, index, value);
719 break;
720 }
721 }
722
723 static void imx_enet_write(IMXFECState *s, uint32_t index, uint32_t value)
724 {
725 switch (index) {
726 case ENET_RSFL:
727 case ENET_RSEM:
728 case ENET_RAEM:
729 case ENET_RAFL:
730 case ENET_TSEM:
731 case ENET_TAEM:
732 case ENET_TAFL:
733 s->regs[index] = value & 0x000001ff;
734 break;
735 case ENET_TIPG:
736 s->regs[index] = value & 0x0000001f;
737 break;
738 case ENET_FTRL:
739 s->regs[index] = value & 0x00003fff;
740 break;
741 case ENET_TACC:
742 s->regs[index] = value & 0x00000019;
743 break;
744 case ENET_RACC:
745 s->regs[index] = value & 0x000000C7;
746 break;
747 case ENET_ATCR:
748 s->regs[index] = value & 0x00002a9d;
749 break;
750 case ENET_ATVR:
751 case ENET_ATOFF:
752 case ENET_ATPER:
753 s->regs[index] = value;
754 break;
755 case ENET_ATSTMP:
756 /* ATSTMP is read only */
757 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Register ATSTMP is read only\n",
758 TYPE_IMX_FEC, __func__);
759 break;
760 case ENET_ATCOR:
761 s->regs[index] = value & 0x7fffffff;
762 break;
763 case ENET_ATINC:
764 s->regs[index] = value & 0x00007f7f;
765 break;
766 case ENET_TGSR:
767 /* implement clear timer flag */
768 value = value & 0x0000000f;
769 break;
770 case ENET_TCSR0:
771 case ENET_TCSR1:
772 case ENET_TCSR2:
773 case ENET_TCSR3:
774 value = value & 0x000000fd;
775 break;
776 case ENET_TCCR0:
777 case ENET_TCCR1:
778 case ENET_TCCR2:
779 case ENET_TCCR3:
780 s->regs[index] = value;
781 break;
782 default:
783 imx_default_write(s, index, value);
784 break;
785 }
786 }
787
788 static void imx_eth_write(void *opaque, hwaddr offset, uint64_t value,
789 unsigned size)
790 {
791 IMXFECState *s = IMX_FEC(opaque);
792 uint32_t index = offset >> 2;
793
794 FEC_PRINTF("reg[%s] <= 0x%" PRIx32 "\n", imx_eth_reg_name(s, index),
795 (uint32_t)value);
796
797 switch (index) {
798 case ENET_EIR:
799 s->regs[index] &= ~value;
800 break;
801 case ENET_EIMR:
802 s->regs[index] = value;
803 break;
804 case ENET_RDAR:
805 if (s->regs[ENET_ECR] & ENET_ECR_ETHEREN) {
806 if (!s->regs[index]) {
807 s->regs[index] = ENET_RDAR_RDAR;
808 imx_eth_enable_rx(s);
809 }
810 } else {
811 s->regs[index] = 0;
812 }
813 break;
814 case ENET_TDAR:
815 if (s->regs[ENET_ECR] & ENET_ECR_ETHEREN) {
816 s->regs[index] = ENET_TDAR_TDAR;
817 imx_eth_do_tx(s);
818 }
819 s->regs[index] = 0;
820 break;
821 case ENET_ECR:
822 if (value & ENET_ECR_RESET) {
823 return imx_eth_reset(DEVICE(s));
824 }
825 s->regs[index] = value;
826 if ((s->regs[index] & ENET_ECR_ETHEREN) == 0) {
827 s->regs[ENET_RDAR] = 0;
828 s->rx_descriptor = s->regs[ENET_RDSR];
829 s->regs[ENET_TDAR] = 0;
830 s->tx_descriptor = s->regs[ENET_TDSR];
831 }
832 break;
833 case ENET_MMFR:
834 s->regs[index] = value;
835 if (extract32(value, 29, 1)) {
836 /* This is a read operation */
837 s->regs[ENET_MMFR] = deposit32(s->regs[ENET_MMFR], 0, 16,
838 do_phy_read(s,
839 extract32(value,
840 18, 10)));
841 } else {
842 /* This a write operation */
843 do_phy_write(s, extract32(value, 18, 10), extract32(value, 0, 16));
844 }
845 /* raise the interrupt as the PHY operation is done */
846 s->regs[ENET_EIR] |= ENET_INT_MII;
847 break;
848 case ENET_MSCR:
849 s->regs[index] = value & 0xfe;
850 break;
851 case ENET_MIBC:
852 /* TODO: Implement MIB. */
853 s->regs[index] = (value & 0x80000000) ? 0xc0000000 : 0;
854 break;
855 case ENET_RCR:
856 s->regs[index] = value & 0x07ff003f;
857 /* TODO: Implement LOOP mode. */
858 break;
859 case ENET_TCR:
860 /* We transmit immediately, so raise GRA immediately. */
861 s->regs[index] = value;
862 if (value & 1) {
863 s->regs[ENET_EIR] |= ENET_INT_GRA;
864 }
865 break;
866 case ENET_PALR:
867 s->regs[index] = value;
868 s->conf.macaddr.a[0] = value >> 24;
869 s->conf.macaddr.a[1] = value >> 16;
870 s->conf.macaddr.a[2] = value >> 8;
871 s->conf.macaddr.a[3] = value;
872 break;
873 case ENET_PAUR:
874 s->regs[index] = (value | 0x0000ffff) & 0xffff8808;
875 s->conf.macaddr.a[4] = value >> 24;
876 s->conf.macaddr.a[5] = value >> 16;
877 break;
878 case ENET_OPD:
879 s->regs[index] = (value & 0x0000ffff) | 0x00010000;
880 break;
881 case ENET_IAUR:
882 case ENET_IALR:
883 case ENET_GAUR:
884 case ENET_GALR:
885 /* TODO: implement MAC hash filtering. */
886 break;
887 case ENET_TFWR:
888 if (s->is_fec) {
889 s->regs[index] = value & 0x3;
890 } else {
891 s->regs[index] = value & 0x13f;
892 }
893 break;
894 case ENET_RDSR:
895 if (s->is_fec) {
896 s->regs[index] = value & ~3;
897 } else {
898 s->regs[index] = value & ~7;
899 }
900 s->rx_descriptor = s->regs[index];
901 break;
902 case ENET_TDSR:
903 if (s->is_fec) {
904 s->regs[index] = value & ~3;
905 } else {
906 s->regs[index] = value & ~7;
907 }
908 s->tx_descriptor = s->regs[index];
909 break;
910 case ENET_MRBR:
911 s->regs[index] = value & 0x00003ff0;
912 break;
913 default:
914 if (s->is_fec) {
915 imx_fec_write(s, index, value);
916 } else {
917 imx_enet_write(s, index, value);
918 }
919 return;
920 }
921
922 imx_eth_update(s);
923 }
924
925 static int imx_eth_can_receive(NetClientState *nc)
926 {
927 IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc));
928
929 FEC_PRINTF("\n");
930
931 return s->regs[ENET_RDAR] ? 1 : 0;
932 }
933
934 static ssize_t imx_fec_receive(NetClientState *nc, const uint8_t *buf,
935 size_t len)
936 {
937 IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc));
938 IMXFECBufDesc bd;
939 uint32_t flags = 0;
940 uint32_t addr;
941 uint32_t crc;
942 uint32_t buf_addr;
943 uint8_t *crc_ptr;
944 unsigned int buf_len;
945 size_t size = len;
946
947 FEC_PRINTF("len %d\n", (int)size);
948
949 if (!s->regs[ENET_RDAR]) {
950 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Unexpected packet\n",
951 TYPE_IMX_FEC, __func__);
952 return 0;
953 }
954
955 /* 4 bytes for the CRC. */
956 size += 4;
957 crc = cpu_to_be32(crc32(~0, buf, size));
958 crc_ptr = (uint8_t *) &crc;
959
960 /* Huge frames are truncated. */
961 if (size > ENET_MAX_FRAME_SIZE) {
962 size = ENET_MAX_FRAME_SIZE;
963 flags |= ENET_BD_TR | ENET_BD_LG;
964 }
965
966 /* Frames larger than the user limit just set error flags. */
967 if (size > (s->regs[ENET_RCR] >> 16)) {
968 flags |= ENET_BD_LG;
969 }
970
971 addr = s->rx_descriptor;
972 while (size > 0) {
973 imx_fec_read_bd(&bd, addr);
974 if ((bd.flags & ENET_BD_E) == 0) {
975 /* No descriptors available. Bail out. */
976 /*
977 * FIXME: This is wrong. We should probably either
978 * save the remainder for when more RX buffers are
979 * available, or flag an error.
980 */
981 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Lost end of frame\n",
982 TYPE_IMX_FEC, __func__);
983 break;
984 }
985 buf_len = (size <= s->regs[ENET_MRBR]) ? size : s->regs[ENET_MRBR];
986 bd.length = buf_len;
987 size -= buf_len;
988
989 FEC_PRINTF("rx_bd 0x%x length %d\n", addr, bd.length);
990
991 /* The last 4 bytes are the CRC. */
992 if (size < 4) {
993 buf_len += size - 4;
994 }
995 buf_addr = bd.data;
996 dma_memory_write(&address_space_memory, buf_addr, buf, buf_len);
997 buf += buf_len;
998 if (size < 4) {
999 dma_memory_write(&address_space_memory, buf_addr + buf_len,
1000 crc_ptr, 4 - size);
1001 crc_ptr += 4 - size;
1002 }
1003 bd.flags &= ~ENET_BD_E;
1004 if (size == 0) {
1005 /* Last buffer in frame. */
1006 bd.flags |= flags | ENET_BD_L;
1007 FEC_PRINTF("rx frame flags %04x\n", bd.flags);
1008 s->regs[ENET_EIR] |= ENET_INT_RXF;
1009 } else {
1010 s->regs[ENET_EIR] |= ENET_INT_RXB;
1011 }
1012 imx_fec_write_bd(&bd, addr);
1013 /* Advance to the next descriptor. */
1014 if ((bd.flags & ENET_BD_W) != 0) {
1015 addr = s->regs[ENET_RDSR];
1016 } else {
1017 addr += sizeof(bd);
1018 }
1019 }
1020 s->rx_descriptor = addr;
1021 imx_eth_enable_rx(s);
1022 imx_eth_update(s);
1023 return len;
1024 }
1025
1026 static ssize_t imx_enet_receive(NetClientState *nc, const uint8_t *buf,
1027 size_t len)
1028 {
1029 IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc));
1030 IMXENETBufDesc bd;
1031 uint32_t flags = 0;
1032 uint32_t addr;
1033 uint32_t crc;
1034 uint32_t buf_addr;
1035 uint8_t *crc_ptr;
1036 unsigned int buf_len;
1037 size_t size = len;
1038
1039 FEC_PRINTF("len %d\n", (int)size);
1040
1041 if (!s->regs[ENET_RDAR]) {
1042 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Unexpected packet\n",
1043 TYPE_IMX_FEC, __func__);
1044 return 0;
1045 }
1046
1047 /* 4 bytes for the CRC. */
1048 size += 4;
1049 crc = cpu_to_be32(crc32(~0, buf, size));
1050 crc_ptr = (uint8_t *) &crc;
1051
1052 /* Huge frames are truncted. */
1053 if (size > ENET_MAX_FRAME_SIZE) {
1054 size = ENET_MAX_FRAME_SIZE;
1055 flags |= ENET_BD_TR | ENET_BD_LG;
1056 }
1057
1058 /* Frames larger than the user limit just set error flags. */
1059 if (size > (s->regs[ENET_RCR] >> 16)) {
1060 flags |= ENET_BD_LG;
1061 }
1062
1063 addr = s->rx_descriptor;
1064 while (size > 0) {
1065 imx_enet_read_bd(&bd, addr);
1066 if ((bd.flags & ENET_BD_E) == 0) {
1067 /* No descriptors available. Bail out. */
1068 /*
1069 * FIXME: This is wrong. We should probably either
1070 * save the remainder for when more RX buffers are
1071 * available, or flag an error.
1072 */
1073 qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: Lost end of frame\n",
1074 TYPE_IMX_FEC, __func__);
1075 break;
1076 }
1077 buf_len = (size <= s->regs[ENET_MRBR]) ? size : s->regs[ENET_MRBR];
1078 bd.length = buf_len;
1079 size -= buf_len;
1080
1081 FEC_PRINTF("rx_bd 0x%x length %d\n", addr, bd.length);
1082
1083 /* The last 4 bytes are the CRC. */
1084 if (size < 4) {
1085 buf_len += size - 4;
1086 }
1087 buf_addr = bd.data;
1088 dma_memory_write(&address_space_memory, buf_addr, buf, buf_len);
1089 buf += buf_len;
1090 if (size < 4) {
1091 dma_memory_write(&address_space_memory, buf_addr + buf_len,
1092 crc_ptr, 4 - size);
1093 crc_ptr += 4 - size;
1094 }
1095 bd.flags &= ~ENET_BD_E;
1096 if (size == 0) {
1097 /* Last buffer in frame. */
1098 bd.flags |= flags | ENET_BD_L;
1099 FEC_PRINTF("rx frame flags %04x\n", bd.flags);
1100 if (bd.option & ENET_BD_RX_INT) {
1101 s->regs[ENET_EIR] |= ENET_INT_RXF;
1102 }
1103 } else {
1104 if (bd.option & ENET_BD_RX_INT) {
1105 s->regs[ENET_EIR] |= ENET_INT_RXB;
1106 }
1107 }
1108 imx_enet_write_bd(&bd, addr);
1109 /* Advance to the next descriptor. */
1110 if ((bd.flags & ENET_BD_W) != 0) {
1111 addr = s->regs[ENET_RDSR];
1112 } else {
1113 addr += sizeof(bd);
1114 }
1115 }
1116 s->rx_descriptor = addr;
1117 imx_eth_enable_rx(s);
1118 imx_eth_update(s);
1119 return len;
1120 }
1121
1122 static ssize_t imx_eth_receive(NetClientState *nc, const uint8_t *buf,
1123 size_t len)
1124 {
1125 IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc));
1126
1127 if (!s->is_fec && (s->regs[ENET_ECR] & ENET_ECR_EN1588)) {
1128 return imx_enet_receive(nc, buf, len);
1129 } else {
1130 return imx_fec_receive(nc, buf, len);
1131 }
1132 }
1133
1134 static const MemoryRegionOps imx_eth_ops = {
1135 .read = imx_eth_read,
1136 .write = imx_eth_write,
1137 .valid.min_access_size = 4,
1138 .valid.max_access_size = 4,
1139 .endianness = DEVICE_NATIVE_ENDIAN,
1140 };
1141
1142 static void imx_eth_cleanup(NetClientState *nc)
1143 {
1144 IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc));
1145
1146 s->nic = NULL;
1147 }
1148
1149 static NetClientInfo imx_eth_net_info = {
1150 .type = NET_CLIENT_OPTIONS_KIND_NIC,
1151 .size = sizeof(NICState),
1152 .can_receive = imx_eth_can_receive,
1153 .receive = imx_eth_receive,
1154 .cleanup = imx_eth_cleanup,
1155 .link_status_changed = imx_eth_set_link,
1156 };
1157
1158
1159 static void imx_eth_realize(DeviceState *dev, Error **errp)
1160 {
1161 IMXFECState *s = IMX_FEC(dev);
1162 SysBusDevice *sbd = SYS_BUS_DEVICE(dev);
1163
1164 memory_region_init_io(&s->iomem, OBJECT(dev), &imx_eth_ops, s,
1165 TYPE_IMX_FEC, 0x400);
1166 sysbus_init_mmio(sbd, &s->iomem);
1167 sysbus_init_irq(sbd, &s->irq[0]);
1168 sysbus_init_irq(sbd, &s->irq[1]);
1169
1170 qemu_macaddr_default_if_unset(&s->conf.macaddr);
1171
1172 s->conf.peers.ncs[0] = nd_table[0].netdev;
1173
1174 s->nic = qemu_new_nic(&imx_eth_net_info, &s->conf,
1175 object_get_typename(OBJECT(dev)),
1176 DEVICE(dev)->id, s);
1177
1178 qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a);
1179 }
1180
1181 static Property imx_eth_properties[] = {
1182 DEFINE_NIC_PROPERTIES(IMXFECState, conf),
1183 DEFINE_PROP_END_OF_LIST(),
1184 };
1185
1186 static void imx_eth_class_init(ObjectClass *klass, void *data)
1187 {
1188 DeviceClass *dc = DEVICE_CLASS(klass);
1189
1190 dc->vmsd = &vmstate_imx_eth;
1191 dc->reset = imx_eth_reset;
1192 dc->props = imx_eth_properties;
1193 dc->realize = imx_eth_realize;
1194 dc->desc = "i.MX FEC/ENET Ethernet Controller";
1195 }
1196
1197 static void imx_fec_init(Object *obj)
1198 {
1199 IMXFECState *s = IMX_FEC(obj);
1200
1201 s->is_fec = true;
1202 }
1203
1204 static void imx_enet_init(Object *obj)
1205 {
1206 IMXFECState *s = IMX_FEC(obj);
1207
1208 s->is_fec = false;
1209 }
1210
1211 static const TypeInfo imx_fec_info = {
1212 .name = TYPE_IMX_FEC,
1213 .parent = TYPE_SYS_BUS_DEVICE,
1214 .instance_size = sizeof(IMXFECState),
1215 .instance_init = imx_fec_init,
1216 .class_init = imx_eth_class_init,
1217 };
1218
1219 static const TypeInfo imx_enet_info = {
1220 .name = TYPE_IMX_ENET,
1221 .parent = TYPE_IMX_FEC,
1222 .instance_init = imx_enet_init,
1223 };
1224
1225 static void imx_eth_register_types(void)
1226 {
1227 type_register_static(&imx_fec_info);
1228 type_register_static(&imx_enet_info);
1229 }
1230
1231 type_init(imx_eth_register_types)
QEMU mirror